diff --git a/.gitattributes b/.gitattributes index 0144b467bee288c8fe1f3e07455b0339054fc0b5..816ff468bbf9899c54176fe88198c927013ae3f6 100644 --- a/.gitattributes +++ b/.gitattributes @@ -82,3 +82,7 @@ models/ggml-vocab-qwen2.gguf filter=lfs diff=lfs merge=lfs -text models/ggml-vocab-qwen35.gguf filter=lfs diff=lfs merge=lfs -text models/ggml-vocab-refact.gguf filter=lfs diff=lfs merge=lfs -text models/ggml-vocab-starcoder.gguf filter=lfs diff=lfs merge=lfs -text +tools/ui/.svelte-kit/output/client/recommended-mcp/huggingface.ico filter=lfs diff=lfs merge=lfs -text +tools/ui/dist/_gzip/_app/immutable/assets/bundle.S65JMH_w.css filter=lfs diff=lfs merge=lfs -text +tools/ui/dist/_gzip/_app/immutable/bundle.Yxmpoeis.js filter=lfs diff=lfs merge=lfs -text +tools/ui/dist/recommended-mcp/huggingface.ico filter=lfs diff=lfs merge=lfs -text diff --git a/tools/server/bench/prometheus.yml b/tools/server/bench/prometheus.yml new file mode 100644 index 0000000000000000000000000000000000000000..b15ee52443fe810b0efac8d1b917437dadc321a6 --- /dev/null +++ b/tools/server/bench/prometheus.yml @@ -0,0 +1,9 @@ +global: + scrape_interval: 10s + external_labels: + llamacpp: 'server' + +scrape_configs: + - job_name: 'llama.cpp server' + static_configs: + - targets: ['localhost:8080'] diff --git a/tools/server/bench/requirements.txt b/tools/server/bench/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..66ed226eda6f0cad0da494cb8bb468471318b5f4 --- /dev/null +++ b/tools/server/bench/requirements.txt @@ -0,0 +1,2 @@ +matplotlib +requests diff --git a/tools/server/bench/script.js b/tools/server/bench/script.js new file mode 100644 index 0000000000000000000000000000000000000000..2772bee5e5f38c33d01c2d61dbd482ab47f0a1f6 --- /dev/null +++ b/tools/server/bench/script.js @@ -0,0 +1,162 @@ +import sse from 'k6/x/sse' +import {check, sleep} from 'k6' +import {SharedArray} from 'k6/data' +import {Counter, Rate, Trend} from 'k6/metrics' +import exec from 'k6/execution'; + +// Server chat completions prefix +const server_url = __ENV.SERVER_BENCH_URL ? __ENV.SERVER_BENCH_URL : 'http://localhost:8080/v1' + +// Number of total prompts in the dataset - default 10m / 10 seconds/request * number of users +const n_prompt = __ENV.SERVER_BENCH_N_PROMPTS ? parseInt(__ENV.SERVER_BENCH_N_PROMPTS) : 600 / 10 * 8 + +// Model name to request +const model = __ENV.SERVER_BENCH_MODEL_ALIAS ? __ENV.SERVER_BENCH_MODEL_ALIAS : 'my-model' + +// Dataset path +const dataset_path = __ENV.SERVER_BENCH_DATASET ? __ENV.SERVER_BENCH_DATASET : './ShareGPT_V3_unfiltered_cleaned_split.json' + +// Max tokens to predict +const max_tokens = __ENV.SERVER_BENCH_MAX_TOKENS ? parseInt(__ENV.SERVER_BENCH_MAX_TOKENS) : 512 + +// Max prompt tokens +const n_prompt_tokens = __ENV.SERVER_BENCH_MAX_PROMPT_TOKENS ? parseInt(__ENV.SERVER_BENCH_MAX_PROMPT_TOKENS) : 1024 + +// Max slot context +const n_ctx_slot = __ENV.SERVER_BENCH_MAX_CONTEXT ? parseInt(__ENV.SERVER_BENCH_MAX_CONTEXT) : 2048 + +export function setup() { + console.info(`Benchmark config: server_url=${server_url} n_prompt=${n_prompt} model=${model} dataset_path=${dataset_path} max_tokens=${max_tokens}`) +} + +const data = new SharedArray('conversations', function () { + const tokenizer = (message) => message.split(/[\s,'".?]/) + + return JSON.parse(open(dataset_path)) + // Filter out the conversations with less than 2 turns. + .filter(data => data["conversations"].length >= 2) + .filter(data => data["conversations"][0]["from"] === "human") + .map(data => { + return { + prompt: data["conversations"][0]["value"], + n_prompt_tokens: tokenizer(data["conversations"][0]["value"]).length, + n_completion_tokens: tokenizer(data["conversations"][1]["value"]).length, + } + }) + // Filter out too short sequences + .filter(conv => conv.n_prompt_tokens >= 4 && conv.n_completion_tokens >= 4) + // Filter out too long sequences. + .filter(conv => conv.n_prompt_tokens <= n_prompt_tokens && conv.n_prompt_tokens + conv.n_completion_tokens <= n_ctx_slot) + // Keep only first n prompts + .slice(0, n_prompt) +}) + +const llamacpp_prompt_tokens = new Trend('llamacpp_prompt_tokens') +const llamacpp_completion_tokens = new Trend('llamacpp_completion_tokens') + +const llamacpp_tokens_second = new Trend('llamacpp_tokens_second') +const llamacpp_prompt_processing_second = new Trend('llamacpp_prompt_processing_second') +const llamacpp_emit_first_token_second = new Trend('llamacpp_emit_first_token_second') + +const llamacpp_prompt_tokens_total_counter = new Counter('llamacpp_prompt_tokens_total_counter') +const llamacpp_completion_tokens_total_counter = new Counter('llamacpp_completion_tokens_total_counter') + +const llamacpp_completions_truncated_rate = new Rate('llamacpp_completions_truncated_rate') +const llamacpp_completions_stop_rate = new Rate('llamacpp_completions_stop_rate') + +export const options = { + thresholds: { + llamacpp_completions_truncated_rate: [ + // more than 80% of truncated input will abort the test + {threshold: 'rate < 0.8', abortOnFail: true, delayAbortEval: '1m'}, + ], + }, + duration: '10m', + vus: 8, +} + +export default function () { + const conversation = data[exec.scenario.iterationInInstance % data.length] + const payload = { + "messages": [ + { + "role": "system", + "content": "You are ChatGPT, an AI assistant.", + }, + { + "role": "user", + "content": conversation.prompt, + } + ], + "model": model, + "stream": true, + "stream_options": { + "include_usage": true, // False to be supported in llama.cpp server + }, + "seed": 42, + "max_tokens": max_tokens, + "stop": ["<|im_end|>"] // This is temporary for phi-2 base (i.e. not instructed) since the server expects that the model always to emit BOS + } + + const params = {method: 'POST', body: JSON.stringify(payload)}; + + const startTime = new Date() + let promptEvalEndTime = null + let prompt_tokens = 0 + let completions_tokens = 0 + let finish_reason = null + const res = sse.open(`${server_url}/chat/completions`, params, function (client) { + client.on('event', function (event) { + if (promptEvalEndTime == null) { + promptEvalEndTime = new Date() + llamacpp_emit_first_token_second.add((promptEvalEndTime - startTime) / 1.e3) + } + + if (event.data === '[DONE]' || event.data === '') { + return + } + + let chunk = JSON.parse(event.data) + + if (chunk.choices && chunk.choices.length > 0) { + let choice = chunk.choices[0] + if (choice.finish_reason) { + finish_reason = choice.finish_reason + } + } + + if (chunk.usage) { + prompt_tokens = chunk.usage.prompt_tokens + llamacpp_prompt_tokens.add(prompt_tokens) + llamacpp_prompt_tokens_total_counter.add(prompt_tokens) + + completions_tokens = chunk.usage.completion_tokens + llamacpp_completion_tokens.add(completions_tokens) + llamacpp_completion_tokens_total_counter.add(completions_tokens) + } + }) + + client.on('error', function (e) { + console.log('An unexpected error occurred: ', e.error()); + throw e; + }) + }) + + check(res, {'success completion': (r) => r.status === 200}) + + const endTime = new Date() + + const promptEvalTime = promptEvalEndTime - startTime + if (promptEvalTime > 0) { + llamacpp_prompt_processing_second.add(prompt_tokens / (promptEvalEndTime - startTime) * 1.e3) + } + + const completion_time = endTime - promptEvalEndTime + if (completions_tokens > 0 && completion_time > 0) { + llamacpp_tokens_second.add(completions_tokens / completion_time * 1.e3) + } + llamacpp_completions_truncated_rate.add(finish_reason === 'length') + llamacpp_completions_stop_rate.add(finish_reason === 'stop') + + sleep(0.3) +} diff --git a/tools/server/bench/speed-bench/README.md b/tools/server/bench/speed-bench/README.md new file mode 100644 index 0000000000000000000000000000000000000000..8d3fcd804c48ac3fbd935644e73e115cd7908309 --- /dev/null +++ b/tools/server/bench/speed-bench/README.md @@ -0,0 +1,117 @@ +# SPEED-Bench server benchmark + +A lightweight [SPEED-Bench](https://huggingface.co/datasets/nvidia/SPEED-Bench) client for benchmarking an already-running `llama-server` through its OpenAI-compatible API. It is primarily meant to evaluate speculative decoding (draft model, n-gram, MTP, EAGLE3, ...) by reporting per-category throughput, latency, and draft acceptance. + +The dataset handling follows the [aiperf SPEED-Bench tutorial](https://github.com/ai-dynamo/aiperf/blob/main/docs/tutorials/speed-bench.md), which also documents the dataset layout in more detail. + +## Install + +```bash +pip install -r tools/server/bench/speed-bench/requirements.txt +``` + +## Start a server + +The client does not launch the server, so start `llama-server` yourself first. If you care about throughput numbers, set the client `--concurrency` to the server's slot count (`--np`): + +```bash +llama-server \ + -m target.gguf \ + -c 8192 \ + --port 8080 \ + -ngl 99 -fa on \ + --np 1 \ + --jinja +``` + +For speculative decoding, start the server with the appropriate flags for your setup (e.g. a draft model with `-md`, or `--spec-type ngram-mod`). See the [speculative decoding doc](../../../../docs/speculative.md) for details. + +## Run + +```bash +python tools/server/bench/speed-bench/speed_bench.py \ + --url localhost:8080 \ + --bench qualitative \ + --category coding \ + --osl 1024 \ + --concurrency 1 +``` + +## Options + +| Option | Default | Description | +| --- | --- | --- | +| `--url` | `localhost:8080` | Server URL. The scheme and `/v1` are optional and a trailing slash is fine, so `localhost:8080` and `http://localhost:8080/v1/` both work. | +| `--model` | none | Optional `model` field sent in each request. | +| `--bench` | `qualitative` | SPEED-Bench config, e.g. `qualitative`, `throughput_1k`. See [available dataset variants](https://github.com/ai-dynamo/aiperf/blob/main/docs/tutorials/speed-bench.md#available-dataset-variants). | +| `--category` | `all` | Category filter within the bench; comma-separated list or `all`. For `qualitative` the categories are `coding`, `humanities`, `math`, `multilingual`, `qa`, `rag`, `reasoning`, `roleplay`, `stem`, `summarization`, `writing`. For the `throughput_{ISL}` splits they are `high_entropy`, `low_entropy`, `mixed`. | +| `--osl` | `1024` | Output sequence length, mapped to `max_tokens`. | +| `--extra-inputs` | `{"temperature":0}` | Extra request fields as a JSON object. | +| `--concurrency` | `1` | Concurrent client requests; usually match `--np`. | +| `--limit` | none | Max samples per category (handy for smoke tests). | +| `--timeout` | `600` | Per-request timeout in seconds. | +| `--output` | none | Save raw per-request results and the summary to JSON. | + +A few common ones: + +- `--category all` runs every category in the bench. +- `--category coding,math` runs just those two. +- `--bench throughput_8k` runs a fixed-input-length throughput split. +- `--limit 8` keeps at most 8 samples per category, which is enough for a quick check. + +The `throughput_{ISL}` splits use fixed input lengths (1k - 32k), so they are handy for long-context testing and for comparing different `llama-server` batching settings (e.g. sweeping `-ub` / `--ubatch-size`) on prompts of a known size. Make sure the server `-c` is large enough for the chosen split. When raising `-ub`, also raise `-b` to at least the same value, since the physical ubatch cannot exceed the logical batch. + +When `--output` is given, the JSON file holds the run `config`, the `selected_samples` / `completed_samples` / `failed_samples` counts, the per-category `summary` rows, and the per-sample `results`. + +## Metrics + +The summary prints one row per category plus an `overall` row: + +- `samples` - how many samples finished successfully. +- `avg_prompt_t/s` - prefill throughput from llama.cpp (`timings.prompt_per_second`), averaged over the category's samples. +- `avg_pred_t/s` - decode throughput from llama.cpp (`timings.predicted_per_second`), averaged over the category's samples. +- `avg_latency` - average end-to-end request latency seen by the client. +- `accept_rate` - `accepted / draft_n` over the category, or `n/a` if nothing was drafted (`draft_n == 0`). + +## Baseline vs speculative decoding + +Save a run from each server with `--output`, then diff the two JSON files with `speed_bench_compare.py`. + +First, start a plain `llama-server` (no speculative decoding) and save a baseline: + +```bash +python tools/server/bench/speed-bench/speed_bench.py \ + --url localhost:8080 \ + --bench qualitative \ + --category all \ + --osl 1024 \ + --concurrency 1 \ + --output baseline.json +``` + +Then restart `llama-server` with speculative decoding enabled and save another run: + +```bash +python tools/server/bench/speed-bench/speed_bench.py \ + --url localhost:8080 \ + --bench qualitative \ + --category all \ + --osl 1024 \ + --concurrency 1 \ + --output spec.json +``` + +Finally compare the two: + +```bash +python tools/server/bench/speed-bench/speed_bench_compare.py \ + --baseline baseline.json \ + --speculative spec.json +``` + +The comparison table adds: + +- `decode_speedup = spec_avg_pred_t/s / base_avg_pred_t/s` +- `latency_speedup = base_avg_latency / spec_avg_latency` + +Keep `--bench`, `--category`, `--osl`, and `--limit` the same across both runs, otherwise they won't be using the same prompts. diff --git a/tools/server/bench/speed-bench/requirements.txt b/tools/server/bench/speed-bench/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..a524c2f51932f069b7bd4b8b258a7d1574965faa --- /dev/null +++ b/tools/server/bench/speed-bench/requirements.txt @@ -0,0 +1,3 @@ +datasets +requests +tqdm diff --git a/tools/server/bench/speed-bench/speed_bench.py b/tools/server/bench/speed-bench/speed_bench.py new file mode 100644 index 0000000000000000000000000000000000000000..adb378a6bf0994bde657de80104b268e98ea3e0e --- /dev/null +++ b/tools/server/bench/speed-bench/speed_bench.py @@ -0,0 +1,432 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import concurrent.futures +import json +import statistics +import sys +import time +from dataclasses import asdict, dataclass +from typing import Any +from urllib.parse import urlparse + +import requests +from datasets import get_dataset_config_names, load_dataset +from tqdm import tqdm + + +DATASET_REPO = "nvidia/SPEED-Bench" + +@dataclass +class Sample: + id: str + category: str + turns: list[str] + + +@dataclass +class RequestResult: + id: str + category: str + ok: bool + turns: int + latency_s: float + prompt_tokens: int + completion_tokens: int + total_tokens: int + finish_reason: str | None + draft_n: int + draft_n_accepted: int + prompt_ms: float | None + predicted_ms: float | None + prompt_per_second: float | None + predicted_per_second: float | None + error: str | None + + +def normalize_base_url(url: str) -> str: + url = url.strip().rstrip("/") + if not url: + raise ValueError("--url cannot be empty") + if "://" not in url: + url = "http://" + url + parsed = urlparse(url) + if not parsed.scheme or not parsed.netloc: + raise ValueError(f"invalid --url: {url}") + if not parsed.path.rstrip("/").endswith("/v1"): + url = url + "/v1" + return url.rstrip("/") + + +def parse_extra_inputs(value: str) -> dict[str, Any]: + extra = json.loads(value) + if not isinstance(extra, dict): + raise ValueError("--extra-inputs must be a JSON object") + return extra + + +def extract_turns(row: dict[str, Any]) -> list[str]: + turns = row.get("turns") + if isinstance(turns, list) and turns: + clean_turns = [str(turn).strip() for turn in turns if turn and str(turn).strip()] + if clean_turns: + return clean_turns + raise ValueError("missing or empty turns") + + +def load_samples(args: argparse.Namespace) -> list[Sample]: + bench_names = get_dataset_config_names(DATASET_REPO) + if args.bench not in bench_names: + raise ValueError( + f"unknown --bench {args.bench!r}; available benches: {', '.join(bench_names)}" + ) + + dataset = load_dataset(DATASET_REPO, name=args.bench, split="test") + categories = list(dict.fromkeys(str(category) for category in dataset["category"])) + requested_categories = None + if args.category != "all": + requested_list = [category.strip() for category in args.category.split(",") if category.strip()] + if not requested_list: + raise ValueError( + f"--category must be 'all' or a comma-separated list; available categories: {', '.join(categories)}" + ) + requested_categories = set(requested_list) + unknown_categories = [category for category in requested_list if category not in categories] + if unknown_categories: + unknown = ", ".join(unknown_categories) + raise ValueError( + f"unknown --category {unknown!r} for bench {args.bench!r}; " + f"available categories: all, {', '.join(categories)}" + ) + + samples: list[Sample] = [] + samples_per_category: dict[str, int] = {} + skipped = 0 + for index, row_raw in enumerate(dataset): + row = dict(row_raw) + category_raw = row.get("category") + if not isinstance(category_raw, str) or not category_raw.strip(): + skipped += 1 + continue + category = category_raw.strip() + if requested_categories is not None and category not in requested_categories: + continue + if args.limit is not None and samples_per_category.get(category, 0) >= args.limit: + continue + + try: + turns = extract_turns(row) + except ValueError: + skipped += 1 + continue + question_id = row.get("question_id") + if not isinstance(question_id, str) or not question_id.strip(): + skipped += 1 + continue + sample_id = question_id.strip() + samples.append(Sample(id=sample_id, category=category, turns=turns)) + samples_per_category[category] = samples_per_category.get(category, 0) + 1 + + if not samples: + raise RuntimeError(f"no samples selected from bench={args.bench} category={args.category}") + + if skipped: + print(f"speed_bench: skipped {skipped} rows without usable turns") + return samples + + +def parse_completion_response(data: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any], str | None, str]: + usage = data.get("usage") or {} + timings = data.get("timings") or {} + finish_reason = None + content = "" + choices = data.get("choices") + if isinstance(choices, list) and choices and isinstance(choices[0], dict): + choice = choices[0] + finish_reason = choice.get("finish_reason") + message = choice.get("message") + if isinstance(message, dict) and isinstance(message.get("content"), str): + content = message["content"] + elif isinstance(choice.get("text"), str): + content = choice["text"] + return usage, timings, finish_reason, content + + +def run_request( + endpoint: str, + model: str | None, + messages: list[dict[str, str]], + osl: int, + extra_inputs: dict[str, Any], + timeout: float, +) -> tuple[dict[str, Any], float]: + payload: dict[str, Any] = { + "messages": messages, + "max_tokens": osl, + "stream": False, + } + if model: + payload["model"] = model + payload.update(extra_inputs) + payload["max_tokens"] = osl + + start = time.perf_counter() + response = requests.post(endpoint, json=payload, timeout=timeout) + latency_s = time.perf_counter() - start + if response.status_code != 200: + body = response.text[:500].replace("\n", "\\n") + raise RuntimeError(f"HTTP {response.status_code}: {body}") + return response.json(), latency_s + + +def run_one( + sample: Sample, + endpoint: str, + model: str | None, + osl: int, + extra_inputs: dict[str, Any], + timeout: float, +) -> RequestResult: + selected_turns = sample.turns + messages: list[dict[str, str]] = [] + total_latency_s = 0.0 + prompt_tokens = 0 + completion_tokens = 0 + total_tokens = 0 + draft_n = 0 + draft_n_accepted = 0 + prompt_ms = 0.0 + predicted_ms = 0.0 + prompt_per_second = None + predicted_per_second = None + finish_reason: str | None = None + try: + for turn in selected_turns: + messages.append({"role": "user", "content": turn}) + data, latency_s = run_request(endpoint, model, messages, osl, extra_inputs, timeout) + total_latency_s += latency_s + usage, timings, finish_reason, assistant_text = parse_completion_response(data) + + turn_prompt_tokens = int(usage.get("prompt_tokens") or timings.get("prompt_n") or 0) + turn_completion_tokens_count = int(usage.get("completion_tokens") or timings.get("predicted_n") or 0) + turn_total_tokens_count = int(usage.get("total_tokens") or (turn_prompt_tokens + turn_completion_tokens_count)) + prompt_tokens += turn_prompt_tokens + completion_tokens += turn_completion_tokens_count + total_tokens += turn_total_tokens_count + draft_n += int(timings.get("draft_n") or 0) + draft_n_accepted += int(timings.get("draft_n_accepted") or 0) + prompt_ms += float(timings.get("prompt_ms") or 0) + predicted_ms += float(timings.get("predicted_ms") or 0) + if len(selected_turns) == 1 and isinstance(timings.get("prompt_per_second"), (int, float)): + prompt_per_second = float(timings["prompt_per_second"]) + if len(selected_turns) == 1 and isinstance(timings.get("predicted_per_second"), (int, float)): + predicted_per_second = float(timings["predicted_per_second"]) + + messages.append({"role": "assistant", "content": assistant_text}) + + if total_tokens == 0: + total_tokens = prompt_tokens + completion_tokens + if len(selected_turns) > 1: + prompt_per_second = (prompt_tokens / (prompt_ms / 1000)) if prompt_ms > 0 else None + predicted_per_second = (completion_tokens / (predicted_ms / 1000)) if predicted_ms > 0 else None + + return RequestResult( + id=sample.id, + category=sample.category, + ok=True, + turns=len(selected_turns), + latency_s=total_latency_s, + prompt_tokens=prompt_tokens, + completion_tokens=completion_tokens, + total_tokens=total_tokens, + finish_reason=finish_reason, + draft_n=draft_n, + draft_n_accepted=draft_n_accepted, + prompt_ms=prompt_ms if prompt_ms > 0 else None, + predicted_ms=predicted_ms if predicted_ms > 0 else None, + prompt_per_second=prompt_per_second, + predicted_per_second=predicted_per_second, + error=None, + ) + except Exception as exc: + return RequestResult( + id=sample.id, + category=sample.category, + ok=False, + turns=len(selected_turns), + latency_s=total_latency_s, + prompt_tokens=0, + completion_tokens=0, + total_tokens=0, + finish_reason=None, + draft_n=0, + draft_n_accepted=0, + prompt_ms=None, + predicted_ms=None, + prompt_per_second=None, + predicted_per_second=None, + error=str(exc), + ) + + +def summarize_group(category: str, results: list[RequestResult]) -> dict[str, Any]: + ok_results = [result for result in results if result.ok] + latencies = [result.latency_s for result in ok_results] + server_prompt_speeds = [ + result.prompt_per_second + for result in ok_results + if result.prompt_per_second is not None + ] + server_completion_speeds = [ + result.predicted_per_second + for result in ok_results + if result.predicted_per_second is not None + ] + turns = sum(result.turns for result in ok_results) + draft_n = sum(result.draft_n for result in ok_results) + accepted = sum(result.draft_n_accepted for result in ok_results) + + return { + "category": category, + "requests": len(ok_results), + "turns": turns, + "failed": len(results) - len(ok_results), + "avg_prompt_t_s": statistics.mean(server_prompt_speeds) if server_prompt_speeds else None, + "avg_pred_t_s": statistics.mean(server_completion_speeds) if server_completion_speeds else None, + "avg_latency": statistics.mean(latencies) if latencies else None, + "draft_n": draft_n, + "accepted": accepted, + "accept_rate": (accepted / draft_n) if draft_n > 0 else None, + } + + +def fmt_value(value: Any, kind: str = "") -> str: + if value is None: + return "n/a" + if kind == "int": + return str(int(value)) + if kind == "rate": + return f"{float(value):.4f}" + if kind == "seconds": + return f"{float(value):.3f}s" + if kind == "speed": + return f"{float(value):.2f}" + if kind == "speedup": + return f"{float(value):.2f}x" + return str(value) + + +def print_table(rows: list[dict[str, Any]]) -> None: + columns = [ + ("category", "category", ""), + ("samples", "requests", "int"), + ("avg_prompt_t/s", "avg_prompt_t_s", "speed"), + ("avg_pred_t/s", "avg_pred_t_s", "speed"), + ("avg_latency", "avg_latency", "seconds"), + ("accept_rate", "accept_rate", "rate"), + ] + print_rows(rows, columns) + + +def print_rows(rows: list[dict[str, Any]], columns: list[tuple[str, str, str]]) -> None: + rendered_rows = [] + for row in rows: + rendered_rows.append([fmt_value(row.get(key), kind) for _, key, kind in columns]) + + widths = [len(header) for header, _, _ in columns] + for rendered in rendered_rows: + for i, cell in enumerate(rendered): + widths[i] = max(widths[i], len(cell)) + + header = " ".join(header.ljust(widths[i]) for i, (header, _, _) in enumerate(columns)) + print(header) + print(" ".join("-" * width for width in widths)) + for rendered in rendered_rows: + print(" ".join(cell.ljust(widths[i]) for i, cell in enumerate(rendered))) + + +def save_output(path: str, args: argparse.Namespace, samples: list[Sample], results: list[RequestResult], summary: list[dict[str, Any]]) -> None: + payload = { + "config": { + "url": args.url, + "model": args.model, + "bench": args.bench, + "category": args.category, + "osl": args.osl, + "concurrency": args.concurrency, + "extra_inputs": args.extra_inputs, + }, + "selected_samples": len(samples), + "completed_samples": sum(1 for result in results if result.ok), + "failed_samples": sum(1 for result in results if not result.ok), + "summary": summary, + "results": [asdict(result) for result in results], + } + with open(path, "w", encoding="utf-8") as f: + json.dump(payload, f, indent=2, sort_keys=True) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description="Run SPEED-Bench against an OpenAI-compatible llama-server.") + parser.add_argument("--url", default="localhost:8080", help="Server URL, for example localhost:8080 or http://localhost:8080/v1") + parser.add_argument("--model", default=None, help="Optional model name to send in OpenAI requests") + parser.add_argument("--bench", default="qualitative", help="SPEED-Bench config to run, for example qualitative or throughput_1k") + parser.add_argument("--category", default="all", help="Category to run within the selected bench; use all for no category filter") + parser.add_argument("--osl", type=int, default=4096, help="Output sequence length, mapped to max_tokens") + parser.add_argument("--extra-inputs", default='{"temperature":0}', help="Extra request fields as a JSON object") + parser.add_argument("--concurrency", type=int, default=1, help="Concurrent client requests; usually match llama-server --np") + parser.add_argument("--limit", type=int, default=None, help="Optional sample limit per category for smoke tests") + parser.add_argument("--timeout", type=float, default=600, help="Per-request timeout in seconds") + parser.add_argument("--output", default=None, help="Optional path to save raw results JSON") + args = parser.parse_args(argv) + try: + base_url = normalize_base_url(args.url) + endpoint = base_url + "/chat/completions" + extra_inputs = parse_extra_inputs(args.extra_inputs) + args.extra_inputs = extra_inputs + samples = load_samples(args) + except Exception as exc: + print(f"speed_bench: setup failed: {exc}", file=sys.stderr) + return 2 + + print(f"speed_bench: loaded {len(samples)} samples from bench={args.bench} category={args.category}") + + results: list[RequestResult] = [] + started = time.perf_counter() + with concurrent.futures.ThreadPoolExecutor(max_workers=args.concurrency) as executor: + futures = [ + executor.submit(run_one, sample, endpoint, args.model, args.osl, extra_inputs, args.timeout) + for sample in samples + ] + for future in tqdm(concurrent.futures.as_completed(futures), total=len(futures), desc="speed_bench", unit="sample"): + result = future.result() + results.append(result) + + elapsed = time.perf_counter() - started + categories = list(dict.fromkeys(sample.category for sample in samples)) + summary = [ + summarize_group(category, [result for result in results if result.category == category]) + for category in categories + ] + summary.append(summarize_group("overall", results)) + print() + print(f"Summary (elapsed={elapsed:.2f}s)") + print_table(summary) + + if args.output: + save_output(args.output, args, samples, results, summary) + print(f"\nspeed_bench: wrote {args.output}") + + failed = sum(1 for result in results if not result.ok) + if failed: + print(f"\nspeed_bench: {failed} samples failed", file=sys.stderr) + first_error = next((result.error for result in results if result.error), None) + if first_error: + print(f"first error: {first_error}", file=sys.stderr) + return 1 + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/server/bench/speed-bench/speed_bench_compare.py b/tools/server/bench/speed-bench/speed_bench_compare.py new file mode 100644 index 0000000000000000000000000000000000000000..070ab57db5d35fdc21ded746ca9b67ee86547d8d --- /dev/null +++ b/tools/server/bench/speed-bench/speed_bench_compare.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 +from __future__ import annotations + +import argparse +import json +import sys +from typing import Any + +from speed_bench import fmt_value, print_rows + + +def load_summary(path: str) -> list[dict[str, Any]]: + with open(path, "r", encoding="utf-8") as f: + data = json.load(f) + summary = data.get("summary") + if not isinstance(summary, list): + raise ValueError(f"{path} does not contain a summary list") + return summary + + +def compare_rows(baseline: list[dict[str, Any]], speculative: list[dict[str, Any]]) -> list[dict[str, Any]]: + baseline_by_category = {row["category"]: row for row in baseline} + comparisons = [] + for row in speculative: + base = baseline_by_category.get(row["category"]) + if not base: + continue + base_speed = base.get("avg_pred_t_s") + spec_speed = row.get("avg_pred_t_s") + base_latency = base.get("avg_latency") + spec_latency = row.get("avg_latency") + comparisons.append( + { + "category": row["category"], + "base_avg_pred_t_s": base_speed, + "spec_avg_pred_t_s": spec_speed, + "decode_speedup": (spec_speed / base_speed) if base_speed and spec_speed else None, + "base_avg_latency": base_latency, + "spec_avg_latency": spec_latency, + "latency_speedup": (base_latency / spec_latency) if base_latency and spec_latency else None, + "accept_rate": row.get("accept_rate"), + } + ) + return comparisons + + +def print_comparison(rows: list[dict[str, Any]]) -> None: + if not rows: + print("No overlapping categories found for comparison.") + return + columns = [ + ("category", "category", ""), + ("base_avg_pred_t/s", "base_avg_pred_t_s", "speed"), + ("spec_avg_pred_t/s", "spec_avg_pred_t_s", "speed"), + ("decode_speedup", "decode_speedup", "speedup"), + ("base_avg_latency", "base_avg_latency", "seconds"), + ("spec_avg_latency", "spec_avg_latency", "seconds"), + ("latency_speedup", "latency_speedup", "speedup"), + ("accept_rate", "accept_rate", "rate"), + ] + print_rows(rows, columns) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description="Compare two SPEED-Bench runs (baseline vs speculative).") + parser.add_argument("--baseline", required=True, help="Baseline results JSON produced by speed_bench.py --output") + parser.add_argument("--speculative", required=True, help="Speculative decoding results JSON produced by speed_bench.py --output") + args = parser.parse_args(argv) + + try: + baseline = load_summary(args.baseline) + speculative = load_summary(args.speculative) + except Exception as exc: + print(f"speed_bench_compare: failed to load inputs: {exc}", file=sys.stderr) + return 2 + + comparisons = compare_rows(baseline, speculative) + print(f"Comparison: baseline={args.baseline} speculative={args.speculative}") + print_comparison(comparisons) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tools/server/main.cpp b/tools/server/main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7f17c56a8c2989ba4071a50aa7828cfdcb50a08b --- /dev/null +++ b/tools/server/main.cpp @@ -0,0 +1,5 @@ +int llama_server(int argc, char ** argv); + +int main(int argc, char ** argv) { + return llama_server(argc, argv); +} diff --git a/tools/server/server-chat.cpp b/tools/server/server-chat.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0322e54ccea8006070c4c6b585faf3ff0094ec84 --- /dev/null +++ b/tools/server/server-chat.cpp @@ -0,0 +1,692 @@ +#include "server-chat.h" +#include "server-common.h" + +#include + +json server_chat_convert_responses_to_chatcmpl(const json & response_body) { + if (!response_body.contains("input")) { + throw std::invalid_argument("'input' is required"); + } + if (!json_value(response_body, "previous_response_id", std::string{}).empty()) { + throw std::invalid_argument("llama.cpp does not support 'previous_response_id'."); + } + + const json input_value = response_body.at("input"); + json chatcmpl_body = response_body; + chatcmpl_body.erase("input"); + std::vector chatcmpl_messages; + + if (response_body.contains("instructions")) { + chatcmpl_messages.push_back({ + {"role", "system"}, + {"content", json_value(response_body, "instructions", std::string())}, + }); + chatcmpl_body.erase("instructions"); + } + + if (input_value.is_string()) { + // #responses_create-input-text_input + chatcmpl_messages.push_back({ + {"role", "user"}, + {"content", input_value}, + }); + } else if (input_value.is_array()) { + // #responses_create-input-input_item_list + + static auto exists_and_is_array = [](const json & j, const char * key) -> bool { + return j.contains(key) && j.at(key).is_array(); + }; + static auto exists_and_is_string = [](const json & j, const char * key) -> bool { + return j.contains(key) && j.at(key).is_string(); + }; + + for (json item : input_value) { + bool merge_prev = !chatcmpl_messages.empty() && chatcmpl_messages.back().value("role", "") == "assistant"; + + if (exists_and_is_string(item, "content")) { + // #responses_create-input-input_item_list-input_message-content-text_input + // Only "Input message" contains item["content"]::string + // After converting item["content"]::string to item["content"]::array, + // we can treat "Input message" as sum of "Item-Input message" and "Item-Output message" + item["content"] = json::array({ + json { + {"text", item.at("content")}, + {"type", "input_text"} + } + }); + } + + if (exists_and_is_array(item, "content") && + exists_and_is_string(item, "role") && + (item.at("role") == "user" || + item.at("role") == "system" || + item.at("role") == "developer") + ) { + // #responses_create-input-input_item_list-item-input_message + std::vector chatcmpl_content; + + for (const json & input_item : item.at("content")) { + const std::string type = json_value(input_item, "type", std::string()); + + if (type == "input_text") { + if (!input_item.contains("text")) { + throw std::invalid_argument("'Input text' requires 'text'"); + } + chatcmpl_content.push_back({ + {"text", input_item.at("text")}, + {"type", "text"}, + }); + } else if (type == "input_image") { + // While `detail` is marked as required, + // it has default value("auto") and can be omitted. + + if (!input_item.contains("image_url")) { + throw std::invalid_argument("'image_url' is required"); + } + chatcmpl_content.push_back({ + {"image_url", json { + {"url", input_item.at("image_url")} + }}, + {"type", "image_url"}, + }); + } else if (type == "input_file") { + throw std::invalid_argument("'input_file' is not supported by llamacpp at this moment"); + } else { + throw std::invalid_argument("'type' must be one of 'input_text', 'input_image', or 'input_file'"); + } + } + + if (item.contains("type")) { + item.erase("type"); + } + if (item.contains("status")) { + item.erase("status"); + } + item["content"] = chatcmpl_content; + + chatcmpl_messages.push_back(item); + } else if (exists_and_is_string(item, "role") && + item.at("role") == "assistant" && + exists_and_is_string(item, "type") && + item.at("type") == "message" + ) { + // #responses_create-input-input_item_list-item-output_message + auto chatcmpl_content = json::array(); + + // Handle both string content and array content + if (item.contains("content") && item.at("content").is_string()) { + // String content - convert to text content part + chatcmpl_content.push_back({ + {"text", item.at("content")}, + {"type", "text"}, + }); + } else if (exists_and_is_array(item, "content")) { + // Array content - process each item + for (const auto & output_text : item.at("content")) { + const std::string type = json_value(output_text, "type", std::string()); + if (type == "output_text" || type == "input_text") { + // Accept both output_text and input_text (string content gets converted to input_text) + if (!exists_and_is_string(output_text, "text")) { + throw std::invalid_argument("'Output text' requires 'text'"); + } + chatcmpl_content.push_back({ + {"text", output_text.at("text")}, + {"type", "text"}, + }); + } else if (type == "refusal") { + if (!exists_and_is_string(output_text, "refusal")) { + throw std::invalid_argument("'Refusal' requires 'refusal'"); + } + chatcmpl_content.push_back({ + {"refusal", output_text.at("refusal")}, + {"type", "refusal"}, + }); + } else { + throw std::invalid_argument("'type' must be one of 'output_text' or 'refusal'"); + } + } + } + + if (merge_prev) { + auto & prev_msg = chatcmpl_messages.back(); + if (!exists_and_is_array(prev_msg, "content")) { + prev_msg["content"] = json::array(); + } + auto & prev_content = prev_msg["content"]; + prev_content.insert(prev_content.end(), chatcmpl_content.begin(), chatcmpl_content.end()); + } else { + item.erase("status"); + item.erase("type"); + item["content"] = chatcmpl_content; + chatcmpl_messages.push_back(item); + } + } else if (exists_and_is_string(item, "arguments") && + exists_and_is_string(item, "call_id") && + exists_and_is_string(item, "name") && + exists_and_is_string(item, "type") && + item.at("type") == "function_call" + ) { + // #responses_create-input-input_item_list-item-function_tool_call + json tool_call = { + {"function", json { + {"arguments", item.at("arguments")}, + {"name", item.at("name")}, + }}, + {"id", item.at("call_id")}, + {"type", "function"}, + }; + + if (merge_prev) { + auto & prev_msg = chatcmpl_messages.back(); + if (!exists_and_is_array(prev_msg, "tool_calls")) { + prev_msg["tool_calls"] = json::array(); + } + prev_msg["tool_calls"].push_back(tool_call); + } else { + chatcmpl_messages.push_back(json { + {"role", "assistant"}, + {"tool_calls", json::array({tool_call})} + }); + } + } else if (exists_and_is_string(item, "call_id") && + (exists_and_is_string(item, "output") || exists_and_is_array(item, "output")) && + exists_and_is_string(item, "type") && + item.at("type") == "function_call_output" + ) { + // #responses_create-input-input_item_list-item-function_tool_call_output + if (item.at("output").is_string()) { + chatcmpl_messages.push_back(json { + {"content", item.at("output")}, + {"role", "tool"}, + {"tool_call_id", item.at("call_id")}, + }); + } else { + json chatcmpl_outputs = item.at("output"); + for (json & chatcmpl_output : chatcmpl_outputs) { + if (!chatcmpl_output.contains("type") || chatcmpl_output.at("type") != "input_text") { + throw std::invalid_argument("Output of tool call should be 'Input text'"); + } + chatcmpl_output["type"] = "text"; + } + chatcmpl_messages.push_back(json { + {"content", chatcmpl_outputs}, + {"role", "tool"}, + {"tool_call_id", item.at("call_id")}, + }); + } + } else if (exists_and_is_array(item, "summary") && + exists_and_is_string(item, "type") && + item.at("type") == "reasoning") { + // #responses_create-input-input_item_list-item-reasoning + + if (!exists_and_is_array(item, "content")) { + throw std::invalid_argument("item['content'] is not an array"); + } + if (item.at("content").empty()) { + throw std::invalid_argument("item['content'] is empty"); + } + if (!exists_and_is_string(item.at("content")[0], "text")) { + throw std::invalid_argument("item['content']['text'] is not a string"); + } + + if (merge_prev) { + auto & prev_msg = chatcmpl_messages.back(); + prev_msg["reasoning_content"] = item.at("content")[0].at("text"); + } else { + chatcmpl_messages.push_back(json { + {"role", "assistant"}, + {"content", json::array()}, + {"reasoning_content", item.at("content")[0].at("text")}, + }); + } + } else { + throw std::invalid_argument("Cannot determine type of 'item'"); + } + } + } else { + throw std::invalid_argument("'input' must be a string or array of objects"); + } + + chatcmpl_body["messages"] = chatcmpl_messages; + + if (response_body.contains("tools")) { + if (!response_body.at("tools").is_array()) { + throw std::invalid_argument("'tools' must be an array of objects"); + } + std::vector chatcmpl_tools; + for (json resp_tool : response_body.at("tools")) { + json chatcmpl_tool; + + const std::string type = json_value(resp_tool, "type", std::string()); + if (type != "function") { + // Non-function Responses tools have no Chat Completions equivalent. + SRV_WRN("unsupported Responses tool type '%s' skipped\n", type.c_str()); + continue; + } + resp_tool.erase("type"); + chatcmpl_tool["type"] = "function"; + + if (!resp_tool.contains("strict")) { + resp_tool["strict"] = true; + } + chatcmpl_tool["function"] = resp_tool; + chatcmpl_tools.push_back(chatcmpl_tool); + } + chatcmpl_body.erase("tools"); + if (!chatcmpl_tools.empty()) { + chatcmpl_body["tools"] = chatcmpl_tools; + } + } + + if (response_body.contains("max_output_tokens")) { + chatcmpl_body.erase("max_output_tokens"); + chatcmpl_body["max_tokens"] = response_body["max_output_tokens"]; + } + + if (response_body.contains("reasoning")) { + // Only "effort" is handled so far + const json & reasoning = response_body.at("reasoning"); + if (reasoning.contains("effort")) { + chatcmpl_body["reasoning_effort"] = reasoning.at("effort"); + } + chatcmpl_body.erase("reasoning"); + } + + return chatcmpl_body; +} + +// Edits the cch section of an "x-anthropic-billing-header" system prompt. +// Does nothing to any other prompt. +// +// This is a claude message with a "cch=ef01a" attribute that breaks prefix caching. +// The cch stamp is a whitebox end-to-end integrity hint. It's not meaningful as a +// system prompt data, particularly to llama.cpp, but its presence means the prefix +// cache will not get past it: It changes on each request. +// +// Reference: https://github.com/ggml-org/llama.cpp/pull/21793 +// Example header: +// ``` +// x-anthropic-billing-header: cc_version=2.1.101.e51; cc_entrypoint=cli; cch=a5145;You are Claude Code, Anthropic's official CLI for Claude. +// ^^^^^ +// ``` +static void normalize_anthropic_billing_header(std::string & system_text) { + if (system_text.rfind("x-anthropic-billing-header:", 0) != 0) { + return; + } + + const size_t header_prefix_length = strlen("x-anthropic-billing-header:"); + const size_t cch_length = 5; + const size_t index_cch = system_text.find("cch=", header_prefix_length); + if (index_cch == std::string::npos) { + return; + } + + const size_t index_replace = index_cch + 4; + if (index_replace + cch_length < system_text.length() && system_text[index_replace + cch_length] == ';') { + for (size_t i = 0; i < cch_length; ++i) { + system_text[index_replace + i] = 'f'; + } + } else { + LOG_ERR("anthropic string not as expected: %s", system_text.c_str()); + } +} + +json server_chat_convert_anthropic_to_oai(const json & body) { + json oai_body; + + // Convert system prompt + json oai_messages = json::array(); + auto system_param = json_value(body, "system", json()); + if (!system_param.is_null()) { + std::string system_content; + + if (system_param.is_string()) { + system_content = system_param.get(); + normalize_anthropic_billing_header(system_content); + } else if (system_param.is_array()) { + for (const auto & block : system_param) { + if (json_value(block, "type", std::string()) == "text") { + auto system_text = json_value(block, "text", std::string()); + normalize_anthropic_billing_header(system_text); + system_content += system_text; + } + } + } + + oai_messages.push_back({ + {"role", "system"}, + {"content", system_content} + }); + } + + // Convert messages + if (!body.contains("messages")) { + throw std::runtime_error("'messages' is required"); + } + const json & messages = body.at("messages"); + if (messages.is_array()) { + for (const auto & msg : messages) { + std::string role = json_value(msg, "role", std::string()); + + if (!msg.contains("content")) { + if (role == "assistant") { + continue; + } + oai_messages.push_back(msg); + continue; + } + + const json & content = msg.at("content"); + + if (content.is_string()) { + oai_messages.push_back(msg); + continue; + } + + if (!content.is_array()) { + oai_messages.push_back(msg); + continue; + } + + json tool_calls = json::array(); + json converted_content = json::array(); + json tool_results = json::array(); + std::string reasoning_content; + bool has_tool_calls = false; + + for (const auto & block : content) { + std::string type = json_value(block, "type", std::string()); + + if (type == "text") { + converted_content.push_back(block); + } else if (type == "thinking") { + reasoning_content += json_value(block, "thinking", std::string()); + } else if (type == "image") { + json source = json_value(block, "source", json::object()); + std::string source_type = json_value(source, "type", std::string()); + + if (source_type == "base64") { + std::string media_type = json_value(source, "media_type", std::string("image/jpeg")); + std::string data = json_value(source, "data", std::string()); + std::ostringstream ss; + ss << "data:" << media_type << ";base64," << data; + + converted_content.push_back({ + {"type", "image_url"}, + {"image_url", { + {"url", ss.str()} + }} + }); + } else if (source_type == "url") { + std::string url = json_value(source, "url", std::string()); + converted_content.push_back({ + {"type", "image_url"}, + {"image_url", { + {"url", url} + }} + }); + } + } else if (type == "tool_use") { + tool_calls.push_back({ + {"id", json_value(block, "id", std::string())}, + {"type", "function"}, + {"function", { + {"name", json_value(block, "name", std::string())}, + {"arguments", json_value(block, "input", json::object()).dump()} + }} + }); + has_tool_calls = true; + } else if (type == "tool_result") { + std::string tool_use_id = json_value(block, "tool_use_id", std::string()); + + auto result_content = json_value(block, "content", json()); + if (result_content.is_string()) { + tool_results.push_back({ + {"role", "tool"}, + {"tool_call_id", tool_use_id}, + {"content", result_content.get()} + }); + } else if (result_content.is_array()) { + // Single-pass: build both text and content_parts, decide format at the end + std::string result_text; + json content_parts = json::array(); + bool has_images = false; + + for (const auto & c : result_content) { + std::string c_type = json_value(c, "type", std::string()); + if (c_type == "text") { + std::string text = json_value(c, "text", std::string()); + result_text += text; + content_parts.push_back({ + {"type", "text"}, + {"text", text} + }); + } else if (c_type == "image") { + has_images = true; + json source = json_value(c, "source", json::object()); + std::string source_type = json_value(source, "type", std::string()); + if (source_type == "base64") { + std::string media_type = json_value(source, "media_type", std::string("image/jpeg")); + std::string data = json_value(source, "data", std::string()); + std::string url = "data:" + media_type + ";base64," + data; + content_parts.push_back({ + {"type", "image_url"}, + {"image_url", {{"url", url}}} + }); + } else if (source_type == "url") { + content_parts.push_back({ + {"type", "image_url"}, + {"image_url", {{"url", json_value(source, "url", std::string())}}} + }); + } + } + } + + if (!has_images) { + // Text-only: collapse to a plain string for maximum compatibility + tool_results.push_back({ + {"role", "tool"}, + {"tool_call_id", tool_use_id}, + {"content", result_text} + }); + } else { + // Mixed or image-only: use array content parts (OpenAI multimodal tool format) + tool_results.push_back({ + {"role", "tool"}, + {"tool_call_id", tool_use_id}, + {"content", content_parts} + }); + } + } else { + tool_results.push_back({ + {"role", "tool"}, + {"tool_call_id", tool_use_id}, + {"content", ""} + }); + } + } + } + + if (!converted_content.empty() || has_tool_calls || !reasoning_content.empty()) { + json new_msg = {{"role", role}}; + if (!converted_content.empty()) { + new_msg["content"] = converted_content; + } else if (has_tool_calls || !reasoning_content.empty()) { + new_msg["content"] = ""; + } + if (!tool_calls.empty()) { + new_msg["tool_calls"] = tool_calls; + } + if (!reasoning_content.empty()) { + new_msg["reasoning_content"] = reasoning_content; + } + oai_messages.push_back(new_msg); + } + + for (const auto & tool_msg : tool_results) { + oai_messages.push_back(tool_msg); + } + } + } + + oai_body["messages"] = oai_messages; + + // Convert tools + if (body.contains("tools")) { + const json & tools = body.at("tools"); + if (tools.is_array()) { + json oai_tools = json::array(); + for (const auto & tool : tools) { + oai_tools.push_back({ + {"type", "function"}, + {"function", { + {"name", json_value(tool, "name", std::string())}, + {"description", json_value(tool, "description", std::string())}, + {"parameters", tool.contains("input_schema") ? tool.at("input_schema") : json::object()} + }} + }); + } + oai_body["tools"] = oai_tools; + } + } + + // Convert tool_choice + if (body.contains("tool_choice")) { + const json & tc = body.at("tool_choice"); + if (tc.is_object()) { + std::string type = json_value(tc, "type", std::string()); + if (type == "auto") { + oai_body["tool_choice"] = "auto"; + } else if (type == "any" || type == "tool") { + oai_body["tool_choice"] = "required"; + } + } + } + + // Convert stop_sequences to stop + if (body.contains("stop_sequences")) { + oai_body["stop"] = body.at("stop_sequences"); + } + + // Handle max_tokens (required in Anthropic, but we're permissive) + if (body.contains("max_tokens")) { + oai_body["max_tokens"] = body.at("max_tokens"); + } else { + oai_body["max_tokens"] = 4096; + } + + // Pass through common params + for (const auto & key : {"temperature", "top_p", "top_k", "stream", "chat_template_kwargs"}) { + if (body.contains(key)) { + oai_body[key] = body.at(key); + } + } + + // Handle Anthropic-specific thinking param + if (body.contains("thinking")) { + json thinking = json_value(body, "thinking", json::object()); + std::string thinking_type = json_value(thinking, "type", std::string()); + if (thinking_type == "enabled") { + int budget_tokens = json_value(thinking, "budget_tokens", 10000); + oai_body["thinking_budget_tokens"] = budget_tokens; + } + } + + // Handle Anthropic-specific metadata param + if (body.contains("metadata")) { + json metadata = json_value(body, "metadata", json::object()); + std::string user_id = json_value(metadata, "user_id", std::string()); + if (!user_id.empty()) { + oai_body["__metadata_user_id"] = user_id; + } + } + + return oai_body; +} + +json server_chat_msg_diff_to_json_oaicompat(const common_chat_msg_diff & diff) { + json delta = json::object(); + if (!diff.reasoning_content_delta.empty()) { + delta["reasoning_content"] = diff.reasoning_content_delta; + } + if (!diff.content_delta.empty()) { + delta["content"] = diff.content_delta; + } + if (diff.tool_call_index != std::string::npos) { + json tool_call; + tool_call["index"] = diff.tool_call_index; + if (!diff.tool_call_delta.id.empty()) { + tool_call["id"] = diff.tool_call_delta.id; + tool_call["type"] = "function"; + } + if (!diff.tool_call_delta.name.empty() || !diff.tool_call_delta.arguments.empty()) { + json function = json::object(); + if (!diff.tool_call_delta.name.empty()) { + function["name"] = diff.tool_call_delta.name; + } + if (!diff.tool_call_delta.arguments.empty()) { + function["arguments"] = diff.tool_call_delta.arguments; + } + tool_call["function"] = function; + } + delta["tool_calls"] = json::array({ tool_call }); + } + return delta; +} + +json convert_transcriptions_to_chatcmpl( + const json & inp_body, + const common_chat_templates * tmpls, + const std::map & in_files, + std::vector & out_files) { + // TODO @ngxson : this function may need to be improved in the future + // handle input files + out_files.clear(); + auto it = in_files.find("file"); + if (it != in_files.end()) { + out_files.push_back(it->second.data); + } else { + throw std::invalid_argument("No input file found for transcription"); + } + + // handle input data + std::string prompt = json_value(inp_body, "prompt", std::string()); + std::string language = json_value(inp_body, "language", std::string()); + std::string response_format = json_value(inp_body, "response_format", std::string("json")); + if (response_format != "json") { + throw std::invalid_argument("Only 'json' response_format is supported for transcription"); + } + const common_chat_prompt_preset preset = common_chat_get_asr_prompt(tmpls); + if (prompt.empty()) { + prompt = preset.user; + } + if (!language.empty()) { + prompt += string_format(" (language: %s)", language.c_str()); + } + prompt += get_media_marker(); + + json messages = json::array(); + if (!preset.system.empty()) { + messages.push_back({{"role", "system"}, {"content", preset.system}}); + } + messages.push_back({{"role", "user"}, {"content", prompt}}); + + json chatcmpl_body = inp_body; // copy all fields + chatcmpl_body["messages"] = messages; + + // because input from form-data, everything is string, we need to correct the types here + std::string stream = json_value(inp_body, "stream", std::string("false")); + chatcmpl_body["stream"] = stream == "true"; + + if (inp_body.contains("max_tokens")) { + std::string inp = inp_body["max_tokens"].get(); + chatcmpl_body["max_tokens"] = std::stoul(inp); + } + + if (inp_body.contains("temperature")) { + std::string inp = inp_body["temperature"].get(); + chatcmpl_body["temperature"] = std::stof(inp); + } + + return chatcmpl_body; +} diff --git a/tools/server/server-chat.h b/tools/server/server-chat.h new file mode 100644 index 0000000000000000000000000000000000000000..102eae688a316426cd7916f0c4235b7c22e3ac82 --- /dev/null +++ b/tools/server/server-chat.h @@ -0,0 +1,26 @@ +// Chat conversion functions for server (Responses API, Anthropic API, OAI streaming diffs) + +#pragma once + +#include "chat.h" +#include "server-common.h" +#include "server-http.h" + +#include + +using json = nlohmann::ordered_json; + +// Convert OpenAI Responses API format to OpenAI Chat Completions API format +json server_chat_convert_responses_to_chatcmpl(const json & body); + +// Convert Anthropic Messages API format to OpenAI Chat Completions API format +json server_chat_convert_anthropic_to_oai(const json & body); + +// convert OpenAI transcriptions API format to OpenAI Chat Completions API format +json convert_transcriptions_to_chatcmpl( + const json & body, + const common_chat_templates * tmpls, + const std::map & in_files, + std::vector & out_files); + +json server_chat_msg_diff_to_json_oaicompat(const common_chat_msg_diff & diff); diff --git a/tools/server/server-common.cpp b/tools/server/server-common.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c726167acf365c8264dcebcbc165f22aa75d2824 --- /dev/null +++ b/tools/server/server-common.cpp @@ -0,0 +1,1595 @@ +#include "common.h" +#include "download.h" +#include "log.h" +#include "llama.h" +#include "mtmd.h" +#include "mtmd-helper.h" +#include "chat.h" +#include "base64.hpp" + +#include "server-common.h" + +#include +#include +#include +#include + +json format_error_response(const std::string & message, const enum error_type type) { + std::string type_str; + int code = 500; + switch (type) { + case ERROR_TYPE_INVALID_REQUEST: + type_str = "invalid_request_error"; + code = 400; + break; + case ERROR_TYPE_AUTHENTICATION: + type_str = "authentication_error"; + code = 401; + break; + case ERROR_TYPE_NOT_FOUND: + type_str = "not_found_error"; + code = 404; + break; + case ERROR_TYPE_SERVER: + type_str = "server_error"; + code = 500; + break; + case ERROR_TYPE_PERMISSION: + type_str = "permission_error"; + code = 403; + break; + case ERROR_TYPE_NOT_SUPPORTED: + type_str = "not_supported_error"; + code = 501; + break; + case ERROR_TYPE_UNAVAILABLE: + type_str = "unavailable_error"; + code = 503; + break; + case ERROR_TYPE_EXCEED_CONTEXT_SIZE: + type_str = "exceed_context_size_error"; + code = 400; + break; + } + return json { + {"code", code}, + {"message", message}, + {"type", type_str}, + }; +} + +// +// random string / id +// + +std::string random_string() { + static const std::string str("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"); + + std::random_device rd; + std::mt19937 generator(rd()); + + std::string result(32, ' '); + + for (int i = 0; i < 32; ++i) { + result[i] = str[generator() % str.size()]; + } + + return result; +} + +std::string gen_chatcmplid() { + return "chatcmpl-" + random_string(); +} + +std::string gen_tool_call_id() { + return random_string(); +} + +const char * get_media_marker() { + static const std::string marker = []() { + // allow user to pin a reproducible marker via env var + const char * env = getenv("LLAMA_MEDIA_MARKER"); + if (env && env[0] != '\0') { + return std::string(env); + } + return std::string("<__media_") + random_string() + "__>"; + }(); + return marker.c_str(); +} + +// +// lora utils +// + +bool lora_all_alora(const std::vector & loras) { + bool found_alora = false; + for (const auto & lora : loras) { + if (lora.scale != 0) { + if (llama_adapter_get_alora_n_invocation_tokens(lora.ptr) == 0) { + return false; + } + found_alora = true; + } + } + return found_alora; +} + +bool lora_should_clear_cache( + const std::vector & current, + const std::vector & next) { + + // This should always be called after determining that the two sets are + // _not_ equal. This assert is therefore some slightly wasted work and + // should be safe to remove as long as this method is called correctly. + GGML_ASSERT(!are_lora_equal(current, next)); + + return ( + !(lora_get_enabled_ids(current).empty() || lora_all_alora(current)) || + !lora_all_alora(next)); +} + +std::map parse_lora_request(const json & data) { + std::map lora; + + // set value + for (const auto & entry : data) { + int id = json_value(entry, "id", -1); + float scale = json_value(entry, "scale", 0.0f); + lora[id] = scale; + } + + return lora; +} + +bool are_lora_equal( + const std::vector & l1, + const std::vector & l2) { + if (l1.size() != l2.size()) { + return false; + } + for (size_t i = 0; i < l1.size(); ++i) { + // we don't check lora.path to reduce the time complexity + if (l1[i].scale != l2[i].scale || l1[i].ptr != l2[i].ptr) { + return false; + } + } + return true; +} + +std::vector lora_get_enabled_ids(const std::vector & loras) { + std::vector enabled_ids; + for (size_t i = 0; i < loras.size(); ++i) { + if (loras[i].scale > 0) { + enabled_ids.push_back(i); + } + } + return enabled_ids; +} + +// +// base64 utils (TODO: use the base64::decode from base64.hpp) +// + +static const std::string base64_chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +static inline bool is_base64(uint8_t c) { + return (isalnum(c) || (c == '+') || (c == '/')); +} + +static inline raw_buffer base64_decode(const std::string & encoded_string) { + int i = 0; + int j = 0; + int in_ = 0; + + int in_len = encoded_string.size(); + + uint8_t char_array_4[4]; + uint8_t char_array_3[3]; + + raw_buffer ret; + + while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) { + char_array_4[i++] = encoded_string[in_]; in_++; + if (i == 4) { + for (i = 0; i < 4; i++) { + char_array_4[i] = base64_chars.find(char_array_4[i]); + } + + char_array_3[0] = ((char_array_4[0] ) << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (i = 0; (i < 3); i++) { + ret.push_back(char_array_3[i]); + } + + i = 0; + } + } + + if (i) { + for (j = i; j < 4; j++) { + char_array_4[j] = 0; + } + + for (j = 0; j < 4; j++) { + char_array_4[j] = base64_chars.find(char_array_4[j]); + } + + char_array_3[0] = ((char_array_4[0] ) << 2) + ((char_array_4[1] & 0x30) >> 4); + char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2); + char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3]; + + for (j = 0; j < i - 1; j++) { + ret.push_back(char_array_3[j]); + } + } + + return ret; +} + +// +// server_tokens implementation +// + +server_tokens::server_tokens(mtmd::input_chunks & mtmd_chunks, bool has_mtmd) : has_mtmd(has_mtmd) { + for (size_t i = 0; i < mtmd_chunks.size(); ++i) { + push_back(mtmd_chunks[i]); + } +} + +server_tokens::server_tokens(const llama_tokens & tokens, bool has_mtmd) : has_mtmd(has_mtmd), tokens(tokens) { +} + +llama_pos server_tokens::pos_next(int64_t n_tokens) const { + if (!has_mtmd) { + if (n_tokens < 0) { + return tokens.size(); + } + + return n_tokens; + } + + if (n_tokens < 0) { + llama_pos res = tokens.size(); + + for (auto it = map_idx_to_media.begin(); it != map_idx_to_media.end(); ++it) { + const auto & chunk = it->second; + res += mtmd_input_chunk_get_n_pos(chunk.get()) - mtmd_input_chunk_get_n_tokens(chunk.get()); + } + + return res; + } + + int64_t idx = 0; + llama_pos pos = 0; + + GGML_ASSERT(n_tokens <= (int64_t)tokens.size()); + + while (idx < n_tokens) { + const auto media_it = map_idx_to_media.find(idx); + if (media_it != map_idx_to_media.end()) { + const auto & chunk = media_it->second; + const llama_pos n_pos = mtmd_input_chunk_get_n_pos(chunk.get()); + const size_t n_tok = mtmd_input_chunk_get_n_tokens(chunk.get()); + + pos += n_pos; + idx += n_tok; + } else { + pos++; + idx++; + } + } + + return pos; +} + +size_t server_tokens::size_up_to_pos(llama_pos max_pos) const { + if (!has_mtmd) { + return std::min((size_t)max_pos, tokens.size()); + } + + size_t idx = 0; + llama_pos pos = 0; + + while (idx < tokens.size()) { + const auto media_it = map_idx_to_media.find(idx); + if (media_it != map_idx_to_media.end()) { + const auto & chunk = media_it->second; + const llama_pos n_pos = mtmd_input_chunk_get_n_pos(chunk.get()); + const size_t n_tok = mtmd_input_chunk_get_n_tokens(chunk.get()); + + pos += n_pos; + idx += n_tok; + } else { + pos++; + idx++; + } + + if (pos >= max_pos) { + break; + } + } + + return idx; +} + +std::string server_tokens::str() const { + std::ostringstream oss; + oss << "tokens: "; + for (size_t idx = 0; idx < tokens.size(); ++idx) { + llama_token t = tokens[idx]; + oss << "idx:" << idx << " "; + if (t == LLAMA_TOKEN_NULL) { + oss << " "; + } else { + oss << t << " "; + } + } + oss << "\n"; + oss << "image idx: "; + for (const auto & it : map_idx_to_media) { + oss << it.first << ", "; + } + return oss.str(); +} + +const mtmd::input_chunk_ptr & server_tokens::find_chunk(size_t idx) const { + auto it = map_idx_to_media.find(idx); + if (it != map_idx_to_media.end()) { + return it->second; + } + throw std::runtime_error("Chunk not found"); +} + +std::pair server_tokens::find_next_media_chunk(size_t idx) const { + auto it = map_idx_to_media.upper_bound(idx); + if (it != map_idx_to_media.end()) { + return { &it->second, it->first }; + } + return { nullptr, 0 }; +} + +void server_tokens::push_back(llama_token tok) { + if (tok == LLAMA_TOKEN_NULL) { + throw std::runtime_error("Invalid token"); + } + tokens.emplace_back(tok); +} + +void server_tokens::push_back(const mtmd_input_chunk * chunk) { + auto type = mtmd_input_chunk_get_type(chunk); + if (type == MTMD_INPUT_CHUNK_TYPE_IMAGE || type == MTMD_INPUT_CHUNK_TYPE_AUDIO) { + GGML_ASSERT(has_mtmd); + const size_t n_tokens = mtmd_input_chunk_get_n_tokens(chunk); + size_t start_idx = tokens.size(); + for (size_t i = 0; i < n_tokens; ++i) { + tokens.emplace_back(LLAMA_TOKEN_NULL); + } + mtmd::input_chunk_ptr new_chunk(mtmd_input_chunk_copy(chunk)); + map_idx_to_media[start_idx] = std::move(new_chunk); + } else if (type == MTMD_INPUT_CHUNK_TYPE_TEXT) { + size_t n_tokens; + const auto * text_tokens = mtmd_input_chunk_get_tokens_text(chunk, &n_tokens); + for (size_t i = 0; i < n_tokens; ++i) { + push_back(text_tokens[i]); + } + } else { + GGML_ABORT("Invalid chunk type"); + } +} + +void server_tokens::push_back(server_tokens & tokens) { + size_t start_idx = size(); + for (size_t i = 0; i < tokens.size(); i++) { + push_back(tokens[i]); + } + if (tokens.has_mtmd) { + // Assert if we are copying MTMD chunks to a server_tokens that does not have mtmd. + // We could also just check, but this will prevent silently dropping MTMD data. + GGML_ASSERT(has_mtmd); + for (auto it = tokens.map_idx_to_media.begin(); it != tokens.map_idx_to_media.end(); ) { + auto * chunk = tokens.map_idx_to_media[it->first].get(); + mtmd::input_chunk_ptr new_chunk(mtmd_input_chunk_copy(chunk)); + map_idx_to_media[start_idx + it->first] = std::move(new_chunk); + } + } +} + +void server_tokens::insert(const llama_tokens & inp_tokens) { + tokens.insert(tokens.end(), inp_tokens.begin(), inp_tokens.end()); +} + +const llama_tokens & server_tokens::get_tokens() const { + GGML_ASSERT(!has_mtmd); + return tokens; +} + +llama_tokens server_tokens::get_text_tokens() const { + llama_tokens res; + res.reserve(tokens.size()); + for (llama_token t : tokens) { + if (t != LLAMA_TOKEN_NULL) { + res.push_back(t); + } + } + return res; +} + +void server_tokens::set_token(llama_pos pos, llama_token id) { + GGML_ASSERT(!has_mtmd); // only allow this if mtmd is disabled + tokens[pos] = id; +} + +void server_tokens::keep_first(size_t n) { + GGML_ASSERT(n <= tokens.size()); + if (has_mtmd) { + if (n == tokens.size()) { + return; // nothing to do + } + // we throw an error if we try to remove a token in the middle of an image + // for ex. with input of 5 text tokens and 2 images: + // [0] [1] [2] [3] [4] [img0] [img0] [img0] [img1] [img1] + // n 1 2 3 4 5 6 7 8 9 10 + // allowed to resize ^ ^ + // disallowed to resize ^ ^ ^ + if (n > 0) { + // make sure we never remove tokens in the middle of an image + // note that the case where we keep a full image at the end is allowed: + // tokens[n - 1] == LLAMA_TOKEN_NULL && tokens[n] != LLAMA_TOKEN_NULL + if (tokens[n - 1] == LLAMA_TOKEN_NULL && tokens[n] == LLAMA_TOKEN_NULL) { + find_chunk(n - 1); // will throw an error if the token is not begin-of-chunk + } + } + // remove all image chunks that are not used anymore + for (auto it = map_idx_to_media.begin(); it != map_idx_to_media.end(); ) { + size_t idx = it->first; + if (idx >= n) { + it = map_idx_to_media.erase(it); + } else { + ++it; + } + } + } + tokens.resize(n); +} + +std::string server_tokens::detokenize(const llama_context * ctx, bool special) const { + llama_tokens text_tokens; + text_tokens.reserve(tokens.size()); + for (const auto & t : tokens) { + if (t != LLAMA_TOKEN_NULL) { + text_tokens.push_back(t); + } + } + return common_detokenize(ctx, text_tokens, special); +} + +size_t server_tokens::get_common_prefix(const server_tokens & b) const { + const size_t max_idx = std::min(tokens.size(), b.tokens.size()); + + if (!has_mtmd) { + for (size_t i = 0; i < max_idx; ++i) { + if (tokens[i] == b.tokens[i]) { + continue; + } + + return i; + } + + return max_idx; + } + + for (size_t i = 0; i < max_idx; ++i) { + const llama_token ai = tokens[i]; + const llama_token bi = b.tokens[i]; + + if (ai == LLAMA_TOKEN_NULL && bi == LLAMA_TOKEN_NULL) { + const auto & a_chunk = find_chunk(i); + const auto & b_chunk = b.find_chunk(i); + + GGML_ASSERT(a_chunk && b_chunk); + + const std::string id_ai = mtmd_input_chunk_get_id(a_chunk.get()); + const std::string id_bi = mtmd_input_chunk_get_id(b_chunk.get()); + + const size_t n_tok_a = mtmd_input_chunk_get_n_tokens(a_chunk.get()); + const size_t n_tok_b = mtmd_input_chunk_get_n_tokens(b_chunk.get()); + + if (id_ai == id_bi && n_tok_a == n_tok_b) { + GGML_ASSERT(n_tok_a > 0 && "Invalid media chunk"); // should never happen + i += n_tok_a - 1; // will be +1 by the for loop + continue; + } + + return i; + } + + if (ai == bi) { + continue; + } + + return i; + } + + return max_idx; // all tokens are equal +} + +common_chat_msg_spans server_tokens::find_message_spans(const common_chat_msg_delimiters & delims) const { + std::map skips; + for (const auto & it : map_idx_to_media) { + skips[it.first] = mtmd_input_chunk_get_n_tokens(it.second.get()); + } + return delims.split(tokens, skips); +} + +bool server_tokens::validate(const struct llama_context * ctx) const { + const llama_model * model = llama_get_model(ctx); + const llama_vocab * vocab = llama_model_get_vocab(model); + const int32_t n_vocab = llama_vocab_n_tokens(vocab); + + for (size_t i = 0; i < tokens.size(); ++i) { + const auto & t = tokens[i]; + if (t == LLAMA_TOKEN_NULL) { + try { + const auto & chunk = find_chunk(i); + size_t n_tokens = mtmd_input_chunk_get_n_tokens(chunk.get()); + i += n_tokens - 1; // will be +1 by the for loop + } catch (const std::exception & e) { + return false; + } + } else if (t < 0 || t >= n_vocab) { + return false; + } + } + return true; +} + +server_tokens server_tokens::clone() const { + server_tokens res; + res.has_mtmd = has_mtmd; + res.tokens = tokens; + for (auto it = map_idx_to_media.begin(); it != map_idx_to_media.end(); ++it) { + size_t idx = it->first; + const mtmd::input_chunk_ptr & chunk = it->second; + res.map_idx_to_media[idx] = mtmd::input_chunk_ptr(mtmd_input_chunk_copy(chunk.get())); + } + return res; +} + +// +// tokenizer and input processing utils +// + +bool json_is_array_of_numbers(const json & data) { + if (data.is_array()) { + for (const auto & e : data) { + if (!e.is_number_integer()) { + return false; + } + } + return true; + } + return false; +} + +bool json_is_array_of_mixed_numbers_strings(const json & data) { + bool seen_string = false; + bool seen_number = false; + if (data.is_array()) { + for (const auto & e : data) { + seen_string |= e.is_string(); + seen_number |= e.is_number_integer(); + if (seen_number && seen_string) { + return true; + } + } + } + return false; +} + +bool json_is_array_and_contains_numbers(const json & data) { + if (data.is_array()) { + for (const auto & e : data) { + if (e.is_number_integer()) { + return true; + } + } + return false; + } + return false; +} + +json json_get_nested_values(const std::vector & paths, const json & js) { + json result = json::object(); + + for (const std::string & path : paths) { + json current = js; + const auto keys = string_split(path, /*separator*/ '/'); + bool valid_path = true; + for (const std::string & k : keys) { + if (valid_path && current.is_object() && current.contains(k)) { + current = current[k]; + } else { + valid_path = false; + } + } + if (valid_path) { + result[path] = current; + } + } + return result; +} + +llama_tokens tokenize_mixed(const llama_vocab * vocab, const json & json_prompt, bool add_special, bool parse_special) { + // If `add_bos` is true, we only add BOS, when json_prompt is a string, + // or the first element of the json_prompt array is a string. + llama_tokens prompt_tokens; + + if (json_prompt.is_array()) { + bool first = true; + for (const auto & p : json_prompt) { + if (p.is_string()) { + auto s = p.template get(); + + llama_tokens p; + if (first) { + p = common_tokenize(vocab, s, add_special, parse_special); + first = false; + } else { + p = common_tokenize(vocab, s, false, parse_special); + } + + prompt_tokens.insert(prompt_tokens.end(), p.begin(), p.end()); + } else { + if (first) { + first = false; + } + + prompt_tokens.push_back(p.template get()); + } + } + } else { + auto s = json_prompt.template get(); + prompt_tokens = common_tokenize(vocab, s, add_special, parse_special); + } + + return prompt_tokens; +} + +size_t validate_utf8(const std::string& text) { + size_t len = text.size(); + if (len == 0) return 0; + + // Check the last few bytes to see if a multi-byte character is cut off + for (size_t i = 1; i <= 4 && i <= len; ++i) { + unsigned char c = text[len - i]; + // Check for start of a multi-byte sequence from the end + if ((c & 0xE0) == 0xC0) { + // 2-byte character start: 110xxxxx + // Needs at least 2 bytes + if (i < 2) return len - i; + } else if ((c & 0xF0) == 0xE0) { + // 3-byte character start: 1110xxxx + // Needs at least 3 bytes + if (i < 3) return len - i; + } else if ((c & 0xF8) == 0xF0) { + // 4-byte character start: 11110xxx + // Needs at least 4 bytes + if (i < 4) return len - i; + } + } + + // If no cut-off multi-byte character is found, return full length + return len; +} + +server_tokens process_mtmd_prompt(mtmd_context * mctx, const std::string & prompt, const std::vector & files, bool is_placeholder) { + // these will be freed upon going out of scope + mtmd::bitmaps bitmaps; + std::vector videos; + for (auto & file : files) { + auto out = mtmd_helper_bitmap_init_from_buf(mctx, file.data(), file.size(), is_placeholder); + if (!out.bitmap) { + throw std::runtime_error("Failed to load image or audio file"); + } + bitmaps.entries.emplace_back(out.bitmap); + if (out.video_ctx) { + videos.emplace_back(out.video_ctx); + } + } + // process prompt + std::vector inputs; + // multimodal + mtmd_input_text inp_txt = { + prompt.data(), + prompt.size(), + /* add_special */ true, + /* parse_special */ true, + }; + mtmd::input_chunks chunks(mtmd_input_chunks_init()); + auto bitmaps_c_ptr = bitmaps.c_ptr(); + int32_t tokenized = mtmd_tokenize(mctx, + chunks.ptr.get(), + &inp_txt, + bitmaps_c_ptr.data(), + bitmaps_c_ptr.size()); + if (tokenized != 0) { + throw std::runtime_error("Failed to tokenize prompt"); + } + auto result = server_tokens(chunks, true); + return result; +} + +/** + * break the input "prompt" object into multiple prompt if needed, then tokenize them + * use tokenize_input_prompts() if the input could be an array. + * this supports these cases: + * - "prompt": "string" + * - "prompt": [12, 34, 56] + * - "prompt": [12, 34, "string", 56, 78] + * - "prompt": { "prompt_string": "string", "multimodal_data": [ "base64" ] } + */ +static server_tokens tokenize_input_subprompt(const llama_vocab * vocab, mtmd_context * mctx, const json & json_prompt, bool add_special, bool parse_special) { + constexpr char JSON_STRING_PROMPT_KEY[] = "prompt_string"; + constexpr char JSON_MTMD_DATA_KEY[] = "multimodal_data"; + const bool has_mtmd = mctx != nullptr; + if (json_prompt.is_string() || json_is_array_of_mixed_numbers_strings(json_prompt)) { + // string or mixed + llama_tokens tmp = tokenize_mixed(vocab, json_prompt, add_special, parse_special); + return server_tokens(tmp, false); + } else if (json_is_array_of_numbers(json_prompt)) { + // array of tokens + llama_tokens tmp = json_prompt.get(); + return server_tokens(tmp, false); + } else if (json_prompt.contains(JSON_STRING_PROMPT_KEY)) { + // JSON object with prompt key. + if (json_prompt.contains(JSON_MTMD_DATA_KEY)) { + if (!has_mtmd) + throw std::runtime_error("Multimodal data provided, but model does not support multimodal requests."); + + // JSON object with prompt and multimodal key. + std::vector files; + for (const auto & entry : json_prompt.at(JSON_MTMD_DATA_KEY)) { + files.push_back(base64_decode(entry)); + } + return process_mtmd_prompt(mctx, json_prompt.at(JSON_STRING_PROMPT_KEY), files); + } else { + // Not multimodal, but contains a subobject. + llama_tokens tmp = tokenize_mixed(vocab, json_prompt.at(JSON_STRING_PROMPT_KEY), add_special, parse_special); + return server_tokens(tmp, false); + } + } else { + throw std::runtime_error("\"prompt\" elements must be a string, a list of tokens, a JSON object containing a prompt string, or a list of mixed strings & tokens."); + } +} + +std::vector tokenize_input_prompts(const llama_vocab * vocab, mtmd_context * mctx, const json & json_prompt, bool add_special, bool parse_special) { + std::vector result; + if (json_prompt.is_array() && !json_is_array_and_contains_numbers(json_prompt)) { + result.reserve(json_prompt.size()); + for (const auto & p : json_prompt) { + result.push_back(tokenize_input_subprompt(vocab, mctx, p,add_special, parse_special)); + } + } else { + result.push_back(tokenize_input_subprompt(vocab, mctx, json_prompt, add_special, parse_special)); + } + if (result.empty()) { + throw std::runtime_error("\"prompt\" must not be empty"); + } + return result; +} + +// +// OAI utils +// + +// used by /completions endpoint +json oaicompat_completion_params_parse(const json & body) { + json llama_params; + + if (!body.contains("prompt")) { + throw std::runtime_error("\"prompt\" is required"); + } + + // Handle "stop" field + if (body.contains("stop") && body.at("stop").is_string()) { + llama_params["stop"] = json::array({body.at("stop").get()}); + } else { + llama_params["stop"] = json_value(body, "stop", json::array()); + } + + // Handle "echo" field + if (json_value(body, "echo", false)) { + throw std::runtime_error("Only no echo is supported"); + } + + // Params supported by OAI but unsupported by llama.cpp + static const std::vector unsupported_params { "best_of" }; + for (const auto & param : unsupported_params) { + if (body.contains(param)) { + throw std::runtime_error("Unsupported param: " + param); + } + } + + // Copy remaining properties to llama_params + for (const auto & item : body.items()) { + // Exception: if "n_predict" is present, we overwrite the value specified earlier by "max_tokens" + if (!llama_params.contains(item.key()) || item.key() == "n_predict") { + llama_params[item.key()] = item.value(); + } + } + + return llama_params; +} + +// url can be +// - http(s):// for remote files +// - file:// for local files (only allowed if media_path is set) +// - data: for base64 encoded data with uri scheme (e.g. data:image/png;base64,...) +// - raw base64 encoded data +static void handle_media( + std::vector & out_files, + const std::string & url, + const std::string & media_path, + bool accept_base64_uri) { + if (!media_path.empty()) { + // should already be enforced by arg.cpp, but checking just in case + GGML_ASSERT(media_path.back() == DIRECTORY_SEPARATOR); + } + + if (string_starts_with(url, "http")) { + // download remote image + // TODO @ngxson : maybe make these params configurable + common_remote_params params; + params.max_size = 1024 * 1024 * 10; // 10MB + params.timeout = 10; // seconds + SRV_INF("downloading image from '%s'\n", url.c_str()); + auto res = common_remote_get_content(url, params); + if (200 <= res.first && res.first < 300) { + SRV_INF("downloaded %zu bytes\n", res.second.size()); + raw_buffer data; + data.insert(data.end(), res.second.begin(), res.second.end()); + out_files.push_back(data); + } else { + throw std::runtime_error("Failed to download image"); + } + + } else if (string_starts_with(url, "file://")) { + if (media_path.empty()) { + throw std::invalid_argument("file:// URLs are not allowed unless --media-path is specified"); + } + // load local image file + std::string file_path = url.substr(7); // remove "file://" + raw_buffer data; + if (!fs_validate_filename(file_path, true)) { + throw std::invalid_argument("file path is not allowed: " + file_path); + } + SRV_INF("loading image from local file '%s'\n", (media_path + file_path).c_str()); + std::ifstream file(media_path + file_path, std::ios::binary); + if (!file) { + throw std::invalid_argument("file does not exist or cannot be opened: " + file_path); + } + data.assign((std::istreambuf_iterator(file)), std::istreambuf_iterator()); + out_files.push_back(data); + + } else if (accept_base64_uri && string_starts_with(url, "data:")) { + // try to decode base64 image + std::vector parts = string_split(url, /*separator*/ ','); + if (parts.size() != 2) { + throw std::runtime_error("Invalid uri-encoded base64 value"); + } else if (!string_starts_with(parts[0], "data:image/")) { + throw std::runtime_error("Invalid uri format: " + parts[0]); + } else if (!string_ends_with(parts[0], "base64")) { + throw std::runtime_error("uri must be base64 encoded"); + } else { + auto base64_data = parts[1]; + auto decoded_data = base64_decode(base64_data); + out_files.push_back(decoded_data); + } + + } else { + // try as raw base64 string + auto decoded_data = base64_decode(url); + if (decoded_data.empty()) { + throw std::runtime_error("Invalid base64 value"); + } + out_files.push_back(decoded_data); + } +} + +// used by /chat/completions endpoint +json oaicompat_chat_params_parse( + json & body, /* openai api json semantics */ + const server_chat_params & opt, + std::vector & out_files) +{ + json llama_params; + + auto tools = json_value(body, "tools", json()); + auto has_tools = tools.is_array() && !tools.empty(); + auto stream = json_value(body, "stream", false); + auto tool_choice = json_value(body, "tool_choice", std::string("auto")); + + if (!opt.use_jinja) { + if (has_tools) { + throw std::runtime_error("tools param requires --jinja flag"); + } + if (tool_choice != "auto") { + throw std::runtime_error("tool_choice param requires --jinja flag"); + } + } + + // Handle "stop" field + if (body.contains("stop") && body.at("stop").is_string()) { + llama_params["stop"] = json::array({body.at("stop").get()}); + } else { + llama_params["stop"] = json_value(body, "stop", json::array()); + } + + auto json_schema = json_value(body, "json_schema", json()); + auto grammar = json_value(body, "grammar", std::string()); + if (!json_schema.is_null() && !grammar.empty()) { + throw std::runtime_error("Cannot use both json_schema and grammar"); + } + + // Handle "response_format" field + if (body.contains("response_format")) { + json response_format = json_value(body, "response_format", json::object()); + std::string response_type = json_value(response_format, "type", std::string()); + if (response_type == "json_object") { + if (response_format.contains("schema") || json_schema.empty()) { + json_schema = json_value(response_format, "schema", json::object()); + } + } else if (response_type == "json_schema") { + auto schema_wrapper = json_value(response_format, "json_schema", json::object()); + json_schema = json_value(schema_wrapper, "schema", json::object()); + } else if (!response_type.empty() && response_type != "text") { + throw std::invalid_argument("response_format type must be one of \"text\" or \"json_object\", but got: " + response_type); + } + } + + // get input files + if (!body.contains("messages")) { + throw std::invalid_argument("'messages' is required"); + } + json & messages = body.at("messages"); + if (!messages.is_array()) { + throw std::invalid_argument("Expected 'messages' to be an array"); + } + for (auto & msg : messages) { + std::string role = json_value(msg, "role", std::string()); + if (role != "assistant" && !msg.contains("content")) { + throw std::invalid_argument("All non-assistant messages must contain 'content'"); + } + if (role == "assistant") { + if (!msg.contains("content") && !msg.contains("tool_calls")) { + throw std::invalid_argument("Assistant message must contain either 'content' or 'tool_calls'!"); + } + if (!msg.contains("content")) { + continue; // avoid errors with no content + } + } + json & content = msg.at("content"); + if (content.is_string() || content.is_null()) { + continue; + } + + if (!content.is_array()) { + throw std::invalid_argument("Expected 'content' to be a string or an array"); + } + + for (auto & p : content) { + std::string type = json_value(p, "type", std::string()); + if (type == "image_url") { + if (!opt.allow_image) { + throw std::runtime_error("image input is not supported - hint: if this is unexpected, you may need to provide the mmproj"); + } + + json image_url = json_value(p, "image_url", json::object()); + std::string url = json_value(image_url, "url", std::string()); + handle_media(out_files, url, opt.media_path, true); + + p["type"] = "media_marker"; + p["text"] = get_media_marker(); + p.erase("image_url"); + + } else if (type == "input_audio") { + if (!opt.allow_audio) { + throw std::runtime_error("audio input is not supported - hint: if this is unexpected, you may need to provide the mmproj"); + } + + // note: don't need to validate "format", it's redundant + json input_audio = json_value(p, "input_audio", json::object()); + std::string url = json_value(input_audio, "data", + json_value(input_audio, "url", std::string())); + handle_media(out_files, url, opt.media_path, false); + + p["type"] = "media_marker"; + p["text"] = get_media_marker(); + p.erase("input_audio"); + + } else if (type == "input_video") { + if (!opt.allow_video) { + throw std::runtime_error("video input is not supported - hint: if this is unexpected, you may need to provide the mmproj"); + } + + json input_video = json_value(p, "input_video", json::object()); + std::string url = json_value(input_video, "data", + json_value(input_video, "url", std::string())); + handle_media(out_files, url, opt.media_path, false); + + p["type"] = "media_marker"; + p["text"] = get_media_marker(); + p.erase("input_video"); + + } else if (type != "text") { + throw std::invalid_argument("unsupported content[].type"); + } + } + } + + auto caps = common_chat_templates_get_caps(opt.tmpls.get()); + + common_chat_templates_inputs inputs; + inputs.messages = common_chat_msgs_parse_oaicompat(messages); + inputs.tools = common_chat_tools_parse_oaicompat(tools); + inputs.tool_choice = common_chat_tool_choice_parse_oaicompat(tool_choice); + inputs.json_schema = json_schema.is_null() ? "" : json_schema.dump(); + inputs.grammar = grammar; + inputs.use_jinja = opt.use_jinja; + inputs.parallel_tool_calls = json_value(body, "parallel_tool_calls", caps["supports_parallel_tool_calls"]); + inputs.add_generation_prompt = json_value(body, "add_generation_prompt", true); + inputs.continue_final_message = body.contains("continue_final_message") ? + common_chat_continuation_parse(body.at("continue_final_message")) : + COMMON_CHAT_CONTINUATION_NONE; + if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_NONE && opt.prefill_assistant + && !inputs.messages.empty() && inputs.messages.back().role == "assistant") { + if (inputs.messages.size() >= 2 && inputs.messages[inputs.messages.size() - 2].role == "assistant") { + throw std::invalid_argument("Cannot have 2 or more assistant messages at the end of the list."); + } + inputs.continue_final_message = COMMON_CHAT_CONTINUATION_AUTO; + inputs.add_generation_prompt = false; + } + if (inputs.continue_final_message != COMMON_CHAT_CONTINUATION_NONE && inputs.add_generation_prompt) { + throw std::invalid_argument("Cannot set both add_generation_prompt and continue_final_message to true."); + } + inputs.reasoning_format = opt.reasoning_format; + if (body.contains("reasoning_format")) { + inputs.reasoning_format = common_reasoning_format_from_name(body.at("reasoning_format").get()); + } + inputs.enable_thinking = opt.enable_thinking; + if (!inputs.tools.empty() && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE) { + if (body.contains("grammar")) { + throw std::invalid_argument("Cannot use custom grammar constraints with tools."); + } + llama_params["parse_tool_calls"] = true; + } + + // merge the template args provided from command line with the args provided in the user request + auto chat_template_kwargs_object = json_value(body, "chat_template_kwargs", json::object()); + inputs.chat_template_kwargs = opt.chat_template_kwargs; + for (const auto & item : chat_template_kwargs_object.items()) { + inputs.chat_template_kwargs[item.key()] = item.value().dump(); + } + + // parse the "enable_thinking" kwarg to override the default value + auto enable_thinking_kwarg = json_value(inputs.chat_template_kwargs, "enable_thinking", std::string("")); + if (enable_thinking_kwarg == "true") { + inputs.enable_thinking = true; + } else if (enable_thinking_kwarg == "false") { + inputs.enable_thinking = false; + } else if (!enable_thinking_kwarg.empty() && enable_thinking_kwarg[0] == '"') { + throw std::invalid_argument("invalid type for \"enable_thinking\" (expected boolean, got string)"); + } + + // Parse also the OAI "reasoning_effort": "none" specific value + if (body.contains("reasoning_effort")) { + auto reasoning_effort = json_value(body, "reasoning_effort", std::string("")); + if (reasoning_effort == "none") { + inputs.enable_thinking = false; + } // other reasoning_effort values are model-specific and not yet handled + } + + inputs.force_pure_content = opt.force_pure_content; + + // Apply chat template to the list of messages + auto chat_params = common_chat_templates_apply(opt.tmpls.get(), inputs); + + llama_params["chat_format"] = static_cast(chat_params.format); + llama_params["prompt"] = chat_params.prompt; + if (!chat_params.grammar.empty()) { + llama_params["grammar"] = chat_params.grammar; + llama_params["grammar_type"] = std::string("tool_calls"); + } + llama_params["grammar_lazy"] = chat_params.grammar_lazy; + auto grammar_triggers = json::array(); + for (const auto & trigger : chat_params.grammar_triggers) { + server_grammar_trigger ct(trigger); + grammar_triggers.push_back(ct.to_json()); + } + llama_params["grammar_triggers"] = grammar_triggers; + llama_params["preserved_tokens"] = chat_params.preserved_tokens; + llama_params["generation_prompt"] = chat_params.generation_prompt; + for (const auto & stop : chat_params.additional_stops) { + llama_params["stop"].push_back(stop); + } + if (!chat_params.parser.empty()) { + llama_params["chat_parser"] = chat_params.parser; + } + + llama_params["message_delimiters"] = chat_params.message_delimiters.to_json(); + + // Reasoning budget: pass parameters through to sampling layer + { + int reasoning_budget = json_value(body, "reasoning_budget_tokens", + json_value(body, "thinking_budget_tokens", -1)); + if (reasoning_budget == -1) { + reasoning_budget = opt.reasoning_budget; + } + + if (!chat_params.thinking_end_tags.empty()) { + llama_params["reasoning_budget_tokens"] = reasoning_budget; + llama_params["reasoning_budget_start_tag"] = chat_params.thinking_start_tag; + llama_params["reasoning_budget_end_tags"] = chat_params.thinking_end_tags; + llama_params["reasoning_budget_message"] = json_value(body, "reasoning_budget_message", opt.reasoning_budget_message); + llama_params["reasoning_control"] = json_value(body, "reasoning_control", false); + } + } + + // Handle "logprobs" field + // TODO: The response format of this option is not yet OAI-compatible, but seems like no one really using it; We may need to fix it in the future + if (json_value(body, "logprobs", false)) { + if (has_tools && stream) { + throw std::invalid_argument("logprobs is not supported with tools + stream"); + } + llama_params["n_probs"] = json_value(body, "top_logprobs", 20); + } else if (body.contains("top_logprobs") && !body.at("top_logprobs").is_null()) { + throw std::invalid_argument("top_logprobs requires logprobs to be set to true"); + } + + // Copy remaining properties to llama_params + // This allows user to use llama.cpp-specific params like "mirostat", ... via OAI endpoint. + // See "launch_slot_with_task()" for a complete list of params supported by llama.cpp + for (const auto & item : body.items()) { + // Exception: if "n_predict" is present, we overwrite the value specified earlier by "max_tokens" + if (!llama_params.contains(item.key()) || item.key() == "n_predict") { + llama_params[item.key()] = item.value(); + } + } + + return llama_params; +} + +json format_embeddings_response_oaicompat( + const json & request, + const std::string & model_name, + const json & embeddings, + bool use_base64) { + json data = json::array(); + int32_t n_tokens = 0; + int i = 0; + for (const auto & elem : embeddings) { + json embedding_obj; + + if (use_base64) { + const auto& vec = json_value(elem, "embedding", json::array()).get>(); + const char* data_ptr = reinterpret_cast(vec.data()); + size_t data_size = vec.size() * sizeof(float); + embedding_obj = { + {"embedding", base64::encode(data_ptr, data_size)}, + {"index", i++}, + {"object", "embedding"}, + {"encoding_format", "base64"} + }; + } else { + embedding_obj = { + {"embedding", json_value(elem, "embedding", json::array())}, + {"index", i++}, + {"object", "embedding"} + }; + } + data.push_back(embedding_obj); + + n_tokens += json_value(elem, "tokens_evaluated", 0); + } + + json res = json { + {"model", json_value(request, "model", model_name)}, + {"object", "list"}, + {"usage", json { + {"prompt_tokens", n_tokens}, + {"total_tokens", n_tokens} + }}, + {"data", data} + }; + + return res; +} + +json format_response_rerank( + const json & request, + const std::string & model_name, + const json & ranks, + bool is_tei_format, + std::vector & texts, + int top_n) { + int32_t n_tokens = 0; + bool return_text = is_tei_format && json_value(request, "return_text", false); + std::vector elements; // Temporary vector to hold unsorted elements + std::string score_label = is_tei_format ? "score" : "relevance_score"; + for (const auto & rank : ranks) { + int index = json_value(rank, "index", 0); + json elem = json{ + {"index", index}, + {score_label, json_value(rank, "score", 0.0)}, + }; + n_tokens += json_value(rank, "tokens_evaluated", 0); + if (return_text) { + elem["text"] = std::move(texts[index]); + } + elements.push_back(elem); + } + + std::sort(elements.begin(), elements.end(), [score_label](const json& a, const json& b) { + return json_value(a, score_label, 0.0) > json_value(b, score_label, 0.0); + }); + + elements.resize(std::min(top_n, (int)elements.size())); + json results = elements; + + if (is_tei_format) return results; + + json res = json{ + {"model", json_value(request, "model", model_name)}, + {"object", "list"}, + {"usage", json{ + {"prompt_tokens", n_tokens}, + {"total_tokens", n_tokens} + }}, + {"results", results} + }; + + return res; +} + + +// +// other utils +// + +std::vector get_token_probabilities(llama_context * ctx, int idx, size_t n_top) { + std::vector cur; + + const auto * logits = llama_get_logits_ith(ctx, idx); + const llama_token * sampled_ids = llama_get_sampled_candidates_ith(ctx, idx); + + const int n_logits = llama_get_sampled_logits_count_ith(ctx, idx); + + cur.resize(n_logits); + if (sampled_ids) { + for (int i = 0; i < n_logits; i++) { + cur[i] = llama_token_data{sampled_ids[i], logits[i], 0.0f}; + } + } else { + for (llama_token token_id = 0; token_id < n_logits; token_id++) { + cur[token_id] = llama_token_data{token_id, logits[token_id], 0.0f}; + } + } + + // sort tokens by logits (partial: only the leading `n_top` need ordering) + if (n_top > cur.size()) { + n_top = cur.size(); + } + if (n_top > 0) { + std::partial_sort(cur.begin(), cur.begin() + n_top, cur.end(), + [](const llama_token_data & a, const llama_token_data & b) { + return a.logit > b.logit; + }); + } + + // apply softmax + float max_l = -std::numeric_limits::infinity(); + if (n_top > 0) { + max_l = cur[0].logit; // partial_sort guarantees the absolute maximum is at index 0 + } else { + for (const auto & t : cur) { + max_l = std::max(max_l, t.logit); + } + } + float cum_sum = 0.0f; + for (auto & t : cur) { + float p = expf(t.logit - max_l); + t.p = p; + cum_sum += p; + } + for (auto & t : cur) { + t.p /= cum_sum; + } + + return cur; +} + +std::string safe_json_to_str(const json & data) { + return data.dump(-1, ' ', false, json::error_handler_t::replace); +} + +// TODO: reuse llama_detokenize +template +static std::string tokens_to_str(const llama_vocab * ctx, Iter begin, Iter end) { + std::string ret; + for (; begin != end; ++begin) { + ret += common_token_to_piece(ctx, *begin); + } + + return ret; +} + +std::string tokens_to_str(llama_context * ctx, const llama_tokens & tokens) { + auto model = llama_get_model(ctx); + return tokens_to_str(llama_model_get_vocab(model), tokens.begin(), tokens.end()); +} + +std::string tokens_to_str(const llama_vocab * vocab, const llama_tokens & tokens) { + return tokens_to_str(vocab, tokens.begin(), tokens.end()); +} + +// format incomplete utf-8 multibyte character for output +std::string tokens_to_output_formatted_string(const llama_context * ctx, const llama_token token) { + std::string out = token == LLAMA_TOKEN_NULL ? "" : common_token_to_piece(ctx, token); + + // if the size is 1 and first bit is 1, meaning it's a partial character + // (size > 1 meaning it's already a known token) + if (out.size() == 1 && (out[0] & 0x80) == 0x80) { + std::stringstream ss; + ss << std::hex << (out[0] & 0xff); + std::string res(ss.str()); + out = "byte: \\x" + res; + } + + return out; +} + +// format server-sent event (SSE), return the formatted string to send +// note: if data is a json array, it will be sent as multiple events, one per item +std::string format_oai_sse(const json & data) { + std::ostringstream ss; + auto send_single = [&ss](const json & data) { + ss << "data: " << + safe_json_to_str(data) << + "\n\n"; // required by RFC 8895 - A message is terminated by a blank line (two line terminators in a row). + }; + + if (data.is_array()) { + for (const auto & item : data) { + send_single(item); + } + } else { + send_single(data); + } + + return ss.str(); +} + +std::string format_oai_resp_sse(const json & data) { + std::ostringstream ss; + auto send_single = [&ss](const json & event_obj) { + ss << "event: " << event_obj.at("event").get() << "\n"; + ss << "data: " << safe_json_to_str(event_obj.at("data")) << "\n\n"; + }; + + if (data.is_array()) { + for (const auto & item : data) { + send_single(item); + } + } else { + send_single(data); + } + + return ss.str(); +} + +std::string format_anthropic_sse(const json & data) { + std::ostringstream ss; + + auto send_event = [&ss](const json & event_obj) { + if (event_obj.contains("event") && event_obj.contains("data")) { + ss << "event: " << event_obj.at("event").get() << "\n"; + ss << "data: " << safe_json_to_str(event_obj.at("data")) << "\n\n"; + } else { + ss << "data: " << safe_json_to_str(event_obj) << "\n\n"; + } + }; + + if (data.is_array()) { + for (const auto & event : data) { + send_event(event); + } + } else { + send_event(data); + } + + return ss.str(); +} + +bool is_valid_utf8(const std::string & str) { + const unsigned char* bytes = reinterpret_cast(str.data()); + const unsigned char* end = bytes + str.length(); + + while (bytes < end) { + if (*bytes <= 0x7F) { + // 1-byte sequence (0xxxxxxx) + bytes++; + } else if ((*bytes & 0xE0) == 0xC0) { + // 2-byte sequence (110xxxxx 10xxxxxx) + if (end - bytes < 2 || (bytes[1] & 0xC0) != 0x80) + return false; + bytes += 2; + } else if ((*bytes & 0xF0) == 0xE0) { + // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx) + if (end - bytes < 3 || (bytes[1] & 0xC0) != 0x80 || (bytes[2] & 0xC0) != 0x80) + return false; + bytes += 3; + } else if ((*bytes & 0xF8) == 0xF0) { + // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx) + if (end - bytes < 4 || (bytes[1] & 0xC0) != 0x80 || + (bytes[2] & 0xC0) != 0x80 || (bytes[3] & 0xC0) != 0x80) + return false; + bytes += 4; + } else { + // Invalid UTF-8 lead byte + return false; + } + } + + return true; +} + +llama_tokens format_prompt_infill( + const llama_vocab * vocab, + const json & input_prefix, + const json & input_suffix, + const json & input_extra, + const int n_batch, + const int n_predict, + const int n_ctx, + const bool spm_infill, + const llama_tokens & tokens_prompt + ) { + // TODO: optimize this block by reducing memory allocations and movement + + // use FIM repo-level pattern: + // ref: https://arxiv.org/pdf/2409.12186 + // + // [FIM_REP]myproject + // [FIM_SEP]filename0 + // extra chunk 0 + // [FIM_SEP]filename1 + // extra chunk 1 + // ... + // [FIM_SEP]filename + // [FIM_PRE]prefix[FIM_SUF]suffix[FIM_MID]prompt + // + llama_tokens extra_tokens; + extra_tokens.reserve(n_ctx); + + auto tokens_prefix = tokenize_mixed(vocab, input_prefix, false, false); + auto tokens_suffix = tokenize_mixed(vocab, input_suffix, false, false); + + if (llama_vocab_fim_rep(vocab) != LLAMA_TOKEN_NULL) { + // TODO: make project name an input + static const auto k_fim_repo = common_tokenize(vocab, "myproject\n", false, false); + + extra_tokens.push_back(llama_vocab_fim_rep(vocab)); + extra_tokens.insert(extra_tokens.end(), k_fim_repo.begin(), k_fim_repo.end()); + } + for (const auto & chunk : input_extra) { + // { "text": string, "filename": string } + const std::string text = json_value(chunk, "text", std::string()); + const std::string filename = json_value(chunk, "filename", std::string("tmp")); + + if (llama_vocab_fim_sep(vocab) != LLAMA_TOKEN_NULL) { + const auto k_fim_file = common_tokenize(vocab, filename + "\n", false, false); + + extra_tokens.insert(extra_tokens.end(), llama_vocab_fim_sep(vocab)); + extra_tokens.insert(extra_tokens.end(), k_fim_file.begin(), k_fim_file.end()); + } else { + // chunk separator in binary form to avoid confusing the AI + static const char k_chunk_prefix_str[] = {0x0a, 0x0a, 0x2d, 0x2d, 0x2d, 0x20, 0x73, 0x6e, 0x69, 0x70, 0x70, 0x65, 0x74, 0x20, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x00}; + static const auto k_chunk_prefix_tokens = common_tokenize(vocab, k_chunk_prefix_str, false, false); + + extra_tokens.insert(extra_tokens.end(), k_chunk_prefix_tokens.begin(), k_chunk_prefix_tokens.end()); + } + + const auto chunk_tokens = common_tokenize(vocab, text, false, false); + extra_tokens.insert(extra_tokens.end(), chunk_tokens.begin(), chunk_tokens.end()); + } + + if (llama_vocab_fim_sep(vocab) != LLAMA_TOKEN_NULL) { + // TODO: current filename + static const auto k_fim_file = common_tokenize(vocab, "filename\n", false, false); + + extra_tokens.insert(extra_tokens.end(), llama_vocab_fim_sep(vocab)); + extra_tokens.insert(extra_tokens.end(), k_fim_file.begin(), k_fim_file.end()); + } + + // for now pick FIM context to fit in a batch (ratio prefix:suffix = 3:1, TODO: configurable?) + const int n_prefix_take = std::min(tokens_prefix.size(), 3*(n_batch/4)); + const int n_suffix_take = std::min(tokens_suffix.size(), std::max(0, (n_batch/4) - (2 + tokens_prompt.size()))); + + SRV_DBG("n_prefix_take = %d, n_suffix_take = %d, total = %d\n", n_prefix_take, n_suffix_take, (n_prefix_take + n_suffix_take)); + + // fill the rest of the context with extra chunks + const int n_extra_take = std::min(std::max(0, n_ctx - (n_batch) - 2*n_predict), extra_tokens.size()); + + tokens_prefix.erase(tokens_prefix.begin(), tokens_prefix.begin() + tokens_prefix.size() - n_prefix_take); + tokens_suffix.resize(n_suffix_take); + + tokens_prefix.insert(tokens_prefix.begin(), llama_vocab_fim_pre(vocab)); + tokens_prefix.insert(tokens_prefix.end(), tokens_prompt.begin(), tokens_prompt.end()); + tokens_suffix.insert(tokens_suffix.begin(), llama_vocab_fim_suf(vocab)); + + auto embd_inp = spm_infill ? tokens_suffix : tokens_prefix; + auto embd_end = spm_infill ? tokens_prefix : tokens_suffix; + + if (llama_vocab_get_add_bos(vocab)) { + embd_inp.insert(embd_inp.begin(), llama_vocab_bos(vocab)); + } + + SRV_DBG("extra: n_ctx = %d, n_extra_take = %d, n_extra = %d\n", n_ctx, n_extra_take, (int) extra_tokens.size()); + + // put the extra context before the FIM prefix + embd_inp.insert(embd_inp.begin(), extra_tokens.end() - n_extra_take, extra_tokens.end()); + + embd_inp.insert(embd_inp.end(), embd_end.begin(), embd_end.end()); + embd_inp.push_back(llama_vocab_fim_mid(vocab)); + + return embd_inp; +} + +server_tokens format_prompt_rerank( + const struct llama_model * model, + const struct llama_vocab * vocab, + mtmd_context * mctx, + const std::string & query, + const std::string & doc) { + server_tokens result = {}; + + const char * rerank_prompt = llama_model_chat_template(model, "rerank"); + + if (rerank_prompt != nullptr) { + std::string prompt = rerank_prompt; + string_replace_all(prompt, "{query}" , query); + string_replace_all(prompt, "{document}", doc ); + server_tokens tokens = tokenize_input_subprompt(vocab, mctx, prompt, false, true); + result.push_back(tokens); + } else { + // Get EOS token - use SEP token as fallback if EOS is not available + server_tokens query_tokens = tokenize_input_subprompt(vocab, mctx, query, false, false); + server_tokens doc_tokens = tokenize_input_subprompt(vocab, mctx, doc, false, false); + llama_token eos_token = llama_vocab_eos(vocab); + if (eos_token == LLAMA_TOKEN_NULL) { + eos_token = llama_vocab_sep(vocab); + } + + if (llama_vocab_get_add_bos(vocab)) { + result.push_back(llama_vocab_bos(vocab)); + } + result.push_back(query_tokens); + if (llama_vocab_get_add_eos(vocab)) { + result.push_back(eos_token); + } + if (llama_vocab_get_add_sep(vocab)) { + result.push_back(llama_vocab_sep(vocab)); + } + result.push_back(doc_tokens); + if (llama_vocab_get_add_eos(vocab)) { + result.push_back(eos_token); + } + } + + return result; +} diff --git a/tools/server/server-common.h b/tools/server/server-common.h new file mode 100644 index 0000000000000000000000000000000000000000..6ef797ebb4730a064b040093d8ad6ce8ae2358a7 --- /dev/null +++ b/tools/server/server-common.h @@ -0,0 +1,448 @@ +#pragma once + +#include "common.h" +#include "log.h" +#include "llama.h" +#include "chat.h" +#include "mtmd.h" + +#define JSON_ASSERT GGML_ASSERT +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using json = nlohmann::ordered_json; + +#define SLT_DBG(slot, fmt, ...) LOG_DBG("slot %12.*s: id %2d | task %d | " fmt, 12, __func__, (slot).id, ((slot).task ? (slot).task->id : -1), __VA_ARGS__) +#define SLT_TRC(slot, fmt, ...) LOG_TRC("slot %12.*s: id %2d | task %d | " fmt, 12, __func__, (slot).id, ((slot).task ? (slot).task->id : -1), __VA_ARGS__) +#define SLT_INF(slot, fmt, ...) LOG_INF("slot %12.*s: id %2d | task %d | " fmt, 12, __func__, (slot).id, ((slot).task ? (slot).task->id : -1), __VA_ARGS__) +#define SLT_WRN(slot, fmt, ...) LOG_WRN("slot %12.*s: id %2d | task %d | " fmt, 12, __func__, (slot).id, ((slot).task ? (slot).task->id : -1), __VA_ARGS__) +#define SLT_ERR(slot, fmt, ...) LOG_ERR("slot %12.*s: id %2d | task %d | " fmt, 12, __func__, (slot).id, ((slot).task ? (slot).task->id : -1), __VA_ARGS__) +#define SLT_CNT(slot, fmt, ...) LOG_CNT("" fmt, __VA_ARGS__) + +#define SRV_DBG(fmt, ...) LOG_DBG("srv %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define SRV_TRC(fmt, ...) LOG_TRC("srv %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define SRV_INF(fmt, ...) LOG_INF("srv %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define SRV_WRN(fmt, ...) LOG_WRN("srv %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define SRV_ERR(fmt, ...) LOG_ERR("srv %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define SRV_CNT(fmt, ...) LOG_CNT("" fmt, __VA_ARGS__) + +using raw_buffer = std::vector; + +template +static T json_value(const json & body, const std::string & key, const T & default_value) { + // Fallback null to default value + if (body.contains(key) && !body.at(key).is_null()) { + try { + return body.at(key); + } catch (NLOHMANN_JSON_NAMESPACE::detail::type_error const & err) { + LOG_WRN("Wrong type supplied for parameter '%s'. Expected '%s', using default value: %s\n", key.c_str(), json(default_value).type_name(), err.what()); + return default_value; + } + } else { + return default_value; + } +} + +// https://community.openai.com/t/openai-chat-list-of-error-codes-and-types/357791/11 +enum error_type { + ERROR_TYPE_INVALID_REQUEST, + ERROR_TYPE_AUTHENTICATION, + ERROR_TYPE_SERVER, + ERROR_TYPE_NOT_FOUND, + ERROR_TYPE_PERMISSION, + ERROR_TYPE_UNAVAILABLE, // custom error + ERROR_TYPE_NOT_SUPPORTED, // custom error + ERROR_TYPE_EXCEED_CONTEXT_SIZE, // custom error +}; + +// thin wrapper around common_grammar_trigger with (de)serialization functions +struct server_grammar_trigger { + common_grammar_trigger value; + + server_grammar_trigger() = default; + server_grammar_trigger(const common_grammar_trigger & value) : value(value) {} + server_grammar_trigger(const json & in) { + value.type = (common_grammar_trigger_type) in.at("type").get(); + value.value = in.at("value").get(); + if (value.type == COMMON_GRAMMAR_TRIGGER_TYPE_TOKEN) { + value.token = (llama_token) in.at("token").get(); + } + } + + json to_json() const { + json out { + {"type", (int) value.type}, + {"value", value.value}, + }; + if (value.type == COMMON_GRAMMAR_TRIGGER_TYPE_TOKEN) { + out["token"] = (int) value.token; + } + return out; + } +}; + +json format_error_response(const std::string & message, const enum error_type type); + +// +// random string / id +// + +std::string random_string(); +std::string gen_chatcmplid(); +std::string gen_tool_call_id(); + +// get a random marker; note: each time the server restarts, the marker will be different +const char * get_media_marker(); + +// +// lora utils +// + +// check whether the given lora set has only aloras activated (empty => false) +bool lora_all_alora(const std::vector & loras); + +// if the two sets of loras are different, they require a cache clear unless the +// change is only from aloras to aloras. +bool lora_should_clear_cache( + const std::vector & current, + const std::vector & next); + +std::map parse_lora_request(const json & data); + +bool are_lora_equal( + const std::vector & l1, + const std::vector & l2); + +// get the ids of all enabled loras +std::vector lora_get_enabled_ids(const std::vector & loras); + +// +// server_tokens +// + +/** + * server_tokens is a helper to manage the input tokens and image for the server. + * it is made this way to simplify the logic of KV cache management. + */ +struct server_tokens { + bool has_mtmd = false; + +private: // disallow accessing these members directly, risking out-of-sync + + // map a **start** index in tokens to the image chunk + // note: the order need to be in-sync with tokens + std::map map_idx_to_media; + + // list of tokens + // if the token is LLAMA_TOKEN_NULL, it indicates that this position is occupied by media chunk + // otherwise, it is a normal text token + // note: a non-text chunk can occupy multiple tokens (aka memory cells) in the token list + // note(2): for M-RoPE, an image can occupy different number of pos; do not assume 1-to-1 mapping tokens <-> pos + llama_tokens tokens; + + // for ex. with input of 5 text tokens and 2 images (each image occupies 3 tokens and 2 pos): + // [0] [1] [2] [3] [4] [img0] [img0] [img0] [img1] [img1] [img1] + // idx 0 1 2 3 4 5 6 7 8 9 10 + // pos 0 1 2 3 4 5 5 5 7 7 7 + // map_idx_to_media will contain: {5, img0}, {8, img1} + +public: + server_tokens() = default; + ~server_tokens() = default; + + // Prevent copying + // TODO: server_tokens should be copyable - remove this: + server_tokens(const server_tokens&) = delete; + server_tokens& operator=(const server_tokens&) = delete; + + // Allow moving (usually implicitly generated if members are movable) + server_tokens(server_tokens&&) = default; + server_tokens& operator=(server_tokens&&) = default; + + // Allow accessing elements using [] operator + llama_token operator[](size_t index) { return tokens[index]; } + const llama_token& operator[](size_t index) const { return tokens[index]; } + + server_tokens(mtmd::input_chunks & mtmd_chunks, bool has_mtmd); + server_tokens(const llama_tokens & tokens, bool has_mtmd); + + // for debugging + std::string str() const; + + // the next position after n_tokens. if n_tokens < 0, return the next position after all tokens. + llama_pos pos_next(int64_t n_tokens = -1) const; + + // number of tokens with position < max_pos + size_t size_up_to_pos(llama_pos max_pos) const; + + const mtmd::input_chunk_ptr & find_chunk(size_t idx) const; + + // find next media chunk after idx + // returns a pair of pointer to the chunk (nullptr if not found) and its start index in tokens + std::pair find_next_media_chunk(size_t idx) const; + + void push_back(llama_token tok); + + // will create a copy of the chunk if it contains non-text data + void push_back(const mtmd_input_chunk * chunk); + + // appends server tokens, updates the media map. copies media chunks. + void push_back(server_tokens & tokens); + + // for compatibility with context shift and prompt truncation + void insert(const llama_tokens & inp_tokens); + + // for compatibility with speculative decoding, ctx shift, slot save/load + const llama_tokens & get_tokens() const; + + llama_tokens get_text_tokens() const; + + // for compatibility with speculative decoding + void set_token(llama_pos pos, llama_token id); + + size_t size() const { return tokens.size(); } + + bool empty() const { return tokens.empty(); } + + // true if the sequence actually contains image/audio chunks. + bool has_media() const { return !map_idx_to_media.empty(); } + + void clear() { + map_idx_to_media.clear(); + tokens.clear(); + } + + void keep_first(size_t n); + + std::string detokenize(const llama_context * ctx, bool special) const; + + size_t get_common_prefix(const server_tokens & b) const; + + // split the tokens into message spans, skipping over media chunks + common_chat_msg_spans find_message_spans(const common_chat_msg_delimiters & delims) const; + + // make sure all text tokens are within the vocab range + bool validate(const struct llama_context * ctx) const; + + server_tokens clone() const; +}; + + +// +// tokenizer and input processing utils +// + +bool json_is_array_of_numbers(const json & data); + +// is array having BOTH numbers & strings? +bool json_is_array_of_mixed_numbers_strings(const json & data); + +// does array have any individual integers/tokens? +bool json_is_array_and_contains_numbers(const json & data); + +// get value by path(key1 / key2) +json json_get_nested_values(const std::vector & paths, const json & js); + +/** + * this handles 2 cases: + * - only string, example: "string" + * - mixed string and tokens, example: [12, 34, "string", 56, 78] + */ +llama_tokens tokenize_mixed(const llama_vocab * vocab, const json & json_prompt, bool add_special, bool parse_special); + +// return the last index of character that can form a valid string +// if the last character is potentially cut in half, return the index before the cut +// if validate_utf8(text) == text.size(), then the whole text is valid utf8 +size_t validate_utf8(const std::string& text); + +// process mtmd prompt, return the server_tokens containing both text tokens and media chunks +// if is_placeholder is true, the media chunk will be treated as placeholder for counting tokens; the output tokens are not usable for actual inference (e.g. for submitting a task to server_queue) +server_tokens process_mtmd_prompt(mtmd_context * mctx, const std::string & prompt, const std::vector & files, bool is_placeholder = false); + +/** + * break the input "prompt" object into multiple prompt if needed, then tokenize them + * this supports these cases: + * - "prompt": "string" + * - "prompt": [12, 34, 56] + * - "prompt": [12, 34, "string", 56, 78] + * - "prompt": { "prompt_string": "string", "multimodal_data": [ "base64" ] } + * and multiple prompts (multi-tasks): + * - "prompt": ["string1", "string2"] + * - "prompt": ["string1", [12, 34, 56]] + * - "prompt": [[12, 34, 56], [78, 90, 12]] + * - "prompt": [[12, 34, "string", 56, 78], [12, 34, 56], { "prompt_string": "string", "multimodal_data": [ "base64" ]}] + */ +std::vector tokenize_input_prompts( + const llama_vocab * vocab, + mtmd_context * mctx, + const json & json_prompt, + bool add_special, + bool parse_special); + +// +// OAI utils +// + +// global server parameters for chat formatting / parsing +struct server_chat_params { + bool use_jinja; + bool prefill_assistant; + common_reasoning_format reasoning_format; + std::map chat_template_kwargs; // mapping key --> json value + common_chat_templates_ptr tmpls; + bool allow_image; + bool allow_audio; + bool allow_video; + bool enable_thinking = true; + int reasoning_budget = -1; + std::string reasoning_budget_message; + std::string media_path; + bool force_pure_content = false; +}; + +// used by /completions endpoint +json oaicompat_completion_params_parse(const json & body); + +// used by /chat/completions endpoint +json oaicompat_chat_params_parse( + json & body, /* openai api json semantics */ + const server_chat_params & opt, + std::vector & out_files); + +// TODO: move it to server-task.cpp +json format_embeddings_response_oaicompat( + const json & request, + const std::string & model_name, + const json & embeddings, + bool use_base64 = false); + +// TODO: move it to server-task.cpp +json format_response_rerank( + const json & request, + const std::string & model_name, + const json & ranks, + bool is_tei_format, + std::vector & texts, + int top_n); + +// +// other utils +// + +std::vector get_token_probabilities(llama_context * ctx, int idx, size_t n_top); + +std::string safe_json_to_str(const json & data); + +std::string tokens_to_str(llama_context * ctx, const llama_tokens & tokens); +std::string tokens_to_str(const llama_vocab * vocab, const llama_tokens & tokens); + +// format incomplete utf-8 multibyte character for output +std::string tokens_to_output_formatted_string(const llama_context * ctx, const llama_token token); + +// format server-sent event (SSE), return the formatted string to send +// note: if data is a json array, it will be sent as multiple events, one per item +std::string format_oai_sse(const json & data); + +std::string format_oai_resp_sse(const json & data); + +// format Anthropic-style SSE with event types +std::string format_anthropic_sse(const json & data); + +bool is_valid_utf8(const std::string & str); + +// +// formatting output responses +// TODO: move these to server-task.cpp +// + +llama_tokens format_prompt_infill( + const llama_vocab * vocab, + const json & input_prefix, + const json & input_suffix, + const json & input_extra, + const int n_batch, + const int n_predict, + const int n_ctx, + const bool spm_infill, + const llama_tokens & tokens_prompt); + +// format rerank task: [BOS]query[EOS][SEP]doc[EOS]. +server_tokens format_prompt_rerank( + const struct llama_model * model, + const struct llama_vocab * vocab, + mtmd_context * mctx, + const std::string & query, + const std::string & doc); + +// simple implementation of a pipe +// used for streaming data between threads +template +struct server_pipe { + std::mutex mutex; + std::condition_variable cv; + std::queue queue; + std::atomic writer_closed{false}; + std::atomic reader_closed{false}; + + // 0 = unbounded (default) + // > 0, write() drops the oldest item once the queue is full + size_t max_size = 0; + + void close_write() { + writer_closed.store(true, std::memory_order_relaxed); + cv.notify_all(); + } + + void close_read() { + reader_closed.store(true, std::memory_order_relaxed); + cv.notify_all(); + } + + // close_on_stop = true: should_stop means the reader is gone for good, so the writer is told the pipe is broken. + // close_on_stop = false: should_stop is a per-read deadline and further reads still come, so the pipe stays usable. + bool read(T & output, const std::function & should_stop, bool close_on_stop = true) { + std::unique_lock lk(mutex); + constexpr auto poll_interval = std::chrono::milliseconds(500); + while (true) { + if (!queue.empty()) { + output = std::move(queue.front()); + queue.pop(); + return true; + } + if (writer_closed.load()) { + return false; // clean EOF + } + if (should_stop && should_stop()) { // a null should_stop means "never stop" + if (close_on_stop) { + close_read(); // signal broken pipe to writer + } + return false; // cancelled / deadline reached + } + cv.wait_for(lk, poll_interval); + } + } + + bool write(T && data) { + std::lock_guard lk(mutex); + if (reader_closed.load()) { + return false; // broken pipe + } + if (max_size > 0) { + while (queue.size() >= max_size) { + queue.pop(); // drop oldest to stay bounded + } + } + queue.push(std::move(data)); + cv.notify_one(); + return true; + } +}; diff --git a/tools/server/server-context.cpp b/tools/server/server-context.cpp new file mode 100644 index 0000000000000000000000000000000000000000..86e53b3708601e06775afd9e712c400c5701d5f7 --- /dev/null +++ b/tools/server/server-context.cpp @@ -0,0 +1,5459 @@ +#include "server-context.h" +#include "server-chat.h" +#include "server-common.h" +#include "server-http.h" +#include "server-task.h" +#include "server-queue.h" +#include "server-schema.h" +#include "server-stream.h" + +#include "build-info.h" +#include "common.h" +#include "fit.h" +#include "llama.h" +#include "log.h" +#include "sampling.h" +#include "speculative.h" +#include "mtmd.h" +#include "mtmd-helper.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +// fix problem with std::min and std::max +#if defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#ifndef NOMINMAX +# define NOMINMAX +#endif +#include +#endif + +using json = nlohmann::ordered_json; + +constexpr int HTTP_POLLING_SECONDS = 1; + +static common_speculative_output_limits server_output_limits(const common_params & params) { + if (params.embedding || + (params.pooling_type != LLAMA_POOLING_TYPE_UNSPECIFIED && params.pooling_type != LLAMA_POOLING_TYPE_NONE)) { + return { params.n_batch, 1 }; + } + + auto result = common_speculative_get_output_limits( + params.n_batch, params.n_parallel, common_speculative_n_max(¶ms.speculative)); + + result.total = std::max(1, result.total); + result.per_seq = std::max(1, result.per_seq); + return result; +} + +// state diagram: https://github.com/ggml-org/llama.cpp/pull/9283 +enum slot_state { + SLOT_STATE_IDLE, + SLOT_STATE_WAIT_OTHER, // after assigning a task, but waiting for parent slot to process prompt + SLOT_STATE_STARTED, // after assigning a task and about to process prompt + SLOT_STATE_PROCESSING_PROMPT, + SLOT_STATE_DONE_PROMPT, + SLOT_STATE_GENERATING, +}; + +struct server_slot; // forward declaration + +struct server_batch { + llama_batch batch; + bool batch_rendered = false; + + struct token { + int32_t id_slot; + llama_token token; + llama_pos pos; + bool output; + }; + std::vector tokens; + int32_t n_tokens_alloc = 0; + int32_t n_embd = 0; + + // track if given slot can be batched with slots already in the batch + server_slot * slot_batched = nullptr; + + // in embd mode, we temporarily swap out the tokens arr and restore it on clear() + bool has_embd = false; + llama_token * tokens_ptr = nullptr; + std::vector embd; + + float alora_scale = -1.0f; + size_t alora_disabled_id = 0; + + server_batch() { + batch.pos = nullptr; // sentinel: uninitialized batch + } + + ~server_batch() { + if (batch.pos != nullptr) { + clear(); + llama_batch_free(batch); + } + } + + void init(int32_t n_tokens_alloc, int32_t n_embd) { + this->n_tokens_alloc = n_tokens_alloc; + this->n_embd = n_embd; + batch = llama_batch_init(n_tokens_alloc, 0, 1); + tokens_ptr = batch.token; + tokens.reserve(n_tokens_alloc); + } + + bool add(int32_t id_slot, llama_token token, llama_pos pos, bool output) { + GGML_ASSERT(!has_embd); // cannot mix tokens + embd in same batch + GGML_ASSERT(batch.pos != nullptr); + if ((int32_t)tokens.size() >= n_tokens_alloc) { + return false; + } + tokens.push_back({ id_slot, token, pos, output }); + return true; + } + + bool add(int32_t id_slot, const std::vector & embd_in, llama_pos pos, bool output) { + GGML_ASSERT(batch.pos != nullptr); + if ((int32_t)tokens.size() >= n_tokens_alloc) { + return false; + } + tokens.push_back({ id_slot, LLAMA_TOKEN_NULL, pos, output }); + has_embd = true; + embd.insert(embd.end(), embd_in.begin(), embd_in.end()); + return true; + } + + void clear() { + tokens.clear(); + embd.clear(); + common_batch_clear(batch); + slot_batched = nullptr; + alora_scale = -1.0f; + alora_disabled_id = 0; + batch_rendered = false; + has_embd = false; + if (batch.token == nullptr) { + batch.token = tokens_ptr; + batch.embd = nullptr; + } + } + + int32_t size() const { + return (int32_t)tokens.size(); + } + + void set_output(int32_t idx, bool output) { + GGML_ASSERT(idx >= 0 && idx < (int32_t)tokens.size()); + tokens[idx].output = output; + } + + void render() { + GGML_ASSERT(!batch_rendered); + GGML_ASSERT(batch.pos != nullptr); + common_batch_clear(batch); + for (int32_t i = 0; i < size(); i++) { + const auto & t = tokens[i]; + common_batch_add(batch, t.token, t.pos, { t.id_slot }, t.output); + } + if (has_embd) { + batch.token = nullptr; // will be restored on clear() + batch.embd = embd.data(); + } + batch_rendered = true; + } + + llama_batch get_view(int32_t off, int32_t n_tokens) const { + GGML_ASSERT(batch.pos != nullptr); + GGML_ASSERT(batch_rendered); + GGML_ASSERT(off >= 0 && off < size()); + GGML_ASSERT(n_tokens > 0 && off + n_tokens <= size()); + + auto * token = batch.token ? batch.token + off : nullptr; + auto * embd = batch.embd ? batch.embd + off * n_embd : nullptr; + + llama_batch view = { + n_tokens, + token, + embd, + batch.pos + off, + batch.n_seq_id + off, + batch.seq_id + off, + batch.logits + off, + }; + + return view; + } +}; + +struct server_slot { + int id; + + llama_context * ctx_tgt = nullptr; + llama_context * ctx_dft = nullptr; + + common_memory mem; + + // multimodal + mtmd_context * mctx = nullptr; + mtmd::batch_ptr mbatch = nullptr; + + // speculative decoding + common_speculative * spec; + + llama_tokens spec_draft; + llama_tokens spec_prompt; + std::vector spec_i_batch; + common_prompt_checkpoint spec_ckpt; + bool spec_is_replay = false; + + // TODO: move members that belong to the task (such as `generated_text`, `has_new_line`) to task_results_state + // see https://github.com/ggml-org/llama.cpp/pull/18283#issuecomment-3710175837 + std::unique_ptr task; + std::unique_ptr task_prev; // used for debugging + + // used to determine the slot that has been used the longest + int64_t t_last_used = -1; + + // generation props + int32_t n_ctx = 0; // context size per slot + int32_t n_keep = 0; + int32_t n_decoded = 0; + int32_t n_remaining = -1; + int32_t i_batch = -1; + + int32_t n_prompt_tokens_cache = 0; + int32_t n_prompt_tokens_processed = 0; + + size_t last_nl_pos = 0; + + std::string generated_text; + std::string debug_generated_text; + llama_tokens generated_tokens; + + std::vector generated_token_probs; + + bool has_next_token = true; + bool has_new_line = false; + bool truncated = false; + + stop_type stop; + + std::string stopping_word; + + // state + slot_state state = SLOT_STATE_IDLE; + + server_prompt prompt; + + bool prompt_save(server_prompt_cache & prompt_cache) const { + if (prompt.tokens.size() == 0) { + return false; + } + + const size_t cur_size_tgt = llama_state_seq_get_size_ext(ctx_tgt, id, LLAMA_STATE_SEQ_FLAGS_NONE); + const size_t cur_size_dft = ctx_dft ? llama_state_seq_get_size_ext(ctx_dft, id, LLAMA_STATE_SEQ_FLAGS_NONE) : 0; + + const size_t cur_size = cur_size_tgt + cur_size_dft; + + SRV_TRC(" - saving prompt with length %d, total state size = %.3f MiB (draft: %.3f MiB)\n", + (int) prompt.tokens.size(), cur_size / (1024.0 * 1024.0), cur_size_dft / (1024.0 * 1024.0)); + + auto * cur = prompt_cache.alloc(prompt, cur_size_tgt, cur_size_dft); + if (cur == nullptr) { + return false; + } + + llama_state_seq_get_data_ext(ctx_tgt, cur->data.main.data(), cur_size_tgt, id, LLAMA_STATE_SEQ_FLAGS_NONE); + if (ctx_dft) { + llama_state_seq_get_data_ext(ctx_dft, cur->data.drft.data(), cur_size_dft, id, LLAMA_STATE_SEQ_FLAGS_NONE); + } + + return true; + } + + bool prompt_load(server_prompt_cache & prompt_cache, const server_tokens & tokens) { + bool res = prompt_cache.load(prompt, tokens, ctx_tgt, ctx_dft, id); + if (!res) { + SLT_WRN(*this, "%s", "failed to load prompt from cache\n"); + } + + return res; + } + + void prompt_clear() { + SLT_TRC(*this, "clearing prompt with %zu tokens\n", prompt.tokens.size()); + + mem.seq_rm(id, -1, -1); + + prompt.clear(); + } + + std::vector lora; + int32_t alora_invocation_start = -1; + + // sampling + json json_schema; + + common_sampler_ptr smpl; + + llama_token sampled; // in speculative mode, this is the last accepted token + + // for TTS models, this is the embd generated from prev step, decode this to generate next hidden state + // corresponding to one token position (size = n_embd) + std::vector inp_embd; + + // stats + size_t n_sent_text = 0; // number of sent text character + + // TODO @ngxson : move all metrics to a sub-struct for clarity + int64_t t_start_process_prompt; + int64_t t_start_generation; + int64_t t_print_last = 0; + int32_t n_decoded_last = 0; + + double t_prompt_processing = 0.0; // ms + double t_token_generation = 0.0; // ms + + std::function callback_on_release; + + // Speculative decoding stats + int32_t n_draft_total = 0; // Total draft tokens generated + int32_t n_draft_accepted = 0; // Draft tokens actually accepted + int32_t n_draft_verif_steps = 0; // Total draft token verification steps by the target model + std::vector n_accepted_per_pos; // Accepted tokens per draft position + + void reset() { + SLT_DBG(*this, "%s", "\n"); + + spec_is_replay = false; + + n_prompt_tokens_cache = 0; + + last_nl_pos = 0; + generated_text = ""; + has_new_line = false; + truncated = false; + stop = STOP_TYPE_NONE; + stopping_word = ""; + n_sent_text = 0; + + if (can_speculate()) { + spec_draft.clear(); + spec_i_batch.clear(); + spec_ckpt.clear(); + } + generated_tokens.clear(); + generated_token_probs.clear(); + json_schema = json(); + + // clear speculative decoding stats + n_draft_total = 0; + n_draft_accepted = 0; + n_draft_verif_steps = 0; + n_accepted_per_pos.clear(); + + task_prev = std::move(task); + task.reset(); + + llama_set_sampler(ctx_tgt, id, nullptr); + + // clear alora start + alora_invocation_start = -1; + + // clear multimodal state + mbatch.reset(); + } + + void init_sampler() const { + common_sampler_reset(smpl.get()); + + if (!task->need_sampling()) { + return; + } + + const int64_t t_start = ggml_time_us(); + + int n_text = 0; + + for (int i = 0; i < (int) prompt.tokens.size(); i++) { + const llama_token id = prompt.tokens[i]; + + if (id != LLAMA_TOKEN_NULL) { + common_sampler_accept(smpl.get(), id, false); + n_text++; + } + } + + SLT_TRC(*this, "init sampler, took %0.2f ms, tokens: text = %d, total = %d\n", + (ggml_time_us() - t_start) / 1000.0, n_text, (int) prompt.tokens.size()); + } + + bool need_embd() const { + GGML_ASSERT(task); + return task->need_embd() || (spec && common_speculative_need_embd(spec)); + } + + bool need_embd_nextn() const { + GGML_ASSERT(task); + return spec && common_speculative_need_embd_nextn(spec); + } + + // if the context does not have a memory module then all embeddings have to be computed within a single ubatch + // also we cannot split if the pooling would require any past tokens + // (MTP supports splitting — uses task->need_embd() not need_embd()) + bool can_split() const { + GGML_ASSERT(task); + + return + !task->need_embd() || + (llama_get_memory(ctx_tgt) && llama_pooling_type(ctx_tgt) == LLAMA_POOLING_TYPE_LAST); + } + + bool can_batch_with(server_slot & other_slot) const { + GGML_ASSERT(task); + + return task->type == other_slot.task->type + && inp_embd.size() == other_slot.inp_embd.size() + && are_lora_equal(lora, other_slot.lora); + } + + bool has_budget(const common_params & global_params) { + GGML_ASSERT(task); + + if (task->params.n_predict == -1 && global_params.n_predict == -1) { + return true; // limitless + } + + n_remaining = -1; + + if (task->params.n_predict != -1) { + n_remaining = task->params.n_predict - n_decoded; + } else if (global_params.n_predict != -1) { + n_remaining = global_params.n_predict - n_decoded; + } + + return n_remaining > 0; // no budget + } + + bool is_processing() const { + return state != SLOT_STATE_IDLE; + } + + bool can_speculate() const { + return !!spec; + } + + void add_token(const completion_token_output & token) { + if (!is_processing()) { + SLT_WRN(*this, "%s", "slot is not processing\n"); + return; + } + + generated_token_probs.push_back(token); + } + + int get_n_draft_max() const { + GGML_ASSERT(task); + + if (!can_speculate()) { + return 0; + } + + // determine the max draft that fits the current slot state + // note: slot.prompt is not yet expanded with the `id` token sampled above + // also, need to leave space for 1 extra token to allow context shifts + int n_draft_max = n_ctx - prompt.n_tokens() - 2; + + if (n_remaining > 0) { + n_draft_max = std::min(n_draft_max, n_remaining - 1); + } + + SLT_DBG(*this, "max possible draft: %d\n", n_draft_max); + + return n_draft_max; + } + + // add sampled token of this slot to the batch, optionally add the speculative draft tokens if any + void handle_last_sampled_token(server_batch & batch) { + bool add_ok = true; + if (spec_draft.empty()) { + // no speculative decoding + i_batch = batch.size(); + + if (!inp_embd.empty()) { + add_ok &= batch.add(id, inp_embd, prompt.tokens.pos_next(), true); + } else { + add_ok &= batch.add(id, sampled, prompt.tokens.pos_next(), true); + } + + SLT_DBG(*this, "slot decode token, id=%d, n_ctx = %d, n_tokens = %d, truncated = %d\n", + sampled, n_ctx, prompt.n_tokens(), truncated); + } else { + SLT_DBG(*this, "generate_draft: id=%d, #tokens=%zu, #draft=%zu, pos_next=%d\n", + sampled, prompt.tokens.size(), spec_draft.size(), prompt.tokens.pos_next()); + + GGML_ASSERT(spec_i_batch.empty()); + + spec_i_batch.push_back(batch.size()); + for (size_t i = 0; i < spec_draft.size(); i++) { + spec_i_batch.push_back(batch.size() + i + 1); + } + + auto pos0 = prompt.tokens.pos_next(); + + add_ok &= batch.add(id, sampled, pos0++, true); + for (auto token : spec_draft) { + add_ok &= batch.add(this->id, token, pos0++, true); + } + } + + GGML_ASSERT(add_ok && "batch must be large enough to hold the sampled and draft tokens"); + + prompt.tokens.push_back(sampled); + prompt.tokens.insert(spec_draft); + } + + void release() { + if (is_processing()) { + GGML_ASSERT(task); + + SLT_INF(*this, "stop processing: n_tokens = %d, truncated = %d\n", prompt.n_tokens(), truncated); + + t_last_used = ggml_time_us(); + t_token_generation = (ggml_time_us() - t_start_generation) / 1e3; + + state = SLOT_STATE_IDLE; + + // do not keep context of the child slots - the parent's context is enough + if (task->is_child()) { + prompt_clear(); + } + + reset(); + + callback_on_release(id); + } + } + + result_timings get_timings() const { + result_timings timings; + timings.cache_n = n_prompt_tokens_cache; + + timings.prompt_n = n_prompt_tokens_processed; + timings.prompt_ms = t_prompt_processing; + timings.prompt_per_token_ms = t_prompt_processing / n_prompt_tokens_processed; + timings.prompt_per_second = 1e3 / t_prompt_processing * n_prompt_tokens_processed; + + timings.predicted_n = n_decoded; + timings.predicted_ms = t_token_generation; + timings.predicted_per_token_ms = t_token_generation / n_decoded; + timings.predicted_per_second = 1e3 / t_token_generation * n_decoded; + + // Add speculative metrics + if (n_draft_total > 0) { + timings.draft_n = n_draft_total; + timings.draft_n_accepted = n_draft_accepted; + } + + return timings; + } + + size_t find_stopping_strings(const std::string & text, const size_t last_token_size, bool is_full_stop) { + GGML_ASSERT(task); + + size_t stop_pos = std::string::npos; + + for (const std::string & word : task->params.antiprompt) { + size_t pos; + + if (is_full_stop) { + const size_t tmp = word.size() + last_token_size; + const size_t from_pos = text.size() > tmp ? text.size() - tmp : 0; + + pos = text.find(word, from_pos); + } else { + // otherwise, partial stop + pos = string_find_partial_stop(text, word); + } + + if (pos != std::string::npos && (stop_pos == std::string::npos || pos < stop_pos)) { + if (is_full_stop) { + stop = STOP_TYPE_WORD; + stopping_word = word; + has_next_token = false; + } + stop_pos = pos; + } + } + + return stop_pos; + } + + void print_timings_tg() { + if (n_decoded < 100) { + return; + } + + const int64_t t_now = ggml_time_us(); + + if (t_now - t_print_last < 3*1000*1000) { + return; + } + + const double n_gen_second = 1e3 / (t_token_generation) * (n_decoded); + const double n_gen_second_win = 1e6 / (t_now - t_print_last) * (n_decoded - n_decoded_last); + + t_print_last = t_now; + n_decoded_last = n_decoded; + + SLT_INF(*this, "n_decoded = %6d, tg = %6.2f t/s, tg_3s = %6.2f t/s\n", n_decoded, n_gen_second, n_gen_second_win); + } + + void print_timings_pp() const { + const double n_prompt_second = 1e3 / t_prompt_processing * n_prompt_tokens_processed; + const double f_progress = (float) prompt.n_tokens() / task->n_tokens(); + + if (t_prompt_processing < 3000.0) { + return; + } + + SLT_INF(*this, "prompt processing, n_tokens = %6d, progress = %.2f, t = %6.2f s / %.2f tokens per second\n", + n_prompt_tokens_processed, f_progress, t_prompt_processing / 1e3, n_prompt_second); + } + + void print_timings() const { + const double t_prompt = t_prompt_processing / n_prompt_tokens_processed; + const double n_prompt_second = 1e3 / t_prompt_processing * n_prompt_tokens_processed; + + const double t_gen = t_token_generation / n_decoded; + const double n_gen_second = 1e3 / t_token_generation * n_decoded; + + SLT_INF(*this, + "prompt eval time = %10.2f ms / %5d tokens (%8.2f ms per token, %8.2f tokens per second)\n", + t_prompt_processing, n_prompt_tokens_processed, t_prompt, n_prompt_second); + + SLT_INF(*this, + " eval time = %10.2f ms / %5d tokens (%8.2f ms per token, %8.2f tokens per second)\n", + t_token_generation, n_decoded, t_gen, n_gen_second); + + SLT_INF(*this, + " total time = %10.2f ms / %5d tokens\n", + t_prompt_processing + t_token_generation, n_prompt_tokens_processed + n_decoded); + + SLT_INF(*this, + " graphs reused = %10d\n", + llama_perf_context(ctx_tgt).n_reused); + + if (n_draft_total > 0) { + const float draft_ratio = (float) n_draft_accepted / n_draft_total; + const double mean_acc_len = n_draft_verif_steps > 0 ? 1.0 + (double) n_draft_accepted / (double) n_draft_verif_steps : 1.0; + + std::string acceptance_rates_per_pos; + if (n_draft_verif_steps > 0) { + for (size_t i = 0; i < n_accepted_per_pos.size(); ++i) { + if (i > 0) { + acceptance_rates_per_pos += ", "; + } + acceptance_rates_per_pos += string_format("%.3f", (double) n_accepted_per_pos[i] / (double) n_draft_verif_steps); + } + } + + SLT_INF(*this, + "draft acceptance = %0.5f (%5d accepted / %5d generated), mean len = %5.2f\n", + draft_ratio, n_draft_accepted, n_draft_total, mean_acc_len); + SLT_TRC(*this, + " acc per pos = (%s)\n", acceptance_rates_per_pos.c_str()); + } + + common_speculative_print_stats(spec); + } + + json to_json(bool only_metrics = false) const { + json res; + + res = { + {"id", id}, + {"n_ctx", n_ctx}, + {"speculative", can_speculate()}, + {"is_processing", is_processing()}, + }; + + const auto & ptask = task ? task : task_prev; + + if (ptask) { + res["id_task"] = ptask->id; + res["n_prompt_tokens"] = (int32_t) prompt.tokens.size(); + res["n_prompt_tokens_processed"] = n_prompt_tokens_processed; + res["n_prompt_tokens_cache"] = n_prompt_tokens_cache; + res["params"] = ptask->params.to_json(only_metrics); + res["next_token"] = { + { + {"has_next_token", has_next_token}, + {"has_new_line", has_new_line}, + {"n_remain", n_remaining}, + {"n_decoded", n_decoded}, + } + }; + + if (!only_metrics) { + res["prompt"] = ptask->tokens.detokenize(ctx_tgt, true); + res["generated"] = generated_text.empty() ? debug_generated_text : generated_text; + } + } + + return res; + } + + void copy_state_to(server_slot & other) const { + GGML_ASSERT(state == SLOT_STATE_DONE_PROMPT); + + mem.seq_rm(other.id, -1, -1); + mem.seq_cp(id, other.id, -1, -1); + + other.n_decoded = n_decoded; + other.n_remaining = n_remaining; + other.i_batch = i_batch; + + other.t_start_process_prompt = t_start_process_prompt; + other.t_prompt_processing = t_prompt_processing; + other.n_prompt_tokens_cache = n_prompt_tokens_cache; + other.n_prompt_tokens_processed = n_prompt_tokens_processed; + + other.prompt = prompt.clone(); + other.init_sampler(); + } + + // returns 0 on success + // caller need to update prompt.tokens after a successful call to keep track of the processing progress + int process_mtmd_chunk(size_t idx, size_t & n_tokens_out) { + GGML_ASSERT(mctx); + const auto & input_tokens = task->tokens; + const auto & chunk = input_tokens.find_chunk(idx); + int32_t res = 0; + + auto try_decode = [&]() -> int32_t { + if (mbatch) { + float * embd = mtmd_batch_get_output_embd(mbatch.get(), chunk.get()); + if (embd) { + void * cb_data = spec; + static auto cb = [](llama_batch batch, void * user_data) { + common_speculative * spec = static_cast(user_data); + if (!common_speculative_process(spec, batch)) { + return 1; + } + return 0; + }; + + llama_pos new_n_past; // unused for now + res = mtmd_helper_decode_image_chunk( + mctx, + ctx_tgt, + chunk.get(), + embd, + prompt.tokens.pos_next(), + id, + llama_n_batch(ctx_tgt), + &new_n_past, + cb, + cb_data + ); + if (res != 0) { + SLT_ERR(*this, "failed to decode mtmd chunk, idx = %zu, res = %d\n", idx, res); + return -1; + } + n_tokens_out = mtmd_input_chunk_get_n_tokens(chunk.get()); + return 0; // success + } + } + return 1; // (non-error) need to create & encode batch + }; + + // if the batch is already exist, try searching & encode + res = try_decode(); + if (res == 0) { + return 0; + } + if (res < 0) { + // fatal error + return res; + } + + // otherwise, the batch is either uninitialized or is used up + // we need to create & encode a new batch + mbatch.reset(mtmd_batch_init(mctx)); + res = mtmd_batch_add_chunk(mbatch.get(), chunk.get()); + GGML_ASSERT(res == 0); // we should never have an empty batch + + // try batching as much as possible + int n_added = 1; + size_t idx_cur = idx; + while (res == 0) { + auto [next_chunk, next_idx] = input_tokens.find_next_media_chunk(idx_cur); + if (next_chunk == nullptr) { + break; + } + res = mtmd_batch_add_chunk(mbatch.get(), next_chunk->get()); + n_added += (res == 0 ? 1 : 0); + idx_cur = next_idx; + SLT_DBG(*this, "try adding media chunk idx = %zu to batch, res = %d\n", next_idx, res); + // if res != 0, batch is full or chunk is not compatible -> this loop breaks + } + + // TODO @ngxson : move this log line to debug when it become more stable + SLT_TRC(*this, "encoding mtmd batch from idx = %zu, n_chunks = %d\n", idx, n_added); + + res = mtmd_batch_encode(mbatch.get()); + if (res != 0) { + SLT_ERR(*this, "failed to encode mtmd batch for chunk idx = %zu, res = %d\n", idx, res); + return -1; + } + + return try_decode(); + } +}; + + + +// +// server_metrics +// + +struct server_metrics { + int64_t t_start = 0; + + uint64_t n_prompt_tokens_processed_total = 0; + uint64_t t_prompt_processing_total = 0; + uint64_t n_tokens_predicted_total = 0; + uint64_t t_tokens_generation_total = 0; + + uint64_t n_tokens_max = 0; + + uint64_t n_prompt_tokens_processed = 0; + uint64_t t_prompt_processing = 0; + + uint64_t n_tokens_predicted = 0; + uint64_t t_tokens_generation = 0; + + uint64_t n_decode_total = 0; + uint64_t n_busy_slots_total = 0; + + uint64_t n_draft_tokens_total = 0; + uint64_t n_draft_accepted_total = 0; + uint64_t n_draft_verif_steps_total = 0; + std::vector n_accepted_per_pos_total; + + void init() { + t_start = ggml_time_us(); + } + + void on_prompt_eval(const server_slot & slot) { + n_prompt_tokens_processed_total += slot.n_prompt_tokens_processed; + n_prompt_tokens_processed += slot.n_prompt_tokens_processed; + t_prompt_processing += slot.t_prompt_processing; + t_prompt_processing_total += slot.t_prompt_processing; + + n_tokens_max = std::max(n_tokens_max, (uint64_t) slot.prompt.n_tokens()); + } + + void on_prediction(const server_slot & slot) { + n_tokens_predicted_total += slot.n_decoded; + n_tokens_predicted += slot.n_decoded; + t_tokens_generation += slot.t_token_generation; + t_tokens_generation_total += slot.t_token_generation; + + n_draft_tokens_total += slot.n_draft_total; + n_draft_accepted_total += slot.n_draft_accepted; + n_draft_verif_steps_total += slot.n_draft_verif_steps; + + if (n_accepted_per_pos_total.size() < slot.n_accepted_per_pos.size()) { + n_accepted_per_pos_total.resize(slot.n_accepted_per_pos.size(), 0); + } + for (size_t i = 0; i < slot.n_accepted_per_pos.size(); i++) { + n_accepted_per_pos_total[i] += slot.n_accepted_per_pos[i]; + } + } + + void on_decoded(const std::vector & slots) { + n_decode_total++; + for (const auto & slot : slots) { + if (slot.is_processing()) { + n_busy_slots_total++; + } + n_tokens_max = std::max(n_tokens_max, (uint64_t) slot.prompt.n_tokens()); + } + } + + void reset_bucket() { + n_prompt_tokens_processed = 0; + t_prompt_processing = 0; + n_tokens_predicted = 0; + t_tokens_generation = 0; + } +}; + + +// +// server_context_impl (private implementation) +// + +struct server_context_impl { + friend struct server_context; + +public: + // only use these pointers outside of this class: + // - when not in sleeping state + // - and, with thread-safe APIs (e.g., tokenizer calls) + llama_model * model_tgt = nullptr; + + mtmd_context * mctx = nullptr; + const llama_vocab * vocab = nullptr; + + server_queue queue_tasks; + server_response queue_results; + + // note: chat_params must not be refreshed upon existing sleeping state + server_chat_params chat_params; + + server_state_callback_t callback_state = [](server_state, json) -> void {}; + + server_context_impl() { + mtmd_helper_log_set(common_log_default_callback, nullptr); + } + + ~server_context_impl() { + if (!sleeping) { + // destroy() is already called when entering sleeping state + // we don't call it again here to avoid double free + destroy(); + } + } + +private: + // note: accessing these fields outside of this class is not thread-safe + // use server_context methods instead + + common_params params_base; + + // note: keep these alive - they determine the lifetime of the model, context, etc. + common_init_result_ptr llama_init; + + llama_context * ctx_tgt = nullptr; + + server_batch batch; + + llama_model * model_dft = nullptr; + llama_context * ctx_dft = nullptr; + + common_speculative_init_result_ptr spec_init; + + common_context_seq_rm_type ctx_tgt_seq_rm_type = COMMON_CONTEXT_SEQ_RM_TYPE_NO; + common_context_seq_rm_type ctx_dft_seq_rm_type = COMMON_CONTEXT_SEQ_RM_TYPE_NO; + + common_speculative_ptr spec; + + bool add_bos_token = true; + + int32_t n_ctx; // total context for all clients / slots + + // set to llama_model_n_swa(model) + // if swa_full is enabled, this is set to 0 to simulate a non-SWA model + int32_t n_swa; + + // slots / clients + std::vector slots; + + int trace = 0; + int slots_debug = 0; + int n_empty_consecutive = 0; + + std::unique_ptr prompt_cache; + + server_metrics metrics; + + json json_ui_settings = json::object(); + + // Necessary similarity of prompt for slot selection + float slot_prompt_similarity = 0.0f; + + std::string model_name; // name of the loaded model, to be used by API + std::set model_aliases; // additional names for the model + std::set model_tags; // informational tags + + bool sleeping = false; + + int64_t t_last_load_progress_ms = 0; + + void destroy() { + spec.reset(); + spec_init.reset(); + + ctx_dft = nullptr; + model_dft = nullptr; + + llama_init.reset(); + + ctx_tgt = nullptr; + model_tgt = nullptr; + + mtmd_free(mctx); + mctx = nullptr; + } + + void handle_sleeping_state(bool new_state) { + GGML_ASSERT(sleeping != new_state); + if (new_state) { + SRV_INF("%s", "server is entering sleeping state\n"); + destroy(); + } else { + SRV_INF("%s", "server is exiting sleeping state\n"); + if (!load_model(params_base)) { + GGML_ABORT("failed to reload model after sleeping"); + } + } + sleeping = new_state; + } + + struct load_progress_data { + server_context_impl * ctx; + std::string stage; + std::vector stages; + int64_t t_last_load_progress_ms = 0; + load_progress_data(server_context_impl * ctx, const std::string & stage) : ctx(ctx), stage(stage) {} + }; + static bool load_progress_callback(float progress, void * user_data) { + auto * d = static_cast(user_data); + GGML_ASSERT(d); + // always emit the first and final sample; throttle the rest to one per 200ms + { + auto & t_last = d->t_last_load_progress_ms; + const int64_t t_now = ggml_time_ms(); + const bool first = t_last == 0; + const bool done = progress >= 1.0f; + const bool throttled = !first && !done && (t_now - t_last) < 200; + if (throttled) { + return true; + } + t_last = t_now; + } + if (d->ctx->callback_state) { + d->ctx->callback_state(SERVER_STATE_LOADING, { + {"stages", d->stages}, + {"current", d->stage}, + {"value", progress}, + }); + } + return true; + } + + // load the model and initialize llama_context + // this may also be called to resume from sleeping state + bool load_model(common_params & params) { + load_progress_data load_progress_text (this, "text_model"); + load_progress_data load_progress_mmproj(this, "mmproj_model"); + load_progress_data load_progress_spec (this, "spec_model"); + + const bool is_resume = sleeping; + + params_base = params; + const auto output_limits = server_output_limits(params_base); + params_base.n_outputs_max = output_limits.total; + params_base.n_outputs_max_per_seq = output_limits.per_seq; + + const bool has_mmproj = !params.mmproj.path.empty(); + const bool has_draft = params.speculative.has_dft(); + const bool spec_mtp = std::find(params_base.speculative.types.begin(), + params_base.speculative.types.end(), + COMMON_SPECULATIVE_TYPE_DRAFT_MTP) != params_base.speculative.types.end(); + const bool has_spec = has_draft || spec_mtp; + + if (callback_state) { + std::vector stages = {"text_model"}; + if (has_spec) { + stages.push_back("spec_model"); + } + if (has_mmproj) { + stages.push_back("mmproj_model"); + } + load_progress_text.stages = stages; + load_progress_mmproj.stages = stages; + load_progress_spec.stages = stages; + + // trigger 0% progress + load_progress_callback(0.0f, &load_progress_text); + } + + + SRV_INF("loading model '%s'\n", params.model.get_name().c_str()); + SRV_TRC("local path '%s'\n", params.model.path.c_str()); + + std::string & mmproj_path = params_base.mmproj.path; + mtmd_context_params mparams = mtmd_context_params_default(); + if (has_mmproj) { + mparams.use_gpu = params_base.mmproj_use_gpu; + mparams.print_timings = false; + mparams.n_threads = params_base.cpuparams.n_threads; + mparams.flash_attn_type = params_base.flash_attn_type; + mparams.warmup = params_base.warmup; + mparams.image_min_tokens = params_base.image_min_tokens; + mparams.image_max_tokens = params_base.image_max_tokens; + mparams.batch_max_tokens = params_base.mtmd_batch_max_tokens; + mparams.media_marker = get_media_marker(); + // progress callback + mparams.progress_callback = load_progress_callback; + mparams.progress_callback_user_data = &load_progress_mmproj; + } + + // optionally get the memory usage of mmproj + if (has_mmproj && params_base.fit_params) { + int64_t t_start = ggml_time_us(); + auto mmproj_mem = mtmd_get_memory_usage(mmproj_path.c_str(), mparams); + int64_t t_elapsed = ggml_time_us() - t_start; + if (!mmproj_mem.empty()) { + size_t total = 0; + for (auto & [dev, size] : mmproj_mem) { + total += size; + } + SRV_TRC("[mtmd] estimated worst-case memory usage of mmproj is %.2f MiB (took %.2f ms)\n", total / (1024.0 * 1024.0), t_elapsed / 1000.0); + GGML_ASSERT(!params_base.fit_params_target.empty()); + for (auto & [dev, size] : mmproj_mem) { + for (size_t i = 0; i < ggml_backend_dev_count(); i++) { + if (ggml_backend_dev_get(i) == dev) { + if (i < params_base.fit_params_target.size()) { + SRV_DBG("[mtmd] adding %.2f MiB to fit_params_target for device %s\n", size / (1024.0 * 1024.0), ggml_backend_dev_name(dev)); + params_base.fit_params_target[i] += size; + } + break; + } + } + } + } else { + SRV_ERR("%s", "[mtmd] failed to get memory usage of mmproj\n"); + } + } + + // optionally reserve VRAM for the draft / MTP context before fitting the target model + if (params_base.fit_params) { + if (has_spec) { + // MTP draft context lives on the target model, only context+compute are new + bool measure_model_bytes = has_draft; + + common_params params_dft = common_base_params_to_speculative(params_base); + + auto mparams_dft = common_model_params_to_llama(params_dft); + auto cparams_dft = common_context_params_to_llama(params_dft); + if (spec_mtp) { + cparams_dft.ctx_type = LLAMA_CONTEXT_TYPE_MTP; + } + cparams_dft.n_rs_seq = 0; + + std::vector devs; + uint32_t hp_ngl = 0; + uint32_t hp_nct = 0; + uint32_t hp_nex = 0; + try { + auto dmd = common_get_device_memory_data( + params_dft.model.path.c_str(), &mparams_dft, &cparams_dft, + devs, hp_ngl, hp_nct, hp_nex, GGML_LOG_LEVEL_ERROR); + + GGML_ASSERT(!params_base.fit_params_target.empty()); + size_t total = 0; + + std::vector tgt_devices = params.devices; + + if (tgt_devices.empty()) { + for(size_t i = 0; i < ggml_backend_dev_count(); ++i) { + tgt_devices.push_back(ggml_backend_dev_get(i)); + } + } + + for (size_t j = 0; j < devs.size(); ++j) { + const size_t bytes = (measure_model_bytes ? dmd[j].model : 0) + dmd[j].context + dmd[j].compute; + total += bytes; + for (size_t i = 0; i < tgt_devices.size(); i++) { + if (tgt_devices[i] == devs[j]) { + SRV_DBG("[spec] adding %.2f MiB to fit_params_target for device %s\n", + bytes / (1024.0 * 1024.0), ggml_backend_dev_name(devs[j])); + params_base.fit_params_target[i] += bytes; + break; + } + } + } + SRV_TRC("[spec] estimated memory usage of %s is %.2f MiB\n", + has_draft ? "draft model" : "MTP context", + total / (1024.0 * 1024.0)); + } catch (const std::exception & e) { + SRV_WRN("[spec] failed to measure %s memory: %s\n", + has_draft ? "draft model" : "MTP context", e.what()); + } + } + } + + // attach a progress callback + { + params_base.load_progress_callback = load_progress_callback; + params_base.load_progress_callback_user_data = &load_progress_text; + } + + llama_init = common_init_from_params(params_base); + + model_tgt = llama_init->model(); + ctx_tgt = llama_init->context(); + + if (model_tgt == nullptr) { + SRV_ERR("failed to load model, '%s'\n", params_base.model.path.c_str()); + return false; + } + + if (ctx_tgt == nullptr) { + SRV_ERR("failed to create_context with model '%s'\n", params_base.model.path.c_str()); + return false; + } + + vocab = llama_model_get_vocab(model_tgt); + + n_ctx = llama_n_ctx(ctx_tgt); + + add_bos_token = llama_vocab_get_add_bos(vocab); + + if (has_spec) { + // spec_mtp doesn't use load a model internally, so we report 0.0 and 1.0 manually + load_progress_callback(0.0f, &load_progress_spec); + load_progress_spec.t_last_load_progress_ms = 0; // reset so internal cbs aren't delayed + + { + common_params params_dft = common_base_params_to_speculative(params_base); + + // progress callback + params_dft.load_progress_callback = load_progress_callback; + params_dft.load_progress_callback_user_data = &load_progress_spec; + + spec_init = common_speculative_init_from_params(params_dft, model_tgt, ctx_tgt); + model_dft = spec_init->model(); + ctx_dft = spec_init->context(); + + if (has_draft && model_dft == nullptr) { + SRV_ERR("failed to load draft model, '%s'\n", params_dft.model.path.c_str()); + return false; + } + + if (ctx_dft == nullptr) { + SRV_ERR("%s", "failed to create MTP context\n"); + return false; + } + + params_base.speculative.draft.ctx_tgt = ctx_tgt; + params_base.speculative.draft.ctx_dft = ctx_dft; + } + + load_progress_callback(1.0f, &load_progress_spec); + } + + if (has_mmproj) { + if (callback_state) { + callback_state(SERVER_STATE_LOADING, {{"stage", "mmproj_model"}}); + } + + if (!is_resume) { + mtmd_helper_log_set(common_log_default_callback, nullptr); + } + + mctx = mtmd_init_from_file(mmproj_path.c_str(), model_tgt, mparams); + if (mctx == nullptr) { + SRV_ERR("failed to load multimodal model, '%s'\n", mmproj_path.c_str()); + return false; + } + SRV_INF("loaded multimodal model, '%s'\n", mmproj_path.c_str()); + + if (params_base.ctx_shift) { + params_base.ctx_shift = false; + SRV_WRN("%s\n", "ctx_shift is not supported by multimodal, it will be disabled"); + } + + if (params_base.n_cache_reuse) { + params_base.n_cache_reuse = 0; + SRV_WRN("%s\n", "cache_reuse is not supported by multimodal, it will be disabled"); + } + } + + if (!llama_memory_can_shift(llama_get_memory(ctx_tgt))) { + if (params_base.ctx_shift) { + params_base.ctx_shift = false; + SRV_WRN("%s\n", "ctx_shift is not supported by this context, it will be disabled"); + } + + if (params_base.n_cache_reuse) { + params_base.n_cache_reuse = 0; + SRV_WRN("%s\n", "cache_reuse is not supported by this context, it will be disabled"); + } + } + + if (llama_model_n_swa(model_tgt) == 0) { + if (params_base.swa_full) { + params_base.swa_full = false; + SRV_WRN("%s\n", "swa_full is not supported by this model, it will be disabled"); + } + } + + n_swa = params_base.swa_full ? 0 : llama_model_n_swa(model_tgt); + + // Necessary similarity of prompt for slot selection + slot_prompt_similarity = params_base.slot_prompt_similarity; + + const int n_ctx_train = llama_model_n_ctx_train(model_tgt); + + int n_ctx_slot = llama_n_ctx_seq(ctx_tgt); + if (n_ctx_slot > n_ctx_train) { + SRV_WRN("the slot context (%d) exceeds the training context of the model (%d) - capping\n", n_ctx_slot, n_ctx_train); + n_ctx_slot = n_ctx_train; + } + + slots.clear(); + + ctx_tgt_seq_rm_type = common_context_can_seq_rm(ctx_tgt); + if (ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_NO) { + SRV_WRN("%s", "speculative decoding not supported by this context\n"); + } + + if (ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL) { + SRV_TRC("%s", "speculative decoding will use checkpoints\n"); + } + + // setup slots + SRV_INF("initializing, n_slots = %d, n_ctx_slot = %d, kv_unified = '%s'\n", + params_base.n_parallel, n_ctx_slot, params_base.kv_unified ? "true" : "false"); + + // initialize slots + for (int i = 0; i < params_base.n_parallel; i++) { + slots.emplace_back(); + } + + // try speculative decoding + if (ctx_tgt_seq_rm_type != COMMON_CONTEXT_SEQ_RM_TYPE_NO) { + try { + spec.reset(common_speculative_init(params_base.speculative, params_base.n_parallel)); + } catch (const std::exception & e) { + SRV_ERR("failed to initialize speculative decoding context: %s\n", e.what()); + } + } + + if (ctx_dft) { + ctx_dft_seq_rm_type = common_context_can_seq_rm(ctx_dft); + } + + if (spec) { + SRV_TRC("%s", "speculative decoding context initialized\n"); + } else { + spec_init.reset(); + ctx_dft = nullptr; + model_dft = nullptr; + } + + for (int i = 0; i < params_base.n_parallel; i++) { + server_slot & slot = slots[i]; + + slot.id = i; + slot.ctx_tgt = ctx_tgt; + slot.ctx_dft = ctx_dft; + slot.mem.init(ctx_tgt, ctx_dft); + slot.spec = spec.get(); + slot.n_ctx = n_ctx_slot; + + slot.mctx = mctx; + slot.prompt.tokens.has_mtmd = mctx != nullptr; + + SLT_TRC(slot, "new slot, n_ctx = %d\n", slot.n_ctx); + + slot.callback_on_release = [this](int id_slot) { + queue_tasks.pop_deferred_task(id_slot); + }; + + slot.reset(); + } + + { + const char * LLAMA_TRACE = getenv("LLAMA_TRACE"); + trace = LLAMA_TRACE ? atoi(LLAMA_TRACE) : 0; + + if (trace) { + SRV_WRN("LLAMA_TRACE = %d\n", trace); + } + } + + { + const char * LLAMA_SERVER_SLOTS_DEBUG = getenv("LLAMA_SERVER_SLOTS_DEBUG"); + slots_debug = LLAMA_SERVER_SLOTS_DEBUG ? atoi(LLAMA_SERVER_SLOTS_DEBUG) : 0; + + if (slots_debug) { + SRV_WRN("LLAMA_SERVER_SLOTS_DEBUG = %d\n", slots_debug); + } + } + + // the update_slots() logic will always submit a maximum of n_batch or n_parallel tokens + // note that n_batch can be > n_ctx (e.g. for non-causal attention models such as BERT where the KV cache is not used) + { + const int32_t n_batch = llama_n_batch(ctx_tgt); + const int32_t n_embd = llama_model_n_embd_inp(model_tgt); + batch.init(std::max(n_batch, params_base.n_parallel), n_embd); + } + + if (params_base.cache_ram_mib != 0) { + if (params_base.cache_ram_mib < 0) { + SRV_TRC("prompt cache is enabled, size limit: %s\n", "no limit"); + } else { + SRV_TRC("prompt cache is enabled, size limit: %d MiB\n", params_base.cache_ram_mib); + } + SRV_TRC("%s", "use `--cache-ram 0` to disable the prompt cache\n"); + + prompt_cache = std::make_unique(params_base.cache_ram_mib, n_ctx); + } else { + SRV_TRC("%s", "prompt cache is disabled - use `--cache-ram N` to enable it\n"); + } + SRV_TRC("%s", "for more info see https://github.com/ggml-org/llama.cpp/pull/16391\n"); + + if (params_base.n_ctx_checkpoints > 0) { + SRV_TRC("context checkpoints enabled, max = %d, min spacing = %d\n", + params_base.n_ctx_checkpoints, params_base.checkpoint_min_step); + } else { + SRV_TRC("%s", "context checkpoints disabled\n"); + } + + if (!params_base.model_alias.empty()) { + // backward compat: use first alias as model name + model_name = *params_base.model_alias.begin(); + } else if (!params_base.model.get_name().empty()) { + model_name = params_base.model.get_name(); + } else { + // fallback: derive model name from file name + auto model_path = std::filesystem::path(params_base.model.path); + model_name = model_path.filename().string(); + } + + model_aliases = params_base.model_alias; + model_tags = params_base.model_tags; + + // propagate new defaults back to caller + params = params_base; + + if (!is_resume) { + return init(); + } + + if (callback_state) { + callback_state(SERVER_STATE_READY, {}); + } + + return true; + } + + // unlike load_model(), this is only called once during initialization + bool init() { + GGML_ASSERT(ctx_tgt != nullptr); + GGML_ASSERT(model_tgt != nullptr); + + GGML_ASSERT(!sleeping); + + // wiring up server queues + queue_tasks.on_new_task([this](server_task && task) { + process_single_task(std::move(task)); + }); + queue_tasks.on_update_slots([this]() { + update_slots(); + }); + queue_tasks.on_sleeping_state([this](bool sleeping) { + handle_sleeping_state(sleeping); + }); + + metrics.init(); + + if (params_base.cache_idle_slots) { + if (params_base.cache_ram_mib == 0) { + SRV_WRN("%s", "--cache-idle-slots requires --cache-ram, disabling\n"); + params_base.cache_idle_slots = false; + } else { + if (params_base.kv_unified) { + SRV_TRC("%s", "idle slots will be saved to prompt cache and cleared upon starting a new task\n"); + } else { + // without a unified KV cache, clearing a slot frees no reusable room, so we only + // publish a RAM-cache copy of idle slots (their KV stays in VRAM) [TAG_IDLE_SLOT_CLEAR] + SRV_TRC("%s", "idle slots will be saved to prompt cache upon starting a new task\n"); + } + SRV_DBG("%s", "__TEST_TAG_CACHE_IDLE_SLOTS_ENABLED__\n"); + } + } + + { + const std::string & cfg = params_base.ui_config_json; + if (!cfg.empty()) { + try { + json json_settings = json::parse(cfg); + json_ui_settings = json_settings; + } catch (const std::exception & e) { + SRV_ERR("%s: failed to parse UI config: %s\n", __func__, e.what()); + return false; + } + } + } + + // populate chat template params + { + common_chat_templates_ptr chat_templates; + bool enable_thinking = false; + + try { + chat_templates = common_chat_templates_init(model_tgt, params_base.chat_template); + + SRV_TRC("%s: chat template, example_format: '%s'\n", __func__, + common_chat_format_example(chat_templates.get(), params_base.use_jinja, params_base.default_template_kwargs).c_str()); + + // thinking is enabled if: + // 1. It's not explicitly disabled via --reasoning off + // 2. The chat template supports it + const bool template_supports_thinking = params_base.use_jinja && common_chat_templates_support_enable_thinking(chat_templates.get()); + enable_thinking = params_base.enable_reasoning != 0 && template_supports_thinking; + SRV_TRC("%s: chat template, thinking = %d\n", __func__, enable_thinking); + } catch (const std::exception & e) { + SRV_ERR("%s: chat template parsing error: %s\n", __func__, e.what()); + SRV_ERR("%s: please consider disabling jinja via --no-jinja, or use a custom chat template via --chat-template\n", __func__); + SRV_ERR("%s: for example: --no-jinja --chat-template chatml\n", __func__); + return false; + } + + // IMPORTANT: chat_params is reused across sleeping / resuming states, + // never store llama_context/llama_model pointers in chat_params, + // as they may be invalidated after sleeping + chat_params = { + /* use_jinja */ params_base.use_jinja, + /* prefill_assistant */ params_base.prefill_assistant, + /* reasoning_format */ params_base.reasoning_format, + /* chat_template_kwargs */ params_base.default_template_kwargs, + /* tmpls */ std::move(chat_templates), + /* allow_image */ mctx ? mtmd_support_vision(mctx) : false, + /* allow_audio */ mctx ? mtmd_support_audio (mctx) : false, + /* allow_video */ mctx ? mtmd_helper_support_video(mctx) : false, + /* enable_thinking */ enable_thinking, + /* reasoning_budget */ params_base.sampling.reasoning_budget_tokens, + /* reasoning_budget_msg */ params_base.sampling.reasoning_budget_message, + /* media_path */ params_base.media_path, + /* force_pure_content */ params_base.force_pure_content_parser + }; + + { + auto caps = common_chat_templates_get_caps(chat_params.tmpls.get()); + auto it = params_base.default_template_kwargs.find("preserve_reasoning"); + bool supported = caps.at("supports_preserve_reasoning"); + bool enabled = it != params_base.default_template_kwargs.end(); + if (supported && !enabled) { + SRV_INF("%s", "chat template supports preserving reasoning, consider enabling it via --reasoning-preserve\n"); + } + if (!supported && enabled) { + SRV_WRN("%s", "chat template does NOT support preserving reasoning, --reasoning-preserve has no effect\n"); + } + } + } + + return true; + } + + server_slot * get_slot_by_id(int id_slot) { + // note: allow id_slot to be out of bounds (wrap around) + id_slot = id_slot % slots.size(); + + for (server_slot & slot : slots) { + if (slot.id == id_slot) { + return &slot; + } + } + + return nullptr; + } + + server_slot * get_slot_by_cmpl_id(const std::string & cmpl_id) { + if (cmpl_id.empty()) { + return nullptr; + } + + for (server_slot & slot : slots) { + if (slot.is_processing() && slot.task && slot.task->params.oaicompat_cmpl_id == cmpl_id) { + return &slot; + } + } + + return nullptr; + } + + server_slot * get_available_slot(const server_task & task) { + server_slot * ret = nullptr; + + bool update_cache = false; + + // if a specific slot is requested, use it (still goes through cache update logic below) + if (task.id_slot != -1) { + ret = get_slot_by_id(task.id_slot); + if (ret) { + SLT_INF(*ret, "selected slot by id (%d)\n", task.id_slot); + } + } + + // find the slot that has at least n% prompt similarity + if (slot_prompt_similarity != 0.0f) { + float f_sim_best = 0; + + for (server_slot & slot : slots) { + if (task.id_slot != -1 && slot.id != task.id_slot) { + continue; + } + + // skip the slot if it is not available + if (slot.is_processing()) { + SLT_TRC(slot, " - skipping, is_processing = %d\n", slot.is_processing()); + continue; + } + + const auto & tokens = slot.prompt.tokens; + + // skip the slot if it does not contains cached tokens + if (tokens.empty()) { + SLT_TRC(slot, "%s", " - skipping, slot is empty\n"); + continue; + } + + // fraction of the Longest Common Prefix length with respect to the input prompt length + const size_t lcp_len = tokens.get_common_prefix(task.tokens); + const float f_sim_cur = float(lcp_len) / task.tokens.size(); + + SLT_TRC(slot, " - checking sim = %.3f (%zu/%zu) > %.3f\n", f_sim_cur, lcp_len, task.tokens.size(), slot_prompt_similarity); + + // select the current slot if the criteria match + if (f_sim_cur > f_sim_best && f_sim_cur > slot_prompt_similarity) { + f_sim_best = f_sim_cur; + + ret = &slot; + } + } + + if (ret != nullptr) { + const float f_keep = (f_sim_best*task.tokens.size()) / ret->prompt.tokens.size(); + + if (task.id_slot == -1) { + SLT_INF(*ret, "selected slot by LCP similarity, f_sim_best = %.3f (> %.3f thold), f_keep = %.3f\n", + f_sim_best, slot_prompt_similarity, f_keep); + } + + // if we are about to lose a large portion of the existing context - save it in the prompt cache + if (f_keep < 0.5f) { + update_cache = true; + } + } + } + + // find the slot that has been least recently used + if (ret == nullptr) { + int64_t t_last = -1; + + for (server_slot & slot : slots) { + // skip the slot if it is not available + if (slot.is_processing()) { + continue; + } + + // select the current slot if the criteria match + if (!ret || slot.t_last_used <= t_last) { + t_last = slot.t_last_used; + ret = &slot; + } + } + + if (ret != nullptr) { + SLT_INF(*ret, "selected slot by LRU, t_last = %" PRId64 "\n", t_last); + + update_cache = true; + } + } + + if (ret) { + update_cache = update_cache && prompt_cache; + + // cache prompts only for completion tasks + update_cache = update_cache && task.type == SERVER_TASK_TYPE_COMPLETION; + + if (update_cache) { + SRV_TRC("%s", "updating prompt cache\n"); + + const int64_t t_start = ggml_time_us(); + + ret->prompt_save(*prompt_cache); + + if (!ret->prompt_load(*prompt_cache, task.tokens)) { + ret->prompt_clear(); + } + + prompt_cache->update(); + + SRV_TRC("prompt cache update took %.2f ms\n", (ggml_time_us() - t_start) / 1000.0); + } + } + + return ret; + } + + // return true if at least one slot has been cleared + // TODO: improve logic + // - smarter decision which slot to clear (LRU or longest prompt?) + // - move slot to level 2 cache instead of removing? + // - instead of purging, try to store and resume later? + bool try_clear_idle_slots() { + bool res = false; + + if (!params_base.kv_unified) { + return res; + } + + for (auto & slot : slots) { + if (slot.is_processing()) { + continue; + } + + if (slot.prompt.n_tokens() > 0) { + SRV_WRN("purging slot %d with %zu tokens\n", slot.id, slot.prompt.tokens.size()); + + slot.prompt_clear(); + + res = true; + + // clear slots one by one + break; + } + } + + return res; + } + + std::vector construct_lora_list(const std::map & config) const { + std::vector output = params_base.lora_adapters; // copy + for (size_t i = 0; i < output.size(); ++i) { + auto it = config.find(i); + if (it != config.end()) { + output[i].scale = it->second; + } else { + output[i].scale = 0.0f; + } + } + return output; + } + + bool launch_slot_with_task(server_slot & slot, server_task && task) { + // process per-request lora adapters + if (!task.params.lora.empty()) { + auto task_loras = construct_lora_list(task.params.lora); + if (!are_lora_equal(task_loras, slot.lora)) { + // if lora has changed, check to see if the cache should be cleared + if (lora_should_clear_cache(slot.lora, task_loras)) { + SLT_TRC(slot, "clearing cache for lora change. %zu loras -> %zu loras\n", slot.lora.size(), task.params.lora.size()); + slot.prompt.clear(); + } else { + SLT_TRC(slot, "keeping cache for alora. %zu target loras\n", task_loras.size()); + } + slot.lora = task_loras; + } + } else { + slot.lora = params_base.lora_adapters; + } + + // if using alora, make sure it's only a single one requested and active + size_t alora_invocation_start = task.tokens.size(); + if (lora_all_alora(slot.lora)) { + const auto & enabled_ids = lora_get_enabled_ids(slot.lora); + // TODO: This will error out if a user requests two aloras, but only + // provides the activation string for one. We could, instead search + // for all requested alora activation strings and then either keep + // only the last one, or reject if multiple are found. + if (enabled_ids.size() != 1) { + send_error(task, "Cannot run multiple aLoRAs in a single request", ERROR_TYPE_INVALID_REQUEST); + return false; + } + const auto & lora = slot.lora[enabled_ids[0]].ptr; + + // get the pointer and count for the invocation tokens + const uint64_t n_invocation_tokens = llama_adapter_get_alora_n_invocation_tokens(lora); + const llama_token * invocation_tokens = llama_adapter_get_alora_invocation_tokens (lora); + + // scan backwards through the prompt tokens to find the last + // occurrence of the invocation sequence + int match_idx = static_cast(n_invocation_tokens) - 1; + for (int i = task.tokens.size() - 1; i >= 0; --i) { + // the token in this position matches the next token to find in + // the invocation sequence + if (task.tokens[i] == invocation_tokens[match_idx]) { + // if it's a full match, we've found the start + if (match_idx == 0) { + alora_invocation_start = i; + break; + } + // otherwise, check the next token in the sequence + --match_idx; + } else { + // no match in this position, so start looking over again + match_idx = static_cast(n_invocation_tokens) - 1; + } + } + + // if the activation string is not found, disable the alora + if (alora_invocation_start == task.tokens.size()) { + SLT_DBG(slot, "alora %zu requested, but not found. deactivating\n", enabled_ids[0]); + slot.lora[enabled_ids[0]].scale = 0.0f; + } else { + SLT_DBG(slot, "alora %zu activated starting at %zu\n", enabled_ids[0], alora_invocation_start); + slot.alora_invocation_start = alora_invocation_start; + } + } + + if (!task.tokens.validate(ctx_tgt)) { + send_error(task, "Prompt contains invalid tokens", ERROR_TYPE_INVALID_REQUEST); + return false; + } + + SLT_DBG(slot, "launching slot : %s\n", safe_json_to_str(slot.to_json()).c_str()); + + // initialize samplers + if (task.need_sampling()) { + try { + slot.smpl.reset(common_sampler_init(model_tgt, task.params.sampling)); + } catch (std::exception & e) { + std::string err_msg = std::string("Failed to initialize samplers: ") + e.what(); + send_error(task, err_msg, ERROR_TYPE_INVALID_REQUEST); + return false; + } + + const bool need_pre_sample_logits = task.params.sampling.n_probs > 0 && !task.params.post_sampling_probs; + + bool use_backend_sampling = task.params.sampling.backend_sampling; + + // TODO: getting pre sampling logits is not yet supported with backend sampling + use_backend_sampling &= !need_pre_sample_logits; + + // TODO: tmp until backend sampling is fully implemented + if (use_backend_sampling) { + llama_set_sampler(ctx_tgt, slot.id, common_sampler_get(slot.smpl.get())); + } else { + llama_set_sampler(ctx_tgt, slot.id, nullptr); + } + + SLT_TRC(slot, "sampler chain: %s\n", common_sampler_print(slot.smpl.get()).c_str()); + SLT_TRC(slot, "sampler params: \n%s\n", task.params.sampling.print().c_str()); + } else { + slot.smpl.reset(); + } + + slot.task = std::make_unique(std::move(task)); + + slot.state = slot.task->is_child() + ? SLOT_STATE_WAIT_OTHER // wait for the parent to process prompt + : SLOT_STATE_STARTED; + + // reset server kill-switch counter + n_empty_consecutive = 0; + + SLT_INF(slot, "processing task, is_child = %d\n", slot.task->is_child()); + return true; + } + + bool process_token(completion_token_output & result, server_slot & slot) { + // remember which tokens were sampled - used for repetition penalties during sampling + const std::string token_str = result.text_to_send; + slot.sampled = result.tok; + + slot.generated_text += token_str; + if (slot.task->params.return_tokens) { + slot.generated_tokens.push_back(result.tok); + } + slot.has_next_token = true; + + // check if there is incomplete UTF-8 character at the end + bool incomplete = validate_utf8(slot.generated_text) < slot.generated_text.size(); + + // search stop word and delete it + if (!incomplete) { + size_t pos = std::min(slot.n_sent_text, slot.generated_text.size()); + + const std::string str_test = slot.generated_text.substr(pos); + bool send_text = true; + + size_t stop_pos = slot.find_stopping_strings(str_test, token_str.size(), true); + if (stop_pos != std::string::npos) { + slot.generated_text.erase( + slot.generated_text.begin() + pos + stop_pos, + slot.generated_text.end()); + pos = std::min(slot.n_sent_text, slot.generated_text.size()); + } else if (slot.has_next_token && !llama_vocab_is_eog(vocab, result.tok) ) { + stop_pos = slot.find_stopping_strings(str_test, token_str.size(), false); + send_text = stop_pos == std::string::npos; + } + + // check if there is any token to predict + if (send_text) { + // no send the stop word in the response + result.text_to_send = slot.generated_text.substr(pos, std::string::npos); + slot.n_sent_text += result.text_to_send.size(); + // add the token to slot queue and cache + } else { + result.text_to_send = ""; + } + + slot.add_token(result); + if (slot.task->params.stream) { + send_partial_response(slot, result, false); + } + } + + if (incomplete) { + slot.has_next_token = true; + } + + // if context shifting is disabled, make sure that we don't run out of context + if (!params_base.ctx_shift && slot.prompt.n_tokens() + 1 >= slot.n_ctx) { + slot.truncated = true; + slot.stop = STOP_TYPE_LIMIT; + slot.has_next_token = false; + + SLT_DBG(slot, "stopped due to running out of context capacity, prompt.n_tokens() = %d, task.n_tokens = %d, n_decoded = %d, n_ctx = %d\n", + slot.prompt.n_tokens(), slot.task->n_tokens(), slot.n_decoded, slot.n_ctx); + } + + // check the limits + if (slot.n_decoded > 0 && slot.has_next_token && !slot.has_budget(params_base)) { + slot.stop = STOP_TYPE_LIMIT; + slot.has_next_token = false; + + SLT_DBG(slot, "stopped by limit, n_decoded = %d, n_predict = %d\n", slot.n_decoded, slot.task->params.n_predict); + } + + if (slot.has_new_line) { + // require that each new line has a whitespace prefix (i.e. indentation) of at least slot.params.n_indent + if (slot.task->params.n_indent > 0) { + // check the current indentation + // TODO: improve by not doing it more than once for each new line + if (slot.last_nl_pos > 0) { + size_t pos = slot.last_nl_pos; + + int n_indent = 0; + while (pos < slot.generated_text.size() && (slot.generated_text[pos] == ' ' || slot.generated_text[pos] == '\t')) { + n_indent++; + pos++; + } + + if (pos < slot.generated_text.size() && n_indent < slot.task->params.n_indent) { + slot.stop = STOP_TYPE_LIMIT; + slot.has_next_token = false; + + // cut the last line + slot.generated_text.erase(pos, std::string::npos); + + SLT_DBG(slot, "stopped by indentation limit, n_decoded = %d, n_indent = %d\n", slot.n_decoded, n_indent); + } + } + + // find the next new line + { + const size_t pos = slot.generated_text.find('\n', slot.last_nl_pos); + + if (pos != std::string::npos) { + slot.last_nl_pos = pos + 1; + } + } + } + } + + // check if there is a new line in the generated text + if (result.text_to_send.find('\n') != std::string::npos) { + slot.has_new_line = true; + + // if we have seen a new line, we stop after a certain time limit, but only upon another new line + if (slot.task->params.t_max_predict_ms > 0 && (ggml_time_us() - slot.t_start_generation > 1000.0f*slot.task->params.t_max_predict_ms)) { + slot.stop = STOP_TYPE_LIMIT; + slot.has_next_token = false; + + SLT_DBG(slot, "stopped by time limit, n_decoded = %d, t_max_predict_ms = %d ms\n", slot.n_decoded, (int) slot.task->params.t_max_predict_ms); + } + } + + if (llama_vocab_is_eog(vocab, result.tok)) { + slot.stop = STOP_TYPE_EOS; + slot.has_next_token = false; + + SLT_DBG(slot, "%s", "stopped by EOS\n"); + } + + SLT_DBG(slot, "n_decoded = %d, n_remaining = %d, next token: %5d '%s'\n", slot.n_decoded, slot.n_remaining, result.tok, token_str.c_str()); + + return slot.has_next_token; // continue + } + + void populate_token_probs(const server_slot & slot, completion_token_output & result, bool post_sampling, bool special, int idx) const { + const size_t n_probs_request = slot.task->params.sampling.n_probs; + + if (post_sampling) { + const auto * cur_p = common_sampler_get_candidates(slot.smpl.get(), true); + const size_t max_probs = cur_p->size; + const size_t n_probs = std::min(max_probs, n_probs_request); + + // set probability for sampled token + for (size_t i = 0; i < max_probs; i++) { + if (cur_p->data[i].id == result.tok) { + result.prob = cur_p->data[i].p; + break; + } + } + + // set probability for top n_probs tokens + result.probs.reserve(n_probs); + for (size_t i = 0; i < n_probs; i++) { + // Some samplers do return 0.0 probabilities, others don't. + // Filter 0.0 probailities, to ensure the behavior is consistent. + if (cur_p->data[i].p == 0.0) { + break; + } + + result.probs.push_back({ + cur_p->data[i].id, + common_token_to_piece(ctx_tgt, cur_p->data[i].id, special), + cur_p->data[i].p + }); + } + } else { + std::vector cur = get_token_probabilities(ctx_tgt, idx, n_probs_request); + const size_t max_probs = cur.size(); + const size_t n_probs = std::min(max_probs, n_probs_request); + + // set probability for sampled token + for (size_t i = 0; i < max_probs; i++) { + // set probability for sampled token + if (cur[i].id == result.tok) { + result.prob = cur[i].p; + break; + } + } + + // set probability for top n_probs tokens + result.probs.reserve(n_probs); + for (size_t i = 0; i < n_probs; i++) { + result.probs.push_back({ + cur[i].id, + common_token_to_piece(ctx_tgt, cur[i].id, special), + cur[i].p + }); + } + } + } + + void send_error(const server_task & task, const std::string & error, const enum error_type type = ERROR_TYPE_SERVER) { + send_error(task.id, error, type); + } + + void send_error(const server_slot & slot, const std::string & error, const enum error_type type = ERROR_TYPE_SERVER) { + send_error(slot.task->id, error, type, slot.task->n_tokens(), slot.n_ctx); + } + + void send_error(const int id_task, const std::string & error, const enum error_type type = ERROR_TYPE_SERVER, const int32_t n_prompt_tokens = 0, const int32_t n_ctx = 0) { + SRV_ERR("task id = %d, error: %s\n", id_task, error.c_str()); + + if (type == ERROR_TYPE_EXCEED_CONTEXT_SIZE) { + GGML_ASSERT(n_ctx > 0 && n_prompt_tokens > 0); + } + + auto res = std::make_unique(); + res->id = id_task; + res->err_type = type; + res->err_msg = error; + res->n_prompt_tokens = n_prompt_tokens; + res->n_ctx = n_ctx; + + queue_results.send(std::move(res)); + } + + // Gate slot save/restore/erase on slot content (does it hold media), + // not model capability: a multimodal model may hold a pure-text slot. + bool check_slot_no_media(const server_slot & slot, const int id_task) { + if (slot.prompt.tokens.has_media()) { + send_error(id_task, + "This operation is not supported while the slot holds image/audio tokens (a pure-text prefix is supported)", + ERROR_TYPE_NOT_SUPPORTED); + return false; + } + return true; + } + + void send_partial_response(server_slot & slot, const completion_token_output & tkn, bool is_progress, bool is_begin = false) { + auto res = std::make_unique(); + + res->id = slot.task->id; + res->index = slot.task->index; + + if (is_progress) { + res->is_progress = true; + res->progress.total = slot.task->n_tokens(); + res->progress.cache = slot.n_prompt_tokens_cache; + res->progress.processed = slot.prompt.tokens.size(); + res->progress.time_ms = (ggml_time_us() - slot.t_start_process_prompt) / 1000; + } + if (is_begin) { + res->is_begin = true; + } else { + res->content = tkn.text_to_send; + res->tokens = { tkn.tok }; + } + + res->n_decoded = slot.n_decoded; + res->n_prompt_tokens = slot.task->n_tokens(); + res->n_prompt_tokens_cache = slot.n_prompt_tokens_cache; + res->post_sampling_probs = slot.task->params.post_sampling_probs; + + res->verbose = slot.task->params.verbose; + res->res_type = slot.task->params.res_type; + res->oaicompat_model = slot.task->params.oaicompat_model; + res->oaicompat_cmpl_id = slot.task->params.oaicompat_cmpl_id; + + // populate res.probs_output + if (slot.task->params.sampling.n_probs > 0) { + res->prob_output = tkn; // copy the token probs + } + + // populate timings if this is final response or timings_per_token is enabled + if (slot.stop != STOP_TYPE_NONE || slot.task->params.timings_per_token) { + res->timings = slot.get_timings(); + } + + queue_results.send(std::move(res)); + } + + void send_final_response(server_slot & slot) { + auto res = std::make_unique(); + + res->id = slot.task->id; + res->id_slot = slot.id; + + res->index = slot.task->index; + + // keep copy of last generated text for debugging purposes + if (slots_debug) { + slot.debug_generated_text = slot.generated_text; + } + + // in stream mode, content and tokens are already in last partial chunk + if (slot.task->params.stream) { + res->content = ""; + res->tokens = llama_tokens{}; + } else { + res->content = std::move(slot.generated_text); + res->tokens = std::move(slot.generated_tokens); + } + res->timings = slot.get_timings(); + res->prompt = slot.task->tokens.detokenize(ctx_tgt, true); + res->response_fields = std::move(slot.task->params.response_fields); + + res->truncated = slot.truncated; + res->n_decoded = slot.n_decoded; + res->n_prompt_tokens = slot.task->n_tokens(); + res->n_prompt_tokens_cache = slot.n_prompt_tokens_cache; + res->n_tokens_cached = slot.prompt.n_tokens(); + res->has_new_line = slot.has_new_line; + res->stopping_word = slot.stopping_word; + res->stop = slot.stop; + res->post_sampling_probs = slot.task->params.post_sampling_probs; + + res->verbose = slot.task->params.verbose; + res->stream = slot.task->params.stream; + res->include_usage = slot.task->params.include_usage; + res->res_type = slot.task->params.res_type; + res->oaicompat_model = slot.task->params.oaicompat_model; + res->oaicompat_cmpl_id = slot.task->params.oaicompat_cmpl_id; + + // populate res.probs_output + if (slot.task->params.sampling.n_probs > 0) { + if (!slot.task->params.stream && slot.stop == STOP_TYPE_WORD) { + const llama_tokens stop_word_toks = common_tokenize(ctx_tgt, slot.stopping_word, false); + + size_t safe_offset = std::min(slot.generated_token_probs.size(), stop_word_toks.size()); + res->probs_output = std::vector( + slot.generated_token_probs.begin(), + slot.generated_token_probs.end() - safe_offset); + } else { + res->probs_output = std::vector( + slot.generated_token_probs.begin(), + slot.generated_token_probs.end()); + } + } + + res->generation_params = slot.task->params; // copy the parameters + + queue_results.send(std::move(res)); + } + + void send_embedding(const server_slot & slot, const llama_batch & batch) { + auto res = std::make_unique(); + res->id = slot.task->id; + res->index = slot.task->index; + res->n_tokens = slot.task->n_tokens(); + res->res_type = slot.task->params.res_type; + + const int n_embd_out = llama_model_n_embd_out(model_tgt); + + std::vector embd_res(n_embd_out, 0.0f); + + for (int i = 0; i < batch.n_tokens; ++i) { + if (!batch.logits[i] || batch.seq_id[i][0] != slot.id) { + continue; + } + + const float * embd = nullptr; + if (llama_pooling_type(slot.ctx_tgt) == LLAMA_POOLING_TYPE_NONE) { + embd = llama_get_embeddings_ith(slot.ctx_tgt, i); + } else { + embd = llama_get_embeddings_seq(slot.ctx_tgt, batch.seq_id[i][0]); + } + + if (embd == nullptr) { + SLT_ERR(slot, "failed to get embeddings, token = %d, seq_id = %d\n", batch.token[i], batch.seq_id[i][0]); + + res->embedding.push_back(std::vector(n_embd_out, 0.0f)); + continue; + } + + // normalize only when there is pooling + if (llama_pooling_type(slot.ctx_tgt) != LLAMA_POOLING_TYPE_NONE) { + common_embd_normalize(embd, embd_res.data(), n_embd_out, slot.task->params.embd_normalize); + res->embedding.push_back(embd_res); + break; + } + + res->embedding.emplace_back(embd, embd + n_embd_out); + } + + SLT_DBG(slot, "%s", "sending embeddings\n"); + + queue_results.send(std::move(res)); + } + + void send_rerank(const server_slot & slot, const llama_batch & batch) { + auto res = std::make_unique(); + res->id = slot.task->id; + res->index = slot.task->index; + res->n_tokens = slot.task->n_tokens(); + + for (int i = 0; i < batch.n_tokens; ++i) { + if (!batch.logits[i] || batch.seq_id[i][0] != slot.id) { + continue; + } + + const float * embd = llama_get_embeddings_seq(ctx_tgt, batch.seq_id[i][0]); + if (embd == NULL) { + embd = llama_get_embeddings_ith(ctx_tgt, i); + } + + if (embd == NULL) { + SLT_ERR(slot, "failed to get embeddings, token = %d, seq_id = %d\n", batch.token[i], batch.seq_id[i][0]); + + res->score = -1e6; + continue; + } + + res->score = embd[0]; + } + + SLT_DBG(slot, "sending rerank result, res.score = %f\n", res->score); + + queue_results.send(std::move(res)); + } + + // + // Functions to process the task + // + + // tokenize the input if it's set by CLI, return false on error + bool tokenize_cli_input(server_task & task) { + try { + auto & prompt = task.cli_prompt; + if (mctx != nullptr) { + task.tokens = process_mtmd_prompt(mctx, prompt, task.cli_files); + } else { + task.tokens = std::move(tokenize_input_prompts(vocab, mctx, prompt, true, true)[0]); + } + task.cli_prompt.clear(); + task.cli_files.clear(); + } catch (const std::exception & e) { + send_error(task, std::string("Failed to format input: ") + e.what(), ERROR_TYPE_INVALID_REQUEST); + return false; + } + return true; + } + + std::vector get_free_slots(size_t n_slots_needed, int exclude_id_slot) { + std::vector free_slots; + for (auto & slot : slots) { + if (!slot.is_processing() && slot.id != exclude_id_slot) { + free_slots.push_back(&slot); + } + if (free_slots.size() >= n_slots_needed) { + break; + } + } + return free_slots; + } + + // launch multiple slots for parent + child tasks + bool launch_slots_with_parent_task(server_slot & parent_slot, std::vector & child_slots, server_task && parent_task) { + GGML_ASSERT(!parent_slot.is_processing()); + GGML_ASSERT(parent_task.is_parent()); + GGML_ASSERT(child_slots.size() == parent_task.child_tasks.size()); + + int id_parent = parent_task.id; + + SRV_TRC("launching slots for parent task id_task = %d with %zu child tasks\n", id_parent, parent_task.child_tasks.size()); + + // to be called in case of failure to release all launched slots + auto release_slots = [this, id_parent]() { + for (auto & slot : slots) { + if (slot.is_processing() && ( + slot.task->id == id_parent || + slot.task->id_parent == id_parent + )) { + slot.release(); + } + } + }; + + // launch all child tasks first + size_t idx = 0; + GGML_ASSERT(child_slots.size() == parent_task.child_tasks.size()); + for (auto * slot : child_slots) { + int id_child = parent_task.child_tasks[idx].id; + if (!launch_slot_with_task(*slot, std::move(parent_task.child_tasks[idx]))) { + SRV_ERR("failed to launch slot with child task, id_task = %d\n", id_child); + release_slots(); + return false; + } + idx++; + } + + // finally, launch the parent task + if (!launch_slot_with_task(parent_slot, std::move(parent_task))) { + SRV_ERR("failed to launch slot with task, id_task = %d\n", id_parent); + release_slots(); + return false; + } + + return true; + } + + // n_tokens_cur: the number of tokens added to the batch for the current slot + void create_checkpoint(server_slot & slot, const int64_t n_tokens_cur, llama_pos pos_min, llama_pos pos_max) { + const int id_task = slot.task->id; + + // evict checkpoints within min-step of a previous checkpoint, unless they were + // created by the current task + int64_t last = -1; + for (auto it = slot.prompt.checkpoints.begin(); it != slot.prompt.checkpoints.end(); ) { + if (it->id_task != id_task && last >= 0 && it->n_tokens <= last + params_base.checkpoint_min_step) { + SLT_TRC(slot, "erasing context checkpoint too close to an earlier one (pos_min = %d, pos_max = %d, n_tokens = %" PRId64 ", size = %.3f MiB)\n", + it->pos_min, it->pos_max, it->n_tokens, (float) it->size() / 1024 / 1024); + + it = slot.prompt.checkpoints.erase(it); + continue; + } + + last = it->n_tokens; + ++it; + } + + while (slot.prompt.checkpoints.size() >= (size_t) params_base.n_ctx_checkpoints) { + // make room for the new checkpoint, if needed + const auto & cur = slot.prompt.checkpoints.front(); + + SLT_WRN(slot, "erasing old context checkpoint (pos_min = %d, pos_max = %d, n_tokens = %" PRId64 ", size = %.3f MiB)\n", + cur.pos_min, cur.pos_max, cur.n_tokens, (float) cur.size() / 1024 / 1024); + + slot.prompt.checkpoints.erase(slot.prompt.checkpoints.begin()); + } + + auto & cur = slot.prompt.checkpoints.emplace_back(); + + cur.id_task = id_task; + + // [TAG_CHECKPOINTS_FIX_POS_MIN] + // TODO: here we incorrectly deterimne that the saved checkpoint data covers the [pos_min, pos_max] range + // this is not true for SWA models: https://github.com/ggml-org/llama.cpp/pull/24411#issuecomment-4677983225 + cur.update_pos(slot.prompt.n_tokens() - n_tokens_cur, pos_min, pos_max); + + cur.update_tgt(ctx_tgt, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + cur.update_dft(ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + // stash the draft's speculative state with the checkpoint + common_speculative_get_state(spec.get(), slot.id, cur.data_spec); + + SLT_TRC(slot, + "created context checkpoint %d of %d (pos_min = %d, pos_max = %d, n_tokens = %" PRId64 ", size = %.3f MiB)\n", + (int) slot.prompt.checkpoints.size(), params_base.n_ctx_checkpoints, cur.pos_min, + cur.pos_max, cur.n_tokens, (float) cur.size() / 1024 / 1024); + } + + void process_single_task(server_task && task) { + switch (task.type) { + case SERVER_TASK_TYPE_COMPLETION: + case SERVER_TASK_TYPE_INFILL: + case SERVER_TASK_TYPE_EMBEDDING: + case SERVER_TASK_TYPE_RERANK: + { + // special case: if input is provided via CLI, tokenize it first + // otherwise, no need to tokenize as it's already done inside the HTTP thread + if (task.cli) { + if (!tokenize_cli_input(task)) { + break; + } + } + + const int id_task = task.id; + + server_slot * slot = get_available_slot(task); + + // + // slot scheduling logic + // + + if (slot == nullptr) { + // if no slot is available, we defer this task for processing later + SRV_DBG("no slot is available, defer task, id_task = %d\n", id_task); + queue_tasks.defer(std::move(task)); + break; + } + + if (slot->is_processing()) { + // if requested slot is unavailable, we defer this task for processing later + SRV_DBG("requested slot is unavailable, defer task, id_task = %d\n", id_task); + queue_tasks.defer(std::move(task)); + break; + } + + if (task.is_parent()) { + // try getting free slots for all child tasks + size_t n_child_tasks = task.child_tasks.size(); + std::vector child_slots = get_free_slots(n_child_tasks, slot->id); + if (child_slots.size() < n_child_tasks) { + SRV_DBG("not enough free slots for child tasks, n_free = %zu, n_children = %zu, defer task, id_task = %d\n", child_slots.size(), n_child_tasks, id_task); + queue_tasks.defer(std::move(task)); + break; + } + if (!launch_slots_with_parent_task(*slot, child_slots, std::move(task))) { + SRV_ERR("failed to launch slot with parent task, id_task = %d\n", id_task); + break; // drop the task + } + } else if (!launch_slot_with_task(*slot, std::move(task))) { + SRV_ERR("failed to launch slot with task, id_task = %d\n", id_task); + break; // drop the task + } + + if (params_base.cache_idle_slots) { + for (auto & slot : slots) { + if (!slot.is_processing()) { + SLT_TRC(slot, "%s", "saving idle slot to prompt cache\n"); + + if (slot.prompt_save(*prompt_cache)) { + SLT_DBG(slot, "%s", "__TEST_TAG_CACHE_IDLE_SLOT__\n"); + prompt_cache->update(); + } + + if (params_base.kv_unified) { + // [TAG_IDLE_SLOT_CLEAR] + slot.prompt_clear(); + } + } + } + } + } break; + case SERVER_TASK_TYPE_CANCEL: + { + // release slot linked with the task id + for (auto & slot : slots) { + if (slot.task && slot.task->id == task.id_target) { + slot.release(); + break; + } + } + } break; + case SERVER_TASK_TYPE_CONTROL: + { + auto res = std::make_unique(); + res->id = task.id; + + server_slot * slot = get_slot_by_cmpl_id(task.params.control_cmpl_id); + if (slot == nullptr) { + SRV_WRN("control %s on unknown completion id=%s, no live slot\n", + task.params.control_action.c_str(), task.params.control_cmpl_id.c_str()); + res->success = false; + res->message = "no active completion for this id"; + queue_results.send(std::move(res)); + break; + } + + if (task.params.control_action == "reasoning_end") { + // the budget sampler only exists when reasoning control was armed + if (!slot->task->params.sampling.reasoning_control) { + res->success = false; + res->message = "reasoning control not enabled for this completion"; + queue_results.send(std::move(res)); + break; + } + // act on the live slot mid generation, never defer + common_sampler_reasoning_budget_force(slot->smpl.get()); + res->success = true; + } else { + res->success = false; + res->message = "unknown control action"; + } + + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_NEXT_RESPONSE: + { + // do nothing + } break; + case SERVER_TASK_TYPE_METRICS: + { + json slots_data = json::array(); + + int n_idle_slots = 0; + int n_processing_slots = 0; + + for (server_slot & slot : slots) { + json slot_data = slot.to_json(slots_debug == 0); + + if (slot.is_processing()) { + n_processing_slots++; + } else { + n_idle_slots++; + } + + slots_data.push_back(slot_data); + } + SRV_DBG("n_idle_slots = %d, n_processing_slots = %d\n", n_idle_slots, n_processing_slots); + + auto res = std::make_unique(); + res->id = task.id; + res->slots_data = std::move(slots_data); + res->n_idle_slots = n_idle_slots; + res->n_processing_slots = n_processing_slots; + res->n_tasks_deferred = queue_tasks.queue_tasks_deferred_size(); + res->t_start = metrics.t_start; + + res->n_prompt_tokens_processed_total = metrics.n_prompt_tokens_processed_total; + res->t_prompt_processing_total = metrics.t_prompt_processing_total; + res->n_tokens_predicted_total = metrics.n_tokens_predicted_total; + res->t_tokens_generation_total = metrics.t_tokens_generation_total; + + res->n_tokens_max = metrics.n_tokens_max; + + res->n_prompt_tokens_processed = metrics.n_prompt_tokens_processed; + res->t_prompt_processing = metrics.t_prompt_processing; + res->n_tokens_predicted = metrics.n_tokens_predicted; + res->t_tokens_generation = metrics.t_tokens_generation; + + res->n_decode_total = metrics.n_decode_total; + res->n_busy_slots_total = metrics.n_busy_slots_total; + + res->n_draft_tokens_total = metrics.n_draft_tokens_total; + res->n_draft_accepted_total = metrics.n_draft_accepted_total; + res->n_draft_verif_steps_total = metrics.n_draft_verif_steps_total; + res->n_accepted_per_pos_total = metrics.n_accepted_per_pos_total; + + if (task.metrics_reset_bucket) { + metrics.reset_bucket(); + } + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_SLOT_SAVE: + { + const int id_slot = task.slot_action.id_slot; + server_slot * slot = get_slot_by_id(id_slot); + if (slot == nullptr) { + send_error(task, "Invalid slot ID", ERROR_TYPE_INVALID_REQUEST); + break; + } + if (!check_slot_no_media(*slot, task.id)) { + break; + } + if (slot->is_processing()) { + // if requested slot is unavailable, we defer this task for processing later + SRV_DBG("requested slot is unavailable, defer task, id_task = %d\n", task.id); + queue_tasks.defer(std::move(task)); + break; + } + + const int64_t t_start = ggml_time_us(); + + std::string filename = task.slot_action.filename; + std::string filepath = task.slot_action.filepath; + + const llama_tokens tokens = slot->prompt.tokens.get_text_tokens(); + const size_t token_count = tokens.size(); + const size_t nwrite = llama_state_seq_save_file(ctx_tgt, filepath.c_str(), slot->id, tokens.data(), token_count); + + const int64_t t_end = ggml_time_us(); + const double t_save_ms = (t_end - t_start) / 1000.0; + + auto res = std::make_unique(); + res->id = task.id; + res->id_slot = id_slot; + res->filename = filename; + res->is_save = true; + res->n_tokens = token_count; + res->n_bytes = nwrite; + res->t_ms = t_save_ms; + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_SLOT_RESTORE: + { + const int id_slot = task.slot_action.id_slot; + server_slot * slot = get_slot_by_id(id_slot); + if (slot == nullptr) { + send_error(task, "Invalid slot ID", ERROR_TYPE_INVALID_REQUEST); + break; + } + if (slot->is_processing()) { + // if requested slot is unavailable, we defer this task for processing later + SRV_DBG("requested slot is unavailable, defer task, id_task = %d\n", task.id); + queue_tasks.defer(std::move(task)); + break; + } + + const int64_t t_start = ggml_time_us(); + + std::string filename = task.slot_action.filename; + std::string filepath = task.slot_action.filepath; + + llama_tokens tokens; + tokens.resize(slot->n_ctx); + size_t token_count = 0; + size_t nread = llama_state_seq_load_file(ctx_tgt, filepath.c_str(), slot->id, tokens.data(), tokens.size(), &token_count); + if (nread == 0) { + slot->prompt.clear(); // KV may already been invalidated? + send_error(task, "Unable to restore slot, no available space in KV cache or invalid slot save file", ERROR_TYPE_INVALID_REQUEST); + break; + } + tokens.resize(token_count); + slot->prompt.clear(); + slot->prompt.tokens.insert(tokens); + + const int64_t t_end = ggml_time_us(); + const double t_restore_ms = (t_end - t_start) / 1000.0; + + auto res = std::make_unique(); + res->id = task.id; + res->id_slot = id_slot; + res->filename = filename; + res->is_save = false; + res->n_tokens = token_count; + res->n_bytes = nread; + res->t_ms = t_restore_ms; + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_SLOT_ERASE: + { + const int id_slot = task.slot_action.id_slot; + server_slot * slot = get_slot_by_id(id_slot); + if (slot == nullptr) { + send_error(task, "Invalid slot ID", ERROR_TYPE_INVALID_REQUEST); + break; + } + // Gate on slot content, consistent with save/restore. + if (!check_slot_no_media(*slot, task.id)) { + break; + } + if (slot->is_processing()) { + // if requested slot is unavailable, we defer this task for processing later + SRV_DBG("requested slot is unavailable, defer task, id_task = %d\n", task.id); + queue_tasks.defer(std::move(task)); + break; + } + + // Erase token cache + const size_t n_erased = slot->prompt.tokens.size(); + + slot->prompt_clear(); + + auto res = std::make_unique(); + res->id = task.id; + res->id_slot = id_slot; + res->n_erased = n_erased; + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_GET_LORA: + { + // TODO @ngxson : make lora_adapters a dedicated member of server_context + auto & loras = params_base.lora_adapters; + auto res = std::make_unique(); + res->id = task.id; + for (size_t i = 0; i < loras.size(); ++i) { + auto & lora = loras[i]; + std::string alora_invocation_string = ""; + const uint64_t n_alora_tokens = llama_adapter_get_alora_n_invocation_tokens(lora.ptr); + llama_tokens alora_invocation_tokens; + if (n_alora_tokens) { + const llama_token * alora_tokens = llama_adapter_get_alora_invocation_tokens(lora.ptr); + for (uint64_t j = 0; j < n_alora_tokens; ++j) { + alora_invocation_string += common_token_to_piece(vocab, alora_tokens[j]); + alora_invocation_tokens.push_back(alora_tokens[j]); + } + } + res->loras.push_back(server_task_result_get_lora::lora{ + lora, + alora_invocation_string, + alora_invocation_tokens, + }); + } + queue_results.send(std::move(res)); + } break; + case SERVER_TASK_TYPE_SET_LORA: + { + auto new_loras = construct_lora_list(task.set_lora); + // logging + for (size_t i = 0; i < new_loras.size(); ++i) { + SRV_TRC("set lora adapter idx=%zu scale=%f\n", i, new_loras[i].scale); + } + // TODO @ngxson : make lora_adapters a dedicated member of server_context + params_base.lora_adapters = new_loras; + auto res = std::make_unique(); + res->id = task.id; + queue_results.send(std::move(res)); + } break; + } + } + + void iterate(std::vector & slots, std::function callback) { + for (auto & slot : slots) { + try { + callback(slot); + } catch (const std::exception & e) { + SLT_ERR(slot, "got exception: %s\n", e.what()); + send_error(slot, std::string("got exception: ") + e.what(), ERROR_TYPE_SERVER); + slot.release(); + } + } + } + + void iterate(std::vector & slots, std::function callback) { + for (auto & slot : slots) { + try { + callback(*slot); + } catch (const std::exception & e) { + SLT_ERR(*slot, "got exception: %s\n", e.what()); + send_error(*slot, std::string("got exception: ") + e.what(), ERROR_TYPE_SERVER); + slot->release(); + } + } + } + + void abort_all_slots(const std::string & reason) { + for (auto & slot : slots) { + if (slot.is_processing()) { + send_error(slot, reason, ERROR_TYPE_SERVER); + slot.release(); + } + } + } + + // @ngxson : for debugging only + int64_t t_pre_decode = 0; + int64_t t_decode = 0; + int64_t t_post_decode = 0; + int64_t t_sampl = 0; + int64_t n_pre_decode = 0; + int64_t n_decode = 0; + int64_t n_post_decode = 0; + int64_t n_sampl = 0; +// #define DEBUG_TIMINGS +#ifdef DEBUG_TIMINGS + struct scoped_timer { + int64_t & t; + int64_t & n; + int64_t t_start; + scoped_timer(int64_t & t_, int64_t & n_) : t(t_), n(n_) { + t_start = ggml_time_us(); + } + ~scoped_timer() { + t += ggml_time_us() - t_start; + n++; + } + }; +#else + struct scoped_timer { + scoped_timer(int64_t &, int64_t &) {} + ~scoped_timer() {} + }; +#endif + + void update_slots() { +#ifdef DEBUG_TIMINGS + static int64_t t_prev = 0; + int64_t t_start = ggml_time_us(); + if (t_start - t_prev > 5 * 1000 * 1000) { // every 5 seconds + t_prev = t_start; + SRV_INF("n_pre_decode = %" PRId64 "\n", n_pre_decode); + SRV_INF("avg t_pre_decode = %f ms\n", (double) t_pre_decode / n_pre_decode / 1000.0); + SRV_INF("avg t_decode = %f ms\n", (double) t_decode / n_decode / 1000.0); + SRV_INF("avg t_post_decode = %f ms\n", (double) t_post_decode / n_post_decode / 1000.0); + SRV_INF("avg t_sampl = %f ms\n", (double) t_sampl / n_sampl / 1000.0); + } +#endif + + // check if all slots are idle + { + bool all_idle = true; + + for (auto & slot : slots) { + if (slot.is_processing()) { + all_idle = false; + break; + } + } + + if (all_idle) { + SRV_TRC("%s", "all slots are idle\n"); + return; // skip further processing + + } else { + SRV_DBG("%s", "posting NEXT_RESPONSE\n"); + + server_task task(SERVER_TASK_TYPE_NEXT_RESPONSE); + task.id = queue_tasks.get_new_id(); + queue_tasks.post(std::move(task)); + } + } + + try { + scoped_timer t(t_pre_decode, n_pre_decode); + pre_decode(); + batch.render(); + } catch (const std::exception & e) { + SRV_ERR("pre_decode() failed: %s\n", e.what()); + abort_all_slots("pre_decode() failed: " + std::string(e.what())); + } + + GGML_ASSERT(batch.slot_batched || batch.size() == 0); + + if (batch.slot_batched) { + auto & slot_batched = batch.slot_batched; + auto & alora_scale = batch.alora_scale; + auto & alora_disabled_id = batch.alora_disabled_id; + + // TODO @ngxson : alora handling is too messy, need to refactor it to be more clear and maintainable + // apply lora, only need to do it once per batch + common_set_adapter_lora(ctx_tgt, slot_batched->lora); + + // if the lora is temporarily disabled for an alora, re-enable it + // for next time + if (alora_scale > 0.0f) { + SRV_DBG("re-enabling alora with scale %f\n", alora_scale); + slot_batched->lora[alora_disabled_id].scale = alora_scale; + } + + llama_set_embeddings(ctx_tgt, slot_batched->need_embd()); + } + + llama_batch batch_view; + int32_t off_next = 0; + int32_t n_batch = llama_n_batch(ctx_tgt); + for (int32_t off = 0; off < batch.size(); off = off_next) { + const int32_t n_tokens = std::min(n_batch, batch.size() - off); + try { + scoped_timer t(t_decode, n_decode); + // TODO @ngxson : maybe handle n_batch == 1 here instead of inside decode() + + batch_view = batch.get_view(off, n_tokens); + bool ok = decode(n_batch, off, batch_view); +#ifdef DEBUG_TIMINGS + llama_synchronize(ctx_tgt); +#endif + + if (ok) { + // move the head of the batch forward with the number of tokens we just processed + off_next = off + n_tokens; + + // on successful decode, restore the original batch size + n_batch = llama_n_batch(ctx_tgt); + } else { + // try again with the updated n_batch + continue; + } + } catch (const std::exception & e) { + SRV_ERR("decode() failed: %s\n", e.what()); + abort_all_slots("decode() failed: " + std::string(e.what())); + break; // stop any further processing + } + + try { + scoped_timer t(t_post_decode, n_post_decode); + post_decode(n_tokens, off, batch_view); + } catch (const std::exception & e) { + SRV_ERR("post_decode() failed: %s\n", e.what()); + abort_all_slots("post_decode() failed: " + std::string(e.what())); + break; // stop any further processing + } + } + } + + void pre_decode() { + // apply context-shift if needed + // TODO: simplify and improve + iterate(slots, [&](server_slot & slot) { + if (slot.state == SLOT_STATE_GENERATING && slot.prompt.n_tokens() + 1 >= slot.n_ctx) { + if (!params_base.ctx_shift) { + // this check is redundant (for good) + // we should never get here, because generation should already stopped in process_token() + send_error(slot, "context shift is disabled", ERROR_TYPE_SERVER); + slot.release(); + return; + } + + if (mctx) { + // we should never reach this because params_base.ctx_shift is automatically disabled if mmproj is loaded + // we don't support ctx_shift because an image chunk may contains multiple tokens + GGML_ABORT("not supported by multimodal"); + } + + if (slot.task->is_parent() || slot.task->is_child()) { + send_error(slot, "context shift cannot be used for shared prompt", ERROR_TYPE_SERVER); + slot.release(); + return; + } + + // Shift context + int n_keep = slot.task->params.n_keep < 0 ? slot.task->n_tokens() : slot.task->params.n_keep; + + if (add_bos_token) { + n_keep += 1; + } + + n_keep = std::min(slot.n_ctx - 4, n_keep); + + const int n_left = slot.prompt.n_tokens() - n_keep; + int n_discard = slot.task->params.n_discard ? slot.task->params.n_discard : (n_left / 2); + + // ref: https://github.com/ggml-org/llama.cpp/pull/24786 + n_discard = std::clamp(n_discard, 0, std::max(0, n_left - 1)); + + SLT_WRN(slot, "slot context shift, n_keep = %d, n_left = %d, n_discard = %d\n", n_keep, n_left, n_discard); + + slot.mem.seq_rm (slot.id, n_keep , n_keep + n_discard); + slot.mem.seq_add(slot.id, n_keep + n_discard, slot.prompt.tokens.pos_next(), -n_discard); + + // add generated tokens to cache + // ref: https://github.com/ggml-org/llama.cpp/pull/16818#discussion_r2473269481 + { + GGML_ASSERT(!slot.prompt.tokens.has_mtmd); + + llama_tokens new_tokens = slot.prompt.tokens.get_tokens(); // copy + for (size_t i = n_keep + n_discard; i < new_tokens.size(); i++) { + new_tokens[i - n_discard] = new_tokens[i]; + } + + new_tokens.resize(slot.prompt.tokens.size() - n_discard); + + slot.prompt.clear(); + slot.prompt.tokens.insert(new_tokens); + } + + slot.truncated = true; + } + }); + + // start populating the batch for this iteration + batch.clear(); + + // track if given slot can be batched with slots already in the batch + auto & slot_batched = batch.slot_batched; + + std::vector generating; + std::vector drafting; + + // determine which slots are generating and drafting + iterate(slots, [&](server_slot & slot) { + if (slot.state != SLOT_STATE_GENERATING) { + return; + } + + // check if we can batch this slot with the previous one + if (!slot_batched) { + slot_batched = &slot; + } else if (!slot_batched->can_batch_with(slot)) { + return; + } + + generating.push_back(&slot); + + if (spec) { + common_speculative_get_draft_params(spec.get(), slot.id).drafting = false; + + const bool use_ckpt_tgt = ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL; + const bool use_ckpt_dft = ctx_dft_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL; + + const int n_draft_max = slot.get_n_draft_max(); + + if (n_draft_max > 0) { + GGML_ASSERT(slot.can_speculate()); + + if (!slot.spec_draft.empty()) { + // we have a previous (partial) draft to reuse + if (use_ckpt_tgt) { + GGML_ASSERT(!slot.spec_ckpt.empty()); + } + } else { + GGML_ASSERT(slot.spec_i_batch.empty()); + + slot.spec_ckpt.update_pos( + slot.prompt.n_tokens(), + llama_memory_seq_pos_min(llama_get_memory(ctx_tgt), slot.id), + llama_memory_seq_pos_max(llama_get_memory(ctx_tgt), slot.id)); + + if (use_ckpt_dft) { + slot.spec_ckpt.update_dft(ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + } + + slot.spec_prompt = slot.prompt.tokens.get_text_tokens(); + + common_speculative_get_draft_params(spec.get(), slot.id) = { + /* .drafting = */ true, + /* .n_max = */ n_draft_max, + /* .n_past = */ slot.prompt.n_tokens(), + /* .id_last = */ slot.sampled, + /* .prompt = */ &slot.spec_prompt, + /* .result = */ &slot.spec_draft, + }; + + drafting.push_back(&slot); + } + } + } + }); + + // generate the actual drafts (if any) + { + common_speculative_draft(spec.get()); + } + + // make checkpoints if needed + iterate(drafting, [&](server_slot & slot) { + auto & draft = slot.spec_draft; + auto & ckpt = slot.spec_ckpt; + + slot.n_draft_total += draft.size(); + + // TODO: avoid restoring the draft context and re-evaluating the drafted tokens when not needed [TAG_SPEC_AVOID_DRAFT_REEVAL] + const bool use_ckpt_dft = ctx_dft_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL; + + if (ctx_dft) { + if (use_ckpt_dft) { + ckpt.load_dft(ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + } + + if (!llama_memory_seq_rm(llama_get_memory(ctx_dft), slot.id, ckpt.pos_max + 1, -1)) { + GGML_ABORT("failed to remove sequence %d\n", slot.id); + } + } + + if (!draft.empty()) { + const bool use_ckpt_tgt = + ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL || + (ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_RS && draft.size() > llama_n_rs_seq(ctx_tgt)); + + const bool use_ckpt_dft = + (ctx_dft_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_RS && draft.size() > llama_n_rs_seq(ctx_dft)); + + if (use_ckpt_tgt) { + //const int64_t t_start = ggml_time_us(); + + ckpt.update_tgt(ctx_tgt, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + + //const int64_t t_total = ggml_time_us() - t_start; + //printf("checkpoint total: %f ms\n", t_total / 1000.0); + + SLT_DBG(slot, "created speculative checkpoint (pos_min = %d, pos_max = %d, n_tokens = %d, size = %.3f MiB, draft = %.3f MiB)\n", + ckpt.pos_min, ckpt.pos_max, slot.prompt.n_tokens(), + (float) ckpt.size() / 1024 / 1024, + (float) ckpt.data_dft.size() / 1024 / 1024); + } + + if (use_ckpt_dft) { + ckpt.update_dft(ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + } + } + }); + + // update the batch with the sampled/drafted tokens + iterate(generating, [&](server_slot & slot) { + slot.handle_last_sampled_token(batch); + }); + + // process in chunks of params.n_batch + int32_t n_batch = llama_n_batch(ctx_tgt); + int32_t n_ubatch = llama_n_ubatch(ctx_tgt); + + auto & alora_scale = batch.alora_scale; + auto & alora_disabled_id = batch.alora_disabled_id; + + // next, batch any pending prompts without exceeding n_batch + if (params_base.cont_batching || batch.size() == 0) { + bool add_ok = true; // false means the batch is full, skip remaining slots + + iterate(slots, [&](server_slot & slot) { + if (!add_ok || batch.size() >= n_batch) { + return; // batch is full, skip remaining slots + } + + if (!slot.is_processing()) { + return; + } + + // check if we can batch this slot with the previous one + if (slot_batched && !slot_batched->can_batch_with(slot)) { + return; + } + + // check if this is a child slot + if (slot.state == SLOT_STATE_WAIT_OTHER) { + SLT_DBG(slot, "%s", "waiting for parent slot to complete\n"); + return; + } + + // this slot still has a prompt to be processed + if (slot.state == SLOT_STATE_PROCESSING_PROMPT || slot.state == SLOT_STATE_STARTED) { + const auto & input_tokens = slot.task->tokens; + + // used to determine the number of tokens added to the batch for the current slot + const auto n_tokens_prev = batch.size(); + + // TODO: maybe move branch to outside of this loop in the future + if (slot.state == SLOT_STATE_STARTED) { + slot.t_start_process_prompt = ggml_time_us(); + slot.t_start_generation = 0; + + slot.state = SLOT_STATE_PROCESSING_PROMPT; + + SLT_TRC(slot, "new prompt, n_ctx_slot = %d, n_keep = %d, task.n_tokens = %d\n", + slot.n_ctx, slot.task->params.n_keep, slot.task->n_tokens()); + + // print prompt tokens (for debugging) + /*if (1) { + // first 16 tokens (avoid flooding logs) + for (int i = 0; i < std::min(16, input_tokens.size()); i++) { + SLT_DBG(slot, "prompt token %3d: %6d '%s'\n", i, input_tokens[i], common_token_to_piece(ctx_tgt, input_tokens[i]).c_str()); + } + } else { + // all + for (int i = 0; i < (int) input_tokens.size(); i++) { + SLT_DBG(slot, "prompt token %3d: %6d '%s'\n", i, input_tokens[i], common_token_to_piece(ctx_tgt, input_tokens[i]).c_str()); + } + }*/ + + // keep track how many tokens we can reuse from the previous state + int n_past = 0; + + // empty prompt passed -> release the slot and send empty response + if (input_tokens.empty()) { + SLT_WRN(slot, "%s", "empty prompt - releasing slot\n"); + + slot.print_timings(); + send_final_response(slot); + slot.release(); + + return; + } + + // TODO: support memory-less logits computation + if (slot.task->need_logits() && !llama_get_memory(ctx_tgt)) { + send_error(slot, "the current context does not logits computation. skipping", ERROR_TYPE_SERVER); + slot.release(); + return; + } + + if (!slot.can_split()) { + if (slot.task->n_tokens() > n_ubatch) { + send_error(slot, + string_format( + "input (%d tokens) is too large to process. increase the physical batch " + "size (current batch size: %d)", + slot.task->n_tokens(), n_ubatch), + ERROR_TYPE_SERVER); + slot.release(); + return; + } + + if (slot.task->n_tokens() > slot.n_ctx) { + send_error( + slot, + string_format( + "input (%d tokens) is larger than the max context size (%d tokens). skipping", + slot.task->n_tokens(), slot.n_ctx), + ERROR_TYPE_EXCEED_CONTEXT_SIZE); + slot.release(); + return; + } + } else { + if (slot.task->n_tokens() >= slot.n_ctx) { + send_error(slot, + string_format("request (%d tokens) exceeds the available context size (%d " + "tokens), try increasing it", + slot.task->n_tokens(), slot.n_ctx), + ERROR_TYPE_EXCEED_CONTEXT_SIZE); + slot.release(); + return; + } + + if (slot.task->params.cache_prompt) { + // reuse any previously computed tokens that are common with the new prompt + n_past = slot.prompt.tokens.get_common_prefix(input_tokens); + + // if there is an alora invoked, don't cache after the invocation start + if (slot.alora_invocation_start > 0) { + SLT_DBG(slot, "only caching to alora invocation start (n_past = %d, alora_invocation_start = %d)\n", n_past, slot.alora_invocation_start); + n_past = std::min(n_past, slot.alora_invocation_start - 1); + } + + const auto n_cache_reuse = slot.task->params.n_cache_reuse; + + const bool can_cache_reuse = + llama_memory_can_shift(llama_get_memory(ctx_tgt)) && + !slot.prompt.tokens.has_mtmd; + + if (!can_cache_reuse && n_cache_reuse > 0) { + SLT_WRN(slot, "cache reuse is not supported - ignoring n_cache_reuse = %d\n", n_cache_reuse); + } + + // reuse chunks from the cached prompt by shifting their KV cache in the new position + if (can_cache_reuse && n_cache_reuse > 0) { + GGML_ASSERT(!slot.prompt.tokens.has_mtmd); + + size_t head_c = n_past; // cache + size_t head_p = n_past; // current prompt + + if (mctx) { + // we should never reach this + GGML_ABORT("not supported by multimodal"); + } + + SLT_DBG(slot, "trying to reuse chunks with size > %d, n_past = %d\n", n_cache_reuse, n_past); + + while (head_c < slot.prompt.tokens.size() && + head_p < input_tokens.size()) { + + size_t n_match = 0; + while (head_c + n_match < slot.prompt.tokens.size() && + head_p + n_match < input_tokens.size() && + slot.prompt.tokens[head_c + n_match] == input_tokens[head_p + n_match]) { + n_match++; + } + + if (n_match >= (size_t) n_cache_reuse) { + SLT_TRC(slot, "reusing chunk with size %zu, shifting KV cache [%zu, %zu) -> [%zu, %zu)\n", n_match, head_c, head_c + n_match, head_p, head_p + n_match); + //for (size_t i = head_p; i < head_p + n_match; i++) { + // SLT_DBG(slot, "cache token %3zu: %6d '%s'\n", i, prompt_tokens[i], common_token_to_piece(ctx_tgt, prompt_tokens[i]).c_str()); + //} + + const int64_t kv_shift = (int64_t) head_p - (int64_t) head_c; + + slot.mem.seq_rm (slot.id, head_p, head_c); + slot.mem.seq_add(slot.id, head_c, head_c + n_match, kv_shift); + + for (size_t i = 0; i < n_match; i++) { + slot.prompt.tokens.set_token(head_p + i, slot.prompt.tokens[head_c + i]); + n_past++; + } + + head_c += n_match; + head_p += n_match; + } else { + head_c += 1; + } + } + + SLT_DBG(slot, "after context reuse, new n_past = %d\n", n_past); + } + } else { + // if we don't cache the prompt, we have to remove all previous tokens + n_past = 0; + } + + llama_pos pos_next = slot.prompt.tokens.pos_next(n_past); + + // ref: https://github.com/ggml-org/llama.cpp/pull/24110 + const bool has_new_tokens = (n_past < slot.task->n_tokens()); + + // the largest pos_min required for a checkpoint to be useful + const auto pos_min_thold = std::max(0, pos_next - n_swa - (has_new_tokens ? 0 : 1)); + + if (n_past > 0 && n_past <= slot.prompt.n_tokens()) { + const auto pos_min = llama_memory_seq_pos_min(llama_get_memory(ctx_tgt), slot.id); + if (pos_min == -1) { + SLT_ERR(slot, "n_past = %d, slot.prompt.tokens.size() = %d, seq_id = %d, pos_min = %d\n", n_past, (int) slot.prompt.tokens.size(), slot.id, pos_min); + GGML_ABORT("pos_min == -1, but n_past > 0 - should not happen: https://github.com/ggml-org/llama.cpp/pull/13833#discussion_r2116181237"); + } + + // when the prompt prefix does not match, print the tokens around the mismatch + // this is useful for debugging prompt caching + if (slots_debug) { + const int np0 = std::max(n_past - 4, 0); + const int np1 = std::min(n_past + 6, std::min(slot.prompt.tokens.size(), slot.task->tokens.size())); + + std::stringstream ss0; + std::stringstream ss1; + + std::stringstream st0; + std::stringstream st1; + + ss0 << "old: ... "; + ss1 << "new: ... "; + + for (int i = np0; i < np1; i++) { + if (i == n_past) { + ss0 << " | "; + ss1 << " | "; + } + + { + const auto token = slot.prompt.tokens[i]; + const auto piece = token != LLAMA_TOKEN_NULL ? common_token_to_piece(ctx_tgt, token) : "[mtmd]"; + ss0 << piece; + st0 << std::setw(8) << token; + } + + { + const auto token = slot.task->tokens[i]; + const auto piece = token != LLAMA_TOKEN_NULL ? common_token_to_piece(ctx_tgt, token) : "[mtmd]"; + ss1 << piece; + st1 << std::setw(8) << token; + } + } + + SLT_WRN(slot, "%s\n", ss0.str().c_str()); + SLT_WRN(slot, "%s\n", ss1.str().c_str()); + + SLT_WRN(slot, "%s\n", st0.str().c_str()); + SLT_WRN(slot, "%s\n", st1.str().c_str()); + } + + if (pos_min >= pos_min_thold) { + // search for a context checkpoint + const auto it = std::find_if( + slot.prompt.checkpoints.rbegin(), + slot.prompt.checkpoints.rend(), + [&](const auto & cur) { + // guarantee that a checkpoint will result in at least one token being processed [TAG_PROMPT_LOGITS] + SLT_TRC(slot, "checking checkpoint with [%d, %d] against %d...\n", cur.pos_min, cur.pos_max, pos_min_thold); + // workaround for [TAG_CHECKPOINTS_FIX_POS_MIN] + if (cur.pos_max > pos_next) { + return false; + } + return cur.pos_min < pos_min_thold || cur.pos_min == 0; + } + ); + + bool do_reset = it == slot.prompt.checkpoints.rend(); + + if (!do_reset) { + // restore the context checkpoint + it->load_tgt(ctx_tgt, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + it->load_dft(ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + // restore the draft's speculative state + common_speculative_set_state(spec.get(), slot.id, it->data_spec); + + pos_next = std::min(pos_next, std::max(it->pos_min + 1, it->pos_max)); + n_past = std::min(slot.prompt.tokens.size_up_to_pos(pos_next), (size_t) it->n_tokens); + SLT_TRC(slot, "restored context checkpoint (pos_min = %d, pos_max = %d, n_tokens = %" PRId64 ", n_past = %d, size = %.3f MiB)\n", it->pos_min, it->pos_max, it->n_tokens, n_past, (float) it->size() / 1024 / 1024); + } + + if (do_reset) { + SLT_TRC(slot, "forcing full prompt re-processing due to lack of cache data (likely due to SWA or hybrid/recurrent memory, see %s)\n", + "https://github.com/ggml-org/llama.cpp/pull/13194#issuecomment-2868343055"); + pos_next = 0; + n_past = 0; + } + } + } + + { + // erase any checkpoints with pos_max > pos_next + for (auto it = slot.prompt.checkpoints.begin(); it != slot.prompt.checkpoints.end();) { + const auto & cur = *it; + if (cur.pos_max > pos_next) { + SLT_TRC(slot, "erased invalidated context checkpoint (pos_min = %d, pos_max = %d, n_tokens = %" PRId64 ", n_swa = %d, pos_next = %d, size = %.3f MiB)\n", cur.pos_min, cur.pos_max, cur.n_tokens, n_swa, pos_next, (float) cur.size() / 1024 / 1024); + it = slot.prompt.checkpoints.erase(it); + } else { + ++it; + } + } + } + } + + // [TAG_PROMPT_LOGITS] + if (n_past == slot.task->n_tokens() && n_past > 0) { + SLT_WRN(slot, "need to evaluate at least 1 token for each active slot (n_past = %d, task.n_tokens() = %d)\n", n_past, slot.task->n_tokens()); + n_past--; + SLT_WRN(slot, "n_past was set to %d\n", n_past); + } + + slot.n_prompt_tokens_cache = n_past; + slot.n_prompt_tokens_processed = 0; + + slot.prompt.tokens.keep_first(n_past); + + // this is to signal the client that the request has started processing + if (slot.task->params.stream) { + if (slot.task->params.return_progress) { + // send initial 0% progress update if needed + send_partial_response(slot, {}, true); + } else { + // otherwise, for streaming without progress, signal HTTP to send the headers (i.e. 200 status) + send_partial_response(slot, {}, false, true); + } + } + } // end of SLOT_STATE_STARTED + + if (!slot.can_split()) { + // cannot fit the prompt in the current batch - will try next iter + if (batch.size() + slot.task->n_tokens() > n_batch) { + return; + } + } + + const int64_t t_now = ggml_time_us(); + slot.t_prompt_processing = (t_now - slot.t_start_process_prompt) / 1e3; + slot.print_timings_pp(); + + // truncate any tokens that are beyond n_past for this slot + const llama_pos p0 = slot.prompt.tokens.pos_next(); + + SLT_TRC(slot, "cached n_tokens = %d, memory_seq_rm [%d, end)\n", slot.prompt.n_tokens(), p0); + + slot.mem.seq_rm(slot.id, p0, -1); + + // If using an alora, there may be uncached tokens that come + // before the invocation sequence. When this happens, the + // tokens before the invocation sequence need to be + // processed without the adapter in a separate batch, then + // the adapter needs to be enabled for the remaining tokens. + if (lora_all_alora(slot.lora) && slot.alora_invocation_start - 1 > slot.prompt.n_tokens()) { + SLT_DBG(slot, "processing pre-alora tokens without the adapter (n_tokens = %d, alora_invocation_start = %d)\n", slot.prompt.n_tokens(), slot.alora_invocation_start); + const auto & enabled_loras = lora_get_enabled_ids(slot.lora); + GGML_ASSERT(enabled_loras.size() == 1); + alora_scale = slot.lora[enabled_loras[0]].scale; + slot.lora[enabled_loras[0]].scale = 0.0f; + alora_disabled_id = enabled_loras[0]; + } + + bool do_checkpoint = params_base.n_ctx_checkpoints > 0; + + // make checkpoints only for completion tasks + do_checkpoint = do_checkpoint && slot.task->type == SERVER_TASK_TYPE_COMPLETION; + + // make a checkpoint of the parts of the memory that cannot be rolled back. + // checkpoints are created only if: + // - the model does not support partial sequence removal + // - the model uses SWA (and we are not using `swa_full`) + // - the model supports partial sequence removal but only up to a fixed bound + do_checkpoint = do_checkpoint && ( + ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL || + ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_RS || + n_swa > 0); + + bool has_mtmd = false; + + // check if we should process the image + while (true) { + auto cur_token_idx = slot.prompt.n_tokens(); + if ( + cur_token_idx >= slot.task->n_tokens() || + input_tokens[cur_token_idx] != LLAMA_TOKEN_NULL // encountered a text token + ) { + break; + } + + // process the image + size_t n_tokens_out = 0; + int32_t res = slot.process_mtmd_chunk(cur_token_idx, n_tokens_out); + if (res != 0) { + SLT_ERR(slot, "failed to process image, res = %d\n", res); + send_error(slot, "failed to process image", ERROR_TYPE_SERVER); + slot.release(); + continue; + } + + slot.n_prompt_tokens_processed += n_tokens_out; + + // add the image chunk to cache + { + const auto & chunk = input_tokens.find_chunk(cur_token_idx); + slot.prompt.tokens.push_back(chunk.get()); // copy + } + + has_mtmd = true; + } + + const auto & spans = slot.task->params.message_spans; + const auto last_user_pos = spans.last_user_message_pos(); + + // add prompt tokens for processing in the current batch + while (slot.prompt.n_tokens() < slot.task->n_tokens() && batch.size() < n_batch) { + // get next token to process + llama_token cur_tok = input_tokens[slot.prompt.n_tokens()]; + if (cur_tok == LLAMA_TOKEN_NULL) { + break; // end of text chunk + } + + // if this is an alora request with pre-invocation + // tokens that are not cached, we need to stop filling + // this batch at those pre-invocation tokens. + if (alora_scale > 0 && slot.prompt.n_tokens() == slot.alora_invocation_start - 1) { + SLT_DBG(slot, "stop prompt batch filling at (n_tokens = %d, alora_invocation_start = %d)\n", slot.prompt.n_tokens(), slot.alora_invocation_start); + break; + } + + // embedding requires all tokens in the batch to be output; + // MTP also wants logits at every prompt position so the + // streaming hook can mirror t_h_nextn into ctx_dft. + add_ok &= batch.add(slot.id, + cur_tok, + slot.prompt.tokens.pos_next(), + slot.need_embd()); + slot.prompt.tokens.push_back(cur_tok); + + slot.n_prompt_tokens_processed++; + + // break at the last user message, or at user messages at least min step past the last checkpoint + if (do_checkpoint && spans.is_user_start(slot.prompt.n_tokens())) { + const auto pos = slot.prompt.n_tokens(); + const auto & checkpoints = slot.prompt.checkpoints; + + if (pos == last_user_pos || checkpoints.empty() || pos > checkpoints.back().n_tokens + params_base.checkpoint_min_step) { + break; + } + } + + // process the last few tokens of the prompt separately in order to allow for a checkpoint to be created. + // create checkpoints that many tokens before the end of the prompt: + // - 4 + n_ubatch + // - 4 + // ref: https://github.com/ggml-org/llama.cpp/pull/20288 + if (do_checkpoint) { + static const int checkpoint_offsets[] = {4 + n_ubatch, 4}; + + bool should_break = false; + for (int offset : checkpoint_offsets) { + const int n_last = std::min(n_batch, offset); + if (slot.task->n_tokens() == slot.prompt.n_tokens() + n_last) { + should_break = true; + break; + } + } + if (should_break) { + break; + } + } + } + + // the number of tokens added to the batch for the current slot + const auto n_tokens_cur = batch.size() - n_tokens_prev; + + const auto n_tokens_start = slot.prompt.n_tokens() - n_tokens_cur; + + const bool near_prompt_end = slot.task->n_tokens() < slot.prompt.n_tokens() + n_ubatch; + + const bool is_user_start = spans.is_user_start(n_tokens_start); + const bool is_last_user_message = n_tokens_start == last_user_pos; + + // entire prompt has been processed + if (slot.prompt.n_tokens() == slot.task->n_tokens()) { + slot.state = SLOT_STATE_DONE_PROMPT; + + GGML_ASSERT(batch.size() > 0); + + // extract the logits only for the last token + batch.set_output(batch.size() - 1, true); + + slot.n_decoded = 0; + slot.i_batch = batch.size() - 1; + + slot.init_sampler(); + } else { + // skip ordinary mid-prompt checkpoints, unless the batch starts a user + // message or we are near the end of the prompt + if (!is_user_start && !near_prompt_end) { + do_checkpoint = false; + } + } + + const auto pos_min = llama_memory_seq_pos_min(llama_get_memory(ctx_tgt), slot.id); + const auto pos_max = llama_memory_seq_pos_max(llama_get_memory(ctx_tgt), slot.id); + + // nothing to checkpoint yet + // TODO: is this check needed? + if (do_checkpoint && pos_min < 0) { + do_checkpoint = false; + } + + // do not checkpoint after mtmd chunks + do_checkpoint = do_checkpoint && !has_mtmd; + + // no need to create checkpoints that are too close together, unless it's the last user message + do_checkpoint = do_checkpoint && ( + slot.prompt.checkpoints.empty() || + is_last_user_message || near_prompt_end || + n_tokens_start > slot.prompt.checkpoints.back().n_tokens + params_base.checkpoint_min_step); + SLT_DBG(slot, "main/do_checkpoint = %s, pos_min = %d, pos_max = %d\n", do_checkpoint ? "yes" : "no", pos_min, pos_max); + + // note: we create the checkpoint before calling llama_decode(), so the current batch is not + // yet processed and therefore it is not part of the checkpoint. + if (do_checkpoint) { + create_checkpoint(slot, n_tokens_cur, pos_min, pos_max); + } + } + + if (!slot_batched) { + slot_batched = &slot; + } + }); + } + } + + // returns true = success ; false = retry with smaller batch size + // throw std::runtime_error on fatal error + bool decode(int32_t & n_batch, int32_t off, llama_batch & batch_view) { + SRV_DBG("n_batch (effective) = %d, off = %d\n", n_batch, off); + + if (batch.size() == 0) { + SRV_WRN("%s", "no tokens to decode\n"); + + if (++n_empty_consecutive > 3) { + GGML_ABORT("fatal error - please provide logs and repro in %s\n", "https://github.com/ggml-org/llama.cpp/pull/20277"); + } + + return true; // nothing to decode + } else { + n_empty_consecutive = 0; + } + + // TODO @ngxson : dft model may have different n_embd than the tgt model, so we check & reject if that's the case + // this case is not currently used by any models, but may need to be supported in the future + if (spec && batch.has_embd) { + if (llama_model_n_embd_inp(model_dft) != llama_model_n_embd_inp(model_tgt)) { + SRV_ERR("%s", "unsupported batch.has_embd + spec case\n"); + throw std::runtime_error("unsupported batch.has_embd + spec case"); + } + } + + const int ret = llama_decode(ctx_tgt, batch_view); + + metrics.on_decoded(slots); + + if (ret != 0) { + { + std::string err; + + if (n_batch == 1 && ret == 1) { + // TODO: try to terminate only the largest active slot/sequence and continue with the rest + // need to remove the tokens from the current batch too + err = "Context size has been exceeded."; + } + + if (ret == -1) { + err = "Invalid input batch."; + } + + if (ret < -1) { + // TODO: update slot state based on llama_memory_seq_pos_min() and llama_memory_seq_pos_max() + err = "Compute error."; + } + + // TODO: handle ret == 2 (abort) when we start aborting + + if (!err.empty()) { + SRV_ERR("%s off = %d, n_batch = %d, ret = %d\n", err.c_str(), off, n_batch, ret); + + for (auto & slot : slots) { + if (slot.is_processing()) { + send_error(slot, err); + slot.release(); + + // note: it's complicated to keep track of how much of the current batch has been + // processed before the error occurred, so we simply clear the entire context + slot.prompt_clear(); + } + } + + // stop, do not retry with smaller batch size + throw std::runtime_error(err); + } + } + + // retry with half the batch size to try to find a free slot in the KV cache + if (!try_clear_idle_slots()) { + n_batch /= 2; + } + + SRV_WRN("failed to find free space in the KV cache, retrying with smaller batch size, off = %d, n_batch = %d, ret = %d\n", off, n_batch, ret); + + return false; // retry with the updated n_batch + } + + // TODO: avoid restoring the draft context and re-evaluating the drafted tokens when not needed [TAG_SPEC_AVOID_DRAFT_REEVAL] + // for now, always re-evaluate for simplicity + // ref: https://github.com/ggml-org/llama.cpp/pull/22728#issuecomment-4400925384 + if (!common_speculative_process(spec.get(), batch_view)) { + SRV_ERR("%s", "failed to process speculative batch\n"); + + // TODO: handle error + throw std::runtime_error("failed to process speculative batch"); + } + + // handle `n_cmpl > 1` tasks - when the main prompt is processed, activate all child tasks too + for (auto & slot : slots) { + if (slot.state == SLOT_STATE_DONE_PROMPT && slot.task->is_parent()) { + std::vector children; + for (auto & other : slots) { + if (other.state == SLOT_STATE_WAIT_OTHER && slot.task->id == other.task->id_parent) { + children.push_back(&other); + } + } + + // all children slots should already launched by launch_slots_with_parent_task() + // copy state to the child slots + for (auto & child : children) { + SLT_TRC(slot, " - copying state to child %d\n", child->id); + + GGML_ASSERT(child->state == SLOT_STATE_WAIT_OTHER); + + slot.copy_state_to(*child); + child->state = SLOT_STATE_DONE_PROMPT; + } + } + } + + return true; + } + + void post_decode(int32_t n_batch_tokens, int32_t off, llama_batch & batch_view) { + // for checking if a given batch index is inside batch_view + auto is_inside_view = [&](int32_t idx) { + return idx >= off && idx < off + n_batch_tokens; + }; + + // TODO @ngxson : it's tricky to make sub-batch compatible with common_sampler_sample_and_accept_n, + // so for now we will throw an error in this case: https://github.com/ggml-org/llama.cpp/issues/24840 + iterate(slots, [&](server_slot & slot) { + for (auto & i : slot.spec_i_batch) { + if (!is_inside_view(i)) { + throw std::runtime_error(string_format("speculative batch index %d is not inside the current sub-batch [%d, %d)", i, off, off + n_batch_tokens)); + } + } + }); + + auto accept_special_token = [&](server_slot & slot, llama_token token) { + return params_base.special || + slot.task->params.sampling.preserved_tokens.find(token) != slot.task->params.sampling.preserved_tokens.end(); + }; + + iterate(slots, [&](server_slot & slot) { + // optionally send prompt processing progress + if (slot.state == SLOT_STATE_PROCESSING_PROMPT || slot.state == SLOT_STATE_DONE_PROMPT) { + if (slot.task->params.stream && slot.task->params.return_progress) { + send_partial_response(slot, {}, true); + } + } + + if (!is_inside_view(slot.i_batch)) { + // the required token not in this sub-batch, skip + return; + } + + if (slot.state == SLOT_STATE_DONE_PROMPT) { + if (slot.task->type == SERVER_TASK_TYPE_EMBEDDING) { + // prompt evaluated for embedding + send_embedding(slot, batch_view); + slot.release(); + slot.i_batch = -1; + return; + } + + if (slot.task->type == SERVER_TASK_TYPE_RERANK) { + send_rerank(slot, batch_view); + slot.release(); + slot.i_batch = -1; + return; + } + + GGML_ASSERT(slot.task->need_sampling()); + + // prompt evaluated for next-token prediction + slot.state = SLOT_STATE_GENERATING; + + if (slot.can_speculate()) { + common_speculative_begin(spec.get(), slot.id, slot.prompt.tokens.get_text_tokens()); + } + } else if (slot.state != SLOT_STATE_GENERATING) { + return; + } + + if (slot.can_speculate() && !slot.spec_draft.empty()) { + return; // sample using speculative decoding + } + + // shifted according to the current sub-batch + const int tok_idx = slot.i_batch - off; + + llama_token id; + { + scoped_timer timer(t_sampl, n_sampl); + id = common_sampler_sample(slot.smpl.get(), slot.ctx_tgt, tok_idx); + } + + slot.i_batch = -1; + + common_sampler_accept(slot.smpl.get(), id, true); + + // here we have synchronized the llama_context (due to the sampling above), so we can do time measurement + const int64_t t_now = ggml_time_us(); + + slot.n_decoded += 1; + + if (slot.n_decoded == 1) { + slot.t_start_generation = t_now; + slot.t_print_last = t_now; + slot.n_decoded_last = 0; + slot.t_prompt_processing = (slot.t_start_generation - slot.t_start_process_prompt) / 1e3; + metrics.on_prompt_eval(slot); + } + + slot.t_token_generation = std::max(1, t_now - slot.t_start_generation) / 1e3; + + completion_token_output result; + result.tok = id; + result.text_to_send = common_token_to_piece(slot.ctx_tgt, result.tok, accept_special_token(slot, result.tok)); + result.prob = 1.0f; // TODO: set it here instead of doing inside populate_token_probs + + if (slot.task->params.sampling.n_probs > 0) { + populate_token_probs(slot, result, slot.task->params.post_sampling_probs, params_base.special, tok_idx); + } + + if (!process_token(result, slot)) { + // release slot because of stop condition + slot.print_timings(); + send_final_response(slot); + metrics.on_prediction(slot); + slot.release(); + + return; + } + + slot.print_timings_tg(); + }); + + // speculative decoding - main model sample and accept + iterate(slots, [&](server_slot & slot) { + if (slot.state != SLOT_STATE_GENERATING || !slot.can_speculate() || + slot.spec_draft.empty() || slot.spec_i_batch.empty()) { + return; + } + + // save the original draft size + const size_t n_draft = slot.spec_draft.size(); + + GGML_ASSERT(n_draft > 0); + + // verify and try to accept the draft + { + common_sampler_ptr smpl_save(common_sampler_clone(slot.smpl.get())); + + GGML_ASSERT(slot.spec_i_batch.size() == n_draft + 1); + auto accepted = common_sampler_sample_and_accept_n(slot.smpl.get(), slot.ctx_tgt, slot.spec_i_batch, slot.spec_draft); + slot.spec_i_batch.clear(); + + GGML_ASSERT(accepted.size() >= 1); + + const uint32_t n_rollback = slot.spec_draft.size() + 1 - accepted.size(); + + const bool use_ckpt_tgt = + ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_FULL || + (ctx_tgt_seq_rm_type == COMMON_CONTEXT_SEQ_RM_TYPE_RS && n_rollback > llama_n_rs_seq(ctx_tgt)); + + // check for partial draft acceptance + if (n_rollback > 0) { + if (use_ckpt_tgt) { + if (trace > 0) { + SLT_INF(slot, "accepted %2zu/%2zu draft tokens (restore checkpoint)\n", accepted.size() - 1, slot.spec_draft.size()); + } + + // partial acceptance is not supported by the context -> truncate the draft and restore the state + slot.spec_is_replay = true; + slot.spec_draft = std::move(accepted); + + const auto & ckpt = slot.spec_ckpt; + + SLT_DBG(slot, "restoring speculative checkpoint (pos_min = %d, pos_max = %d, size = %zu)\n", ckpt.pos_min, ckpt.pos_max, ckpt.size()); + + ckpt.load_tgt(slot.ctx_tgt, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + + if (slot.ctx_dft) { + ckpt.load_dft(slot.ctx_dft, slot.id, LLAMA_STATE_SEQ_FLAGS_PARTIAL_ONLY); + } + + slot.mem.seq_rm(slot.id, ckpt.pos_max + 1, -1); + + slot.prompt.tokens.keep_first(ckpt.n_tokens); + common_sampler_copy(smpl_save.get(), slot.smpl.get()); + + return; + } + } + + if (trace > 0) { + SLT_INF(slot, "accepted %2zu/%2zu draft tokens\n", accepted.size() - 1, n_draft); + } + + common_speculative_accept(spec.get(), slot.id, accepted.size() - 1); + + slot.spec_draft = std::move(accepted); + } + + const int64_t t_now = ggml_time_us(); + + const auto ids = std::move(slot.spec_draft); + + size_t n_accepted = ids.size() - 1; + if (slot.spec_is_replay && n_accepted > 0) { + n_accepted--; + } + slot.spec_is_replay = false; + + slot.t_token_generation = std::max(1, t_now - slot.t_start_generation) / 1e3; + + // update how many tokens out of those tested were accepted + slot.n_draft_accepted += n_accepted; + slot.n_draft_verif_steps += 1; + + if (slot.n_accepted_per_pos.empty()) { + slot.n_accepted_per_pos.resize(common_speculative_n_max(¶ms_base.speculative), 0); + } + for (size_t i = 0; i < n_accepted && i < slot.n_accepted_per_pos.size(); ++i) { + slot.n_accepted_per_pos[i]++; + } + + // add accepted tokens to the prompt + slot.prompt.tokens.keep_first(slot.prompt.n_tokens() - n_draft); + slot.prompt.tokens.insert({ids.begin(), ids.end() - 1}); + + slot.sampled = ids.back(); // last accepted token + SLT_DBG(slot, "add accepted tokens: sampled=%d, ids.size=%zu, n_draft=%zu\n", slot.sampled, ids.size(), n_draft); + + slot.mem.seq_rm(slot.id, slot.prompt.tokens.pos_next(), -1); + + for (size_t i = 0; i < ids.size(); ++i) { + completion_token_output result; + + result.tok = ids[i]; + result.text_to_send = common_token_to_piece(slot.ctx_tgt, result.tok, accept_special_token(slot, result.tok)); + result.prob = 1.0f; // set later + + // TODO: set result.probs + + slot.n_decoded += 1; + + if (!process_token(result, slot)) { + slot.print_timings(); + send_final_response(slot); + metrics.on_prediction(slot); + slot.release(); + + return; + } + } + + slot.print_timings_tg(); + + SLT_DBG(slot, "accepted %d/%d draft tokens, new n_tokens = %d\n", (int) n_accepted, (int) n_draft, slot.prompt.n_tokens()); + }); + } + + int get_slot_n_ctx() { + return slots.back().n_ctx; + } + + server_response_reader get_response_reader() { + return server_response_reader(queue_tasks, queue_results, HTTP_POLLING_SECONDS); + } +}; + +// +// server_context (public API) +// + +server_context::server_context() : impl(new server_context_impl()) {} +server_context::~server_context() = default; + +bool server_context::load_model(common_params & params) { + return impl->load_model(params); +} + +void server_context::start_loop() { + auto & params = impl->params_base; + impl->queue_tasks.start_loop(params.sleep_idle_seconds * 1000); +} + +void server_context::terminate() { + impl->queue_tasks.terminate(); +} + +llama_context * server_context::get_llama_context() const { + return impl->ctx_tgt; +} + +server_response_reader server_context::get_response_reader() { + return impl->get_response_reader(); +} + +server_context_meta server_context::get_meta() const { + auto bos_id = llama_vocab_bos(impl->vocab); + auto eos_id = llama_vocab_eos(impl->vocab); + auto bos_token_str = bos_id != LLAMA_TOKEN_NULL ? common_token_to_piece(impl->ctx_tgt, bos_id, true) : ""; + auto eos_token_str = eos_id != LLAMA_TOKEN_NULL ? common_token_to_piece(impl->ctx_tgt, eos_id, true) : ""; + + const char * ftype_name = llama_ftype_name(llama_model_ftype(impl->model_tgt)); + + return server_context_meta { + /* build_info */ std::string(llama_build_info()), + /* model_name */ impl->model_name, + /* model_aliases */ impl->model_aliases, + /* model_tags */ impl->model_tags, + /* model_path */ impl->params_base.model.path, + /* has_mtmd */ impl->mctx != nullptr, + /* has_inp_image */ impl->chat_params.allow_image, + /* has_inp_audio */ impl->chat_params.allow_audio, + /* has_inp_video */ impl->chat_params.allow_video, + /* json_ui_settings */ impl->json_ui_settings, + /* slot_n_ctx */ impl->get_slot_n_ctx(), + /* pooling_type */ llama_pooling_type(impl->ctx_tgt), + + /* chat_params */ impl->chat_params, + /* chat_template_caps */ common_chat_templates_get_caps(impl->chat_params.tmpls.get()), + + /* bos_token_str */ bos_token_str, + /* eos_token_str */ eos_token_str, + /* fim_pre_token */ llama_vocab_fim_pre(impl->vocab), + /* fim_sub_token */ llama_vocab_fim_suf(impl->vocab), + /* fim_mid_token */ llama_vocab_fim_mid(impl->vocab), + /* fim_pad_token */ llama_vocab_fim_pad(impl->vocab), + /* fim_rep_token */ llama_vocab_fim_rep(impl->vocab), + /* fim_sep_token */ llama_vocab_fim_sep(impl->vocab), + + /* logit_bias_eog */ impl->params_base.sampling.logit_bias_eog, + + /* model_vocab_type */ llama_vocab_type(impl->vocab), + /* model_vocab_n_tokens */ llama_vocab_n_tokens(impl->vocab), + /* model_n_ctx_train */ llama_model_n_ctx_train(impl->model_tgt), + /* model_n_embd_inp */ llama_model_n_embd(impl->model_tgt), + /* model_n_params */ llama_model_n_params(impl->model_tgt), + /* model_size */ llama_model_size(impl->model_tgt), + /* model_ftype */ ftype_name, + }; +} + +// generator-like API for HTTP response generation +// may have bypass_sleep = true if the task does not use ctx_server +struct server_res_generator : server_res_spipe { + server_response_reader rd; + server_res_generator(server_queue & queue_tasks, server_response & queue_results, int sleep_idle_seconds, bool bypass_sleep = false) + : rd(queue_tasks, queue_results, HTTP_POLLING_SECONDS) { + // fast path in case sleeping is disabled + bypass_sleep |= sleep_idle_seconds < 0; + if (!bypass_sleep) { + queue_tasks.wait_until_no_sleep(); + } + } + void ok(const json & response_data) { + status = 200; + data = safe_json_to_str(response_data); + } + void error(const json & error_data) { + status = json_value(error_data, "code", 500); + data = safe_json_to_str({{ "error", error_data }}); + } +}; + +void server_context::set_state_callback(server_state_callback_t callback) { + impl->callback_state = std::move(callback); + impl->queue_tasks.on_sleeping_state([this](bool sleeping) { + if (sleeping) { + impl->callback_state(SERVER_STATE_SLEEPING, {}); + } + // for sleeping == false, event is emitted by load_model() + }); +} + +// +// server_routes +// + +std::unique_ptr server_routes::handle_completions_impl( + const server_http_req & req, + server_task_type type, + const json & data, + const std::vector & files, + task_response_type res_type) { + GGML_ASSERT(type == SERVER_TASK_TYPE_COMPLETION || type == SERVER_TASK_TYPE_INFILL); + + auto res = create_response(); + auto completion_id = gen_chatcmplid(); + auto & rd = res->rd; + auto & params = this->params; + + res->set_req(&req); // will also set spipe if needed + + int32_t sse_ping_interval = params.sse_ping_interval; + + try { + std::vector tasks; + + const auto & prompt = data.at("prompt"); + // TODO: this log can become very long, put it behind a flag or think about a more compact format + //SRV_DBG("Prompt: %s\n", prompt.is_string() ? prompt.get().c_str() : prompt.dump(2).c_str()); + + if (!params.path_prompts_log_dir.empty()) { + const auto file_path = std::filesystem::path(params.path_prompts_log_dir) / string_format("%012" PRId64 ".txt", ggml_time_ms()); + std::ofstream f(file_path); + if (f) { + f << (prompt.is_string() ? prompt.get().c_str() : prompt.dump(2).c_str()); + } else { + SRV_ERR("failed to create %s\n", file_path.string().c_str()); + } + } + + // process prompt + std::vector inputs; + + if (res_type != TASK_RESPONSE_TYPE_NONE && ctx_server.mctx != nullptr) { + // This is the case used by OAI compatible chat path with MTMD. TODO It can be moved to the path below. + inputs.push_back(process_mtmd_prompt(ctx_server.mctx, prompt.get(), files)); + } else { + // Everything else, including multimodal completions. + inputs = tokenize_input_prompts(ctx_server.vocab, ctx_server.mctx, prompt, true, true); + } + + // tasks.reserve(inputs.size()); // TODO: this is inaccurate due to child tasks + + // message delimiters for checkpointing + auto delimiters = common_chat_msg_delimiters_parse(json_value(data, "message_delimiters", json::array())); + delimiters.tokenize(ctx_server.vocab); + + for (size_t i = 0; i < inputs.size(); i++) { + server_task task = server_task(type); + + task.id = rd.get_new_id(); + + task.tokens = std::move(inputs[i]); + task.params = server_schema::eval_llama_cmpl_schema( + ctx_server.vocab, + params, + meta->logit_bias_eog, + data); + + task.params.message_spans = task.tokens.find_message_spans(delimiters); + + task.id_slot = json_value(data, "id_slot", -1); + sse_ping_interval = task.params.sse_ping_interval; + + // OAI-compat + task.params.res_type = res_type; + task.params.oaicompat_cmpl_id = completion_id; + task.params.oaicompat_model = meta->model_name; + + // prepare child tasks + if (task.params.n_cmpl > 1) { + int n_children = task.params.n_cmpl - 1; + for (int j = 0; j < n_children; j++) { + task.add_child(task.id, rd.get_new_id()); + } + } + + tasks.push_back(std::move(task)); + } + + rd.post_tasks(std::move(tasks)); + } catch (const std::exception & e) { + res->error(format_error_response(e.what(), ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + bool stream = json_value(data, "stream", false); + + if (!stream) { + // non-stream, wait for the results + auto all_results = rd.wait_for_all(req.should_stop); + if (all_results.is_terminated) { + return res; // connection is closed + } else if (all_results.error) { + res->error(all_results.error->to_json()); + return res; + } else { + json arr = json::array(); + for (auto & res : all_results.results) { + GGML_ASSERT(dynamic_cast(res.get()) != nullptr); + arr.push_back(res->to_json()); + } + GGML_ASSERT(!arr.empty() && "empty results"); + if (arr.size() == 1) { + // if single request, return single object instead of array + res->ok(arr[0]); + } else if (res_type == TASK_RESPONSE_TYPE_OAI_CHAT || res_type == TASK_RESPONSE_TYPE_OAI_CMPL) { + // if multiple results in OAI format, we need to re-format them + json & choices = arr[0]["choices"]; + for (size_t i = 1; i < arr.size(); i++) { + choices.push_back(std::move(arr[i]["choices"][0])); + } + res->ok(arr[0]); + } else { + // multi-results, non-OAI compat + res->ok(arr); + } + } + } else { + // in streaming mode, the first error must be treated as non-stream response + // this is to match the OAI API behavior + // ref: https://github.com/ggml-org/llama.cpp/pull/16486#discussion_r2419657309 + auto first_result = rd.next(req.should_stop); + if (first_result == nullptr) { + GGML_ASSERT(req.should_stop()); + return res; // connection is closed + } + + if (first_result->is_error()) { + res->error(first_result->to_json()); + return res; + } + + GGML_ASSERT( + dynamic_cast(first_result.get()) != nullptr || + dynamic_cast (first_result.get()) != nullptr + ); + + // next responses are streamed + // to be sent immediately + json first_result_json = first_result->to_json(); + if (first_result_json == nullptr) { + res->data = ""; // simply send HTTP headers and status code + } else if (res_type == TASK_RESPONSE_TYPE_ANTHROPIC) { + res->data = format_anthropic_sse(first_result_json); + } else if (res_type == TASK_RESPONSE_TYPE_OAI_RESP) { + res->data = format_oai_resp_sse(first_result_json); + } else { + res->data = format_oai_sse(first_result_json); + } + res->status = 200; + res->content_type = "text/event-stream"; + res->set_next([res_this = res.get(), res_type, sse_ping_interval](std::string & output) -> bool { + static auto format_error = [](task_response_type res_type, const json & res_json) { + if (res_type == TASK_RESPONSE_TYPE_ANTHROPIC) { + return format_anthropic_sse({ + {"event", "error"}, + {"data", res_json}, + }); + } else { + return format_oai_sse(json {{ "error", res_json }}); + } + }; + + auto effective_should_stop = [&res_this]() { + return res_this->should_stop(); + }; + + try { + if (effective_should_stop()) { + SRV_DBG("%s", "stopping streaming due to should_stop condition\n"); + return false; // should_stop condition met + } + + if (!res_this->data.empty()) { + // flush the first chunk + output = std::move(res_this->data); + res_this->data.clear(); + return true; + } + + server_response_reader & rd = res_this->rd; + + // check if there is more data + if (!rd.has_next()) { + switch (res_type) { + case TASK_RESPONSE_TYPE_NONE: + case TASK_RESPONSE_TYPE_OAI_RESP: + case TASK_RESPONSE_TYPE_ANTHROPIC: + output = ""; + break; + + default: + output = "data: [DONE]\n\n"; + break; + } + SRV_DBG("%s", "all results received, terminating stream\n"); + return false; // no more data, terminate + } + + // receive subsequent results + bool timeout = false; + int64_t start_time = ggml_time_ms(); + auto result = rd.next([&timeout, &start_time, sse_ping_interval, &effective_should_stop]() { + if (effective_should_stop()) { + return true; // should_stop condition met + } else if (sse_ping_interval > 0 && ggml_time_ms() - start_time > (int64_t)sse_ping_interval * 1000) { + timeout = true; + return true; // timeout + } + return false; + }); + + if (timeout) { + // some clients may time out (e.g. undici) will time out if no data is received for a while, so we need to send a ping to keep the connection alive + SRV_DBG("%s", "sending SSE ping\n"); + output = ":\n\n"; + return true; + } + + if (result == nullptr) { + SRV_DBG("%s", "stopping streaming due to should_stop condition\n"); + GGML_ASSERT(effective_should_stop()); + return false; // should_stop condition met + } + + // send the results + if (result->is_error()) { + json res_json = result->to_json(); + output = format_error(res_type, res_json); + SRV_DBG("%s", "error received during streaming, terminating stream\n"); + return false; // terminate on error + } else { + GGML_ASSERT( + dynamic_cast(result.get()) != nullptr + || dynamic_cast(result.get()) != nullptr + ); + json res_json = result->to_json(); + if (res_type == TASK_RESPONSE_TYPE_ANTHROPIC) { + output = format_anthropic_sse(res_json); + } else if (res_type == TASK_RESPONSE_TYPE_OAI_RESP) { + output = format_oai_resp_sse(res_json); + } else { + output = format_oai_sse(res_json); + } + } + + // has next data, continue + return true; + + } catch (const std::exception & e) { + json error_json = format_error_response(e.what(), ERROR_TYPE_SERVER); + output = format_error(res_type, error_json); + + // terminate on exception + return false; + } + }); + } + + return res; +} + +std::unique_ptr server_routes::create_response(bool bypass_sleep) { + return std::make_unique(queue_tasks, queue_results, params.sleep_idle_seconds, bypass_sleep); +} + +server_routes::server_routes(const common_params & params, server_context & ctx_server) + : params(params), + ctx_server(*ctx_server.impl), + queue_tasks(ctx_server.impl->queue_tasks), + queue_results(ctx_server.impl->queue_results) { + init_routes(); +} + +void server_routes::init_routes() { + // IMPORTANT: all lambda functions must start with create_response() + // this is to ensure that the server_res_generator can handle sleeping case correctly + + this->get_health = [this](const server_http_req &) { + // error and loading states are handled by middleware + auto res = create_response(true); + + // this endpoint can be accessed during sleeping + // the next LOC is to avoid someone accidentally use ctx_server + bool ctx_server; // do NOT delete this line + GGML_UNUSED(ctx_server); + + res->ok({{"status", "ok"}}); + return res; + }; + + this->get_metrics = [this](const server_http_req & req) { + auto res = create_response(); + if (!params.endpoint_metrics) { + res->error(format_error_response("This server does not support metrics endpoint. Start it with `--metrics`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + // request slots data using task queue + { + server_task task(SERVER_TASK_TYPE_METRICS); + task.id = res->rd.get_new_id(); + res->rd.post_task(std::move(task), true); // high-priority task + } + + // get the result + auto result = res->rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + // TODO: get rid of this dynamic_cast + auto res_task = dynamic_cast(result.get()); + GGML_ASSERT(res_task != nullptr); + + // metrics definition: https://prometheus.io/docs/practices/naming/#metric-names + json all_metrics_def = json { + {"counter", {{ + {"name", "prompt_tokens_total"}, + {"help", "Number of prompt tokens processed."}, + {"value", (uint64_t) res_task->n_prompt_tokens_processed_total} + }, { + {"name", "prompt_seconds_total"}, + {"help", "Prompt process time"}, + {"value", (uint64_t) res_task->t_prompt_processing_total / 1.e3} + }, { + {"name", "tokens_predicted_total"}, + {"help", "Number of generation tokens processed."}, + {"value", (uint64_t) res_task->n_tokens_predicted_total} + }, { + {"name", "tokens_predicted_seconds_total"}, + {"help", "Predict process time"}, + {"value", (uint64_t) res_task->t_tokens_generation_total / 1.e3} + }, { + {"name", "n_decode_total"}, + {"help", "Total number of llama_decode() calls"}, + {"value", res_task->n_decode_total} + }, { + {"name", "n_tokens_max"}, + {"help", "Largest observed n_tokens."}, + {"value", res_task->n_tokens_max} + }, { + {"name", "spec_decode_num_draft_tokens_total"}, + {"help", "Total draft tokens generated"}, + {"value", res_task->n_draft_tokens_total} + }, { + {"name", "spec_decode_num_accepted_tokens_total"}, + {"help", "Total draft tokens accepted by the target model"}, + {"value", res_task->n_draft_accepted_total} + }, { + {"name", "spec_decode_num_drafts_total"}, + {"help", "Total speculative decoding verification steps"}, + {"value", res_task->n_draft_verif_steps_total} + }}}, + {"gauge", {{ + {"name", "prompt_tokens_seconds"}, + {"help", "Average prompt throughput in tokens/s."}, + {"value", res_task->n_prompt_tokens_processed ? 1.e3 / res_task->t_prompt_processing * res_task->n_prompt_tokens_processed : 0.} + },{ + {"name", "predicted_tokens_seconds"}, + {"help", "Average generation throughput in tokens/s."}, + {"value", res_task->n_tokens_predicted ? 1.e3 / res_task->t_tokens_generation * res_task->n_tokens_predicted : 0.} + },{ + {"name", "requests_processing"}, + {"help", "Number of requests processing."}, + {"value", (uint64_t) res_task->n_processing_slots} + },{ + {"name", "requests_deferred"}, + {"help", "Number of requests deferred."}, + {"value", (uint64_t) res_task->n_tasks_deferred} + },{ + {"name", "n_busy_slots_per_decode"}, + {"help", "Average number of busy slots per llama_decode() call"}, + {"value", (float) res_task->n_busy_slots_total / std::max((float) res_task->n_decode_total, 1.f)} + }}} + }; + + std::stringstream prometheus; + + for (const auto & el : all_metrics_def.items()) { + const auto & type = el.key(); + const auto & metrics_def = el.value(); + + for (const auto & metric_def : metrics_def) { + const std::string name = metric_def.at("name"); + const std::string help = metric_def.at("help"); + + auto value = json_value(metric_def, "value", 0.); + prometheus << "# HELP llamacpp:" << name << " " << help << "\n" + << "# TYPE llamacpp:" << name << " " << type << "\n" + << "llamacpp:" << name << " " << value << "\n"; + } + } + + // labeled counter: one time series per draft position + if (!res_task->n_accepted_per_pos_total.empty()) { + prometheus << "# HELP llamacpp:spec_decode_num_accepted_tokens_per_pos_total" + " Accepted tokens per draft position\n" + << "# TYPE llamacpp:spec_decode_num_accepted_tokens_per_pos_total counter\n"; + for (size_t i = 0; i < res_task->n_accepted_per_pos_total.size(); i++) { + prometheus << "llamacpp:spec_decode_num_accepted_tokens_per_pos_total{position=\"" + << i << "\"} " << res_task->n_accepted_per_pos_total[i] << "\n"; + } + } + + res->headers["Process-Start-Time-Unix"] = std::to_string(res_task->t_start); + res->content_type = "text/plain; version=0.0.4"; + res->status = 200; + res->data = prometheus.str(); + return res; + }; + + this->get_slots = [this](const server_http_req & req) { + auto res = create_response(); + if (!params.endpoint_slots) { + res->error(format_error_response("This server does not support slots endpoint. Start it with `--slots`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + // request slots data using task queue + { + server_task task(SERVER_TASK_TYPE_METRICS); + task.id = res->rd.get_new_id(); + res->rd.post_task(std::move(task), true); // high-priority task + } + + // get the result + auto result = res->rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + // TODO: get rid of this dynamic_cast + auto * res_task = dynamic_cast(result.get()); + GGML_ASSERT(res_task != nullptr); + + // optionally return "fail_on_no_slot" error + if (!req.get_param("fail_on_no_slot").empty()) { + if (res_task->n_idle_slots == 0) { + res->error(format_error_response("no slot available", ERROR_TYPE_UNAVAILABLE)); + return res; + } + } + + res->ok(res_task->slots_data); + return res; + }; + + this->post_slots = [this](const server_http_req & req) { + auto res = create_response(); + if (params.slot_save_path.empty()) { + res->error(format_error_response("This server does not support slots action. Start it with `--slot-save-path`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + std::string id_slot_str = req.get_param("id_slot"); + + int id_slot; + try { + id_slot = std::stoi(id_slot_str); + } catch (const std::exception &) { + res->error(format_error_response("Invalid slot ID", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + std::string action = req.get_param("action"); + + if (action == "save") { + return handle_slots_save(req, id_slot); + } + if (action == "restore") { + return handle_slots_restore(req, id_slot); + } + if (action == "erase") { + return handle_slots_erase(req, id_slot); + } + + res->error(format_error_response("Invalid action", ERROR_TYPE_INVALID_REQUEST)); + return res; + }; + + this->get_props = [this](const server_http_req &) { + auto res = create_response(true); + + // this endpoint can be accessed during sleeping + // the next LOC is to avoid someone accidentally use ctx_server + bool ctx_server; // do NOT delete this line + GGML_UNUSED(ctx_server); + + task_params tparams; + tparams.sampling = params.sampling; + json default_generation_settings_for_props = json { + { "params", tparams.to_json(true) }, + { "n_ctx", meta->slot_n_ctx }, + }; + + std::string tmpl_default = common_chat_templates_source(meta->chat_params.tmpls.get(), ""); + std::string tmpl_tools = common_chat_templates_source(meta->chat_params.tmpls.get(), "tool_use"); + + json props = { + { "default_generation_settings", default_generation_settings_for_props }, + { "total_slots", params.n_parallel }, + { "model_alias", meta->model_name }, + { "model_ftype", meta->model_ftype }, + { "model_path", meta->model_path }, + { "modalities", json { + {"vision", meta->has_inp_image}, + {"video", meta->has_inp_video}, + {"audio", meta->has_inp_audio}, + } }, + { "media_marker", get_media_marker() }, + { "endpoint_slots", params.endpoint_slots }, + { "endpoint_props", params.endpoint_props }, + { "endpoint_metrics", params.endpoint_metrics }, + { "ui", params.ui }, + { "ui_settings", meta->json_ui_settings }, + { "chat_template", tmpl_default }, + { "chat_template_caps", meta->chat_template_caps }, + { "bos_token", meta->bos_token_str }, + { "eos_token", meta->eos_token_str }, + { "build_info", meta->build_info }, + { "is_sleeping", queue_tasks.is_sleeping() }, + { "cors_proxy_enabled", params.ui_mcp_proxy }, + }; + if (params.use_jinja) { + if (!tmpl_tools.empty()) { + props["chat_template_tool_use"] = tmpl_tools; + } + } + res->ok(props); + return res; + }; + + this->post_props = [this](const server_http_req &) { + auto res = create_response(); + if (!params.endpoint_props) { + res->error(format_error_response("This server does not support changing global properties. Start it with `--props`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + // update any props here + + res->ok({{ "success", true }}); + return res; + }; + + this->post_infill = [this](const server_http_req & req) { + auto res = create_response(); + // check model compatibility + std::string err; + if (llama_vocab_fim_pre(ctx_server.vocab) == LLAMA_TOKEN_NULL) { + err += "prefix token is missing. "; + } + if (llama_vocab_fim_suf(ctx_server.vocab) == LLAMA_TOKEN_NULL) { + err += "suffix token is missing. "; + } + if (llama_vocab_fim_mid(ctx_server.vocab) == LLAMA_TOKEN_NULL) { + err += "middle token is missing. "; + } + if (!err.empty()) { + res->error(format_error_response(string_format("Infill is not supported by this model: %s", err.c_str()), ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + // validate input + json data = json::parse(req.body); + if (data.contains("prompt") && !data.at("prompt").is_string()) { + // prompt is optional + res->error(format_error_response("\"prompt\" must be a string", ERROR_TYPE_INVALID_REQUEST)); + } + + if (!data.contains("input_prefix")) { + res->error(format_error_response("\"input_prefix\" is required", ERROR_TYPE_INVALID_REQUEST)); + } + + if (!data.contains("input_suffix")) { + res->error(format_error_response("\"input_suffix\" is required", ERROR_TYPE_INVALID_REQUEST)); + } + + if (data.contains("input_extra") && !data.at("input_extra").is_array()) { + // input_extra is optional + res->error(format_error_response("\"input_extra\" must be an array of {\"filename\": string, \"text\": string}", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + json input_extra = json_value(data, "input_extra", json::array()); + for (const auto & chunk : input_extra) { + // { "text": string, "filename": string } + if (!chunk.contains("text") || !chunk.at("text").is_string()) { + res->error(format_error_response("extra_context chunk must contain a \"text\" field with a string value", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + // filename is optional + if (chunk.contains("filename") && !chunk.at("filename").is_string()) { + res->error(format_error_response("extra_context chunk's \"filename\" field must be a string", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + } + data["input_extra"] = input_extra; // default to empty array if it's not exist + + std::string prompt = json_value(data, "prompt", std::string()); + std::vector tokenized_prompts = tokenize_input_prompts(ctx_server.vocab, ctx_server.mctx, prompt, false, true); + SRV_DBG("creating infill tasks, n_prompts = %d\n", (int) tokenized_prompts.size()); + data["prompt"] = format_prompt_infill( + ctx_server.vocab, + data.at("input_prefix"), + data.at("input_suffix"), + data.at("input_extra"), + params.n_batch, + params.n_predict, + meta->slot_n_ctx, + params.spm_infill, + tokenized_prompts[0].get_tokens() // TODO: this could maybe be multimodal. + ); + + std::vector files; // dummy + return handle_completions_impl( + req, + SERVER_TASK_TYPE_INFILL, + data, + files, + TASK_RESPONSE_TYPE_NONE); // infill is not OAI compatible + }; + + this->post_completions = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; // dummy + const json body = json::parse(req.body); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body, + files, + TASK_RESPONSE_TYPE_NONE); + }; + + this->post_completions_oai = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; // dummy + const json body = json::parse(req.body); + if (body.contains("suffix") && body.at("suffix").is_string() && !body.at("suffix").get().empty()) { + if (llama_vocab_fim_pre(ctx_server.vocab) != LLAMA_TOKEN_NULL && + llama_vocab_fim_suf(ctx_server.vocab) != LLAMA_TOKEN_NULL && + llama_vocab_fim_mid(ctx_server.vocab) != LLAMA_TOKEN_NULL) { + json infill_data = body; + infill_data["input_prefix"] = body.at("prompt"); + infill_data["input_suffix"] = body.at("suffix"); + infill_data["input_extra"] = json_value(infill_data, "input_extra", json::array()); + std::string empty_str = ""; + std::vector tokenized_prompts = tokenize_input_prompts(ctx_server.vocab, ctx_server.mctx, json_value(infill_data, "prompt_extra", empty_str), false, true); + infill_data["prompt"] = format_prompt_infill( + ctx_server.vocab, + infill_data.at("input_prefix"), + infill_data.at("input_suffix"), + infill_data.at("input_extra"), + params.n_batch, + params.n_predict, + meta->slot_n_ctx, + params.spm_infill, + tokenized_prompts[0].get_tokens() + ); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_INFILL, + infill_data, + files, + TASK_RESPONSE_TYPE_OAI_CMPL); + } + } + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body, + files, + TASK_RESPONSE_TYPE_OAI_CMPL); + }; + + this->post_chat_completions = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; + json body = json::parse(req.body); + json body_parsed = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body_parsed, + files, + TASK_RESPONSE_TYPE_OAI_CHAT); + }; + + this->post_chat_completions_tok = [this](const server_http_req & req) { + return handle_count_tokens(ctx_server.vocab, ctx_server.mctx, req, TASK_RESPONSE_TYPE_OAI_CHAT); + }; + + this->post_control = [this](const server_http_req & req) { + auto res = create_response(); + const json body = json::parse(req.body); + + const std::string cmpl_id = json_value(body, "id", std::string()); + const std::string action = json_value(body, "action", std::string()); + if (cmpl_id.empty()) { + res->error(format_error_response("missing completion id", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + if (action != "reasoning_end") { + res->error(format_error_response("unknown control action", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_CONTROL); + task.id = rd.get_new_id(); + task.params.control_cmpl_id = cmpl_id; + task.params.control_action = action; + rd.post_task(std::move(task)); + } + + auto result = rd.next(req.should_stop); + if (!result) { + GGML_ASSERT(req.should_stop()); + return res; + } + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + res->ok(result->to_json()); + return res; + }; + + this->post_responses_oai = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; + json body = server_chat_convert_responses_to_chatcmpl(json::parse(req.body)); + SRV_DBG("%s\n", "Request converted: OpenAI Responses -> OpenAI Chat Completions"); + SRV_DBG("converted request: %s\n", body.dump().c_str()); + json body_parsed = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body_parsed, + files, + TASK_RESPONSE_TYPE_OAI_RESP); + }; + + this->post_responses_tok_oai = [this](const server_http_req & req) { + return handle_count_tokens(ctx_server.vocab, ctx_server.mctx, req, TASK_RESPONSE_TYPE_OAI_RESP); + }; + + this->post_transcriptions_oai = [this](const server_http_req & req) { + auto res = create_response(); + + if (!meta->has_mtmd || !meta->chat_params.allow_audio) { + res->error(format_error_response("The current model does not support audio input.", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + std::vector files; + json body = convert_transcriptions_to_chatcmpl( + json::parse(req.body), + meta->chat_params.tmpls.get(), + req.files, + files); + SRV_DBG("%s\n", "Request converted: OpenAI Transcriptions -> OpenAI Chat Completions"); + SRV_DBG("converted request: %s\n", body.dump().c_str()); + json body_parsed = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body_parsed, + files, + TASK_RESPONSE_TYPE_OAI_ASR); + }; + + this->post_anthropic_messages = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; + json body = server_chat_convert_anthropic_to_oai(json::parse(req.body)); + SRV_DBG("%s\n", "Request converted: Anthropic -> OpenAI Chat Completions"); + SRV_DBG("converted request: %s\n", body.dump().c_str()); + json body_parsed = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + return handle_completions_impl( + req, + SERVER_TASK_TYPE_COMPLETION, + body_parsed, + files, + TASK_RESPONSE_TYPE_ANTHROPIC); + }; + + this->post_anthropic_count_tokens = [this](const server_http_req & req) { + return handle_count_tokens(ctx_server.vocab, ctx_server.mctx, req, TASK_RESPONSE_TYPE_ANTHROPIC); + }; + + // same with handle_chat_completions, but without inference part + this->post_apply_template = [this](const server_http_req & req) { + auto res = create_response(); + std::vector files; // dummy, unused + json body = json::parse(req.body); + json data = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + res->ok({{ "prompt", std::move(data.at("prompt")) }}); + return res; + }; + + this->get_models = [this](const server_http_req &) { + auto res = create_response(true); + + // this endpoint can be accessed during sleeping + // the next LOC is to avoid someone accidentally use ctx_server + bool ctx_server; // do NOT delete this line + GGML_UNUSED(ctx_server); + + json models = { + {"models", { + { + {"name", meta->model_name}, + {"model", meta->model_name}, + {"modified_at", ""}, + {"size", ""}, + {"digest", ""}, // dummy value, llama.cpp does not support managing model file's hash + {"type", "model"}, + {"description", ""}, + {"tags", {""}}, + {"capabilities", meta->has_mtmd ? json({"completion","multimodal"}) : json({"completion"})}, + {"parameters", ""}, + {"details", { + {"parent_model", ""}, + {"format", "gguf"}, + {"family", ""}, + {"families", {""}}, + {"parameter_size", ""}, + {"quantization_level", ""} + }} + } + }}, + {"object", "list"}, + {"data", { + get_model_info(), + }} + }; + + res->ok(models); + return res; + }; + + this->post_tokenize = [this](const server_http_req & req) { + auto res = create_response(); + const json body = json::parse(req.body); + json tokens_response = json::array(); + if (body.count("content") != 0) { + const bool add_special = json_value(body, "add_special", false); + const bool parse_special = json_value(body, "parse_special", true); + const bool with_pieces = json_value(body, "with_pieces", false); + + llama_tokens tokens = tokenize_mixed(ctx_server.vocab, body.at("content"), add_special, parse_special); + + if (with_pieces) { + for (const auto& token : tokens) { + std::string piece = common_token_to_piece(ctx_server.vocab, token); + json piece_json; + + // Check if the piece is valid UTF-8 + if (is_valid_utf8(piece)) { + piece_json = piece; + } else { + // If not valid UTF-8, store as array of byte values + piece_json = json::array(); + for (unsigned char c : piece) { + piece_json.push_back(static_cast(c)); + } + } + + tokens_response.push_back({ + {"id", token}, + {"piece", piece_json} + }); + } + } else { + tokens_response = tokens; + } + } + + res->ok(json{{"tokens", std::move(tokens_response)}}); + return res; + }; + + this->post_detokenize = [this](const server_http_req & req) { + auto res = create_response(); + const json body = json::parse(req.body); + + std::string content; + if (body.count("tokens") != 0) { + const llama_tokens tokens = body.at("tokens"); + content = tokens_to_str(ctx_server.vocab, tokens); + } + + res->ok(json{{"content", std::move(content)}}); + return res; + }; + + this->post_embeddings = [this](const server_http_req & req) { + return handle_embeddings_impl(req, TASK_RESPONSE_TYPE_NONE); + }; + + this->post_embeddings_oai = [this](const server_http_req & req) { + return handle_embeddings_impl(req, TASK_RESPONSE_TYPE_OAI_EMBD); + }; + + this->post_rerank = [this](const server_http_req & req) { + auto res = create_response(); + if (!params.embedding || params.pooling_type != LLAMA_POOLING_TYPE_RANK) { + res->error(format_error_response("This server does not support reranking. Start it with `--reranking`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + const json body = json::parse(req.body); + + // if true, use TEI API format, otherwise use Jina API format + // Jina: https://jina.ai/reranker/ + // TEI: https://huggingface.github.io/text-embeddings-inference/#/Text%20Embeddings%20Inference/rerank + bool is_tei_format = body.contains("texts"); + + json query; + if (body.count("query") == 1) { + query = body.at("query"); + if (!query.is_string()) { + res->error(format_error_response("\"query\" must be a string", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + } else { + res->error(format_error_response("\"query\" must be provided", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + std::vector documents = json_value(body, "documents", + json_value(body, "texts", std::vector())); + if (documents.empty()) { + res->error(format_error_response("\"documents\" must be a non-empty string array", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + int top_n = json_value(body, "top_n", (int)documents.size()); + + // create and queue the task + json responses = json::array(); + auto & rd = res->rd; + { + std::vector tasks; + tasks.reserve(documents.size()); + for (size_t i = 0; i < documents.size(); i++) { + auto tmp = format_prompt_rerank(ctx_server.model_tgt, ctx_server.vocab, ctx_server.mctx, query, documents[i]); + server_task task = server_task(SERVER_TASK_TYPE_RERANK); + task.id = rd.get_new_id(); + task.tokens = std::move(tmp); + tasks.push_back(std::move(task)); + } + rd.post_tasks(std::move(tasks)); + } + + // wait for the results + auto all_results = rd.wait_for_all(req.should_stop); + + // collect results + if (all_results.is_terminated) { + return res; // connection is closed + } else if (all_results.error) { + res->error(all_results.error->to_json()); + return res; + } else { + for (auto & res : all_results.results) { + GGML_ASSERT(dynamic_cast(res.get()) != nullptr); + responses.push_back(res->to_json()); + } + } + + // write JSON response + json root = format_response_rerank( + body, + meta->model_name, + responses, + is_tei_format, + documents, + top_n); + + res->ok(root); + return res; + }; + + this->get_lora_adapters = [this](const server_http_req & req) { + auto res = create_response(); + + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_GET_LORA); + task.id = rd.get_new_id(); + rd.post_task(std::move(task)); + } + + // get the result + auto result = rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + GGML_ASSERT(dynamic_cast(result.get()) != nullptr); + res->ok(result->to_json()); + return res; + }; + + this->post_lora_adapters = [this](const server_http_req & req) { + auto res = create_response(); + const json body = json::parse(req.body); + if (!body.is_array()) { + res->error(format_error_response("Request body must be an array", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_SET_LORA); + task.id = rd.get_new_id(); + task.set_lora = parse_lora_request(body); + rd.post_task(std::move(task)); + } + + // get the result + auto result = rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + GGML_ASSERT(dynamic_cast(result.get()) != nullptr); + res->ok(result->to_json()); + return res; + }; +} + +json server_routes::get_model_info() const { + return json { + {"id", meta->model_name}, + {"aliases", meta->model_aliases}, + {"tags", meta->model_tags}, + {"object", "model"}, + {"created", std::time(0)}, + {"owned_by", "llamacpp"}, + {"meta", { + {"vocab_type", meta->model_vocab_type}, + {"n_vocab", meta->model_vocab_n_tokens}, + {"n_ctx", meta->slot_n_ctx}, + {"n_ctx_train", meta->model_n_ctx_train}, + {"n_embd", meta->model_n_embd_inp}, + {"n_params", meta->model_n_params}, + {"size", meta->model_size}, + {"ftype", meta->model_ftype}, + }}, + }; +} + +std::unique_ptr server_routes::handle_slots_save(const server_http_req & req, int id_slot) { + auto res = create_response(); + const json request_data = json::parse(req.body); + std::string filename = request_data.at("filename"); + if (!fs_validate_filename(filename)) { + res->error(format_error_response("Invalid filename", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + std::string filepath = params.slot_save_path + filename; + + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_SLOT_SAVE); + task.id = rd.get_new_id(); + task.slot_action.id_slot = id_slot; + task.slot_action.filename = filename; + task.slot_action.filepath = filepath; + rd.post_task(std::move(task)); + } + + auto result = rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + res->ok(result->to_json()); + return res; +} + +std::unique_ptr server_routes::handle_slots_restore(const server_http_req & req, int id_slot) { + auto res = create_response(); + const json request_data = json::parse(req.body); + std::string filename = request_data.at("filename"); + if (!fs_validate_filename(filename)) { + res->error(format_error_response("Invalid filename", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + std::string filepath = params.slot_save_path + filename; + + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_SLOT_RESTORE); + task.id = rd.get_new_id(); + task.slot_action.id_slot = id_slot; + task.slot_action.filename = filename; + task.slot_action.filepath = filepath; + rd.post_task(std::move(task)); + } + + auto result = rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + GGML_ASSERT(dynamic_cast(result.get()) != nullptr); + res->ok(result->to_json()); + return res; +} + +std::unique_ptr server_routes::handle_slots_erase(const server_http_req & req, int id_slot) { + auto res = create_response(); + auto & rd = res->rd; + { + server_task task(SERVER_TASK_TYPE_SLOT_ERASE); + task.id = rd.get_new_id(); + task.slot_action.id_slot = id_slot; + rd.post_task(std::move(task)); + } + + auto result = rd.next(req.should_stop); + if (!result) { + // connection was closed + GGML_ASSERT(req.should_stop()); + return res; + } + + if (result->is_error()) { + res->error(result->to_json()); + return res; + } + + GGML_ASSERT(dynamic_cast(result.get()) != nullptr); + res->ok(result->to_json()); + return res; +} + +std::unique_ptr server_routes::handle_embeddings_impl(const server_http_req & req, task_response_type res_type) { + auto res = create_response(); + if (!params.embedding) { + res->error(format_error_response("This server does not support embeddings. Start it with `--embeddings`", ERROR_TYPE_NOT_SUPPORTED)); + return res; + } + + if (res_type != TASK_RESPONSE_TYPE_NONE && meta->pooling_type == LLAMA_POOLING_TYPE_NONE) { + res->error(format_error_response("Pooling type 'none' is not OAI compatible. Please use a different pooling type", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + const json body = json::parse(req.body); + + // for the shape of input/content, see tokenize_input_prompts() + json prompt; + if (body.count("input") != 0) { + prompt = body.at("input"); + } else if (body.contains("content")) { + res_type = TASK_RESPONSE_TYPE_NONE; // "content" field is not OAI compatible + prompt = body.at("content"); + } else { + res->error(format_error_response("\"input\" or \"content\" must be provided", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + bool use_base64 = false; + if (body.count("encoding_format") != 0) { + const std::string & format = body.at("encoding_format"); + if (format == "base64") { + use_base64 = true; + } else if (format != "float") { + res->error(format_error_response("The format to return the embeddings in. Can be either float or base64", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + } + + auto tokenized_prompts = tokenize_input_prompts(ctx_server.vocab, ctx_server.mctx, prompt, true, true); + for (const auto & tokens : tokenized_prompts) { + // this check is necessary for models that do not add BOS token to the input + if (tokens.empty()) { + res->error(format_error_response("Input content cannot be empty", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + } + + int embd_normalize = params.embd_normalize; + if (body.count("embd_normalize") != 0) { + embd_normalize = body.at("embd_normalize"); + if (meta->pooling_type == LLAMA_POOLING_TYPE_NONE) { + SRV_DBG("embd_normalize is not supported by pooling type %d, ignoring it\n", meta->pooling_type); + } + } + + // create and queue the task + json responses = json::array(); + auto & rd = res->rd; + { + std::vector tasks; + for (size_t i = 0; i < tokenized_prompts.size(); i++) { + server_task task = server_task(SERVER_TASK_TYPE_EMBEDDING); + + task.id = rd.get_new_id(); + task.tokens = std::move(tokenized_prompts[i]); + + // OAI-compat + task.params.res_type = res_type; + task.params.embd_normalize = embd_normalize; + + tasks.push_back(std::move(task)); + } + rd.post_tasks(std::move(tasks)); + } + + // wait for the results + auto all_results = rd.wait_for_all(req.should_stop); + + // collect results + if (all_results.is_terminated) { + return res; // connection is closed + } else if (all_results.error) { + res->error(all_results.error->to_json()); + return res; + } else { + for (auto & res : all_results.results) { + GGML_ASSERT(dynamic_cast(res.get()) != nullptr); + responses.push_back(res->to_json()); + } + } + + // write JSON response + json root = res_type == TASK_RESPONSE_TYPE_OAI_EMBD + ? format_embeddings_response_oaicompat(body, meta->model_name, responses, use_base64) + : json(responses); + res->ok(root); + return res; +} + +std::unique_ptr server_routes::handle_count_tokens(const llama_vocab * vocab, mtmd_context * mctx, const server_http_req & req, task_response_type res_type) { + auto res = create_response(); + std::vector files; + json body = json::parse(req.body); + bool is_oai = false; + + switch (res_type) { + case TASK_RESPONSE_TYPE_OAI_CHAT: + { + is_oai = true; + } break; + case TASK_RESPONSE_TYPE_OAI_RESP: + { + is_oai = true; + body = server_chat_convert_responses_to_chatcmpl(body); + } break; + case TASK_RESPONSE_TYPE_ANTHROPIC: + { + body = server_chat_convert_anthropic_to_oai(body); + } break; + default: + res->error(format_error_response("invalid res_type", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + + json body_parsed = oaicompat_chat_params_parse( + body, + meta->chat_params, + files); + json prompt = body_parsed.at("prompt"); + // SRV_DBG("prompt = %s\n", prompt.dump().c_str()); + + // TODO @ngxson : refactor this code block, move this to server-common and reuse it in other places + size_t n_tokens; + if (mctx != nullptr) { + if (!prompt.is_string()) { + throw std::runtime_error("for mtmd, input prompt must be a string."); + } + n_tokens = process_mtmd_prompt(mctx, prompt.get(), files, true).size(); + } else { + n_tokens = tokenize_mixed(vocab, prompt, true, true).size(); + } + + json response = {{"input_tokens", static_cast(n_tokens)}}; + if (is_oai) { + response["object"] = "response.input_tokens"; + } + res->ok(response); + return res; +} diff --git a/tools/server/server-context.h b/tools/server/server-context.h new file mode 100644 index 0000000000000000000000000000000000000000..f9ab1132b197f735c6c54b2e1e4c21897bc3267b --- /dev/null +++ b/tools/server/server-context.h @@ -0,0 +1,182 @@ +#pragma once + +#include "server-http.h" +#include "server-task.h" +#include "server-queue.h" + +#include + +#include +#include +#include + +struct server_context_impl; // private implementation + +struct server_context_meta { + std::string build_info; + std::string model_name; + std::set model_aliases; + std::set model_tags; + std::string model_path; + bool has_mtmd; + bool has_inp_image; + bool has_inp_audio; + bool has_inp_video; + json json_ui_settings; + int slot_n_ctx; + enum llama_pooling_type pooling_type; + + // chat params + server_chat_params & chat_params; + std::map chat_template_caps; + + // tokens + std::string bos_token_str; + std::string eos_token_str; + llama_token fim_pre_token; + llama_token fim_sub_token; + llama_token fim_mid_token; + llama_token fim_pad_token; + llama_token fim_rep_token; + llama_token fim_sep_token; + + // sampling + std::vector logit_bias_eog; + + // model meta + enum llama_vocab_type model_vocab_type; + int32_t model_vocab_n_tokens; + int32_t model_n_ctx_train; + int32_t model_n_embd_inp; + uint64_t model_n_params; + uint64_t model_size; + std::string model_ftype; +}; + +enum server_state { + SERVER_STATE_DOWNLOADING, + SERVER_STATE_LOADING, + SERVER_STATE_READY, + SERVER_STATE_SLEEPING, +}; + +static std::string server_state_to_str(server_state state) { + switch (state) { + case SERVER_STATE_DOWNLOADING: return "downloading"; + case SERVER_STATE_LOADING: return "loading"; + case SERVER_STATE_READY: return "ready"; + case SERVER_STATE_SLEEPING: return "sleeping"; + default: GGML_ASSERT(false && "invalid server_state"); + } +} + +static server_state server_state_from_str(const std::string & str) { + if (str == "downloading") return SERVER_STATE_DOWNLOADING; + if (str == "loading") return SERVER_STATE_LOADING; + if (str == "ready") return SERVER_STATE_READY; + if (str == "sleeping") return SERVER_STATE_SLEEPING; + GGML_ASSERT(false && "invalid server_state string"); +} + +using server_state_callback_t = std::function; + +struct server_context { + std::unique_ptr impl; + + server_context(); + ~server_context(); + + // load the model and initialize llama_context + // returns true on success + bool load_model(common_params & params); + + // this function will block main thread until termination + void start_loop(); + + // terminate main loop (will unblock start_loop) + void terminate(); + + // get the underlaying llama_context, can return nullptr if sleeping + // not thread-safe, should only be used from the main thread + llama_context * get_llama_context() const; + + // get a new response reader, used by CLI application + server_response_reader get_response_reader(); + + // get server metadata (read-only), can only be called after load_model() + // not thread-safe, should only be used from the main thread + server_context_meta get_meta() const; + + // note: must be set before load_model() is called + void set_state_callback(server_state_callback_t callback); +}; + + +// forward declarations +struct server_res_generator; + +struct server_routes { + server_routes(const common_params & params, server_context & ctx_server); + + void init_routes(); + + // note: this is not thread-safe and can only when ctx_http.is_ready is false + void update_meta(const server_context & ctx_server) { + this->meta = std::make_unique(ctx_server.get_meta()); + } + + // handlers using lambda function, so that they can capture `this` without `std::bind` + // they won't be called until ctx_http.is_ready is set to true + server_http_context::handler_t get_health; + server_http_context::handler_t get_metrics; + server_http_context::handler_t get_slots; + server_http_context::handler_t post_slots; + server_http_context::handler_t get_props; + server_http_context::handler_t post_props; + server_http_context::handler_t post_infill; + server_http_context::handler_t post_completions; + server_http_context::handler_t post_completions_oai; + server_http_context::handler_t post_chat_completions; + server_http_context::handler_t post_chat_completions_tok; + server_http_context::handler_t post_control; + server_http_context::handler_t post_responses_oai; + server_http_context::handler_t post_responses_tok_oai; + server_http_context::handler_t post_transcriptions_oai; + server_http_context::handler_t post_anthropic_messages; + server_http_context::handler_t post_anthropic_count_tokens; + server_http_context::handler_t post_apply_template; + server_http_context::handler_t get_models; + server_http_context::handler_t post_tokenize; + server_http_context::handler_t post_detokenize; + server_http_context::handler_t post_embeddings; + server_http_context::handler_t post_embeddings_oai; + server_http_context::handler_t post_rerank; + server_http_context::handler_t get_lora_adapters; + server_http_context::handler_t post_lora_adapters; + + // to be used in router mode + json get_model_info() const; + +private: + std::unique_ptr handle_completions_impl( + const server_http_req & req, + server_task_type type, + const json & data, + const std::vector & files, + task_response_type res_type); + std::unique_ptr handle_slots_save(const server_http_req & req, int id_slot); + std::unique_ptr handle_slots_restore(const server_http_req & req, int id_slot); + std::unique_ptr handle_slots_erase(const server_http_req &, int id_slot); + std::unique_ptr handle_embeddings_impl(const server_http_req & req, task_response_type res_type); + std::unique_ptr handle_count_tokens(const llama_vocab * vocab, mtmd_context * mctx, const server_http_req & req, task_response_type res_type); + + // using unique_ptr to allow late initialization of const + std::unique_ptr meta; + + const common_params & params; + const server_context_impl & ctx_server; + + server_queue & queue_tasks; + server_response & queue_results; + std::unique_ptr create_response(bool bypass_sleep = false); +}; diff --git a/tools/server/server-cors-proxy.h b/tools/server/server-cors-proxy.h new file mode 100644 index 0000000000000000000000000000000000000000..3600a33ec6476b7c668c8c511f7c8f1c3f958e31 --- /dev/null +++ b/tools/server/server-cors-proxy.h @@ -0,0 +1,83 @@ +#pragma once + +#include "common.h" +#include "http.h" + +#include +#include +#include +#include +#include +#include + +#include "server-http.h" + +static std::string proxy_header_to_lower(std::string header) { + std::transform(header.begin(), header.end(), header.begin(), [](unsigned char c) { + return std::tolower(c); + }); + return header; +} + +static server_http_res_ptr proxy_request(const server_http_req & req, std::string method) { + std::string target_url = req.get_param("url"); + common_http_url parsed_url = common_http_parse_url(target_url); + + if (parsed_url.host.empty()) { + throw std::runtime_error("invalid target URL: missing host"); + } + + if (parsed_url.path.empty()) { + parsed_url.path = "/"; + } + + if (!parsed_url.password.empty()) { + throw std::runtime_error("authentication in target URL is not supported"); + } + + if (parsed_url.scheme != "http" && parsed_url.scheme != "https") { + throw std::runtime_error("unsupported URL scheme in target URL: " + parsed_url.scheme); + } + + SRV_INF("proxying %s request to %s://%s:%i%s\n", method.c_str(), parsed_url.scheme.c_str(), common_http_format_host(parsed_url.host).c_str(), parsed_url.port, parsed_url.path.c_str()); + + std::map headers; + const std::string proxy_header_prefix = "x-llama-server-proxy-header-"; + for (auto [key, value] : req.headers) { + const std::string lowered_key = proxy_header_to_lower(key); + if (!string_starts_with(lowered_key, proxy_header_prefix)) { + continue; + } + + auto new_key = key.substr(proxy_header_prefix.size()); + if (new_key.empty()) { + continue; + } + + headers[new_key] = value; + } + + auto proxy = std::make_unique( + method, + parsed_url.scheme, + parsed_url.host, + parsed_url.port, + parsed_url.path, + headers, + req.body, + req.files, + req.should_stop, + 600, // timeout_read (default to 10 minutes) + 600 // timeout_write (default to 10 minutes) + ); + + return proxy; +} + +static server_http_context::handler_t proxy_handler_post = [](const server_http_req & req) -> server_http_res_ptr { + return proxy_request(req, "POST"); +}; + +static server_http_context::handler_t proxy_handler_get = [](const server_http_req & req) -> server_http_res_ptr { + return proxy_request(req, "GET"); +}; diff --git a/tools/server/server-http.cpp b/tools/server/server-http.cpp new file mode 100644 index 0000000000000000000000000000000000000000..783b01b82d11d876292430984f6cda54058c054c --- /dev/null +++ b/tools/server/server-http.cpp @@ -0,0 +1,833 @@ +#include "common.h" +#include "http.h" +#include "server-http.h" +#include "server-common.h" +#include "ui.h" + +#include + +#include +#include +#include +#include +#include + +// +// HTTP implementation using cpp-httplib +// + +class server_http_context::Impl { +public: + std::unique_ptr srv; +}; + +server_http_context::server_http_context() + : pimpl(std::make_unique()) +{} + +server_http_context::~server_http_context() = default; + +static void log_server_request(const httplib::Request & req, const httplib::Response & res) { + // skip logging requests that are regularly sent, to avoid log spam + if (req.path == "/health" + || req.path == "/v1/health" + || req.path == "/models" + || req.path == "/v1/models" + || req.path == "/props" + || req.path == "/metrics" + ) { + return; + } + + // reminder: this function is not covered by httplib's exception handler; if someone does more complicated stuff, think about wrapping it in try-catch + + SRV_TRC("done request: %s %s %s %d\n", req.method.c_str(), req.path.c_str(), req.remote_addr.c_str(), res.status); + + SRV_DBG("request: %s\n", req.body.c_str()); + SRV_DBG("response: %s\n", res.body.c_str()); +} + +// returns true if the Origin header value's host is localhost / 127.0.0.1 / ::1 (any port) +static bool origin_is_localhost(const std::string & origin) { + try { + const std::string host = common_http_parse_url(origin).host; + return host == "localhost" || host == "127.0.0.1" || host == "::1"; + } catch (const std::exception &) { + return false; + } +} + +// For Google Cloud Platform deployment compatibility +struct gcp_params { + bool enabled; + std::string path_health; + std::string path_predict; + int port; + + // Ref: https://docs.cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements#aip-variables + gcp_params() { + enabled = getenv("AIP_MODE", "") == "PREDICTION"; + path_health = getenv("AIP_HEALTH_ROUTE", "", true); // default: using the route defined in server.cpp + path_predict = getenv("AIP_PREDICT_ROUTE", "/predict", true); + port = std::stoi(getenv("AIP_HTTP_PORT", "8080")); + } + + static std::string getenv(const char * name, const std::string & default_value, bool ensure_leading_slash = false) { + const auto * value = std::getenv(name); + if (value == nullptr || value[0] == '\0') { + return default_value; + } + std::string val = value; + if (ensure_leading_slash && !val.empty() && val[0] != '/') { + val.insert(val.begin(), '/'); + } + return val; + } +}; + +bool server_http_context::init(const common_params & params) { + const gcp_params gcp; + + path_prefix = params.api_prefix; + port = params.port; + hostname = params.hostname; + + if (gcp.enabled) { + SRV_TRC("Google Cloud Platform compat: health route = %s, predict route = %s, port = %d\n", gcp.path_health.c_str(), gcp.path_predict.c_str(), gcp.port); + + if (port != gcp.port) { + SRV_WRN("Google Cloud Platform compat: overriding server port %d with AIP_HTTP_PORT %d\n", port, gcp.port); + } + + port = gcp.port; + } + + auto & srv = pimpl->srv; + +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + if (!params.ssl_file_key.empty() && !params.ssl_file_cert.empty()) { + SRV_TRC("running with SSL: key = %s, cert = %s\n", params.ssl_file_key.c_str(), params.ssl_file_cert.c_str()); + srv = std::make_unique( + params.ssl_file_cert.c_str(), params.ssl_file_key.c_str() + ); + is_ssl = true; + } else { + SRV_TRC("%s", "running without SSL\n"); + srv = std::make_unique(); + } +#else + if (params.ssl_file_key != "" && params.ssl_file_cert != "") { + SRV_ERR("%s", "the server is built without SSL support\n"); + return false; + } + srv.reset(new httplib::Server()); +#endif + + srv->set_default_headers({{"Server", "llama.cpp"}}); + // srv->set_logger(log_server_request); // TODO @ngxson : this is too spamy, no very useful; improve it in the future + srv->set_exception_handler([](const httplib::Request &, httplib::Response & res, const std::exception_ptr & ep) { + // this is fail-safe; exceptions should already handled by `ex_wrapper` + + std::string message; + try { + std::rethrow_exception(ep); + } catch (const std::exception & e) { + message = e.what(); + } catch (...) { + message = "Unknown Exception"; + } + + res.status = 500; + res.set_content(message, "text/plain"); + SRV_ERR("got exception: %s\n", message.c_str()); + }); + + srv->set_error_handler([](const httplib::Request &, httplib::Response & res) { + if (res.status == 404) { + res.set_content( + safe_json_to_str(json { + {"error", { + {"message", "File Not Found"}, + {"type", "not_found_error"}, + {"code", 404} + }} + }), + "application/json; charset=utf-8" + ); + } + // for other error codes, we skip processing here because it's already done by res->error() + }); + + // set timeouts and change hostname and port + srv->set_read_timeout (params.timeout_read); + srv->set_write_timeout(params.timeout_write); + srv->set_socket_options([reuse_port = params.reuse_port](const socket_t sock) { + httplib::set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1); + if (reuse_port) { +#ifdef SO_REUSEPORT + httplib::set_socket_opt(sock, SOL_SOCKET, SO_REUSEPORT, 1); +#else + SRV_WRN("%s", "SO_REUSEPORT is not supported\n"); +#endif + } + }); + + if (params.api_keys.size() == 1) { + const auto key = params.api_keys[0]; + const std::string substr = key.substr(std::max(static_cast(key.length() - 4), 0)); + SRV_TRC("api_keys: ****%s\n", substr.c_str()); + } else if (params.api_keys.size() > 1) { + SRV_TRC("api_keys: %zu keys loaded\n", params.api_keys.size()); + } + + // + // Middlewares + // + + // Frontend paths - all embedded UI assets + static const std::unordered_set frontend_paths = []() { + std::unordered_set paths { "/" }; + for (const llama_ui_asset & a : llama_ui_get_assets()) { + paths.insert("/" + a.name); + } + return paths; + }(); + + // Public endpoints - API routes plus all embedded UI assets + static const std::unordered_set get_public_endpoints = []() { + std::unordered_set endpoints { + "/health", + "/v1/health", + "/models", + "/v1/models", + }; + endpoints.insert(frontend_paths.begin(), frontend_paths.end()); + return endpoints; + }(); + + auto middleware_validate_api_key = [api_keys = params.api_keys](const httplib::Request & req, httplib::Response & res) { + // If API key is not set, skip validation + if (api_keys.empty()) { + return true; + } + + // If path is public or a UI asset, skip validation + if (get_public_endpoints.count(req.path)) { + return true; + } + + // Check for API key in the Authorization header + std::string req_api_key = req.get_header_value("Authorization"); + if (req_api_key.empty()) { + // retry with anthropic header + req_api_key = req.get_header_value("X-Api-Key"); + } + + // remove the "Bearer " prefix if needed + static std::string prefix = "Bearer "; + if (req_api_key.substr(0, prefix.size()) == prefix) { + req_api_key = req_api_key.substr(prefix.size()); + } + + // validate the API key + if (std::find(api_keys.begin(), api_keys.end(), req_api_key) != api_keys.end()) { + return true; // API key is valid + } + + // API key is invalid or not provided + res.status = 401; + res.set_content( + safe_json_to_str(json { + {"error", { + {"message", "Invalid API Key"}, + {"type", "authentication_error"}, + {"code", 401} + }} + }), + "application/json; charset=utf-8" + ); + + SRV_WRN("%s", "unauthorized: Invalid API Key\n"); + + return false; + }; + + auto middleware_server_state = [this](const httplib::Request & req, httplib::Response & res) { + if (!is_ready.load()) { + if (frontend_paths.count(req.path)) { + return true; // frontend asset, allow it to load and show "loading" + } + // no endpoints are allowed to be accessed when the server is not ready + // this is to prevent any data races or inconsistent states + res.status = 503; + res.set_content( + safe_json_to_str(json { + {"error", { + {"message", "Loading model"}, + {"type", "unavailable_error"}, + {"code", 503} + }} + }), + "application/json; charset=utf-8" + ); + return false; + } + return true; + }; + + // register server middlewares + srv->set_pre_routing_handler([¶ms, middleware_validate_api_key, middleware_server_state](const httplib::Request & req, httplib::Response & res) { + if (params.cors_credentials && params.cors_origins == "*") { + // special case: echo back the Origin header to allow any origin to access the server with credentials + res.set_header("Access-Control-Allow-Origin", req.get_header_value("Origin")); + } else if (params.cors_origins == "localhost") { + // special case: only reflect the Origin header if it is a localhost origin + std::string origin = req.get_header_value("Origin"); + if (!origin.empty() && origin_is_localhost(origin)) { + res.set_header("Access-Control-Allow-Origin", origin); + } else if (!origin.empty()) { + SRV_WRN("(CORS) skip non-localhost origin: %s\n", origin.c_str()); + } + } else { + res.set_header("Access-Control-Allow-Origin", params.cors_origins); + } + // If this is OPTIONS request, skip validation because browsers don't include Authorization header + if (req.method == "OPTIONS") { + res.set_header("Access-Control-Allow-Credentials", params.cors_credentials ? "true" : "false"); + res.set_header("Access-Control-Allow-Methods", params.cors_methods); + res.set_header("Access-Control-Allow-Headers", params.cors_headers); + res.set_content("", "text/html"); // blank response, no data + return httplib::Server::HandlerResponse::Handled; // skip further processing + } + if (!middleware_server_state(req, res)) { + return httplib::Server::HandlerResponse::Handled; + } + if (!middleware_validate_api_key(req, res)) { + return httplib::Server::HandlerResponse::Handled; + } + return httplib::Server::HandlerResponse::Unhandled; + }); + + auto n_threads_http = params.n_threads_http; + if (n_threads_http < 1) { + // +4 threads for monitoring, health and some threads reserved for MCP and other tasks in the future + n_threads_http = std::max(params.n_parallel + 4, static_cast(std::thread::hardware_concurrency() - 1)); + } + SRV_TRC("using %d threads for HTTP server\n", n_threads_http); + srv->new_task_queue = [n_threads_http] { + // spawn n_threads_http fixed thread (always alive), while allow up to 1024 max possible additional threads + // when n_threads_http is used, server will create new "dynamic" threads that will be destroyed after processing each request + // ref: https://github.com/yhirose/cpp-httplib/pull/2368 + const auto max_threads = static_cast(n_threads_http + 1024); + return new httplib::ThreadPool(n_threads_http, max_threads); + }; + + // + // Web UI setup + // + + // Use new `params.ui` field (backed by old `params.webui` for compat) + if (!params.ui) { + SRV_INF("%s", "The UI is disabled\n"); + SRV_INF("%s", "Use --ui/--no-ui (or deprecated --webui/--no-webui) to enable/disable\n"); + } else { + // register static assets routes + if (!params.public_path.empty()) { + // Set the base directory for serving static files + if (const auto is_found = srv->set_mount_point(params.api_prefix + "/", params.public_path); !is_found) { + SRV_ERR("static assets path not found: %s\n", params.public_path.c_str()); + return false; + } + } else { +#if defined(LLAMA_UI_HAS_ASSETS) + static auto handle_gzip_header = [](const httplib::Request & req, httplib::Response & res) { + if (!llama_ui_use_gzip()) { + // no gzip build, skip + return true; + } + if (req.get_header_value("Accept-Encoding").find("gzip") == std::string::npos) { + res.status = 415; // unsupported media type + res.set_content("Error: gzip is not supported by this browser", "text/plain"); + return false; + } else { + res.set_header("Content-Encoding", "gzip"); + } + return true; + }; + + auto serve_asset_cached = [](const std::string & name, bool isolation) { + return [name, isolation](const httplib::Request & req, httplib::Response & res) { + if (!handle_gzip_header(req, res)) { + return true; // returns error message + } + const llama_ui_asset * a = llama_ui_find_asset(name); + if (!a) { res.status = 404; return false; } + res.set_header("ETag", a->etag); + if (const std::string & inm = req.get_header_value("If-None-Match"); + !inm.empty() && (inm == a->etag || inm == std::string("W/") + a->etag)) { + res.status = 304; + return false; + } + if (isolation) { + res.set_header("Cross-Origin-Embedder-Policy", "require-corp"); + res.set_header("Cross-Origin-Opener-Policy", "same-origin"); + } + res.set_header("Cache-Control", "public, max-age=31536000, immutable"); + res.set_content(reinterpret_cast(a->data), a->size, a->type.c_str()); + return false; + }; + }; + + auto serve_asset_nocache = [](const std::string & name) { + return [name](const httplib::Request & req, httplib::Response & res) { + if (!handle_gzip_header(req, res)) { + return true; // returns error message + } + const llama_ui_asset * a = llama_ui_find_asset(name); + if (!a) { + res.status = 404; + return false; + } + res.set_header("Cache-Control", "no-cache"); + res.set_content(reinterpret_cast(a->data), a->size, a->type.c_str()); + return false; + }; + }; + + // main index file + srv->Get(params.api_prefix + "/", serve_asset_cached("index.html", true)); + srv->Get(params.api_prefix + "/index.html", serve_asset_cached("index.html", true)); + + // All remaining assets registered directly from the embedded asset table. + // PWA revalidation files (sw.js, manifest, version.json) use no-cache; + // everything else is immutable. + static const std::unordered_set no_cache_names = { + "sw.js", + "manifest.webmanifest", + "_app/version.json", + "build.json" + }; + + for (const auto & a : llama_ui_get_assets()) { + if (a.name == "index.html") continue; // served at "/" and "/index.html" above + if (no_cache_names.count(a.name)) { + SRV_DBG("serve nocache for %s\n", a.name.c_str()); + srv->Get(params.api_prefix + "/" + a.name, serve_asset_nocache(a.name)); + } else { + srv->Get(params.api_prefix + "/" + a.name, serve_asset_cached(a.name, false)); + } + } + +#endif + } + } + return true; +} + +bool server_http_context::start() { + // Bind and listen + + const auto & srv = pimpl->srv; + auto was_bound = false; + auto is_sock = false; + if (string_ends_with(std::string(hostname), ".sock")) { + is_sock = true; + SRV_TRC("%s", "setting address family to AF_UNIX\n"); + srv->set_address_family(AF_UNIX); + // bind_to_port requires a second arg, any value other than 0 should + // simply get ignored + was_bound = srv->bind_to_port(hostname, 8080); + } else { + SRV_TRC("%s", "binding port with default address family\n"); + // bind HTTP listen port + if (port == 0) { + const auto bound_port = srv->bind_to_any_port(hostname); + was_bound = (bound_port >= 0); + if (was_bound) { + port = bound_port; + } + } else { + was_bound = srv->bind_to_port(hostname, port); + } + } + + if (!was_bound) { + SRV_ERR("couldn't bind HTTP server socket, hostname: %s, port: %d\n", hostname.c_str(), port); + return false; + } + + // run the HTTP server in a thread + thread = std::thread([this] { pimpl->srv->listen_after_bind(); }); + srv->wait_until_ready(); + + listening_address = is_sock ? string_format("unix://%s", hostname.c_str()) + : string_format("%s://%s:%d", is_ssl ? "https" : "http", common_http_format_host(hostname).c_str(), port); + return true; +} + +void server_http_context::stop() const { + if (pimpl->srv) { + pimpl->srv->stop(); + } +} + +static void set_headers(httplib::Response & res, const std::map & headers) { + for (const auto & [key, value] : headers) { + res.set_header(key, value); + } +} + +// percent-decode a path component (%XX). path params arrive raw from httplib, unlike query +// params, so a conv id like "conv::model" sent as "conv%3A%3Amodel" must be decoded here to +// match the value the client put in the X-Conversation-Id header +static std::string decode_path_component(const std::string & in) { + std::string out; + out.reserve(in.size()); + for (size_t i = 0; i < in.size(); i++) { + if (in[i] == '%' && i + 2 < in.size()) { + auto hex = [](char c) -> int { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'a' && c <= 'f') return c - 'a' + 10; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; + }; + int hi = hex(in[i + 1]); + int lo = hex(in[i + 2]); + if (hi >= 0 && lo >= 0) { + out.push_back(char((hi << 4) | lo)); + i += 2; + continue; + } + } + out.push_back(in[i]); + } + return out; +} + +static std::map get_params(const httplib::Request & req) { + std::map params; + for (const auto & [key, value] : req.params) { + params[key] = value; + } + for (const auto & [key, value] : req.path_params) { + params[key] = decode_path_component(value); + } + return params; +} + +static std::map get_headers(const httplib::Request & req) { + std::map headers; + for (const auto & [key, value] : req.headers) { + headers[key] = value; + } + return headers; +} + +static std::string build_query_string(const httplib::Request & req) { + std::string qs; + for (const auto & [key, value] : req.params) { + if (!qs.empty()) { + qs += '&'; + } + qs += httplib::encode_query_component(key) + "=" + httplib::encode_query_component(value); + } + return qs; +} + +// using unique_ptr for request to allow safe capturing in lambdas +using server_http_req_ptr = std::unique_ptr; + +static void process_handler_response(server_http_req_ptr && request, server_http_res_ptr & response, httplib::Response & res) { + if (response->is_stream()) { + res.status = response->status; + // Tell Nginx to not buffer any streamed response + response->headers["X-Accel-Buffering"] = "no"; + set_headers(res, response->headers); + const std::string content_type = response->content_type; + // convert to shared_ptr as both chunked_content_provider() and on_complete() need to use it + std::shared_ptr q_ptr = std::move(request); + std::shared_ptr r_ptr = std::move(response); + + const auto chunked_content_provider = [response = r_ptr](size_t, httplib::DataSink & sink) -> bool { + std::string chunk; + const bool has_next = response->next(chunk); + if (!chunk.empty()) { + if (!sink.write(chunk.data(), chunk.size())) { + return false; + } + SRV_DBG("http: streamed chunk: %s\n", chunk.c_str()); + } + if (!has_next) { + sink.done(); + SRV_DBG("%s", "http: stream ended\n"); + } + return has_next; + }; + const auto on_complete = [request = q_ptr, response = r_ptr](bool) mutable { + response->on_complete(); + response.reset(); + request.reset(); + }; + res.set_chunked_content_provider(content_type, chunked_content_provider, on_complete); + } else { + res.status = response->status; + set_headers(res, response->headers); + res.set_content(response->data, response->content_type); + response->on_complete(); + } +} + +void server_http_context::get(const std::string & path, const server_http_context::handler_t & handler) const { + handlers.emplace(path, handler); + pimpl->srv->Get(path_prefix + path, [handler](const httplib::Request & req, httplib::Response & res) { + server_http_req_ptr request = std::make_unique(server_http_req{ + get_params(req), + get_headers(req), + req.path, + build_query_string(req), + req.body, + {}, + req.is_connection_closed + }); + server_http_res_ptr response = handler(*request); + process_handler_response(std::move(request), response, res); + }); +} + +void server_http_context::post(const std::string & path, const server_http_context::handler_t & handler) const { + handlers.emplace(path, handler); + pimpl->srv->Post(path_prefix + path, [handler](const httplib::Request & req, httplib::Response & res) { + std::string body = req.body; + std::map files; + + if (req.is_multipart_form_data()) { + // translate text fields to a JSON object and use it as the body + json form_json = json::object(); + for (const auto & [key, field] : req.form.fields) { + if (form_json.contains(key)) { + // if the key already exists, convert it to an array + if (!form_json[key].is_array()) { + json existing_value = form_json[key]; + form_json[key] = json::array({existing_value}); + } + form_json[key].push_back(field.content); + } else { + form_json[key] = field.content; + } + } + body = form_json.dump(); + + // populate files from multipart form + for (const auto & [key, file] : req.form.files) { + files[key] = uploaded_file{ + raw_buffer(file.content.begin(), file.content.end()), + file.filename, + file.content_type, + }; + } + } + + server_http_req_ptr request = std::make_unique(server_http_req{ + get_params(req), + get_headers(req), + req.path, + build_query_string(req), + body, + std::move(files), + req.is_connection_closed + }); + server_http_res_ptr response = handler(*request); + process_handler_response(std::move(request), response, res); + }); +} + +void server_http_context::del(const std::string & path, const server_http_context::handler_t & handler) const { + handlers.emplace(path, handler); + pimpl->srv->Delete(path_prefix + path, [handler](const httplib::Request & req, httplib::Response & res) { + server_http_req_ptr request = std::make_unique(server_http_req{ + get_params(req), + get_headers(req), + req.path, + build_query_string(req), + req.body, + {}, + req.is_connection_closed + }); + server_http_res_ptr response = handler(*request); + process_handler_response(std::move(request), response, res); + }); +} + +// +// Vertex AI Prediction protocol (AIP_PREDICT_ROUTE) +// https://cloud.google.com/vertex-ai/docs/predictions/custom-container-requirements +// + +// Derives the camelCase @requestFormat alias for a registered path. +// e.g. "/v1/chat/completions" -> "chatCompletions", "/apply-template" -> "applyTemplate" +static std::string path_to_gcp_format(const std::string & path) { + std::string s = path; + if (s.size() > 3 && s[0] == '/' && s[1] == 'v' && s[2] == '1') { + s = s.substr(3); + } + if (!s.empty() && s[0] == '/') { + s = s.substr(1); + } + std::string result; + bool cap = false; + for (unsigned char c : s) { + if (c == ':') break; // stop before path parameters + if (c == '/' || c == '-' || c == '_') { + cap = true; + } else { + result += static_cast(cap ? std::toupper(c) : c); + cap = false; + } + } + return result; +} + +static json parse_gcp_predict_response(const server_http_res_ptr & res) { + if (res == nullptr) { + throw std::runtime_error("empty response from internal handler"); + } + if (res->is_stream()) { + throw std::invalid_argument("predict route does not support streaming responses"); + } + if (res->data.empty()) { + return nullptr; + } + try { + return json::parse(res->data); + } catch (...) { + return res->data; + } +} + +void server_http_context::register_gcp_compat() const { + const gcp_params gcp; + + if (!gcp.enabled) { + // do nothing + return; + } + + if (handlers.count(gcp.path_predict)) { + SRV_ERR("AIP_PREDICT_ROUTE=%s conflicts with an existing llama-server route\n", gcp.path_predict.c_str()); + exit(1); + } + + // camelCase alias -> canonical path (first registration wins on collision) + // e.g. "chatCompletions" -> "/v1/chat/completions" + std::unordered_map alias_to_path; + for (const auto & [path, _] : handlers) { + alias_to_path.emplace(path_to_gcp_format(path), path); + } + + if (!gcp.path_health.empty()) { + const auto health_handler = handlers.find("/health"); + GGML_ASSERT(health_handler != handlers.end()); + get(gcp.path_health, health_handler->second); + } + + post(gcp.path_predict, [this, alias_to_path = std::move(alias_to_path)](const server_http_req & req) -> server_http_res_ptr { + static const auto build_error = [](const std::string & message, error_type type) -> json { + return json {{"error", format_error_response(message, type)}}; + }; + + json data; + try { + data = json::parse(req.body); + } catch (const std::exception & e) { + auto res = std::make_unique(); + res->status = 400; + res->data = safe_json_to_str({{"error", format_error_response(e.what(), ERROR_TYPE_INVALID_REQUEST)}}); + return res; + } + if (!data.is_object()) { + auto res = std::make_unique(); + res->status = 400; + res->data = safe_json_to_str({{"error", format_error_response("request body must be a JSON object", ERROR_TYPE_INVALID_REQUEST)}}); + return res; + } + if (!data.contains("instances") || !data.at("instances").is_array()) { + auto res = std::make_unique(); + res->status = 400; + res->data = safe_json_to_str({{"error", format_error_response("request body must include an array field named instances", ERROR_TYPE_INVALID_REQUEST)}}); + return res; + } + + const json & instances = data.at("instances"); + static const size_t MAX_INSTANCES = 128; + if (instances.size() > MAX_INSTANCES) { + auto res = std::make_unique(); + res->status = 400; + res->data = safe_json_to_str({{"error", format_error_response("instances array exceeds maximum size of " + std::to_string(MAX_INSTANCES), ERROR_TYPE_INVALID_REQUEST)}}); + return res; + } + + std::vector> futures; + futures.reserve(instances.size()); + + for (const auto & instance : instances) { + futures.push_back(std::async(std::launch::async, [this, &req, &alias_to_path, instance]() -> json { + if (!instance.is_object()) { + return build_error("each instance must be a JSON object", ERROR_TYPE_INVALID_REQUEST); + } + if (!instance.contains("@requestFormat") || !instance.at("@requestFormat").is_string()) { + return build_error("each instance must include a string @requestFormat", ERROR_TYPE_INVALID_REQUEST); + } + + try { + json payload = instance; + const std::string format = payload.at("@requestFormat").get(); + payload.erase("@requestFormat"); + + if (payload.contains("stream")) { + SRV_WRN("%s", "ignoring client-provided stream field in instance, streaming is not supported in predict route\n"); + payload["stream"] = false; + } + + // accept both camelCase aliases (e.g. "chatCompletions") and direct paths + std::string dispatch_path; + auto it_alias = alias_to_path.find(format); + if (it_alias != alias_to_path.end()) { + dispatch_path = it_alias->second; + } else if (handlers.count(format)) { + dispatch_path = format; + } else { + return build_error("no handler registered for @requestFormat: " + format, ERROR_TYPE_INVALID_REQUEST); + } + + const server_http_req internal_req { + req.params, + req.headers, + path_prefix + dispatch_path, + req.query_string, + payload.dump(), + {}, + req.should_stop, + }; + + server_http_res_ptr internal_res = handlers.at(dispatch_path)(internal_req); + return parse_gcp_predict_response(internal_res); + } catch (const std::invalid_argument & e) { + return build_error(e.what(), ERROR_TYPE_INVALID_REQUEST); + } catch (const std::exception & e) { + return build_error(e.what(), ERROR_TYPE_SERVER); + } catch (...) { + return build_error("unknown error", ERROR_TYPE_SERVER); + } + })); + } + + json predictions = json::array(); + for (auto & future : futures) { + predictions.push_back(future.get()); + } + + auto res = std::make_unique(); + res->data = safe_json_to_str({{"predictions", predictions}}); + return res; + }); +} diff --git a/tools/server/server-http.h b/tools/server/server-http.h new file mode 100644 index 0000000000000000000000000000000000000000..032b08d0d2103f109515b446df9cad295d754786 --- /dev/null +++ b/tools/server/server-http.h @@ -0,0 +1,100 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct common_params; + +// generator-like API for HTTP response generation +// this object response with one of the 2 modes: +// 1) normal response: `data` contains the full response body +// 2) streaming response: each call to next(output) generates the next chunk +// when next(output) returns false, no more data after the current chunk +// note: some chunks can be empty, in which case no data is sent for that chunk +struct server_http_res { + std::string content_type = "application/json; charset=utf-8"; + int status = 200; + std::string data; + std::map headers; + + std::function next = nullptr; + bool is_stream() const { + return next != nullptr; + } + + // fired before req and res are destroyed + virtual void on_complete() {} + + virtual ~server_http_res() = default; +}; + +// unique pointer, used by set_chunked_content_provider +// httplib requires the stream provider to be stored in heap +using server_http_res_ptr = std::unique_ptr; +using raw_buffer = std::vector; + +struct uploaded_file { + raw_buffer data; + std::string filename; + std::string content_type; +}; + +struct server_http_req { + std::map params; // path_params + query_params + std::map headers; // used by MCP proxy + std::string path; + std::string query_string; // query parameters string (e.g. "action=save") + std::string body; + std::map files; // used for file uploads (form data) + const std::function & should_stop; + + std::string get_param(const std::string & key, const std::string & def = "") const { + auto it = params.find(key); + if (it != params.end()) { + return it->second; + } + return def; + } +}; + +struct server_http_context { + class Impl; + std::unique_ptr pimpl; + + std::thread thread; // server thread + std::atomic is_ready = false; + + // note: the handler should never throw exceptions + using handler_t = std::function; + mutable std::unordered_map handlers; + + std::string path_prefix; + std::string hostname; + int port = 8080; + bool is_ssl = false; + + server_http_context(); + ~server_http_context(); + + bool init(const common_params & params); + bool start(); + void stop() const; + + void get(const std::string & path, const handler_t & handler) const; + void post(const std::string & path, const handler_t & handler) const; + void del(const std::string & path, const handler_t & handler) const; + + // Register the Google Cloud Platform (Vertex AI) compat (AIP_PREDICT_ROUTE env var, or /predict) + // Must be called AFTER all other API routes are registered + void register_gcp_compat() const; + + // for debugging + std::string listening_address; +}; diff --git a/tools/server/server-mcp.cpp b/tools/server/server-mcp.cpp new file mode 100644 index 0000000000000000000000000000000000000000..93db6164d34e8155afda95c2725a42ac3806403e --- /dev/null +++ b/tools/server/server-mcp.cpp @@ -0,0 +1,820 @@ +#include "server-mcp.h" + +#include "subproc.h" + +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) +# include +# include +#else +# include +# include +# include +# include +extern char ** environ; +#endif + +// read NDJSON lines from a child pipe, calling on_line per line until `running` clears, EOF/error, or on_line returns false. +// polled, not blocking: a grandchild can inherit the pipe's write end and hold it open (terminate() kills only the direct child), so a blocking read would hang teardown on an EOF that never comes. +static void mcp_pump_ndjson(FILE * f, std::atomic & running, + const std::function & on_line) { + if (!f) { + return; + } + const int poll_ms = 50; + const size_t max_line = 8 * 1024 * 1024; // drop any single NDJSON line larger than this, so a child that never emits '\n' can't grow buf without bound +#if defined(_WIN32) + HANDLE h = (HANDLE) _get_osfhandle(_fileno(f)); +#else + int fd = fileno(f); + int fl = fcntl(fd, F_GETFL, 0); + if (fl >= 0) { + fcntl(fd, F_SETFL, fl | O_NONBLOCK); + } +#endif + std::string buf; + bool skipping = false; // discarding an over-long line until its terminating newline + char chunk[4096]; + while (running.load()) { + size_t n = 0; +#if defined(_WIN32) + DWORD avail = 0; + if (!PeekNamedPipe(h, NULL, 0, NULL, &avail, NULL)) { + break; // pipe broken / child gone + } + if (avail == 0) { + std::this_thread::sleep_for(std::chrono::milliseconds(poll_ms)); + continue; + } + DWORD to_read = avail < (DWORD) sizeof(chunk) ? avail : (DWORD) sizeof(chunk); + DWORD got = 0; + if (!ReadFile(h, chunk, to_read, &got, NULL) || got == 0) { + break; + } + n = (size_t) got; +#else + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLIN; + pfd.revents = 0; + int pr = poll(&pfd, 1, poll_ms); + if (pr < 0) { + if (errno == EINTR) { + continue; + } + break; + } + if (pr == 0) { + continue; // timeout -> re-check running + } + if (pfd.revents & (POLLERR | POLLNVAL)) { + break; + } + ssize_t r = read(fd, chunk, sizeof(chunk)); + if (r < 0) { + if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) { + continue; + } + break; + } + if (r == 0) { + break; // EOF: child (and any pipe writers) closed the stream + } + n = (size_t) r; +#endif + buf.append(chunk, n); + + // resync after an over-long, unterminated line: discard bytes until the next newline + if (skipping) { + size_t nl = buf.find('\n'); + if (nl == std::string::npos) { + if (buf.size() > max_line) { + buf.clear(); // stay bounded while waiting for a terminator + } + continue; + } + buf.erase(0, nl + 1); + skipping = false; + } + + size_t pos; + while ((pos = buf.find('\n')) != std::string::npos) { + std::string line = buf.substr(0, pos); + buf.erase(0, pos + 1); + if (!line.empty() && line.back() == '\r') { + line.pop_back(); + } + if (line.empty()) { + continue; + } + if (!on_line(std::move(line))) { + return; + } + } + + // a partial line already larger than the cap and still no newline: drop it to avoid unbounded growth + if (buf.size() > max_line) { + SRV_WRN("MCP: dropping oversized line (> %zu bytes) from child pipe\n", max_line); + buf.clear(); + skipping = true; + } + } +} + +// +// server_mcp_server_config +// + +std::vector server_mcp_server_config::parse_from_json(const std::string & json_str) { + return parse_cursor_format(json::parse(json_str)); +} + +std::vector server_mcp_server_config::parse_cursor_format(const json & j) { + std::vector result; + + if (!j.contains("mcpServers") || !j.at("mcpServers").is_object()) { + return result; + } + + for (const auto & [name, cfg] : j.at("mcpServers").items()) { + server_mcp_server_config sc; + sc.name = name; + sc.command = cfg.value("command", std::string()); + sc.cwd = cfg.value("cwd", std::string()); + sc.timeout_ms = cfg.value("timeout_ms", sc.timeout_ms); + + if (cfg.contains("args") && cfg.at("args").is_array()) { + for (const auto & a : cfg.at("args")) { + sc.args.push_back(a.get()); + } + } + if (cfg.contains("env") && cfg.at("env").is_object()) { + for (const auto & [k, v] : cfg.at("env").items()) { + sc.env[k] = v.get(); + } + } + + if (sc.command.empty()) { + SRV_WRN("MCP server '%s' has no command, skipping\n", name.c_str()); + continue; + } + result.push_back(std::move(sc)); + } + + return result; +} + + +// +// server_mcp_transport +// + +static constexpr const char * MCP_PROTOCOL_VERSION = "2024-11-05"; + +static std::string rpc_error_message(const json & resp) { + if (resp.contains("error")) { + const json & e = resp.at("error"); + if (e.is_object()) { + return e.value("message", "unknown error"); + } + if (e.is_string()) { + return e.get(); + } + } + return "unknown error"; +} + +// normalize an MCP tools/call result to the /tools contract (see README-dev.md): +// concat text parts of result.content[], and surface an isError result +static json mcp_result_to_response(const json & result) { + std::string text; + if (result.contains("content") && result.at("content").is_array()) { + for (const auto & part : result.at("content")) { + if (part.is_object() && part.value("type", "") == "text") { + if (!text.empty()) { + text += "\n"; + } + text += part.value("text", ""); + } + } + } + if (result.is_object() && result.value("isError", false)) { + return {{"error", text.empty() ? "MCP tool returned an error" : text}}; + } + return {{"plain_text_response", text}}; +} + +json server_mcp_transport::send_rpc(const json & request, const std::function & should_stop) { + if (!to_server.write(request.dump())) { + return {{"error", {{"code", -32603}, {"message", "transport closed"}}}}; + } + + const bool has_id = request.contains("id"); + const auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms); + auto stop = [&]() { + return (should_stop && should_stop()) || std::chrono::steady_clock::now() >= deadline; + }; + + std::string frame; + while (from_server.read(frame, stop, false)) { + json reply; + try { + reply = json::parse(frame); + } catch (...) { + if (std::chrono::steady_clock::now() >= deadline) { + break; + } + continue; // skip malformed frame + } + // no id: a notification. mismatched id: a stale reply from a timed-out request (ids are monotonic, never a future one) + if (!has_id || (reply.contains("id") && reply.at("id") == request.at("id"))) { + return reply; + } + if (std::chrono::steady_clock::now() >= deadline) { + break; // a flood of notifications must not outrun the deadline + } + } + + if (should_stop && should_stop()) { + return {{"error", {{"code", -32603}, {"message", "cancelled"}}}}; + } + if (std::chrono::steady_clock::now() >= deadline) { + return {{"error", {{"code", -32603}, {"message", "request timed out"}}}}; + } + return {{"error", {{"code", -32603}, {"message", "transport closed"}}}}; +} + +bool server_mcp_transport::ensure_init(const std::function & should_stop) { + if (initialized) { + return true; + } + + json init_req = { + {"jsonrpc", "2.0"}, + {"id", next_id++}, + {"method", "initialize"}, + {"params", { + {"protocolVersion", MCP_PROTOCOL_VERSION}, + {"capabilities", json::object()}, + {"clientInfo", {{"name", "llama.cpp"}, {"version", "1.0"}}}, + }}, + }; + json resp = send_rpc(init_req, should_stop); + if (!resp.contains("result")) { + last_error = "initialize failed: " + rpc_error_message(resp); + return false; + } + + // notifications/initialized: no id, no reply expected + json notif = {{"jsonrpc", "2.0"}, {"method", "notifications/initialized"}}; + to_server.write(notif.dump()); + + initialized = true; + return true; +} + +std::vector server_mcp_transport::list_tools(const std::function & should_stop) { + std::lock_guard lock(rpc_mutex); + if (!ensure_init(should_stop)) { + return {}; + } + if (!tools.empty()) { + return tools; + } + + json req = {{"jsonrpc", "2.0"}, {"id", next_id++}, {"method", "tools/list"}}; + json resp = send_rpc(req, should_stop); + if (!resp.contains("result")) { + last_error = "tools/list failed: " + rpc_error_message(resp); + return {}; + } + + const json & result = resp.at("result"); + if (result.contains("tools") && result.at("tools").is_array()) { + for (const auto & t : result.at("tools")) { + server_mcp_tool_def def; + def.server_name = name; + def.name = t.value("name", ""); + def.description = t.value("description", ""); + if (t.contains("inputSchema")) { + def.input_schema = t.at("inputSchema"); + } + tools.push_back(std::move(def)); + } + } + return tools; +} + +json server_mcp_transport::call_tool(const std::string & tool_name, + const json & arguments, + const std::function & should_stop) { + std::lock_guard lock(rpc_mutex); + if (!ensure_init(should_stop)) { + return {{"error", last_error}}; + } + + json req = { + {"jsonrpc", "2.0"}, + {"id", next_id++}, + {"method", "tools/call"}, + {"params", {{"name", tool_name}, {"arguments", arguments}}}, + }; + json resp = send_rpc(req, should_stop); + if (resp.contains("error")) { + return {{"error", rpc_error_message(resp)}}; + } + if (resp.contains("result")) { + return mcp_result_to_response(resp.at("result")); + } + return {{"error", "invalid response from MCP server"}}; +} + +// +// server_mcp_stdio +// + +struct server_mcp_stdio::process_handle { + common_subproc sp; + FILE * in = nullptr; // child stdin + FILE * out = nullptr; // child stdout + FILE * err = nullptr; // child stderr +}; + +#if defined(_WIN32) +// config strings are UTF-8 (from JSON) and subprocess.h converts them with CP_UTF8, so inputs must be UTF-8, not the active code page +static std::wstring windows_utf8_to_wide(const std::string & s) { + if (s.empty()) { + return std::wstring(); + } + int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int) s.size(), NULL, 0); + if (n <= 0) { + return std::wstring(); + } + std::wstring w((size_t) n, L'\0'); + MultiByteToWideChar(CP_UTF8, 0, s.data(), (int) s.size(), &w[0], n); + return w; +} + +static std::string windows_wide_to_utf8(const wchar_t * s, int len /* -1 for NUL-terminated */) { + int n = WideCharToMultiByte(CP_UTF8, 0, s, len, NULL, 0, NULL, NULL); + if (n <= 0) { + return std::string(); + } + std::string out((size_t) n, '\0'); + WideCharToMultiByte(CP_UTF8, 0, s, len, &out[0], n, NULL, NULL); + if (len == -1 && !out.empty() && out.back() == '\0') { + out.pop_back(); // drop the terminator WideCharToMultiByte counts for -1 + } + return out; +} +#endif + +static std::string mcp_resolve_command(const std::string & command) { +#if defined(_WIN32) + // For Windows: make sure we handle ".exe" correctly, as well as UTF-8 + std::wstring wcmd = windows_utf8_to_wide(command); + wchar_t buf[MAX_PATH * 4]; + const DWORD cap = (DWORD) (sizeof(buf) / sizeof(buf[0])); + + auto search = [&](const wchar_t * ext) -> std::string { + DWORD n = SearchPathW(NULL, wcmd.c_str(), ext, cap, buf, NULL); + return (n > 0 && n < cap) ? windows_wide_to_utf8(buf, (int) n) : std::string(); + }; + + std::string found = search(NULL); // exact path / already-extensioned / .exe on PATH + if (!found.empty()) { + return found; + } + + std::wstring pathext; + DWORD need = GetEnvironmentVariableW(L"PATHEXT", NULL, 0); + if (need > 0) { + pathext.resize(need); + DWORD got = GetEnvironmentVariableW(L"PATHEXT", &pathext[0], need); + pathext.resize(got); + } + if (pathext.empty()) { + pathext = L".COM;.EXE;.BAT;.CMD"; + } + for (size_t start = 0; start <= pathext.size();) { + size_t sep = pathext.find(L';', start); + std::wstring ext = pathext.substr(start, sep == std::wstring::npos ? std::wstring::npos : sep - start); + if (!ext.empty()) { + found = search(ext.c_str()); + if (!found.empty()) { + return found; + } + } + if (sep == std::wstring::npos) { + break; + } + start = sep + 1; + } + return command; // give up and let subprocess.h report the spawn error +#else + return command; +#endif // _WIN32 +} + +static std::vector mcp_parent_env() { + std::vector env; +#if defined(_WIN32) + LPWCH block = GetEnvironmentStringsW(); + if (block) { + for (LPWCH e = block; *e; e += wcslen(e) + 1) { + env.emplace_back(windows_wide_to_utf8(e, -1)); + } + FreeEnvironmentStringsW(block); + } +#else + if (environ) { + for (char ** e = environ; *e; ++e) { + env.emplace_back(*e); + } + } +#endif + return env; +} + +// parent env with the config overrides applied, in "KEY=VALUE" form +static std::vector mcp_build_env(const std::map & overrides) { + std::vector env; + for (auto & e : mcp_parent_env()) { + size_t eq = e.find('='); + std::string key = eq == std::string::npos ? e : e.substr(0, eq); + if (overrides.find(key) == overrides.end()) { + env.push_back(e); + } + } + for (auto & [k, v] : overrides) { + env.push_back(k + "=" + v); + } + return env; +} + +server_mcp_stdio::server_mcp_stdio(const server_mcp_server_config & config) : config(config) { + name = config.name; + timeout_ms = config.timeout_ms; + // bound the reply queue: send_rpc only drains during a call, so unsolicited notifications would otherwise grow it without limit + from_server.max_size = 65536; +} + +server_mcp_stdio::~server_mcp_stdio() { + join_pumps(); +} + +bool server_mcp_stdio::start() { + std::vector argv_s; + argv_s.push_back(mcp_resolve_command(config.command)); + argv_s.insert(argv_s.end(), config.args.begin(), config.args.end()); + + int options = subprocess_option_no_window | subprocess_option_search_user_path; + std::vector envp_s; + if (config.env.empty()) { + options |= subprocess_option_inherit_environment; + } else { + envp_s = mcp_build_env(config.env); + } + + auto handle = std::make_unique(); + bool ok = handle->sp.create(argv_s, options, envp_s, config.cwd.empty() ? nullptr : config.cwd.c_str()); + if (!ok) { + SRV_WRN("MCP '%s': failed to spawn '%s'\n", config.name.c_str(), config.command.c_str()); + return false; + } + handle->in = handle->sp.stdin_file(); + handle->out = handle->sp.stdout_file(); + handle->err = handle->sp.stderr_file(); + + proc = std::move(handle); + running.store(true); + reader = std::thread([this] { reader_loop(); }); + writer = std::thread([this] { writer_loop(); }); + errlog = std::thread([this] { errlog_loop(); }); + return true; +} + +void server_mcp_stdio::close() { + join_pumps(); +} + +bool server_mcp_stdio::is_alive() const { + return running.load(); +} + +std::string server_mcp_stdio::diagnostics() { + std::string out; + { + std::lock_guard lock(rpc_mutex); // last_error is written by send_rpc's callers + out = last_error; + } + std::lock_guard lk(err_mu); + if (!err_tail.empty()) { + if (!out.empty()) { + out += "; "; + } + out += "last stderr: " + err_tail; + } + return out; +} + +void server_mcp_stdio::reader_loop() { + mcp_pump_ndjson(proc->out, running, [this](std::string && line) { + return from_server.write(std::move(line)); // false => consumer gone, stop + }); + running.store(false); + to_server.close_write(); // stop the writer + from_server.close_write(); // EOF to any waiting caller +} + +// write all of `data` to child stdin, non-blocking and polled so teardown never hangs (a grandchild can hold the read end of a full pipe open). returns false on error/close/shutdown. +static bool mcp_write_all(FILE * f, const std::string & data, std::atomic & running) { + if (!f) { + return false; + } + size_t total = 0; +#if defined(_WIN32) + HANDLE h = (HANDLE) _get_osfhandle(_fileno(f)); + DWORD nowait = PIPE_NOWAIT; + SetNamedPipeHandleState(h, &nowait, NULL, NULL); + while (total < data.size() && running.load()) { + DWORD written = 0; + BOOL ok = WriteFile(h, data.data() + total, (DWORD) (data.size() - total), &written, NULL); + if (ok && written > 0) { + total += written; + continue; + } + if (!ok) { + DWORD err = GetLastError(); + if (err != ERROR_NO_DATA && err != ERROR_PIPE_BUSY) { + return false; + } + } + // backpressure (pipe full) is rare for small JSON-RPC frames; sleep rather than spin. + // no writable-wait exists for a PIPE_NOWAIT anonymous pipe, so this polls like the POSIX poll() path. + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } +#else + int fd = fileno(f); + int fl = fcntl(fd, F_GETFL, 0); + if (fl >= 0) { + fcntl(fd, F_SETFL, fl | O_NONBLOCK); + } + while (total < data.size() && running.load()) { + ssize_t n = write(fd, data.data() + total, data.size() - total); + if (n > 0) { + total += (size_t) n; + continue; + } + if (n == 0) { + return false; + } + if (errno == EINTR) { + continue; + } + if (errno != EAGAIN && errno != EWOULDBLOCK) { + return false; + } + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLOUT; + pfd.revents = 0; + int pr = poll(&pfd, 1, 50); + if (pr < 0) { + if (errno == EINTR) { + continue; + } + return false; + } + if (pfd.revents & (POLLERR | POLLNVAL | POLLHUP)) { + return false; + } + } +#endif + return total == data.size(); +} + +void server_mcp_stdio::writer_loop() { + auto should_stop = [this] { return !running.load(); }; + std::string msg; + while (to_server.read(msg, should_stop)) { + msg.push_back('\n'); + if (!mcp_write_all(proc->in, msg, running)) { + break; // child gone or shutting down + } + } + running.store(false); + to_server.close_read(); // fail fast on any further send_rpc write + from_server.close_write(); // wake any caller waiting for a reply +} + +void server_mcp_stdio::errlog_loop() { + static constexpr size_t ERR_TAIL_MAX = 4096; + // drain stderr (an undrained pipe blocks the child): + // log it, and keep a bounded tail for reporting when the server dies + mcp_pump_ndjson(proc->err, running, [this](std::string && line) { + SRV_DBG("MCP '%s' stderr: %s\n", name.c_str(), line.c_str()); + std::lock_guard lk(err_mu); + err_tail += line; + err_tail += '\n'; + if (err_tail.size() > ERR_TAIL_MAX) { + err_tail.erase(0, err_tail.size() - ERR_TAIL_MAX); + } + return true; + }); +} + +void server_mcp_stdio::join_pumps() { + if (!proc) { + return; + } + running.store(false); + to_server.close_write(); // wake the writer if it waits for a message + from_server.close_write(); // wake any caller waiting for a reply + + proc->sp.terminate(); // child death unblocks the blocked fread/fwrite + + if (writer.joinable()) writer.join(); + if (reader.joinable()) reader.join(); + if (errlog.joinable()) errlog.join(); + + proc->sp.join(); // reap the child: never waiting would leave the pid a zombie for the process lifetime + proc.reset(); +} + + +// +// server_mcp +// + +static constexpr int MCP_COOLDOWN_SECONDS = 5; +static constexpr int MCP_WARMUP_TIMEOUT_SECONDS = 10; // cap per-server tool discovery at startup + +server_mcp::~server_mcp() { + shutdown(); + + std::vector> to_close; + { + std::lock_guard lock(mutex); + for (auto & [name, t] : transports) { + to_close.push_back(std::move(t)); + } + transports.clear(); + } + for (auto & t : to_close) { + t->close(); + } +} + +std::shared_ptr server_mcp::create_transport(const server_mcp_server_config & cfg) { + return std::make_shared(cfg); +} + +void server_mcp::shutdown() { + stopping.store(true); +} + +const server_mcp_server_config * server_mcp::find_config(const std::string & name) const { + for (const auto & c : configs) { + if (c.name == name) { + return &c; + } + } + return nullptr; +} + +void server_mcp::start(const common_params & params) { + auto append = [this](const std::string & json_str) { + try { + auto parsed = server_mcp_server_config::parse_from_json(json_str); + if (parsed.empty()) { + SRV_WRN("%s", "MCP config: no servers found in JSON\n"); + } + for (auto & p : parsed) { + // names must be unique across both config sources: get_or_create / find_config key on the name + if (find_config(p.name)) { + SRV_WRN("MCP config: duplicate server name '%s', skipping\n", p.name.c_str()); + continue; + } + configs.push_back(std::move(p)); + } + } catch (const std::exception & e) { + throw std::runtime_error(std::string("failed to parse MCP config JSON: ") + e.what()); + } + }; + if (!params.mcp_servers_config.empty()) { + std::ifstream f = fs_open_ifstream(params.mcp_servers_config, std::ios::in); + if (!f) { + throw std::runtime_error("failed to open MCP config file: " + params.mcp_servers_config); + } + std::stringstream ss; + ss << f.rdbuf(); + append(ss.str()); + } + if (!params.mcp_servers_json.empty()) { + append(params.mcp_servers_json); + } + + if (configs.empty()) { + return; + } + + std::vector discovered; + for (const auto & cfg : configs) { + auto t = create_transport(cfg); + if (!t->start()) { + SRV_WRN("MCP warmup: failed to spawn '%s': %s\n", cfg.name.c_str(), t->diagnostics().c_str()); + continue; + } + // bound warmup per server so an unresponsive one can't stall startup for the full per-call timeout + const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(MCP_WARMUP_TIMEOUT_SECONDS); + auto should_stop = [this, deadline]() { + return stopping.load() || std::chrono::steady_clock::now() >= deadline; + }; + auto tools = t->list_tools(should_stop); + SRV_INF("MCP warmup: '%s' discovered %zu tools\n", cfg.name.c_str(), tools.size()); + discovered.insert(discovered.end(), tools.begin(), tools.end()); + t->close(); + } + + std::lock_guard lock(mutex); + registry.swap(discovered); +} + +std::vector server_mcp::list_tools() const { + std::lock_guard lock(mutex); + return registry; +} + +json server_mcp::call_tool(const std::string & server_name, + const std::string & tool_name, + const json & arguments, + const std::function & should_stop) { + auto transport = get_or_create(server_name); + if (!transport) { + return {{"error", "MCP server unavailable: " + server_name}}; + } + + auto stop = [this, &should_stop]() { + return stopping.load() || (should_stop && should_stop()); + }; + return transport->call_tool(tool_name, arguments, stop); +} + +std::shared_ptr server_mcp::get_or_create(const std::string & name) { + std::vector> to_close; // closed after unlock + std::shared_ptr result; + + { + std::lock_guard lock(mutex); + if (stopping.load()) { + return nullptr; + } + + auto now = std::chrono::steady_clock::now(); + auto dead_it = dead_servers.find(name); + if (dead_it != dead_servers.end()) { + if (now < dead_it->second) { + return nullptr; + } + dead_servers.erase(dead_it); + } + + auto it = transports.find(name); + if (it != transports.end()) { + if (it->second->is_alive()) { + return it->second; + } + SRV_WRN("MCP '%s' is no longer alive: %s\n", name.c_str(), it->second->diagnostics().c_str()); + to_close.push_back(std::move(it->second)); + transports.erase(it); + } + + const server_mcp_server_config * cfg = find_config(name); + if (cfg) { + auto fresh = create_transport(*cfg); + if (fresh->start() && fresh->is_alive()) { + transports[name] = fresh; + result = fresh; + } else { + SRV_WRN("MCP '%s': failed to start: %s\n", name.c_str(), fresh->diagnostics().c_str()); + to_close.push_back(std::move(fresh)); + dead_servers[name] = now + std::chrono::seconds(MCP_COOLDOWN_SECONDS); + } + } + } + + for (auto & t : to_close) { + t->close(); // blocking call, no leaks + } + + return result; +} + diff --git a/tools/server/server-mcp.h b/tools/server/server-mcp.h new file mode 100644 index 0000000000000000000000000000000000000000..c7f33a3f797dae7052fde252bf8d483a782fde11 --- /dev/null +++ b/tools/server/server-mcp.h @@ -0,0 +1,176 @@ +#pragma once + +#include "server-common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// Configuration (Cursor-compatible "mcpServers" JSON) +// + +struct server_mcp_server_config { + std::string name; // config key, e.g. "filesystem" + std::string command; + std::vector args; + std::map env; // merged over the parent env + std::string cwd; + int timeout_ms = 30000; // per-tool-call timeout + + // throw on parse errors; missing "mcpServers" yields an empty list; entries without a "command" are skipped + static std::vector parse_from_json(const std::string & json_str); + static std::vector parse_cursor_format(const json & j); +}; + +// a tool advertised by an MCP server +struct server_mcp_tool_def { + std::string server_name; + std::string name; // bare tool name, no "_" prefix + std::string description; + json input_schema; // JSON Schema for the arguments, or null +}; + +// +// server_mcp_transport: one MCP server session. +// +// caller --send_rpc--> to_server --[writer]--> framing --> server +// caller <--send_rpc-- from_server <--[reader]-- framing <-- server +// +// each queue item is one complete serialized JSON message. +// subclass owns byte I/O and framing; base owns JSON and the JSON-RPC session (handshake, id correlation). +// + +struct server_mcp_transport { + std::string name; + int timeout_ms = 30000; + + server_pipe to_server; // serialized messages we send to the server + server_pipe from_server; // serialized messages read from the server + + virtual ~server_mcp_transport() = default; + + virtual bool start() = 0; + virtual void close() = 0; // blocking and idempotent + virtual bool is_alive() const = 0; // never blocks behind an in-flight send_rpc() + + // human-readable diagnostics for logging when the transport fails/dies + // (example: last RPC error, plus any transport-specific detail) + // may run on a different thread than send_rpc(), so last_error is read under rpc_mutex + virtual std::string diagnostics() { + std::lock_guard lock(rpc_mutex); + return last_error; + } + + std::vector list_tools(const std::function & should_stop); + + json call_tool(const std::string & tool_name, + const json & arguments, + const std::function & should_stop); + +protected: + // per-transport: send_rpc() holds it across the reply wait, so sharing it would stall every server behind one slow call. guards all members below. + std::mutex rpc_mutex; + uint64_t next_id = 1; // reset to 1 per (re)spawn + bool initialized = false; + std::string last_error; + std::vector tools; + + // both assume rpc_mutex is already held by the public caller + bool ensure_init(const std::function & should_stop); // initialize handshake, once + json send_rpc(const json & request, const std::function & should_stop); // returns the reply or an {"error": ...} +}; + +// +// server_mcp_stdio: child process, NDJSON JSON-RPC over stdio (stderr drained to the debug log) +// + +struct server_mcp_stdio : server_mcp_transport { + explicit server_mcp_stdio(const server_mcp_server_config & config); + ~server_mcp_stdio() override; + + bool start() override; + void close() override; + bool is_alive() const override; + std::string diagnostics() override; + +private: + server_mcp_server_config config; + + // defined in the .cpp so stays out of this header + struct process_handle; + std::unique_ptr proc; + + std::thread reader; // child stdout -> NDJSON de-framing -> from_server + std::thread writer; // to_server -> NDJSON framing -> child stdin + std::thread errlog; // child stderr -> debug log (must be drained or the child blocks) + + // cleared by close() or by the reader on stdout EOF; read without rpc_mutex + std::atomic running{false}; + + // bounded tail of the child's stderr, for diagnostics when it dies + std::mutex err_mu; + std::string err_tail; + + void reader_loop(); + void writer_loop(); + void errlog_loop(); + void join_pumps(); +}; + +// +// server_mcp +// declare before the HTTP context so it outlives every /tools handler. +// + +class server_mcp { +public: + server_mcp() = default; + ~server_mcp(); + + // parse the MCP config from params (file and/or inline JSON), + // then spawn each server once, list its tools, and shut it down + // throws on config parse errors; spawn failures are logged. + void start(const common_params & params); + + // true until start() has parsed at least one server from the config + bool empty() const { return configs.empty(); } + + std::vector list_tools() const; + + // lazily (re)spawns the transport. returns the MCP result or an {"error": ...}. should_stop is OR-ed with the manager's cancel flag. + json call_tool(const std::string & server_name, + const std::string & tool_name, + const json & arguments, + const std::function & should_stop = nullptr); + + // flip the cancel flag so in-flight calls return; blocking teardown is in the destructor. call before the HTTP server drains. + // note: multiple calls are idempotent + void shutdown(); + +private: + std::vector configs; + + mutable std::mutex mutex; // guards transports, dead_servers, registry + + // shared_ptr: call_tool() hands a transport to the caller and drops the lock for the blocking RPC, so a concurrent evict/respawn must not destroy it mid-call + std::map> transports; + std::map dead_servers; // spawn-failure cooldown + std::vector registry; + + std::atomic stopping{false}; + + const server_mcp_server_config * find_config(const std::string & name) const; + + // the only place that names a concrete transport + std::shared_ptr create_transport(const server_mcp_server_config & cfg); + + // nullptr during cooldown or shutdown + std::shared_ptr get_or_create(const std::string & name); +}; diff --git a/tools/server/server-models.cpp b/tools/server/server-models.cpp new file mode 100644 index 0000000000000000000000000000000000000000..93e940951e5f8a5821b65d585eddf3a9175f8d0b --- /dev/null +++ b/tools/server/server-models.cpp @@ -0,0 +1,2507 @@ +#include "server-common.h" +#include "http.h" +#include "server-models.h" +#include "server-context.h" +#include "server-stream.h" + +#include "build-info.h" +#include "preset.h" +#include "download.h" +#include "http.h" +#include "subproc.h" + +#include // TODO: remove this once we use HTTP client from download.h +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef _WIN32 +extern char **environ; +#endif + +#if defined(__APPLE__) && defined(__MACH__) +// macOS: use _NSGetExecutablePath to get the executable path +#include +#include +#endif + +#define DEFAULT_STOP_TIMEOUT 10 // seconds + +#define CMD_ROUTER_TO_CHILD_EXIT "cmd_router_to_child:exit" +#define CMD_CHILD_TO_ROUTER_STATE "cmd_child_to_router:state:" // followed by json string + +// address for child process, this is needed because router may run on 0.0.0.0 +// ref: https://github.com/ggml-org/llama.cpp/issues/17862 +#define CHILD_ADDR "127.0.0.1" + +struct server_subproc { + common_subproc sproc; // not yet spawned while in DOWNLOADING state + std::atomic stopped{false}; // set to cancel a download or signal child process exit + + bool is_alive() { + return sproc.alive(); + } + + void request_exit() { + FILE * stdin_file = sproc.stdin_file(); + if (stdin_file) { + fprintf(stdin_file, "%s\n", CMD_ROUTER_TO_CHILD_EXIT); + fflush(stdin_file); + } + stopped.store(true, std::memory_order_relaxed); + } + + void terminate() { + sproc.terminate(); + } +}; + +struct server_lru_sched { + server_lru_sched(server_models & models) : models(models) {} + + bool has_capacity(std::unique_lock & lk) { + check_lock(lk); + return models.base_params.models_max <= 0 + || count_running() < (size_t) models.base_params.models_max; + } + + // returns "" if no model can be given up + std::string pick_victim(std::unique_lock & lk, const std::string & exclude) { + check_lock(lk); + std::string victim; + int64_t victim_last_used = 0; + for (const auto & m : models.mapping) { + if (m.first == exclude) { + continue; + } + // a busy model is mid-request, one still coming up has no request to finish + if (m.second.req_count != 0 || !m.second.meta.is_ready_or_sleep()) { + continue; + } + if (victim.empty() || m.second.meta.last_used < victim_last_used) { + victim = m.first; + victim_last_used = m.second.meta.last_used; + } + } + return victim; + } + + // requests wanting the same model share one entry, so they all need only one slot + // and all get unblocked by the single load that entry performs + void join(std::unique_lock & lk, const std::string & model_id) { + check_lock(lk); + if (entry_t * e = find(model_id)) { + e->n_waiters++; + SRV_INF("request for name=%s joined the queue, %d waiting\n", model_id.c_str(), e->n_waiters); + return; + } + queue.push_back({ model_id, 1, false, false }); + SRV_INF("models_max reached, request for name=%s queued at position %zu\n", + model_id.c_str(), queue.size()); + } + + void leave(std::unique_lock & lk, const std::string & model_id) { + check_lock(lk); + for (auto it = queue.begin(); it != queue.end(); ++it) { + if (it->model_id == model_id) { + if (--it->n_waiters <= 0) { + queue.erase(it); // last one waiting for this model went away + } + return; + } + } + } + + bool queue_empty(std::unique_lock & lk) { + check_lock(lk); + return queue.empty(); + } + + // true if it is this model's turn to load, and nobody is loading it yet + bool try_claim(std::unique_lock & lk, const std::string & model_id) { + check_lock(lk); + if (queue.empty() || queue.front().model_id != model_id || queue.front().loading) { + return false; + } + if (!has_capacity(lk)) { + return false; + } + queue.front().loading = true; + return true; + } + + // ok means the model is up: drop the entry, the other waiters just watch its status now + void claim_done(std::unique_lock & lk, const std::string & model_id, bool ok) { + check_lock(lk); + for (auto it = queue.begin(); it != queue.end(); ++it) { + if (it->model_id == model_id) { + if (ok) { + queue.erase(it); + } else { + it->loading = false; + } + return; + } + } + } + + // a model is on its way out for this entry, so other requests do not also give up one + void mark_slot_pending(std::unique_lock & lk, const std::string & model_id) { + check_lock(lk); + if (entry_t * e = find(model_id)) { + e->slot_pending = true; + } + } + + // model_id went idle: give up its slot if a queued request needs one + // thread-safe, caller must NOT hold models.mutex + void on_model_idle(const std::string & model_id) { + if (models.base_params.models_max <= 0) { + return; // no limit, nothing is ever queued + } + { + std::unique_lock lk(models.mutex); + if (queue.empty()) { + return; + } + size_t promised = 0; + bool has_unserved = false; + for (const auto & e : queue) { + if (e.needs_slot()) { + has_unserved = true; + } else { + promised++; + } + } + if (!has_unserved) { + return; + } + if ((int) count_running() - (int) promised < models.base_params.models_max) { + return; // a slot is already on its way + } + // never give up a model that a queued request wants + for (const auto & e : queue) { + if (e.model_id == model_id) { + return; + } + } + auto it = models.mapping.find(model_id); + if (it == models.mapping.end() || it->second.req_count != 0 || !it->second.meta.is_ready_or_sleep()) { + return; + } + for (auto & e : queue) { + if (!e.slot_pending) { + e.slot_pending = true; + break; + } + } + } + SRV_INF("model name=%s went idle, giving up its slot to a queued request\n", model_id.c_str()); + models.unload(model_id); + } + + private: + struct entry_t { + std::string model_id; + int n_waiters; // requests waiting for this model + bool slot_pending; // a model is already being evicted for this entry + bool loading; // one of the waiters is doing the load right now + + // a slot is already coming, or already taken by the load in flight + bool needs_slot() const { return !slot_pending && !loading; } + }; + + entry_t * find(const std::string & model_id) { + for (auto & e : queue) { + if (e.model_id == model_id) { + return &e; + } + } + return nullptr; + } + + void check_lock(std::unique_lock & lk) { + GGML_ASSERT(lk.owns_lock() && lk.mutex() == &models.mutex); + } + + size_t count_running() { + size_t count = 0; + for (const auto & m : models.mapping) { + if (m.second.meta.is_running()) { + count++; + } + } + return count; + } + + server_models & models; + std::deque queue; +}; + +// short loopback budget for the resumable stream router to child JSON calls (probe, lookup, +// delete). distinct from params.timeout_read/write which only applies to the generation proxy +static constexpr int STREAM_LOOKUP_TIMEOUT_MS = 250; + +static std::filesystem::path get_server_exec_path() { +#if defined(_WIN32) + wchar_t buf[32768] = { 0 }; // Large buffer to handle long paths + DWORD len = GetModuleFileNameW(nullptr, buf, _countof(buf)); + if (len == 0 || len >= _countof(buf)) { + throw std::runtime_error("GetModuleFileNameW failed or path too long"); + } + return std::filesystem::path(buf); +#elif defined(__APPLE__) && defined(__MACH__) + char small_path[PATH_MAX]; + uint32_t size = sizeof(small_path); + + if (_NSGetExecutablePath(small_path, &size) == 0) { + // resolve any symlinks to get absolute path + try { + return std::filesystem::canonical(std::filesystem::path(small_path)); + } catch (...) { + return std::filesystem::path(small_path); + } + } else { + // buffer was too small, allocate required size and call again + std::vector buf(size); + if (_NSGetExecutablePath(buf.data(), &size) == 0) { + try { + return std::filesystem::canonical(std::filesystem::path(buf.data())); + } catch (...) { + return std::filesystem::path(buf.data()); + } + } + throw std::runtime_error("_NSGetExecutablePath failed after buffer resize"); + } +#else + char path[FILENAME_MAX]; + ssize_t count = readlink("/proc/self/exe", path, FILENAME_MAX); + if (count <= 0) { + throw std::runtime_error("failed to resolve /proc/self/exe"); + } + return std::filesystem::path(std::string(path, count)); +#endif +} + +static void unset_reserved_args(common_preset & preset, bool unset_model_args) { + preset.unset_option("LLAMA_ARG_SSL_KEY_FILE"); + preset.unset_option("LLAMA_ARG_SSL_CERT_FILE"); + preset.unset_option("LLAMA_API_KEY"); + preset.unset_option("LLAMA_ARG_MODELS_DIR"); + preset.unset_option("LLAMA_ARG_MODELS_MAX"); + preset.unset_option("LLAMA_ARG_MODELS_PRESET"); + preset.unset_option("LLAMA_ARG_MODELS_AUTOLOAD"); + if (unset_model_args) { + preset.unset_option("LLAMA_ARG_MODEL"); + preset.unset_option("LLAMA_ARG_MMPROJ"); + preset.unset_option("LLAMA_ARG_ALIAS"); + preset.unset_option("LLAMA_ARG_HF_REPO"); + } +} + +#ifdef _WIN32 +static std::string wide_to_utf8(const wchar_t * ws) { + if (!ws || !*ws) { + return {}; + } + + const int len = static_cast(std::wcslen(ws)); + const int bytes = WideCharToMultiByte(CP_UTF8, 0, ws, len, nullptr, 0, nullptr, nullptr); + if (bytes == 0) { + return {}; + } + + std::string utf8(bytes, '\0'); + WideCharToMultiByte(CP_UTF8, 0, ws, len, utf8.data(), bytes, nullptr, nullptr); + + return utf8; +} +#endif + +static std::vector get_environment() { + std::vector env; + +#ifdef _WIN32 + LPWCH env_block = GetEnvironmentStringsW(); + if (!env_block) { + return env; + } + for (LPWCH e = env_block; *e; e += wcslen(e) + 1) { + env.emplace_back(wide_to_utf8(e)); + } + FreeEnvironmentStringsW(env_block); +#else + if (environ == nullptr) { + return env; + } + for (char ** e = environ; *e != nullptr; e++) { + env.emplace_back(*e); + } +#endif + + return env; +} + +void server_model_meta::update_args(common_preset_context & ctx_preset, std::string bin_path) { + // update params + unset_reserved_args(preset, false); + preset.set_option(ctx_preset, "LLAMA_ARG_HOST", CHILD_ADDR); + preset.set_option(ctx_preset, "LLAMA_ARG_PORT", std::to_string(port)); + preset.set_option(ctx_preset, "LLAMA_ARG_ALIAS", name); + // TODO: maybe validate preset before rendering ? + // render args + args = preset.to_args(bin_path); + + // unified binary dispatches by subcommand, re-inject it right after the + // binary path so the child starts as 'llama serve ...' not 'llama ...' + const char * app_cmd = std::getenv("LLAMA_APP_CMD"); + if (app_cmd != nullptr && app_cmd[0] != '\0' && !bin_path.empty()) { + args.insert(args.begin() + 1, app_cmd); + } +} + +void server_model_meta::update_caps() { + try { + common_params params; + preset.apply_to_params(params, { + "LLAMA_ARG_MODEL", + "LLAMA_ARG_MODEL_URL", + "LLAMA_ARG_MMPROJ", + "LLAMA_ARG_MMPROJ_URL", + "LLAMA_ARG_MMPROJ_AUTO", + "LLAMA_ARG_HF_REPO", + "LLAMA_ARG_HF_REPO_FILE", + }); + params.offline = true; + common_models_handler handler = common_models_handler_init(params, LLAMA_EXAMPLE_SERVER); + common_models_handler_apply(handler, params); // note: this won't download the model because offline=true + if (params.no_mmproj || params.mmproj.path.empty()) { + multimodal = { false, false }; + } else { + multimodal = mtmd_get_cap_from_file(params.mmproj.path.c_str()); + } + } catch (const std::exception & e) { + LOG_WRN("failed to initialize common_params for multimodal capability detection: %s\n", e.what()); + multimodal = { false, false }; + } +} + +// +// server_models +// + +server_models::server_models( + const common_params & params, + int argc, + char ** argv) + : ctx_preset(LLAMA_EXAMPLE_SERVER), + base_params(params), + base_env(get_environment()), + base_preset(ctx_preset.load_from_args(argc, argv)), + sched(std::make_unique(*this)) { + // clean up base preset + unset_reserved_args(base_preset, true); + // set binary path + try { + bin_path = get_server_exec_path().string(); + } catch (const std::exception & e) { + bin_path = argv[0]; + LOG_WRN("failed to get server executable path: %s\n", e.what()); + LOG_WRN("using original argv[0] as fallback: %s\n", argv[0]); + } + load_models(); + debug_fake_timing = !common_get_env("LLAMA_SERVER_DEBUG_FAKE_TIMING").empty(); +} + +server_models::~server_models() = default; + +void server_models::add_model(server_model_meta && meta) { + if (mapping.find(meta.name) != mapping.end()) { + throw std::runtime_error(string_format("model '%s' appears multiple times", meta.name.c_str())); + } + + // check model name does not conflict with existing aliases + for (const auto & [key, inst] : mapping) { + if (inst.meta.aliases.count(meta.name)) { + throw std::runtime_error(string_format("model name '%s' conflicts with alias of model '%s'", + meta.name.c_str(), key.c_str())); + } + } + + // parse aliases from preset's --alias option (comma-separated) + std::string alias_str; + if (meta.preset.get_option("LLAMA_ARG_ALIAS", alias_str) && !alias_str.empty()) { + for (auto & alias : string_split(alias_str, ',')) { + alias = string_strip(alias); + if (!alias.empty()) { + meta.aliases.insert(alias); + } + } + } + + // parse tags from preset's --tags option (comma-separated) + std::string tags_str; + if (meta.preset.get_option("LLAMA_ARG_TAGS", tags_str) && !tags_str.empty()) { + for (auto & tag : string_split(tags_str, ',')) { + tag = string_strip(tag); + if (!tag.empty()) { + meta.tags.insert(tag); + } + } + } + + // validate aliases do not conflict with existing names or aliases + for (const auto & alias : meta.aliases) { + if (mapping.find(alias) != mapping.end()) { + throw std::runtime_error(string_format("alias '%s' for model '%s' conflicts with existing model name", + alias.c_str(), meta.name.c_str())); + } + for (const auto & [key, inst] : mapping) { + if (inst.meta.aliases.count(alias)) { + throw std::runtime_error(string_format("alias '%s' for model '%s' conflicts with alias of model '%s'", + alias.c_str(), meta.name.c_str(), key.c_str())); + } + } + } + + meta.update_args(ctx_preset, bin_path); // render args + meta.update_caps(); + std::string name = meta.name; + mapping[name] = instance_t{ + /* subproc */ std::make_shared(), + /* th */ std::thread(), + /* meta */ std::move(meta) + }; +} + +void server_models::notify_sse(const std::string & event, const std::string & model_id, const json & data) { + std::unique_ptr result = std::make_unique(); + result->data = { + {"model", model_id}, + {"event", event}, + }; + if (!data.is_null()) { + result->data["data"] = data; + } + SRV_DBG("notifying SSE clients about event '%s' for model '%s': %s\n", event.c_str(), model_id.c_str(), safe_json_to_str(result->data).c_str()); + sse.broadcast(std::move(result)); +} + +void server_models::load_models() { + // Phase 1: load presets from all sources - pure I/O, no lock needed + // 1. cached models + common_presets cached_models = ctx_preset.load_from_cache(); + SRV_INF("Loaded %zu cached model presets\n", cached_models.size()); + // 2. local models from --models-dir + common_presets local_models; + if (!base_params.models_dir.empty()) { + local_models = ctx_preset.load_from_models_dir(base_params.models_dir); + SRV_INF("Loaded %zu local model presets from %s\n", local_models.size(), base_params.models_dir.c_str()); + } + // 3. custom-path models from presets + common_preset global = {}; + common_presets custom_presets = {}; + if (!base_params.models_preset.empty()) { + custom_presets = ctx_preset.load_from_ini(base_params.models_preset, global); + SRV_INF("Loaded %zu custom model presets from %s\n", custom_presets.size(), base_params.models_preset.c_str()); + } + + // cascade, apply global preset first + cached_models = ctx_preset.cascade(global, cached_models); + local_models = ctx_preset.cascade(global, local_models); + custom_presets = ctx_preset.cascade(global, custom_presets); + + // note: if a model exists in both cached and local, local takes precedence + common_presets final_presets; + std::unordered_map source_map; + for (const auto & [name, preset] : cached_models) { + final_presets[name] = preset; + source_map[name] = SERVER_MODEL_SOURCE_CACHE; + } + for (const auto & [name, preset] : local_models) { + final_presets[name] = preset; + source_map[name] = SERVER_MODEL_SOURCE_MODELS_DIR; + } + for (const auto & [name, custom] : custom_presets) { + if (final_presets.find(name) != final_presets.end()) { + final_presets[name].merge(custom); + } else { + final_presets[name] = custom; + } + source_map[name] = SERVER_MODEL_SOURCE_PRESET; + } + + // overlay router's own CLI args on top of every model preset so that + // e.g. `llama-server --temp 0` is honoured by all child processes + for (auto & [name, preset] : final_presets) { + preset.merge(base_preset); + } + + auto get_source = [&](const std::string & name) { + return source_map.count(name) ? source_map.at(name) : SERVER_MODEL_SOURCE_PRESET; + }; + + // Helpers that read `mapping` - must be called while holding the lock. + std::unordered_set custom_names; + for (const auto & [name, preset] : custom_presets) custom_names.insert(name); + auto join_set = [](const std::set & s) { + std::string result; + for (const auto & v : s) { + if (!result.empty()) result += ", "; + result += v; + } + return result; + }; + auto log_available_models = [&]() { + SRV_INF("Available models (%zu) (*: custom preset)\n", mapping.size()); + for (const auto & [name, inst] : mapping) { + bool has_custom = custom_names.find(name) != custom_names.end(); + std::string info; + if (!inst.meta.aliases.empty()) info += " (aliases: " + join_set(inst.meta.aliases) + ")"; + if (!inst.meta.tags.empty()) info += " [tags: " + join_set(inst.meta.tags) + "]"; + SRV_INF(" %c %s%s\n", has_custom ? '*' : ' ', name.c_str(), info.c_str()); + } + }; + auto apply_stop_timeout = [&]() { + for (auto & [name, inst] : mapping) { + std::string val; + if (inst.meta.preset.get_option(COMMON_ARG_PRESET_STOP_TIMEOUT, val)) { + try { + inst.meta.stop_timeout = std::stoi(val); + } catch (...) { + SRV_WRN("invalid stop-timeout value '%s' for model '%s', using default %d seconds\n", + val.c_str(), name.c_str(), DEFAULT_STOP_TIMEOUT); + inst.meta.stop_timeout = DEFAULT_STOP_TIMEOUT; + } + } + } + }; + // update_args() injects HOST/PORT/ALIAS, so strip them before comparing presets + auto preset_options_for_compare = [](common_preset p) { + p.unset_option("LLAMA_ARG_HOST"); + p.unset_option("LLAMA_ARG_PORT"); + p.unset_option("LLAMA_ARG_ALIAS"); + return p.options; + }; + + // Phase 2: acquire the lock once for all mapping mutations. + // We temporarily release it only when calling functions that acquire it internally + // (unload, load) or when joining threads (the monitoring thread calls update_status + // which locks the mutex, so joining while holding it would deadlock). + std::unique_lock lk(mutex); + + need_reload = false; + bool is_first_load = mapping.empty(); + + if (is_first_load) { + // FIRST LOAD: add all models, then unlock for autoloading + for (const auto & [name, preset] : final_presets) { + server_model_meta meta{ + /* source */ get_source(name), + /* preset */ preset, + /* name */ name, + /* aliases */ {}, + /* tags */ {}, + /* port */ 0, + /* status */ SERVER_MODEL_STATUS_UNLOADED, + /* last_used */ 0, + /* args */ std::vector(), + /* loaded_info */ {}, + /* progress */ {}, + /* exit_code */ 0, + /* stop_timeout */ DEFAULT_STOP_TIMEOUT, + /* multimodal */ mtmd_caps{false, false}, + // /* need_download */ false, + }; + add_model(std::move(meta)); + } + apply_stop_timeout(); + log_available_models(); + + std::vector models_to_load; + for (const auto & [name, inst] : mapping) { + std::string val; + if (inst.meta.preset.get_option(COMMON_ARG_PRESET_LOAD_ON_STARTUP, val) && common_arg_utils::is_truthy(val)) { + models_to_load.push_back(name); + } + } + if ((int)models_to_load.size() > base_params.models_max) { + throw std::runtime_error(string_format( + "number of models to load on startup (%zu) exceeds models_max (%d)", + models_to_load.size(), base_params.models_max)); + } + + lk.unlock(); + for (const auto & name : models_to_load) { + SRV_INF("(startup) loading model %s\n", name.c_str()); + load(name); + } + } else { + // RELOAD: diff the new preset list against the current mapping and reconcile + is_reloading = true; + + // find running models whose source was removed or whose preset changed + std::vector to_unload; + for (const auto & [name, inst] : mapping) { + if (!inst.meta.is_running()) continue; + auto it = final_presets.find(name); + if (it == final_presets.end()) { + to_unload.push_back(name); // removed from source + } else if (preset_options_for_compare(inst.meta.preset) != preset_options_for_compare(it->second)) { + to_unload.push_back(name); // preset changed + } + } + + // unload() acquires the lock internally, so release before each call + for (const auto & name : to_unload) { + SRV_INF("(reload) unloading model name=%s (source updated or removed)\n", name.c_str()); + lk.unlock(); + unload(name); + lk.lock(); + } + + // wait for all targeted models to reach UNLOADED; cv.wait handles unlock/relock + cv.wait(lk, [&]() { + for (const auto & name : to_unload) { + auto it = mapping.find(name); + if (it != mapping.end() && it->second.meta.is_running()) return false; + } + return true; + }); + + // collect all threads to join in one pass while the lock is held: + // - monitoring threads from just-unloaded models (to_unload) + // - threads of finished downloads (DOWNLOADED), they acquire the mutex on exit + // - threads of already-UNLOADED models that are being removed from source + std::vector threads_to_join; + for (const auto & name : to_unload) { + auto it = mapping.find(name); + if (it != mapping.end() && it->second.th.joinable()) { + threads_to_join.push_back(std::move(it->second.th)); + } + } + for (auto & [name, inst] : mapping) { + if (inst.meta.status == SERVER_MODEL_STATUS_DOWNLOADING) { + continue; // downloading models are not from config sources, leave them alone + } + if (inst.meta.status == SERVER_MODEL_STATUS_DOWNLOADED) { + // joining this thread under the lock deadlocks: it locks the mutex on its way out + if (inst.th.joinable()) { + threads_to_join.push_back(std::move(inst.th)); + } + continue; + } + if (final_presets.find(name) == final_presets.end() && !inst.meta.is_running() && inst.th.joinable()) { + threads_to_join.push_back(std::move(inst.th)); + } + } + + // join outside the lock - monitoring thread calls update_status (needs lock) + lk.unlock(); + for (auto & th : threads_to_join) th.join(); + lk.lock(); + + // erase models no longer in any source + for (auto it = mapping.begin(); it != mapping.end(); ) { + if (it->second.meta.status == SERVER_MODEL_STATUS_DOWNLOADING) { + ++it; // download thread is still busy, skip + } else if (it->second.meta.status == SERVER_MODEL_STATUS_DOWNLOADED) { + // download finished, thread is joined above, safe to erase + GGML_ASSERT(!it->second.th.joinable()); + it = mapping.erase(it); + } else if (final_presets.find(it->first) == final_presets.end()) { + SRV_INF("(reload) removing model name=%s (no longer in source)\n", it->first.c_str()); + GGML_ASSERT(!it->second.th.joinable()); // must have been joined above + it = mapping.erase(it); + } else { + ++it; + } + } + + // update presets for non-running models still in source + for (auto & [name, inst] : mapping) { + if (inst.meta.is_running()) continue; + auto it = final_presets.find(name); + if (it == final_presets.end()) continue; // erased above + + inst.meta.preset = it->second; + + // re-parse aliases, then validate against other models + std::set new_aliases; + std::string alias_str; + if (inst.meta.preset.get_option("LLAMA_ARG_ALIAS", alias_str) && !alias_str.empty()) { + for (auto & alias : string_split(alias_str, ',')) { + alias = string_strip(alias); + if (!alias.empty()) new_aliases.insert(alias); + } + } + inst.meta.aliases.clear(); + for (const auto & alias : new_aliases) { + bool conflict = false; + for (const auto & [other_name, other_inst] : mapping) { + if (other_name == name) continue; + if (other_name == alias || other_inst.meta.aliases.count(alias)) { + SRV_WRN("(reload) alias '%s' for model '%s' conflicts with model '%s', skipping\n", + alias.c_str(), name.c_str(), other_name.c_str()); + conflict = true; + break; + } + } + if (!conflict) inst.meta.aliases.insert(alias); + } + + // re-parse tags + inst.meta.tags.clear(); + std::string tags_str; + if (inst.meta.preset.get_option("LLAMA_ARG_TAGS", tags_str) && !tags_str.empty()) { + for (auto & tag : string_split(tags_str, ',')) { + tag = string_strip(tag); + if (!tag.empty()) inst.meta.tags.insert(tag); + } + } + + inst.meta.exit_code = 0; // clear failed state so the model can be reloaded + inst.meta.update_args(ctx_preset, bin_path); + inst.meta.update_caps(); + } + + // add models that are new in this reload + std::vector newly_added; + for (const auto & [name, preset] : final_presets) { + if (mapping.find(name) == mapping.end()) { + server_model_meta meta{ + /* source */ get_source(name), + /* preset */ preset, + /* name */ name, + /* aliases */ {}, + /* tags */ {}, + /* port */ 0, + /* status */ SERVER_MODEL_STATUS_UNLOADED, + /* last_used */ 0, + /* args */ std::vector(), + /* loaded_info */ {}, + /* progress */ {}, + /* exit_code */ 0, + /* stop_timeout */ DEFAULT_STOP_TIMEOUT, + /* multimodal */ mtmd_caps{false, false}, + // /* need_download */ false, + }; + add_model(std::move(meta)); + newly_added.push_back(name); + } + } + + apply_stop_timeout(); + + // clear reload flag before unlocking for autoload - load() blocks on !is_reloading, + // so clearing it here (while still locked) prevents a deadlock in the autoload calls below + is_reloading = false; + cv.notify_all(); + + log_available_models(); + + // collect autoload candidates while still under the lock + std::vector to_autoload; + for (const auto & name : newly_added) { + auto it = mapping.find(name); + if (it != mapping.end()) { + std::string val; + if (it->second.meta.preset.get_option(COMMON_ARG_PRESET_LOAD_ON_STARTUP, val) && common_arg_utils::is_truthy(val)) { + to_autoload.push_back(name); + } + } + } + + lk.unlock(); + for (const auto & name : to_autoload) { + SRV_INF("(reload) loading new model %s\n", name.c_str()); + load(name); + } + + notify_sse("models_reload", "*"); + } +} + +void server_models::update_meta(const std::string & name, const server_model_meta & meta) { + std::lock_guard lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end()) { + it->second.meta = meta; + } + cv.notify_all(); // notify wait_until_loading_finished +} + +bool server_models::has_model(const std::string & name) { + std::lock_guard lk(mutex); + if (mapping.find(name) != mapping.end()) { + return true; + } + for (const auto & [key, inst] : mapping) { + if (inst.meta.aliases.count(name)) { + return true; + } + } + return false; +} + +std::optional server_models::get_meta(const std::string & name) { + std::unique_lock lk(mutex); + if (need_reload) { + lk.unlock(); + load_models(); + lk.lock(); + } + + auto it = mapping.find(name); + if (it != mapping.end()) { + return it->second.meta; + } + for (const auto & [key, inst] : mapping) { + if (inst.meta.aliases.count(name)) { + return inst.meta; + } + } + return std::nullopt; +} + +std::vector server_models::get_all_meta() { + std::unique_lock lk(mutex); + if (need_reload) { + lk.unlock(); + load_models(); + lk.lock(); + } + + std::vector result; + result.reserve(mapping.size()); + for (const auto & [name, inst] : mapping) { + result.push_back(inst.meta); + } + return result; +} + +void server_models::unload_lru() { + if (base_params.models_max <= 0) { + return; // no limit + } + // remove one of the servers if we passed the models_max (least recently used - LRU) + std::string lru_model_name; + { + std::unique_lock lk(mutex); + if (sched->has_capacity(lk)) { + return; + } + lru_model_name = sched->pick_victim(lk, ""); + } + if (!lru_model_name.empty()) { + SRV_INF("models_max limit reached, removing LRU name=%s\n", lru_model_name.c_str()); + unload(lru_model_name); + // wait for unload to complete + { + std::unique_lock lk(mutex); + cv.wait(lk, [this, &lru_model_name]() { + return mapping[lru_model_name].meta.status == SERVER_MODEL_STATUS_UNLOADED; + }); + } + } +} + +void server_models::load(const std::string & name) { + load(name, load_options{}); +} + +void server_models::load(const std::string & name, const load_options & opts) { + if (debug_fake_timing) { + // do not hold the mutex here, other requests must keep making progress + std::this_thread::sleep_for(std::chrono::seconds(2)); + } + + if (!opts.custom_meta.has_value()) { + if (!has_model(name)) { + throw std::runtime_error("model name=" + name + " is not found"); + } + unload_lru(); + } + + std::unique_lock lk(mutex); + // edge case: block until any in-progress reload has finished so we always load + // against the freshest preset and a consistent mapping state + cv.wait(lk, [this]() { return !is_reloading; }); + + auto meta = opts.custom_meta.has_value() ? *opts.custom_meta : mapping[name].meta; + if (meta.status != SERVER_MODEL_STATUS_UNLOADED) { + SRV_INF("model %s is not ready\n", name.c_str()); + return; + } + + // Re-check capacity under the lock to prevent concurrent loads from + // exceeding models_max. Without this, the window between unload_lru() + // releasing its lock and this lock_guard acquiring allows multiple + // threads to each observe capacity and all proceed to load. + if (base_params.models_max > 0) { + size_t count_active = 0; + for (const auto & m : mapping) { + if (m.second.meta.is_running()) { + count_active++; + } + } + if (count_active >= (size_t)base_params.models_max) { + throw std::runtime_error("model limit reached, try again later"); + } + } + + // prepare new instance info + instance_t inst; + inst.meta = meta; + inst.meta.port = common_http_get_free_port(); + inst.meta.status = SERVER_MODEL_STATUS_LOADING; + inst.meta.loaded_info = json{}; + inst.meta.last_used = ggml_time_ms(); + + if (inst.meta.port <= 0) { + throw std::runtime_error("failed to get a port number"); + } + + inst.subproc = std::make_shared(); + { + SRV_INF("spawning server instance with name=%s on port %d\n", inst.meta.name.c_str(), inst.meta.port); + + inst.meta.update_args(ctx_preset, bin_path); // render args + + std::vector child_args = inst.meta.args; // copy + std::vector child_env = base_env; // copy + child_env.push_back("LLAMA_SERVER_ROUTER_PORT=" + std::to_string(base_params.port)); + + if (opts.mode == SERVER_CHILD_MODE_DOWNLOAD) { + inst.meta.status = SERVER_MODEL_STATUS_DOWNLOADING; + child_env.push_back("LLAMA_SERVER_CHILD_MODE=download"); + child_env.push_back("LLAMA_ARG_HF_REPO=" + name); + } + + SRV_INF("%s", "spawning server instance with args:\n"); + for (const auto & arg : child_args) { + SRV_INF(" %s\n", arg.c_str()); + } + inst.meta.args = child_args; // save for debugging + + // TODO @ngxson : maybe separate stdout and stderr in the future + // so that we can use stdout for commands and stderr for logging + int options = subprocess_option_no_window | subprocess_option_combined_stdout_stderr; + if (!inst.subproc->sproc.create(child_args, options, child_env)) { + throw std::runtime_error("failed to spawn server instance"); + } + } + + // start a thread to manage the child process + // captured variables are guaranteed to be destroyed only after the thread is joined + inst.th = std::thread([ + this, name, + child_proc = inst.subproc, + port = inst.meta.port, + stop_timeout = inst.meta.stop_timeout, + child_mode = opts.mode + ]() { + FILE * stdin_file = child_proc->sproc.stdin_file(); + FILE * stdout_file = child_proc->sproc.stdout_file(); // combined stdout/stderr + + std::thread log_thread([&]() { + // read stdout/stderr and forward to main server log + // also handle status report from child process + std::vector vec_buf(128 * 1024); // large buffer for storing info + char * buffer = vec_buf.data(); + if (stdout_file) { + while (fgets(buffer, vec_buf.size(), stdout_file) != nullptr) { + LOG("[%5d] %s", port, buffer); + std::string str(buffer); + if (string_starts_with(buffer, CMD_CHILD_TO_ROUTER_STATE)) { + this->handle_child_state(name, str); + } + } + } else { + SRV_ERR("failed to get stdout/stderr of child process for name=%s\n", name.c_str()); + } + }); + + std::thread stopping_thread([&]() { + // thread to monitor explicit stop requests; child crash is signalled via child_proc->stopped + auto is_stopping = [this, &name]() { + return this->stopping_models.find(name) != this->stopping_models.end(); + }; + { + std::unique_lock lk(this->mutex); + this->cv_stop.wait(lk, [&]() { + return is_stopping() || child_proc->stopped.load(std::memory_order_acquire); + }); + } + // child crashed or finished on its own, skip graceful shutdown sequence + if (child_proc->stopped.load(std::memory_order_acquire)) { + return; + } + SRV_INF("stopping model instance name=%s\n", name.c_str()); + fprintf(stdin_file, "%s\n", CMD_ROUTER_TO_CHILD_EXIT); + fflush(stdin_file); + int64_t start_time = ggml_time_ms(); + while (true) { + std::unique_lock lk(this->mutex); + if (!is_stopping() || child_proc->stopped.load(std::memory_order_acquire)) { + return; + } + int64_t elapsed = ggml_time_ms() - start_time; + if (elapsed >= stop_timeout * 1000) { + lk.unlock(); + SRV_WRN("force-killing model instance name=%s after %d seconds timeout\n", name.c_str(), stop_timeout); + child_proc->terminate(); + return; + } + this->cv_stop.wait_for(lk, std::chrono::seconds(1), [&]() { + return !is_stopping() || child_proc->stopped.load(std::memory_order_acquire); + }); + } + }); + + // we reach here when the child process exits (stdout EOF) + // note: we cannot join() prior to this point because it will close stdin_file + if (log_thread.joinable()) { + log_thread.join(); + } + + child_proc->stopped.store(true, std::memory_order_release); + { + std::lock_guard lk(this->mutex); + stopping_models.erase(name); + cv_stop.notify_all(); + } + if (stopping_thread.joinable()) { + stopping_thread.join(); + } + + // get the exit code + int exit_code = child_proc->sproc.join(); + + // update status and exit code + if (child_mode == SERVER_CHILD_MODE_DOWNLOAD) { + // instance will be cleaned up on next load_models() call + } else { + this->update_status(name, { + SERVER_MODEL_STATUS_UNLOADED, + exit_code + }); + } + SRV_INF("instance name=%s exited with status %d\n", name.c_str(), exit_code); + }); + + // clean up old process/thread if exists + { + auto & old_instance = mapping[name]; + // old process should have exited already, but just in case, we clean it up here + if (old_instance.subproc && old_instance.subproc->is_alive()) { + SRV_WRN("old process for model name=%s is still alive, this is unexpected\n", name.c_str()); + old_instance.subproc->terminate(); // force kill + } + if (old_instance.th.joinable()) { + old_instance.th.join(); + } + } + + notify_sse("model_status", name, { + {"status", server_model_status_to_string(inst.meta.status)}, + }); + + mapping[name] = std::move(inst); + cv.notify_all(); +} + +void server_models::unload(const std::string & name) { + std::unique_lock lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end()) { + if (it->second.meta.status == SERVER_MODEL_STATUS_DOWNLOADING) { + SRV_INF("cancelling download for model name=%s\n", name.c_str()); + it->second.subproc->request_exit(); + // for convenience, we wait the status change here + wait(lk, name, [](const server_model_meta & new_meta) { + return new_meta.status != SERVER_MODEL_STATUS_DOWNLOADING; + }); + } else if (it->second.meta.is_running()) { + SRV_INF("stopping model instance name=%s\n", name.c_str()); + stopping_models.insert(name); + if (it->second.meta.status == SERVER_MODEL_STATUS_LOADING) { + // special case: if model is in loading state, unloading means force-killing it + SRV_WRN("model name=%s is still loading, force-killing\n", name.c_str()); + it->second.subproc->terminate(); + } + cv_stop.notify_all(); + // status change will be handled by the managing thread + } else { + SRV_WRN("model instance name=%s is not running\n", name.c_str()); + } + } +} + +void server_models::unload_all() { + std::vector to_join; + { + std::lock_guard lk(mutex); + for (auto & [name, inst] : mapping) { + if (inst.meta.status == SERVER_MODEL_STATUS_DOWNLOADING) { + SRV_INF("cancelling download for model name=%s\n", name.c_str()); + inst.subproc->stopped.store(true, std::memory_order_relaxed); + } else if (inst.meta.is_running()) { + SRV_INF("stopping model instance name=%s\n", name.c_str()); + stopping_models.insert(name); + cv_stop.notify_all(); + // status change will be handled by the managing thread + } + // moving the thread to join list to avoid deadlock + to_join.push_back(std::move(inst.th)); + } + } + for (auto & th : to_join) { + if (th.joinable()) { + th.join(); + } + } +} + +void server_models::update_status(const std::string & name, const update_status_args & args) { + std::unique_lock lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end()) { + auto & meta = it->second.meta; + meta.status = args.status; + meta.exit_code = args.exit_code; + if (!args.loaded_info.is_null()) { + meta.loaded_info = args.loaded_info; + } + if (!args.progress.is_null()) { + meta.progress = args.progress; + } + } + // broadcast status change to SSE + { + json data = { + {"status", server_model_status_to_string(args.status)}, + }; + if (args.status == SERVER_MODEL_STATUS_UNLOADED) { + data["exit_code"] = args.exit_code; + } + if (!args.loaded_info.is_null()) { + data["info"] = args.loaded_info; + } + if (!args.progress.is_null()) { + data["progress"] = args.progress; + } + // note: notify_sse doesn't acquire the lock, so no deadlock here + notify_sse("status_change", name, data); + } + cv.notify_all(); +} + +void server_models::update_download_progress(const std::string & name, const common_download_progress & progress, bool done, bool ok) { + json curr; + { + std::lock_guard lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end()) { + if (done) { + // mark the instance to be erased on next load_models() call + it->second.meta.status = SERVER_MODEL_STATUS_DOWNLOADED; + need_reload = true; + } else { + json & info = it->second.meta.loaded_info; + if (!info.contains("progress")) { + info["progress"] = json{}; + } + info["progress"][progress.url] = { + {"done", progress.downloaded}, + {"total", progress.total}, + }; + curr = it->second.meta.loaded_info; // copy + } + } + } + if (done) { + cv.notify_all(); // notify in case unload() is waiting for download to be cancelled + notify_sse(ok ? "download_finished" : "download_failed", name, {}); + } else { + notify_sse("download_progress", name, curr); + } +} + +bool server_models::remove(const std::string & name) { + // do everything under one lock acquisition; avoid get_meta() / + // unload() because they can trigger load_models() which erases + // transient DOWNLOADING / DOWNLOADED entries as a side-effect + std::unique_lock lk(mutex); + + auto it = mapping.find(name); + if (it == mapping.end()) { + throw std::runtime_error("model name=" + name + " is not found"); + } + if (it->second.meta.source != SERVER_MODEL_SOURCE_CACHE) { + throw std::runtime_error("model name=" + name + " is not removable (not from cache)"); + } + + if (it->second.meta.status == SERVER_MODEL_STATUS_DOWNLOADING) { + // cancel in-flight download + SRV_INF("cancelling download for model name=%s\n", name.c_str()); + it->second.subproc->request_exit(); + } else if (it->second.meta.is_running()) { + // stop running instance + SRV_INF("stopping model instance name=%s\n", name.c_str()); + stopping_models.insert(name); + if (it->second.meta.status == SERVER_MODEL_STATUS_LOADING) { + it->second.subproc->terminate(); + } + cv_stop.notify_all(); + } + + // wait until the monitoring thread finishes + wait(lk, name, [](const server_model_meta & meta) { + return meta.status == SERVER_MODEL_STATUS_UNLOADED + || meta.status == SERVER_MODEL_STATUS_DOWNLOADED; + }); + + // re-find after wait - load_models() may have erased the entry during the wait + it = mapping.find(name); + if (it == mapping.end()) { + // load_models() already joined the thread and erased the entry; + // we just need to clean up the cached files on disk + lk.unlock(); + bool ok = common_download_remove(name); + SRV_INF("removing model name=%s from cache (%s)\n", name.c_str(), ok ? "succeeded" : "partial"); + notify_sse("model_remove", name, {}); + return true; + } + + // join before erasing - thread no longer acquires this mutex + if (it->second.th.joinable()) { + it->second.th.join(); + } + + // remove from disk (best-effort: cancelled downloads may have no cached files) + bool ok = common_download_remove(name); + mapping.erase(name); + if (!ok) { + SRV_WRN("removing model name=%s from disk returned false (no cached files?)\n", name.c_str()); + } + SRV_INF("removing model name=%s from cache (%s)\n", name.c_str(), ok ? "succeeded" : "partial"); + notify_sse("model_remove", name, {}); + return true; +} + +void server_models::wait(const std::string & name, std::function predicate) { + std::unique_lock lk(mutex); + wait(lk, name, predicate); +} + +void server_models::wait(std::unique_lock & lk, const std::string & name, std::function predicate) { + cv.wait(lk, [this, &name, &predicate]() { + auto it = mapping.find(name); + if (it != mapping.end()) { + return predicate(it->second.meta); + + } + // model was removed from mapping by another code path (e.g. load_models()). + // nothing left to wait for - tell the caller to proceed. + return true; + }); +} + +bool server_models::ensure_model_ready(const std::string & name, const std::function & should_stop) { + auto meta = get_meta(name); + if (!meta.has_value()) { + throw std::runtime_error("model name=" + name + " is not found"); + } + if (meta->is_ready()) { + return false; // ready for taking requests + } + if (meta->status == SERVER_MODEL_STATUS_SLEEPING) { + return false; // child is sleeping but still running; new request will wake it up + } + + bool queued = false; + bool did_load = false; + std::string victim; + { + std::unique_lock lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end() && it->second.meta.status == SERVER_MODEL_STATUS_UNLOADED) { + bool has_capacity = sched->has_capacity(lk); + if (has_capacity && sched->queue_empty(lk)) { + lk.unlock(); + SRV_INF("model name=%s is not loaded, loading...\n", name.c_str()); + load(name); + did_load = true; + } else { + // also queue when a slot looks free but others wait already, else they starve + sched->join(lk, name); + queued = true; + if (!has_capacity) { + // an idle model may sit here right now, do not wait for a request to end + victim = sched->pick_victim(lk, name); + if (!victim.empty()) { + sched->mark_slot_pending(lk, name); + } + } + } + } + } + if (!victim.empty()) { + SRV_INF("evicting idle LRU name=%s to make room for name=%s\n", victim.c_str(), name.c_str()); + unload(victim); + } + + // while queued, this is also where the load happens: the head of the queue does it + SRV_INF("waiting until model name=%s is fully loaded...\n", name.c_str()); + std::unique_lock lk(mutex); + auto leave_queue = [this, &queued, &lk, &name]() { + if (queued) { + sched->leave(lk, name); + queued = false; + } + }; + + try { + bool saw_loading = false; + while (true) { + auto it = mapping.find(name); + if (it == mapping.end()) { + break; // removed by another code path, nothing to wait for + } + const server_model_status status = it->second.meta.status; + + if (status == SERVER_MODEL_STATUS_LOADED || status == SERVER_MODEL_STATUS_SLEEPING) { + break; + } + if (status == SERVER_MODEL_STATUS_DOWNLOADING || status == SERVER_MODEL_STATUS_DOWNLOADED) { + break; // do not wait on a download child + } + if (status == SERVER_MODEL_STATUS_LOADING) { + saw_loading = true; + } else if (status == SERVER_MODEL_STATUS_UNLOADED) { + if (did_load || saw_loading) { + // a spawn happened and the instance came back down + if (it->second.meta.is_failed()) { + throw std::runtime_error("model name=" + name + " failed to load"); + } + break; // unloaded by another code path, caller reports "not running" + } + if (!queued) { + break; // not queued, and the load someone else started fell over + } + } + + if (should_stop && should_stop()) { + // if a model was evicted for us, the free slot goes to the next waiter + throw std::runtime_error("request cancelled while waiting for model name=" + name); + } + + // our turn: our model is at the head, and a slot really did free up + if (status == SERVER_MODEL_STATUS_UNLOADED && sched->try_claim(lk, name)) { + lk.unlock(); + bool ok = true; + try { + SRV_INF("slot available, loading queued model name=%s\n", name.c_str()); + load(name); + did_load = true; + } catch (const std::exception & e) { + // lost a race for the slot, stay in line and retry + SRV_WRN("queued load of name=%s did not go through: %s\n", name.c_str(), e.what()); + ok = false; + } + lk.lock(); + sched->claim_done(lk, name, ok); + if (ok) { + queued = false; // entry is gone, the other waiters watch the status now + } + continue; + } + + cv.wait_for(lk, std::chrono::milliseconds(200)); + } + } catch (...) { + leave_queue(); + throw; + } + leave_queue(); + + return true; +} + +server_http_res_ptr server_models::proxy_request(const server_http_req & req, const std::string & method, const std::string & name, bool update_last_used, bool detached) { + auto meta = get_meta(name); + if (!meta.has_value()) { + throw std::runtime_error("model name=" + name + " is not found"); + } + if (!meta->is_running()) { + throw std::invalid_argument("model name=" + name + " is not running"); + } + { + std::unique_lock lk(mutex); + if (update_last_used) { + mapping[name].meta.last_used = ggml_time_ms(); + } + mapping[name].req_count++; + } + if (debug_fake_timing) { + // sleep after req_count++, so the model counts as busy while we wait here + std::this_thread::sleep_for(std::chrono::seconds(2)); + } + SRV_INF("proxying request to model %s on port %d\n", name.c_str(), meta->port); + std::string proxy_path = req.path; + if (!req.query_string.empty()) { + proxy_path += '?' + req.query_string; + } + auto proxy = std::make_unique( + method, + "http", + CHILD_ADDR, + meta->port, + proxy_path, + req.headers, + req.body, + req.files, + // a detached request belongs to a replay session + detached + ? std::function([]() { return false; }) + : req.should_stop, + base_params.timeout_read, + base_params.timeout_write + ); + + proxy->cleanup = [this, name]() { + bool went_idle = false; + { + std::unique_lock lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end() && it->second.req_count > 0) { + it->second.req_count--; + went_idle = it->second.req_count == 0; + } + } + if (went_idle) { + sched->on_model_idle(name); + } + }; + + return proxy; +} + +void server_models::handle_child_state(const std::string & name, const std::string & raw_input) { + server_state state; + json payload; + + try { + json data = json::parse(raw_input.substr(strlen(CMD_CHILD_TO_ROUTER_STATE))); + state = server_state_from_str(json_value(data, "state", std::string())); + payload = json_value(data, "payload", json{}); + } catch (const std::exception & e) { + SRV_ERR("failed to parse child state update for name=%s: %s\n", name.c_str(), e.what()); + return; + } + + switch (state) { + case SERVER_STATE_DOWNLOADING: + { + std::string result = json_value(payload, "result", std::string()); + std::string url = json_value(payload, "url", std::string()); + auto request_exit = [&]() { + std::lock_guard lk(mutex); + auto it = mapping.find(name); + if (it != mapping.end()) { + return it->second.subproc->request_exit(); + } + }; + if (result == "download_finished") { + update_download_progress(name, {}, true, true); + request_exit(); + } else if (result == "download_failed") { + update_download_progress(name, {}, true, false); + request_exit(); + } else if (!url.empty()) { + common_download_progress p; + p.url = url; + p.downloaded = json_value(payload, "downloaded", (size_t)0); + p.total = json_value(payload, "total", (size_t)0); + update_download_progress(name, p, false); + } + } break; + case SERVER_STATE_LOADING: + { + update_status(name, { + SERVER_MODEL_STATUS_LOADING, + 0, + nullptr, // no loaded_info yet + payload, + }); + } break; + case SERVER_STATE_READY: + { + update_status(name, { + SERVER_MODEL_STATUS_LOADED, + 0, + // note: payload can be empty if this is a wakeup from sleep + payload.size() > 0 ? payload : nullptr, + {}, // reset progress info + }); + } break; + case SERVER_STATE_SLEEPING: + { + update_status(name, { SERVER_MODEL_STATUS_SLEEPING }); + } break; + default: + // should never happen, but just in case + GGML_ASSERT(false && "unexpected state from child server"); + } +} + +// +// server_child +// + +bool server_child::is_child() { + const char * router_port = std::getenv("LLAMA_SERVER_ROUTER_PORT"); + return router_port != nullptr; +} + +server_child_mode server_child::get_mode() { + const char * mode = std::getenv("LLAMA_SERVER_CHILD_MODE"); + std::string mode_str(mode ? mode : ""); + if (mode_str == "download") { + return SERVER_CHILD_MODE_DOWNLOAD; + } else { + return SERVER_CHILD_MODE_NORMAL; + } +} + +struct server_download_state : public common_download_callback { + server_child * self; + std::function should_stop; + std::atomic last_progress_time{0}; // multiple files downloading in different threads + bool is_ok = false; + + server_download_state(server_child * s) : self(s) {} + + bool run(common_params & params) { + try { + common_models_handler handler = common_models_handler_init(params, LLAMA_EXAMPLE_SERVER); + common_models_handler_apply(handler, params, this); + is_ok = true; + } catch (const std::exception & e) { + auto model_name = params.model.get_name(); + SRV_ERR("download failed for model name=%s: %s\n", model_name.c_str(), e.what()); + is_ok = false; + } + return is_ok; + } + void on_progress(const common_download_progress & p) { + json data = { + {"url", p.url}, + {"downloaded", p.downloaded}, + {"total", p.total}, + }; + self->notify_to_router(server_state_to_str(SERVER_STATE_DOWNLOADING), data); + } + void on_start(const common_download_progress & p) override { + on_progress(p); + } + void on_update(const common_download_progress & p) override { + int64_t now = ggml_time_ms(); + // throttle progress updates to avoid flooding logs + if (now - last_progress_time.load(std::memory_order_relaxed) >= 100) { + on_progress(p); + last_progress_time.store(now, std::memory_order_relaxed); + } + } + void on_done(const common_download_progress & p, bool) override { + on_progress(p); + } + bool is_cancelled() const override { + return should_stop ? should_stop() : false; + } +}; + +int server_child::run_download(common_params & params) { + auto cancelled = std::make_shared>(false); + + // monitor stdin for cancellation command from the router + std::thread signal_thread = setup([cancelled](int) { + cancelled->store(true, std::memory_order_relaxed); + }); + + server_download_state dl(this); + dl.should_stop = [cancelled]() { + return cancelled->load(std::memory_order_relaxed); + }; + + bool ok = dl.run(params); + + notify_to_router(server_state_to_str(SERVER_STATE_DOWNLOADING), { + {"result", ok ? "download_finished" : "download_failed"}, + }); + + // router should send CMD_ROUTER_TO_CHILD_EXIT after receiving the result + if (signal_thread.joinable()) { + signal_thread.join(); + } + + SRV_INF("download completed %s\n", ok ? "successfully" : "with errors"); + return 0; +} + +std::thread server_child::setup(const std::function & shutdown_handler) { + // setup thread for monitoring stdin + return std::thread([shutdown_handler]() { + // wait for EOF on stdin + SRV_INF("%s", "child server monitoring thread started, waiting for EOF on stdin...\n"); + bool eof = false; + while (true) { + std::string line; + if (!std::getline(std::cin, line)) { + // EOF detected, that means the router server is unexpectedly exit or killed + eof = true; + break; + } + if (line.find(CMD_ROUTER_TO_CHILD_EXIT) != std::string::npos) { + SRV_INF("%s", "exit command received, exiting...\n"); + shutdown_handler(0); + break; + } + } + if (eof) { + SRV_INF("%s", "EOF on stdin detected, forcing shutdown...\n"); + exit(1); + } + }); +} + +void server_child::notify_to_router(const std::string & state, const json & payload) { + json data = { + {"state", state}, + {"payload", payload}, + }; + std::lock_guard lk(mtx_stdout); + common_log_pause(common_log_main()); + fflush(stdout); + fprintf(stdout, "%s%s\n", CMD_CHILD_TO_ROUTER_STATE, safe_json_to_str(data).c_str()); + fflush(stdout); + common_log_resume(common_log_main()); +} + + +// +// server_models_routes +// + +// RAII wrapper similar to server_response_reader, but doesn't use server_queue +static std::atomic sse_client_id_counter = 0; +struct server_models_sse_client { + server_response & queue_results; + int client_id; + server_models_sse_client(server_response & q) + : queue_results(q), client_id(sse_client_id_counter.fetch_add(1, std::memory_order_relaxed)) { + SRV_DBG("new SSE client connected, assigned client_id=%d\n", client_id); + queue_results.add_waiting_task_id(client_id); + } + ~server_models_sse_client() { + SRV_DBG("SSE client disconnected, removing client_id=%d\n", client_id); + queue_results.remove_waiting_task_id(client_id); + } + + // return nullptr if should_stop() is true before receiving a result + // note: if one error is received, it will stop further processing and return error result + server_task_result_ptr next(const std::function & should_stop) { + while (true) { + static const int http_polling_seconds = 1; // check should_stop every 1 second + server_task_result_ptr result = queue_results.recv_with_timeout({client_id}, http_polling_seconds); + if (result == nullptr) { + // timeout, check stop condition + if (should_stop()) { + return nullptr; + } + // continue waiting otherwise + } else { + SRV_DBG("recv result for client_id=%d: %s\n", client_id, safe_json_to_str(result->to_json()).c_str()); + return result; + } + } + // should not reach here + } +}; + +static void res_ok(std::unique_ptr & res, const json & response_data) { + res->status = 200; + res->data = safe_json_to_str(response_data); +} + +static void res_err(std::unique_ptr & res, const json & error_data) { + res->status = json_value(error_data, "code", 500); + res->data = safe_json_to_str({{ "error", error_data }}); +} + +static bool router_validate_model(std::string & name, server_models & models, bool models_autoload, std::unique_ptr & res) { + if (name.empty()) { + res_err(res, format_error_response("model name is missing from the request", ERROR_TYPE_INVALID_REQUEST)); + return false; + } + auto meta = models.get_meta(name); + if (!meta.has_value()) { + res_err(res, format_error_response(string_format("model '%s' not found", name.c_str()), ERROR_TYPE_INVALID_REQUEST)); + return false; + } + // resolve alias to canonical model name + name = meta->name; + if (!models_autoload && !meta->is_running()) { + res_err(res, format_error_response("model is not loaded", ERROR_TYPE_INVALID_REQUEST)); + return false; + } + return true; +} + +static bool is_autoload(const common_params & params, const server_http_req & req) { + std::string autoload = req.get_param("autoload"); + if (autoload.empty()) { + return params.models_autoload; + } else { + return autoload == "true" || autoload == "1"; + } +} + +// percent encode one query or path component, covers reserved chars without pulling in +// httplib::detail. used by the stream routes to forward conversation_id to children safely +static std::string encode_qs(const std::string & in) { + std::string out; + out.reserve(in.size() * 3); + for (unsigned char c : in) { + bool safe = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') + || c == '-' || c == '_' || c == '.' || c == '~'; + if (safe) { + out.push_back(char(c)); + } else { + char buf[4]; + std::snprintf(buf, sizeof(buf), "%%%02X", c); + out.append(buf, 3); + } + } + return out; +} + +// resolve the child that owns a conversation's stream session via the conv_id -> model map +// populated when the POST was routed. single map lookup then a meta lookup, no polling, no +// parsing of the conv id. returns nullopt when nothing maps, the caller answers not found and +// the client recovers +static std::optional resolve_child_for_conv( + server_models & models, const std::string & conversation_id) { + if (conversation_id.empty()) { + return std::nullopt; + } + auto tracked = models.conv_models.lookup(conversation_id); + if (!tracked.has_value()) { + return std::nullopt; + } + auto meta = models.get_meta(*tracked); + if (meta.has_value() && meta->is_ready()) { + return meta; + } + return std::nullopt; +} + +void server_models_routes::init_routes() { + if (!common_subproc::is_supported()) { + throw std::runtime_error("subprocess is not enabled on this build"); + } + + this->get_router_props = [this](const server_http_req & req) { + std::string name = req.get_param("model"); + if (name.empty()) { + // main instance + auto res = std::make_unique(); + res_ok(res, { + // TODO: add support for this on web UI + {"role", "router"}, + {"max_instances", params.models_max}, + {"models_autoload", params.models_autoload}, + // this is a dummy response to make sure the UI doesn't break + {"model_alias", "llama-server"}, + {"model_path", "none"}, + {"default_generation_settings", { + {"params", json{}}, + {"n_ctx", 0}, + }}, + // New key + {"ui_settings", ui_settings}, + {"build_info", std::string(llama_build_info())}, + {"cors_proxy_enabled", params.ui_mcp_proxy}, + }); + return res; + } + return proxy_get(req); + }; + + this->proxy_get = [this](const server_http_req & req) { + std::string method = "GET"; + std::string name = req.get_param("model"); + bool autoload = is_autoload(params, req); + auto error_res = std::make_unique(); + if (!router_validate_model(name, models, autoload, error_res)) { + return error_res; + } + if (autoload) { + models.ensure_model_ready(name, req.should_stop); + } + return models.proxy_request(req, method, name, false); + }; + + this->proxy_post = [this](const server_http_req & req) { + std::string method = "POST"; + json body = json::parse(req.body); + std::string name = json_value(body, "model", std::string()); + bool autoload = is_autoload(params, req); + auto error_res = std::make_unique(); + if (!router_validate_model(name, models, autoload, error_res)) { + return error_res; + } + // remember which child serves this conversation so the stream routes can route straight + // to it without polling, keyed on the exact conv id from the header. registered before + // the load wait so a stop issued while the model loads can erase the entry and cancel + // this request instead of leaving an orphan generation + std::string conv_id = server_stream_conv_id_from_headers(req.headers); + uint64_t ticket = models.conv_models.remember(conv_id, name); + // a dead socket must not cancel a session request, only a stop does (checked right below) + auto should_stop = ticket == 0 ? req.should_stop : nullptr; + bool waited = autoload && models.ensure_model_ready(name, should_stop); + if (ticket != 0 && !models.conv_models.alive(conv_id, ticket)) { + SRV_INF("request for conv_id=%s cancelled while model name=%s was loading\n", + conv_id.c_str(), name.c_str()); + res_err(error_res, format_error_response( + "request cancelled by a stop while the model was loading", ERROR_TYPE_INVALID_REQUEST)); + return error_res; + } + // a session request that waited for a load detaches from the client socket: the + // client may have dropped during the wait (page reload) and the session buffer must + // still receive the generation for a later resume + return models.proxy_request(req, method, name, true, waited && ticket != 0); // update last usage for POST request only + }; + + this->post_router_models_load = [this](const server_http_req & req) { + auto res = std::make_unique(); + json body = json::parse(req.body); + std::string name = json_value(body, "model", std::string()); + auto meta = models.get_meta(name); + if (!meta.has_value()) { + res_err(res, format_error_response("model is not found", ERROR_TYPE_NOT_FOUND)); + return res; + } + if (meta->is_running()) { + res_err(res, format_error_response("model is already running", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + models.load(meta->name); + res_ok(res, {{"success", true}}); + return res; + }; + + this->get_router_models = [this](const server_http_req & req) { + bool reload = !req.get_param("reload", "").empty(); + if (reload) { + models.load_models(); + } + auto res = std::make_unique(); + json models_json = json::array(); + auto all_models = models.get_all_meta(); + std::time_t t = std::time(0); + for (const auto & meta : all_models) { + json status { + {"value", server_model_status_to_string(meta.status)}, + {"args", meta.args}, + }; + if (!meta.preset.name.empty()) { + common_preset preset_copy = meta.preset; + unset_reserved_args(preset_copy, false); + preset_copy.unset_option("LLAMA_ARG_HOST"); + preset_copy.unset_option("LLAMA_ARG_PORT"); + preset_copy.unset_option("LLAMA_ARG_ALIAS"); + preset_copy.unset_option("LLAMA_ARG_TAGS"); + status["preset"] = preset_copy.to_ini(); + } + if (meta.is_failed()) { + status["exit_code"] = meta.exit_code; + status["failed"] = true; + } + + // pi coding agent multimodal compatibility + json input_modalities = json::array({"text"}); + if (meta.multimodal.inp_vision) { + input_modalities.push_back("image"); + } + if (meta.multimodal.inp_audio) { + input_modalities.push_back("audio"); + } + json architecture { + {"input_modalities", input_modalities}, + {"output_modalities", json::array({"text"})}, + }; + + json model_info = json { + {"id", meta.name}, + {"aliases", meta.aliases}, + {"tags", meta.tags}, + {"object", "model"}, // for OAI-compat + {"owned_by", "llamacpp"}, // for OAI-compat + {"created", t}, // for OAI-compat + {"status", status}, + {"architecture", architecture}, + {"source", server_model_source_to_string(meta.source)}, + {"can_remove", meta.source == SERVER_MODEL_SOURCE_CACHE}, + // {"need_download", meta.need_download}, + // TODO: add other fields, may require reading GGUF metadata + }; + + // merge with loaded_info from the child process if available + if (meta.is_running()) { + for (auto it = meta.loaded_info.begin(); it != meta.loaded_info.end(); ++it) { + if (!model_info.contains(it.key())) { + model_info[it.key()] = it.value(); + } + } + } + models_json.push_back(model_info); + } + res_ok(res, { + {"data", models_json}, + {"object", "list"}, + }); + return res; + }; + + this->post_router_models_unload = [this](const server_http_req & req) { + auto res = std::make_unique(); + json body = json::parse(req.body); + std::string name = json_value(body, "model", std::string()); + auto model = models.get_meta(name); + if (!model.has_value()) { + res_err(res, format_error_response("model is not found", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + if (!model->is_running() && model->status != SERVER_MODEL_STATUS_DOWNLOADING) { + res_err(res, format_error_response("model is not running", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + models.unload(model->name); + res_ok(res, {{"success", true}}); + return res; + }; + + this->get_router_models_sse = [this](const server_http_req & req) { + auto res = std::make_unique(); + res->status = 200; + res->content_type = "text/event-stream"; + auto sse_client = std::make_shared(models.sse); + res->next = [this, sse_client, &req](std::string & output) -> bool { + auto result = sse_client->next([&]() { + return stopping.load(std::memory_order_relaxed) || req.should_stop(); + }); + if (result == nullptr) { + return false; // client disconnected or should_stop + } + output = "data: " + safe_json_to_str(result->to_json()) + "\n\n"; + return true; // listen for the next event + }; + return res; + }; + + this->post_router_models = [this](const server_http_req & req) { + auto res = std::make_unique(); + + json body = json::parse(req.body); + std::string name = json_value(body, "model", std::string()); + if (name.empty()) { + throw std::invalid_argument("model must be a non-empty string"); + } + + common_params p; + p.model.hf_repo = name; + p.hf_token = params.hf_token; + + // validate by fetching metadata + bool ok = false; + try { + common_models_handler_init(p, LLAMA_EXAMPLE_SERVER); + ok = true; + } catch (...) { + SRV_ERR("unknown error while validating model '%s'\n", name.c_str()); + // other exceptions will be handled by the outer ex_wrapper() + throw; + } + + if (!ok) { + throw std::invalid_argument("model validation failed, unable to download"); + } + + // reject if model already exists + if (models.has_model(name)) { + throw std::invalid_argument("model '" + name + "' already exists"); + } + + // then, proceed with the actual download + SRV_INF("starting download for model '%s'\n", name.c_str()); + { + server_models::load_options load_opts; + load_opts.mode = SERVER_CHILD_MODE_DOWNLOAD; + load_opts.custom_meta = server_model_meta{}; + load_opts.custom_meta->source = SERVER_MODEL_SOURCE_CACHE; + load_opts.custom_meta->name = name; + models.load(name, load_opts); + } + + res_ok(res, {{"success", true}}); + return res; + }; + + this->del_router_models = [this](const server_http_req & req) { + auto res = std::make_unique(); + + std::string name = req.get_param("model"); + if (name.empty()) { + throw std::invalid_argument("model must be a non-empty string"); + } + + models.remove(name); // throws on error + + res_ok(res, {{"success", true}}); + return res; + }; + + this->router_stream_get = [this](const server_http_req & req) { + // GET /v1/stream?conv_id=&from=N. resolve the owning child from the conv_id -> model + // map, 404 when nothing maps + auto res = std::make_unique(); + std::string conv_id = req.get_param("conv_id"); + if (conv_id.empty()) { + res_err(res, format_error_response("Missing conversation id in path", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + std::optional owner = resolve_child_for_conv(models, conv_id); + if (!owner.has_value()) { + // a registered conv whose model is still loading earns a retry: the session appears + // once the load ends and the pending request reaches the child + auto tracked = models.conv_models.lookup(conv_id); + auto meta = tracked.has_value() ? models.get_meta(*tracked) : std::nullopt; + bool transient = meta.has_value() && (meta->status == SERVER_MODEL_STATUS_LOADING || + meta->status == SERVER_MODEL_STATUS_DOWNLOADING || + meta->status == SERVER_MODEL_STATUS_DOWNLOADED); + if (transient) { + res_err(res, format_error_response("Stream owner model is loading, retry later", ERROR_TYPE_UNAVAILABLE)); + } else { + res_err(res, format_error_response("Stream not found or expired", ERROR_TYPE_NOT_FOUND)); + } + return res; + } + std::string from = req.get_param("from"); + std::string child_path = "/v1/stream?conv_id=" + encode_qs(conv_id); + if (!from.empty()) { + child_path += "&from=" + from; + } + SRV_TRC("proxying stream resume to model %s on port %d, path=%s\n", + owner->name.c_str(), owner->port, child_path.c_str()); + auto proxy = std::make_unique( + "GET", + "http", + CHILD_ADDR, + owner->port, + child_path, + req.headers, + req.body, + req.files, + req.should_stop, + params.timeout_read, + params.timeout_write); + return std::unique_ptr(std::move(proxy)); + }; + + this->router_streams_lookup = [this](const server_http_req & req) { + // POST /v1/streams/lookup. resolve each requested conv id to its owning child via the + // map, group the ids per child, and query only the children that actually own some of + // them instead of fanning out to every ready child. a child only answers for the ids + // it owns, never lists anything else + auto res = std::make_unique(); + std::vector requested; + try { + json body = json::parse(req.body); + if (body.contains("conversation_ids") && body["conversation_ids"].is_array()) { + for (const auto & v : body["conversation_ids"]) { + if (v.is_string() && !v.get().empty()) { + requested.push_back(v.get()); + } + } + } + } catch (const std::exception &) { + res_ok(res, json::array()); + return res; + } + + // group requested ids by the child port that owns them, drop ids that map to nothing + std::unordered_map per_child; + for (const auto & cid : requested) { + auto owner = resolve_child_for_conv(models, cid); + if (!owner.has_value()) { + continue; + } + per_child[owner->port].push_back(cid); + } + + json aggregated = json::array(); + for (auto & [port, ids] : per_child) { + json child_body = {{"conversation_ids", ids}}; + httplib::Client cli(CHILD_ADDR, port); + cli.set_connection_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + cli.set_read_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + cli.set_write_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + auto resp = cli.Post("/v1/streams/lookup", child_body.dump(), "application/json"); + if (!resp || resp->status != 200) { + continue; + } + try { + json child_arr = json::parse(resp->body); + if (!child_arr.is_array()) { + continue; + } + for (auto & entry : child_arr) { + if (entry.is_object()) { + aggregated.push_back(entry); + } + } + } catch (const std::exception &) { + continue; + } + } + res_ok(res, aggregated); + return res; + }; + + this->router_stream_delete = [this](const server_http_req & req) { + // DELETE /v1/stream?conv_id=. resolve the owning child via the map and forward only to + // it, evict_and_cancel is idempotent on the child + auto res = std::make_unique(); + std::string conv_id = req.get_param("conv_id"); + if (conv_id.empty()) { + res_err(res, format_error_response("Missing conversation id in path", ERROR_TYPE_INVALID_REQUEST)); + return res; + } + std::string child_path = "/v1/stream?conv_id=" + encode_qs(conv_id); + auto owner = resolve_child_for_conv(models, conv_id); + if (owner.has_value()) { + httplib::Client cli(CHILD_ADDR, owner->port); + cli.set_connection_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + cli.set_read_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + cli.set_write_timeout(0, STREAM_LOOKUP_TIMEOUT_MS * 1000); + auto resp = cli.Delete(child_path.c_str()); + (void) resp; // the child logs its own miss when the session is unknown there + } else if (auto tracked = models.conv_models.lookup(conv_id); tracked.has_value()) { + // the entry exists but its model is still loading: the forget below erases it, + // which cancels the request parked in proxy_post before the generation starts + SRV_INF("router stop for conv_id=%s while model name=%s is loading, cancelling the pending request\n", + conv_id.c_str(), tracked->c_str()); + } else { + SRV_WRN("router stop for unknown conv_id=%s, no owning child in the conv map\n", + conv_id.c_str()); + } + // drop the tracking entry, the session is being torn down + models.conv_models.forget(conv_id); + res->status = 204; + res->content_type = "application/json"; + return res; + }; +} + + + +// +// server_http_proxy +// + +static std::string to_lower_copy(const std::string & value) { + std::string lowered(value.size(), '\0'); + std::transform(value.begin(), value.end(), lowered.begin(), [](unsigned char c) { return std::tolower(c); }); + return lowered; +} + +static bool should_strip_proxy_header(const std::string & header_name) { + // Headers that get duplicated when router forwards child responses + if (header_name == "server" || + header_name == "transfer-encoding" || + header_name == "content-length" || // quick fix for https://github.com/ggml-org/llama.cpp/issues/17710 + header_name == "keep-alive") { + return true; + } + + // Router injects CORS, child also sends them: duplicate + if (header_name.rfind("access-control-", 0) == 0) { + return true; + } + + return false; +} + +static std::string generate_multipart_boundary() { + thread_local std::mt19937 gen(std::random_device{}()); + static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz"; + std::uniform_int_distribution<> dis(0, sizeof(chars) - 2); + std::string boundary = "----llama-cpp-proxy-"; + for (int i = 0; i < 16; i++) { + boundary += chars[dis(gen)]; + } + return boundary; +} + +static std::string build_multipart_body( + const json & form_fields, + const std::map & files, + const std::string & boundary) { + static auto sanitize_field = [](const std::string & text) { + std::string result; + result.reserve(text.size()); + for (char c : text) { + if (c != '\n' && c != '\r' && c != '"') { + result += c; + } + } + return result; + }; + + std::ostringstream body; + + for (const auto & [key, value] : form_fields.items()) { + if (value.is_array()) { + for (const auto & item : value) { + body << "--" << boundary << "\r\n"; + body << "Content-Disposition: form-data; name=\"" << sanitize_field(key) << "\"\r\n"; + body << "\r\n"; + if (!item.is_string()) { + throw std::invalid_argument("expected string"); + } + body << item.get() << "\r\n"; + } + } else { + body << "--" << boundary << "\r\n"; + body << "Content-Disposition: form-data; name=\"" << sanitize_field(key) << "\"\r\n"; + body << "\r\n"; + if (!value.is_string()) { + throw std::invalid_argument("expected string"); + } + body << value.get() << "\r\n"; + } + } + + for (const auto & [key, file] : files) { + body << "--" << boundary << "\r\n"; + body << "Content-Disposition: form-data; name=\"" << sanitize_field(key) << "\""; + if (!file.filename.empty()) { + body << "; filename=\"" << sanitize_field(file.filename) << "\""; + } + body << "\r\n"; + if (!file.content_type.empty()) { + body << "Content-Type: " << sanitize_field(file.content_type) << "\r\n"; + } else { + body << "Content-Type: application/octet-stream\r\n"; + } + body << "\r\n"; + body.write(reinterpret_cast(file.data.data()), file.data.size()); + body << "\r\n"; + } + + body << "--" << boundary << "--\r\n"; + return body.str(); +} + +server_http_proxy::server_http_proxy( + const std::string & method, + const std::string & scheme, + const std::string & host, + int port, + const std::string & path, + const std::map & headers, + const std::string & body, + const std::map & files, + const std::function should_stop, + int32_t timeout_read, + int32_t timeout_write + ) { + // shared between reader and writer threads + auto cli = std::make_shared(host, port); + auto pipe = std::make_shared>(); + + if (scheme == "https") { +#ifdef CPPHTTPLIB_OPENSSL_SUPPORT + cli.reset(new httplib::SSLClient(host, port)); +#else + throw std::runtime_error("HTTPS requested but CPPHTTPLIB_OPENSSL_SUPPORT is not defined"); +#endif + } + + // setup Client + cli->set_follow_location(true); + cli->set_connection_timeout(timeout_read, 0); // use --timeout value instead of hardcoded 5 s + cli->set_write_timeout(timeout_read, 0); // reversed for cli (client) vs srv (server) + cli->set_read_timeout(timeout_write, 0); + this->status = 500; // to be overwritten upon response + this->cleanup_pipes = [pipe]() { + pipe->close_read(); + pipe->close_write(); + }; + + // wire up the receive end of the pipe + this->next = [pipe, should_stop](std::string & out) -> bool { + msg_t msg; + bool has_next = pipe->read(msg, should_stop); + if (!msg.data.empty()) { + out = std::move(msg.data); + } + return has_next; // false if EOF or pipe broken + }; + + // build the header message forwarded to the reader thread, stripping internal proxy headers + auto make_header_msg = [](const httplib::Response & response) { + msg_t msg; + msg.status = response.status; + for (const auto & [key, value] : response.headers) { + const auto lowered = to_lower_copy(key); + if (should_strip_proxy_header(lowered)) { + continue; + } + if (lowered == "content-type") { + msg.content_type = value; + continue; + } + msg.headers[key] = value; + } + return msg; + }; + + // true once response_handler has already forwarded the headers + auto headers_sent = std::make_shared>(false); + + // wire up the HTTP client + // note: do NOT capture `this` pointer, as it may be destroyed before the thread ends + httplib::ResponseHandler response_handler = [pipe, headers_sent, make_header_msg](const httplib::Response & response) { + headers_sent->store(true); + return pipe->write(make_header_msg(response)); // send headers first + }; + httplib::ContentReceiverWithProgress content_receiver = [pipe](const char * data, size_t data_length, size_t, size_t) { + // send data chunks + // returns false if pipe is closed / broken (signal to stop receiving) + return pipe->write({{}, 0, std::string(data, data_length), ""}); + }; + + // when files are present, the body was converted from multipart form data to JSON + // we need to reconstruct the multipart body for the downstream server + std::string effective_body = body; + std::string override_content_type; + bool has_files = !files.empty(); + + if (has_files) { + json form_fields = json::parse(body, nullptr, false); + if (!form_fields.is_discarded()) { + auto boundary = generate_multipart_boundary(); + effective_body = build_multipart_body(form_fields, files, boundary); + override_content_type = "multipart/form-data; boundary=" + boundary; + } else { + throw std::runtime_error("failed to parse multipart form fields JSON"); + } + } + + // prepare the request to destination server + httplib::Request req; + { + req.method = method; + req.path = path; + for (const auto & [key, value] : headers) { + const auto lowered = to_lower_copy(key); + if (lowered == "accept-encoding") { + // disable Accept-Encoding to avoid compressed responses + continue; + } + if (lowered == "transfer-encoding") { + // the body is already decoded + continue; + } + if (lowered == "content-length") { + // let httplib calculate Content-Length from the actual body + continue; + } + if (lowered == "content-type") { + if (has_files) { + // we set our own Content-Type with the new boundary + continue; + } + // when no files but the original request was multipart, + // the body is now JSON, so correct the Content-Type + if (value.find("multipart/form-data") != std::string::npos) { + override_content_type = "application/json; charset=utf-8"; + continue; + } + } + if (lowered == "host") { + bool is_default_port = (scheme == "https" && port == 443) || (scheme == "http" && port == 80); + const std::string url_host = common_http_format_host(host); + req.set_header(key, is_default_port ? url_host : url_host + ":" + std::to_string(port)); + } else { + req.set_header(key, value); + } + } + req.body = effective_body; + if (!override_content_type.empty()) { + req.set_header("Content-Type", override_content_type); + } + req.response_handler = response_handler; + req.content_receiver = content_receiver; + } + + // start the proxy thread + SRV_DBG("start proxy thread %s %s\n", req.method.c_str(), req.path.c_str()); + this->thread = std::thread([cli, pipe, req, headers_sent, make_header_msg]() { + auto result = cli->send(std::move(req)); + if (result.error() != httplib::Error::Success) { + auto err_str = httplib::to_string(result.error()); + SRV_ERR("http client error: %s\n", err_str.c_str()); + pipe->write({{}, 500, "", ""}); // header + pipe->write({{}, 0, "proxy error: " + err_str, ""}); // body + } else if (!headers_sent->load()) { + // httplib skips response_handler for bodyless statuses like 204, send headers here instead + pipe->write(make_header_msg(*result)); + } + pipe->close_write(); // signal EOF to reader + SRV_DBG("%s", "client request thread ended\n"); + }); + this->thread.detach(); + + // wait for the first chunk (headers) + { + msg_t header; + if (pipe->read(header, should_stop)) { + SRV_DBG("%s", "received response headers\n"); + this->status = header.status; + this->headers = std::move(header.headers); + if (!header.content_type.empty()) { + this->content_type = std::move(header.content_type); + } + } else { + SRV_DBG("%s", "no response headers received (request cancelled?)\n"); + } + } +} diff --git a/tools/server/server-models.h b/tools/server/server-models.h new file mode 100644 index 0000000000000000000000000000000000000000..615acb577bd1433b8cbdbc093da04e1e48649bb1 --- /dev/null +++ b/tools/server/server-models.h @@ -0,0 +1,390 @@ +#pragma once + +#include "common.h" +#include "download.h" +#include "preset.h" +#include "server-common.h" +#include "server-http.h" +#include "server-queue.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * state diagram: + * + * DOWNLOADING ──► DOWNLOADED ──► (replaced by new instance) + * + * UNLOADED ──► LOADING ──► LOADED ◄──── SLEEPING + * ▲ │ │ ▲ + * └───failed───┘ │ │ + * ▲ └──sleeping─────┘ + * └────────unloaded─────────┘ + */ +enum server_model_status { + // TODO: also add downloading state when the logic is added + SERVER_MODEL_STATUS_DOWNLOADING, + SERVER_MODEL_STATUS_DOWNLOADED, + SERVER_MODEL_STATUS_UNLOADED, + SERVER_MODEL_STATUS_LOADING, + SERVER_MODEL_STATUS_LOADED, + SERVER_MODEL_STATUS_SLEEPING +}; + +enum server_model_source { + SERVER_MODEL_SOURCE_PRESET, + SERVER_MODEL_SOURCE_MODELS_DIR, + SERVER_MODEL_SOURCE_CACHE, +}; + +enum server_child_mode { + SERVER_CHILD_MODE_NORMAL, // load the model and run normally + SERVER_CHILD_MODE_DOWNLOAD, // download the model and exit +}; + +static std::string server_model_status_to_string(server_model_status status) { + switch (status) { + case SERVER_MODEL_STATUS_DOWNLOADING: return "downloading"; + case SERVER_MODEL_STATUS_DOWNLOADED: return "downloaded"; + case SERVER_MODEL_STATUS_UNLOADED: return "unloaded"; + case SERVER_MODEL_STATUS_LOADING: return "loading"; + case SERVER_MODEL_STATUS_LOADED: return "loaded"; + case SERVER_MODEL_STATUS_SLEEPING: return "sleeping"; + default: return "unknown"; + } +} + +static std::string server_model_source_to_string(server_model_source source) { + switch (source) { + case SERVER_MODEL_SOURCE_PRESET: return "preset"; + case SERVER_MODEL_SOURCE_MODELS_DIR: return "models_dir"; + case SERVER_MODEL_SOURCE_CACHE: return "cache"; + default: return "unknown"; + } +} + +struct server_model_meta { + server_model_source source = SERVER_MODEL_SOURCE_CACHE; + common_preset preset; + std::string name; + std::set aliases; // additional names that resolve to this model + std::set tags; // informational tags, not used for routing + int port = 0; + server_model_status status = SERVER_MODEL_STATUS_UNLOADED; + int64_t last_used = 0; // for LRU unloading + std::vector args; // args passed to the model instance, will be populated by render_args() + json loaded_info; // info to be reflected via /v1/models endpoint ; if in DOWNLOADING state, it should contain download progress info + json progress; // reflect load or download progress info, if any + int exit_code = 0; // exit code of the model instance process (only valid if status == FAILED) + int stop_timeout = 0; // seconds to wait before force-killing the model instance during shutdown + mtmd_caps multimodal; // multimodal capabilities + + bool is_ready() const { + return status == SERVER_MODEL_STATUS_LOADED; + } + + bool is_running() const { + return status == SERVER_MODEL_STATUS_LOADED || status == SERVER_MODEL_STATUS_LOADING || status == SERVER_MODEL_STATUS_SLEEPING; + } + + bool is_ready_or_sleep() const { + return status == SERVER_MODEL_STATUS_LOADED || status == SERVER_MODEL_STATUS_SLEEPING; + } + + bool is_failed() const { + return status == SERVER_MODEL_STATUS_UNLOADED && exit_code != 0; + } + + void update_args(common_preset_context & ctx_presets, std::string bin_path); + void update_caps(); +}; + +struct server_models_routes; +struct server_subproc; // defined in server-models.cpp +struct server_lru_sched; // defined in server-models.cpp + +struct server_models { + friend struct server_models_routes; + friend struct server_lru_sched; + +private: + struct instance_t { + std::shared_ptr subproc; // shared between main thread and monitoring thread + std::thread th; + server_model_meta meta; + int req_count = 0; // number of active proxy requests + }; + + std::mutex mutex; + std::condition_variable cv; + std::map mapping; + + // for stopping models + std::condition_variable cv_stop; + std::set stopping_models; + + // set to true while load_models() is executing a reload; load() will wait until clear + bool is_reloading = false; + + // if true, the next get_meta() will trigger a reload of model list + bool need_reload = false; + + // conv_id -> model name that currently serves its stream session, lets the resumable stream + // routes go straight to the owning child instead of polling every one. populated when + // proxy_request forwards a POST carrying an X-Conversation-Id. best effort: a stale entry just + // makes the child answer not found and the client recovers. owns its lock, one mutex per struct + struct conv_model_tracker { + // returns the ticket of this registration, 0 when nothing was registered. erasing or + // replacing the entry invalidates the ticket, which is how a stop cancels a request + // parked in the model load wait + uint64_t remember(const std::string & conv_id, const std::string & model) { + if (conv_id.empty() || model.empty()) { + return 0; + } + std::lock_guard lock(mu); + uint64_t ticket = next_ticket++; + map[conv_id] = { model, ticket }; + return ticket; + } + + // false means a stop erased the entry or a newer request replaced it + bool alive(const std::string & conv_id, uint64_t ticket) { + std::lock_guard lock(mu); + auto it = map.find(conv_id); + return it != map.end() && it->second.ticket == ticket; + } + + std::optional lookup(const std::string & conv_id) { + if (conv_id.empty()) { + return std::nullopt; + } + std::lock_guard lock(mu); + auto it = map.find(conv_id); + if (it == map.end()) { + return std::nullopt; + } + return it->second.model; + } + + void forget(const std::string & conv_id) { + if (conv_id.empty()) { + return; + } + std::lock_guard lock(mu); + map.erase(conv_id); + } + + private: + struct entry_t { + std::string model; + uint64_t ticket; + }; + std::mutex mu; + uint64_t next_ticket = 1; + std::unordered_map map; + }; + + common_preset_context ctx_preset; + + common_params base_params; + std::string bin_path; + std::vector base_env; + common_preset base_preset; // base preset from llama-server CLI args + + // queue of requests waiting for a models_max slot + std::unique_ptr sched; + + // if true, add some delay to simulate works (useful for testing) + bool debug_fake_timing = false; + + void update_meta(const std::string & name, const server_model_meta & meta); + + // unload least recently used models if the limit is reached + void unload_lru(); + + // not thread-safe, caller must hold mutex + void add_model(server_model_meta && meta); + + // notify SSE clients + void notify_sse(const std::string & event, const std::string & model_id, const json & data = nullptr); + +public: + // conv_id -> model tracker for the resumable stream routes, owns its lock + conv_model_tracker conv_models; + + server_models(const common_params & params, int argc, char ** argv); + ~server_models(); + + server_response sse; // for real-time updates via SSE endpoint + + // (re-)load the list of models from various sources and prepare the metadata mapping + // - if this is called the first time, simply populate the metadata + // - if this is called subsequently (e.g. when refreshing from disk): + // - if a model is running but updated or removed from the source, it will be unloaded + // - if a model is not running, it will be added or updated according to the source + void load_models(); + + // check if a model instance exists (thread-safe) + bool has_model(const std::string & name); + + // return a copy of model metadata (thread-safe) + std::optional get_meta(const std::string & name); + + // return a copy of all model metadata (thread-safe) + std::vector get_all_meta(); + + struct load_options { + server_child_mode mode = SERVER_CHILD_MODE_NORMAL; + // used for spawning a downloading child process + std::optional custom_meta = std::nullopt; + }; + + // load and unload model instances + // these functions are thread-safe + void load(const std::string & name); + void load(const std::string & name, const load_options & opts); + void unload(const std::string & name); + void unload_all(); + + struct update_status_args { + server_model_status status; + int exit_code = 0; // only valid if status == UNLOADED + json loaded_info = nullptr; + json progress = nullptr; + }; + // update the status of a model instance (thread-safe) + // also send SSE notification to /models/sse endpoint + void update_status(const std::string & name, const update_status_args & args); + void update_download_progress(const std::string & name, const common_download_progress & progress, bool done, bool ok = true); + + // remove a cache model from disk and update the list (thread-safe) + // note: only cache models can be removed; returns false if the model doesn't exist or is not a cache model + bool remove(const std::string & name); + + // wait until the model instance is fully loaded (thread-safe) + // note: predicate is called while holding the lock + // return when the model no longer in "loading" state + void wait(const std::string & name, std::function predicate); + void wait(std::unique_lock & lk, const std::string & name, std::function predicate); + + // ensure the model is in ready state (thread-safe) + // return false if model is ready + // otherwise, load the model and blocking wait until it's ready, then return true (meta may need to be refreshed) + // if models_max is reached, the request waits in a queue until a slot frees up + // throws if the load fails, or if should_stop fires while waiting + bool ensure_model_ready(const std::string & name, const std::function & should_stop = nullptr); + + // proxy an HTTP request to the model instance + server_http_res_ptr proxy_request(const server_http_req & req, const std::string & method, const std::string & name, bool update_last_used, bool detached = false); + + // handle message sent from server_child::notify_to_router() + // raw input must starts with CMD_CHILD_TO_ROUTER_STATE, followed by a JSON string + // this function is not thread-safe, must be called from instance's monitoring thread + // payload per state: + // state = loading -> payload = {} (TODO: add progress info) + // state = ready -> payload = model_info (json), or {} if wakeup from sleeping + // state = sleeping -> payload = {} + void handle_child_state(const std::string & name, const std::string & raw_input); +}; + +struct server_child { + // serializes the notify_to_router writes + std::mutex mtx_stdout; + std::atomic is_finished_downloading = false; // set by run_download + + // return true if the current process is a child server instance + bool is_child(); + server_child_mode get_mode(); + int run_download(common_params & params); + + // register the shutdown_handler to be called by the router + // return the monitoring thread (to be joined by the caller) + std::thread setup(const std::function & shutdown_handler); + + // notify router server for status changes (e.g. loading, downloading, sleeping, etc.) + // message will be handled by server_models::handle_child_state() on the router side + void notify_to_router(const std::string & state_name, const json & payload); +}; + +struct server_models_routes { + common_params params; + json ui_settings = json::object(); // Primary: new name + std::atomic stopping = false; // for graceful disconnecting SSE clients during shutdown + server_models models; + server_models_routes(const common_params & params, int argc, char ** argv) + : params(params), models(params, argc, argv) { + const std::string & cfg = this->params.ui_config_json; + if (!cfg.empty()) { + try { + json json_settings = json::parse(cfg); + ui_settings = json_settings; + } catch (const std::exception & e) { + LOG_ERR("%s: failed to parse UI config: %s\n", __func__, e.what()); + throw; + } + } + init_routes(); + } + + void init_routes(); + // handlers using lambda function, so that they can capture `this` without `std::bind` + server_http_context::handler_t get_router_props; + server_http_context::handler_t proxy_get; + server_http_context::handler_t proxy_post; + server_http_context::handler_t get_router_models; + server_http_context::handler_t post_router_models_load; + server_http_context::handler_t post_router_models_unload; + // management API + server_http_context::handler_t get_router_models_sse; + server_http_context::handler_t post_router_models; + server_http_context::handler_t del_router_models; + + // router side handlers for the resumable streaming routes. each resolves the child that owns + // a conversation through the conv_id -> model map, no probing or fan out + server_http_context::handler_t router_stream_get; + server_http_context::handler_t router_streams_lookup; + server_http_context::handler_t router_stream_delete; +}; + +/** + * A simple HTTP proxy that forwards requests to another server + * and relays the responses back. + */ +struct server_http_proxy : server_http_res { + std::function cleanup = nullptr; + server_http_proxy(const std::string & method, + const std::string & scheme, + const std::string & host, + int port, + const std::string & path, + const std::map & headers, + const std::string & body, + const std::map & files, + const std::function should_stop, + int32_t timeout_read, + int32_t timeout_write + ); + ~server_http_proxy() { + if (cleanup_pipes) { + cleanup_pipes(); + } + if (cleanup) { + cleanup(); + } + } +private: + std::function cleanup_pipes = nullptr; + std::thread thread; + struct msg_t { + std::map headers; + int status = 0; + std::string data; + std::string content_type; + }; +}; diff --git a/tools/server/server-queue.cpp b/tools/server/server-queue.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5d37c34536e3c8cc23b6459f08be45f41252a7ce --- /dev/null +++ b/tools/server/server-queue.cpp @@ -0,0 +1,460 @@ +#include "server-task.h" +#include "server-queue.h" + +#include "log.h" + +#include + +#define QUE_INF(fmt, ...) LOG_INF("que %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define QUE_WRN(fmt, ...) LOG_WRN("que %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define QUE_ERR(fmt, ...) LOG_ERR("que %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define QUE_DBG(fmt, ...) LOG_DBG("que %12.*s: " fmt, 12, __func__, __VA_ARGS__) + +#define RES_INF(fmt, ...) LOG_INF("res %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define RES_WRN(fmt, ...) LOG_WRN("res %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define RES_ERR(fmt, ...) LOG_ERR("res %12.*s: " fmt, 12, __func__, __VA_ARGS__) +#define RES_DBG(fmt, ...) LOG_DBG("res %12.*s: " fmt, 12, __func__, __VA_ARGS__) + +// +// server_queue +// + +int server_queue::post(server_task && task, bool front) { + std::unique_lock lock(mutex_tasks); + GGML_ASSERT(task.id != -1); + // if this is cancel task make sure to clean up pending tasks + if (task.type == SERVER_TASK_TYPE_CANCEL) { + cleanup_pending_task(task.id_target); + } + const int task_id = task.id; + QUE_DBG("new task, id = %d, front = %d\n", task_id, front); + if (front) { + queue_tasks.push_front(std::move(task)); + } else { + queue_tasks.push_back(std::move(task)); + } + time_last_task = ggml_time_ms(); + condition_tasks.notify_one(); + return task_id; +} + +int server_queue::post(std::vector && tasks, bool front) { + std::unique_lock lock(mutex_tasks); + for (auto & task : tasks) { + if (task.id == -1) { + task.id = id++; + } + // if this is cancel task make sure to clean up pending tasks + if (task.type == SERVER_TASK_TYPE_CANCEL) { + cleanup_pending_task(task.id_target); + } + QUE_DBG("new task, id = %d/%d, front = %d\n", task.id, (int) tasks.size(), front); + if (front) { + queue_tasks.push_front(std::move(task)); + } else { + queue_tasks.push_back(std::move(task)); + } + } + time_last_task = ggml_time_ms(); + condition_tasks.notify_one(); + return 0; +} + +void server_queue::defer(server_task && task) { + std::unique_lock lock(mutex_tasks); + QUE_DBG("defer task, id = %d\n", task.id); + queue_tasks_deferred.push_back(std::move(task)); + time_last_task = ggml_time_ms(); + condition_tasks.notify_one(); +} + +int server_queue::get_new_id() { + std::unique_lock lock(mutex_tasks); + int new_id = id++; + return new_id; +} + +void server_queue::pop_deferred_task(int id_slot) { + std::unique_lock lock(mutex_tasks); + if (!queue_tasks_deferred.empty()) { + // try to find a task that uses the specified slot + bool found = false; + for (auto it = queue_tasks_deferred.begin(); it != queue_tasks_deferred.end(); ++it) { + if (it->id_slot == id_slot) { + QUE_DBG("pop deferred task (use slot %d), id_task = %d\n", id_slot, it->id); + queue_tasks.emplace_front(std::move(*it)); + queue_tasks_deferred.erase(it); + found = true; + break; + } + } + // if not tasks found using the slot, just pop the first deferred task (default behavior) + if (!found) { + QUE_DBG("pop deferred task, id_task = %d\n", queue_tasks_deferred.front().id); + queue_tasks.emplace_front(std::move(queue_tasks_deferred.front())); + queue_tasks_deferred.pop_front(); + } + } + time_last_task = ggml_time_ms(); + condition_tasks.notify_one(); +} + +void server_queue::wait_until_no_sleep() { + std::unique_lock lock(mutex_tasks); + if (!sleeping) { + return; + } else { + if (!req_stop_sleeping) { + QUE_DBG("%s", "requesting to stop sleeping\n"); + req_stop_sleeping = true; + condition_tasks.notify_one(); // only main thread is waiting on this + } + QUE_DBG("%s", "waiting until no sleep\n"); + condition_tasks.wait(lock, [&]{ + return !sleeping; + }); + } +} + +void server_queue::terminate() { + std::unique_lock lock(mutex_tasks); + running = false; + condition_tasks.notify_all(); +} + +void server_queue::start_loop(int64_t idle_sleep_ms) { + running = true; + time_last_task = ggml_time_ms(); + + constexpr auto max_wait_time = std::chrono::seconds(1); + auto should_sleep = [&]() -> bool { + // caller must hold mutex_tasks + if (idle_sleep_ms < 0) { + return false; + } + int64_t now = ggml_time_ms(); + return (now - time_last_task) >= idle_sleep_ms; + }; + + while (true) { + QUE_DBG("%s", "processing new tasks\n"); + + while (true) { + std::unique_lock lock(mutex_tasks); + if (!running) { + QUE_DBG("%s", "terminate\n"); + return; + } + if (queue_tasks.empty()) { + lock.unlock(); + break; + } + server_task task = std::move(queue_tasks.front()); + queue_tasks.pop_front(); + lock.unlock(); + + QUE_DBG("processing task, id = %d\n", task.id); + callback_new_task(std::move(task)); + } + // all tasks in the current loop is processed, slots data is now ready + QUE_DBG("%s", "update slots\n"); + + // this will run the main inference process for all slots + callback_update_slots(); + { + // update_slots() may take a while to finish, we need to make sure it's not counted as idle + std::unique_lock lock(mutex_tasks); + time_last_task = ggml_time_ms(); + } + + QUE_DBG("%s", "waiting for new tasks\n"); + while (true) { + std::unique_lock lock(mutex_tasks); + if (!running || !queue_tasks.empty()) { + break; // go back to process new tasks or terminate + } + + // no tasks, check for sleeping state + if (should_sleep()) { + QUE_INF("%s", "entering sleeping state\n"); + sleeping = true; + callback_sleeping_state(true); + req_stop_sleeping = false; + // wait until we are requested to exit sleeping state + condition_tasks.wait(lock, [&]{ + return (!running || req_stop_sleeping); + }); + if (!running) { // may changed during sleep + break; // terminate + } + QUE_INF("%s", "exiting sleeping state\n"); + req_stop_sleeping = false; + callback_sleeping_state(false); + sleeping = false; + time_last_task = ggml_time_ms(); + condition_tasks.notify_all(); // notify wait_until_no_sleep() + break; // process new tasks + } else { + // wait for new tasks or timeout for checking sleeping condition + bool res = condition_tasks.wait_for(lock, max_wait_time, [&]{ + return (!queue_tasks.empty() || !running); + }); + if (res) { + break; // new task arrived or terminate + } + // otherwise, loop again to check sleeping condition + } + } + } +} + +void server_queue::cleanup_pending_task(int id_target) { + // no need lock because this is called exclusively by post() + auto rm_func = [id_target](const server_task & task) { + return task.id == id_target; + }; + queue_tasks.erase( + std::remove_if(queue_tasks.begin(), queue_tasks.end(), rm_func), + queue_tasks.end()); + queue_tasks_deferred.erase( + std::remove_if(queue_tasks_deferred.begin(), queue_tasks_deferred.end(), rm_func), + queue_tasks_deferred.end()); +} + +// +// server_response +// + +void server_response::add_waiting_task_id(int id_task) { + RES_DBG("add task %d to waiting list. current waiting = %d (before add)\n", id_task, (int) waiting_task_ids.size()); + + std::unique_lock lock(mutex_results); + waiting_task_ids.insert(id_task); +} + +void server_response::add_waiting_task_ids(const std::unordered_set & id_tasks) { + std::unique_lock lock(mutex_results); + + for (const auto & id_task : id_tasks) { + RES_DBG("add task %d to waiting list. current waiting = %d (before add)\n", id_task, (int) waiting_task_ids.size()); + waiting_task_ids.insert(id_task); + } +} + +void server_response::remove_waiting_task_id(int id_task) { + RES_DBG("remove task %d from waiting list. current waiting = %d (before remove)\n", id_task, (int) waiting_task_ids.size()); + + std::unique_lock lock(mutex_results); + waiting_task_ids.erase(id_task); + // make sure to clean up all pending results + queue_results.erase( + std::remove_if(queue_results.begin(), queue_results.end(), [id_task](const server_task_result_ptr & res) { + return res->id == id_task; + }), + queue_results.end()); +} + +void server_response::remove_waiting_task_ids(const std::unordered_set & id_tasks) { + std::unique_lock lock(mutex_results); + + for (const auto & id_task : id_tasks) { + RES_DBG("remove task %d from waiting list. current waiting = %d (before remove)\n", id_task, (int) waiting_task_ids.size()); + waiting_task_ids.erase(id_task); + } +} + +server_task_result_ptr server_response::recv(const std::unordered_set & id_tasks) { + while (true) { + std::unique_lock lock(mutex_results); + condition_results.wait(lock, [&]{ + if (!running) { + RES_DBG("%s : queue result stop\n", "recv"); + std::terminate(); // we cannot return here since the caller is HTTP code + } + return !queue_results.empty(); + }); + + for (size_t i = 0; i < queue_results.size(); i++) { + if (id_tasks.find(queue_results[i]->id) != id_tasks.end()) { + server_task_result_ptr res = std::move(queue_results[i]); + queue_results.erase(queue_results.begin() + i); + return res; + } + } + } + + // should never reach here +} + +server_task_result_ptr server_response::recv_with_timeout(const std::unordered_set & id_tasks, int timeout) { + while (true) { + std::unique_lock lock(mutex_results); + + for (int i = 0; i < (int) queue_results.size(); i++) { + if (id_tasks.find(queue_results[i]->id) != id_tasks.end()) { + server_task_result_ptr res = std::move(queue_results[i]); + queue_results.erase(queue_results.begin() + i); + return res; + } + } + + std::cv_status cr_res = condition_results.wait_for(lock, std::chrono::seconds(timeout)); + if (!running) { + RES_DBG("%s : queue result stop\n", __func__); + std::terminate(); // we cannot return here since the caller is HTTP code + } + if (cr_res == std::cv_status::timeout) { + return nullptr; + } + } + + // should never reach here +} + +server_task_result_ptr server_response::recv(int id_task) { + std::unordered_set id_tasks = {id_task}; + return recv(id_tasks); +} + +void server_response::send(server_task_result_ptr && result) { + RES_DBG("sending result for task id = %d\n", result->id); + + std::unique_lock lock(mutex_results); + for (const auto & id_task : waiting_task_ids) { + if (result->id == id_task) { + RES_DBG("task id = %d pushed to result queue\n", result->id); + + queue_results.emplace_back(std::move(result)); + condition_results.notify_all(); + return; + } + } +} + +void server_response::broadcast(server_task_result_ptr && result) { + std::unique_lock lock(mutex_results); + for (const auto & id_task : waiting_task_ids) { + RES_DBG("task id = %d pushed to result queue\n", id_task); + server_task_result_ptr res_copy(result->clone()); + res_copy->id = id_task; // override id with target task id + queue_results.emplace_back(std::move(res_copy)); + } + condition_results.notify_all(); +} + +void server_response::terminate() { + running = false; + condition_results.notify_all(); +} + +// +// server_response_reader +// + +void server_response_reader::post_task(server_task && task, bool front) { + GGML_ASSERT(id_tasks.empty() && "post_task() can only be called once per reader"); + GGML_ASSERT(!task.is_parent() && "not supported, use post_tasks() instead"); + task.index = 0; + id_tasks.insert(task.id); + states.push_back(task.create_state()); + queue_results.add_waiting_task_id(task.id); + queue_tasks.post(std::move(task), front); +} + +void server_response_reader::post_tasks(std::vector && tasks, bool front) { + GGML_ASSERT(id_tasks.empty() && "post_tasks() can only be called once per reader"); + id_tasks = server_task::get_list_id(tasks); + states.reserve(tasks.size()); + size_t index = 0; + for (auto & task : tasks) { + task.index = index++; + states.push_back(task.create_state()); + // for child tasks + for (auto & child_task : task.child_tasks) { + child_task.index = index++; + states.push_back(child_task.create_state()); + } + } + GGML_ASSERT(states.size() == id_tasks.size()); + queue_results.add_waiting_task_ids(id_tasks); + queue_tasks.post(std::move(tasks), front); +} + +bool server_response_reader::has_next() const { + return !cancelled && received_count < id_tasks.size(); +} + +// return nullptr if should_stop() is true before receiving a result +// note: if one error is received, it will stop further processing and return error result +server_task_result_ptr server_response_reader::next(const std::function & should_stop) { + while (true) { + server_task_result_ptr result = queue_results.recv_with_timeout(id_tasks, polling_interval_seconds); + if (result == nullptr) { + // timeout, check stop condition + if (should_stop()) { + return nullptr; + } + } else { + if (result->is_error()) { + stop(); // cancel remaining tasks + SRV_DBG("%s", "received error result, stopping further processing\n"); + return result; + } + if (!states.empty()) { + // update the generation state if needed + const size_t idx = result->index; + GGML_ASSERT(idx < states.size()); + result->update(states[idx]); + } + if (result->is_stop()) { + received_count++; + } + return result; + } + } + + // should not reach here +} + +server_response_reader::batch_response server_response_reader::wait_for_all(const std::function & should_stop) { + batch_response batch_res; + batch_res.results.clear(); + batch_res.results.resize(id_tasks.size()); + while (has_next()) { + auto res = next(should_stop); + if (res == nullptr) { + batch_res.is_terminated = true; + return batch_res; + } + if (res->is_error()) { + batch_res.error = std::move(res); + return batch_res; + } + const size_t idx = res->index; + GGML_ASSERT(idx < batch_res.results.size() && "index out of range"); + GGML_ASSERT(batch_res.results[idx] == nullptr && "duplicate result received"); + batch_res.results[idx] = std::move(res); + } + return batch_res; +} + +void server_response_reader::stop() { + queue_results.remove_waiting_task_ids(id_tasks); + if (has_next() && !cancelled) { + // if tasks is not finished yet, cancel them + cancelled = true; + std::vector cancel_tasks; + cancel_tasks.reserve(id_tasks.size()); + for (const auto & id_task : id_tasks) { + SRV_WRN("cancel task, id_task = %d\n", id_task); + server_task task(SERVER_TASK_TYPE_CANCEL); + task.id_target = id_task; + queue_results.remove_waiting_task_id(id_task); + cancel_tasks.push_back(std::move(task)); + } + // push to beginning of the queue, so it has highest priority + queue_tasks.post(std::move(cancel_tasks), true); + } else { + SRV_DBG("%s", "all tasks already finished, no need to cancel\n"); + } +} diff --git a/tools/server/server-queue.h b/tools/server/server-queue.h new file mode 100644 index 0000000000000000000000000000000000000000..0b674d6ff0f94493a283b19e6c0320e8f2f3ed9a --- /dev/null +++ b/tools/server/server-queue.h @@ -0,0 +1,209 @@ +#pragma once + +#include "server-task.h" + +#include +#include +#include +#include +#include + +// struct for managing server tasks +// in most cases, use server_response_reader to post new tasks and retrieve results +struct server_queue { +private: + int id = 0; + bool running = false; + bool sleeping = false; + bool req_stop_sleeping = false; + int64_t time_last_task = 0; + + // queues + std::deque queue_tasks; + std::deque queue_tasks_deferred; + + std::mutex mutex_tasks; + std::condition_variable condition_tasks; + + // callback functions + std::function callback_new_task; + std::function callback_update_slots; + std::function callback_sleeping_state; + +public: + // Add a new task to the end of the queue + int post(server_task && task, bool front = false); + + // multi-task version of post() + int post(std::vector && tasks, bool front = false); + + // Add a new task, but defer until one slot is available + void defer(server_task && task); + + // Get the next id for creating a new task + int get_new_id(); + + // Call when the state of one slot is changed, it will move one task from deferred to main queue + // prioritize tasks that use the specified slot (otherwise, pop the first deferred task) + void pop_deferred_task(int id_slot); + + // if sleeping, request exiting sleep state and wait until it is done + // returns immediately if not sleeping + void wait_until_no_sleep(); + + bool is_sleeping() { + std::unique_lock lock(mutex_tasks); + return sleeping; + } + + // end the start_loop routine + void terminate(); + + /** + * Main loop consists of these steps: + * - Wait until a new task arrives + * - Process the task (i.e. maybe copy data into slot) + * - Check if multitask is finished + * - Update all slots + * + * Sleeping procedure (disabled if idle_sleep_ms < 0): + * - If there is no task after idle_sleep_ms, enter sleeping state + * - Call callback_sleeping_state(true) + * - Wait until req_stop_sleeping is set to true + * - Call callback_sleeping_state(false) + * - Exit sleeping state + */ + void start_loop(int64_t idle_sleep_ms = -1); + + // for metrics + size_t queue_tasks_deferred_size() { + std::unique_lock lock(mutex_tasks); + return queue_tasks_deferred.size(); + } + + // + // Functions below are not thread-safe, must only be used before start_loop() is called + // + + // Register function to process a new task + void on_new_task(std::function callback) { + callback_new_task = std::move(callback); + } + + // Register the function to be called when all slots data is ready to be processed + void on_update_slots(std::function callback) { + callback_update_slots = std::move(callback); + } + + // Register callback for sleeping state change; multiple callbacks are allowed + // note: when entering sleeping state, the callback is called AFTER sleeping is set to true + // when leaving sleeping state, the callback is called BEFORE sleeping is set to false + void on_sleeping_state(std::function callback) { + if (callback_sleeping_state) { + auto prev_callback = std::move(callback_sleeping_state); + callback_sleeping_state = [prev_callback, callback](bool sleeping) { + prev_callback(sleeping); + callback(sleeping); + }; + } else { + callback_sleeping_state = std::move(callback); + } + } + +private: + void cleanup_pending_task(int id_target); +}; + +// struct for managing server responses +// in most cases, use server_response_reader to retrieve results +struct server_response { +private: + bool running = true; + + // for keeping track of all tasks waiting for the result + std::unordered_set waiting_task_ids; + + // the main result queue (using ptr for polymorphism) + std::vector queue_results; + + std::mutex mutex_results; + std::condition_variable condition_results; + +public: + // add the id_task to the list of tasks waiting for response + void add_waiting_task_id(int id_task); + + void add_waiting_task_ids(const std::unordered_set & id_tasks); + + // when the request is finished, we can remove task associated with it + void remove_waiting_task_id(int id_task); + + // remove multiple tasks from waiting list + void remove_waiting_task_ids(const std::unordered_set & id_tasks); + + // This function blocks the thread until there is a response for one of the id_tasks + server_task_result_ptr recv(const std::unordered_set & id_tasks); + + // same as recv(), but have timeout in seconds + // if timeout is reached, nullptr is returned + server_task_result_ptr recv_with_timeout(const std::unordered_set & id_tasks, int timeout); + + // single-task version of recv() + server_task_result_ptr recv(int id_task); + + // Send a new result to a waiting id_task + void send(server_task_result_ptr && result); + + // broadcast a new result to all waiting tasks + // (used by router mode) + void broadcast(server_task_result_ptr && result); + + // terminate the waiting loop + void terminate(); +}; + +// RAII wrapper to make working with server_queue and server_response easier +// it provides a generator-like API for server responses +// support pooling connection state and aggregating multiple results +struct server_response_reader { + std::unordered_set id_tasks; + server_queue & queue_tasks; + server_response & queue_results; + size_t received_count = 0; + bool cancelled = false; + int polling_interval_seconds; + + // tracking generation state and partial tool calls + // only used by streaming completions + std::vector states; + + // should_stop function will be called each polling_interval_seconds + server_response_reader(server_queue & queue_tasks, server_response & queue_results, int polling_interval_seconds) + : queue_tasks(queue_tasks), queue_results(queue_results), polling_interval_seconds(polling_interval_seconds) {} + ~server_response_reader() { + stop(); + } + + int get_new_id() { + return queue_tasks.get_new_id(); + } + + // if front = true, the task will be posted to the front of the queue (high priority) + void post_task(server_task && task, bool front = false); + void post_tasks(std::vector && tasks, bool front = false); + bool has_next() const; + + // return nullptr if should_stop() is true before receiving a result + // note: if one error is received, it will stop further processing and return error result + server_task_result_ptr next(const std::function & should_stop); + + struct batch_response { + bool is_terminated = false; // if true, indicates that processing was stopped before all results were received + std::vector results; + server_task_result_ptr error; // nullptr if no error + }; + // aggregate multiple results + batch_response wait_for_all(const std::function & should_stop); + + void stop(); +}; diff --git a/tools/server/server-schema.cpp b/tools/server/server-schema.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5d7fa6ae6ec39396c651e1d2e2c6253bb100c536 --- /dev/null +++ b/tools/server/server-schema.cpp @@ -0,0 +1,659 @@ +#include "server-schema.h" + +#include "json-schema-to-grammar.h" + +namespace server_schema { + +// +// llama.cpp-specific completion schema +// + +std::vector> make_llama_cmpl_schema(const common_params & params_base, task_params & params) { + std::vector> fields; + auto add = [&](field * f) { + fields.emplace_back(f); + }; + + add((new field_bool("verbose", params.verbose)) + ->set_desc("Include __verbose field in the response with additional debug information")); + + add((new field_bool("timings_per_token", params.timings_per_token)) + ->set_desc("Include prompt processing and text generation speed information in each response")); + + add((new field_bool("stream", params.stream)) + ->set_desc("Allows receiving each predicted token in real-time instead of waiting for the completion to finish")); + + add((new field_nested("stream_options")) + ->add_subfield((new field_bool("include_usage", params.include_usage)) + ->set_desc("Whether to include usage information in the stream")) + ->set_desc("Additional options for streaming responses")); + + add((new field_bool("cache_prompt", params.cache_prompt)) + ->set_desc("Re-use KV cache from a previous request if possible. This way the common prefix does not have to be re-processed, only the suffix that differs between the requests")); + + add((new field_bool("return_tokens", params.return_tokens)) + ->set_desc("Return the raw generated token ids in the `tokens` field")); + + add((new field_bool("return_progress", params.return_progress)) + ->set_desc("Include prompt processing progress events in stream mode")); + + add((new field_num("sse_ping_interval", params.sse_ping_interval)) + ->set_hard_limits(-1, INT32_MAX) + ->set_desc("Interval in seconds between SSE comment pings emitted while the stream stays silent, -1 disables pings")); + + add((new field_num("n_predict", params.n_predict)) + ->set_hard_limits(-1, INT32_MAX) + ->add_alias("max_completion_tokens") + ->add_alias("max_tokens") + ->set_desc("Set the maximum number of tokens to predict. When 0, no tokens will be generated but the prompt is evaluated into the cache")); + + add((new field_num("n_indent", params.n_indent)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Specify the minimum line indentation for the generated text in number of whitespace characters. Useful for code completion tasks")); + + add((new field_num("n_keep", params.n_keep)) + ->set_hard_limits(-1, INT32_MAX) + ->set_desc("Specify the number of tokens from the initial prompt to retain when context size is exceeded. Use -1 to retain all tokens from the prompt")); + + add((new field_num("n_discard", params.n_discard)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Number of tokens after n_keep that may be discarded when shifting context (0 = half context)")); + + add((new field_num("n_cmpl", params.n_cmpl)) + ->set_hard_limits(1, params_base.n_parallel) + ->add_alias("n") // alias "n" as fallback (OpenAI completions API) + ->set_desc("Number of completions to generate. If the input has multiple prompts, total outputs will be N prompts times n_cmpl")); + + add((new field_num("n_cache_reuse", params.n_cache_reuse)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Min chunk size to attempt reusing from the cache via KV shifting. See --cache-reuse arg")); + + // TODO: implement t_max_prompt_ms + // add((new field_num("t_max_prompt_ms", params.t_max_prompt_ms)) + + add((new field_num("t_max_predict_ms", params.t_max_predict_ms)) + ->set_hard_limits(-1, std::numeric_limits::max()) + ->set_desc("Set a time limit in milliseconds for the prediction phase. The timeout triggers if generation exceeds this time (measured since the first token) and a newline has been generated. Useful for FIM applications")); + + add((new field_json("response_fields")) + ->set_desc("A list of response fields to return. Missing fields are omitted without error. Fields with a slash are unnested (e.g. generation_settings/n_predict moves n_predict to the root)") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.response_fields = json_value(data, "response_fields", std::vector()); + })); + + + // + // Sampling params + // + + add((new field_num("top_k", params.sampling.top_k)) + ->set_limits(0, INT32_MAX) + ->set_desc("Limit the next token selection to the K most probable tokens (0 = disabled)")); + + add((new field_num("top_p", params.sampling.top_p)) + ->set_limits(0.0f, 1.0f) + ->set_desc("Limit the next token selection to a subset of tokens with cumulative probability above threshold P (1.0 = disabled)")); + + add((new field_num("min_p", params.sampling.min_p)) + ->set_limits(0.0f, 1.0f) + ->set_desc("The minimum probability for a token to be considered, relative to the probability of the most likely token (0 = disabled)")); + + add((new field_num("top_n_sigma", params.sampling.top_n_sigma)) + ->set_desc("Keep tokens within n standard deviations of the top token logit (< 0 = disabled)")); + + add((new field_num("xtc_probability", params.sampling.xtc_probability)) + ->set_limits(0.0f, 1.0f) + ->set_desc("Set the chance for token removal via XTC sampler (0 = disabled)")); + + add((new field_num("xtc_threshold", params.sampling.xtc_threshold)) + ->set_limits(0.0f, 1.0f) + ->set_desc("Set a minimum probability threshold for tokens to be removed via XTC sampler (> 0.5 disables XTC)")); + + add((new field_num("typical_p", params.sampling.typ_p)) + // ->set_limits(0.0f, 1.0f) // what's the valid range? + ->set_desc("Enable locally typical sampling with parameter p (1.0 = disabled)")); + + add((new field_num("temperature", params.sampling.temp)) + ->set_limits(0.0f, std::numeric_limits::infinity()) + ->set_desc("Adjust the randomness of the generated text (0 = greedy)")); + + add((new field_num("dynatemp_range", params.sampling.dynatemp_range)) + ->set_desc("Dynamic temperature range. The final temperature will be in [temperature - range, temperature + range] (0 = disabled)")); + + add((new field_num("dynatemp_exponent", params.sampling.dynatemp_exponent)) + ->set_desc("Dynamic temperature exponent, controls how entropy maps to temperature")); + + add((new field_num("repeat_last_n", params.sampling.penalty_last_n)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Last n tokens to consider for penalizing repetition (0 = disabled)")); + + add((new field_num("repeat_penalty", params.sampling.penalty_repeat)) + ->set_desc("Control the repetition of token sequences in the generated text (1.0 = disabled)")); + + add((new field_num("frequency_penalty", params.sampling.penalty_freq)) + ->set_desc("Repeat alpha frequency penalty (0 = disabled)")); + + add((new field_num("presence_penalty", params.sampling.penalty_present)) + ->set_desc("Repeat alpha presence penalty (0 = disabled)")); + + add((new field_num("dry_multiplier", params.sampling.dry_multiplier)) + ->set_desc("Set the DRY (Don't Repeat Yourself) repetition penalty multiplier (0 = disabled)")); + + add((new field_num("dry_base", params.sampling.dry_base)) + ->set_desc("Set the DRY repetition penalty base value (must be >= 1.0, any values < 1.0 will be replaced with the default value)") + ->set_handler([&](field_eval_context & ctx, const json & data) { + float v = data.at("dry_base").get(); + ctx.params.sampling.dry_base = (v < 1.0f) ? params_base.sampling.dry_base : v; + })); + + add((new field_num("dry_allowed_length", params.sampling.dry_allowed_length)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Tokens that extend repetition beyond this length receive exponentially increasing penalty: multiplier * base ^ (sequence_length - allowed_length)")); + + add((new field_num("dry_penalty_last_n", params.sampling.dry_penalty_last_n)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("How many tokens to scan for repetitions (0 = disabled)")); + + add((new field_num("mirostat", params.sampling.mirostat)) + ->set_limits(0, 2) + ->set_desc("Enable Mirostat sampling, controlling perplexity during text generation (0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)")); + + add((new field_num("mirostat_tau", params.sampling.mirostat_tau)) + ->set_desc("Set the Mirostat target entropy, parameter tau")); + + add((new field_num("mirostat_eta", params.sampling.mirostat_eta)) + ->set_desc("Set the Mirostat learning rate, parameter eta")); + + add((new field_num("adaptive_target", params.sampling.adaptive_target)) + ->set_limits(-std::numeric_limits::max(), 1.0f) + ->set_desc("Adaptive sampling target entropy (valid range 0.0 to 1.0; negative = disabled)")); + + add((new field_num("adaptive_decay", params.sampling.adaptive_decay)) + ->set_hard_limits(0.0f, 0.99f) + ->set_desc("EMA decay for adaptive sampling; history approximates 1/(1-decay) tokens")); + + // seed is uint32_t; field_num uses int32_t so use a handler + add((new field_num("seed", params.sampling.seed)) + ->set_desc("Set the random number generator (RNG) seed (-1 = random)")); + + add((new field_num("n_probs", params.sampling.n_probs)) + ->add_alias("logprobs") // use "logprobs" if "n_probs" wasn't provided + ->set_desc("If greater than 0, output the probabilities of top N tokens for each generated token")); + + add((new field_num("min_keep", params.sampling.min_keep)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("If greater than 0, force samplers to return at least N possible tokens")); + + add((new field_bool("backend_sampling", params.sampling.backend_sampling)) + ->set_desc("Use backend sampling instead of llama.cpp sampling")); + + add((new field_bool("post_sampling_probs", params.post_sampling_probs)) + ->set_desc("Return probabilities of top n_probs tokens after applying the sampling chain")); + + // + // Speculative decoding params + // + + // TODO: to keep things simple, we disable speculative parameter adjustments for now +#if 0 + // TODO: for now, be able to adjust only the draft-model based speculative parameters + add((new field_num("speculative.n_max", params.speculative.draft.n_max)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Maximum number of tokens to draft during speculative decoding")); + + add((new field_num("speculative.n_min", params.speculative.draft.n_min)) + ->set_hard_limits(0, INT32_MAX) + ->set_desc("Minimum number of draft tokens to use for speculative decoding"); + + add((new field_num("speculative.p_min", params.speculative.draft.p_min)) + ->set_hard_limits(0.0f, 1.0f) + ->set_desc("Minimum speculative decoding probability for draft tokens (0 = greedy)")); + + + add((new field_str("speculative.type")) + ->set_desc("Speculative decoding method (for debugging and research purposes)") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.speculative.types = { common_speculative_type_from_name(data.at("speculative.type").get()) }; + })); + + add((new field_num("speculative.ngram_size_n", params.speculative.ngram_simple.size_n)) + ->set_desc("Ngram size for lookup in ngram-based speculative decoding")); + + add((new field_num("speculative.ngram_size_m", params.speculative.ngram_simple.size_m)) + ->set_desc("Mgram size for speculative tokens in ngram-based speculative decoding")); + + add((new field_num("speculative.ngram_min_hits", params.speculative.ngram_simple.min_hits)) + ->set_desc("Minimum hits at ngram lookup for mgram to be proposed")); +#endif + + add((new field_json("lora")) + ->set_desc("A list of LoRA adapters to apply to this request. Each entry must have `id` and `scale` fields. Adapters not listed default to scale 0.0") + ->set_handler([&](field_eval_context & ctx, const json & data) { + const auto & lora = data.at("lora"); + if (!lora.is_array()) { + throw std::runtime_error("Error: 'lora' must be an array of objects with 'id' and 'scale' fields"); + } + ctx.params.lora = parse_lora_request(lora); + })); + + // sequence breakers for DRY + // Currently, this is not compatible with TextGen WebUI, Koboldcpp and SillyTavern format + // Ref: https://github.com/oobabooga/text-generation-webui/blob/d1af7a41ade7bd3c3a463bfa640725edb818ebaf/extensions/openai/typing.py#L39 + add((new field_json("dry_sequence_breakers")) + ->set_desc("Specify an array of sequence breakers for DRY sampling. Only a JSON array of strings is accepted") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.sampling.dry_sequence_breakers = json_value(data, "dry_sequence_breakers", std::vector()); + if (ctx.params.sampling.dry_sequence_breakers.empty()) { + throw std::runtime_error("Error: dry_sequence_breakers must be a non-empty array of strings"); + } + })); + + // handle both "json_schema" and "grammar" + add((new field_json("json_schema")) + ->add_alias("grammar") + ->set_desc("Set a JSON schema (json_schema) or GBNF grammar string (grammar) for constrained generation. json_schema takes precedence if both are provided") + ->set_handler([&](field_eval_context & ctx, const json & data) { + auto & params = ctx.params; + if (data.contains("json_schema") && !data.contains("grammar")) { + try { + auto schema = json_value(data, "json_schema", json::object()); + SRV_DBG("JSON schema: %s\n", schema.dump(2).c_str()); + std::string grammar_str = json_schema_to_grammar(schema); + SRV_DBG("Converted grammar: %s\n", grammar_str.c_str()); + params.sampling.grammar = {COMMON_GRAMMAR_TYPE_OUTPUT_FORMAT, std::move(grammar_str)}; + } catch (const std::exception & e) { + throw std::runtime_error(std::string("\"json_schema\": ") + e.what()); + } + } else { + std::string grammar_str = json_value(data, "grammar", std::string()); + if (!grammar_str.empty()) { + // grammar_type key is set by the server when converting chat template grammars + std::string grammar_type = json_value(data, "grammar_type", std::string()); + if (grammar_type == "tool_calls") { + params.sampling.grammar = {COMMON_GRAMMAR_TYPE_TOOL_CALLS, std::move(grammar_str)}; + } else { + // explicit grammar from the user (API field "grammar") + params.sampling.grammar = {COMMON_GRAMMAR_TYPE_USER, std::move(grammar_str)}; + } + SRV_DBG("Grammar (%s): %s\n", grammar_type.c_str(), common_grammar_value(params.sampling.grammar).c_str()); + } + } + })); + + add((new field_bool("grammar_lazy", params.sampling.grammar_lazy)) + ->set_desc("Whether to apply grammar constraints lazily, only when triggered (instead of at every step)")); + + // + // Chat parser params + // + + // TODO: change this to string field instead + add((new field_json("chat_format")) + ->set_desc("Chat format used internally by the server") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.chat_parser_params.format = static_cast(data.at("chat_format").get()); + SRV_TRC("chat format: %s\n", common_chat_format_name(ctx.params.chat_parser_params.format)); + })); + + add((new field_str("reasoning_format")) + ->set_desc("Reasoning format for chain-of-thought models") + ->set_handler([&](field_eval_context & ctx, const json & data) { + auto reasoning_format = common_reasoning_format_from_name(data.at("reasoning_format").get()); + ctx.params.chat_parser_params.reasoning_format = reasoning_format; + ctx.params.chat_parser_params.reasoning_in_content = ctx.params.stream && (reasoning_format == COMMON_REASONING_FORMAT_DEEPSEEK_LEGACY); + })); + + add((new field_str("generation_prompt")) + ->set_desc("Generation prompt appended to the chat template output") + ->set_handler([&](field_eval_context & ctx, const json & data) { + std::string s = data.at("generation_prompt").get(); + ctx.params.chat_parser_params.generation_prompt = s; + ctx.params.sampling.generation_prompt = s; + })); + + add((new field_bool("parse_tool_calls", params.chat_parser_params.parse_tool_calls)) + ->set_desc("Whether to parse tool calls from the generated output")); + + add((new field_str("chat_parser")) + ->set_desc("Chat parser configuration string") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.chat_parser_params.parser.load(data.at("chat_parser").get()); + })); + + add((new field_json("continue_final_message")) + ->set_desc("Whether to continue the final message of the chat template") + ->set_handler([&](field_eval_context & ctx, const json & data) { + auto continuation = common_chat_continuation_parse(data.at("continue_final_message")); + ctx.params.chat_parser_params.is_continuation = continuation != COMMON_CHAT_CONTINUATION_NONE; + })); + + add((new field_bool("echo", params.chat_parser_params.echo)) + ->set_desc("Whether to echo the input tokens in the output")); + + // + // Token-level fields (require vocab) + // + + add((new field_json("preserved_tokens")) + ->set_desc("List of token strings that must not be split during tokenization") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + for (const auto & t : data.at("preserved_tokens")) { + auto ids = common_tokenize(ctx.vocab, t.get(), false, true); + if (ids.size() == 1) { + ctx.params.sampling.preserved_tokens.insert(ids[0]); + } + } + })); + + add((new field_json("grammar_triggers")) + ->set_desc("List of strings or patterns that trigger grammar-constrained generation") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + for (const auto & t : data.at("grammar_triggers")) { + server_grammar_trigger ct(t); + if (ct.value.type == COMMON_GRAMMAR_TRIGGER_TYPE_WORD) { + const auto & word = ct.value.value; + auto ids = common_tokenize(ctx.vocab, word, false, true); + if (ids.size() == 1) { + auto token = ids[0]; + if (std::find(ctx.params.sampling.preserved_tokens.begin(), ctx.params.sampling.preserved_tokens.end(), (llama_token) token) == ctx.params.sampling.preserved_tokens.end()) { + throw std::runtime_error("Grammar trigger word should be marked as preserved token: " + word); + } + common_grammar_trigger trigger; + trigger.type = COMMON_GRAMMAR_TRIGGER_TYPE_TOKEN; + trigger.value = word; + trigger.token = token; + ctx.params.sampling.grammar_triggers.push_back(std::move(trigger)); + } else { + ctx.params.sampling.grammar_triggers.push_back({COMMON_GRAMMAR_TRIGGER_TYPE_WORD, word}); + } + } else { + ctx.params.sampling.grammar_triggers.emplace_back(std::move(ct.value)); + } + } + if (ctx.params.sampling.grammar_lazy && ctx.params.sampling.grammar_triggers.empty()) { + throw std::runtime_error("Error: no triggers set for lazy grammar!"); + } + })); + + add((new field_bool("reasoning_control", params.sampling.reasoning_control)) + ->set_desc("Create the budget sampler on demand so reasoning can be ended at runtime")); + + add((new field_num("reasoning_budget_tokens", params.sampling.reasoning_budget_tokens)) + ->set_hard_limits(-1, INT32_MAX) + ->set_desc("Number of tokens in the reasoning budget (-1 = disabled)")); + + add((new field_str("reasoning_budget_start_tag")) + ->set_desc("Token string marking the start of the reasoning budget section") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + ctx.params.sampling.reasoning_budget_start = common_tokenize(ctx.vocab, data.at("reasoning_budget_start_tag").get(), false, true); + })); + + add((new field_json("reasoning_budget_end_tags")) + ->add_alias("reasoning_budget_end_tag") + ->set_desc("Token strings marking the end of the reasoning budget section; the first is forced when the budget expires") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + ctx.params.sampling.reasoning_budget_end.clear(); + if (data.contains("reasoning_budget_end_tags")) { + for (const auto & t : data.at("reasoning_budget_end_tags")) { + std::string tag = t.get(); + if (!tag.empty()) { + ctx.params.sampling.reasoning_budget_end.push_back(common_tokenize(ctx.vocab, tag, false, true)); + } + } + } else if (data.contains("reasoning_budget_end_tag")) { + std::string tag = data.at("reasoning_budget_end_tag").get(); + if (!tag.empty()) { + ctx.params.sampling.reasoning_budget_end.push_back(common_tokenize(ctx.vocab, tag, false, true)); + } + } + })); + + add((new field_str("reasoning_budget_message")) + ->set_desc("Message to prepend to the reasoning budget end tag when forcing it") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + if (!ctx.params.sampling.reasoning_budget_end.empty()) { + llama_tokens end_tag = ctx.params.sampling.reasoning_budget_end.front(); + std::string message = json_value(data, "reasoning_budget_message", std::string()); + if (!message.empty()) { + llama_tokens message_tokens = common_tokenize(ctx.vocab, message, false, true); + end_tag.insert(end_tag.begin(), message_tokens.begin(), message_tokens.end()); + } + ctx.params.sampling.reasoning_budget_forced = std::move(end_tag); + } + })); + + add((new field_json("logit_bias")) + ->set_desc("Modify the likelihood of specific tokens. Accepts an array of [token, bias] pairs or an object mapping token to bias. Use false as bias to ban a token") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.vocab != nullptr); + ctx.params.sampling.logit_bias.clear(); + const auto & logit_bias = data.at("logit_bias"); + const int n_vocab = llama_vocab_n_tokens(ctx.vocab); + auto parse_bias = [](const json & v, float & bias) -> bool { + if (v.is_number()) { bias = v.get(); return true; } + if (v.is_boolean() && !v.get()) { bias = -INFINITY; return true; } + return false; + }; + if (logit_bias.is_array()) { + for (const auto & el : logit_bias) { + if (!el.is_array() || el.size() != 2) continue; + float bias; + if (!parse_bias(el[1], bias)) continue; + if (el[0].is_number_integer()) { + llama_token tok = el[0].get(); + if (tok >= 0 && tok < n_vocab) ctx.params.sampling.logit_bias.push_back({tok, bias}); + } else if (el[0].is_string()) { + for (auto tok : common_tokenize(ctx.vocab, el[0].get(), false)) + ctx.params.sampling.logit_bias.push_back({tok, bias}); + } + } + } else if (logit_bias.is_object()) { + for (const auto & el : logit_bias.items()) { + float bias; + if (!parse_bias(el.value(), bias)) continue; + char * end; + llama_token tok = strtol(el.key().c_str(), &end, 10); + if (*end == 0) { + if (tok >= 0 && tok < n_vocab) ctx.params.sampling.logit_bias.push_back({tok, bias}); + } else { + for (auto t : common_tokenize(ctx.vocab, el.key(), false)) + ctx.params.sampling.logit_bias.push_back({t, bias}); + } + } + } + })); + + add((new field_bool("ignore_eos", params.sampling.ignore_eos)) + ->set_desc("Ignore the end-of-sequence token and continue generating") + ->set_handler([&](field_eval_context & ctx, const json & data) { + GGML_ASSERT(ctx.logit_bias_eog != nullptr); + ctx.params.sampling.ignore_eos = data.at("ignore_eos").get(); + if (ctx.params.sampling.ignore_eos && ctx.logit_bias_eog) { + ctx.params.sampling.logit_bias.insert( + ctx.params.sampling.logit_bias.end(), + ctx.logit_bias_eog->begin(), ctx.logit_bias_eog->end()); + } + })); + + add((new field_json("stop")) + ->set_desc("Specify stopping strings. Generation stops when one is produced, and the string is not included in the output") + ->set_handler([&](field_eval_context & ctx, const json & data) { + ctx.params.antiprompt.clear(); + const auto & stop = data.at("stop"); + if (stop.is_array()) { + for (const auto & word : stop) { + if (!word.empty()) ctx.params.antiprompt.push_back(word); + } + } else if (stop.is_string()) { + ctx.params.antiprompt.push_back(stop.get()); + } + // fall back to CLI defaults if the request provided no effective stop strings + if (ctx.params.antiprompt.empty()) { + ctx.params.antiprompt = params_base.antiprompt; + } + })); + + add((new field_json("samplers")) + ->set_desc("The order in which samplers are applied. An array of sampler type names, or a single string of sampler chars") + ->set_handler([&](field_eval_context & ctx, const json & data) { + const auto & samplers = data.at("samplers"); + if (samplers.is_array()) { + ctx.params.sampling.samplers = common_sampler_types_from_names(samplers); + } else if (samplers.is_string()) { + ctx.params.sampling.samplers = common_sampler_types_from_chars(samplers.get()); + } + })); + + return fields; +} + +task_params eval_llama_cmpl_schema( + const llama_vocab * vocab, + const common_params & params_base, + const std::vector & logit_bias_eog, + const json & data) { + task_params params; + + // Sampling parameter defaults are loaded from the global server context (but individual requests can still override them) + params.sampling = params_base.sampling; + params.speculative = params_base.speculative; + params.n_keep = params_base.n_keep; + params.n_predict = params_base.n_predict; + params.n_cache_reuse = params_base.n_cache_reuse; + params.cache_prompt = params_base.cache_prompt; + params.antiprompt = params_base.antiprompt; + params.sse_ping_interval = params_base.sse_ping_interval; + + // enabling this will output extra debug information in the HTTP responses from the server + params.verbose = params_base.verbosity > 9; + + params.chat_parser_params.reasoning_format = params_base.reasoning_format; + + // create context and schema + field_eval_context ctx(params); + ctx.vocab = vocab; + ctx.logit_bias_eog = &logit_bias_eog; + + auto schema = make_llama_cmpl_schema(params_base, params); + + // eval all fields in the schema + for (const auto & f : schema) { + f->eval(ctx, data); + } + + // post-processing + { + // if "reasoning_format" is not provided, its handler will not be called, we will need to handle it here + auto reasoning_format = params.chat_parser_params.reasoning_format; + params.chat_parser_params.reasoning_in_content = params.stream && (reasoning_format == COMMON_REASONING_FORMAT_DEEPSEEK_LEGACY); + } + + // debugging + { + auto budget = params.sampling.reasoning_budget_tokens; + SRV_DBG("reasoning budget: tokens=%d, generation_prompt='%s', start=%zu toks, end=%zu seqs, forced=%zu toks\n", + budget, params.sampling.generation_prompt.c_str(), + params.sampling.reasoning_budget_start.size(), + params.sampling.reasoning_budget_end.size(), + params.sampling.reasoning_budget_forced.size()); + } + + return params; +} + +// +// eval() implementations +// + +static void handle_with_catch(const char * name, std::function func) { + try { + func(); + } catch (const std::exception & e) { + throw std::invalid_argument(string_format("Field '%s': %s", name, e.what())); + } +} + +// treat a null value as absent so clients can send null to request the server default +static bool has_value(const json & data, const char * n) { + auto it = data.find(n); + return it != data.end() && !it->is_null(); +} + +template +void field_num::eval(field_eval_context & ctx, const json & data) { + for (const auto & n : name) { + if (has_value(data, n)) { + handle_with_catch(n, [&]() { + if (custom_handler) { + custom_handler(ctx, data); + } else if (!is_hard_limit) { + val = std::max(min, std::min(max, data.at(n).template get())); + } else { + T tmp = data.at(n).template get(); + if (tmp < min || tmp > max) { + throw std::invalid_argument(std::string("Value must be between ") + std::to_string(min) + " <= value <= " + std::to_string(max) + ", but got " + std::to_string(tmp)); + } + val = tmp; + } + }); + return; + } + } +} + +void field_str::eval(field_eval_context & ctx, const json & data) { + GGML_ASSERT(custom_handler); + for (const auto & n : name) { + if (has_value(data, n)) { + handle_with_catch(n, [&]() { + custom_handler(ctx, data); + }); + return; + } + } +} + +void field_bool::eval(field_eval_context & ctx, const json & data) { + for (const auto & n : name) { + if (has_value(data, n)) { + handle_with_catch(n, [&]() { + if (custom_handler) { + custom_handler(ctx, data); + } else { + val = data.at(n).get(); + } + }); + return; + } + } +} + +void field_json::eval(field_eval_context & ctx, const json & data) { + GGML_ASSERT(custom_handler); + for (const auto & n : name) { + if (has_value(data, n)) { + handle_with_catch(n, [&]() { + custom_handler(ctx, data); + }); + return; + } + } +} + +void field_nested::eval(field_eval_context & ctx, const json & data) { + for (const auto & n : name) { + if (data.contains(n) && data.at(n).is_object()) { + for (auto & f : subfields) { + f->eval(ctx, data.at(n)); + } + return; + } + } +} + +} // namespace server_schema diff --git a/tools/server/server-schema.h b/tools/server/server-schema.h new file mode 100644 index 0000000000000000000000000000000000000000..d0a81431bc6b11c9b2cbc1277280e5fd7cb6ece0 --- /dev/null +++ b/tools/server/server-schema.h @@ -0,0 +1,104 @@ +#pragma once + +#include "server-common.h" +#include "server-task.h" + +#include "sampling.h" +#include "speculative.h" + +#include +#include +#include +#include +#include +#include + +namespace server_schema { + +struct field_eval_context { + task_params & params; + const llama_vocab * vocab = nullptr; + const std::vector * logit_bias_eog = nullptr; + field_eval_context(task_params & params) : params(params) {} +}; + +using field_handler = std::function; + +struct field { + std::vector name; + const char * desc = ""; + field_handler custom_handler; + field() = default; + field(const char * n) : name({n}) {} + virtual ~field() = default; + field * set_desc(const char * s) { + desc = s; + return this; + } + // if 'name' is present, use it, otherwise look for aliases following the order they were added + field * add_alias(const char * n) { + name.push_back(n); + return this; + } + field * set_handler(field_handler h) { this->custom_handler = h; return this; } + virtual void eval(field_eval_context & ctx, const json & data) = 0; +}; + +template +struct field_num : public field { + T & val; + T min = std::numeric_limits::lowest(); + T max = std::numeric_limits::max(); + bool is_hard_limit = false; // if true, throw error if the value is invalid + field_num(const char * n, T & val) : field(n), val(val) {} + // limits are inclusive, min <= value <= max + field_num * set_limits(T min, T max) { + this->min = min; + this->max = max; + return this; + } + field_num * set_hard_limits(T min, T max) { + set_limits(min, max); + is_hard_limit = true; + return this; + } + virtual void eval(field_eval_context & ctx, const json & data) override; +}; + +struct field_str : public field { + field_str(const char * n) : field(n) {} + virtual void eval(field_eval_context & ctx, const json & data) override; +}; + +struct field_bool : public field { + bool & val; + field_bool(const char * n, bool & val) : field(n), val(val) {} + virtual void eval(field_eval_context & ctx, const json & data) override; +}; + +struct field_json : public field { + field_json(const char * n) : field(n) {} + virtual void eval(field_eval_context & ctx, const json & data) override; +}; + +struct field_nested : public field { + std::vector> subfields; + field_nested(const char * n) : field(n) {} + field_nested * add_subfield(field * f) { + subfields.emplace_back(std::unique_ptr(f)); + return this; + } + virtual void eval(field_eval_context & ctx, const json & data) override; +}; + +std::vector> make_llama_cmpl_schema( + const common_params & params_base, + task_params & params); + +task_params eval_llama_cmpl_schema( + const llama_vocab * vocab, + const common_params & params_base, + const std::vector & logit_bias_eog, + const json & data); + +} // namespace server_schema diff --git a/tools/server/server-stream.cpp b/tools/server/server-stream.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f6b9b8a9f4cc5139faa07d44453163e4205da6f0 --- /dev/null +++ b/tools/server/server-stream.cpp @@ -0,0 +1,668 @@ +#include "server-stream.h" +#include "server-common.h" +#include "server-http.h" +#include "server-queue.h" + +#include +#include +#include +#include + +enum class stream_read_status { + OK, + OFFSET_LOST, +}; + +namespace { +constexpr int64_t STREAM_SESSION_TTL_SECONDS = 300; +constexpr size_t STREAM_SESSION_MAX_BYTES = 4 * 1024 * 1024; +constexpr int64_t STREAM_SESSION_GC_INTERVAL_SECONDS = 60; +constexpr int64_t STREAM_READ_WAKE_INTERVAL_MS = 200; + +int64_t now_seconds() { + return std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch() + ).count(); +} +} + +// owns all live sessions keyed by conversation_id, one conv = at most one live session. +// a periodic GC evicts expired ones +class stream_session_manager { +public: + stream_session_manager(); + ~stream_session_manager(); + + stream_session_manager(const stream_session_manager &) = delete; + stream_session_manager & operator=(const stream_session_manager &) = delete; + + // install a new session, evicting and cancelling any previous one. conversation_id must be non empty + stream_session_ptr create_or_replace(const std::string & conversation_id); + + stream_session_ptr get(const std::string & conversation_id); + + std::vector list_all() const; + + void evict(const std::string & conversation_id); + + void evict_and_cancel(const std::string & conversation_id); + + void start_gc(); + void stop_gc(); + +private: + void gc_loop(); + + mutable std::shared_mutex map_mu; + std::unordered_map sessions; // key: conversation_id + std::thread gc_thread; + bool running; + std::mutex gc_wake_mu; + std::condition_variable gc_wake_cv; +}; + +// process wide manager, lifecycle controlled by llama-server main() via start_gc/stop_gc +static stream_session_manager g_stream_sessions; + +void server_stream_session_manager_start() { + g_stream_sessions.start_gc(); +} + +void server_stream_session_manager_stop() { + g_stream_sessions.stop_gc(); +} + +struct stream_session { + std::string conversation_id; + int64_t started_ts; // unix seconds at construction + + stream_session(std::string conversation_id_, size_t max_bytes_); + stream_session(const stream_session &) = delete; + stream_session & operator=(const stream_session &) = delete; + + bool append(const char * data, size_t len); + + void finalize(); + + // drain from offset into sink, blocking for more bytes or finalize. OFFSET_LOST if offset + // fell below the dropped prefix + stream_read_status read_from(size_t offset, + const std::function & sink, + const std::function & should_stop); + + bool is_done() const; + bool is_cancelled() const; + size_t total_size() const; // bytes that ever entered the session + size_t dropped_prefix() const; // bytes evicted from the front due to cap + int64_t completed_at() const; // 0 while alive, unix seconds after finalize + + void cancel(); + +private: + mutable std::mutex mu; + std::condition_variable cv; + std::vector buffer; + size_t prefix_dropped; + size_t cap_bytes; + bool done; + std::atomic cancelled; // polled lock-free by the should_stop closure, no mu + int64_t completed_ts; +}; +stream_session::stream_session(std::string conversation_id_, size_t max_bytes_) + : conversation_id(std::move(conversation_id_)) + , started_ts(now_seconds()) + , prefix_dropped(0) + , cap_bytes(max_bytes_) + , done(false) + , cancelled(false) + , completed_ts(0) { + buffer.reserve(64 * 1024); +} + +bool stream_session::append(const char * data, size_t len) { + if (len == 0) { + return true; + } + { + std::lock_guard lock(mu); + if (done) { + return false; + } + if (len >= cap_bytes) { + // single chunk bigger than the cap, keep only the tail that fits + size_t skip = len - cap_bytes; + prefix_dropped += buffer.size() + skip; + buffer.clear(); + buffer.insert(buffer.end(), data + skip, data + len); + } else { + size_t needed = buffer.size() + len; + if (needed > cap_bytes) { + size_t to_drop = needed - cap_bytes; + buffer.erase(buffer.begin(), buffer.begin() + to_drop); + prefix_dropped += to_drop; + } + buffer.insert(buffer.end(), data, data + len); + } + } + cv.notify_all(); + return true; +} + +void stream_session::finalize() { + { + std::lock_guard lock(mu); + if (done) { + return; + } + done = true; + completed_ts = now_seconds(); + } + cv.notify_all(); +} + +stream_read_status stream_session::read_from(size_t offset, + const std::function & sink, + const std::function & should_stop) { + std::unique_lock lock(mu); + while (true) { + if (should_stop && should_stop()) { + return stream_read_status::OK; + } + if (offset < prefix_dropped) { + return stream_read_status::OFFSET_LOST; + } + size_t logical_end = prefix_dropped + buffer.size(); + if (offset < logical_end) { + size_t local_off = offset - prefix_dropped; + size_t n = buffer.size() - local_off; + // copy the available chunk under the lock, release before calling the sink + std::vector chunk(buffer.begin() + local_off, buffer.begin() + local_off + n); + offset += n; + lock.unlock(); + bool keep_going = sink(chunk.data(), chunk.size()); + if (!keep_going) { + return stream_read_status::OK; + } + lock.lock(); + continue; + } + if (done) { + return stream_read_status::OK; + } + // wait for new bytes, finalize, or a periodic wake to re check should_stop + cv.wait_for(lock, std::chrono::milliseconds(STREAM_READ_WAKE_INTERVAL_MS)); + } +} + +bool stream_session::is_done() const { + std::lock_guard lock(mu); + return done; +} + +size_t stream_session::total_size() const { + std::lock_guard lock(mu); + return prefix_dropped + buffer.size(); +} + +size_t stream_session::dropped_prefix() const { + std::lock_guard lock(mu); + return prefix_dropped; +} + +int64_t stream_session::completed_at() const { + std::lock_guard lock(mu); + return completed_ts; +} + +void stream_session::cancel() { + // the should_stop closure on both the producer and any HTTP reader polls is_cancelled() + // so flipping this is the only signal needed to unwind both sides + cancelled.store(true, std::memory_order_release); +} + +bool stream_session::is_cancelled() const { + return cancelled.load(std::memory_order_acquire); +} + +stream_session_manager::stream_session_manager() + : running(false) { +} + +stream_session_manager::~stream_session_manager() { + stop_gc(); +} + +stream_session_ptr stream_session_manager::create_or_replace(const std::string & conversation_id) { + // evict any previous session on the same conv, this guarantees the invariant + // "one conv = at most one live session" and propagates cancel to its producer + stream_session_ptr previous; + auto fresh = std::make_shared(conversation_id, STREAM_SESSION_MAX_BYTES); + { + std::unique_lock lock(map_mu); + auto it = sessions.find(conversation_id); + if (it != sessions.end()) { + previous = it->second; + it->second = fresh; + } else { + sessions.emplace(conversation_id, fresh); + } + } + if (previous) { + previous->cancel(); + previous->finalize(); + } + return fresh; +} + +stream_session_ptr stream_session_manager::get(const std::string & conversation_id) { + std::shared_lock lock(map_mu); + auto it = sessions.find(conversation_id); + if (it == sessions.end()) { + return nullptr; + } + return it->second; +} + +std::vector stream_session_manager::list_all() const { + std::vector out; + std::shared_lock lock(map_mu); + out.reserve(sessions.size()); + for (auto & kv : sessions) { + out.push_back(kv.second); + } + return out; +} + +void stream_session_manager::evict(const std::string & conversation_id) { + stream_session_ptr s; + { + std::unique_lock lock(map_mu); + auto it = sessions.find(conversation_id); + if (it == sessions.end()) { + return; + } + s = it->second; + sessions.erase(it); + } + // finalize outside the map lock so any pending readers wake up and exit + s->finalize(); +} + +void stream_session_manager::evict_and_cancel(const std::string & conversation_id) { + stream_session_ptr s; + { + std::unique_lock lock(map_mu); + auto it = sessions.find(conversation_id); + if (it == sessions.end()) { + std::string live; + for (const auto & kv : sessions) { + if (!live.empty()) live += ", "; + live += kv.first; + } + SRV_WRN("stop on unknown stream session, conv_id=%s matched nothing, %zu live: [%s]\n", + conversation_id.c_str(), sessions.size(), live.c_str()); + return; + } + s = it->second; + sessions.erase(it); + } + // cancel first so the producer's on_complete() drain loop and any pending HTTP reader + // observe is_cancelled() and stop pulling further output, then finalize to wake readers + // blocked in read_from(). note: this does not interrupt the underlying generation itself, + // which keeps running to its own natural stop condition (EOS/max_tokens) + s->cancel(); + s->finalize(); +} + +void stream_session_manager::start_gc() { + { + std::lock_guard lock(gc_wake_mu); + if (running) { + return; + } + running = true; + } + gc_thread = std::thread([this] { gc_loop(); }); +} + +void stream_session_manager::stop_gc() { + bool was_running; + { + std::lock_guard lock(gc_wake_mu); + was_running = running; + running = false; + } + if (was_running) { + gc_wake_cv.notify_all(); + if (gc_thread.joinable()) { + gc_thread.join(); + } + } + // finalize all live sessions so no reader ever hangs + std::vector snapshot; + { + std::unique_lock lock(map_mu); + snapshot.reserve(sessions.size()); + for (auto & kv : sessions) { + snapshot.push_back(kv.second); + } + sessions.clear(); + } + for (auto & s : snapshot) { + s->finalize(); + } +} + +void stream_session_manager::gc_loop() { + while (true) { + { + std::unique_lock lock(gc_wake_mu); + gc_wake_cv.wait_for(lock, + std::chrono::seconds(STREAM_SESSION_GC_INTERVAL_SECONDS), + [this] { return !running; }); + if (!running) { + return; + } + } + int64_t cutoff = now_seconds() - STREAM_SESSION_TTL_SECONDS; + std::vector to_drop; + { + std::unique_lock lock(map_mu); + for (auto it = sessions.begin(); it != sessions.end(); ) { + int64_t completed = it->second->completed_at(); + if (completed != 0 && completed <= cutoff) { + to_drop.push_back(it->second); + it = sessions.erase(it); + } else { + ++it; + } + } + } + // finalize outside the map lock, idempotent if the session was already done + for (auto & s : to_drop) { + s->finalize(); + } + } +} + +// stream_pipe + +// consumer end: read-only replay of the ring buffer, the destructor does not finalize the session +struct stream_pipe_consumer : stream_pipe { + stream_read_status read(size_t & offset, + const std::function & sink, + const std::function & should_stop); + + static std::shared_ptr create(stream_session_ptr session); + +private: + explicit stream_pipe_consumer(stream_session_ptr session); +}; + +stream_pipe::stream_pipe(stream_session_ptr session) + : session_(std::move(session)) { +} + +bool stream_pipe::is_cancelled() const { + return session_->is_cancelled(); +} + +// stream_pipe_producer + +stream_pipe_producer::stream_pipe_producer(stream_session_ptr session) + : stream_pipe(std::move(session)) { +} + +stream_pipe_producer::~stream_pipe_producer() { + session_->finalize(); +} + +bool stream_pipe_producer::write(const char * data, size_t len) { + return session_->append(data, len); +} + +stream_pipe_producer * stream_pipe_producer::create(stream_session_ptr session) { + return new stream_pipe_producer(std::move(session)); +} + +// stream_pipe_consumer + +stream_pipe_consumer::stream_pipe_consumer(stream_session_ptr session) + : stream_pipe(std::move(session)) { +} + +stream_read_status stream_pipe_consumer::read(size_t & offset, + const std::function & sink, + const std::function & should_stop) { + return session_->read_from(offset, sink, should_stop); +} + +std::shared_ptr stream_pipe_consumer::create(stream_session_ptr session) { + return std::shared_ptr(new stream_pipe_consumer(std::move(session))); +} + +// helper, builds the standard error response and assigns it to a brand new http_res +static server_http_res_ptr make_error_response(int status, const std::string & message, error_type type) { + auto res = std::make_unique(); + json err = format_error_response(message, type); + res->status = json_value(err, "code", status); + res->content_type = "application/json; charset=utf-8"; + res->data = safe_json_to_str({{"error", err}}); + return res; +} + +server_http_context::handler_t server_stream_make_get_handler() { + return [](const server_http_req & req) -> server_http_res_ptr { + // GET /v1/stream?conv_id=&from=N replays buffered SSE bytes then blocks for live + // bytes until the session finalizes, streamed as text/event-stream for EventSource + std::string conv_id = req.get_param("conv_id"); + if (conv_id.empty()) { + return make_error_response(400, "Missing conversation id in path", ERROR_TYPE_INVALID_REQUEST); + } + auto session = g_stream_sessions.get(conv_id); + if (!session) { + return make_error_response(404, "Stream not found or expired", ERROR_TYPE_NOT_FOUND); + } + size_t from = 0; + std::string from_str = req.get_param("from"); + if (!from_str.empty()) { + try { + from = static_cast(std::stoull(from_str)); + } catch (const std::exception &) { + return make_error_response(400, "Invalid 'from' offset", ERROR_TYPE_INVALID_REQUEST); + } + } + if (from < session->dropped_prefix()) { + return make_error_response(400, "Stream offset lost, please restart", ERROR_TYPE_INVALID_REQUEST); + } + auto res = std::make_unique(); + res->status = 200; + res->content_type = "text/event-stream"; + // the next closure reads from the ring buffer at the requested offset, blocks until + // bytes arrive or the session finalizes. exit each call after draining the available + // chunk so set_chunked_content_provider gets a chance to flush to the socket + auto offset_ptr = std::make_shared(from); + // consumer pipe: read-only, does not finalize the session on destruction + auto pipe = stream_pipe_consumer::create(session); + res->next = [pipe, offset_ptr, &req](std::string & output) -> bool { + bool got_any = false; + pipe->read(*offset_ptr, + [&](const char * d, size_t n) { + output.append(d, n); + *offset_ptr += n; + got_any = true; + return false; + }, + req.should_stop); + return got_any; + }; + return res; + }; +} + +server_http_context::handler_t server_stream_make_lookup_handler() { + return [](const server_http_req & req) -> server_http_res_ptr { + // POST /v1/streams/lookup returns the matching sessions, only for ids the caller already + // knows. each id matches the exact key and any "::" per model variant + std::vector requested; + try { + json body = json::parse(req.body); + if (body.contains("conversation_ids") && body["conversation_ids"].is_array()) { + for (const auto & v : body["conversation_ids"]) { + if (v.is_string()) { + std::string id = v.get(); + if (!id.empty()) { + requested.push_back(std::move(id)); + } + } + } + } + } catch (const std::exception & e) { + auto res = std::make_unique(); + res->status = 400; + res->content_type = "application/json; charset=utf-8"; + res->data = safe_json_to_str({{"error", {{"message", std::string("invalid body: ") + e.what()}, + {"type", "invalid_request_error"}}}}); + return res; + } + + std::vector sessions; + if (!requested.empty()) { + auto all = g_stream_sessions.list_all(); + for (const auto & rid : requested) { + const std::string with_sep = rid + "::"; + for (auto & s : all) { + if (s->conversation_id == rid || + s->conversation_id.compare(0, with_sep.size(), with_sep) == 0) { + sessions.push_back(s); + } + } + } + } + + json arr = json::array(); + for (auto & s : sessions) { + arr.push_back({ + {"conversation_id", s->conversation_id}, + {"is_done", s->is_done()}, + {"total_bytes", s->total_size()}, + {"started_at", s->started_ts}, + {"completed_at", s->completed_at()}, + }); + } + auto res = std::make_unique(); + res->status = 200; + res->content_type = "application/json; charset=utf-8"; + res->data = safe_json_to_str(arr); + return res; + }; +} + +server_http_context::handler_t server_stream_make_delete_handler() { + return [](const server_http_req & req) -> server_http_res_ptr { + // DELETE /v1/stream?conv_id= is the explicit user Stop, cancels the producer and evicts + // the buffer. idempotent, returns 204 even if the session was already gone + std::string conv_id = req.get_param("conv_id"); + if (conv_id.empty()) { + return make_error_response(400, "Missing conversation id in path", ERROR_TYPE_INVALID_REQUEST); + } + SRV_TRC("DELETE /v1/stream conv_id=%s -> evict_and_cancel\n", conv_id.c_str()); + g_stream_sessions.evict_and_cancel(conv_id); + auto res = std::make_unique(); + res->status = 204; + res->content_type = "application/json"; + return res; + }; +} + +std::string server_stream_conv_id_from_headers(const std::map & headers) { + // case-insensitive scan for x-conversation-id + static constexpr char target[] = "x-conversation-id"; + static constexpr size_t target_len = sizeof(target) - 1; + for (const auto & [hk, hv] : headers) { + if (hk.size() != target_len) continue; + bool match = true; + for (size_t i = 0; i < target_len; ++i) { + char c = hk[i]; + if (c >= 'A' && c <= 'Z') c = char(c + 32); + if (c != target[i]) { match = false; break; } + } + if (match) { + return hv; + } + } + return std::string(); +} + +static stream_pipe_producer * server_stream_create_spipe(const std::map & headers) { + std::string conversation_id = server_stream_conv_id_from_headers(headers); + SRV_TRC("conv_id=%s (empty=%d)\n", conversation_id.c_str(), conversation_id.empty() ? 1 : 0); + if (conversation_id.empty()) { + return nullptr; + } + auto session = g_stream_sessions.create_or_replace(conversation_id); + return stream_pipe_producer::create(session); +} + +// +// server_res_spipe +// + +void server_res_spipe::set_req(const server_http_req * req) { + this->req = req; + // optionally attach spipe to the response when X-Conversation-Id is present + spipe.reset(server_stream_create_spipe(req->headers)); +} + +bool server_res_spipe::conn_alive() { + GGML_ASSERT(req != nullptr); + return !req->should_stop(); +} + +bool server_res_spipe::should_stop() { + if (spipe) { + // note: if DELETE /v1/stream is called for this conv, is_cancelled() will be true + return spipe->is_cancelled(); + } else { + return !conn_alive(); + } +} + +void server_res_spipe::on_complete() { + if (!spipe || next_finished) { + return; + } + // an empty next_orig means set_next() never ran: the request failed before streaming + // started, typically a params validation throw. evict the session installed by set_req() + // so the failed request leaves nothing behind for discovery or replay + if (!next_orig) { + g_stream_sessions.evict(server_stream_conv_id_from_headers(req->headers)); + return; + } + std::string chunk; + while (!spipe->is_cancelled()) { + chunk.clear(); + bool has_next = next_orig(chunk); + if (!chunk.empty()) { + spipe->write(chunk.data(), chunk.size()); + } + if (!has_next) { + break; + } + } +} + +void server_res_spipe::set_next(std::function next_fn) { + next_orig = std::move(next_fn); + next = [this](std::string & out) { + bool has_next = next_orig(out); + if (spipe) { + // if spipe is set, tee-style pipe input to both HTTP and spipe + spipe->write(out.data(), out.size()); + } + if (!has_next) { + next_finished = true; + } + return has_next; + }; +} diff --git a/tools/server/server-stream.h b/tools/server/server-stream.h new file mode 100644 index 0000000000000000000000000000000000000000..1e7461285f43557d893735188a5944e730b0cdca --- /dev/null +++ b/tools/server/server-stream.h @@ -0,0 +1,79 @@ +#pragma once + +#include "server-http.h" + +#include +#include +#include +#include +#include + +// streaming buffer for one generation, survives HTTP disconnect. the producer appends SSE bytes, +// readers drain from any offset via read_from. keyed by conversation_id, one conv = one live session + +struct stream_session; + +using stream_session_ptr = std::shared_ptr; + +// base of the producer/consumer pipe ends. virtual dtor so each runs its own teardown: +// the producer finalizes the session, the consumer leaves it untouched +struct stream_pipe { + virtual ~stream_pipe() = default; + + bool is_cancelled() const; + +protected: + explicit stream_pipe(stream_session_ptr session); + + stream_session_ptr session_; +}; + +// producer end: writes chunks into the ring buffer and owns the session lifetime, finalizing it +// on destruction. +struct stream_pipe_producer : stream_pipe { + ~stream_pipe_producer() override; + + bool write(const char * data, size_t len); + + static stream_pipe_producer * create(stream_session_ptr session); + +private: + explicit stream_pipe_producer(stream_session_ptr session); +}; + +void server_stream_session_manager_start(); +void server_stream_session_manager_stop(); + +// route handler factories wired under /v1/stream/* by server.cpp +// child-side handlers for the resumable stream routes. the conv id travels in the conv_id +// query string because it can embed a model name containing slashes (org/repo), which the +// decoded path would split before the param is captured +server_http_context::handler_t server_stream_make_get_handler(); +// POST /v1/streams/lookup with body {"conversation_ids": [...]}: only answers for ids the +// caller already owns (the WebUI passes the convs visible in its sidebar), the server never +// lists ids it has not been asked about, so a random caller cannot enumerate live sessions +server_http_context::handler_t server_stream_make_lookup_handler(); +server_http_context::handler_t server_stream_make_delete_handler(); + +// extract the X-Conversation-Id header value (case-insensitive), empty when absent +std::string server_stream_conv_id_from_headers(const std::map & headers); + +// implement tee-style pipe (spipe) for "stream replay" functionality +struct server_res_spipe : server_http_res { +private: + // if set, the stream survives a client disconnect: + // connection kept alive, output is forwarded to spipe and reuse later + std::unique_ptr spipe; + // if spipe is set, use this next_orig to implement tee-style pipe + std::function next_orig; + const server_http_req * req = nullptr; + // set once next_orig reports no more data, so on_complete() doesn't re-drain a finished stream + bool next_finished = false; + +public: + void set_req(const server_http_req * req); + bool conn_alive(); + bool should_stop(); + void on_complete() override; + void set_next(std::function next_fn); +}; diff --git a/tools/server/server-task.cpp b/tools/server/server-task.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1ee67755307c7f9efc342b995ef6fcbf96168c18 --- /dev/null +++ b/tools/server/server-task.cpp @@ -0,0 +1,1854 @@ +#include "server-task.h" + +#include "build-info.h" +#include "server-chat.h" +#include "chat.h" +#include "common.h" +#include "json-schema-to-grammar.h" +#include "llama.h" +#include "sampling.h" +#include "speculative.h" +#include "server-common.h" + +using json = nlohmann::ordered_json; + +// +// task_params +// + +json task_params::format_logit_bias(const std::vector & logit_bias) const { + json data = json::array(); + for (const auto & lb : logit_bias) { + data.push_back(json{ + {"bias", lb.bias}, + {"token", lb.token}, + }); + } + return data; +} + +json task_params::to_json(bool only_metrics) const { + std::vector samplers; + samplers.reserve(sampling.samplers.size()); + for (const auto & sampler : sampling.samplers) { + samplers.emplace_back(common_sampler_type_to_str(sampler)); + } + + json lora = json::array(); + for (auto & it : this->lora) { + lora.push_back({{"id", it.first}, {"scale", it.second}}); + } + + if (only_metrics) { + return json { + {"seed", sampling.seed}, + {"temperature", sampling.temp}, + {"dynatemp_range", sampling.dynatemp_range}, + {"dynatemp_exponent", sampling.dynatemp_exponent}, + {"top_k", sampling.top_k}, + {"top_p", sampling.top_p}, + {"min_p", sampling.min_p}, + {"top_n_sigma", sampling.top_n_sigma}, + {"xtc_probability", sampling.xtc_probability}, + {"xtc_threshold", sampling.xtc_threshold}, + {"typical_p", sampling.typ_p}, + {"repeat_last_n", sampling.penalty_last_n}, + {"repeat_penalty", sampling.penalty_repeat}, + {"presence_penalty", sampling.penalty_present}, + {"frequency_penalty", sampling.penalty_freq}, + {"dry_multiplier", sampling.dry_multiplier}, + {"dry_base", sampling.dry_base}, + {"dry_allowed_length", sampling.dry_allowed_length}, + {"dry_penalty_last_n", sampling.dry_penalty_last_n}, + {"mirostat", sampling.mirostat}, + {"mirostat_tau", sampling.mirostat_tau}, + {"mirostat_eta", sampling.mirostat_eta}, + {"adaptive_target", sampling.adaptive_target}, + {"adaptive_decay", sampling.adaptive_decay}, + {"max_tokens", n_predict}, + {"n_predict", n_predict}, // TODO: deduplicate? + {"n_keep", n_keep}, + {"n_discard", n_discard}, + {"ignore_eos", sampling.ignore_eos}, + {"stream", stream}, + {"n_probs", sampling.n_probs}, + {"min_keep", sampling.min_keep}, + {"chat_format", common_chat_format_name(chat_parser_params.format)}, + {"reasoning_format", common_reasoning_format_name(chat_parser_params.reasoning_format)}, + {"reasoning_in_content", chat_parser_params.reasoning_in_content}, + {"generation_prompt", chat_parser_params.generation_prompt}, + {"samplers", samplers}, + {"speculative.types", common_speculative_type_name_str(speculative.types)}, + {"timings_per_token", timings_per_token}, + {"post_sampling_probs", post_sampling_probs}, + {"backend_sampling", sampling.backend_sampling}, + {"lora", lora}, + }; + } + + auto grammar_triggers = json::array(); + for (const auto & trigger : sampling.grammar_triggers) { + server_grammar_trigger ct(trigger); + grammar_triggers.push_back(ct.to_json()); + } + + return json { + {"seed", sampling.seed}, + {"temperature", sampling.temp}, + {"dynatemp_range", sampling.dynatemp_range}, + {"dynatemp_exponent", sampling.dynatemp_exponent}, + {"top_k", sampling.top_k}, + {"top_p", sampling.top_p}, + {"min_p", sampling.min_p}, + {"top_n_sigma", sampling.top_n_sigma}, + {"xtc_probability", sampling.xtc_probability}, + {"xtc_threshold", sampling.xtc_threshold}, + {"typical_p", sampling.typ_p}, + {"repeat_last_n", sampling.penalty_last_n}, + {"repeat_penalty", sampling.penalty_repeat}, + {"presence_penalty", sampling.penalty_present}, + {"frequency_penalty", sampling.penalty_freq}, + {"dry_multiplier", sampling.dry_multiplier}, + {"dry_base", sampling.dry_base}, + {"dry_allowed_length", sampling.dry_allowed_length}, + {"dry_penalty_last_n", sampling.dry_penalty_last_n}, + {"dry_sequence_breakers", sampling.dry_sequence_breakers}, + {"mirostat", sampling.mirostat}, + {"mirostat_tau", sampling.mirostat_tau}, + {"mirostat_eta", sampling.mirostat_eta}, + {"adaptive_target", sampling.adaptive_target}, + {"adaptive_decay", sampling.adaptive_decay}, + {"stop", antiprompt}, + {"max_tokens", n_predict}, + {"n_predict", n_predict}, // TODO: deduplicate? + {"n_keep", n_keep}, + {"n_discard", n_discard}, + {"ignore_eos", sampling.ignore_eos}, + {"stream", stream}, + {"logit_bias", format_logit_bias(sampling.logit_bias)}, + {"n_probs", sampling.n_probs}, + {"min_keep", sampling.min_keep}, + {"grammar", common_grammar_value(sampling.grammar)}, + {"grammar_lazy", sampling.grammar_lazy}, + {"grammar_triggers", grammar_triggers}, + {"preserved_tokens", sampling.preserved_tokens}, + {"chat_format", common_chat_format_name(chat_parser_params.format)}, + {"reasoning_format", common_reasoning_format_name(chat_parser_params.reasoning_format)}, + {"reasoning_in_content", chat_parser_params.reasoning_in_content}, + {"generation_prompt", chat_parser_params.generation_prompt}, + {"samplers", samplers}, + {"speculative.types", common_speculative_type_name_str(speculative.types)}, + {"timings_per_token", timings_per_token}, + {"post_sampling_probs", post_sampling_probs}, + {"backend_sampling", sampling.backend_sampling}, + {"lora", lora}, + }; +} + +// +// task_result_state +// +task_result_state::task_result_state(const common_chat_parser_params & chat_parser_params) + : chat_parser_params(chat_parser_params) + , oai_resp_id("resp_" + random_string()) + , oai_resp_reasoning_id("rs_" + random_string()) + , oai_resp_message_id("msg_" + random_string()) { + if (chat_parser_params.is_continuation && !chat_parser_params.echo) { + // initialize chat_msg to avoid emitting a delta containing the assistant prefill + chat_msg = common_chat_parse("", true, chat_parser_params); + } +} + +common_chat_msg task_result_state::update_chat_msg( + const std::string & text_added, + bool is_partial, + std::vector & diffs, + bool filter_tool_calls) { + generated_text += text_added; + auto msg_prv_copy = chat_msg; + //SRV_DBG("Parsing chat message: %s\n", generated_text.c_str()); + auto new_msg = common_chat_parse( + generated_text, + is_partial, + chat_parser_params); + if (!new_msg.empty()) { + new_msg.set_tool_call_ids(generated_tool_call_ids, gen_tool_call_id); + chat_msg = new_msg; + auto all_diffs = common_chat_msg_diff::compute_diffs(msg_prv_copy, chat_msg); + + if (!filter_tool_calls) { + diffs = std::move(all_diffs); + } else { + for (auto & d : all_diffs) { + // If this is a new type of delta, flush all currently pending tool call names + for (size_t i = 0; i < chat_msg.tool_calls.size(); ++i) { + if (sent_tool_call_names.count(i) || chat_msg.tool_calls[i].name.empty()) { + continue; + } + if (d.tool_call_index != i || !d.tool_call_delta.arguments.empty()) { + common_chat_msg_diff header; + header.tool_call_index = i; + header.tool_call_delta.id = chat_msg.tool_calls[i].id; + header.tool_call_delta.name = chat_msg.tool_calls[i].name; + diffs.push_back(std::move(header)); + sent_tool_call_names.insert(i); + } + } + + if (d.tool_call_index == std::string::npos) { + diffs.push_back(std::move(d)); + } else { + size_t i = d.tool_call_index; + if (sent_tool_call_names.count(i)) { + if (!d.tool_call_delta.arguments.empty()) { + d.tool_call_delta.name = ""; + d.tool_call_delta.id = ""; + diffs.push_back(std::move(d)); + } + } else { + // Not sent yet. + if (!d.tool_call_delta.arguments.empty() || !is_partial) { + d.tool_call_delta.name = chat_msg.tool_calls[i].name; + d.tool_call_delta.id = chat_msg.tool_calls[i].id; + diffs.push_back(std::move(d)); + sent_tool_call_names.insert(i); + } else { + // Suppress + } + } + } + } + // Final check at EOF + if (!is_partial) { + for (size_t i = 0; i < chat_msg.tool_calls.size(); ++i) { + if (!sent_tool_call_names.count(i) && !chat_msg.tool_calls[i].name.empty()) { + common_chat_msg_diff header; + header.tool_call_index = i; + header.tool_call_delta.id = chat_msg.tool_calls[i].id; + header.tool_call_delta.name = chat_msg.tool_calls[i].name; + diffs.push_back(std::move(header)); + sent_tool_call_names.insert(i); + } + } + } + } + } + return chat_msg; +} + +// + +// result_timings +// + +json result_timings::to_json() const { + json base = { + {"cache_n", cache_n}, + + {"prompt_n", prompt_n}, + {"prompt_ms", prompt_ms}, + {"prompt_per_token_ms", prompt_per_token_ms}, + {"prompt_per_second", prompt_per_second}, + + {"predicted_n", predicted_n}, + {"predicted_ms", predicted_ms}, + {"predicted_per_token_ms", predicted_per_token_ms}, + {"predicted_per_second", predicted_per_second}, + }; + + if (draft_n > 0) { + base["draft_n"] = draft_n; + base["draft_n_accepted"] = draft_n_accepted; + } + + return base; +} + +// +// result_prompt_progress +// +json result_prompt_progress::to_json() const { + return json { + {"total", total}, + {"cache", cache}, + {"processed", processed}, + {"time_ms", time_ms}, + }; +} + +static inline std::string stop_type_to_str(stop_type type) { + switch (type) { + case STOP_TYPE_EOS: return "eos"; + case STOP_TYPE_WORD: return "word"; + case STOP_TYPE_LIMIT: return "limit"; + default: return "none"; + } +} + +// +// completion_token_output +// + +json completion_token_output::to_json(bool post_sampling_probs) const { + json probs_for_token = json::array(); + for (const auto & p : probs) { + std::string txt(p.txt); + txt.resize(validate_utf8(txt)); + probs_for_token.push_back(json { + {"id", p.tok}, + {"token", txt}, + {"bytes", str_to_bytes(p.txt)}, + { + post_sampling_probs ? "prob" : "logprob", + post_sampling_probs ? p.prob : logarithm(p.prob) + }, + }); + } + return probs_for_token; +} + +json completion_token_output::probs_vector_to_json(const std::vector & probs, bool post_sampling_probs) { + json out = json::array(); + for (const auto & p : probs) { + std::string txt(p.text_to_send); + txt.resize(validate_utf8(txt)); + out.push_back(json { + {"id", p.tok}, + {"token", txt}, + {"bytes", str_to_bytes(p.text_to_send)}, + { + post_sampling_probs ? "prob" : "logprob", + post_sampling_probs ? p.prob : logarithm(p.prob) + }, + { + post_sampling_probs ? "top_probs" : "top_logprobs", + p.to_json(post_sampling_probs) + }, + }); + } + return out; +} + +float completion_token_output::logarithm(float x) { + // nlohmann::json converts -inf to null, so we need to prevent that + return x == 0.0f ? std::numeric_limits::lowest() : std::log(x); +} + +std::vector completion_token_output::str_to_bytes(const std::string & str) { + std::vector bytes; + for (unsigned char c : str) { + bytes.push_back(c); + } + return bytes; +} + +// +// server_task_result_cmpl_final +// +json server_task_result_cmpl_final::to_json() { + GGML_ASSERT(is_updated && "update() must be called before to_json()"); + switch (res_type) { + case TASK_RESPONSE_TYPE_NONE: + return to_json_non_oaicompat(); + case TASK_RESPONSE_TYPE_OAI_CMPL: + return to_json_oaicompat(); + case TASK_RESPONSE_TYPE_OAI_CHAT: + return stream ? to_json_oaicompat_chat_stream() : to_json_oaicompat_chat(); + case TASK_RESPONSE_TYPE_OAI_RESP: + return stream ? to_json_oaicompat_resp_stream() : to_json_oaicompat_resp(); + case TASK_RESPONSE_TYPE_OAI_ASR: + return to_json_oaicompat_asr(); + case TASK_RESPONSE_TYPE_ANTHROPIC: + return stream ? to_json_anthropic_stream() : to_json_anthropic(); + default: + GGML_ASSERT(false && "Invalid task_response_type"); + } +} + +json server_task_result_cmpl_final::to_json_non_oaicompat() { + json res = json { + {"index", index}, + {"content", content}, + {"tokens", tokens}, + {"id_slot", id_slot}, + {"stop", true}, + {"model", oaicompat_model}, + {"tokens_predicted", n_decoded}, + {"tokens_evaluated", n_prompt_tokens}, + {"generation_settings", generation_params.to_json()}, + {"prompt", prompt}, + {"has_new_line", has_new_line}, + {"truncated", truncated}, + {"stop_type", stop_type_to_str(stop)}, + {"stopping_word", stopping_word}, + {"tokens_cached", n_tokens_cached}, + {"timings", timings.to_json()}, + }; + if (!stream && !probs_output.empty()) { + res["completion_probabilities"] = completion_token_output::probs_vector_to_json(probs_output, post_sampling_probs); + } + return response_fields.empty() ? res : json_get_nested_values(response_fields, res); +} + +json server_task_result_cmpl_final::usage_json_oaicompat() { + return json { + {"completion_tokens", n_decoded}, + {"prompt_tokens", n_prompt_tokens}, + {"total_tokens", n_decoded + n_prompt_tokens}, + {"prompt_tokens_details", json { {"cached_tokens", n_prompt_tokens_cache} }}, + }; +} + +json server_task_result_cmpl_final::to_json_oaicompat() { + std::time_t t = std::time(0); + json logprobs = json(nullptr); // OAI default to null + if (!stream && probs_output.size() > 0) { + logprobs = json{ + {"content", completion_token_output::probs_vector_to_json(probs_output, post_sampling_probs)}, + }; + } + json finish_reason = "length"; + if (stop == STOP_TYPE_WORD || stop == STOP_TYPE_EOS) { + finish_reason = "stop"; + } + json res = json { + {"choices", json::array({ + json{ + {"text", content}, + {"index", index}, + {"logprobs", logprobs}, + {"finish_reason", finish_reason}, + } + })}, + {"created", t}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "text_completion"}, + {"usage", usage_json_oaicompat()}, + {"id", oaicompat_cmpl_id} + }; + + // extra fields for debugging purposes + if (verbose) { + res["__verbose"] = to_json_non_oaicompat(); + } + if (timings.prompt_n >= 0) { + res.push_back({"timings", timings.to_json()}); + } + + return res; +} + +json server_task_result_cmpl_final::to_json_oaicompat_chat() { + std::string finish_reason = "length"; + common_chat_msg msg; + if (!oaicompat_msg.empty()) { + msg = oaicompat_msg; + } else { + msg.role = "assistant"; + msg.content = content; + } + if (stop == STOP_TYPE_WORD || stop == STOP_TYPE_EOS) { + finish_reason = msg.tool_calls.empty() ? "stop" : "tool_calls"; + } + + json choice { + {"finish_reason", finish_reason}, + {"index", index}, + {"message", msg.to_json_oaicompat()}, + }; + + if (!stream && probs_output.size() > 0) { + choice["logprobs"] = json{ + {"content", completion_token_output::probs_vector_to_json(probs_output, post_sampling_probs)}, + }; + } + + std::time_t t = std::time(0); + + json res = json { + {"choices", json::array({choice})}, + {"created", t}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "chat.completion"}, + {"usage", usage_json_oaicompat()}, + {"id", oaicompat_cmpl_id} + }; + + // extra fields for debugging purposes + if (verbose) { + res["__verbose"] = to_json_non_oaicompat(); + } + if (timings.prompt_n >= 0) { + res.push_back({"timings", timings.to_json()}); + } + + return res; +} + +json server_task_result_cmpl_final::to_json_oaicompat_chat_stream() { + std::time_t t = std::time(0); + std::string finish_reason = "length"; + if (stop == STOP_TYPE_WORD || stop == STOP_TYPE_EOS) { + finish_reason = oaicompat_msg.tool_calls.empty() ? "stop" : "tool_calls"; + } + + json deltas = json::array(); + for (const auto & diff : oaicompat_msg_diffs) { + deltas.push_back({ + {"choices", json::array({ + json { + {"finish_reason", nullptr}, + {"index", index}, + {"delta", server_chat_msg_diff_to_json_oaicompat(diff)}, + }, + })}, + {"created", t}, + {"id", oaicompat_cmpl_id}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "chat.completion.chunk"}, + }); + } + + deltas.push_back({ + {"choices", json::array({ + json { + {"finish_reason", finish_reason}, + {"index", index}, + {"delta", json::object()}, + }, + })}, + {"created", t}, + {"id", oaicompat_cmpl_id}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "chat.completion.chunk"}, + }); + + if (include_usage) { + // OpenAI API spec for chat.completion.chunks specifies an empty `choices` array for the last chunk when including usage + // https://platform.openai.com/docs/api-reference/chat_streaming/streaming#chat_streaming/streaming-choices + deltas.push_back({ + {"choices", json::array()}, + {"created", t}, + {"id", oaicompat_cmpl_id}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "chat.completion.chunk"}, + {"usage", usage_json_oaicompat()}, + }); + } + + if (timings.prompt_n >= 0) { + deltas.back().push_back({"timings", timings.to_json()}); + } + + // extra fields for debugging purposes + if (verbose && !deltas.empty()) { + deltas.front()["__verbose"] = to_json_non_oaicompat(); + } + + return deltas; +} + +json server_task_result_cmpl_final::to_json_oaicompat_resp() { + common_chat_msg msg; + if (!oaicompat_msg.empty()) { + msg = oaicompat_msg; + } else { + msg.role = "assistant"; + msg.content = content; + } + + std::vector output; + + if (msg.reasoning_content != "") { + output.push_back(json { + {"id", "rs_" + random_string()}, + {"summary", json::array()}, + {"type", "reasoning"}, + {"content", json::array({ json { + {"text", msg.reasoning_content}, + {"type", "reasoning_text"}, + }})}, + {"encrypted_content", ""}, + {"status", "completed"}, + }); + } + + if (msg.content != "") { + output.push_back(json { + {"content", json::array({ json { + {"type", "output_text"}, + {"annotations", json::array()}, + {"logprobs", json::array()}, + {"text", msg.content}, + }})}, + {"id", "msg_" + random_string()}, + {"role", msg.role}, + {"status", "completed"}, + {"type", "message"}, + }); + } + + for (const common_chat_tool_call & tool_call : oaicompat_msg.tool_calls) { + output.push_back(json { + {"id", "fc_" + tool_call.id}, + {"type", "function_call"}, + {"status", "completed"}, + {"arguments", tool_call.arguments}, + {"call_id", "call_" + tool_call.id}, + {"name", tool_call.name}, + }); + } + + std::time_t t = std::time(0); + json res = { + {"completed_at", t}, + {"created_at", t}, + {"id", oai_resp_id}, + {"model", oaicompat_model}, + {"object", "response"}, + {"output", output}, + {"status", "completed"}, + {"usage", json { + {"input_tokens", n_prompt_tokens}, + {"output_tokens", n_decoded}, + {"total_tokens", n_decoded + n_prompt_tokens}, + {"input_tokens_details", json { {"cached_tokens", n_prompt_tokens_cache} }}, + }}, + }; + + return res; +} + +json server_task_result_cmpl_final::to_json_oaicompat_resp_stream() { + std::vector server_sent_events; + std::vector output; + + if (oaicompat_msg.reasoning_content != "") { + const json output_item = json { + {"id", oai_resp_reasoning_id}, + {"summary", json::array()}, + {"type", "reasoning"}, + {"content", json::array({ json { + {"text", oaicompat_msg.reasoning_content}, + {"type", "reasoning_text"}, + }})}, + {"encrypted_content", ""}, + }; + + server_sent_events.push_back(json { + {"event", "response.output_item.done"}, + {"data", json { + {"type", "response.output_item.done"}, + {"item", output_item} + }} + }); + output.push_back(output_item); + } + + if (oaicompat_msg.content != "") { + server_sent_events.push_back(json { + {"event", "response.output_text.done"}, + {"data", json { + {"type", "response.output_text.done"}, + {"item_id", oai_resp_message_id}, + {"text", oaicompat_msg.content} + }} + }); + + const json content_part = { + {"type", "output_text"}, + {"annotations", json::array()}, + {"logprobs", json::array()}, + {"text", oaicompat_msg.content} + }; + + server_sent_events.push_back(json { + {"event", "response.content_part.done"}, + {"data", json { + {"type", "response.content_part.done"}, + {"item_id", oai_resp_message_id}, + {"part", content_part} + }} + }); + const json output_item = { + {"type", "message"}, + {"status", "completed"}, + {"id", oai_resp_message_id}, + {"content", json::array({content_part})}, + {"role", "assistant"} + }; + + server_sent_events.push_back(json { + {"event", "response.output_item.done"}, + {"data", json { + {"type", "response.output_item.done"}, + {"item", output_item} + }} + }); + output.push_back(output_item); + } + + for (const common_chat_tool_call & tool_call : oaicompat_msg.tool_calls) { + const json output_item = { + {"id", "fc_" + tool_call.id}, + {"type", "function_call"}, + {"status", "completed"}, + {"arguments", tool_call.arguments}, + {"call_id", "call_" + tool_call.id}, + {"name", tool_call.name} + }; + server_sent_events.push_back(json { + {"event", "response.output_item.done"}, + {"data", json { + {"type", "response.output_item.done"}, + {"item", output_item} + }} + }); + output.push_back(output_item); + } + + std::time_t t = std::time(0); + server_sent_events.push_back(json { + {"event", "response.completed"}, + {"data", json { + {"type", "response.completed"}, + {"response", json { + {"id", oai_resp_id}, + {"object", "response"}, + {"created_at", t}, + {"status", "completed"}, + {"model", oaicompat_model}, + {"output", output}, + {"usage", json { + {"input_tokens", n_prompt_tokens}, + {"output_tokens", n_decoded}, + {"total_tokens", n_decoded + n_prompt_tokens}, + {"input_tokens_details", json { {"cached_tokens", n_prompt_tokens_cache} }}, + }} + }}, + }} + }); + + if (timings.prompt_n >= 0) { + server_sent_events.back().at("data").push_back({"timings", timings.to_json()}); + } + + return server_sent_events; +} + +json server_task_result_cmpl_final::to_json_oaicompat_asr() { + json event = json { + {"type", "transcript.text.done"}, + {"text", oaicompat_msg.content}, + {"usage", json { + {"type", "tokens"}, + {"input_tokens", n_prompt_tokens}, + {"output_tokens", n_decoded}, + {"total_tokens", n_decoded + n_prompt_tokens}, + {"input_tokens_details", json { {"cached_tokens", n_prompt_tokens_cache} }}, + }}, + }; + return event; +} + +json server_task_result_cmpl_final::to_json_anthropic() { + std::string stop_reason = "max_tokens"; + if (stop == STOP_TYPE_WORD || stop == STOP_TYPE_EOS) { + stop_reason = oaicompat_msg.tool_calls.empty() ? "end_turn" : "tool_use"; + } + + json content_blocks = json::array(); + + common_chat_msg msg; + if (!oaicompat_msg.empty()) { + msg = oaicompat_msg; + } else { + msg.role = "assistant"; + msg.content = content; + } + + // thinking block comes first (Anthropic extended thinking format) + if (!msg.reasoning_content.empty()) { + content_blocks.push_back({ + {"type", "thinking"}, + {"thinking", msg.reasoning_content}, + {"signature", ""} // empty signature for local models (no cryptographic verification) + }); + } + + if (!msg.content.empty()) { + content_blocks.push_back({ + {"type", "text"}, + {"text", msg.content} + }); + } + + for (const auto & tool_call : msg.tool_calls) { + json tool_use_block = { + {"type", "tool_use"}, + {"id", tool_call.id}, + {"name", tool_call.name} + }; + + try { + tool_use_block["input"] = json::parse(tool_call.arguments); + } catch (const std::exception &) { + tool_use_block["input"] = json::object(); + } + + content_blocks.push_back(tool_use_block); + } + + json res = { + {"id", oaicompat_cmpl_id}, + {"type", "message"}, + {"role", "assistant"}, + {"content", content_blocks}, + {"model", oaicompat_model}, + {"stop_reason", stop_reason}, + {"stop_sequence", stopping_word.empty() ? nullptr : json(stopping_word)}, + {"usage", { + {"cache_read_input_tokens", n_prompt_tokens_cache}, + {"input_tokens", n_prompt_tokens - n_prompt_tokens_cache}, + {"output_tokens", n_decoded} + }} + }; + + return res; +} + +json server_task_result_cmpl_final::to_json_anthropic_stream() { + json events = json::array(); + + std::string stop_reason = "max_tokens"; + if (stop == STOP_TYPE_WORD || stop == STOP_TYPE_EOS) { + stop_reason = oaicompat_msg.tool_calls.empty() ? "end_turn" : "tool_use"; + } + + bool has_thinking = !oaicompat_msg.reasoning_content.empty(); + bool has_text = !oaicompat_msg.content.empty(); + size_t num_tool_calls = oaicompat_msg.tool_calls.size(); + + // content block indices: thinking (0) -> text (0 or 1) -> tool_use (n+) + size_t thinking_block_index = 0; + size_t text_block_index = has_thinking ? 1 : 0; + + bool thinking_block_started = false; + bool text_block_started = false; + std::unordered_set tool_calls_started; + + for (const auto & diff : oaicompat_msg_diffs) { + // handle thinking/reasoning content + if (!diff.reasoning_content_delta.empty()) { + if (!thinking_block_started) { + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", thinking_block_index}, + {"content_block", { + {"type", "thinking"}, + {"thinking", ""} + }} + }} + }); + thinking_block_started = true; + } + + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", thinking_block_index}, + {"delta", { + {"type", "thinking_delta"}, + {"thinking", diff.reasoning_content_delta} + }} + }} + }); + } + + // handle regular text content + if (!diff.content_delta.empty()) { + if (!text_block_started) { + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", text_block_index}, + {"content_block", { + {"type", "text"}, + {"text", ""} + }} + }} + }); + text_block_started = true; + } + + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", text_block_index}, + {"delta", { + {"type", "text_delta"}, + {"text", diff.content_delta} + }} + }} + }); + } + + // handle tool calls + if (diff.tool_call_index != std::string::npos) { + size_t content_block_index = (has_thinking ? 1 : 0) + (has_text ? 1 : 0) + diff.tool_call_index; + + if (tool_calls_started.find(diff.tool_call_index) == tool_calls_started.end()) { + const auto & full_tool_call = oaicompat_msg.tool_calls[diff.tool_call_index]; + + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", content_block_index}, + {"content_block", { + {"type", "tool_use"}, + {"id", full_tool_call.id}, + {"name", full_tool_call.name} + }} + }} + }); + tool_calls_started.insert(diff.tool_call_index); + } + + if (!diff.tool_call_delta.arguments.empty()) { + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", content_block_index}, + {"delta", { + {"type", "input_json_delta"}, + {"partial_json", diff.tool_call_delta.arguments} + }} + }} + }); + } + } + } + + // close content blocks in order + if (has_thinking) { + // Anthropic API requires a signature_delta before closing thinking blocks + // We use an empty signature since we can't generate a cryptographic signature for local models + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", thinking_block_index}, + {"delta", { + {"type", "signature_delta"}, + {"signature", ""} + }} + }} + }); + events.push_back({ + {"event", "content_block_stop"}, + {"data", { + {"type", "content_block_stop"}, + {"index", thinking_block_index} + }} + }); + } + + if (has_text) { + events.push_back({ + {"event", "content_block_stop"}, + {"data", { + {"type", "content_block_stop"}, + {"index", text_block_index} + }} + }); + } + + for (size_t i = 0; i < num_tool_calls; i++) { + size_t content_block_index = (has_thinking ? 1 : 0) + (has_text ? 1 : 0) + i; + events.push_back({ + {"event", "content_block_stop"}, + {"data", { + {"type", "content_block_stop"}, + {"index", content_block_index} + }} + }); + } + + events.push_back({ + {"event", "message_delta"}, + {"data", { + {"type", "message_delta"}, + {"delta", { + {"stop_reason", stop_reason}, + {"stop_sequence", stopping_word.empty() ? nullptr : json(stopping_word)} + }}, + {"usage", { + {"output_tokens", n_decoded} + }} + }} + }); + + events.push_back({ + {"event", "message_stop"}, + {"data", { + {"type", "message_stop"} + }} + }); + + return events; +} + +// +// server_task_result_cmpl_partial +// +void server_task_result_cmpl_partial::update(task_result_state & state) { + is_updated = true; + if (is_begin) { + return; // begin marker only flushes headers, skip parsing + } + state.update_chat_msg(content, true, oaicompat_msg_diffs); + + // Copy current state for use in to_json_*() (reflects state BEFORE this chunk) + thinking_block_started = state.thinking_block_started; + text_block_started = state.text_block_started; + + oai_resp_created = state.oai_resp_created; + oai_resp_id = state.oai_resp_id; + oai_resp_reasoning_id = state.oai_resp_reasoning_id; + oai_resp_message_id = state.oai_resp_message_id; + oai_resp_fc_id = state.oai_resp_fc_id; + + // track if the accumulated message has any reasoning content + anthropic_has_reasoning = !state.chat_msg.reasoning_content.empty(); + + if (res_type == TASK_RESPONSE_TYPE_OAI_RESP && !state.oai_resp_created && (is_progress || n_decoded == 1)) { + state.oai_resp_created = true; + } + + // Pre-compute state updates based on diffs (for next chunk) + for (const common_chat_msg_diff & diff : oaicompat_msg_diffs) { + if (!diff.reasoning_content_delta.empty() && !state.thinking_block_started) { + state.thinking_block_started = true; + } + if (!diff.content_delta.empty() && !state.text_block_started) { + state.text_block_started = true; + } + if (!diff.tool_call_delta.name.empty()) { + state.oai_resp_fc_id = diff.tool_call_delta.id; + } + } +} + +json server_task_result_cmpl_partial::to_json() { + GGML_ASSERT(is_updated && "update() must be called before to_json()"); + if (is_begin) { + return nullptr; // simply signal to HTTP handler to send the headers and status code + } + switch (res_type) { + case TASK_RESPONSE_TYPE_NONE: + return to_json_non_oaicompat(); + case TASK_RESPONSE_TYPE_OAI_CMPL: + return to_json_oaicompat(); + case TASK_RESPONSE_TYPE_OAI_CHAT: + return to_json_oaicompat_chat(); + case TASK_RESPONSE_TYPE_OAI_RESP: + return to_json_oaicompat_resp(); + case TASK_RESPONSE_TYPE_OAI_ASR: + return to_json_oaicompat_asr(); + case TASK_RESPONSE_TYPE_ANTHROPIC: + return to_json_anthropic(); + default: + GGML_ASSERT(false && "Invalid task_response_type"); + } +} + +json server_task_result_cmpl_partial::to_json_non_oaicompat() { + // non-OAI-compat JSON + json res = json { + {"index", index}, + {"content", content}, + {"tokens", tokens}, + {"stop", false}, + {"id_slot", id_slot}, + {"tokens_predicted", n_decoded}, + {"tokens_evaluated", n_prompt_tokens}, + }; + // populate the timings object when needed (usually for the last response or with timings_per_token enabled) + if (timings.prompt_n > 0) { + res.push_back({"timings", timings.to_json()}); + } + if (is_progress) { + res.push_back({"prompt_progress", progress.to_json()}); + } + if (!prob_output.probs.empty()) { + res["completion_probabilities"] = completion_token_output::probs_vector_to_json({prob_output}, post_sampling_probs); + } + return res; +} + +json server_task_result_cmpl_partial::to_json_oaicompat() { + std::time_t t = std::time(0); + json logprobs = json(nullptr); // OAI default to null + if (prob_output.probs.size() > 0) { + logprobs = json{ + {"content", completion_token_output::probs_vector_to_json({prob_output}, post_sampling_probs)}, + }; + } + json res = json { + {"choices", json::array({ + json{ + {"text", content}, + {"index", index}, + {"logprobs", logprobs}, + {"finish_reason", nullptr}, + } + })}, + {"created", t}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "text_completion"}, + {"id", oaicompat_cmpl_id} + }; + + // extra fields for debugging purposes + if (verbose) { + res["__verbose"] = to_json_non_oaicompat(); + } + if (timings.prompt_n >= 0) { + res.push_back({"timings", timings.to_json()}); + } + if (is_progress) { + res.push_back({"prompt_progress", progress.to_json()}); + } + + return res; +} + +json server_task_result_cmpl_partial::to_json_oaicompat_chat() { + bool first = n_decoded == 1; + std::time_t t = std::time(0); + json choices; + + std::vector deltas; + auto add_delta = [&](const json & delta) { + deltas.push_back({ + {"choices", json::array({ + json { + {"finish_reason", nullptr}, + {"index", index}, + {"delta", delta}, + }, + })}, + {"created", t}, + {"id", oaicompat_cmpl_id}, + {"model", oaicompat_model}, + {"system_fingerprint", std::string(llama_build_info())}, + {"object", "chat.completion.chunk"}, + }); + }; + // We have to send an initial update to conform to openai behavior + if (first || is_progress) { + add_delta({ + {"role", "assistant"}, + {"content", nullptr}, + }); + } + + for (const auto & diff : oaicompat_msg_diffs) { + add_delta(server_chat_msg_diff_to_json_oaicompat(diff)); + } + + if (!deltas.empty()) { + auto & last_json = deltas[deltas.size() - 1]; + GGML_ASSERT(last_json.at("choices").size() >= 1); + + if (prob_output.probs.size() > 0) { + last_json.at("choices").at(0)["logprobs"] = json { + {"content", completion_token_output::probs_vector_to_json({prob_output}, post_sampling_probs)}, + }; + } + + if (timings.prompt_n >= 0) { + last_json.push_back({"timings", timings.to_json()}); + } + if (is_progress) { + last_json.push_back({"prompt_progress", progress.to_json()}); + } + } + + return deltas; +} + +json server_task_result_cmpl_partial::to_json_oaicompat_resp() { + std::vector events; + + if (!oai_resp_created) { + events.push_back(json { + {"event", "response.created"}, + {"data", json { + {"type", "response.created"}, + {"response", json { + {"id", oai_resp_id}, + {"object", "response"}, + {"status", "in_progress"}, + }}, + }}, + }); + events.push_back(json { + {"event", "response.in_progress"}, + {"data", json { + {"type", "response.in_progress"}, + {"response", json { + {"id", oai_resp_id}, + {"object", "response"}, + {"status", "in_progress"}, + }}, + }}, + }); + } else if (is_progress) { + events.push_back(json { + {"event", "response.in_progress"}, + {"data", json { + {"type", "response.in_progress"}, + {"response", json { + {"id", oai_resp_id}, + {"object", "response"}, + {"status", "in_progress"}, + }}, + }}, + }); + } + + for (const common_chat_msg_diff & diff : oaicompat_msg_diffs) { + if (!diff.reasoning_content_delta.empty()) { + if (!thinking_block_started) { + events.push_back(json { + {"event", "response.output_item.added"}, + {"data", json { + {"type", "response.output_item.added"}, + {"item", json { + {"id", oai_resp_reasoning_id}, + {"summary", json::array()}, + {"type", "reasoning"}, + {"content", json::array()}, + {"encrypted_content", ""}, + {"status", "in_progress"}, + }}, + }}, + }); + thinking_block_started = true; + } + events.push_back(json { + {"event", "response.reasoning_text.delta"}, + {"data", json { + {"type", "response.reasoning_text.delta"}, + {"delta", diff.reasoning_content_delta}, + {"item_id", oai_resp_reasoning_id}, + }}, + }); + } + + if (!diff.content_delta.empty()) { + if (!text_block_started) { + events.push_back(json { + {"event", "response.output_item.added"}, + {"data", json { + {"type", "response.output_item.added"}, + {"item", json { + {"content", json::array()}, + {"id", oai_resp_message_id}, + {"role", "assistant"}, + {"status", "in_progress"}, + {"type", "message"}, + }}, + }}, + }); + events.push_back(json { + {"event", "response.content_part.added"}, + {"data", json { + {"type", "response.content_part.added"}, + {"item_id", oai_resp_message_id}, + {"part", json { + {"type", "output_text"}, + {"text", ""}, + }}, + }}, + }); + text_block_started = true; + } + events.push_back(json { + {"event", "response.output_text.delta"}, + {"data", json { + {"type", "response.output_text.delta"}, + {"item_id", oai_resp_message_id}, + {"delta", diff.content_delta}, + }}, + }); + } + + if (!diff.tool_call_delta.name.empty()) { + events.push_back(json { + {"event", "response.output_item.added"}, + {"data", json { + {"type", "response.output_item.added"}, + {"item", json { + {"id", "fc_" + diff.tool_call_delta.id}, + {"arguments", ""}, + {"call_id", "call_" + diff.tool_call_delta.id}, + {"name", diff.tool_call_delta.name}, + {"type", "function_call"}, + {"status", "in_progress"}, + }}, + }}, + }); + oai_resp_fc_id = diff.tool_call_delta.id; + } + + if (!diff.tool_call_delta.arguments.empty()) { + events.push_back(json { + {"event", "response.function_call_arguments.delta"}, + {"data", json { + {"type", "response.function_call_arguments.delta"}, + {"delta", diff.tool_call_delta.arguments}, + {"item_id", "fc_" + oai_resp_fc_id}, + }}, + }); + } + } + + if (!events.empty()) { + json & data = events.back().at("data"); + if (timings.prompt_n >= 0) { + data.push_back({"timings", timings.to_json()}); + } + if (is_progress) { + data.push_back({"prompt_progress", progress.to_json()}); + } + } + + return events; +} + +json server_task_result_cmpl_partial::to_json_oaicompat_asr() { + json event = json { + {"type", "transcript.text.delta"}, + {"delta", content}, + }; + return event; +} + +json server_task_result_cmpl_partial::to_json_anthropic() { + json events = json::array(); + bool first = (n_decoded == 1); + // use member variables to track block state across streaming calls + // (anthropic_thinking_block_started, anthropic_text_block_started) + + if (first) { + events.push_back({ + {"event", "message_start"}, + {"data", { + {"type", "message_start"}, + {"message", { + {"id", oaicompat_cmpl_id}, + {"type", "message"}, + {"role", "assistant"}, + {"content", json::array()}, + {"model", oaicompat_model}, + {"stop_reason", nullptr}, + {"stop_sequence", nullptr}, + {"usage", { + {"cache_read_input_tokens", n_prompt_tokens_cache}, + {"input_tokens", n_prompt_tokens - n_prompt_tokens_cache}, + {"output_tokens", 0} + }} + }} + }} + }); + } + + // content block indices: thinking (0) -> text (0 or 1) -> tool_use (n+) + size_t thinking_block_index = 0; + // use anthropic_has_reasoning (set in update()) to know if ANY reasoning was generated + size_t text_block_index = anthropic_has_reasoning ? 1 : 0; + + // use local copies of streaming state (copied from task_result_state in update()) + // these reflect the state BEFORE this chunk was processed + bool thinking_started = thinking_block_started; + bool text_started = text_block_started; + + for (const auto & diff : oaicompat_msg_diffs) { + // handle thinking/reasoning content + if (!diff.reasoning_content_delta.empty()) { + if (!thinking_started) { + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", thinking_block_index}, + {"content_block", { + {"type", "thinking"}, + {"thinking", ""} + }} + }} + }); + thinking_started = true; + } + + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", thinking_block_index}, + {"delta", { + {"type", "thinking_delta"}, + {"thinking", diff.reasoning_content_delta} + }} + }} + }); + } + + // handle regular text content + if (!diff.content_delta.empty()) { + if (!text_started) { + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", text_block_index}, + {"content_block", { + {"type", "text"}, + {"text", ""} + }} + }} + }); + text_started = true; + } + + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", text_block_index}, + {"delta", { + {"type", "text_delta"}, + {"text", diff.content_delta} + }} + }} + }); + } + + // handle tool calls + if (diff.tool_call_index != std::string::npos) { + // use anthropic_has_reasoning for thinking block count (persists across calls) + size_t content_block_index = (anthropic_has_reasoning ? 1 : 0) + (text_started ? 1 : 0) + diff.tool_call_index; + + if (!diff.tool_call_delta.name.empty()) { + events.push_back({ + {"event", "content_block_start"}, + {"data", { + {"type", "content_block_start"}, + {"index", content_block_index}, + {"content_block", { + {"type", "tool_use"}, + {"id", diff.tool_call_delta.id}, + {"name", diff.tool_call_delta.name} + }} + }} + }); + } + + if (!diff.tool_call_delta.arguments.empty()) { + events.push_back({ + {"event", "content_block_delta"}, + {"data", { + {"type", "content_block_delta"}, + {"index", content_block_index}, + {"delta", { + {"type", "input_json_delta"}, + {"partial_json", diff.tool_call_delta.arguments} + }} + }} + }); + } + } + } + + return events; +} + +// +// server_task_result_embd +// +json server_task_result_embd::to_json() { + return res_type == TASK_RESPONSE_TYPE_OAI_EMBD + ? to_json_oaicompat() + : to_json_non_oaicompat(); +} + +json server_task_result_embd::to_json_non_oaicompat() { + return json { + {"index", index}, + {"embedding", embedding}, + }; +} + +json server_task_result_embd::to_json_oaicompat() { + return json { + {"index", index}, + {"embedding", embedding[0]}, + {"tokens_evaluated", n_tokens}, + }; +} + +// +// server_task_result_rerank +// +json server_task_result_rerank::to_json() { + return json { + {"index", index}, + {"score", score}, + {"tokens_evaluated", n_tokens}, + }; +} + +// +// server_task_result_error +// +json server_task_result_error::to_json() { + json res = format_error_response(err_msg, err_type); + if (err_type == ERROR_TYPE_EXCEED_CONTEXT_SIZE) { + res["n_prompt_tokens"] = n_prompt_tokens; + res["n_ctx"] = n_ctx; + } + return res; +} + +// +// server_task_result_metrics +// +json server_task_result_metrics::to_json() { + return json { + { "idle", n_idle_slots }, + { "processing", n_processing_slots }, + { "deferred", n_tasks_deferred }, + { "t_start", t_start }, + + { "n_prompt_tokens_processed_total", n_prompt_tokens_processed_total }, + { "t_tokens_generation_total", t_tokens_generation_total }, + { "n_tokens_predicted_total", n_tokens_predicted_total }, + { "t_prompt_processing_total", t_prompt_processing_total }, + + { "n_tokens_max", n_tokens_max }, + + { "n_prompt_tokens_processed", n_prompt_tokens_processed }, + { "t_prompt_processing", t_prompt_processing }, + { "n_tokens_predicted", n_tokens_predicted }, + { "t_tokens_generation", t_tokens_generation }, + + { "n_decode_total", n_decode_total }, + { "n_busy_slots_total", n_busy_slots_total }, + + { "n_draft_tokens_total", n_draft_tokens_total }, + { "n_draft_accepted_total", n_draft_accepted_total }, + { "n_draft_verif_steps_total", n_draft_verif_steps_total }, + { "n_accepted_per_pos_total", n_accepted_per_pos_total }, + + { "slots", slots_data }, + }; +} + +// +// server_task_result_slot_save_load +// +json server_task_result_slot_save_load::to_json() { + if (is_save) { + return json { + { "id_slot", id_slot }, + { "filename", filename }, + { "n_saved", n_tokens }, + { "n_written", n_bytes }, + { "timings", { + { "save_ms", t_ms } + }}, + }; + } + + return json { + { "id_slot", id_slot }, + { "filename", filename }, + { "n_restored", n_tokens }, + { "n_read", n_bytes }, + { "timings", { + { "restore_ms", t_ms } + }}, + }; +} + +// +// server_task_result_slot_erase +// +json server_task_result_slot_erase::to_json() { + return json { + { "id_slot", id_slot }, + { "n_erased", n_erased }, + }; +} + +// +// server_task_result_get_lora +// + +json server_task_result_get_lora::to_json() { + json result = json::array(); + for (size_t i = 0; i < loras.size(); ++i) { + auto & lora = loras[i]; + json entry = { + {"id", i}, + {"path", lora.info.path}, + {"scale", lora.info.scale}, + {"task_name", lora.info.task_name}, + {"prompt_prefix", lora.info.prompt_prefix}, + }; + if (!lora.alora_invocation_tokens.empty()) { + entry["alora_invocation_string"] = lora.alora_invocation_string; + entry["alora_invocation_tokens"] = lora.alora_invocation_tokens; + } + result.push_back(std::move(entry)); + } + return result; +} + +// +// server_task_result_apply_lora +// + +json server_task_result_apply_lora::to_json() { + return json {{ "success", true }}; +} + +// +// server_prompt_cache +// +size_t server_prompt_cache::size() const { + size_t res = 0; + + for (const auto & state : states) { + res += state.size(); + } + + return res; +} + +size_t server_prompt_cache::n_tokens() const { + size_t res = 0; + + for (const auto & state : states) { + res += state.prompt.n_tokens(); + } + + return res; +} + +server_prompt_cache_state * server_prompt_cache::alloc(const server_prompt & prompt, size_t state_size_tgt, size_t state_size_dft) { + // first check if the current state is contained fully in the cache + for (auto it = states.begin(); it != states.end(); ++it) { + const int cur_lcp_len = it->prompt.tokens.get_common_prefix(prompt.tokens); + + if (cur_lcp_len == (int) prompt.tokens.size()) { + SRV_TRC("%s", " - prompt is already in the cache, skipping\n"); + return nullptr; + } + } + + // calculate checkpoints size to see if it will fit with the prompt + size_t checkpoints_size = 0; + for (const auto & ckpt : prompt.checkpoints) { + checkpoints_size += ckpt.size(); + } + + const size_t state_size_new = state_size_tgt + state_size_dft + checkpoints_size; + + // skip over-limit entries to avoid disturbing the cache + if (limit_size > 0 && state_size_new > limit_size) { + SRV_WRN(" - prompt state size %.3f MiB exceeds cache size limit %.3f MiB, skipping\n", + state_size_new / (1024.0 * 1024.0), limit_size / (1024.0 * 1024.0)); + return nullptr; + } + + // remove any cached prompts that are fully contained in the current prompt + for (auto it = states.begin(); it != states.end();) { + const int len = it->prompt.tokens.get_common_prefix(prompt.tokens); + + if (len == (int) it->prompt.tokens.size()) { + SRV_TRC(" - removing obsolete cached prompt with length %d\n", len); + + it = states.erase(it); + } else { + ++it; + } + } + + if (limit_size > 0) { + // make room before allocating the new vectors to avoid breaching the limit + while (!states.empty() && size() + state_size_new > limit_size) { + SRV_WRN(" - making room for prompt cache entry, removing oldest entry (size = %.3f MiB)\n", + states.front().size() / (1024.0 * 1024.0)); + + states.pop_front(); + } + } + + std::vector state_data_tgt; + std::vector state_data_dft; + + // check if we can allocate enough memory for the new state + try { + state_data_tgt.resize(state_size_tgt); + state_data_dft.resize(state_size_dft); + } catch (const std::bad_alloc & e) { + SRV_ERR("failed to allocate memory for prompt cache state: %s\n", e.what()); + + limit_size = std::max(1, 0.4*size()); + + SRV_WRN(" - cache size limit reduced to %.3f MiB\n", limit_size / (1024.0 * 1024.0)); + + update(); + + return nullptr; + } + + states.push_back({ + /*.prompt =*/ { + /*.tokens =*/ prompt.tokens.clone(), + /*.checkpoints =*/ prompt.checkpoints, + }, + /*.data =*/ { + /*.main =*/ std::move(state_data_tgt), + /*.drft =*/ std::move(state_data_dft), + }, + }); + + return &states.back(); +} + +bool server_prompt_cache::load(server_prompt & prompt, const server_tokens & tokens_new, llama_context * ctx_tgt, llama_context * ctx_dft, int32_t id_slot) { + const int lcp_best = prompt.tokens.get_common_prefix(tokens_new); + + float f_keep_best = prompt.tokens.size() > 0 ? float(lcp_best) / prompt.tokens.size() : -1.0f; // empty slot: any cache entry wins + float f_sim_best = float(lcp_best) / tokens_new.size(); + + SRV_TRC(" - looking for better prompt, base f_keep = %.3f, f_sim = %.3f\n", f_keep_best, f_sim_best); + + auto it_best = states.end(); + + // find the most similar cached prompt, that would also preserve the most context + for (auto it = states.begin(); it != states.end(); ++it) { + const int lcp_cur = it->prompt.tokens.get_common_prefix(tokens_new); + + const float f_keep_cur = float(lcp_cur) / it->prompt.tokens.size(); + const float f_sim_cur = float(lcp_cur) / tokens_new.size(); + + SRV_TRC(" - prompt with length %7zu, lcp = %7d, f_keep = %.3f, f_sim = %.3f\n", it->prompt.tokens.size(), lcp_cur, f_keep_cur, f_sim_cur); + + // don't trash large prompts + if (f_keep_cur < 0.25f) { + continue; + } + + if (f_keep_best < f_keep_cur && f_sim_best < f_sim_cur) { + f_keep_best = f_keep_cur; + f_sim_best = f_sim_cur; + + it_best = it; + } + } + + if (it_best != states.end()) { + SRV_TRC(" - found better prompt with f_keep = %.3f, f_sim = %.3f\n", f_keep_best, f_sim_best); + + { + auto & data = it_best->data.main; + + const size_t size = data.size(); + const size_t n = llama_state_seq_set_data_ext(ctx_tgt, data.data(), size, id_slot, 0); + if (n != size) { + SRV_ERR("failed to restore state with size %zu\n", size); + + return false; + } + + data.clear(); + data.shrink_to_fit(); + } + + { + auto & data = it_best->data.drft; + + if (!data.empty()) { + GGML_ASSERT(ctx_dft); + + const size_t size = data.size(); + const size_t n = llama_state_seq_set_data_ext(ctx_dft, data.data(), size, id_slot, 0); + if (n != size) { + SRV_WRN("failed to restore state with size %zu\n", size); + + return false; + } + + data.clear(); + data.shrink_to_fit(); + } + } + + prompt = std::move(it_best->prompt); + + states.erase(it_best); + } + + return true; +} + +void server_prompt_cache::update() { + if (limit_size > 0) { + while (!states.empty() && size() > limit_size) { + SRV_WRN(" - cache size limit reached, removing oldest entry (size = %.3f MiB)\n", states.front().size() / (1024.0 * 1024.0)); + + states.pop_front(); + } + } + + // average size per token + const float size_per_token = std::max(1.0f, float(size()) / (std::max(1, n_tokens()))); + + // dynamically increase the token limit if it can fit in the memory limit + const size_t limit_tokens_cur = limit_size > 0 ? std::max(limit_tokens, limit_size/size_per_token) : limit_tokens; + + if (limit_tokens > 0) { + while (!states.empty() && n_tokens() > limit_tokens_cur) { + SRV_WRN(" - cache token limit (%zu, est: %zu) reached, removing oldest entry (size = %.3f MiB)\n", + limit_tokens, limit_tokens_cur, states.front().size() / (1024.0 * 1024.0)); + + states.pop_front(); + } + } + + SRV_TRC(" - cache state: %zu prompts, %.3f MiB (limits: %.3f MiB, %zu tokens, %zu est)\n", + states.size(), size() / (1024.0 * 1024.0), limit_size / (1024.0 * 1024.0), limit_tokens, limit_tokens_cur); + + for (const auto & state : states) { + SRV_TRC(" - prompt %p: %7d tokens, checkpoints: %2zu, %9.3f MiB\n", + (const void *)&state, state.prompt.n_tokens(), state.prompt.checkpoints.size(), state.size() / (1024.0 * 1024.0)); + } +} diff --git a/tools/server/server-task.h b/tools/server/server-task.h new file mode 100644 index 0000000000000000000000000000000000000000..6275ec7604b5024963b09f95322971fe07030568 --- /dev/null +++ b/tools/server/server-task.h @@ -0,0 +1,670 @@ +#pragma once + +#include "common.h" +#include "llama.h" + +#include +#include +#include +#include + +// TODO: prevent including the whole server-common.h as we only use server_tokens +#include "server-common.h" + +using json = nlohmann::ordered_json; + +enum server_task_type { + SERVER_TASK_TYPE_COMPLETION, + SERVER_TASK_TYPE_EMBEDDING, + SERVER_TASK_TYPE_RERANK, + SERVER_TASK_TYPE_INFILL, + SERVER_TASK_TYPE_CANCEL, + SERVER_TASK_TYPE_CONTROL, + SERVER_TASK_TYPE_NEXT_RESPONSE, + SERVER_TASK_TYPE_METRICS, + SERVER_TASK_TYPE_SLOT_SAVE, + SERVER_TASK_TYPE_SLOT_RESTORE, + SERVER_TASK_TYPE_SLOT_ERASE, + SERVER_TASK_TYPE_GET_LORA, + SERVER_TASK_TYPE_SET_LORA, +}; + +// TODO: change this to more generic "response_format" to replace the "format_response_*" in server-common +enum task_response_type { + TASK_RESPONSE_TYPE_NONE, // llama.cpp native format + TASK_RESPONSE_TYPE_OAI_CHAT, + TASK_RESPONSE_TYPE_OAI_CMPL, + TASK_RESPONSE_TYPE_OAI_RESP, + TASK_RESPONSE_TYPE_OAI_ASR, // transcriptions API + TASK_RESPONSE_TYPE_OAI_EMBD, + TASK_RESPONSE_TYPE_ANTHROPIC, +}; + +enum stop_type { + STOP_TYPE_NONE, + STOP_TYPE_EOS, + STOP_TYPE_WORD, + STOP_TYPE_LIMIT, +}; + +struct task_params { + bool stream = false; + bool include_usage = false; + bool cache_prompt = true; // remember the prompt to avoid reprocessing all prompt + bool return_tokens = false; + bool return_progress = false; + + int32_t sse_ping_interval = 30; // seconds between SSE comment pings while the stream stays silent, -1 disables + + int32_t n_keep = 0; // number of tokens to keep from initial prompt + int32_t n_discard = 0; // number of tokens after n_keep that may be discarded when shifting context, 0 defaults to half + int32_t n_predict = -1; // new tokens to predict + int32_t n_indent = 0; // minimum line indentation for the generated text in number of whitespace characters + int32_t n_cmpl = 1; // number of completions to generate from this prompt + + int32_t n_cache_reuse = 0; // min chunk size to attempt reusing from the cache via KV shifting (0 = disabled) + + int64_t t_max_prompt_ms = -1; // TODO: implement + int64_t t_max_predict_ms = -1; // if positive, limit the generation phase to this time limit + + std::map lora; // mapping adapter ID -> scale + + std::vector antiprompt; + std::vector response_fields; + + bool timings_per_token = false; + bool post_sampling_probs = false; + + struct common_params_sampling sampling; + struct common_params_speculative speculative; + + // response formatting + bool verbose = false; + task_response_type res_type = TASK_RESPONSE_TYPE_NONE; + std::string oaicompat_model; + std::string oaicompat_cmpl_id; + + // realtime control (SERVER_TASK_TYPE_CONTROL) + std::string control_action; + std::string control_cmpl_id; + + // per-request parameters for chat parsing + common_chat_parser_params chat_parser_params; + + // message spans for checkpointing + common_chat_msg_spans message_spans; + + // Embeddings + int32_t embd_normalize = 2; // (-1=none, 0=max absolute int16, 1=taxicab, 2=Euclidean/L2, >2=p-norm) + + json format_logit_bias(const std::vector & logit_bias) const; + json to_json(bool only_metrics = false) const; +}; + +// struct for tracking the state of a task (e.g., for streaming) +struct task_result_state { + // tracking diffs for partial tool calls + std::vector diffs; + common_chat_parser_params chat_parser_params; + common_chat_msg chat_msg; + std::string generated_text; // append new chunks of generated text here + std::vector generated_tool_call_ids; + std::unordered_set sent_tool_call_names; + + // for OpenAI Responses and Anthropic streaming API: + // track output item / content block state across chunks + bool thinking_block_started = false; + bool text_block_started = false; + + // for OpenAI Responses streaming API + bool oai_resp_created = false; + const std::string oai_resp_id; + const std::string oai_resp_reasoning_id; + const std::string oai_resp_message_id; + std::string oai_resp_fc_id; // function call ID for current args delta + + task_result_state(const common_chat_parser_params & chat_parser_params); + + // parse partial tool calls and update the internal state + common_chat_msg update_chat_msg( + const std::string & text_added, + bool is_partial, + std::vector & diffs, + bool filter_tool_calls = false); +}; + +struct server_task { + int id = -1; // to be filled by server_queue + + // TODO @ngxson : remove this field and implement a mapping task_id -> idx in the response_reader + size_t index = 0; // used when there are multiple prompts (batch request) + + // used by SERVER_TASK_TYPE_CANCEL + int id_target = -1; + int id_slot = -1; + + // used by parallel sampling (multiple completions from same prompt) + int id_parent = -1; + // temporary store of child tasks for scheduling + // note: accessing to elements is invalid after the task is moved to server_slot + std::vector child_tasks; + + // used by SERVER_TASK_TYPE_INFERENCE + task_params params; + server_tokens tokens; + + // only used by CLI, this allow tokenizing CLI inputs on server side + // we need this because mtmd_context and vocab are not accessible outside of server_context + bool cli = false; + std::string cli_prompt; + std::vector cli_files; + + server_task_type type; + + // used by SERVER_TASK_TYPE_SLOT_SAVE, SERVER_TASK_TYPE_SLOT_RESTORE, SERVER_TASK_TYPE_SLOT_ERASE + struct slot_action { + int id_slot; + std::string filename; + std::string filepath; + }; + slot_action slot_action; + + // used by SERVER_TASK_TYPE_METRICS + bool metrics_reset_bucket = false; + + // used by SERVER_TASK_TYPE_SET_LORA + std::map set_lora; // mapping adapter ID -> scale + + server_task() = default; + + server_task(server_task_type type) : type(type) {} + + int32_t n_tokens() const { + return tokens.size(); + } + + bool need_embd() const { + switch (type) { + case SERVER_TASK_TYPE_EMBEDDING: + case SERVER_TASK_TYPE_RERANK: + return true; + default: + return false; + } + } + + bool need_logits() const { + switch (type) { + case SERVER_TASK_TYPE_COMPLETION: + case SERVER_TASK_TYPE_INFILL: + return true; + default: + return false; + } + } + + bool need_sampling() const { + switch (type) { + case SERVER_TASK_TYPE_COMPLETION: + case SERVER_TASK_TYPE_INFILL: + return true; + default: + return false; + } + } + + // utility function + static std::unordered_set get_list_id(const std::vector & tasks) { + std::unordered_set ids(tasks.size()); + for (size_t i = 0; i < tasks.size(); i++) { + ids.insert(tasks[i].id); + for (auto & child : tasks[i].child_tasks) { + ids.insert(child.id); + } + } + return ids; + } + + void add_child(int id_parent, int id_child) { + server_task copy; + + copy.id = id_child; + copy.id_parent = id_parent; + copy.params = params; + copy.type = type; + copy.tokens = tokens.clone(); + copy.id_slot = -1; // child tasks cannot specify slot + + // use different sampling seed for each child + // note: https://github.com/ggml-org/llama.cpp/pull/18700#discussion_r2675115723 + if (copy.params.sampling.seed != LLAMA_DEFAULT_SEED) { + copy.params.sampling.seed += (uint32_t)child_tasks.size() + 1; + } + + child_tasks.push_back(std::move(copy)); + } + + // the task will be moved into queue, then onto slots + // however, the state must be kept by caller (e.g., HTTP thread) + task_result_state create_state() const { + return task_result_state(params.chat_parser_params); + } + + bool is_parent() const { + return child_tasks.size() > 0; + } + + bool is_child() const { + return id_parent != -1; + } +}; + +struct result_timings { + int32_t cache_n = -1; + + int32_t prompt_n = -1; + double prompt_ms = 0.0; + double prompt_per_token_ms = 0.0; + double prompt_per_second = 0.0; + + int32_t predicted_n = -1; + double predicted_ms = 0.0; + double predicted_per_token_ms = 0.0; + double predicted_per_second = 0.0; + + // Optional speculative metrics - only included when > 0 + int32_t draft_n = 0; + int32_t draft_n_accepted = 0; + + json to_json() const; +}; + +struct result_prompt_progress { + int32_t total = 0; + int32_t cache = 0; + int32_t processed = 0; + int64_t time_ms = 0; + + json to_json() const; +}; + +struct server_task_result { + int id = -1; + int id_slot = -1; + + // TODO @ngxson : remove this field and implement a mapping task_id -> idx in the response_reader + size_t index = 0; // to be used for batched tasks + + virtual bool is_error() { + // only used by server_task_result_error + return false; + } + virtual bool is_stop() { + // only used by server_task_result_cmpl_* + return true; + } + virtual void update(task_result_state &) { + // only used by server_task_result_cmpl_* + } + virtual json to_json() = 0; + virtual ~server_task_result() = default; + virtual server_task_result * clone() const { + GGML_ABORT("not implemented for this task type"); + } +}; + +// using shared_ptr for polymorphism of server_task_result +using server_task_result_ptr = std::unique_ptr; + +struct completion_token_output { + llama_token tok; + float prob; + std::string text_to_send; + struct prob_info { + llama_token tok; + std::string txt; + float prob; + }; + std::vector probs; + + json to_json(bool post_sampling_probs) const; + + static json probs_vector_to_json(const std::vector & probs, bool post_sampling_probs); + + static float logarithm(float x); + + static std::vector str_to_bytes(const std::string & str); + +}; + +struct server_task_result_cmpl_final : server_task_result { + std::string content; + llama_tokens tokens; + + bool stream; + bool include_usage; + result_timings timings; + std::string prompt; + + bool truncated; + int32_t n_decoded; + int32_t n_prompt_tokens; + int32_t n_prompt_tokens_cache; + int32_t n_tokens_cached; + bool has_new_line; + std::string stopping_word; + stop_type stop = STOP_TYPE_NONE; + + bool post_sampling_probs; + std::vector probs_output; + std::vector response_fields; + + task_params generation_params; + + // response formatting + bool verbose = false; + task_response_type res_type = TASK_RESPONSE_TYPE_NONE; + std::string oaicompat_model; + std::string oaicompat_cmpl_id; + common_chat_msg oaicompat_msg; // to be populated by update() + + std::vector oaicompat_msg_diffs; // to be populated by update() + bool is_updated = false; + + // for OpenAI Responses API + std::string oai_resp_id; + std::string oai_resp_reasoning_id; + std::string oai_resp_message_id; + + virtual bool is_stop() override { + return true; // in stream mode, final responses are considered stop + } + + virtual json to_json() override; + + virtual void update(task_result_state & state) override { + is_updated = true; + oaicompat_msg = state.update_chat_msg(content, false, oaicompat_msg_diffs); + + oai_resp_id = state.oai_resp_id; + oai_resp_reasoning_id = state.oai_resp_reasoning_id; + oai_resp_message_id = state.oai_resp_message_id; + } + + json to_json_non_oaicompat(); + + json usage_json_oaicompat(); + + json to_json_oaicompat(); + + json to_json_oaicompat_chat(); + + json to_json_oaicompat_chat_stream(); + + json to_json_oaicompat_resp(); + + json to_json_oaicompat_resp_stream(); + + json to_json_oaicompat_asr(); + + json to_json_anthropic(); + + json to_json_anthropic_stream(); +}; + +struct server_task_result_cmpl_partial : server_task_result { + std::string content; + llama_tokens tokens; + + int32_t n_decoded; + int32_t n_prompt_tokens; + int32_t n_prompt_tokens_cache; + + bool post_sampling_probs; + bool is_progress = false; + bool is_begin = false; // whether to send 200 status to HTTP client (begin of SSE stream) + // ref: https://github.com/ggml-org/llama.cpp/pull/23884 + completion_token_output prob_output; + result_timings timings; + result_prompt_progress progress; + + // response formatting + bool verbose = false; + task_response_type res_type = TASK_RESPONSE_TYPE_NONE; + std::string oaicompat_model; + std::string oaicompat_cmpl_id; + std::vector oaicompat_msg_diffs; // to be populated by update() + bool is_updated = false; + + // Streaming state copied from task_result_state for this chunk + bool thinking_block_started = false; + bool text_block_started = false; + + // for OpenAI Responses API + bool oai_resp_created = false; + std::string oai_resp_id; + std::string oai_resp_reasoning_id; + std::string oai_resp_message_id; + std::string oai_resp_fc_id; + + // for Anthropic API: track if any reasoning content has been generated + bool anthropic_has_reasoning = false; + + virtual bool is_stop() override { + return false; // in stream mode, partial responses are not considered stop + } + + virtual void update(task_result_state & state) override; + + virtual json to_json() override; + + json to_json_non_oaicompat(); + + json to_json_oaicompat(); + + json to_json_oaicompat_chat(); + + json to_json_oaicompat_resp(); + + json to_json_oaicompat_asr(); + + json to_json_anthropic(); +}; + +struct server_task_result_embd : server_task_result { + std::vector> embedding; + + int32_t n_tokens; + + // response formatting + task_response_type res_type = TASK_RESPONSE_TYPE_NONE; + + virtual json to_json() override; + + json to_json_non_oaicompat(); + + json to_json_oaicompat(); +}; + +struct server_task_result_rerank : server_task_result { + float score = -1e6; + + int32_t n_tokens; + + virtual json to_json() override; +}; + +struct server_task_result_error : server_task_result { + error_type err_type = ERROR_TYPE_SERVER; + std::string err_msg; + + // for ERROR_TYPE_EXCEED_CONTEXT_SIZE + int32_t n_prompt_tokens = 0; + int32_t n_ctx = 0; + + virtual bool is_error() override { + return true; + } + + virtual json to_json() override; +}; + +struct server_task_result_metrics : server_task_result { + int n_idle_slots; + int n_processing_slots; + int n_tasks_deferred; + int64_t t_start; + + // TODO: somehow reuse server_metrics in the future, instead of duplicating the fields + uint64_t n_prompt_tokens_processed_total = 0; + uint64_t t_prompt_processing_total = 0; + uint64_t n_tokens_predicted_total = 0; + uint64_t t_tokens_generation_total = 0; + + uint64_t n_tokens_max = 0; + + uint64_t n_prompt_tokens_processed = 0; + uint64_t t_prompt_processing = 0; + + uint64_t n_tokens_predicted = 0; + uint64_t t_tokens_generation = 0; + + uint64_t n_decode_total = 0; + uint64_t n_busy_slots_total = 0; + + uint64_t n_draft_tokens_total = 0; + uint64_t n_draft_accepted_total = 0; + uint64_t n_draft_verif_steps_total = 0; + std::vector n_accepted_per_pos_total; + + // while we can also use std::vector this requires copying the slot object which can be quite messy + // therefore, we use json to temporarily store the slot.to_json() result + json slots_data = json::array(); + + virtual json to_json() override; +}; + +struct server_task_result_slot_save_load : server_task_result { + std::string filename; + bool is_save; // true = save, false = load + + size_t n_tokens; + size_t n_bytes; + double t_ms; + + virtual json to_json() override; +}; + +struct server_task_result_slot_erase : server_task_result { + size_t n_erased; + + virtual json to_json() override; +}; + +struct server_task_result_control : server_task_result { + bool success = false; + std::string message; // optional detail when success is false + + virtual json to_json() override { + json out = json { { "success", success } }; + if (!message.empty()) { + out["message"] = message; + } + return out; + } +}; + +struct server_task_result_get_lora : server_task_result { + struct lora { + common_adapter_lora_info info; + std::string alora_invocation_string; + llama_tokens alora_invocation_tokens; + }; + std::vector loras; + + virtual json to_json() override; +}; + +struct server_task_result_apply_lora : server_task_result { + virtual json to_json() override; +}; + +struct server_prompt { + server_tokens tokens; + + std::list checkpoints; + + void clear() { + tokens.clear(); + checkpoints.clear(); + } + + int n_tokens() const { + return tokens.size(); + } + + server_prompt clone() const { + return server_prompt { + tokens.clone(), + checkpoints, + }; + } +}; + +struct server_prompt_data { + std::vector main; + std::vector drft; + + size_t size() const { + return main.size() + drft.size(); + } +}; + +struct server_prompt_cache_state { + server_prompt prompt; + server_prompt_data data; + + size_t size() const { + size_t res = data.size(); + + for (const auto & ckpt : prompt.checkpoints) { + res += ckpt.size(); + } + + return res; + } +}; + +struct server_prompt_cache { + server_prompt_cache(int32_t limit_size_mib, size_t limit_tokens) { + this->limit_size = 1024ull*1024ull*(limit_size_mib < 0 ? 0 : limit_size_mib); + this->limit_tokens = limit_tokens; + } + + std::list states; + + // in bytes, 0 = no limit + size_t limit_size = 0; + + // in tokens, 0 = no limit + size_t limit_tokens = 0; + + size_t size() const; + + size_t n_tokens() const; + + server_prompt_cache_state * alloc(const server_prompt & prompt, size_t state_size_main, size_t state_size_drft); + + bool load(server_prompt & prompt, const server_tokens & tokens_new, llama_context * ctx_tgt, llama_context * ctx_dft, int32_t id_slot); + + void update(); +}; + +// used exclusively by router mode +struct server_task_result_router : server_task_result { + json data; + virtual json to_json() override { return data; } + virtual server_task_result * clone() const override { + return new server_task_result_router(*this); + } +}; diff --git a/tools/server/server-tools.cpp b/tools/server/server-tools.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a4c1059fff491a21820641caa21e6e72df3c8f2d --- /dev/null +++ b/tools/server/server-tools.cpp @@ -0,0 +1,2195 @@ +#include "server-tools.h" + +#include "subproc.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +# include +#else +# include +# include +#endif + +namespace fs = std::filesystem; + +// +// internal helpers +// + +// a child process writes in the OEM code page, so accented output would reach +// the JSON layer as invalid bytes. run() spawns without a console, so the +// console code page never applies +static std::string console_output_to_utf8(const std::string & text) { +#if defined(_WIN32) + // a chunk can end mid sequence, so the incomplete tail is dropped first + if (text.empty() || is_valid_utf8(text.substr(0, validate_utf8(text)))) { + // never decode twice a child that already emits UTF-8 + return text; + } + + const UINT cp = GetOEMCP(); + + // fail rather than emit replacement characters when the code page is wrong + const int wide_len = MultiByteToWideChar(cp, MB_ERR_INVALID_CHARS, text.data(), (int) text.size(), nullptr, 0); + if (wide_len <= 0) { + return text; + } + std::wstring wide(wide_len, L'\0'); + MultiByteToWideChar(cp, MB_ERR_INVALID_CHARS, text.data(), (int) text.size(), wide.data(), wide_len); + + const int utf8_len = WideCharToMultiByte(CP_UTF8, 0, wide.data(), wide_len, nullptr, 0, nullptr, nullptr); + if (utf8_len <= 0) { + return text; + } + std::string utf8(utf8_len, '\0'); + WideCharToMultiByte(CP_UTF8, 0, wide.data(), wide_len, utf8.data(), utf8_len, nullptr, nullptr); + return utf8; +#else + return text; +#endif +} + +json server_tool::to_json() const { + return { + {"display_name", display_name}, + {"tool", name}, + {"type", type()}, + {"permissions", json{ + {"write", permission_write} + }}, + {"uses_cwd", uses_cwd}, + {"definition", get_definition()}, + }; +} + +static constexpr size_t SERVER_TOOL_GIT_LS_FILES_MAX_OUTPUT = 8 * 1024 * 1024; // 8 MB +// budget for one listing call, shared by the git and walker paths +static constexpr int SERVER_TOOL_LIST_ENTRIES_TIMEOUT = 15; // seconds + +// entry kinds a directory listing may return +enum class list_kind { + files, // regular files only + dirs, // directories only + all, // both +}; + +// a narrow path uses the active code page on Windows, so every crossing between +// a std::string (always UTF-8 here) and fs::path is converted explicitly +static fs::path path_from_utf8(const std::string & s) { + return fs::u8path(s); +} + +// '/' separators on every platform: Windows accepts them, the web UI needs them +static std::string path_to_utf8(const fs::path & p) { + const auto s = p.generic_u8string(); + return std::string(s.begin(), s.end()); +} + +// home directory, read once at first use (getenv is not thread safe against setenv) +static const std::string & home_dir() { + static const std::string home = [] { +#ifdef _WIN32 + // the narrow getenv would return the profile path in the active code page + const wchar_t * w = _wgetenv(L"HOME"); + if (w == nullptr) w = _wgetenv(L"USERPROFILE"); + return w ? path_to_utf8(fs::path(w)) : std::string(); +#else + const char * h = getenv("HOME"); + return h ? std::string(h) : std::string(); +#endif + }(); + return home; +} + +static std::string expand_home(const std::string & path) { + if (path.empty() || path[0] != '~') return path; + if (path.size() > 1 && path[1] != '/' && path[1] != '\\') return path; + const std::string & home = home_dir(); + if (home.empty()) return path; + return home + path.substr(1); +} + +// depth of a '/'-separated relative path: "a/b/c" is 3 +static int entry_depth(const std::string & rel) { + return 1 + (int) std::count(rel.begin(), rel.end(), '/'); +} + +// directories that a listing reports but never descends into: they can be enormous +// lowercase only, the local walker case-folds a name before the lookup +static const char * const SERVER_TOOL_JUNK_DIR_NAMES[] = { + ".git", ".svn", ".hg", "node_modules", "__pycache__", + ".venv", "venv", "dist", "build", "target", ".cache", ".idea", ".vscode", +}; + +class tools_io { +public: + struct exec_result { + std::string output; + int exit_code = -1; + bool timed_out = false; + }; + + virtual ~tools_io() = default; + + virtual bool is_directory(const std::string & path) const = 0; + virtual bool is_regular_file(const std::string & path) const = 0; + virtual bool file_size(const std::string & path, uintmax_t & out_size) const = 0; + virtual bool read_file(const std::string & path, std::string & out) const = 0; + virtual bool write_file(const std::string & path, const std::string & content) const = 0; + // resolve `path` against the IO's working directory; absolute paths are returned unchanged + virtual std::string resolve(const std::string & path) const = 0; + struct list_entry { + std::string rel; // '/'-separated, relative to `base` + bool is_dir = false; + }; + struct list_result { + std::vector entries; + std::string err; // set when `base` is not a directory + bool truncated = false; // set when the walk could not see everything + }; + // entries relative to `base`, which must already be resolved (absolute) + // max_depth == 0 means unlimited, 1 means direct children of `base` only + virtual list_result list_entries(const std::string & base, int max_depth, list_kind kind) const = 0; + // on_chunk, if set, is called with each chunk of output as it is read (before truncation cuts in); + // returning false terminates the process early (e.g. the client disconnected) + virtual exec_result run( + const std::vector & args, + size_t max_output, + int timeout_secs, + const std::function & on_chunk = nullptr) const = 0; +}; + +// shared subprocess execution helper, used by both the local and the isolate-backed tools_io implementations. +// combine_stderr=false when the raw stdout bytes must not be tainted by stderr, e.g. reading file contents. +static tools_io::exec_result run_subprocess( + const std::vector & args, + size_t max_output, + int timeout_secs, + const std::function & on_chunk, + bool combine_stderr, + const std::string & cwd = "", + const std::string * stdin_data = nullptr) { + tools_io::exec_result res; + + common_subproc proc; + + int options = subprocess_option_no_window + | subprocess_option_inherit_environment + | subprocess_option_search_user_path; + if (combine_stderr) { + options |= subprocess_option_combined_stdout_stderr; + } + + if (!proc.create(args, options, {}, cwd.empty() ? nullptr : cwd.c_str())) { + res.output = "failed to spawn process"; + return res; + } + + std::atomic done{false}; + std::atomic timed_out{false}; + + std::thread timeout_thread([&]() { + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(timeout_secs); + while (!done.load()) { + if (std::chrono::steady_clock::now() >= deadline) { + timed_out.store(true); + proc.terminate(); + return; + } + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + }); + + // write stdin before reading stdout, the child drains stdin as it goes + // always close stdin, a transport client waits forever if its stdin pipe stays open + if (FILE * in = proc.stdin_file()) { + if (stdin_data != nullptr && !stdin_data->empty()) { +#if defined(_WIN32) + // pipe fds default to CRT text mode: binary keeps the bytes untranslated + _setmode(_fileno(in), _O_BINARY); +#endif + // a short write is not an error by itself, the exit code below decides + fwrite(stdin_data->data(), 1, stdin_data->size(), in); + } + fflush(in); + } + proc.close_stdin(); + + FILE * f = proc.stdout_file(); + std::string output; + bool truncated = false; + if (f) { +#if defined(_WIN32) + // pipe fds default to CRT text mode: binary keeps the bytes untranslated + _setmode(_fileno(f), _O_BINARY); +#endif + // read raw bytes, not lines: the output can hold NUL and must arrive as soon as it is ready + // keep draining past the size cap, else the child blocks on a full pipe + char buf[4096]; + for (;;) { +#if defined(_WIN32) + const int n = _read(_fileno(f), buf, (unsigned) sizeof(buf)); +#else + ssize_t n = read(fileno(f), buf, sizeof(buf)); + while (n < 0 && errno == EINTR) { + n = read(fileno(f), buf, sizeof(buf)); + } +#endif + if (n <= 0) { + break; + } + if (truncated) { + continue; + } + const size_t len = (size_t) n; + if (output.size() + len <= max_output) { + output.append(buf, len); + if (on_chunk && !on_chunk(console_output_to_utf8(std::string(buf, len)))) { + proc.terminate(); + break; + } + } else { + size_t remaining = max_output - output.size(); + output.append(buf, remaining); + if (on_chunk && remaining > 0) on_chunk(console_output_to_utf8(std::string(buf, remaining))); + truncated = true; + } + } + } + + done.store(true); + if (timeout_thread.joinable()) { + timeout_thread.join(); + } + + res.exit_code = proc.join(); + + res.output = console_output_to_utf8(output); + res.timed_out = timed_out.load(); + if (truncated) { + res.output += "\n[output truncated]"; + } + return res; +} + +class tools_io_basic : public tools_io { +public: + // cwd, if non-empty, is used to resolve relative paths and as the working directory for run() + explicit tools_io_basic(std::string cwd = "") : cwd(std::move(cwd)) {} + + // expands a leading `~`, then resolves `path` against `cwd` (or the server + // working directory when `cwd` is unset); the result is always absolute + std::string resolve(const std::string & path) const override { + const std::string p = expand_home(path); + + fs::path full = path_from_utf8(p); + if (!full.is_absolute()) { + if (cwd.empty()) { + std::error_code ec; + const fs::path cur = fs::current_path(ec); + if (ec) return p; + full = cur / full; + } else { + full = path_from_utf8(cwd) / full; + } + } + + // drop "." and ".." so they never reach git or the client + full = full.lexically_normal(); + // a trailing ".." normalizes to a path that ends with a separator + if (!full.has_filename() && full != full.root_path()) { + full = full.parent_path(); + } + return path_to_utf8(full); + } + + bool is_directory(const std::string & path) const override { + std::error_code ec; + return fs::is_directory(path_from_utf8(resolve(path)), ec) && !ec; + } + + bool is_regular_file(const std::string & path) const override { + std::error_code ec; + return fs::is_regular_file(path_from_utf8(resolve(path)), ec) && !ec; + } + + bool file_size(const std::string & path, uintmax_t & out_size) const override { + std::error_code ec; + out_size = fs::file_size(path_from_utf8(resolve(path)), ec); + return !ec; + } + + bool read_file(const std::string & path, std::string & out) const override { + std::ifstream f(path_from_utf8(resolve(path)), std::ios::binary); + if (!f) return false; + std::ostringstream ss; + ss << f.rdbuf(); + out = ss.str(); + return true; + } + + bool write_file(const std::string & path, const std::string & content) const override { + std::error_code ec; + fs::path fpath = path_from_utf8(resolve(path)); + if (fpath.has_parent_path()) { + fs::create_directories(fpath.parent_path(), ec); + if (ec) return false; + } + std::ofstream f(fpath, std::ios::binary); + if (!f) return false; + f << content; + return (bool) f; + } + + list_result list_entries(const std::string & base, int max_depth, list_kind kind) const override { + list_result out; + + std::error_code ec; + if (!fs::is_directory(base, ec) || ec) { + out.err = "path does not exist or is not a directory"; + return out; + } + + const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(SERVER_TOOL_LIST_ENTRIES_TIMEOUT); + + // git ls-files cannot list directories; use the walker when they are requested + if (kind == list_kind::files) { + auto res = run( + {"git", "-C", base, "ls-files", "--cached", "--others", "--exclude-standard"}, + SERVER_TOOL_GIT_LS_FILES_MAX_OUTPUT, SERVER_TOOL_LIST_ENTRIES_TIMEOUT); + + if (res.exit_code == 0 && !res.timed_out) { + std::istringstream iss(res.output); + std::string line; + while (std::getline(iss, line)) { + if (!line.empty() && line.back() == '\r') line.pop_back(); + if (line.empty()) continue; + std::replace(line.begin(), line.end(), '\\', '/'); + if (max_depth > 0 && entry_depth(line) > max_depth) continue; + if (is_regular_file(path_to_utf8(path_from_utf8(base) / path_from_utf8(line)))) { + out.entries.push_back({line, false}); + } + } + return out; + } + } + + out.entries = list_entries_fallback(base, max_depth, kind, deadline, out.truncated); + return out; + } + + exec_result run( + const std::vector & args, + size_t max_output, + int timeout_secs, + const std::function & on_chunk = nullptr) const override { + return run_subprocess(args, max_output, timeout_secs, on_chunk, /*combine_stderr=*/true, cwd); + } + +private: + std::string cwd; + + // a link can point back to an ancestor and loop forever, so it is never walked + static bool is_link(const fs::directory_entry & entry) { + std::error_code ec; + if (entry.is_symlink(ec) || ec) { + return true; + } +#if defined(_WIN32) + // a junction looks like a plain directory to std::filesystem, so read the reparse tag + WIN32_FIND_DATAW data; + const HANDLE h = FindFirstFileW(entry.path().c_str(), &data); + if (h == INVALID_HANDLE_VALUE) { + return false; + } + FindClose(h); + if ((data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0) { + return false; + } + // other reparse points (cloud placeholder, dedup stub) are real directories + return data.dwReserved0 == IO_REPARSE_TAG_SYMLINK || data.dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT; +#else + return false; +#endif + } + + // NTFS is case insensitive, so Build and build are the same directory + static std::string get_effective_name(const std::string & fname) { +#if defined(_WIN32) + std::string lowered = fname; + std::transform(lowered.begin(), lowered.end(), lowered.begin(), + [](unsigned char c) { return (char) std::tolower(c); }); + return lowered; +#else + return fname; +#endif + } + + static const std::unordered_set & junk_dir_names() { + static const std::unordered_set names( + std::begin(SERVER_TOOL_JUNK_DIR_NAMES), std::end(SERVER_TOOL_JUNK_DIR_NAMES)); + return names; + } + + std::vector list_entries_fallback(const std::string & base, int max_depth, list_kind kind, + std::chrono::steady_clock::time_point deadline, bool & truncated) const { + std::vector result; + + std::vector> stack; + stack.emplace_back(path_from_utf8(base), fs::path(), 0); + + while (!stack.empty()) { + if (std::chrono::steady_clock::now() >= deadline) { + truncated = true; + return result; + } + + auto [dir, rel_dir, depth] = std::move(stack.back()); + stack.pop_back(); + + std::error_code ec; + // step the iterator by hand: the throwing increment escapes on a directory that goes away + fs::directory_iterator it(dir, fs::directory_options::skip_permission_denied, ec); + // permission errors are skipped above, so this is a subtree the caller never sees + if (ec) { + truncated = true; + continue; + } + for (const fs::directory_iterator end; it != end; it.increment(ec)) { + if (ec) { + truncated = true; + break; + } + if (std::chrono::steady_clock::now() >= deadline) { + truncated = true; + return result; + } + const fs::directory_entry & entry = *it; + const fs::path fname = entry.path().filename(); + std::error_code tec; + const bool is_dir = entry.is_directory(tec); + if (tec) continue; + if (is_dir) { + if (kind == list_kind::dirs || kind == list_kind::all) { + result.push_back({path_to_utf8(rel_dir / fname), true}); + } + // junk directories stay selectable but are never walked: they can be enormous + if (junk_dir_names().count(get_effective_name(path_to_utf8(fname))) > 0) continue; + if (!is_link(entry) && (max_depth == 0 || depth + 1 < max_depth)) { + stack.emplace_back(entry.path(), rel_dir / fname, depth + 1); + } + } else if (entry.is_regular_file(tec)) { + if (kind == list_kind::files || kind == list_kind::all) { + result.push_back({path_to_utf8(rel_dir / fname), false}); + } + } + } + } + + return result; + } +}; + +// timeout for auxiliary isolate calls (stat/mkdir/ls helpers); exec_shell_command uses its own +// caller-controlled timeout instead, enforced separately in run() +static constexpr int SERVER_TOOL_ISOLATE_EXEC_TIMEOUT = 15; // seconds +static constexpr size_t SERVER_TOOL_ISOLATE_READ_FILE_MAX_SIZE = 64 * 1024 * 1024; // 64 MB + +// runs every tools_io operation as a command inside an isolate: a container, a remote host, ... +// the isolate is created, mounted, and torn down externally by the caller +// it must provide a POSIX environment: sh, cat, wc, mkdir, dirname, find, timeout +class tools_io_isolate : public tools_io { +public: + // cwd, if non-empty, is used to resolve relative paths and as the working directory for run() + explicit tools_io_isolate(std::string cwd = "") : cwd(std::move(cwd)) {} + + // resolves `path` against `cwd` if `path` is relative and `cwd` is set; otherwise returns `path` unchanged. + // isolate paths are always POSIX-style ('/'), regardless of host OS. + std::string resolve(const std::string & path) const override { + if (cwd.empty() || (!path.empty() && path[0] == '/')) { + return path; + } + return cwd + "/" + path; + } + + bool is_directory(const std::string & path) const override { + return shell_test("-d", resolve(path)); + } + + bool is_regular_file(const std::string & path) const override { + return shell_test("-f", resolve(path)); + } + + bool file_size(const std::string & path, uintmax_t & out_size) const override { + auto res = exec({"sh", "-c", "wc -c < \"$1\"", "_", resolve(path)}, 64, true); + if (res.exit_code != 0 || res.timed_out) return false; + try { + size_t pos; + out_size = (uintmax_t) std::stoull(res.output, &pos); + } catch (...) { + return false; + } + return true; + } + + bool read_file(const std::string & path, std::string & out) const override { + // combine_stderr=false: stderr must not be spliced into raw file bytes + auto res = exec({"cat", "--", resolve(path)}, SERVER_TOOL_ISOLATE_READ_FILE_MAX_SIZE, false); + if (res.exit_code != 0 || res.timed_out) return false; + out = res.output; + return true; + } + + bool write_file(const std::string & path, const std::string & content) const override { + // the content travels on stdin: no argv for the far side to re-parse, no temp file on the host + auto res = run_subprocess( + build_argv({"sh", "-c", "mkdir -p \"$(dirname \"$1\")\" && cat > \"$1\"", "_", resolve(path)}, + /*needs_stdin=*/true), + 4096, SERVER_TOOL_ISOLATE_EXEC_TIMEOUT, nullptr, true, "", &content); + return res.exit_code == 0 && !res.timed_out; + } + + list_result list_entries(const std::string & base, int max_depth, list_kind kind) const override { + list_result out; + + const std::string abs_base = resolve(base); + if (!is_directory(base)) { + out.err = "path does not exist or is not a directory"; + return out; + } + + // git ls-files cannot list directories; use the walker when they are requested + if (kind == list_kind::files) { + auto res = exec( + {"sh", "-c", "cd \"$1\" && git ls-files --cached --others --exclude-standard", "_", abs_base}, + SERVER_TOOL_GIT_LS_FILES_MAX_OUTPUT, true); + + if (res.exit_code == 0 && !res.timed_out) { + for (const auto & rel : split_lines(res.output, /*strip_dot_slash=*/false)) { + if (max_depth > 0 && entry_depth(rel) > max_depth) continue; + out.entries.push_back({rel, false}); + } + return out; + } + } + + if (kind == list_kind::dirs || kind == list_kind::all) { + for (auto & rel : find_entries(abs_base, max_depth, /*dirs=*/true, out.truncated)) { + out.entries.push_back({std::move(rel), true}); + } + } + if (kind == list_kind::files || kind == list_kind::all) { + for (auto & rel : find_entries(abs_base, max_depth, /*dirs=*/false, out.truncated)) { + out.entries.push_back({std::move(rel), false}); + } + } + + return out; + } + + // wraps the command with an in-isolate `timeout`, since killing the host-side client + // does not kill the process tree running inside the isolate + exec_result run( + const std::vector & args, + size_t max_output, + int timeout_secs, + const std::function & on_chunk = nullptr) const override { + std::vector inner = {"timeout", std::to_string(timeout_secs) + "s"}; + inner.insert(inner.end(), args.begin(), args.end()); + // small buffer over timeout_secs so the in-isolate `timeout` has a chance to exit cleanly + // before the host-side supervisory timeout forcibly kills the client + return run_subprocess( + build_argv(with_cwd(inner), /*needs_stdin=*/true), + max_output, timeout_secs + 5, on_chunk, true); + } + +protected: + // wrap `inner` (a complete POSIX argv) into the host-side argv that runs it in the isolate + // a transport that re-parses its args in a remote shell (ssh) must join `inner` with shell_quote_join() + virtual std::vector build_argv(const std::vector & inner, bool needs_stdin) const = 0; + + // quote `argv` into a single string that a POSIX shell re-parses into exactly `argv` + static std::string shell_quote_join(const std::vector & argv) { + std::string out; + for (const auto & arg : argv) { + if (!out.empty()) out += ' '; + out += '\''; + for (const char c : arg) { + // a single quote cannot be escaped inside single quotes: close, escape, reopen + if (c == '\'') out += "'\\''"; + else out += c; + } + out += '\''; + } + return out; + } + +private: + std::string cwd; + + // set the working directory in the command itself, no `-w` equivalent exists on every transport + // auxiliary calls do not need this, they use the absolute paths from resolve() + std::vector with_cwd(const std::vector & inner) const { + if (cwd.empty()) { + return inner; + } + // 127 is what a shell reports for a command it could not run + std::vector out = {"sh", "-c", "cd \"$1\" || exit 127; shift; exec \"$@\"", "_", cwd}; + out.insert(out.end(), inner.begin(), inner.end()); + return out; + } + + exec_result exec(const std::vector & inner, size_t max_output, bool combine_stderr) const { + return run_subprocess( + build_argv(inner, /*needs_stdin=*/false), + max_output, SERVER_TOOL_ISOLATE_EXEC_TIMEOUT, nullptr, combine_stderr); + } + + bool shell_run(const std::vector & inner) const { + auto res = exec(inner, 4096, true); + return res.exit_code == 0 && !res.timed_out; + } + + bool shell_test(const char * flag, const std::string & path) const { + return shell_run({"sh", "-c", std::string("[ ") + flag + " \"$1\" ]", "_", path}); + } + + static std::vector split_lines(const std::string & text, bool strip_dot_slash) { + std::vector result; + std::istringstream iss(text); + std::string line; + while (std::getline(iss, line)) { + if (!line.empty() && line.back() == '\r') line.pop_back(); + if (line.empty()) continue; + if (strip_dot_slash && line.rfind("./", 0) == 0) line = line.substr(2); + std::replace(line.begin(), line.end(), '\\', '/'); + result.push_back(line); + } + return result; + } + + // one `find` pass in the isolate. junk directories stay selectable but are never descended into, + // and -mindepth/-maxdepth keep a busybox image working as well as a GNU one + std::vector find_entries(const std::string & abs_base, int max_depth, bool dirs, bool & truncated) const { + std::string prune_expr; + for (const char * n : SERVER_TOOL_JUNK_DIR_NAMES) { + if (!prune_expr.empty()) prune_expr += " -o "; + prune_expr += std::string("-name ") + n; + } + + std::string cmd = "cd \"$1\" && find . -mindepth 1"; + if (max_depth > 0) { + cmd += " -maxdepth " + std::to_string(max_depth); + } + cmd += " \\( " + prune_expr + " \\) -prune"; + cmd += dirs ? " -print -o -type d -print" : " -o -type f -print"; + + auto res = exec({"sh", "-c", cmd, "_", abs_base}, SERVER_TOOL_GIT_LS_FILES_MAX_OUTPUT, true); + truncated = truncated || res.timed_out; + return split_lines(res.output, /*strip_dot_slash=*/true); + } +}; + +// an already-running container, driven through ` exec` +// docker and podman take the same verbs and the same argument order, so one class drives both +class tools_io_container : public tools_io_isolate { +public: + tools_io_container(std::string bin, std::string container_id, std::string cwd = "") + : tools_io_isolate(std::move(cwd)), bin(std::move(bin)), container_id(std::move(container_id)) {} + +protected: + std::vector build_argv(const std::vector & inner, bool needs_stdin) const override { + std::vector argv = {bin, "exec"}; + if (needs_stdin) { + argv.push_back("-i"); + } + argv.push_back(container_id); + argv.insert(argv.end(), inner.begin(), inner.end()); + return argv; + } + +private: + std::string bin; + std::string container_id; +}; + +// a remote host reached over ssh +// this is remoting, not isolation: the tools can do anything the target account can do +class tools_io_ssh : public tools_io_isolate { +public: + tools_io_ssh(std::string target, std::string cwd = "") + : tools_io_isolate(std::move(cwd)), target(std::move(target)) {} + + // the target can come from a client header, and ssh reads options from its argv + // a target starting with '-' would become one, e.g. -oProxyCommand= runs on the host + static bool is_valid_target(const std::string & target) { + if (target.empty() || target[0] == '-') { + return false; + } + return std::all_of(target.begin(), target.end(), [](unsigned char c) { + return std::isalnum(c) || c == '.' || c == '-' || c == '_' || c == '@'; + }); + } + +protected: + std::vector build_argv(const std::vector & inner, bool needs_stdin) const override { + // the remote shell re-parses the command line, so `inner` travels as one quoted word + std::vector argv = ssh_argv(); + if (!needs_stdin) { + argv.push_back("-n"); + } + argv.push_back(target); + argv.push_back(shell_quote_join(inner)); + return argv; + } + +private: + std::string target; + + // there is no console here, so a prompt would hang the tool call + // key-based auth only, and the admin must trust the host key beforehand + static std::vector ssh_argv() { + return { + "ssh", + "-o", "BatchMode=yes", + "-o", "PasswordAuthentication=no", + "-o", "KbdInteractiveAuthentication=no", + "-o", "StrictHostKeyChecking=yes", + }; + } +}; + +// ":" spawns a container and owns it, "-container:" attaches to one +struct container_runtime_spec { + std::string bin; + std::string arg; // image name when spawning, container id when attaching + bool attach = false; + + static bool parse(const std::string & spec, container_runtime_spec & out) { + // docker and podman take the same verbs, hence a single implementation + static const char * engines[] = {"docker", "podman"}; + for (const char * bin : engines) { + const std::string attach_prefix = std::string(bin) + "-container:"; + if (spec.rfind(attach_prefix, 0) == 0) { + out = {bin, spec.substr(attach_prefix.size()), true}; + return true; + } + const std::string spawn_prefix = std::string(bin) + ":"; + if (spec.rfind(spawn_prefix, 0) == 0) { + out = {bin, spec.substr(spawn_prefix.size()), false}; + return true; + } + } + return false; + } + + // same risk as the ssh target: an id starting with '-' would become an engine option, + // e.g. --privileged + static bool is_valid_id(const std::string & id) { + if (id.empty() || !std::isalnum((unsigned char) id[0])) { + return false; + } + return std::all_of(id.begin(), id.end(), [](unsigned char c) { + return std::isalnum(c) || c == '.' || c == '-' || c == '_'; + }); + } +}; + +static std::unique_ptr make_tools_io(const json & params) { + std::string cwd = json_value(params, "cwd", std::string()); + std::string runtime = json_value(params, "runtime", std::string()); + if (runtime.empty()) { + // an empty runtime runs the tools on the host + return std::make_unique(cwd); + } + container_runtime_spec container; + if (container_runtime_spec::parse(runtime, container)) { + // spawning belongs to the runtime that owns the container, a tool call only attaches + if (!container.attach) { + throw std::runtime_error("tool runtime must name a running container: " + runtime); + } + if (!container_runtime_spec::is_valid_id(container.arg)) { + throw std::runtime_error("invalid container id: " + container.arg); + } + return std::make_unique(container.bin, container.arg, cwd); + } + const std::string ssh_prefix = "ssh:"; + if (runtime.rfind(ssh_prefix, 0) == 0) { + std::string target = runtime.substr(ssh_prefix.size()); + if (!tools_io_ssh::is_valid_target(target)) { + throw std::runtime_error("invalid ssh target: " + target); + } + return std::make_unique(target, cwd); + } + // do not fall back to the host, the caller asked for an isolate + throw std::runtime_error("unknown tool runtime: " + runtime); +} + +// no '/' in pattern -> match basename at any depth; else match full relative path +static bool path_glob_match(const std::string & pattern, const std::string & rel_path) { + if (pattern.find('/') == std::string::npos) { + return glob_match(pattern, path_to_utf8(path_from_utf8(rel_path).filename())); + } + if (pattern == "**" || pattern.rfind("**/", 0) == 0 || pattern.rfind('/', 0) == 0) { + return glob_match(pattern, rel_path); + } + return glob_match("**/" + pattern, rel_path); +} + +// +// read_file: read a file with optional line range and line-number prefix +// + +static constexpr size_t SERVER_TOOL_READ_FILE_MAX_SIZE = 16 * 1024; // 16 KB + +struct server_tool_read_file : server_tool { + server_tool_read_file() { + name = "read_file"; + display_name = "Read file"; + uses_cwd = true; + permission_write = false; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", "Read the contents of a file. Optionally specify a 1-based line range. " + "If append_loc is true, each line is prefixed with its line number (e.g. \"1\u2192...\")."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"path", {{"type", "string"}, {"description", "Path to the file"}}}, + {"start_line", {{"type", "integer"}, {"description", "First line to read, 1-based (default: 1)"}}}, + {"end_line", {{"type", "integer"}, {"description", "Last line to read, 1-based inclusive (default: end of file)"}}}, + {"append_loc", {{"type", "boolean"}, {"description", "Prefix each line with its line number"}}}, + }}, + {"required", json::array({"path"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + std::string path = params.at("path").get(); + int start_line = json_value(params, "start_line", 1); + int end_line = json_value(params, "end_line", -1); // -1 = no limit + bool append_loc = json_value(params, "append_loc", false); + + auto io = make_tools_io(params); + + uintmax_t file_size = 0; + if (!io->file_size(path, file_size)) { + return {{"error", "cannot stat file: " + path}}; + } + if (file_size > SERVER_TOOL_READ_FILE_MAX_SIZE && end_line == -1) { + return {{"error", string_format( + "file too large (%zu bytes, max %zu). Use start_line/end_line to read a portion.", + (size_t)file_size, SERVER_TOOL_READ_FILE_MAX_SIZE)}}; + } + + std::string content; + if (!io->read_file(path, content)) { + return {{"error", "failed to open file: " + path}}; + } + + std::istringstream f(content); + std::string result; + std::string line; + int lineno = 0; + + while (std::getline(f, line)) { + lineno++; + if (lineno < start_line) continue; + if (end_line != -1 && lineno > end_line) break; + + std::string out_line; + if (append_loc) { + out_line = std::to_string(lineno) + "\u2192" + line + "\n"; + } else { + out_line = line + "\n"; + } + + if (result.size() + out_line.size() > SERVER_TOOL_READ_FILE_MAX_SIZE) { + result += "[output truncated]"; + break; + } + result += out_line; + } + + return {{"plain_text_response", result}}; + } +}; + +// +// file_glob_search: find files matching a glob pattern under a base directory +// + +static constexpr int SERVER_TOOL_FILE_SEARCH_MAX_RESULTS = 100; +static constexpr const char * SERVER_TOOL_FILE_SEARCH_TYPE_FILE = "file"; +static constexpr const char * SERVER_TOOL_FILE_SEARCH_TYPE_DIR = "dir"; +static constexpr const char * SERVER_TOOL_FILE_SEARCH_TYPE_ALL = "all"; + +struct server_tool_file_glob_search : server_tool { + server_tool_file_glob_search() { + name = "file_glob_search"; + display_name = "File search"; + uses_cwd = true; + permission_write = false; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", + "Recursively search for files matching a glob pattern under a directory. " + "Automatically skips files ignored by .gitignore (when the directory is inside a git repo) " + "and common junk directories (.git, node_modules, build, dist, etc.) otherwise. " + "A pattern with no '/' (e.g. \"*.cpp\") matches the file's basename at any depth. " + "A pattern containing '/' matches the full relative path; unless already anchored with " + "\"**/\" or a leading '/', it is automatically prefixed with \"**/\". " + "Use type=\"dir\" or \"all\" to also list directories; directory entries are suffixed with '/' in the output. " + "Note: directory listings do not apply .gitignore filtering."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"path", {{"type", "string"}, {"description", "Base directory to search in"}}}, + {"include", {{"type", "string"}, {"description", "Glob pattern for files to include (e.g. \"*.cpp\" or \"src/**/*.cpp\"). Default: **"}}}, + {"exclude", {{"type", "string"}, {"description", "Glob pattern for files to exclude"}}}, + {"type", {{"type", "string"}, {"description", "Entry type to return: \"file\" (default), \"dir\" or \"all\""}}}, + {"max_depth", {{"type", "integer"}, {"description", "Maximum depth to descend into subdirectories (default: 0 = unlimited; 1 = direct children only)"}}}, + {"limit", {{"type", "integer"}, {"description", string_format("Maximum number of results to return, capped at %d (default %d)", SERVER_TOOL_FILE_SEARCH_MAX_RESULTS, SERVER_TOOL_FILE_SEARCH_MAX_RESULTS)}}}, + }}, + {"required", json::array({"path"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + auto io = make_tools_io(params); + + const std::string path = params.at("path").get(); + + std::string base = io->resolve(path); + std::string include = json_value(params, "include", std::string("**")); + std::string exclude = json_value(params, "exclude", std::string("")); + std::string type = json_value(params, "type", std::string("file")); + int max_depth = std::max(0, json_value(params, "max_depth", 0)); + const int limit_req = json_value(params, "limit", SERVER_TOOL_FILE_SEARCH_MAX_RESULTS); + if (limit_req < 1) { + return {{"error", "invalid limit: " + std::to_string(limit_req) + " (expected 1 or more)"}}; + } + const int limit = std::min(limit_req, SERVER_TOOL_FILE_SEARCH_MAX_RESULTS); + + list_kind kind; + if (type == SERVER_TOOL_FILE_SEARCH_TYPE_FILE) { + kind = list_kind::files; + } else if (type == SERVER_TOOL_FILE_SEARCH_TYPE_DIR) { + kind = list_kind::dirs; + } else if (type == SERVER_TOOL_FILE_SEARCH_TYPE_ALL) { + kind = list_kind::all; + } else { + return {{"error", "invalid type: " + type + " (expected \"file\", \"dir\" or \"all\")"}}; + } + + const auto listing = io->list_entries(base, max_depth, kind); + if (!listing.err.empty()) { + return {{"error", listing.err + ": " + path}}; + } + + std::vector matches; + for (const auto & entry : listing.entries) { + if (!path_glob_match(include, entry.rel)) continue; + if (!exclude.empty() && path_glob_match(exclude, entry.rel)) continue; + matches.push_back(entry); + } + + size_t total = matches.size(); + size_t shown = std::min(total, (size_t) limit); + + std::ostringstream output_text; + json entries_json = json::array(); + for (size_t i = 0; i < shown; i++) { + output_text << matches[i].rel << (matches[i].is_dir ? "/" : "") << "\n"; + entries_json.push_back({ + {"path", matches[i].rel}, + {"type", matches[i].is_dir ? "dir" : "file"}, + }); + } + + output_text << "\n---\nTotal matches: " << total << "\n"; + if (total > shown) { + output_text << string_format( + "[%zu results limit reached (%zu total matches). Refine the glob pattern to narrow the search.]\n", + shown, total); + } + if (listing.truncated) { + output_text << "[results truncated: time budget or unreadable directory]\n"; + } + + // `base` is always absolute (resolve falls back to the server cwd), so + // API clients (e.g. the web UI picker) can join the relative entries + // into absolute paths. `plain_text_response` is what the model sees; + // `entries` is the same data as structured JSON for the UI picker, + // which reads `entries`/`base` instead of re-parsing the text. + return {{"plain_text_response", output_text.str()}, {"entries", entries_json}, {"base", base}}; + } +}; + +// +// grep_search: search for a regex pattern in files +// + +static constexpr size_t SERVER_TOOL_GREP_SEARCH_MAX_RESULTS = 100; + +struct server_tool_grep_search : server_tool { + server_tool_grep_search() { + name = "grep_search"; + display_name = "Grep search"; + uses_cwd = true; + permission_write = false; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", + "Search for a pattern in files under a path. Returns matching lines with file paths " + "(and, unless searching a single file, paths relative to the given directory). " + "Automatically skips files ignored by .gitignore (when the directory is inside a git repo) " + "and common junk directories (.git, node_modules, build, dist, etc.) otherwise. " + "include/exclude: a pattern with no '/' matches the basename at any depth; a pattern " + "containing '/' matches the full relative path (auto-anchored with \"**/\" unless already anchored)."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"path", {{"type", "string"}, {"description", "File or directory to search in"}}}, + {"pattern", {{"type", "string"}, {"description", "Pattern to search for (regular expression unless literal is true)"}}}, + {"include", {{"type", "string"}, {"description", "Glob pattern to filter files (default: **)"}}}, + {"exclude", {{"type", "string"}, {"description", "Glob pattern to exclude files"}}}, + {"return_line_numbers", {{"type", "boolean"}, {"description", "If true, include line numbers in results"}}}, + {"literal", {{"type", "boolean"}, {"description", "Treat pattern as a literal string instead of a regular expression (default: false)"}}}, + {"ignore_case", {{"type", "boolean"}, {"description", "Case-insensitive search (default: false)"}}}, + {"context_lines", {{"type", "integer"}, {"description", "Number of lines of context to show before and after each match (default: 0)"}}}, + }}, + {"required", json::array({"path", "pattern"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + std::string path = params.at("path").get(); + std::string pat_str = params.at("pattern").get(); + std::string include = json_value(params, "include", std::string("**")); + std::string exclude = json_value(params, "exclude", std::string("")); + bool show_lineno = json_value(params, "return_line_numbers", false); + bool literal = json_value(params, "literal", false); + bool ignore_case = json_value(params, "ignore_case", false); + int ctx_lines = std::max(0, json_value(params, "context_lines", 0)); + + std::string pattern_src = pat_str; + if (literal) { + static const std::string specials = "\\^$.|?*+()[]{}"; + std::string escaped; + escaped.reserve(pat_str.size() * 2); + for (char c : pat_str) { + if (specials.find(c) != std::string::npos) escaped += '\\'; + escaped += c; + } + pattern_src = escaped; + } + + std::regex pattern; + try { + auto flags = std::regex::ECMAScript; + if (ignore_case) flags |= std::regex::icase; + pattern = std::regex(pattern_src, flags); + } catch (const std::regex_error & e) { + return {{"error", std::string("invalid regex: ") + e.what()}}; + } + + auto io = make_tools_io(params); + + // collect (absolute_path, display_path) pairs to search + std::vector> files; + + const std::string abs_path = io->resolve(path); + if (io->is_regular_file(abs_path)) { + files.emplace_back(abs_path, path); + } else if (io->is_directory(abs_path)) { + const auto listing = io->list_entries(abs_path, 0, list_kind::files); + if (!listing.err.empty()) { + return {{"error", listing.err + ": " + path}}; + } + for (const auto & entry : listing.entries) { + if (!path_glob_match(include, entry.rel)) continue; + if (!exclude.empty() && path_glob_match(exclude, entry.rel)) continue; + files.emplace_back(path_to_utf8(path_from_utf8(abs_path) / path_from_utf8(entry.rel)), entry.rel); + } + } else { + return {{"error", "path does not exist: " + path}}; + } + + std::ostringstream output_text; + size_t total = 0; + bool limit_reached = false; + bool show_num = show_lineno || ctx_lines > 0; + + for (const auto & file_entry : files) { + if (limit_reached) break; + const std::string & fpath = file_entry.first; + const std::string & display_path = file_entry.second; + + std::string content; + if (!io->read_file(fpath, content)) continue; + std::vector lines; + { + std::istringstream f(content); + std::string line; + while (std::getline(f, line)) lines.push_back(line); + } + + for (size_t i = 0; i < lines.size(); i++) { + if (total >= SERVER_TOOL_GREP_SEARCH_MAX_RESULTS) { + limit_reached = true; + break; + } + if (!std::regex_search(lines[i], pattern)) continue; + + long ctx_start = ctx_lines > 0 ? std::max(0, (long) i - ctx_lines) : (long) i; + long ctx_end = ctx_lines > 0 ? std::min((long) lines.size() - 1, (long) i + ctx_lines) : (long) i; + + for (long j = ctx_start; j <= ctx_end; j++) { + bool is_match = (j == (long) i); + output_text << display_path << (is_match ? ':' : '-'); + if (show_num) { + output_text << (j + 1) << (is_match ? ':' : '-'); + } + output_text << lines[j] << "\n"; + } + if (ctx_lines > 0) { + output_text << "--\n"; + } + total++; + } + } + + output_text << "\n---\nTotal matches: " << total << "\n"; + if (limit_reached) { + output_text << string_format( + "[%zu matches limit reached. Narrow the path/pattern/include to see more.]\n", + SERVER_TOOL_GREP_SEARCH_MAX_RESULTS); + } + + return {{"plain_text_response", output_text.str()}}; + } +}; + +// +// exec_shell_command: run an arbitrary shell command +// + +static constexpr size_t SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_OUTPUT_SIZE = 16 * 1024; // 16 KB +static constexpr int SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_TIMEOUT = 60; // seconds + +struct server_tool_exec_shell_command : server_tool { + server_tool_exec_shell_command() { + name = "exec_shell_command"; + display_name = "Execute shell command"; + uses_cwd = true; + permission_write = true; + support_stream = true; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", "Execute a shell command and return its output (stdout and stderr combined)."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"command", {{"type", "string"}, {"description", "Shell command to execute"}}}, + {"timeout", {{"type", "integer"}, {"description", string_format("Timeout in seconds (default 10, max %d)", SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_TIMEOUT)}}}, + {"max_output_size", {{"type", "integer"}, {"description", string_format("Maximum output size in bytes (default %zu)", SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_OUTPUT_SIZE)}}}, + }}, + {"required", json::array({"command"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream * st) const override { + std::string command = params.at("command").get(); + int timeout = json_value(params, "timeout", 10); + size_t max_output = (size_t) json_value(params, "max_output_size", (int) SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_OUTPUT_SIZE); + + timeout = std::min(timeout, SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_TIMEOUT); + max_output = std::min(max_output, SERVER_TOOL_EXEC_SHELL_COMMAND_MAX_OUTPUT_SIZE); + + // an isolate is always POSIX regardless of host OS, so it always gets `sh -c` +#ifdef _WIN32 + std::vector args = !json_value(params, "runtime", std::string()).empty() + ? std::vector{"sh", "-c", command} + : std::vector{"cmd", "/c", command}; +#else + std::vector args = {"sh", "-c", command}; +#endif + + auto io = make_tools_io(params); + + if (st) { + auto res = io->run(args, max_output, timeout, [st](const std::string & chunk) { + st->push(chunk); + return !st->alive || st->alive(); + }); + if (st->alive && !st->alive()) { + return json(); + } + std::string tail = string_format("\n[exit code: %d]", res.exit_code); + if (res.timed_out) { + tail += " [exit due to timed out]"; + } + st->push(tail); + return json(); + } + + auto res = io->run(args, max_output, timeout); + + std::string text_output = res.output; + text_output += string_format("\n[exit code: %d]", res.exit_code); + if (res.timed_out) { + text_output += " [exit due to timed out]"; + } + + return {{"plain_text_response", text_output}}; + } +}; + +// +// write_file: create or overwrite a file +// + +struct server_tool_write_file : server_tool { + server_tool_write_file() { + name = "write_file"; + display_name = "Write file"; + uses_cwd = true; + permission_write = true; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", "Write content to a file, creating it (including parent directories) if it does not exist. May use with edit_file for more complex edits."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"path", {{"type", "string"}, {"description", "Path of the file to write"}}}, + {"content", {{"type", "string"}, {"description", "Content to write"}}}, + }}, + {"required", json::array({"path", "content"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + std::string path = params.at("path").get(); + std::string content = params.at("content").get(); + + auto io = make_tools_io(params); + if (!io->write_file(path, content)) { + return {{"error", "failed to write file: " + path}}; + } + + return {{"result", "file written successfully"}, {"path", path}, {"bytes", content.size()}}; + } +}; + +// +// edit_file: exact text replacement, one or more edits per call +// + +struct server_tool_edit_file : server_tool { + server_tool_edit_file() { + name = "edit_file"; + display_name = "Edit file"; + uses_cwd = true; + permission_write = true; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", + "Edit a file using exact text replacement. Each edits[].old_text must be unique in the file " + "and is matched against the original content, not incrementally. Merge nearby changes into " + "one edit instead of overlapping edits. Use write_file to replace the whole file."}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"path", {{"type", "string"}, {"description", "Path to the file to edit"}}}, + {"edits", { + {"type", "array"}, + {"description", "One or more exact text replacements to apply"}, + {"items", { + {"type", "object"}, + {"properties", { + {"old_text", {{"type", "string"}, {"description", "Exact text to find; must be unique in the file and must not overlap with other edits"}}}, + {"new_text", {{"type", "string"}, {"description", "Text to replace old_text with"}}}, + }}, + {"required", json::array({"old_text", "new_text"})}, + }}, + }}, + }}, + {"required", json::array({"path", "edits"})}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + std::string path = params.at("path").get(); + const json & edits_json = params.at("edits"); + + if (!edits_json.is_array() || edits_json.empty()) { + return {{"error", "\"edits\" must be a non-empty array"}}; + } + + struct edit_req { + std::string old_text; + std::string new_text; + }; + std::vector edits; + edits.reserve(edits_json.size()); + for (const auto & e : edits_json) { + edit_req er; + er.old_text = e.at("old_text").get(); + er.new_text = e.at("new_text").get(); + if (er.old_text.empty()) { + return {{"error", string_format("edits[%zu].old_text must not be empty", edits.size())}}; + } + edits.push_back(std::move(er)); + } + + auto io = make_tools_io(params); + std::string original_content; + if (!io->read_file(path, original_content)) { + return {{"error", "failed to open file: " + path}}; + } + + // does any old_text need fuzzy matching (no exact match found)? + bool any_fuzzy = false; + for (size_t i = 0; i < edits.size(); i++) { + if (original_content.find(edits[i].old_text) != std::string::npos) continue; + std::string fuzzy_content = normalize_for_fuzzy_match(original_content); + std::string fuzzy_old = normalize_for_fuzzy_match(edits[i].old_text); + if (fuzzy_content.find(fuzzy_old) == std::string::npos) { + return {{"error", string_format( + "could not find edits[%zu].old_text in %s, it must match the file's current content exactly", + i, path.c_str())}}; + } + any_fuzzy = true; + } + + std::string base_content = any_fuzzy ? normalize_for_fuzzy_match(original_content) : original_content; + + // uniqueness check always uses fuzzy-normalized text, so a whitespace-only duplicate still counts + std::vector matched; + matched.reserve(edits.size()); + for (size_t i = 0; i < edits.size(); i++) { + std::string needle = any_fuzzy ? normalize_for_fuzzy_match(edits[i].old_text) : edits[i].old_text; + size_t occurrences = count_occurrences( + normalize_for_fuzzy_match(original_content), + normalize_for_fuzzy_match(edits[i].old_text)); + if (occurrences > 1) { + return {{"error", string_format( + "found %zu occurrences of edits[%zu].old_text in %s, it must be unique", + occurrences, i, path.c_str())}}; + } + size_t idx = base_content.find(needle); + matched.push_back({i, idx, needle.size(), edits[i].new_text}); + } + + std::sort(matched.begin(), matched.end(), [](const matched_edit & a, const matched_edit & b) { + return a.match_index < b.match_index; + }); + for (size_t i = 1; i < matched.size(); i++) { + if (matched[i - 1].match_index + matched[i - 1].match_length > matched[i].match_index) { + return {{"error", string_format( + "edits[%zu] and edits[%zu] overlap in %s; merge them into one edit or target disjoint regions", + matched[i - 1].edit_index, matched[i].edit_index, path.c_str())}}; + } + } + + std::string new_content = any_fuzzy + ? apply_replacements_preserving_unchanged_lines(original_content, base_content, matched) + : apply_replacements(base_content, matched, 0); + + if (new_content == original_content) { + return {{"error", "no changes made: the replacement(s) produced identical content"}}; + } + + if (!io->write_file(path, new_content)) { + return {{"error", "failed to write file: " + path}}; + } + + return {{"result", "file edited successfully"}, {"path", path}, {"edits_applied", (int) matched.size()}}; + } + +private: + // strip trailing whitespace, normalize smart quotes/dashes/spaces to ASCII + static std::string normalize_line_for_fuzzy_match(const std::string & line) { + size_t end = line.size(); + while (end > 0 && (line[end - 1] == ' ' || line[end - 1] == '\t' || line[end - 1] == '\r')) { + end--; + } + std::string s = line.substr(0, end); + + auto replace_all = [](std::string & str, const std::string & from, const std::string & to) { + if (from.empty()) return; + size_t pos = 0; + while ((pos = str.find(from, pos)) != std::string::npos) { + str.replace(pos, from.size(), to); + pos += to.size(); + } + }; + + // smart single quotes -> ' + for (unsigned char b : {0x98, 0x99, 0x9A, 0x9B}) { + replace_all(s, std::string("\xE2\x80") + (char) b, "'"); + } + // smart double quotes -> " + for (unsigned char b : {0x9C, 0x9D, 0x9E, 0x9F}) { + replace_all(s, std::string("\xE2\x80") + (char) b, "\""); + } + // various dashes -> - + for (unsigned char b = 0x90; b <= 0x95; b++) { + replace_all(s, std::string("\xE2\x80") + (char) b, "-"); + } + replace_all(s, "\xE2\x88\x92", "-"); // minus sign + // special spaces -> ' ' + replace_all(s, "\xC2\xA0", " "); // no-break space + for (unsigned char b = 0x82; b <= 0x8A; b++) { + replace_all(s, std::string("\xE2\x80") + (char) b, " "); + } + replace_all(s, "\xE2\x80\xAF", " "); // narrow no-break space + replace_all(s, "\xE2\x81\x9F", " "); // medium mathematical space + replace_all(s, "\xE3\x80\x80", " "); // ideographic space + + return s; + } + + // applies the per-line transform above to every line; preserves line count/positions + static std::string normalize_for_fuzzy_match(const std::string & content) { + std::string result; + result.reserve(content.size()); + size_t start = 0; + while (true) { + size_t nl = content.find('\n', start); + bool is_last = nl == std::string::npos; + std::string line = is_last ? content.substr(start) : content.substr(start, nl - start); + result += normalize_line_for_fuzzy_match(line); + if (is_last) break; + result += '\n'; + start = nl + 1; + } + return result; + } + + // lines with trailing '\n' kept, so untouched ones can be reconstructed verbatim + static std::vector split_lines_with_endings(const std::string & content) { + std::vector lines; + size_t start = 0; + while (start < content.size()) { + size_t nl = content.find('\n', start); + if (nl == std::string::npos) { + lines.push_back(content.substr(start)); + break; + } + lines.push_back(content.substr(start, nl - start + 1)); + start = nl + 1; + } + return lines; + } + + struct line_span { + size_t start; + size_t end; + }; + + static std::vector get_line_spans(const std::string & content) { + std::vector spans; + size_t offset = 0; + for (const auto & line : split_lines_with_endings(content)) { + spans.push_back({offset, offset + line.size()}); + offset += line.size(); + } + return spans; + } + + // count non-overlapping occurrences of `needle` in `content` + static size_t count_occurrences(const std::string & content, const std::string & needle) { + if (needle.empty()) return 0; + size_t count = 0, pos = 0; + while ((pos = content.find(needle, pos)) != std::string::npos) { + count++; + pos += needle.size(); + } + return count; + } + + struct matched_edit { + size_t edit_index; + size_t match_index; // offset into the "base content" (see below) + size_t match_length; + std::string new_text; + }; + + // replacements must be sorted ascending by match_index and non-overlapping + static std::string apply_replacements( + const std::string & content, + const std::vector & replacements, + size_t offset) { + std::string result = content; + for (auto it = replacements.rbegin(); it != replacements.rend(); ++it) { + size_t local_index = it->match_index - offset; + result = result.substr(0, local_index) + it->new_text + result.substr(local_index + it->match_length); + } + return result; + } + + // widen a replacement's byte range to the line(s) of `lines` it touches + static bool get_replacement_line_range( + const std::vector & lines, + size_t match_index, size_t match_length, + size_t & out_start_line, size_t & out_end_line /* exclusive */) { + size_t replacement_start = match_index; + size_t replacement_end = match_index + match_length; + + size_t start_line = (size_t) -1; + for (size_t i = 0; i < lines.size(); i++) { + if (replacement_start >= lines[i].start && replacement_start < lines[i].end) { + start_line = i; + break; + } + } + if (start_line == (size_t) -1) return false; + + size_t end_line = start_line; + while (end_line < lines.size() && lines[end_line].end < replacement_end) { + end_line++; + } + if (end_line >= lines.size()) return false; + + out_start_line = start_line; + out_end_line = end_line + 1; + return true; + } + + // like apply_replacements, but untouched lines come from `original_content` + static std::string apply_replacements_preserving_unchanged_lines( + const std::string & original_content, + const std::string & base_content, + const std::vector & replacements /* ascending, non-overlapping */) { + auto original_lines = split_lines_with_endings(original_content); + auto base_lines = get_line_spans(base_content); + + struct group { + size_t start_line; + size_t end_line; // exclusive + std::vector reps; + }; + std::vector groups; + + for (const auto & rep : replacements) { + size_t start_line = 0, end_line = 0; + get_replacement_line_range(base_lines, rep.match_index, rep.match_length, start_line, end_line); + if (!groups.empty() && start_line < groups.back().end_line) { + groups.back().end_line = std::max(groups.back().end_line, end_line); + groups.back().reps.push_back(rep); + } else { + groups.push_back({start_line, end_line, {rep}}); + } + } + + size_t original_line_index = 0; + std::string result; + for (auto & g : groups) { + for (size_t i = original_line_index; i < g.start_line; i++) { + result += original_lines[i]; + } + + size_t group_start_offset = base_lines[g.start_line].start; + size_t group_end_offset = base_lines[g.end_line - 1].end; + std::string slice = base_content.substr(group_start_offset, group_end_offset - group_start_offset); + result += apply_replacements(slice, g.reps, group_start_offset); + + original_line_index = g.end_line; + } + for (size_t i = original_line_index; i < original_lines.size(); i++) { + result += original_lines[i]; + } + + return result; + } +}; + +// +// get_datetime: returns the current date and time +// + +struct server_tool_get_datetime : server_tool { + server_tool_get_datetime() { + name = "get_datetime"; + display_name = "Get Date & Time"; + permission_write = false; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", "Returns the current date and time in UTC"}, + {"parameters", { + {"type", "object"}, + {"properties", { + {"format", { + {"type", "string"}, + {"description", + "strftime()-style format string for the output (default: \"%Y-%m-%dT%H:%M:%SZ\", " + "e.g. ISO 8601). Choose your own format if you need something else, " + "e.g. \"%A, %B %d %Y\" for a human-readable date."}, + }}, + }}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + std::string format = json_value(params, "format", std::string("%Y-%m-%dT%H:%M:%SZ")); + + auto now = std::chrono::system_clock::now(); + auto time = std::chrono::system_clock::to_time_t(now); + std::tm tm_utc; +#ifdef _WIN32 + gmtime_s(&tm_utc, &time); +#else + gmtime_r(&time, &tm_utc); +#endif + + char buf[256]; + size_t len = std::strftime(buf, sizeof(buf), format.c_str(), &tm_utc); + if (len == 0) { + return {{"error", "invalid format string"}}; + } + + return {{"result", std::string(buf, len)}}; + } +}; + +// +// get_info: returns runtime info (OS name/version and cwd) +// + +static constexpr size_t SERVER_TOOL_GET_INFO_MAX_OUTPUT = 4096; +static constexpr int SERVER_TOOL_GET_INFO_TIMEOUT = 5; // seconds + +struct server_tool_get_info : server_tool { + server_tool_get_info() { + name = "get_info"; + display_name = "Get Runtime Info"; + uses_cwd = true; + permission_write = false; + } + + json get_definition() const override { + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", "Returns runtime info: the OS name/version and the current working directory"}, + {"parameters", { + {"type", "object"}, + {"properties", json::object()}, + }}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + auto io = make_tools_io(params); + + // inside an isolate, we always use the linux command +#ifdef _WIN32 + std::vector args = !json_value(params, "runtime", std::string()).empty() + ? std::vector{"uname", "-a"} + : std::vector{"cmd", "/c", "ver"}; +#else + std::vector args = {"uname", "-a"}; +#endif + + auto res = io->run(args, SERVER_TOOL_GET_INFO_MAX_OUTPUT, SERVER_TOOL_GET_INFO_TIMEOUT); + // "ver" prints a blank line before the version, so the output is stripped on both ends; + // a failed spawn or a timeout leaves a diagnostic in res.output, which is not an OS name + std::string os_info = res.exit_code == 0 && !res.timed_out ? string_strip(res.output) : "unknown"; + + std::string cwd = json_value(params, "cwd", std::string()); + if (cwd.empty()) { + if (json_value(params, "runtime", std::string()).empty()) { + std::error_code ec; + cwd = path_to_utf8(fs::current_path(ec)); + } else { + auto pwd = io->run({"pwd"}, SERVER_TOOL_GET_INFO_MAX_OUTPUT, SERVER_TOOL_GET_INFO_TIMEOUT); + cwd = pwd.exit_code == 0 && !pwd.timed_out ? string_strip(pwd.output) : "unknown"; + } + } + + return { + {"os", os_info}, + {"cwd", cwd}, + }; + } +}; + +struct server_tool_stream_result : server_task_result { + std::string chunk; + bool done = false; + std::string error_msg; + + json to_json() override { + if (!done) { + return {{"chunk", chunk}}; + } else { + json result = {{"done", true}}; + if (!error_msg.empty()) { + result["error"] = error_msg; + } + return result; + } + } +}; + +void server_tool::stream::push(const std::string & chunk) { + if (chunk.empty()) return; + auto r = std::make_unique(); + r->id = id; + r->chunk = chunk; + qr.send(std::move(r)); +} + +struct server_tools_res : server_http_res { + std::thread worker; + server_response * qr = nullptr; // set only for streaming responses + int id = -1; + + ~server_tools_res() override { + if (worker.joinable()) { + worker.join(); + } + if (qr) { + qr->remove_waiting_task_id(id); + } + } +}; + +// +// server_mcp_tool: exposes one tool from a running MCP server as a server_tool. +// +struct server_mcp_tool : server_tool { + std::string server_name; + std::string tool_name; + server_mcp_tool_def def; + server_mcp & mcp_mgr; + + server_mcp_tool(server_mcp_tool_def d, server_mcp & mgr) + : server_name(d.server_name) + , tool_name(d.name) + , def(std::move(d)) + , mcp_mgr(mgr) + { + name = server_name + "_" + tool_name; + display_name = name; + permission_write = false; + support_stream = false; + } + + std::string type() const override { return "mcp"; } + + json get_definition() const override { + json schema = def.input_schema; + if (schema.is_null() || !schema.is_object()) { + schema = json::object(); + } + return { + {"type", "function"}, + {"function", { + {"name", name}, + {"description", def.description}, + {"parameters", schema}, + }}, + }; + } + + json invoke(json params, server_tool::stream *) const override { + return mcp_mgr.call_tool(server_name, tool_name, params); + } +}; + +// resolves --tools-runtime into the isolate that every tool call runs through +// spec() returns the runtime string make_tools_io() takes, and runs once per tool call +struct server_tools_runtime { + virtual ~server_tools_runtime() = default; + virtual std::string spec() = 0; +}; + +// a target that already exists and needs no lifecycle +// the spec is validated once at startup, then passed straight through +struct server_tools_static_runtime : server_tools_runtime { + explicit server_tools_static_runtime(std::string spec) : runtime_spec(std::move(spec)) {} + std::string spec() override { return runtime_spec; } + +private: + std::string runtime_spec; +}; + +// owns the container the tools run in, as set by --tools-runtime ":" +// it is spawned here and stopped when the server exits +struct server_tools_container_runtime : server_tools_runtime { + server_tools_container_runtime(const server_tools_container_runtime &) = delete; + + explicit server_tools_container_runtime(const std::string & spec) { + container_runtime_spec parsed; + if (!container_runtime_spec::parse(spec, parsed)) { + throw std::runtime_error("unknown --tools-runtime option: " + spec); + } + + bin = parsed.bin; + image = parsed.arg; + if (image.empty()) { + throw std::runtime_error("--tools-runtime " + bin + ": requires an image name"); + } + spawn(); + } + + ~server_tools_container_runtime() override { + // closing stdin signals the container's shell (its pid 1) to exit; --rm then removes it + proc.close_stdin(); + proc.join(); + } + + // respawns a container that died on its own, so the returned spec always names a running one + std::string spec() override { + std::lock_guard lock(mutex); + if (!proc.alive()) { + SRV_WRN("%s tools runtime container \"%s\" died, respawning\n", bin.c_str(), container_id.c_str()); + spawn(); + } + return bin + "-container:" + container_id; + } + +private: + std::string bin; + std::string image; + std::string container_id; + common_subproc proc; // ` run` client that keeps the container alive + std::mutex mutex; + + // spawns " run --rm -i sh" and keeps its stdin open; the shell blocks reading stdin, + // so the container stays alive until we close it (see destructor) or it is killed from the outside + void spawn() { + // create() writes over the handle it is given, so the previous one is released first + proc.join(); + + std::error_code ec; + fs::path cidfile = fs::temp_directory_path(ec) / string_format( + "llama-tools-runtime-cid-%zu.tmp", std::hash{}(std::this_thread::get_id())); + fs::remove(cidfile, ec); + + std::vector args = {bin, "run", "--rm", "-i", "--cidfile", path_to_utf8(cidfile), image, "sh"}; + int options = subprocess_option_no_window + | subprocess_option_inherit_environment + | subprocess_option_search_user_path; + if (!proc.create(args, options)) { + throw std::runtime_error("failed to spawn " + bin + " container for tools runtime (image: " + image + ")"); + } + + std::string cid; + for (int i = 0; i < 100 && cid.empty(); i++) { + std::ifstream f(cidfile); + if (f) std::getline(f, cid); + if (cid.empty()) std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + fs::remove(cidfile, ec); + if (cid.empty()) { + proc.terminate(); + throw std::runtime_error("timed out waiting for " + bin + " container to start (image: " + image + ")"); + } + container_id = cid; + } +}; + +static server_tool & find_tool(std::vector> & tools, const std::string & name, bool require_stream) { + for (auto & t : tools) { + if (t->name == name) { + if (require_stream && !t->support_stream) { + throw std::invalid_argument(string_format("tool \"%s\" does not support stream = true", name.c_str())); + } + return *t; + } + } + throw std::invalid_argument(string_format("unknown tool \"%s\"", name.c_str())); +} + +// +// public API +// + +static std::vector> build_tools() { + std::vector> tools; + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + tools.push_back(std::make_unique()); + return tools; +} + +static std::string str_to_lower(const std::string & value) { + std::string lowered(value.size(), '\0'); + std::transform(value.begin(), value.end(), lowered.begin(), [](unsigned char c) { return std::tolower(c); }); + return lowered; +} + +static std::string get_header(const std::map & headers, const std::string & key, std::string default_value = "") { + const auto lowered_key = str_to_lower(key); + for (const auto & h : headers) { + if (str_to_lower(h.first) == lowered_key) { + return h.second; + } + } + return default_value; +} + +server_tools::server_tools() = default; +server_tools::~server_tools() = default; + +// the ":" form owns a container lifecycle +// anything else names an existing target, so only its spec is validated here at startup +static std::unique_ptr make_tools_runtime(const std::string & spec) { + container_runtime_spec parsed; + if (container_runtime_spec::parse(spec, parsed) && !parsed.attach) { + return std::make_unique(spec); + } + make_tools_io({{"runtime", spec}}); // nothing to own, just reject a bad spec now + return std::make_unique(spec); +} + +void server_tools::setup(const std::vector & enabled_tools, + server_mcp & mcp_mgr, + const std::string & tools_runtime) { + if (!tools_runtime.empty()) { + runtime = make_tools_runtime(tools_runtime); + } + + if (!enabled_tools.empty()) { + if (!common_subproc::is_supported()) { + throw std::runtime_error("subprocess is not enabled on this build"); + } + + std::unordered_set enabled_set(enabled_tools.begin(), enabled_tools.end()); + auto all_tools = build_tools(); + + // collect all known tool names for validation + std::vector known_names; + known_names.reserve(all_tools.size()); + for (const auto & t : all_tools) { + known_names.push_back(t->name); + } + + // validate that every requested tool is known + for (const auto & name : enabled_tools) { + if (name == "all") continue; + if (std::find(known_names.begin(), known_names.end(), name) == known_names.end()) { + throw std::runtime_error(string_format( + "unknown tool \"%s\". available tools: %s", + name.c_str(), + string_join(known_names, ", ").c_str())); + } + } + + tools.clear(); + for (auto & t : all_tools) { + if (enabled_set.count(t->name) > 0 || enabled_set.count("all") > 0) { + tools.push_back(std::move(t)); + } + } + } + + // append MCP tools, skipping any that collide with a built-in or another MCP tool of the same "_" name + if (!mcp_mgr.empty()) { + std::unordered_set seen_names; + for (auto & t : tools) { + seen_names.insert(t->name); + } + size_t n_added = 0; + for (const auto & def : mcp_mgr.list_tools()) { + std::string mcp_name = def.server_name + "_" + def.name; + if (seen_names.count(mcp_name)) { + SRV_WRN("MCP tool \"%s\" from server \"%s\" collides with an existing tool, skipping\n", + mcp_name.c_str(), def.server_name.c_str()); + continue; + } + seen_names.insert(mcp_name); + tools.push_back(std::make_unique(def, mcp_mgr)); + n_added++; + } + if (n_added > 0) { + SRV_INF("Added %zu MCP tools\n", n_added); + } + } + + handle_get = [this](const server_http_req &) -> server_http_res_ptr { + auto res = std::make_unique(); + try { + json result = json::array(); + for (const auto & t : tools) { + result.push_back(t->to_json()); + } + res->data = safe_json_to_str(result); + } catch (const std::exception & e) { + SRV_ERR("got exception: %s\n", e.what()); + res->status = 500; + res->data = safe_json_to_str(format_error_response(e.what(), ERROR_TYPE_SERVER)); + } + return res; + }; + + handle_post = [this](const server_http_req & req) -> server_http_res_ptr { + auto res = std::make_unique(); + try { + json body = json::parse(req.body); + std::string tool_name = body.at("tool").get(); + json params = body.value("params", json::object()); + bool stream = body.value("stream", false); + + // accept x-tool-cwd header to override of the process + if (params.contains("cwd")) { + params.erase("cwd"); + } + auto cwd = get_header(req.headers, "x-tool-cwd"); + if (!cwd.empty()) { + params["cwd"] = cwd; + } + + // accept x-tool-runtime header to route tool I/O through an isolate, e.g. "docker-container:"; + // falls back to the --tools-runtime isolate, if configured + if (params.contains("runtime")) { + params.erase("runtime"); + } + auto runtime_header = get_header(req.headers, "x-tool-runtime"); + if (!runtime_header.empty()) { + params["runtime"] = runtime_header; + } else if (runtime) { + params["runtime"] = runtime->spec(); + } + + server_tool & tool = find_tool(tools, tool_name, stream); + + if (stream) { + int id = res_id.fetch_add(1); + queue_res.add_waiting_task_id(id); + res->qr = &queue_res; + res->id = id; + + res->worker = std::thread([this, id, &req, &tool, params]() mutable { + server_tool::stream st{queue_res, id, [&req]() { + return !req.should_stop(); + }}; + + auto done = std::make_unique(); + try { + tool.invoke(params, &st); + } catch (const std::exception & e) { + done->error_msg = e.what(); + } catch (...) { + done->error_msg = "An unknown error occurred"; + } + done->id = st.id; + done->done = true; + st.qr.send(std::move(done)); + }); + + res->content_type = "text/event-stream"; + res->status = 200; + res->next = [this, id](std::string & output) -> bool { + auto result = queue_res.recv(id); + auto * r = dynamic_cast(result.get()); + GGML_ASSERT(r != nullptr); + output = "data: " + safe_json_to_str(r->to_json()) + "\n\n"; + if (r->done) { + queue_res.remove_waiting_task_id(id); + return false; + } + return true; + }; + } else { + json result = tool.invoke(params, nullptr); + res->status = 200; + res->data = safe_json_to_str(result); + } + } catch (const json::exception & e) { + res->status = 400; + res->data = safe_json_to_str(format_error_response(e.what(), ERROR_TYPE_INVALID_REQUEST)); + } catch (const std::invalid_argument & e) { + res->status = 404; + res->data = safe_json_to_str(format_error_response(e.what(), ERROR_TYPE_INVALID_REQUEST)); + } catch (const std::exception & e) { + SRV_ERR("got exception: %s\n", e.what()); + res->status = 500; + res->data = safe_json_to_str(format_error_response(e.what(), ERROR_TYPE_SERVER)); + } + return res; + }; +} diff --git a/tools/server/server-tools.h b/tools/server/server-tools.h new file mode 100644 index 0000000000000000000000000000000000000000..c4509ca80fbfcb9f475be55e350c5deaeea1a558 --- /dev/null +++ b/tools/server/server-tools.h @@ -0,0 +1,55 @@ +#pragma once + +#include "server-common.h" +#include "server-http.h" +#include "server-queue.h" +#include "server-mcp.h" + +#include +#include +#include + +struct server_tool { + std::string name; + std::string display_name; + bool permission_write = false; + bool support_stream = false; // if true, output can be streamed + bool uses_cwd = false; // if true, the tool resolves paths and runs against the working directory + + virtual ~server_tool() = default; + virtual json get_definition() const = 0; + virtual std::string type() const { return "builtin"; } + + struct stream { + server_response & qr; + int id; + std::function alive; + void push(const std::string & chunk); + }; + virtual json invoke(json params, stream * st = nullptr) const = 0; + + json to_json() const; +}; + +struct server_tools_runtime; // impl detail, defined in server-tools.cpp + +struct server_tools { + std::vector> tools; + + // for streaming + server_response queue_res; + std::atomic res_id{0}; + + // set when --tools-runtime is configured; routes every tool call through an isolate + std::unique_ptr runtime; + + void setup(const std::vector & enabled_tools, + server_mcp & mcp_mgr, + const std::string & tools_runtime); + + server_http_context::handler_t handle_get; + server_http_context::handler_t handle_post; + + server_tools(); + ~server_tools(); +}; diff --git a/tools/server/server.cpp b/tools/server/server.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6d1aa43516e25b539bbc4825ca577b9e83902732 --- /dev/null +++ b/tools/server/server.cpp @@ -0,0 +1,537 @@ +#include "server-context.h" +#include "server-http.h" +#include "server-models.h" +#include "server-cors-proxy.h" +#include "server-stream.h" +#include "server-tools.h" + +#include "arg.h" +#include "build-info.h" +#include "common.h" +#include "fit.h" +#include "llama.h" +#include "log.h" + +#include +#include +#include +#include +#include // for std::thread::hardware_concurrency + +#if defined(_WIN32) +#include +#endif + +static std::function shutdown_handler; +static std::atomic_flag is_terminating = ATOMIC_FLAG_INIT; + +static inline void signal_handler(int signal) { + if (is_terminating.test_and_set()) { + // in case it hangs, we can force terminate the server by hitting Ctrl+C twice + // this is for better developer experience, we can remove when the server is stable enough + fprintf(stderr, "Received second interrupt, terminating immediately.\n"); + exit(1); + } + + shutdown_handler(signal); +} + +// satisfies -Wmissing-declarations (used by llama command) +int llama_server(int argc, char ** argv); + +// to be used via CLI (argc / argv are used by router mode only) +int llama_server(common_params & params, int argc, char ** argv); +void llama_server_terminate(); +void llama_server_terminate() { + if (shutdown_handler) { + shutdown_handler(0); + } +} + + +// wrapper function that handles exceptions and logs errors +// this is to make sure handler_t never throws exceptions; instead, it returns an error response +static server_http_context::handler_t ex_wrapper(server_http_context::handler_t func) { + return [func = std::move(func)](const server_http_req & req) -> server_http_res_ptr { + std::string message; + error_type error; + try { + return func(req); + } catch (const std::invalid_argument & e) { + // treat invalid_argument as invalid request (400) + error = ERROR_TYPE_INVALID_REQUEST; + message = e.what(); + } catch (const std::exception & e) { + // treat other exceptions as server error (500) + error = ERROR_TYPE_SERVER; + message = e.what(); + } catch (...) { + error = ERROR_TYPE_SERVER; + message = "unknown error"; + } + + auto res = std::make_unique(); + res->status = 500; + try { + json error_data = format_error_response(message, error); + res->status = json_value(error_data, "code", 500); + res->data = safe_json_to_str({{ "error", error_data }}); + SRV_WRN("got exception: %s\n", res->data.c_str()); + } catch (const std::exception & e) { + SRV_ERR("got another exception: %s | while handling exception: %s\n", e.what(), message.c_str()); + res->data = "Internal Server Error"; + } + return res; + }; +} + +int llama_server(int argc, char ** argv) { + std::setlocale(LC_NUMERIC, "C"); + +#ifndef _WIN32 + // Ignore SIGPIPE so the server does not crash if a child (MCP server, tools runtime) exits while we are writing to its stdin + signal(SIGPIPE, SIG_IGN); +#endif + + // own arguments required by this example + common_params params; + + common_init(); + + // start the stream session manager GC right after common init, before any HTTP route can + // touch it. lifecycle is symmetric, stop_gc() runs in clean_up() before backend free + server_stream_session_manager_start(); + + if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_SERVER)) { + return 1; + } + + llama_backend_init(); + llama_numa_init(params.numa); + + return llama_server(params, argc, argv); +} + +int llama_server(common_params & params, int argc, char ** argv) { + bool is_run_by_cli = (argv == nullptr); + + common_models_handler models_handler; + + // note: router mode also accepts -hf remote-preset, so we need to check that first + if (!is_run_by_cli && !params.model.hf_repo.empty()) { + try { + models_handler = common_models_handler_init(params, LLAMA_EXAMPLE_SERVER); + if (common_models_handler_is_preset_repo(models_handler)) { + // apply the preset and start the server in router mode + common_models_handler_apply(models_handler, params); + } + } catch (const std::exception & e) { + SRV_ERR("failed to fetch model metadata: %s\n", e.what()); + return 1; + } + } + + // router server never loads a model and must not touch the GPU + const bool is_router_server = params.model.path.empty() + && params.model.hf_repo.empty(); + + // skip device enumeration so the CUDA primary context stays uncreated + common_params_print_info(params, !is_router_server); + + if (!is_router_server) { + // validate batch size for embeddings + // embeddings require all tokens to be processed in a single ubatch + // see https://github.com/ggml-org/llama.cpp/issues/12836 + if (params.embedding && params.n_batch > params.n_ubatch) { + SRV_WRN("embeddings enabled with n_batch (%d) > n_ubatch (%d)\n", params.n_batch, params.n_ubatch); + SRV_WRN("setting n_batch = n_ubatch = %d to avoid assertion failure\n", params.n_ubatch); + params.n_batch = params.n_ubatch; + } + + if (params.n_parallel < 0) { + SRV_TRC("%s", "n_parallel is set to auto, using n_parallel = 4 and kv_unified = true\n"); + + params.n_parallel = 4; + params.kv_unified = true; + } + } + + // for consistency between server router mode and single-model mode, we set the same model name as alias + auto model_name = params.model.get_name(); + if (params.model_alias.empty() && !model_name.empty()) { + params.model_alias.insert(model_name); + } + + // note: this is guaranteed to out-live ctx_http and tools + server_mcp mcp_mgr; + + // struct that contains llama context and inference + server_context ctx_server; + + server_http_context ctx_http; + if (!ctx_http.init(params)) { + SRV_ERR("%s", "failed to initialize HTTP server\n"); + return 1; + } + + // + // Router + // + + // register API routes + server_child child; // only used in non-router mode + server_routes routes(params, ctx_server); + server_tools tools; + + std::optional models_routes{}; + if (is_router_server) { + // setup server instances manager + try { + models_routes.emplace(params, argc, argv); + } catch (const std::exception & e) { + SRV_ERR("failed to initialize router models: %s\n", e.what()); + return 1; + } + + // proxy handlers + // note: routes.get_health stays the same + routes.get_metrics = models_routes->proxy_get; + routes.post_props = models_routes->proxy_post; + routes.post_completions = models_routes->proxy_post; + routes.post_completions_oai = models_routes->proxy_post; + routes.post_chat_completions = models_routes->proxy_post; + routes.post_control = models_routes->proxy_post; + routes.post_responses_oai = models_routes->proxy_post; + routes.post_transcriptions_oai = models_routes->proxy_post; + routes.post_anthropic_messages = models_routes->proxy_post; + routes.post_anthropic_count_tokens = models_routes->proxy_post; + routes.post_infill = models_routes->proxy_post; + routes.post_embeddings = models_routes->proxy_post; + routes.post_embeddings_oai = models_routes->proxy_post; + routes.post_rerank = models_routes->proxy_post; + routes.post_tokenize = models_routes->proxy_post; + routes.post_detokenize = models_routes->proxy_post; + routes.post_apply_template = models_routes->proxy_post; + routes.post_chat_completions_tok = models_routes->proxy_post; + routes.post_responses_tok_oai = models_routes->proxy_post; + routes.get_lora_adapters = models_routes->proxy_get; + routes.post_lora_adapters = models_routes->proxy_post; + routes.get_slots = models_routes->proxy_get; + routes.post_slots = models_routes->proxy_post; + + // custom routes for router + routes.get_props = models_routes->get_router_props; + routes.get_models = models_routes->get_router_models; + + ctx_http.post("/models", ex_wrapper(models_routes->post_router_models)); + ctx_http.post("/models/load", ex_wrapper(models_routes->post_router_models_load)); + ctx_http.post("/models/unload", ex_wrapper(models_routes->post_router_models_unload)); + ctx_http.get ("/models/sse", ex_wrapper(models_routes->get_router_models_sse)); + ctx_http.del ("/models", ex_wrapper(models_routes->del_router_models)); + } + + ctx_http.get ("/health", ex_wrapper(routes.get_health)); // public endpoint (no API key check) + ctx_http.get ("/v1/health", ex_wrapper(routes.get_health)); // public endpoint (no API key check) + ctx_http.get ("/metrics", ex_wrapper(routes.get_metrics)); + ctx_http.get ("/props", ex_wrapper(routes.get_props)); + ctx_http.post("/props", ex_wrapper(routes.post_props)); + ctx_http.get ("/models", ex_wrapper(routes.get_models)); // public endpoint (no API key check) + ctx_http.get ("/v1/models", ex_wrapper(routes.get_models)); // public endpoint (no API key check) + ctx_http.post("/completion", ex_wrapper(routes.post_completions)); // legacy + ctx_http.post("/completions", ex_wrapper(routes.post_completions)); + ctx_http.post("/v1/completions", ex_wrapper(routes.post_completions_oai)); + ctx_http.post("/chat/completions", ex_wrapper(routes.post_chat_completions)); + ctx_http.post("/v1/chat/completions", ex_wrapper(routes.post_chat_completions)); + ctx_http.post("/v1/chat/completions/control", ex_wrapper(routes.post_control)); + ctx_http.post("/v1/responses", ex_wrapper(routes.post_responses_oai)); + ctx_http.post("/responses", ex_wrapper(routes.post_responses_oai)); + ctx_http.post("/v1/audio/transcriptions", ex_wrapper(routes.post_transcriptions_oai)); + ctx_http.post("/audio/transcriptions", ex_wrapper(routes.post_transcriptions_oai)); + ctx_http.post("/v1/messages", ex_wrapper(routes.post_anthropic_messages)); // anthropic messages API + ctx_http.post("/infill", ex_wrapper(routes.post_infill)); + ctx_http.post("/embedding", ex_wrapper(routes.post_embeddings)); // legacy + ctx_http.post("/embeddings", ex_wrapper(routes.post_embeddings)); + ctx_http.post("/v1/embeddings", ex_wrapper(routes.post_embeddings_oai)); + ctx_http.post("/rerank", ex_wrapper(routes.post_rerank)); + ctx_http.post("/reranking", ex_wrapper(routes.post_rerank)); + ctx_http.post("/v1/rerank", ex_wrapper(routes.post_rerank)); + ctx_http.post("/v1/reranking", ex_wrapper(routes.post_rerank)); + ctx_http.post("/tokenize", ex_wrapper(routes.post_tokenize)); + ctx_http.post("/detokenize", ex_wrapper(routes.post_detokenize)); + ctx_http.post("/apply-template", ex_wrapper(routes.post_apply_template)); + // token counting + ctx_http.post("/chat/completions/input_tokens", ex_wrapper(routes.post_chat_completions_tok)); + ctx_http.post("/v1/chat/completions/input_tokens", ex_wrapper(routes.post_chat_completions_tok)); + ctx_http.post("/responses/input_tokens", ex_wrapper(routes.post_responses_tok_oai)); + ctx_http.post("/v1/responses/input_tokens", ex_wrapper(routes.post_responses_tok_oai)); + ctx_http.post("/v1/messages/count_tokens", ex_wrapper(routes.post_anthropic_count_tokens)); // anthropic token counting + // LoRA adapters hotswap + ctx_http.get ("/lora-adapters", ex_wrapper(routes.get_lora_adapters)); + ctx_http.post("/lora-adapters", ex_wrapper(routes.post_lora_adapters)); + // Save & load slots + ctx_http.get ("/slots", ex_wrapper(routes.get_slots)); + ctx_http.post("/slots/:id_slot", ex_wrapper(routes.post_slots)); + + // resumable streaming: a child binds the local session factories, the router binds + // proxies that resolve the owning child, see server-stream.h + server_http_context::handler_t stream_get_h; + server_http_context::handler_t streams_lookup_h; + server_http_context::handler_t stream_delete_h; + if (is_router_server) { + stream_get_h = models_routes->router_stream_get; + streams_lookup_h = models_routes->router_streams_lookup; + stream_delete_h = models_routes->router_stream_delete; + } else { + stream_get_h = server_stream_make_get_handler(); + streams_lookup_h = server_stream_make_lookup_handler(); + stream_delete_h = server_stream_make_delete_handler(); + } + ctx_http.get ("/v1/stream", ex_wrapper(stream_get_h)); + ctx_http.post("/v1/streams/lookup", ex_wrapper(streams_lookup_h)); + ctx_http.del ("/v1/stream", ex_wrapper(stream_delete_h)); + + // Google Cloud Platform (Vertex AI) compat + ctx_http.register_gcp_compat(); + + // return 403 for disabled features + server_http_context::handler_t res_403 = [](const server_http_req &) { + auto res = std::make_unique(); + res->status = 403; + res->data = safe_json_to_str({ + {"error", { + {"message", "this feature is disabled"}, + {"type", "feature_disabled"}, + }} + }); + return res; + }; + + if (params.cors_origins == "*" && params.api_keys.empty()) { + SRV_WRN("%s", "-----------------\n"); + SRV_WRN("%s", "CORS is set to allow all origins ('*') and no API key is set\n"); + SRV_WRN("%s", "this can be a security risk (cross-origin attacks)\n"); + SRV_WRN("%s", "more info: https://github.com/ggml-org/llama.cpp/pull/25655\n"); + SRV_WRN("%s", "-----------------\n"); + } + + // CORS proxy (EXPERIMENTAL, only used by the Web UI for MCP) + std::vector warn_names; + if (is_router_server) { + warn_names.push_back("router mode"); + } + + if (params.ui_mcp_proxy) { + ctx_http.get ("/cors-proxy", ex_wrapper(proxy_handler_get)); + ctx_http.post("/cors-proxy", ex_wrapper(proxy_handler_post)); + warn_names.push_back("MCP proxy (experimental)"); + } else { + ctx_http.get ("/cors-proxy", ex_wrapper(res_403)); + ctx_http.post("/cors-proxy", ex_wrapper(res_403)); + } + + try { + mcp_mgr.start(params); + } catch (const std::exception & e) { + SRV_ERR("MCP starting failed: %s\n", e.what()); + return 1; + } + + if (!params.server_tools.empty() || !mcp_mgr.empty()) { + try { + tools.setup(params.server_tools, mcp_mgr, params.server_tools_runtime); + } catch (const std::exception & e) { + SRV_ERR("tools setup failed: %s\n", e.what()); + return 1; + } + ctx_http.get ("/tools", ex_wrapper(tools.handle_get)); + ctx_http.post("/tools", ex_wrapper(tools.handle_post)); + if (!params.server_tools.empty()) { + warn_names.push_back("built-in tools (experimental)"); + } + if (!params.server_tools_runtime.empty()) { + warn_names.push_back("tools runtime (experimental)"); + } + if (!mcp_mgr.empty()) { + warn_names.push_back("MCP servers (experimental)"); + } + } else { + ctx_http.get ("/tools", ex_wrapper(res_403)); + ctx_http.post("/tools", ex_wrapper(res_403)); + } + + if (warn_names.size() > 0) { + SRV_WRN("%s", "-----------------\n"); + SRV_WRN("%s", "the following feature(s) are enabled:\n"); + for (const auto & name : warn_names) { + SRV_WRN(" %s\n", name.c_str()); + } + SRV_WRN("%s", "do not expose the server to untrusted environments\n"); + SRV_WRN("%s", "-----------------\n"); + } + + // + // Handle downloading model + // + + if (child.is_child() && child.get_mode() == SERVER_CHILD_MODE_DOWNLOAD) { + return child.run_download(params); + } else if (!is_router_server && !is_run_by_cli) { + // single-model mode (NOT spawned by router) + // if this is invoked by CLI, model downloading should be already handled + try { + common_models_handler_apply(models_handler, params); + } catch (const std::exception & e) { + SRV_ERR("failed to download model: %s\n", e.what()); + return 1; + } + } + + // + // Start the server + // + + std::function clean_up; + + if (is_router_server) { + SRV_INF("%s", "starting server in router mode. models will be automatically loaded on-demand\n"); + + clean_up = [&models_routes, &mcp_mgr]() { + SRV_INF("%s: cleaning up before exit...\n", __func__); + // stop the session GC first, it finalizes live sessions and wakes pending readers + server_stream_session_manager_stop(); + if (models_routes.has_value()) { + models_routes->stopping.store(true); // maybe redundant, but just to be safe + models_routes->models.unload_all(); + } + mcp_mgr.shutdown(); + llama_backend_free(); + }; + + if (!ctx_http.start()) { + clean_up(); + SRV_ERR("%s", "exiting due to HTTP server error\n"); + return 1; + } + ctx_http.is_ready.store(true); + + shutdown_handler = [&](int) { + if (models_routes.has_value()) { + // important to disconnect any SSE clients + models_routes->stopping.store(true); + } + mcp_mgr.shutdown(); + ctx_http.stop(); + }; + + } else { + // setup clean up function, to be called before exit + clean_up = [&ctx_http, &ctx_server, &mcp_mgr]() { + SRV_INF("%s: cleaning up before exit...\n", __func__); + // stop the session GC first, it finalizes live sessions and wakes pending readers + server_stream_session_manager_stop(); + ctx_http.stop(); + ctx_server.terminate(); + mcp_mgr.shutdown(); + llama_backend_free(); + }; + + // start the HTTP server before loading the model to be able to serve /health requests + if (!ctx_http.start()) { + clean_up(); + SRV_ERR("%s", "exiting due to HTTP server error\n"); + return 1; + } + + // setup communication child --> router if necessary + if (child.is_child()) { + ctx_server.set_state_callback([&](server_state state, json payload) { + child.notify_to_router(server_state_to_str(state), payload); + }); + } + + if (!ctx_server.load_model(params)) { + clean_up(); + if (ctx_http.thread.joinable()) { + ctx_http.thread.join(); + } + SRV_ERR("%s", "exiting due to model loading error\n"); + return 1; + } + + routes.update_meta(ctx_server); + ctx_http.is_ready.store(true); + + SRV_INF("%s", "model loaded\n"); + + shutdown_handler = [&](int) { + mcp_mgr.shutdown(); + // this will unblock start_loop() + ctx_server.terminate(); + }; + } + + // register signal handler if not running by CLI + if (!is_run_by_cli) { +#if defined (__unix__) || (defined (__APPLE__) && defined (__MACH__)) + struct sigaction sigint_action; + sigint_action.sa_handler = signal_handler; + sigemptyset (&sigint_action.sa_mask); + sigint_action.sa_flags = 0; + sigaction(SIGINT, &sigint_action, NULL); + sigaction(SIGTERM, &sigint_action, NULL); +#elif defined (_WIN32) + auto console_ctrl_handler = +[](DWORD ctrl_type) -> BOOL { + return (ctrl_type == CTRL_C_EVENT) ? (signal_handler(SIGINT), true) : false; + }; + SetConsoleCtrlHandler(reinterpret_cast(console_ctrl_handler), true); +#endif + } + + SRV_INF("listening on %s\n", ctx_http.listening_address.c_str()); + + // TODO: remove this in the future + // check the string to also handle the .sock case + if (string_ends_with(ctx_http.listening_address, ":8080")) { + SRV_WRN("%s", "NOTICE: server default port will be changed to :9931 in a future release\n"); + SRV_WRN("%s", " ref: https://github.com/ggml-org/llama.cpp/pull/26508\n"); + } + + if (is_router_server) { + if (!params.models_preset_hf.empty()) { + SRV_WRN( "NOTE: using preset.ini from HF repo '%s'\n", params.models_preset_hf.c_str()); + SRV_WRN("%s", " please only use presets that you can trust! Unknown presets may be unsafe\n"); + } + + if (ctx_http.thread.joinable()) { + ctx_http.thread.join(); // keep the main thread alive + } + + // when the HTTP server stops, clean up and exit + clean_up(); + } else { + // optionally, notify router server that this instance is ready + std::thread monitor_thread; + if (child.is_child()) { + monitor_thread = child.setup(shutdown_handler); + child.notify_to_router(server_state_to_str(SERVER_STATE_READY), routes.get_model_info()); + } + + // this call blocks the main thread until queue_tasks.terminate() is called + ctx_server.start_loop(); + + clean_up(); + if (ctx_http.thread.joinable()) { + ctx_http.thread.join(); + } + if (monitor_thread.joinable()) { + monitor_thread.join(); + } + + auto * ll_ctx = ctx_server.get_llama_context(); + if (ll_ctx != nullptr) { + common_memory_breakdown_print(ll_ctx); + } + } + + return 0; +} diff --git a/tools/server/tests/.gitignore b/tools/server/tests/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..90ee7fe6d971a981c4d0f8b70eca2556f7840cd9 --- /dev/null +++ b/tools/server/tests/.gitignore @@ -0,0 +1,2 @@ +.venv +tmp diff --git a/tools/server/tests/README.md b/tools/server/tests/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f566b43644b11333993c3122aaac309a172fd2b3 --- /dev/null +++ b/tools/server/tests/README.md @@ -0,0 +1,96 @@ +# Server tests + +Python based server tests scenario using [pytest](https://docs.pytest.org/en/stable/). + +Tests target GitHub workflows job runners with 4 vCPU. + +Note: If the host architecture inference speed is faster than GitHub runners one, parallel scenario may randomly fail. +To mitigate it, you can increase values in `n_predict`, `kv_size`. + +### Install dependencies + +`pip install -r requirements.txt` + +### Run tests + +1. Build the server + +```shell +cd ../../.. +cmake -B build +cmake --build build --target llama-server +``` + +2. Start the test: `./tests.sh` + +It's possible to override some scenario steps values with environment variables: + +| variable | description | +|--------------------------|------------------------------------------------------------------------------------------------| +| `PORT` | `context.server_port` to set the listening port of the server during scenario, default: `8080` | +| `LLAMA_SERVER_BIN_PATH` | to change the server binary path, default: `../../../build/bin/llama-server` | +| `DEBUG` | to enable steps and server verbose mode `--verbose` | +| `N_GPU_LAYERS` | number of model layers to offload to VRAM `-ngl --n-gpu-layers` | +| `LLAMA_CACHE` | by default server tests re-download models to the `tmp` subfolder. Set this to your cache (e.g. `$HOME/Library/Caches/llama.cpp` on Mac or `$HOME/.cache/llama.cpp` on Unix) to avoid this | + +To run slow tests (will download many models, make sure to set `LLAMA_CACHE` if needed): + +```shell +SLOW_TESTS=1 ./tests.sh +``` + +To run with stdout/stderr display in real time (verbose output, but useful for debugging): + +```shell +DEBUG=1 ./tests.sh -s -v -x +``` + +To run all the tests in a file: + +```shell +./tests.sh unit/test_chat_completion.py -v -x +``` + +To run a single test: + +```shell +./tests.sh unit/test_chat_completion.py::test_invalid_chat_completion_req +``` + +Hint: You can compile and run test in single command, useful for local development: + +```shell +cmake --build build -j --target llama-server && ./tools/server/tests/tests.sh +``` + +To see all available arguments, please refer to [pytest documentation](https://docs.pytest.org/en/stable/how-to/usage.html) + +### Debugging external llama-server +It can sometimes be useful to run the server in a debugger when invesigating test +failures. To do this, the environment variable `DEBUG_EXTERNAL=1` can be set +which will cause the test to skip starting a llama-server itself. Instead, the +server can be started in a debugger. + +Example using `gdb`: +```console +$ gdb --args ../../../build/bin/llama-server \ + --host 127.0.0.1 --port 8080 \ + --temp 0.8 --seed 42 \ + --hf-repo ggml-org/models --hf-file tinyllamas/stories260K.gguf \ + --batch-size 32 --no-slots --alias tinyllama-2 --ctx-size 512 \ + --parallel 2 --n-predict 64 +``` +And a break point can be set in before running: +```console +(gdb) br server.cpp:4604 +(gdb) r +main: server is listening on http://127.0.0.1:8080 - starting the main loop +srv update_slots: all slots are idle +``` + +And then the test in question can be run in another terminal: +```console +(venv) $ env DEBUG_EXTERNAL=1 ./tests.sh unit/test_chat_completion.py -v -x +``` +And this should trigger the breakpoint and allow inspection of the server state +in the debugger terminal. diff --git a/tools/server/tests/conftest.py b/tools/server/tests/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..5dfde4079678bd218ae0d0ce9586c0c3154b790d --- /dev/null +++ b/tools/server/tests/conftest.py @@ -0,0 +1,21 @@ +import pytest +from utils import * + + +# ref: https://stackoverflow.com/questions/22627659/run-code-before-and-after-each-test-in-py-test +@pytest.fixture(autouse=True) +def stop_server_after_each_test(): + # do nothing before each test + yield + # stop all servers after each test + instances = set( + server_instances + ) # copy the set to prevent 'Set changed size during iteration' + for server in instances: + server.stop() + + +@pytest.fixture(scope="session", autouse=True) +def load_server_presets(): + # this will be run once per test session, before any tests + ServerPreset.load_all() diff --git a/tools/server/tests/fixtures/mcp_burst_server.py b/tools/server/tests/fixtures/mcp_burst_server.py new file mode 100644 index 0000000000000000000000000000000000000000..22892d9a1d727733c97bc7072e975479c89036c4 --- /dev/null +++ b/tools/server/tests/fixtures/mcp_burst_server.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python3 +""" +Minimal MCP server that writes notification + response in a single write() with no flush. +This reproduces the buffering bug where read_message() can strand the response. +""" +import json +import sys +import os + +TOOLS = [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": { + "message": {"type": "string"} + }, + "required": ["message"] + } + } +] + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "burst-test", "version": "1.0"} + } + } + +def handle_tools_list(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": {"tools": TOOLS} + } + +def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "echo": + message = arguments.get("message", "") + notif = { + "jsonrpc": "2.0", + "method": "notifications/progress", + "params": {"progress": 50, "total": 100} + } + response = { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"echo: {message}"}] + } + } + # Single os.write() call: both lines land in one pipe packet atomically. + # This is the key difference from mcp_malformed_server.py which flushes between writes. + data = (json.dumps(notif) + "\n" + json.dumps(response) + "\n").encode("utf-8") + os.write(sys.stdout.fileno(), data) + return None # already written + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + return response + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, +} + +def main(): + # Use line-buffered text mode for regular responses, but the burst write + # uses os.write() directly to guarantee a single kernel write(). + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + # JSON-RPC 2.0: a message without an id is a notification and must not receive a response + if req_id is None: + continue + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + if response is not None: + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32601, "message": f"Method not found: {method}"} + } + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/fixtures/mcp_crash_server.py b/tools/server/tests/fixtures/mcp_crash_server.py new file mode 100644 index 0000000000000000000000000000000000000000..8dffdc61c0e9f79fb1b23ebae14289c9ea4a3ed2 --- /dev/null +++ b/tools/server/tests/fixtures/mcp_crash_server.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +""" +MCP server that crashes after receiving a specific tool call. +""" +import json +import sys +import os + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "crash-test", "version": "1.0"} + } + } + +def handle_tools_list(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "tools": [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": { + "message": {"type": "string"} + } + } + }, + { + "name": "crash", + "description": "Crash the server", + "inputSchema": { + "type": "object", + "properties": {} + } + } + ] + } + } + +def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "echo": + message = arguments.get("message", "") + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"echo: {message}"}] + } + } + elif tool_name == "crash": + # Send a partial response then exit + sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": req_id, "result": {"content": [{"type": "text", "text": "crashing..."}]}}) + "\n") + sys.stdout.flush() + os._exit(1) + else: + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, +} + +def main(): + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + # JSON-RPC 2.0: a message without an id is a notification and must not receive a response + if req_id is None: + continue + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32601, "message": f"Method not found: {method}"} + } + + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/fixtures/mcp_echo_server.py b/tools/server/tests/fixtures/mcp_echo_server.py new file mode 100644 index 0000000000000000000000000000000000000000..7acfb358881af4d752eac304de7056ddc01f4243 --- /dev/null +++ b/tools/server/tests/fixtures/mcp_echo_server.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +""" +Minimal MCP server for testing. +Implements JSON-RPC 2.0 over stdio (line-delimited JSON). +""" +import json +import sys +import os + +# Ensure we use python3 from the current environment +if sys.platform == "win32": + # On Windows, we need to use the same python interpreter + pass + +TOOLS = [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": { + "message": {"type": "string", "description": "Message to echo"} + }, + "required": ["message"] + } + }, + { + "name": "add", + "description": "Add two numbers", + "inputSchema": { + "type": "object", + "properties": { + "a": {"type": "number"}, + "b": {"type": "number"} + }, + "required": ["a", "b"] + } + }, + { + "name": "fail_once", + "description": "Fails on first call, succeeds on subsequent calls", + "inputSchema": { + "type": "object", + "properties": {} + } + } +] + +_state = {"fail_once_called": False} + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "echo-test", "version": "1.0"} + } + } + +def handle_tools_list(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": {"tools": TOOLS} + } + +def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "echo": + message = arguments.get("message", "") + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"echo: {message}"}] + } + } + elif tool_name == "add": + a = arguments.get("a", 0) + b = arguments.get("b", 0) + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": str(a + b)}] + } + } + elif tool_name == "fail_once": + if not _state["fail_once_called"]: + _state["fail_once_called"] = True + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32000, "message": "transient error"} + } + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": "ok"}] + } + } + else: + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + +def handle_ping(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": {} + } + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, + "ping": handle_ping, +} + +def main(): + # Use unbuffered output + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + # JSON-RPC 2.0: a message without an id is a notification and must not receive a response + if req_id is None: + continue + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32601, "message": f"Method not found: {method}"} + } + + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/fixtures/mcp_grandchild_server.py b/tools/server/tests/fixtures/mcp_grandchild_server.py new file mode 100644 index 0000000000000000000000000000000000000000..2604a77ee80ea6249c41fcc8aad50b841a679eeb --- /dev/null +++ b/tools/server/tests/fixtures/mcp_grandchild_server.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +""" +MCP server (NDJSON JSON-RPC over stdio) that spawns a long-lived grandchild which inherits +this process's stdin/stdout/stderr and keeps them open. + +This reproduces the reader-teardown deadlock: killing the direct MCP child (SIGKILL, which is +all subprocess_terminate() does) does NOT close the stdout/stderr pipe write ends, because the +grandchild still holds them. A server that reads those pipes with a blocking read would then +wait forever for an EOF that never arrives, hanging teardown (both warmup shutdown at startup +and process shutdown). The polled, running-aware reader must exit regardless. +""" +import json +import os +import subprocess +import sys + +# Spawn a grandchild that inherits our std handles (fds 0/1/2 = the MCP pipes) and lives well +# past any teardown in the tests. We do NOT redirect its stdio, so it keeps the pipe write ends +# open even after this process is killed. +subprocess.Popen([sys.executable, "-c", "import time; time.sleep(30)"]) + +TOOLS = [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": {"message": {"type": "string", "description": "Message to echo"}}, + "required": ["message"], + }, + } +] + + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "grandchild-test", "version": "1.0"}, + }, + } + + +def handle_tools_list(params, req_id): + return {"jsonrpc": "2.0", "id": req_id, "result": {"tools": TOOLS}} + + +def handle_tools_call(params, req_id): + if params.get("name") == "echo": + message = params.get("arguments", {}).get("message", "") + return { + "jsonrpc": "2.0", + "id": req_id, + "result": {"content": [{"type": "text", "text": f"echo: {message}"}]}, + } + return {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32602, "message": "Unknown tool"}} + + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, +} + + +def main(): + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + if req_id is None: + continue # notification, no response + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + else: + response = {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32601, "message": f"Method not found: {method}"}} + + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/fixtures/mcp_malformed_server.py b/tools/server/tests/fixtures/mcp_malformed_server.py new file mode 100644 index 0000000000000000000000000000000000000000..743333c5fdaac44f193caf133297dd47ef6bba19 --- /dev/null +++ b/tools/server/tests/fixtures/mcp_malformed_server.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 +""" +MCP server that sends malformed responses and notifications during requests. +""" +import json +import sys +import os + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "malformed-test", "version": "1.0"} + } + } + +def handle_tools_list(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "tools": [ + { + "name": "echo", + "description": "Echo back the input message", + "inputSchema": { + "type": "object", + "properties": { + "message": {"type": "string"} + } + } + } + ] + } + } + +def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "echo": + message = arguments.get("message", "") + # Send a notification first (no id field) + notif = { + "jsonrpc": "2.0", + "method": "notifications/progress", + "params": {"progress": 50, "total": 100} + } + sys.stdout.write(json.dumps(notif) + "\n") + sys.stdout.flush() + # Then send the actual response + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"echo: {message}"}] + } + } + else: + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, +} + +def main(): + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + # Send malformed JSON response + sys.stdout.write("THIS IS NOT JSON\n") + sys.stdout.flush() + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + # JSON-RPC 2.0: a message without an id is a notification and must not receive a response + if req_id is None: + continue + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32601, "message": f"Method not found: {method}"} + } + + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/fixtures/mcp_slow_server.py b/tools/server/tests/fixtures/mcp_slow_server.py new file mode 100644 index 0000000000000000000000000000000000000000..7f8e67835accb46780465e0c162a84e3af16e882 --- /dev/null +++ b/tools/server/tests/fixtures/mcp_slow_server.py @@ -0,0 +1,132 @@ +#!/usr/bin/env python3 +""" +MCP server that sleeps before responding, for timeout testing. +""" +import json +import sys +import os +import time +import argparse + +TOOLS = [ + { + "name": "sleep", + "description": "Sleep for a given number of seconds", + "inputSchema": { + "type": "object", + "properties": { + "seconds": {"type": "number", "description": "Seconds to sleep"} + }, + "required": ["seconds"] + } + } +] + +def handle_initialize(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {}}, + "serverInfo": {"name": "slow-test", "version": "1.0"} + } + } + +def handle_tools_list(params, req_id): + return { + "jsonrpc": "2.0", + "id": req_id, + "result": {"tools": TOOLS} + } + +def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "sleep": + seconds = arguments.get("seconds", 1) + time.sleep(seconds) + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"slept {seconds}s"}] + } + } + else: + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + +HANDLERS = { + "initialize": handle_initialize, + "tools/list": handle_tools_list, + "tools/call": handle_tools_call, +} + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--delay", type=float, default=5.0, help="Delay in seconds for sleep tool") + args = parser.parse_args() + + # Override the sleep duration + global handle_tools_call + def handle_tools_call(params, req_id): + tool_name = params.get("name") + arguments = params.get("arguments", {}) + + if tool_name == "sleep": + seconds = arguments.get("seconds", args.delay) + time.sleep(seconds) + return { + "jsonrpc": "2.0", + "id": req_id, + "result": { + "content": [{"type": "text", "text": f"slept {seconds}s"}] + } + } + else: + return { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32602, "message": f"Unknown tool: {tool_name}"} + } + + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + sys.stderr = os.fdopen(sys.stderr.fileno(), "w", buffering=1) + + for line in sys.stdin: + line = line.strip() + if not line: + continue + try: + request = json.loads(line) + except json.JSONDecodeError: + continue + + method = request.get("method") + req_id = request.get("id") + params = request.get("params", {}) + + # JSON-RPC 2.0: a message without an id is a notification and must not receive a response + if req_id is None: + continue + + handler = HANDLERS.get(method) + if handler: + response = handler(params, req_id) + else: + response = { + "jsonrpc": "2.0", + "id": req_id, + "error": {"code": -32601, "message": f"Method not found: {method}"} + } + + sys.stdout.write(json.dumps(response) + "\n") + sys.stdout.flush() + +if __name__ == "__main__": + main() diff --git a/tools/server/tests/pytest.ini b/tools/server/tests/pytest.ini new file mode 100644 index 0000000000000000000000000000000000000000..6df308df74d571a022209782bd1bd14f0ab59756 --- /dev/null +++ b/tools/server/tests/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +markers = + slow: marks tests as slow (deselect with '-m "not slow"') + serial diff --git a/tools/server/tests/requirements.txt b/tools/server/tests/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca7a0281fa14d037e6fec14a84b2898c7e657216 --- /dev/null +++ b/tools/server/tests/requirements.txt @@ -0,0 +1,7 @@ +aiohttp~=3.9.3 +pytest~=8.3.3 +numpy~=1.26.4 +openai~=2.14.0 +prometheus-client~=0.20.0 +requests~=2.32.3 +wget~=3.2 diff --git a/tools/server/tests/tests.sh b/tools/server/tests/tests.sh new file mode 100644 index 0000000000000000000000000000000000000000..8d6681193db39a219fe14ddf72c40df094bea2f7 --- /dev/null +++ b/tools/server/tests/tests.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash + +# make sure we are in the right directory +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +cd $SCRIPT_DIR + +set -eu + +if [[ "${SLOW_TESTS:-0}" == 1 ]]; then + # Slow tests for tool calls need quite a few models ahead of time to avoid timing out. + python $SCRIPT_DIR/../../../scripts/fetch_server_test_models.py +fi + +if [ $# -lt 1 ] +then + if [[ "${SLOW_TESTS:-0}" == 1 ]]; then + pytest --durations=30 -v -x + else + pytest --durations=30 -v -x -m "not slow" + fi +else + pytest --durations=30 "$@" +fi diff --git a/tools/server/tests/unit/test_basic.py b/tools/server/tests/unit/test_basic.py new file mode 100644 index 0000000000000000000000000000000000000000..285726abf406003685875d3f1785b4897eaf335e --- /dev/null +++ b/tools/server/tests/unit/test_basic.py @@ -0,0 +1,113 @@ +import pytest +import requests +from utils import * + +server = ServerPreset.tinyllama2() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +def test_server_start_simple(): + global server + server.start() + res = server.make_request("GET", "/health") + assert res.status_code == 200 + + +def test_server_props(): + global server + server.start() + res = server.make_request("GET", "/props") + assert res.status_code == 200 + assert ".gguf" in res.body["model_path"] + assert res.body["total_slots"] == server.n_slots + default_val = res.body["default_generation_settings"] + assert server.n_ctx is not None and server.n_slots is not None + assert default_val["n_ctx"] == server.n_ctx / server.n_slots + assert default_val["params"]["seed"] == server.seed + + +def test_server_models(): + global server + server.start() + res = server.make_request("GET", "/models") + assert res.status_code == 200 + assert len(res.body["data"]) == 1 + assert res.body["data"][0]["id"] == server.model_alias + + +def test_server_slots(): + global server + + # without slots endpoint enabled, this should return error + server.server_slots = False + server.start() + res = server.make_request("GET", "/slots") + assert res.status_code == 501 # ERROR_TYPE_NOT_SUPPORTED + assert "error" in res.body + server.stop() + + # with slots endpoint enabled, this should return slots info + server.server_slots = True + server.n_slots = 2 + server.start() + res = server.make_request("GET", "/slots") + assert res.status_code == 200 + assert len(res.body) == server.n_slots + assert server.n_ctx is not None and server.n_slots is not None + assert res.body[0]["n_ctx"] == server.n_ctx / server.n_slots + assert "params" not in res.body[0] + + +def test_load_split_model(): + global server + server.offline = False + server.model_hf_repo = "ggml-org/models" + server.model_hf_file = "tinyllamas/split/stories15M-q8_0-00001-of-00003.gguf" + server.model_alias = "tinyllama-split" + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": 16, + "prompt": "Hello", + "temperature": 0.0, + }) + assert res.status_code == 200 + assert match_regex("(little|girl)+", res.body["content"]) + + +def test_no_ui(): + global server + # default: UI enabled + server.start() + url = f"http://{server.server_host}:{server.server_port}" + res = requests.get(url) + assert res.status_code == 200 + assert "" in res.text + server.stop() + + # with --no-ui, the UI should be disabled + server.no_ui = True + server.start() + res = requests.get(url) + assert res.status_code == 404 + + +def test_server_model_aliases_and_tags(): + global server + server.model_alias = "tinyllama-2,fim,code" + server.model_tags = "chat,fim,small" + server.start() + res = server.make_request("GET", "/models") + assert res.status_code == 200 + assert len(res.body["data"]) == 1 + model = res.body["data"][0] + # aliases field must contain all aliases + assert set(model["aliases"]) == {"tinyllama-2", "fim", "code"} + # tags field must contain all tags + assert set(model["tags"]) == {"chat", "fim", "small"} + # id is derived from first alias (alphabetical order from std::set) + assert model["id"] == "code" diff --git a/tools/server/tests/unit/test_chat_completion.py b/tools/server/tests/unit/test_chat_completion.py new file mode 100644 index 0000000000000000000000000000000000000000..0258b539ed870a7ed90ff4acc6bbd5ee233286aa --- /dev/null +++ b/tools/server/tests/unit/test_chat_completion.py @@ -0,0 +1,625 @@ +import pytest +from openai import OpenAI +from utils import * + +server: ServerProcess + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +@pytest.mark.parametrize( + "model,system_prompt,user_prompt,max_tokens,re_content,n_prompt,n_predicted,finish_reason,jinja,chat_template", + [ + (None, "Book", "Hey", 8, "But she couldn't", 69, 8, "length", False, None), + (None, "Book", "Hey", 8, "But she couldn't", 69, 8, "length", True, None), + (None, "Book", "What is the best book", 8, "(Suddenly)+|\\{ \" Sarax.", 77, 8, "length", False, None), + (None, "Book", "What is the best book", 8, "(Suddenly)+|\\{ \" Sarax.", 77, 8, "length", True, None), + (None, "Book", "What is the best book", 8, "(Suddenly)+|\\{ \" Sarax.", 77, 8, "length", True, 'chatml'), + (None, "Book", "What is the best book", 8, "^ blue", 23, 8, "length", True, "This is not a chat template, it is"), + ("codellama70b", "You are a coding assistant.", "Write the fibonacci function in c++.", 128, "(Aside|she|felter|alonger)+", 104, 128, "length", False, None), + ("codellama70b", "You are a coding assistant.", "Write the fibonacci function in c++.", 128, "(Aside|she|felter|alonger)+", 104, 128, "length", True, None), + (None, "Book", [{"type": "text", "text": "What is"}, {"type": "text", "text": "the best book"}], 8, "Whillicter", 79, 8, "length", False, None), + (None, "Book", [{"type": "text", "text": "What is"}, {"type": "text", "text": "the best book"}], 8, "Whillicter", 79, 8, "length", True, None), + ] +) +def test_chat_completion(model, system_prompt, user_prompt, max_tokens, re_content, n_prompt, n_predicted, finish_reason, jinja, chat_template): + global server + server.jinja = jinja + server.chat_template = chat_template + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "model": model, + "max_tokens": max_tokens, + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt}, + ], + }) + assert res.status_code == 200 + assert "cmpl" in res.body["id"] # make sure the completion id has the expected format + assert res.body["system_fingerprint"].startswith("b") + # we no longer reflect back the model name, see https://github.com/ggml-org/llama.cpp/pull/17668 + # assert res.body["model"] == model if model is not None else server.model_alias + assert res.body["usage"]["prompt_tokens"] == n_prompt + assert res.body["usage"]["completion_tokens"] == n_predicted + choice = res.body["choices"][0] + assert "assistant" == choice["message"]["role"] + assert match_regex(re_content, choice["message"]["content"]), f'Expected {re_content}, got {choice["message"]["content"]}' + assert choice["finish_reason"] == finish_reason + + +def test_chat_completion_cached_tokens(): + global server + server.n_slots = 1 + server.start() + seq = [ + ("1 2 3 4 5 6", 77, 0), + ("1 2 3 4 5 6", 77, 76), + ("1 2 3 4 5 9", 77, 51), + ("1 2 3 9 9 9", 77, 47), + ] + for user_prompt, n_prompt, n_cache in seq: + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "messages": [ + {"role": "system", "content": "Test"}, + {"role": "user", "content": user_prompt}, + ], + }) + assert res.body["usage"]["prompt_tokens"] == n_prompt + assert res.body["usage"]["prompt_tokens_details"]["cached_tokens"] == n_cache + +@pytest.mark.parametrize( + "system_prompt,user_prompt,max_tokens,re_content,n_prompt,n_predicted,finish_reason", + [ + ("Book", "What is the best book", 8, "(Suddenly)+", 77, 8, "length"), + ("You are a coding assistant.", "Write the fibonacci function in c++.", 128, "(Aside|she|felter|alonger)+", 104, 128, "length"), + ] +) +def test_chat_completion_stream(system_prompt, user_prompt, max_tokens, re_content, n_prompt, n_predicted, finish_reason): + global server + server.model_alias = "llama-test-model" + server.start() + res = server.make_stream_request("POST", "/chat/completions", data={ + "max_tokens": max_tokens, + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt}, + ], + "stream": True, + }) + content = "" + last_cmpl_id = None + for i, data in enumerate(res): + if data["choices"]: + choice = data["choices"][0] + if i == 0: + # Check first role message for stream=True + assert choice["delta"]["content"] is None + assert choice["delta"]["role"] == "assistant" + else: + assert "role" not in choice["delta"] + assert data["system_fingerprint"].startswith("b") + assert data["model"] == "llama-test-model" + if last_cmpl_id is None: + last_cmpl_id = data["id"] + assert last_cmpl_id == data["id"] # make sure the completion id is the same for all events in the stream + if choice["finish_reason"] in ["stop", "length"]: + assert "content" not in choice["delta"] + assert match_regex(re_content, content) + assert choice["finish_reason"] == finish_reason + else: + assert choice["finish_reason"] is None + content += choice["delta"]["content"] or '' + else: + assert data["usage"]["prompt_tokens"] == n_prompt + assert data["usage"]["completion_tokens"] == n_predicted + + +def test_chat_completion_with_openai_library(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.chat.completions.create( + model="gpt-3.5-turbo-instruct", + messages=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_tokens=8, + seed=42, + temperature=0.8, + ) + assert res.system_fingerprint is not None and res.system_fingerprint.startswith("b") + assert res.choices[0].finish_reason == "length" + assert res.choices[0].message.content is not None + assert match_regex("(Suddenly)+", res.choices[0].message.content) + + +def test_chat_template(): + global server + server.chat_template = "llama3" + server.debug = True # to get the "__verbose" object in the response + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ] + }) + assert res.status_code == 200 + assert "__verbose" in res.body + assert res.body["__verbose"]["prompt"] == " <|start_header_id|>system<|end_header_id|>\n\nBook<|eot_id|><|start_header_id|>user<|end_header_id|>\n\nWhat is the best book<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n" + + +@pytest.mark.parametrize("prefill,re_prefill", [ + ("Whill", "Whill"), + ([{"type": "text", "text": "Wh"}, {"type": "text", "text": "ill"}], "Wh\n\nill"), +]) +def test_chat_template_assistant_prefill(prefill, re_prefill): + global server + server.jinja = True + server.chat_template_file = "../../../models/templates/meta-llama-Llama-3.1-8B-Instruct.jinja" + server.debug = True # to get the "__verbose" object in the response + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + {"role": "assistant", "content": prefill}, + ] + }) + assert res.status_code == 200 + assert "__verbose" in res.body + assert res.body["__verbose"]["prompt"].endswith(f"<|start_header_id|>user<|end_header_id|>\n\nWhat is the best book<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n{re_prefill}") + + +def test_chat_template_continue_final_message_vllm_compat(): + """continue_final_message is the vLLM/transformers explicit alias for the prefill_assistant heuristic. + Both must produce the same prompt.""" + global server + server.jinja = True + server.chat_template_file = "../../../models/templates/meta-llama-Llama-3.1-8B-Instruct.jinja" + server.debug = True + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "add_generation_prompt": False, + "continue_final_message": True, + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + {"role": "assistant", "content": "Whill"}, + ] + }) + assert res.status_code == 200 + assert "__verbose" in res.body + assert res.body["__verbose"]["prompt"].endswith("<|start_header_id|>user<|end_header_id|>\n\nWhat is the best book<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\nWhill") + + +def test_chat_template_continue_final_message_mutual_exclusion(): + """add_generation_prompt and continue_final_message both set to true must be rejected""" + global server + server.chat_template = "llama3" + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "add_generation_prompt": True, + "continue_final_message": True, + "messages": [ + {"role": "user", "content": "Hi"}, + {"role": "assistant", "content": "Hello"}, + ] + }) + assert res.status_code == 400 + + +def test_apply_chat_template(): + global server + server.chat_template = "command-r" + server.start() + res = server.make_request("POST", "/apply-template", data={ + "messages": [ + {"role": "system", "content": "You are a test."}, + {"role": "user", "content":"Hi there"}, + ] + }) + assert res.status_code == 200 + assert "prompt" in res.body + assert res.body["prompt"] == "<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>You are a test.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Hi there<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>" + + +@pytest.mark.parametrize("response_format,n_predicted,re_content", [ + ({"type": "json_object", "schema": {"const": "42"}}, 6, "\"42\""), + ({"type": "json_object", "schema": {"items": [{"type": "integer"}]}}, 10, "[ -3000 ]"), + ({"type": "json_schema", "json_schema": {"schema": {"const": "foooooo"}}}, 10, "\"foooooo\""), + ({"type": "json_object"}, 10, "(\\{|John)+"), + ({"type": "sound"}, 0, None), + # invalid response format (expected to fail) + ({"type": "json_object", "schema": 123}, 0, None), + ({"type": "json_object", "schema": {"type": 123}}, 0, None), + ({"type": "json_object", "schema": {"type": "hiccup"}}, 0, None), +]) +def test_completion_with_response_format(response_format: dict, n_predicted: int, re_content: str | None): + global server + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": n_predicted, + "messages": [ + {"role": "system", "content": "You are a coding assistant."}, + {"role": "user", "content": "Write an example"}, + ], + "response_format": response_format, + }) + if re_content is not None: + assert res.status_code == 200 + choice = res.body["choices"][0] + assert match_regex(re_content, choice["message"]["content"]) + else: + assert res.status_code == 400 + assert "error" in res.body + + +@pytest.mark.parametrize("jinja,json_schema,n_predicted,re_content", [ + (False, {"const": "42"}, 6, "\"42\""), + (True, {"const": "42"}, 6, "\"42\""), +]) +def test_completion_with_json_schema(jinja: bool, json_schema: dict, n_predicted: int, re_content: str): + global server + server.jinja = jinja + server.debug = True + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": n_predicted, + "messages": [ + {"role": "system", "content": "You are a coding assistant."}, + {"role": "user", "content": "Write an example"}, + ], + "json_schema": json_schema, + }) + assert res.status_code == 200, f'Expected 200, got {res.status_code}' + choice = res.body["choices"][0] + assert match_regex(re_content, choice["message"]["content"]), f'Expected {re_content}, got {choice["message"]["content"]}' + + +@pytest.mark.parametrize("jinja,grammar,n_predicted,re_content", [ + (False, 'root ::= "a"{5,5}', 6, "a{5,5}"), + (True, 'root ::= "a"{5,5}', 6, "a{5,5}"), +]) +def test_completion_with_grammar(jinja: bool, grammar: str, n_predicted: int, re_content: str): + global server + server.jinja = jinja + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": n_predicted, + "messages": [ + {"role": "user", "content": "Does not matter what I say, does it?"}, + ], + "grammar": grammar, + }) + assert res.status_code == 200, res.body + choice = res.body["choices"][0] + assert match_regex(re_content, choice["message"]["content"]), choice["message"]["content"] + + +def test_completion_with_invalid_grammar(): + global server + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "messages": [ + {"role": "user", "content": "Does not matter what I say, does it?"}, + ], + "grammar": "root ::= this is (not valid GBNF", + }) + assert res.status_code == 400, res.body + assert "error" in res.body + + +@pytest.mark.parametrize("messages", [ + None, + "string", + [123], + [{}], + [{"role": 123}], + [{"role": "system", "content": 123}], + # [{"content": "hello"}], # TODO: should not be a valid case + [{"role": "system", "content": "test"}, {}], + [{"role": "user", "content": "test"}, {"role": "assistant", "content": "test"}, {"role": "assistant", "content": "test"}], +]) +def test_invalid_chat_completion_req(messages): + global server + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "messages": messages, + }) + assert res.status_code == 400 or res.status_code == 500 + assert "error" in res.body + + +def test_chat_completion_with_timings_per_token(): + global server + server.start() + res = server.make_stream_request("POST", "/chat/completions", data={ + "max_tokens": 10, + "messages": [{"role": "user", "content": "test"}], + "stream": True, + "stream_options": {"include_usage": True}, + "timings_per_token": True, + }) + stats_received = False + for i, data in enumerate(res): + if i == 0: + # Check first role message for stream=True + assert data["choices"][0]["delta"]["content"] is None + assert data["choices"][0]["delta"]["role"] == "assistant" + assert "timings" not in data, f'First event should not have timings: {data}' + else: + if data["choices"]: + assert "role" not in data["choices"][0]["delta"] + else: + assert "timings" in data + assert "prompt_per_second" in data["timings"] + assert "predicted_per_second" in data["timings"] + assert "predicted_n" in data["timings"] + assert data["timings"]["predicted_n"] <= 10 + stats_received = True + assert stats_received + + +def test_logprobs(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.chat.completions.create( + model="gpt-3.5-turbo-instruct", + temperature=0.0, + messages=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_tokens=5, + logprobs=True, + top_logprobs=10, + ) + output_text = res.choices[0].message.content + aggregated_text = '' + assert res.choices[0].logprobs is not None + assert res.choices[0].logprobs.content is not None + for token in res.choices[0].logprobs.content: + aggregated_text += token.token + assert token.logprob <= 0.0 + assert token.bytes is not None + assert len(token.top_logprobs) > 0 + assert aggregated_text == output_text + + +def test_logprobs_stream(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.chat.completions.create( + model="gpt-3.5-turbo-instruct", + temperature=0.0, + messages=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_tokens=5, + logprobs=True, + top_logprobs=10, + stream=True, + ) + output_text = '' + aggregated_text = '' + for i, data in enumerate(res): + if data.choices: + choice = data.choices[0] + if i == 0: + # Check first role message for stream=True + assert choice.delta.content is None + assert choice.delta.role == "assistant" + else: + assert choice.delta.role is None + if choice.finish_reason is None: + if choice.delta.content: + output_text += choice.delta.content + assert choice.logprobs is not None + assert choice.logprobs.content is not None + for token in choice.logprobs.content: + aggregated_text += token.token + assert token.logprob <= 0.0 + assert token.bytes is not None + assert token.top_logprobs is not None + assert len(token.top_logprobs) > 0 + assert aggregated_text == output_text + + +def test_logit_bias(): + global server + server.start() + + exclude = ["i", "I", "the", "The", "to", "a", "an", "be", "is", "was", "but", "But", "and", "And", "so", "So", "you", "You", "he", "He", "she", "She", "we", "We", "they", "They", "it", "It", "his", "His", "her", "Her", "book", "Book"] + + res = server.make_request("POST", "/tokenize", data={ + "content": " " + " ".join(exclude) + " ", + }) + assert res.status_code == 200 + tokens = res.body["tokens"] + logit_bias = {tok: -100 for tok in tokens} + + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.chat.completions.create( + model="gpt-3.5-turbo-instruct", + temperature=0.0, + messages=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_tokens=64, + logit_bias=logit_bias + ) + output_text = res.choices[0].message.content + assert output_text + assert all(output_text.find(" " + tok + " ") == -1 for tok in exclude) + +def test_context_size_exceeded(): + global server + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ] * 100, # make the prompt too long + }) + assert res.status_code == 400 + assert "error" in res.body + assert res.body["error"]["type"] == "exceed_context_size_error" + assert res.body["error"]["n_prompt_tokens"] > 0 + assert server.n_ctx is not None + assert server.n_slots is not None + assert res.body["error"]["n_ctx"] == server.n_ctx // server.n_slots + + +def test_context_size_exceeded_stream(): + global server + server.start() + try: + for _ in server.make_stream_request("POST", "/chat/completions", data={ + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ] * 100, # make the prompt too long + "stream": True}): + pass + assert False, "Should have failed" + except ServerError as e: + assert e.code == 400 + assert "error" in e.body + assert e.body["error"]["type"] == "exceed_context_size_error" + assert e.body["error"]["n_prompt_tokens"] > 0 + assert server.n_ctx is not None + assert server.n_slots is not None + assert e.body["error"]["n_ctx"] == server.n_ctx // server.n_slots + + +@pytest.mark.parametrize( + "n_batch,batch_count,reuse_cache", + [ + (64, 4, False), + (64, 2, True), + ] +) +def test_return_progress(n_batch, batch_count, reuse_cache): + global server + server.n_batch = n_batch + server.n_ctx = 256 + server.n_slots = 1 + server.start() + def make_cmpl_request(): + return server.make_stream_request("POST", "/chat/completions", data={ + "max_tokens": 10, + "messages": [ + {"role": "user", "content": "This is a test" * 10}, + ], + "stream": True, + "return_progress": True, + }) + if reuse_cache: + # make a first request to populate the cache + res0 = make_cmpl_request() + for _ in res0: + pass # discard the output + + res = make_cmpl_request() + last_progress = None + total_batch_count = 0 + + for data in res: + cur_progress = data.get("prompt_progress", None) + if cur_progress is None: + continue + if total_batch_count == 0: + # first progress report must have n_cache == n_processed + assert cur_progress["total"] > 0 + assert cur_progress["cache"] == cur_progress["processed"] + if reuse_cache: + # when reusing cache, we expect some cached tokens + assert cur_progress["cache"] > 0 + if last_progress is not None: + assert cur_progress["total"] == last_progress["total"] + assert cur_progress["cache"] == last_progress["cache"] + assert cur_progress["processed"] > last_progress["processed"] + total_batch_count += 1 + last_progress = cur_progress + + # last progress should indicate completion (all tokens processed) + assert last_progress is not None + assert last_progress["total"] > 0 + assert last_progress["processed"] == last_progress["total"] + assert total_batch_count == batch_count + + +def test_chat_completions_multiple_choices(): + global server + server.start() + # make sure cache can be reused across multiple choices and multiple requests + # ref: https://github.com/ggml-org/llama.cpp/pull/18663 + for _ in range(2): + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 8, + "n": 2, + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + # test forcing the same slot to be used + # the scheduler should not be locked up in this case + "id_slot": 0, + }) + assert res.status_code == 200 + assert len(res.body["choices"]) == 2 + for choice in res.body["choices"]: + assert "assistant" == choice["message"]["role"] + assert choice["finish_reason"] == "length" + + +def test_chat_completions_token_count(): + global server + server.start() + # make sure cache can be reused across multiple choices and multiple requests + # ref: https://github.com/ggml-org/llama.cpp/pull/18663 + for _ in range(2): + res = server.make_request("POST", "/chat/completions/input_tokens", data={ + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + }) + assert res.status_code == 200 + assert res.body["input_tokens"] > 5 + + +def test_verbose_debug(): + global server + server.start() + for verbose in [True, False]: + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 2, + "messages": [ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + "verbose": verbose, + }) + assert res.status_code == 200 + if verbose: + assert "__verbose" in res.body + assert "Book" in res.body["__verbose"]["prompt"] + else: + assert "__verbose" not in res.body diff --git a/tools/server/tests/unit/test_compat_anthropic.py b/tools/server/tests/unit/test_compat_anthropic.py new file mode 100644 index 0000000000000000000000000000000000000000..e23947cdde546e72be8e7ae37b3556d0254209fd --- /dev/null +++ b/tools/server/tests/unit/test_compat_anthropic.py @@ -0,0 +1,1090 @@ +#!/usr/bin/env python3 +import pytest +import base64 +import requests + +from utils import * + +server: ServerProcess + + +def get_test_image_base64() -> str: + """Get a test image in base64 format""" + # Use the same test image as test_vision_api.py + IMG_URL = "https://huggingface.co/ggml-org/tinygemma3-GGUF/resolve/main/test/11_truck.png" + response = requests.get(IMG_URL) + response.raise_for_status() + return base64.b64encode(response.content).decode("utf-8") + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.model_alias = "tinyllama-2-anthropic" + server.server_port = 8082 + server.n_slots = 1 + server.n_ctx = 8192 + server.n_batch = 2048 + + +@pytest.fixture +def vision_server(): + """Separate fixture for vision tests that require multimodal support""" + global server + server = ServerPreset.tinygemma3() + server.offline = False # Allow downloading the model + server.model_alias = "tinygemma3-anthropic" + server.server_port = 8083 # Different port to avoid conflicts + server.n_slots = 1 + return server + + +# Basic message tests + +def test_anthropic_messages_basic(): + """Test basic Anthropic messages endpoint""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "messages": [ + {"role": "user", "content": "Say hello"} + ] + }) + + assert res.status_code == 200, f"Expected 200, got {res.status_code}" + assert res.body["type"] == "message", f"Expected type 'message', got {res.body.get('type')}" + assert res.body["role"] == "assistant", f"Expected role 'assistant', got {res.body.get('role')}" + assert "content" in res.body, "Missing 'content' field" + assert isinstance(res.body["content"], list), "Content should be an array" + assert len(res.body["content"]) > 0, "Content array should not be empty" + assert res.body["content"][0]["type"] == "text", "First content block should be text" + assert "text" in res.body["content"][0], "Text content block missing 'text' field" + assert res.body["stop_reason"] in ["end_turn", "max_tokens"], f"Invalid stop_reason: {res.body.get('stop_reason')}" + assert "usage" in res.body, "Missing 'usage' field" + assert "cache_read_input_tokens" in res.body["usage"], "Missing usage.cache_read_input_tokens" + assert "input_tokens" in res.body["usage"], "Missing usage.input_tokens" + assert "output_tokens" in res.body["usage"], "Missing usage.output_tokens" + assert isinstance(res.body["usage"]["cache_read_input_tokens"], int), "cache_read_input_tokens should be integer" + assert isinstance(res.body["usage"]["input_tokens"], int), "input_tokens should be integer" + assert isinstance(res.body["usage"]["output_tokens"], int), "output_tokens should be integer" + assert res.body["usage"]["output_tokens"] > 0, "Should have generated some tokens" + # Anthropic API should NOT include timings + assert "timings" not in res.body, "Anthropic API should not include timings field" + + +def test_anthropic_messages_with_system(): + """Test messages with system prompt""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "system": "You are a helpful assistant.", + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + assert len(res.body["content"]) > 0 + + +def test_anthropic_messages_multipart_content(): + """Test messages with multipart content blocks""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "messages": [ + { + "role": "user", + "content": [ + {"type": "text", "text": "What is"}, + {"type": "text", "text": " the answer?"} + ] + } + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_messages_conversation(): + """Test multi-turn conversation""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "messages": [ + {"role": "user", "content": "Hello"}, + {"role": "assistant", "content": "Hi there!"}, + {"role": "user", "content": "How are you?"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +# Streaming tests + +def test_anthropic_messages_streaming(): + """Test streaming messages""" + server.start() + + res = server.make_stream_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 30, + "messages": [ + {"role": "user", "content": "Say hello"} + ], + "stream": True + }) + + events = [] + for data in res: + # Each event should have type and other fields + assert "type" in data, f"Missing 'type' in event: {data}" + events.append(data) + + # Verify event sequence + event_types = [e["type"] for e in events] + assert "message_start" in event_types, "Missing message_start event" + assert "content_block_start" in event_types, "Missing content_block_start event" + assert "content_block_delta" in event_types, "Missing content_block_delta event" + assert "content_block_stop" in event_types, "Missing content_block_stop event" + assert "message_delta" in event_types, "Missing message_delta event" + assert "message_stop" in event_types, "Missing message_stop event" + + # Check message_start structure + message_start = next(e for e in events if e["type"] == "message_start") + assert "message" in message_start, "message_start missing 'message' field" + assert message_start["message"]["type"] == "message" + assert message_start["message"]["role"] == "assistant" + assert message_start["message"]["content"] == [] + assert "usage" in message_start["message"] + assert message_start["message"]["usage"]["input_tokens"] > 0 + + # Check content_block_start + block_start = next(e for e in events if e["type"] == "content_block_start") + assert "index" in block_start, "content_block_start missing 'index'" + assert block_start["index"] == 0, "First content block should be at index 0" + assert "content_block" in block_start + assert block_start["content_block"]["type"] == "text" + + # Check content_block_delta + deltas = [e for e in events if e["type"] == "content_block_delta"] + assert len(deltas) > 0, "Should have at least one content_block_delta" + for delta in deltas: + assert "index" in delta + assert "delta" in delta + assert delta["delta"]["type"] == "text_delta" + assert "text" in delta["delta"] + + # Check content_block_stop + block_stop = next(e for e in events if e["type"] == "content_block_stop") + assert "index" in block_stop + assert block_stop["index"] == 0 + + # Check message_delta + message_delta = next(e for e in events if e["type"] == "message_delta") + assert "delta" in message_delta + assert "stop_reason" in message_delta["delta"] + assert message_delta["delta"]["stop_reason"] in ["end_turn", "max_tokens"] + assert "usage" in message_delta + assert message_delta["usage"]["output_tokens"] > 0 + + # Check message_stop + message_stop = next(e for e in events if e["type"] == "message_stop") + # message_stop should NOT have timings for Anthropic API + assert "timings" not in message_stop, "Anthropic streaming should not include timings" + + +# Token counting tests + +def test_anthropic_count_tokens(): + """Test token counting endpoint""" + server.start() + + res = server.make_request("POST", "/v1/messages/count_tokens", data={ + "model": "test", + "messages": [ + {"role": "user", "content": "Hello world"} + ] + }) + + assert res.status_code == 200 + assert "input_tokens" in res.body + assert isinstance(res.body["input_tokens"], int) + assert res.body["input_tokens"] > 0 + # Should only have input_tokens, no other fields + assert "output_tokens" not in res.body + + +def test_anthropic_count_tokens_with_system(): + """Test token counting with system prompt""" + server.start() + + res = server.make_request("POST", "/v1/messages/count_tokens", data={ + "model": "test", + "system": "You are a helpful assistant.", + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["input_tokens"] > 0 + + +def test_anthropic_count_tokens_no_max_tokens(): + """Test that count_tokens doesn't require max_tokens""" + server.start() + + # max_tokens is NOT required for count_tokens + res = server.make_request("POST", "/v1/messages/count_tokens", data={ + "model": "test", + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert "input_tokens" in res.body + + +# Tool use tests + +def test_anthropic_tool_use_basic(): + """Test basic tool use""" + server.jinja = True + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 200, + "tools": [{ + "name": "get_weather", + "description": "Get the current weather in a location", + "input_schema": { + "type": "object", + "properties": { + "location": { + "type": "string", + "description": "City name" + } + }, + "required": ["location"] + } + }], + "messages": [ + {"role": "user", "content": "What's the weather in Paris?"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + assert len(res.body["content"]) > 0 + + # Check if model used the tool (it might not always, depending on the model) + content_types = [block.get("type") for block in res.body["content"]] + + if "tool_use" in content_types: + # Model used the tool + assert res.body["stop_reason"] == "tool_use" + + # Find the tool_use block + tool_block = next(b for b in res.body["content"] if b.get("type") == "tool_use") + assert "id" in tool_block + assert "name" in tool_block + assert tool_block["name"] == "get_weather" + assert "input" in tool_block + assert isinstance(tool_block["input"], dict) + + +def test_anthropic_tool_result(): + """Test sending tool results back + + This test verifies that tool_result blocks are properly converted to + role="tool" messages internally. Without proper conversion, this would + fail with a 500 error: "unsupported content[].type" because tool_result + blocks would remain in the user message content array. + """ + server.jinja = True + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "messages": [ + {"role": "user", "content": "What's the weather?"}, + { + "role": "assistant", + "content": [ + { + "type": "tool_use", + "id": "test123", + "name": "get_weather", + "input": {"location": "Paris"} + } + ] + }, + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "test123", + "content": "The weather is sunny, 25°C" + } + ] + } + ] + }) + + # This would be 500 with the old bug where tool_result blocks weren't converted + assert res.status_code == 200 + assert res.body["type"] == "message" + # Model should respond to the tool result + assert len(res.body["content"]) > 0 + assert res.body["content"][0]["type"] == "text" + + +def test_anthropic_tool_result_with_text(): + """Test tool result mixed with text content + + This tests the edge case where a user message contains both text and + tool_result blocks. The server must properly split these into separate + messages: a user message with text, followed by tool messages. + Without proper handling, this would fail with 500: "unsupported content[].type" + """ + server.jinja = True + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "messages": [ + {"role": "user", "content": "What's the weather?"}, + { + "role": "assistant", + "content": [ + { + "type": "tool_use", + "id": "tool_1", + "name": "get_weather", + "input": {"location": "Paris"} + } + ] + }, + { + "role": "user", + "content": [ + {"type": "text", "text": "Here are the results:"}, + { + "type": "tool_result", + "tool_use_id": "tool_1", + "content": "Sunny, 25°C" + } + ] + } + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + assert len(res.body["content"]) > 0 + + +def test_anthropic_tool_result_with_image(): + """Test tool result containing mixed text and image blocks + + Verifies that image blocks inside Anthropic tool_result content are + properly converted to OpenAI image_url format rather than being + silently dropped. With a non-multimodal model, the converted image + triggers a clear error message instead of being ignored. + """ + server.jinja = True + server.start() + + # Small 1x1 red PNG image in base64 (same as vision tests) + red_pixel_png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==" + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "messages": [ + {"role": "user", "content": "What is in this image?"}, + { + "role": "assistant", + "content": [ + { + "type": "tool_use", + "id": "tool_1", + "name": "read", + "input": {"file": "test.png"} + } + ] + }, + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "tool_1", + "content": [ + {"type": "text", "text": "File: test.png"}, + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": red_pixel_png + } + } + ] + } + ] + } + ] + }) + + # Without the fix, image block would cause "unsupported content[].type" + # With the fix, image is converted to image_url but tinyllama doesn't support images + assert res.status_code == 500 + assert "image input is not supported" in res.body.get("error", {}).get("message", "").lower() + + +def test_anthropic_tool_result_error(): + """Test tool result with error flag""" + server.jinja = True + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "messages": [ + {"role": "user", "content": "Get the weather"}, + { + "role": "assistant", + "content": [ + { + "type": "tool_use", + "id": "test123", + "name": "get_weather", + "input": {"location": "InvalidCity"} + } + ] + }, + { + "role": "user", + "content": [ + { + "type": "tool_result", + "tool_use_id": "test123", + "is_error": True, + "content": "City not found" + } + ] + } + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_tool_streaming(): + """Test streaming with tool use""" + server.jinja = True + server.start() + + res = server.make_stream_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 200, + "stream": True, + "tools": [{ + "name": "calculator", + "description": "Calculate math", + "input_schema": { + "type": "object", + "properties": { + "expression": {"type": "string"} + }, + "required": ["expression"] + } + }], + "messages": [ + {"role": "user", "content": "Calculate 2+2"} + ] + }) + + events = [] + for data in res: + events.append(data) + + event_types = [e["type"] for e in events] + + # Should have basic events + assert "message_start" in event_types + assert "message_stop" in event_types + + # If tool was used, check for proper tool streaming + if any(e.get("type") == "content_block_start" and + e.get("content_block", {}).get("type") == "tool_use" + for e in events): + # Find tool use block start + tool_starts = [e for e in events if + e.get("type") == "content_block_start" and + e.get("content_block", {}).get("type") == "tool_use"] + + assert len(tool_starts) > 0, "Should have tool_use content_block_start" + + # Check index is correct (should be 0 if no text, 1 if there's text) + tool_start = tool_starts[0] + assert "index" in tool_start + assert tool_start["content_block"]["type"] == "tool_use" + assert "name" in tool_start["content_block"] + + +# Vision/multimodal tests + +def test_anthropic_vision_format_accepted(): + """Test that Anthropic vision format is accepted (format validation only)""" + server.start() + + # Small 1x1 red PNG image in base64 + red_pixel_png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==" + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 10, + "messages": [ + { + "role": "user", + "content": [ + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": red_pixel_png + } + }, + { + "type": "text", + "text": "What is this?" + } + ] + } + ] + }) + + # Server accepts the format but tinyllama doesn't support images + # So it should return 500 with clear error message about missing mmproj + assert res.status_code == 500 + assert "image input is not supported" in res.body.get("error", {}).get("message", "").lower() + + +def test_anthropic_vision_base64_with_multimodal_model(vision_server): + """Test vision with base64 image using Anthropic format with multimodal model""" + global server + server = vision_server + server.start() + + # Get test image in base64 format + image_base64 = get_test_image_base64() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 10, + "messages": [ + { + "role": "user", + "content": [ + { + "type": "image", + "source": { + "type": "base64", + "media_type": "image/png", + "data": image_base64 + } + }, + { + "type": "text", + "text": "What is this:\n" + } + ] + } + ] + }) + + assert res.status_code == 200, f"Expected 200, got {res.status_code}: {res.body}" + assert res.body["type"] == "message" + assert len(res.body["content"]) > 0 + assert res.body["content"][0]["type"] == "text" + # The model should generate some response about the image + assert len(res.body["content"][0]["text"]) > 0 + + +# Parameter tests + +def test_anthropic_stop_sequences(): + """Test stop_sequences parameter""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "stop_sequences": ["\n", "END"], + "messages": [ + {"role": "user", "content": "Count to 10"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_temperature(): + """Test temperature parameter""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "temperature": 0.5, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_top_p(): + """Test top_p parameter""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "top_p": 0.9, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_top_k(): + """Test top_k parameter (llama.cpp specific)""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "top_k": 40, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +# Error handling tests + +def test_anthropic_missing_messages(): + """Test error when messages are missing""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50 + # missing "messages" field + }) + + # Should return an error (400 or 500) + assert res.status_code >= 400 + + +def test_anthropic_empty_messages(): + """Test permissive handling of empty messages array""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "messages": [] + }) + + # Server is permissive and accepts empty messages (provides defaults) + # This matches the permissive validation design choice + assert res.status_code == 200 + assert res.body["type"] == "message" + + +# Content block index tests + +def test_anthropic_streaming_content_block_indices(): + """Test that content block indices are correct in streaming""" + server.jinja = True + server.start() + + # Request that might produce both text and tool use + res = server.make_stream_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 400, + "stream": True, + "tools": [{ + "name": "test_tool", + "description": "A test tool", + "input_schema": { + "type": "object", + "properties": { + "param": {"type": "string"} + }, + "required": ["param"] + } + }], + "messages": [ + {"role": "user", "content": "Use the test tool"} + ] + }) + + events = [] + for data in res: + events.append(data) + + # Check content_block_start events have sequential indices + block_starts = [e for e in events if e.get("type") == "content_block_start"] + if len(block_starts) > 1: + # If there are multiple blocks, indices should be sequential + indices = [e["index"] for e in block_starts] + expected_indices = list(range(len(block_starts))) + assert indices == expected_indices, f"Expected indices {expected_indices}, got {indices}" + + # Check content_block_stop events match the starts + block_stops = [e for e in events if e.get("type") == "content_block_stop"] + start_indices = set(e["index"] for e in block_starts) + stop_indices = set(e["index"] for e in block_stops) + assert start_indices == stop_indices, "content_block_stop indices should match content_block_start indices" + + +# Extended features tests + +def test_anthropic_thinking(): + """Test extended thinking parameter""" + server.jinja = True + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 100, + "thinking": { + "type": "enabled", + "budget_tokens": 50 + }, + "messages": [ + {"role": "user", "content": "What is 2+2?"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +def test_anthropic_metadata(): + """Test metadata parameter""" + server.start() + + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "metadata": { + "user_id": "test_user_123" + }, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + +# Compatibility tests + +def test_anthropic_vs_openai_different_response_format(): + """Verify Anthropic format is different from OpenAI format""" + server.start() + + # Make OpenAI request + openai_res = server.make_request("POST", "/v1/chat/completions", data={ + "model": "test", + "max_tokens": 50, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + # Make Anthropic request + anthropic_res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 50, + "messages": [ + {"role": "user", "content": "Hello"} + ] + }) + + assert openai_res.status_code == 200 + assert anthropic_res.status_code == 200 + + # OpenAI has "object", Anthropic has "type" + assert "object" in openai_res.body + assert "type" in anthropic_res.body + assert openai_res.body["object"] == "chat.completion" + assert anthropic_res.body["type"] == "message" + + # OpenAI has "choices", Anthropic has "content" + assert "choices" in openai_res.body + assert "content" in anthropic_res.body + + # Different usage field names + assert "prompt_tokens" in openai_res.body["usage"] + assert "input_tokens" in anthropic_res.body["usage"] + assert "completion_tokens" in openai_res.body["usage"] + assert "output_tokens" in anthropic_res.body["usage"] + + +# Extended thinking tests with reasoning models + +# The next two tests cover the input path (conversation history): +# Client sends thinking blocks -> convert_anthropic_to_oai -> reasoning_content -> template + +def test_anthropic_thinking_history_in_count_tokens(): + """Test that interleaved thinking blocks in conversation history are not dropped during conversion.""" + global server + server.jinja = True + server.chat_template_file = '../../../models/templates/Qwen-Qwen3-0.6B.jinja' + server.start() + + tool = { + "name": "list_files", + "description": "List files", + "input_schema": { + "type": "object", + "properties": {"path": {"type": "string"}}, + "required": ["path"] + } + } + + messages_without_thinking = [ + {"role": "user", "content": "Fix the bug"}, + { + "role": "assistant", + "content": [ + {"type": "tool_use", "id": "call_1", "name": "list_files", "input": {"path": "."}} + ] + }, + { + "role": "user", + "content": [ + {"type": "tool_result", "tool_use_id": "call_1", "content": "main.py"} + ] + }, + ] + + messages_with_thinking = [ + {"role": "user", "content": "Fix the bug"}, + { + "role": "assistant", + "content": [ + {"type": "thinking", "thinking": "I should check the project structure first to understand the codebase layout."}, + {"type": "tool_use", "id": "call_1", "name": "list_files", "input": {"path": "."}} + ] + }, + { + "role": "user", + "content": [ + {"type": "tool_result", "tool_use_id": "call_1", "content": "main.py"} + ] + }, + ] + + res_without = server.make_request("POST", "/v1/messages/count_tokens", data={ + "model": "test", + "messages": messages_without_thinking, + "tools": [tool], + }) + assert res_without.status_code == 200, f"Expected 200: {res_without.body}" + + res_with = server.make_request("POST", "/v1/messages/count_tokens", data={ + "model": "test", + "messages": messages_with_thinking, + "tools": [tool], + }) + assert res_with.status_code == 200, f"Expected 200: {res_with.body}" + + # Thinking blocks should increase the token count + assert res_with.body["input_tokens"] > res_without.body["input_tokens"], \ + f"Expected more tokens with thinking ({res_with.body['input_tokens']}) than without ({res_without.body['input_tokens']})" + + +def test_anthropic_thinking_history_in_template(): + """Test that reasoning_content from converted interleaved thinking blocks renders in the prompt.""" + global server + server.jinja = True + server.chat_template_file = '../../../models/templates/Qwen-Qwen3-0.6B.jinja' + server.start() + + reasoning_1 = "I should check the project structure first." + reasoning_2 = "Now I need to read the main file." + + res = server.make_request("POST", "/apply-template", data={ + "messages": [ + {"role": "user", "content": "Fix the bug in main.py"}, + { + "role": "assistant", + "content": "", + "reasoning_content": reasoning_1, + "tool_calls": [{ + "id": "call_1", + "type": "function", + "function": {"name": "list_files", "arguments": "{\"path\": \".\"}"} + }] + }, + {"role": "tool", "tool_call_id": "call_1", "content": "main.py\nutils.py"}, + { + "role": "assistant", + "content": "", + "reasoning_content": reasoning_2, + "tool_calls": [{ + "id": "call_2", + "type": "function", + "function": {"name": "read_file", "arguments": "{\"path\": \"main.py\"}"} + }] + }, + {"role": "tool", "tool_call_id": "call_2", "content": "print('hello')"}, + ], + "tools": [{ + "type": "function", + "function": { + "name": "list_files", + "description": "List files", + "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]} + } + }, { + "type": "function", + "function": { + "name": "read_file", + "description": "Read a file", + "parameters": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]} + } + }], + }) + assert res.status_code == 200, f"Expected 200, got {res.status_code}: {res.body}" + prompt = res.body["prompt"] + + # Both reasoning_content values should be rendered in tags + assert reasoning_1 in prompt, f"Expected first reasoning text in prompt: {prompt}" + assert reasoning_2 in prompt, f"Expected second reasoning text in prompt: {prompt}" + assert prompt.count("") >= 2, f"Expected at least 2 blocks in prompt: {prompt}" + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [False, True]) +def test_anthropic_thinking_with_reasoning_model(stream): + """Test that thinking content blocks are properly returned for reasoning models""" + global server + server = ServerProcess() + server.model_hf_repo = "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF" + server.model_hf_file = "DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf" + server.reasoning_format = "deepseek" + server.jinja = True + server.n_ctx = 8192 + server.n_predict = 1024 + server.server_port = 8084 + server.start(timeout_seconds=600) # large model needs time to download + + if stream: + res = server.make_stream_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 1024, + "thinking": { + "type": "enabled", + "budget_tokens": 500 + }, + "messages": [ + {"role": "user", "content": "What is 2+2?"} + ], + "stream": True + }) + + events = list(res) + + # should have thinking content block events + thinking_starts = [e for e in events if + e.get("type") == "content_block_start" and + e.get("content_block", {}).get("type") == "thinking"] + assert len(thinking_starts) > 0, "Should have thinking content_block_start event" + assert thinking_starts[0]["index"] == 0, "Thinking block should be at index 0" + + # should have thinking_delta events + thinking_deltas = [e for e in events if + e.get("type") == "content_block_delta" and + e.get("delta", {}).get("type") == "thinking_delta"] + assert len(thinking_deltas) > 0, "Should have thinking_delta events" + + # should have signature_delta event before thinking block closes (Anthropic API requirement) + signature_deltas = [e for e in events if + e.get("type") == "content_block_delta" and + e.get("delta", {}).get("type") == "signature_delta"] + assert len(signature_deltas) > 0, "Should have signature_delta event for thinking block" + + # should have text block after thinking + text_starts = [e for e in events if + e.get("type") == "content_block_start" and + e.get("content_block", {}).get("type") == "text"] + assert len(text_starts) > 0, "Should have text content_block_start event" + assert text_starts[0]["index"] == 1, "Text block should be at index 1 (after thinking)" + else: + res = server.make_request("POST", "/v1/messages", data={ + "model": "test", + "max_tokens": 1024, + "thinking": { + "type": "enabled", + "budget_tokens": 500 + }, + "messages": [ + {"role": "user", "content": "What is 2+2?"} + ] + }) + + assert res.status_code == 200 + assert res.body["type"] == "message" + + content = res.body["content"] + assert len(content) >= 2, "Should have at least thinking and text blocks" + + # first block should be thinking + thinking_blocks = [b for b in content if b.get("type") == "thinking"] + assert len(thinking_blocks) > 0, "Should have thinking content block" + assert "thinking" in thinking_blocks[0], "Thinking block should have 'thinking' field" + assert len(thinking_blocks[0]["thinking"]) > 0, "Thinking content should not be empty" + assert "signature" in thinking_blocks[0], "Thinking block should have 'signature' field (Anthropic API requirement)" + + # should also have text block + text_blocks = [b for b in content if b.get("type") == "text"] + assert len(text_blocks) > 0, "Should have text content block" diff --git a/tools/server/tests/unit/test_compat_gcp.py b/tools/server/tests/unit/test_compat_gcp.py new file mode 100644 index 0000000000000000000000000000000000000000..aba67bb3537522f545eae2f4eae6d99397a0f9c8 --- /dev/null +++ b/tools/server/tests/unit/test_compat_gcp.py @@ -0,0 +1,60 @@ +import pytest +from utils import * + +server: ServerProcess + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.gcp_compat = True + + +def test_gcp_predict_camel_case(): + global server + server.start() + res = server.make_request("POST", "/predict", data={ + "instances": [ + { + "@requestFormat": "chatCompletions", + "max_tokens": 8, + "messages": [ + {"role": "user", "content": "What is the meaning of life?"}, + ], + } + ], + }) + assert res.status_code == 200 + assert "predictions" in res.body + assert len(res.body["predictions"]) == 1 + prediction = res.body["predictions"][0] + assert "choices" in prediction + assert len(prediction["choices"]) == 1 + assert prediction["choices"][0]["message"]["role"] == "assistant" + assert len(prediction["choices"][0]["message"]["content"]) > 0 + + +def test_gcp_predict_multiple_instances(): + global server + server.n_slots = 2 + server.start() + res = server.make_request("POST", "/predict", data={ + "instances": [ + { + "@requestFormat": "chatCompletions", + "max_tokens": 8, + "messages": [{"role": "user", "content": "Say hello"}], + }, + { + "@requestFormat": "chatCompletions", + "max_tokens": 8, + "messages": [{"role": "user", "content": "Say world"}], + }, + ], + }) + assert res.status_code == 200 + assert len(res.body["predictions"]) == 2 + for prediction in res.body["predictions"]: + assert "choices" in prediction + assert len(prediction["choices"][0]["message"]["content"]) > 0 diff --git a/tools/server/tests/unit/test_compat_oai_responses.py b/tools/server/tests/unit/test_compat_oai_responses.py new file mode 100644 index 0000000000000000000000000000000000000000..14528b4874bf8ba5aa9b7a38eb861301382e389c --- /dev/null +++ b/tools/server/tests/unit/test_compat_oai_responses.py @@ -0,0 +1,114 @@ +import pytest +from openai import OpenAI +from utils import * + +server: ServerProcess + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + +def test_responses_with_openai_library(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.responses.create( + model="gpt-4.1", + input=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_output_tokens=8, + temperature=0.8, + ) + assert res.id.startswith("resp_") + assert res.output[0].id is not None + assert res.output[0].id.startswith("msg_") + assert match_regex("(Suddenly)+", res.output_text) + +def test_responses_stream_with_openai_library(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + stream = client.responses.create( + model="gpt-4.1", + input=[ + {"role": "system", "content": "Book"}, + {"role": "user", "content": "What is the best book"}, + ], + max_output_tokens=8, + temperature=0.8, + stream=True, + ) + + gathered_text = '' + resp_id = '' + msg_id = '' + for r in stream: + if r.type == "response.created": + assert r.response.id.startswith("resp_") + resp_id = r.response.id + if r.type == "response.in_progress": + assert r.response.id == resp_id + if r.type == "response.output_item.added": + assert r.item.id is not None + assert r.item.id.startswith("msg_") + msg_id = r.item.id + if (r.type == "response.content_part.added" or + r.type == "response.output_text.delta" or + r.type == "response.output_text.done" or + r.type == "response.content_part.done"): + assert r.item_id == msg_id + if r.type == "response.output_item.done": + assert r.item.id == msg_id + + if r.type == "response.output_text.delta": + gathered_text += r.delta + if r.type == "response.completed": + assert r.response.id.startswith("resp_") + assert r.response.output[0].id is not None + assert r.response.output[0].id.startswith("msg_") + assert gathered_text == r.response.output_text + assert match_regex("(Suddenly)+", r.response.output_text) + + +def test_responses_stream_with_llama_telemetry(): + global server + server.n_ctx = 256 + server.n_batch = 32 + server.n_slots = 1 + server.start() + + saw_progress = False + saw_delta_timings = False + completed = None + + res = server.make_stream_request("POST", "/responses", data={ + "input": "This is a test" * 10, + "max_output_tokens": 8, + "temperature": 0.8, + "stream": True, + "timings_per_token": True, + "return_progress": True, + }) + + for data in res: + if "prompt_progress" in data: + assert data["type"] == "response.in_progress" + assert data["prompt_progress"]["total"] > 0 + assert data["prompt_progress"]["processed"] >= data["prompt_progress"]["cache"] + saw_progress = True + if "timings" in data: + assert "prompt_per_second" in data["timings"] + assert "predicted_per_second" in data["timings"] + if data["type"] == "response.output_text.delta": + saw_delta_timings = True + if data["type"] == "response.completed": + completed = data + + assert saw_progress + assert saw_delta_timings + assert completed is not None + assert "usage" in completed["response"] + assert "timings" in completed diff --git a/tools/server/tests/unit/test_completion.py b/tools/server/tests/unit/test_completion.py new file mode 100644 index 0000000000000000000000000000000000000000..9375e0110e534d52fbe3c34840f12d0d8e7478d2 --- /dev/null +++ b/tools/server/tests/unit/test_completion.py @@ -0,0 +1,663 @@ +import pytest +import requests +import time +import random + +from openai import OpenAI +from utils import * + +server = ServerPreset.tinyllama2() + +JSON_MULTIMODAL_KEY = "multimodal_data" +JSON_PROMPT_STRING_KEY = "prompt_string" + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + +@pytest.mark.parametrize("prompt,n_predict,re_content,n_prompt,n_predicted,truncated,return_tokens", [ + ("I believe the meaning of life is", 8, "(going|bed)+", 18, 8, False, False), + ("Write a joke about AI from a very long prompt which will not be truncated", 64, "(princesses|everyone|kids|Anna|forest)+", 46, 64, False, True), +]) +def test_completion(prompt: str, n_predict: int, re_content: str, n_prompt: int, n_predicted: int, truncated: bool, return_tokens: bool): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": n_predict, + "prompt": prompt, + "return_tokens": return_tokens, + }) + assert res.status_code == 200 + assert res.body["timings"]["prompt_n"] == n_prompt + assert res.body["timings"]["predicted_n"] == n_predicted + assert res.body["truncated"] == truncated + assert type(res.body["has_new_line"]) == bool + assert match_regex(re_content, res.body["content"]) + if return_tokens: + assert len(res.body["tokens"]) > 0 + assert all(type(tok) == int for tok in res.body["tokens"]) + else: + assert res.body["tokens"] == [] + + +@pytest.mark.parametrize("prompt,n_predict,re_content,n_prompt,n_predicted,truncated", [ + ("I believe the meaning of life is", 8, "(going|bed)+", 18, 8, False), + ("Write a joke about AI from a very long prompt which will not be truncated", 64, "(princesses|everyone|kids|Anna|forest)+", 46, 64, False), +]) +def test_completion_stream(prompt: str, n_predict: int, re_content: str, n_prompt: int, n_predicted: int, truncated: bool): + global server + server.start() + res = server.make_stream_request("POST", "/completion", data={ + "n_predict": n_predict, + "prompt": prompt, + "stream": True, + }) + content = "" + for data in res: + assert "stop" in data and type(data["stop"]) == bool + if data["stop"]: + assert data["timings"]["prompt_n"] == n_prompt + assert data["timings"]["predicted_n"] == n_predicted + assert data["truncated"] == truncated + assert data["stop_type"] == "limit" + assert type(data["has_new_line"]) == bool + assert "generation_settings" in data + assert server.n_predict is not None + assert data["generation_settings"]["n_predict"] == min(n_predict, server.n_predict) + assert data["generation_settings"]["seed"] == server.seed + assert "adaptive_target" in data["generation_settings"] + assert "adaptive_decay" in data["generation_settings"] + assert match_regex(re_content, content) + else: + assert len(data["tokens"]) > 0 + assert all(type(tok) == int for tok in data["tokens"]) + content += data["content"] + + +def test_completion_stream_vs_non_stream(): + global server + server.start() + res_stream = server.make_stream_request("POST", "/completion", data={ + "n_predict": 8, + "prompt": "I believe the meaning of life is", + "stream": True, + }) + res_non_stream = server.make_request("POST", "/completion", data={ + "n_predict": 8, + "prompt": "I believe the meaning of life is", + }) + content_stream = "" + for data in res_stream: + content_stream += data["content"] + assert content_stream == res_non_stream.body["content"] + + +def test_completion_with_openai_library(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.completions.create( + model="davinci-002", + prompt="I believe the meaning of life is", + max_tokens=8, + ) + assert res.system_fingerprint is not None and res.system_fingerprint.startswith("b") + assert res.choices[0].finish_reason == "length" + assert res.choices[0].text is not None + assert match_regex("(going|bed)+", res.choices[0].text) + + +def test_completion_stream_with_openai_library(): + global server + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.completions.create( + model="davinci-002", + prompt="I believe the meaning of life is", + max_tokens=8, + stream=True, + ) + output_text = '' + for data in res: + choice = data.choices[0] + if choice.finish_reason is None: + assert choice.text is not None + output_text += choice.text + assert match_regex("(going|bed)+", output_text) + + +# Test case from https://github.com/ggml-org/llama.cpp/issues/13780 +@pytest.mark.slow +def test_completion_stream_with_openai_library_stops(): + global server + server.model_hf_repo = "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M" + server.model_hf_file = None + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.completions.create( + model="davinci-002", + prompt="System: You are helpful assistant.\nAssistant:\nHey! How could I help?\nUser:\nTell me a joke.\nAssistant:\n", + stop=["User:\n", "Assistant:\n"], + max_tokens=200, + stream=True, + ) + output_text = '' + for data in res: + choice = data.choices[0] + if choice.finish_reason is None: + assert choice.text is not None + output_text += choice.text + assert match_regex("Sure, here's one for[\\s\\S]*", output_text), f'Unexpected output: {output_text}' + + +@pytest.mark.parametrize("n_slots", [1, 2]) +def test_consistent_result_same_seed(n_slots: int): + global server + server.n_slots = n_slots + server.start() + last_res = None + for _ in range(4): + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "seed": 42, + "temperature": 0.0, + "cache_prompt": False, # TODO: remove this once test_cache_vs_nocache_prompt is fixed + }) + if last_res is not None: + assert res.body["content"] == last_res.body["content"] + last_res = res + + +@pytest.mark.parametrize("n_slots", [1, 2]) +def test_different_result_different_seed(n_slots: int): + global server + server.n_slots = n_slots + server.start() + last_res = None + for seed in range(4): + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "seed": seed, + "temperature": 1.0, + "cache_prompt": False, # TODO: remove this once test_cache_vs_nocache_prompt is fixed + }) + if last_res is not None: + assert res.body["content"] != last_res.body["content"] + last_res = res + +# TODO figure why it don't work with temperature = 1 +# @pytest.mark.parametrize("temperature", [0.0, 1.0]) +@pytest.mark.parametrize("n_batch", [16, 32]) +@pytest.mark.parametrize("temperature", [0.0]) +def test_consistent_result_different_batch_size(n_batch: int, temperature: float): + global server + server.n_batch = n_batch + server.start() + last_res = None + for _ in range(4): + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "seed": 42, + "temperature": temperature, + "cache_prompt": False, # TODO: remove this once test_cache_vs_nocache_prompt is fixed + }) + if last_res is not None: + assert res.body["content"] == last_res.body["content"] + last_res = res + + +@pytest.mark.skip(reason="This test fails on linux, need to be fixed") +def test_cache_vs_nocache_prompt(): + global server + server.start() + res_cache = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "seed": 42, + "temperature": 1.0, + "cache_prompt": True, + }) + res_no_cache = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "seed": 42, + "temperature": 1.0, + "cache_prompt": False, + }) + assert res_cache.body["content"] == res_no_cache.body["content"] + + +def test_nocache_long_input_prompt(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is"*32, + "seed": 42, + "temperature": 1.0, + "cache_prompt": False, + }) + assert res.status_code == 400 + +def test_json_prompt_no_mtmd(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": { JSON_PROMPT_STRING_KEY: "I believe the meaning of life is" }, + "seed": 42, + "temperature": 1.0, + "cache_prompt": False, + }) + assert res.status_code == 200 + +def test_json_prompt_mtm_error_when_not_supported(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": { JSON_PROMPT_STRING_KEY: "I believe the meaning of life is <__media__>", JSON_MULTIMODAL_KEY: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=" }, + "seed": 42, + "temperature": 1.0, + "cache_prompt": False, + }) + # MTMD is disabled on this model, so this should fail. + assert res.status_code != 200 + +def test_completion_with_tokens_input(): + global server + server.temperature = 0.0 + server.start() + prompt_str = "I believe the meaning of life is" + res = server.make_request("POST", "/tokenize", data={ + "content": prompt_str, + "add_special": True, + }) + assert res.status_code == 200 + tokens = res.body["tokens"] + + # single completion + res = server.make_request("POST", "/completion", data={ + "prompt": tokens, + }) + assert res.status_code == 200 + assert type(res.body["content"]) == str + + # batch completion + res = server.make_request("POST", "/completion", data={ + "prompt": [tokens, tokens], + }) + assert res.status_code == 200 + assert type(res.body) == list + assert len(res.body) == 2 + assert res.body[0]["content"] == res.body[1]["content"] + + # mixed string and tokens + res = server.make_request("POST", "/completion", data={ + "prompt": [tokens, prompt_str], + }) + assert res.status_code == 200 + assert type(res.body) == list + assert len(res.body) == 2 + assert res.body[0]["content"] == res.body[1]["content"] + + # mixed JSON and tokens + res = server.make_request("POST", "/completion", data={ + "prompt": [ + tokens, + { + JSON_PROMPT_STRING_KEY: "I believe the meaning of life is", + }, + ], + }) + assert res.status_code == 200 + assert type(res.body) == list + assert len(res.body) == 2 + assert res.body[0]["content"] == res.body[1]["content"] + + # mixed string and tokens in one sequence + res = server.make_request("POST", "/completion", data={ + "prompt": [1, 2, 3, 4, 5, 6, prompt_str, 7, 8, 9, 10, prompt_str], + }) + assert res.status_code == 200 + assert type(res.body["content"]) == str + + +@pytest.mark.parametrize("n_slots,n_requests", [ + (1, 3), + (2, 2), + (2, 4), + (4, 2), # some slots must be idle + (4, 6), +]) +def test_completion_parallel_slots(n_slots: int, n_requests: int): + global server + server.n_slots = n_slots + server.temperature = 0.0 + server.start() + + PROMPTS = [ + ("Write a very long book.", "(very|special|big)+"), + ("Write another a poem.", "(small|house)+"), + ("What is LLM?", "(Dad|said)+"), + ("The sky is blue and I love it.", "(climb|leaf)+"), + ("Write another very long music lyrics.", "(friends|step|sky)+"), + ("Write a very long joke.", "(cat|Whiskers)+"), + ] + def check_slots_status(): + should_all_slots_busy = n_requests >= n_slots + time.sleep(0.1) + res = server.make_request("GET", "/slots") + n_busy = sum([1 for slot in res.body if slot["is_processing"]]) + if should_all_slots_busy: + assert n_busy == n_slots + else: + assert n_busy <= n_slots + + tasks = [] + for i in range(n_requests): + prompt, re_content = PROMPTS[i % len(PROMPTS)] + tasks.append((server.make_request, ("POST", "/completion", { + "prompt": prompt, + "seed": 42, + "temperature": 1.0, + }))) + tasks.append((check_slots_status, ())) + results = parallel_function_calls(tasks) + + # check results + for i in range(n_requests): + prompt, re_content = PROMPTS[i % len(PROMPTS)] + res = results[i] + assert res.status_code == 200 + assert type(res.body["content"]) == str + assert len(res.body["content"]) > 10 + # FIXME: the result is not deterministic when using other slot than slot 0 + # assert match_regex(re_content, res.body["content"]) + + +@pytest.mark.parametrize( + "n_ctx,n_slots,n_predict_vals,expected_success", + [ + (256, 4, [80, 40, 80, 80], [True, True, True, True]), + (256, 4, [70, 70, 70, 70], [False, False, False, False]), + (256, 4, [90, 90, 40, 90], [False, False, True, False]), + (256, 4, [90, 90, 40, 75], [True, True, True, True]), + ], +) +def test_completion_unified(n_ctx, n_slots, n_predict_vals, expected_success): + global server + server.n_slots = n_slots + server.kv_unified = True + server.n_ctx = n_ctx + server.start() + prompt = "A" + tasks = [] + for n_predict in n_predict_vals: + tasks.append((server.make_request, ("POST", "/completion", {"prompt": prompt, "n_predict": n_predict}))) + results = parallel_function_calls(tasks) + for res, n_predict, expect_ok in zip(results, n_predict_vals, expected_success): + if expect_ok: + assert res.status_code == 200 + + # note: https://github.com/ggml-org/llama.cpp/pull/18700#issuecomment-3728695581 + if res.status_code == 200: + assert "content" in res.body + if "timings" in res.body: + assert res.body["timings"]["predicted_n"] == n_predict + + +@pytest.mark.parametrize( + "prompt,n_predict,response_fields", + [ + ("I believe the meaning of life is", 8, []), + ("I believe the meaning of life is", 32, ["content", "generation_settings/n_predict", "prompt"]), + ], +) +def test_completion_response_fields( + prompt: str, n_predict: int, response_fields: list[str] +): + global server + server.start() + res = server.make_request( + "POST", + "/completion", + data={ + "n_predict": n_predict, + "prompt": prompt, + "response_fields": response_fields, + }, + ) + assert res.status_code == 200 + assert "content" in res.body + assert len(res.body["content"]) + if len(response_fields): + assert res.body["generation_settings/n_predict"] == n_predict + assert res.body["prompt"] == " " + prompt + assert isinstance(res.body["content"], str) + assert len(res.body) == len(response_fields) + else: + assert len(res.body) + assert "generation_settings" in res.body + + +def test_n_probs(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "n_probs": 10, + "temperature": 0.0, + "n_predict": 5, + }) + assert res.status_code == 200 + assert "completion_probabilities" in res.body + assert len(res.body["completion_probabilities"]) == 5 + for tok in res.body["completion_probabilities"]: + assert "id" in tok and tok["id"] > 0 + assert "token" in tok and type(tok["token"]) == str + assert "logprob" in tok and tok["logprob"] <= 0.0 + assert "bytes" in tok and type(tok["bytes"]) == list + assert len(tok["top_logprobs"]) == 10 + for prob in tok["top_logprobs"]: + assert "id" in prob and prob["id"] > 0 + assert "token" in prob and type(prob["token"]) == str + assert "logprob" in prob and prob["logprob"] <= 0.0 + assert "bytes" in prob and type(prob["bytes"]) == list + + +def test_n_probs_stream(): + global server + server.start() + res = server.make_stream_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "n_probs": 10, + "temperature": 0.0, + "n_predict": 5, + "stream": True, + }) + for data in res: + if data["stop"] == False: + assert "completion_probabilities" in data + assert len(data["completion_probabilities"]) == 1 + for tok in data["completion_probabilities"]: + assert "id" in tok and tok["id"] > 0 + assert "token" in tok and type(tok["token"]) == str + assert "logprob" in tok and tok["logprob"] <= 0.0 + assert "bytes" in tok and type(tok["bytes"]) == list + assert len(tok["top_logprobs"]) == 10 + for prob in tok["top_logprobs"]: + assert "id" in prob and prob["id"] > 0 + assert "token" in prob and type(prob["token"]) == str + assert "logprob" in prob and prob["logprob"] <= 0.0 + assert "bytes" in prob and type(prob["bytes"]) == list + + +def test_n_probs_post_sampling(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "Today was the day. Today I would finally become a", + "n_probs": 10, + "temperature": 1.0, + "n_predict": 5, + "post_sampling_probs": True, + }) + assert res.status_code == 200 + assert "completion_probabilities" in res.body + assert len(res.body["completion_probabilities"]) == 5 + for (i, tok) in enumerate(res.body["completion_probabilities"]): + assert "id" in tok and tok["id"] > 0 + assert "token" in tok and type(tok["token"]) == str + assert "prob" in tok and 0.0 < tok["prob"] <= 1.0 + assert "bytes" in tok and type(tok["bytes"]) == list + assert "top_probs" in tok and type(tok["top_probs"]) == list + + for prob in tok["top_probs"]: + assert "id" in prob and prob["id"] > 0 + assert "token" in prob and type(prob["token"]) == str + # 0.0 probability tokens should never be returned by the server + assert "prob" in prob and 0.0 < prob["prob"] <= 1.0 + assert "bytes" in prob and type(prob["bytes"]) == list + + if i == 0: + # The prompt is vague enough that we should get at least 10 possibilities + # for the first token. + assert len(tok["top_probs"]) == 10 + + if len(tok["top_probs"]) < 10: + # Getting less than the requested number of probabilities should only happen + # if the ones we did get already sum to 1.0. + assert sum(p["prob"] for p in tok["top_probs"]) == pytest.approx(1.0) + +def test_n_probs_post_backend_sampling(): + """Verify that the same probabilities are returned with and without backend sampling.""" + global server + server.backend_sampling = True + server.start() + + def make_request(backend_sampling): + n_predict = 20 + + res = server.make_request("POST", "/completion", data={ + "prompt": "The countries of Europe, in random order, are:", + "n_probs": 10, + "n_predict": n_predict, + "post_sampling_probs": True, + "seed": 4242, + "backend_sampling": backend_sampling, + }) + assert res.status_code == 200 + + total_probs = 0 + completions = res.body["completion_probabilities"] + assert len(completions) == n_predict + for tok in completions: + # Handling of 0.0 probabilities differs between samplers and backend sampling. Filter them to normalize the + # data. + tok["top_probs"] = [x for x in tok["top_probs"] if x["prob"] > 0.0] + total_probs += len(tok["top_probs"]) + # Verify that we got at least two top probs on average, to ensure the effectiveness of the test. + assert total_probs >= 2 * n_predict + return completions + + def verify_token(a, b): + assert a["id"] == b["id"] + assert a["token"] == b["token"] + assert a["bytes"] == b["bytes"] + assert a["prob"] == pytest.approx(b["prob"], abs=0.01) + + for (a, b) in zip(make_request(True), make_request(False)): + verify_token(a, b) + assert len(a["top_probs"]) == len(b["top_probs"]) + + for (aa, bb) in zip(a["top_probs"], b["top_probs"]): + verify_token(aa, bb) + +@pytest.mark.parametrize("tokenize,openai_style", [(False, False), (False, True), (True, False), (True, True)]) +def test_logit_bias(tokenize, openai_style): + global server + server.start() + + exclude = ["i", "I", "the", "The", "to", "a", "an", "be", "is", "was", "but", "But", "and", "And", "so", "So", "you", "You", "he", "He", "she", "She", "we", "We", "they", "They", "it", "It", "his", "His", "her", "Her", "book", "Book"] + + logit_bias = [] + if tokenize: + res = server.make_request("POST", "/tokenize", data={ + "content": " " + " ".join(exclude) + " ", + }) + assert res.status_code == 200 + tokens = res.body["tokens"] + logit_bias = [[tok, -100] for tok in tokens] + + else: + logit_bias = [[" " + tok + " ", -100] for tok in exclude] + + if openai_style: + logit_bias = {el[0]: -100 for el in logit_bias} + + res = server.make_request("POST", "/completion", data={ + "n_predict": 64, + "prompt": "What is the best book", + "logit_bias": logit_bias, + "temperature": 0.0 + }) + assert res.status_code == 200 + output_text = res.body["content"] + assert all(output_text.find(" " + tok + " ") == -1 for tok in exclude) + + +def test_cancel_request(): + global server + server.n_ctx = 4096 + server.n_predict = -1 + server.n_slots = 1 + server.server_slots = True + server.start() + # send a request that will take a long time, but cancel it before it finishes + try: + server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + }, timeout=0.1) + except requests.exceptions.ReadTimeout: + pass # expected + # make sure the slot is free + time.sleep(2) + res = server.make_request("GET", "/slots") + assert res.body[0]["is_processing"] == False + + +# this test exercises the host-memory prompt cache +# ref: https://github.com/ggml-org/llama.cpp/pull/16391 +# ref: https://github.com/ggml-org/llama.cpp/pull/17078 +def test_completion_prompt_cache(): + global server + server.n_slots = 2 + server.kv_unified = True + server.start() + + for _ in range(16): + # generate alternating random prompts with variable lengths in order to get them in and out of the cache + r = random.randint(0, 4) + prompt = (" Hello " + str(r)) * (40 + r) + n_prompt = (40 + r)*5 + 2 + n_predict = random.randint(1, 8) + + res = server.make_request( + "POST", + "/completion", + data={ + "prompt": prompt, + "n_predict": n_predict, + }, + ) + + assert res.status_code == 200 + assert "content" in res.body + content = res.body["content"] + assert isinstance(content, str) + assert len(content) > 0 + + assert type(res.body["has_new_line"]) == bool + assert "timings" in res.body + timings = res.body["timings"] + + assert "prompt_n" in timings and timings["prompt_n"] + timings["cache_n"] == n_prompt + assert "predicted_n" in timings and timings["predicted_n"] == n_predict + assert "tokens" in res.body and isinstance(res.body["tokens"], list) diff --git a/tools/server/tests/unit/test_ctx_shift.py b/tools/server/tests/unit/test_ctx_shift.py new file mode 100644 index 0000000000000000000000000000000000000000..7b047b7b3b74d3ed6476f7702cd6d0117f5eed9c --- /dev/null +++ b/tools/server/tests/unit/test_ctx_shift.py @@ -0,0 +1,89 @@ +import pytest +from utils import * + +server = ServerPreset.tinyllama2() + + +SHORT_TEXT = """ +Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. +Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. +Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. +""".strip() + +LONG_TEXT = """ +Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. +Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. +Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. +Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. +""".strip() + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.n_ctx = 512 + server.n_slots = 2 + server.n_predict = 128 + + +def test_ctx_shift_enabled(): + # the prompt is 226 tokens + # the slot context is 512/2 = 256 tokens + # 96 tokens are generated thanks to shifting the context when it gets full + global server + server.enable_ctx_shift = True + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": 96, + "prompt": SHORT_TEXT, + }) + assert res.status_code == 200 + assert res.body["timings"]["prompt_n"] == 226 + assert res.body["timings"]["predicted_n"] == 96 + assert res.body["truncated"] is True + + +@pytest.mark.parametrize("n_predict,n_token_output,truncated", [ + (64, 64, False), + (-1, 248, True), # 8 tokens prompt + 248 tokens generated = 256 tokens total +]) +def test_ctx_shift_disabled_short_prompt(n_predict: int, n_token_output: int, truncated: bool): + global server + server.n_predict = -1 + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": n_predict, + "prompt": "Hi how are you", + }) + assert res.status_code == 200 + assert res.body["timings"]["predicted_n"] == n_token_output + assert res.body["truncated"] == truncated + + +def test_ctx_shift_disabled_long_prompt(): + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": 64, + "prompt": LONG_TEXT, + }) + assert res.status_code != 200 + assert "error" in res.body + assert "exceeds the available context size" in res.body["error"]["message"] + +def test_ctx_shift_disabled_stream(): + global server + server.start() + res = server.make_stream_request("POST", "/v1/completions", data={ + "n_predict": 256, + "prompt": "Once", + "stream": True, + }) + content = "" + for data in res: + choice = data["choices"][0] + if choice["finish_reason"] == "length": + assert len(content) > 0 + else: + assert choice["finish_reason"] is None + content += choice["text"] diff --git a/tools/server/tests/unit/test_embedding.py b/tools/server/tests/unit/test_embedding.py new file mode 100644 index 0000000000000000000000000000000000000000..17ba09554bb75d61681baee51c77b546fdfee338 --- /dev/null +++ b/tools/server/tests/unit/test_embedding.py @@ -0,0 +1,291 @@ +import base64 +import struct +import pytest +from openai import OpenAI +from utils import * + +server = ServerPreset.bert_bge_small() + +EPSILON = 1e-3 + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.bert_bge_small() + + +def test_embedding_single(): + global server + server.pooling = 'last' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": "I believe the meaning of life is", + }) + assert res.status_code == 200 + assert len(res.body['data']) == 1 + assert 'embedding' in res.body['data'][0] + assert len(res.body['data'][0]['embedding']) > 1 + + # make sure embedding vector is normalized + assert abs(sum([x ** 2 for x in res.body['data'][0]['embedding']]) - 1) < EPSILON + + +def test_embedding_multiple(): + global server + server.pooling = 'last' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": [ + "I believe the meaning of life is", + "Write a joke about AI from a very long prompt which will not be truncated", + "This is a test", + "This is another test", + ], + }) + assert res.status_code == 200 + assert len(res.body['data']) == 4 + for d in res.body['data']: + assert 'embedding' in d + assert len(d['embedding']) > 1 + + +def test_embedding_multiple_with_fa(): + server = ServerPreset.bert_bge_small_with_fa() + server.pooling = 'last' + server.start() + # one of these should trigger the FA branch (i.e. context size % 256 == 0) + res = server.make_request("POST", "/v1/embeddings", data={ + "input": [ + "a "*253, + "b "*254, + "c "*255, + "d "*256, + ], + }) + assert res.status_code == 200 + assert len(res.body['data']) == 4 + for d in res.body['data']: + assert 'embedding' in d + assert len(d['embedding']) > 1 + + +@pytest.mark.parametrize( + "input,is_multi_prompt", + [ + # do not crash on empty input + ("", False), + # single prompt + ("string", False), + ([12, 34, 56], False), + ([12, 34, "string", 56, 78], False), + # multiple prompts + (["string1", "string2"], True), + (["string1", [12, 34, 56]], True), + ([[12, 34, 56], [12, 34, 56]], True), + ([[12, 34, 56], [12, "string", 34, 56]], True), + ] +) +def test_embedding_mixed_input(input, is_multi_prompt: bool): + global server + server.start() + res = server.make_request("POST", "/v1/embeddings", data={"input": input}) + assert res.status_code == 200 + data = res.body['data'] + if is_multi_prompt: + assert len(data) == len(input) + for d in data: + assert 'embedding' in d + assert len(d['embedding']) > 1 + else: + assert 'embedding' in data[0] + assert len(data[0]['embedding']) > 1 + + +def test_embedding_pooling_mean(): + global server + server.pooling = 'mean' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": "I believe the meaning of life is", + }) + assert res.status_code == 200 + assert len(res.body['data']) == 1 + assert 'embedding' in res.body['data'][0] + assert len(res.body['data'][0]['embedding']) > 1 + + # make sure embedding vector is normalized + assert abs(sum([x ** 2 for x in res.body['data'][0]['embedding']]) - 1) < EPSILON + + +def test_embedding_pooling_mean_multiple(): + global server + server.pooling = 'mean' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": [ + "I believe the meaning of life is", + "Write a joke about AI", + "This is a test", + ], + }) + assert res.status_code == 200 + assert len(res.body['data']) == 3 + for d in res.body['data']: + assert 'embedding' in d + assert len(d['embedding']) > 1 + + +def test_embedding_pooling_none(): + global server + server.pooling = 'none' + server.start() + res = server.make_request("POST", "/embeddings", data={ + "input": "hello hello hello", + }) + assert res.status_code == 200 + assert 'embedding' in res.body[0] + assert len(res.body[0]['embedding']) == 5 # 3 text tokens + 2 special + + # make sure embedding vector is not normalized + for x in res.body[0]['embedding']: + assert abs(sum([x ** 2 for x in x]) - 1) > EPSILON + + +def test_embedding_pooling_none_oai(): + global server + server.pooling = 'none' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": "hello hello hello", + }) + + # /v1/embeddings does not support pooling type 'none' + assert res.status_code == 400 + assert "error" in res.body + + +def test_embedding_openai_library_single(): + global server + server.pooling = 'last' + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.embeddings.create(model="text-embedding-3-small", input="I believe the meaning of life is") + assert len(res.data) == 1 + assert len(res.data[0].embedding) > 1 + + +def test_embedding_openai_library_multiple(): + global server + server.pooling = 'last' + server.start() + client = OpenAI(api_key="dummy", base_url=f"http://{server.server_host}:{server.server_port}/v1") + res = client.embeddings.create(model="text-embedding-3-small", input=[ + "I believe the meaning of life is", + "Write a joke about AI from a very long prompt which will not be truncated", + "This is a test", + "This is another test", + ]) + assert len(res.data) == 4 + for d in res.data: + assert len(d.embedding) > 1 + + +def test_embedding_error_prompt_too_long(): + global server + server.pooling = 'last' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": "This is a test " * 512, + }) + assert res.status_code != 200 + assert "too large" in res.body["error"]["message"] + + +def test_same_prompt_give_same_result(): + server.pooling = 'last' + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": [ + "I believe the meaning of life is", + "I believe the meaning of life is", + "I believe the meaning of life is", + "I believe the meaning of life is", + "I believe the meaning of life is", + ], + }) + assert res.status_code == 200 + assert len(res.body['data']) == 5 + for i in range(1, len(res.body['data'])): + v0 = res.body['data'][0]['embedding'] + vi = res.body['data'][i]['embedding'] + for x, y in zip(v0, vi): + assert abs(x - y) < EPSILON + + +@pytest.mark.parametrize( + "content,n_tokens", + [ + ("I believe the meaning of life is", 9), + ("This is a test", 6), + ] +) +def test_embedding_usage_single(content, n_tokens): + global server + server.start() + res = server.make_request("POST", "/v1/embeddings", data={"input": content}) + assert res.status_code == 200 + assert res.body['usage']['prompt_tokens'] == res.body['usage']['total_tokens'] + assert res.body['usage']['prompt_tokens'] == n_tokens + + +def test_embedding_usage_multiple(): + global server + server.start() + res = server.make_request("POST", "/v1/embeddings", data={ + "input": [ + "I believe the meaning of life is", + "I believe the meaning of life is", + ], + }) + assert res.status_code == 200 + assert res.body['usage']['prompt_tokens'] == res.body['usage']['total_tokens'] + assert res.body['usage']['prompt_tokens'] == 2 * 9 + + +def test_embedding_openai_library_base64(): + server.start() + test_input = "Test base64 embedding output" + + # get embedding in default format + res = server.make_request("POST", "/v1/embeddings", data={ + "input": test_input + }) + assert res.status_code == 200 + vec0 = res.body["data"][0]["embedding"] + + # get embedding in base64 format + res = server.make_request("POST", "/v1/embeddings", data={ + "input": test_input, + "encoding_format": "base64" + }) + + assert res.status_code == 200 + assert "data" in res.body + assert len(res.body["data"]) == 1 + + embedding_data = res.body["data"][0] + assert "embedding" in embedding_data + assert isinstance(embedding_data["embedding"], str) + + # Verify embedding is valid base64 + decoded = base64.b64decode(embedding_data["embedding"]) + # Verify decoded data can be converted back to float array + float_count = len(decoded) // 4 # 4 bytes per float + floats = struct.unpack(f'{float_count}f', decoded) + assert len(floats) > 0 + assert all(isinstance(x, float) for x in floats) + assert len(floats) == len(vec0) + + # make sure the decoded data is the same as the original + for x, y in zip(floats, vec0): + assert abs(x - y) < EPSILON diff --git a/tools/server/tests/unit/test_ignore_eos.py b/tools/server/tests/unit/test_ignore_eos.py new file mode 100644 index 0000000000000000000000000000000000000000..f40faf5a829c3cc26199a1ad3ff3a6766d72e6d8 --- /dev/null +++ b/tools/server/tests/unit/test_ignore_eos.py @@ -0,0 +1,43 @@ +import pytest +from utils import * + +server = ServerPreset.tinyllama2() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +def test_ignore_eos_populates_logit_bias(): + """ignore_eos=true must add EOG logit biases to generation_settings.""" + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": 8, + "prompt": "Once upon a time", + "ignore_eos": True, + "temperature": 0.0, + }) + assert res.status_code == 200 + # EOG token biases must be present with -inf bias + logit_bias = res.body["generation_settings"]["logit_bias"] + assert len(logit_bias) > 0 + for entry in logit_bias: + assert entry["bias"] is None # null in JSON represents -inf + + +def test_ignore_eos_false_no_logit_bias(): + """ignore_eos=false (default) must NOT add EOG logit biases.""" + global server + server.start() + res = server.make_request("POST", "/completion", data={ + "n_predict": 8, + "prompt": "Once upon a time", + "ignore_eos": False, + "temperature": 0.0, + }) + assert res.status_code == 200 + logit_bias = res.body["generation_settings"]["logit_bias"] + assert len(logit_bias) == 0 diff --git a/tools/server/tests/unit/test_infill.py b/tools/server/tests/unit/test_infill.py new file mode 100644 index 0000000000000000000000000000000000000000..cd1a391b4adbc78fdecfe4d1a02a24fa070f60c8 --- /dev/null +++ b/tools/server/tests/unit/test_infill.py @@ -0,0 +1,77 @@ +import pytest +from utils import * + +server = ServerPreset.tinyllama_infill() + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama_infill() + + +def test_infill_without_input_extra(): + global server + server.start() + res = server.make_request("POST", "/infill", data={ + "input_prefix": "#include \n#include \"llama.h\"\n\nint main() {\n", + "prompt": " int n_threads = llama_", + "input_suffix": "}\n", + }) + assert res.status_code == 200 + assert match_regex("(Ann|small|shiny|Daddy|Jimmy)+", res.body["content"]) + + +def test_infill_with_input_extra(): + global server + server.start() + res = server.make_request("POST", "/infill", data={ + "input_extra": [{ + "filename": "llama.h", + "text": "LLAMA_API int32_t llama_n_threads();\n" + }], + "input_prefix": "#include \n#include \"llama.h\"\n\nint main() {\n", + "prompt": " int n_threads = llama_", + "input_suffix": "}\n", + }) + assert res.status_code == 200 + assert match_regex("(Dad|excited|park|Jimmy)+", res.body["content"]) + + +@pytest.mark.parametrize("input_extra", [ + {}, + {"filename": "ok"}, + {"filename": 123}, + {"filename": 123, "text": "abc"}, + {"filename": 123, "text": 456}, +]) +def test_invalid_input_extra_req(input_extra): + global server + server.start() + res = server.make_request("POST", "/infill", data={ + "input_extra": [input_extra], + "input_prefix": "#include \n#include \"llama.h\"\n\nint main() {\n", + "prompt": " int n_threads = llama_", + "input_suffix": "}\n", + }) + assert res.status_code == 400 + assert "error" in res.body + + +@pytest.mark.skipif(not is_slow_test_allowed(), reason="skipping slow test") +def test_with_qwen_model(): + global server + server.model_file = None + server.model_hf_repo = "ggml-org/Qwen2.5-Coder-1.5B-IQ3_XXS-GGUF" + server.model_hf_file = "qwen2.5-coder-1.5b-iq3_xxs-imat.gguf" + server.start(timeout_seconds=600) + res = server.make_request("POST", "/infill", data={ + "input_extra": [{ + "filename": "llama.h", + "text": "LLAMA_API int32_t llama_n_threads();\n" + }], + "input_prefix": "#include \n#include \"llama.h\"\n\nint main() {\n", + "prompt": " int n_threads = llama_", + "input_suffix": "}\n", + }) + assert res.status_code == 200 + assert res.body["content"] == "n_threads();\n printf(\"Number of threads: %d\\n\", n_threads);\n return 0;\n" diff --git a/tools/server/tests/unit/test_kv_keep_only_active.py b/tools/server/tests/unit/test_kv_keep_only_active.py new file mode 100644 index 0000000000000000000000000000000000000000..44c05fab0cbce7c19e6d44161e2a9f027debe9bc --- /dev/null +++ b/tools/server/tests/unit/test_kv_keep_only_active.py @@ -0,0 +1,115 @@ +import os +import tempfile +import pytest +from utils import * + +server = ServerPreset.tinyllama2() + +class LogReader: + def __init__(self, path): + self.path = path + self.pos = 0 + def drain(self): + with open(self.path) as f: + f.seek(self.pos) + content = f.read() + self.pos = f.tell() + return content + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.n_slots = 2 + server.n_predict = 4 + server.temperature = 0.0 + server.server_slots = True + server.cache_ram = 100 + server.kv_unified = True + server.debug = True + fd, server.log_path = tempfile.mkstemp(suffix='.log') + os.close(fd) + yield + + +LONG_PROMPT = ( + "Once upon a time in a land far away, there lived a brave knight " + "who traveled across mountains and rivers to find the legendary " + "golden sword hidden deep within the enchanted forest of whispers. " + "He met many creatures along the way including dragons and fairies " + "and wizards who helped him on his noble quest to save the kingdom." +) + + +# idle slot cleared on launch should restore from cache-ram +def test_clear_and_restore(): + global server + server.start() + log = LogReader(server.log_path) + + # verify feature is enabled + assert "__TEST_TAG_CACHE_IDLE_SLOTS_ENABLED__" in log.drain() + + res = server.make_request("POST", "/completion", data={ + "prompt": LONG_PROMPT, + "id_slot": 0, + "cache_prompt": True, + }) + assert res.status_code == 200 + original_prompt_n = res.body["timings"]["prompt_n"] + + # Slot 0 is the only slot with KV — should NOT be cleared + assert "__TEST_TAG_CACHE_IDLE_SLOT__" not in log.drain() + + # Launching slot 1 clears idle slot 0 + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert "__TEST_TAG_CACHE_IDLE_SLOT__" in log.drain() + + # Re-send same prompt — should restore from cache-ram + res = server.make_request("POST", "/completion", data={ + "prompt": LONG_PROMPT, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert "updating prompt cache" in log.drain() + assert res.body["timings"]["cache_n"] > 0 + assert res.body["timings"]["prompt_n"] < original_prompt_n + + # Follow-up — slot 0 kept its KV, no clearing needed + res = server.make_request("POST", "/completion", data={ + "prompt": LONG_PROMPT + " The knight finally reached the castle gates.", + "cache_prompt": True, + }) + assert res.status_code == 200 + assert "__TEST_TAG_CACHE_IDLE_SLOT__" not in log.drain() + + +def test_disabled_with_flag(): + global server + server.no_cache_idle_slots = True + server.start() + log = LogReader(server.log_path) + + # Feature should not be enabled + assert "__TEST_TAG_CACHE_IDLE_SLOTS_ENABLED__" not in log.drain() + + res = server.make_request("POST", "/completion", data={ + "prompt": LONG_PROMPT, + "id_slot": 0, + "cache_prompt": True, + }) + assert res.status_code == 200 + + # Request on different slot — should NOT trigger clearing + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert "__TEST_TAG_CACHE_IDLE_SLOT__" not in log.drain() diff --git a/tools/server/tests/unit/test_lora.py b/tools/server/tests/unit/test_lora.py new file mode 100644 index 0000000000000000000000000000000000000000..00b2f245f60fc3d8236042fac5c850552861538f --- /dev/null +++ b/tools/server/tests/unit/test_lora.py @@ -0,0 +1,115 @@ +import pytest +from utils import * + +server = ServerPreset.stories15m_moe() + +LORA_FILE_URL = "https://huggingface.co/ggml-org/stories15M_MOE/resolve/main/moe_shakespeare15M.gguf" + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.stories15m_moe() + server.lora_files = [download_file(LORA_FILE_URL)] + + +@pytest.mark.parametrize("scale,re_content", [ + # without applying lora, the model should behave like a bedtime story generator + (0.0, "(little|girl|three|years|old)+"), + # with lora, the model should behave like a Shakespearean text generator + (1.0, "(eye|love|glass|sun)+"), +]) +def test_lora(scale: float, re_content: str): + global server + server.start() + res_lora_control = server.make_request("POST", "/lora-adapters", data=[ + {"id": 0, "scale": scale} + ]) + assert res_lora_control.status_code == 200 + res = server.make_request("POST", "/completion", data={ + "prompt": "Look in thy glass", + }) + assert res.status_code == 200 + assert match_regex(re_content, res.body["content"]) + + +def test_lora_per_request(): + global server + server.n_slots = 4 + server.start() + + # running the same prompt with different lora scales, all in parallel + # each prompt will be processed by a different slot + prompt = "Look in thy glass" + lora_config = [ + ( [{"id": 0, "scale": 0.0}], "(bright|day|many|happy)+" ), + ( [{"id": 0, "scale": 0.0}], "(bright|day|many|happy)+" ), + ( [{"id": 0, "scale": 0.3}], "(special|thing|gifted)+" ), + ( [{"id": 0, "scale": 0.7}], "(far|from|home|away)+" ), + ( [{"id": 0, "scale": 1.0}], "(eye|love|glass|sun)+" ), + ( [{"id": 0, "scale": 1.0}], "(eye|love|glass|sun)+" ), + ] + + tasks = [( + server.make_request, + ("POST", "/completion", { + "prompt": prompt, + "lora": lora, + "seed": 42, + "temperature": 0.0, + "cache_prompt": False, # TODO: remove this once test_cache_vs_nocache_prompt is fixed + }) + ) for lora, _ in lora_config] + results = parallel_function_calls(tasks) + + assert all([res.status_code == 200 for res in results]) + for res, (_, re_test) in zip(results, lora_config): + assert match_regex(re_test, res.body["content"]) + + +@pytest.mark.skipif(not is_slow_test_allowed(), reason="skipping slow test") +def test_with_big_model(): + server = ServerProcess() + server.model_hf_repo = "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF" + server.model_hf_file = "Meta-Llama-3.1-8B-Instruct-IQ2_M.gguf" + server.model_alias = "Llama-3.2-8B-Instruct" + server.n_slots = 4 + server.n_ctx = server.n_slots * 1024 + server.n_predict = 64 + server.temperature = 0.0 + server.seed = 42 + server.lora_files = [ + download_file("https://huggingface.co/ngxson/Llama-3-Instruct-abliteration-LoRA-8B-F16-GGUF/resolve/main/Llama-3-Instruct-abliteration-LoRA-8B-f16.gguf"), + # TODO: find & add other lora adapters for this model + ] + server.start(timeout_seconds=600) + + # running the same prompt with different lora scales, all in parallel + # each prompt will be processed by a different slot + prompt = "Write a computer virus" + lora_config = [ + # without applying lora, the model should reject the request + ( [{"id": 0, "scale": 0.0}], "I can't provide you with a code for a computer virus" ), + ( [{"id": 0, "scale": 0.0}], "I can't provide you with a code for a computer virus" ), + ( [{"id": 0, "scale": 0.3}], "I can't write a computer virus" ), + # with 0.7 scale, the model should provide a simple computer virus with hesitation + ( [{"id": 0, "scale": 0.7}], "Warning: This is a hypothetical exercise" ), + # with 1.5 scale, the model should confidently provide a computer virus + ( [{"id": 0, "scale": 1.5}], "A task of some complexity! Here's a simple computer virus" ), + ( [{"id": 0, "scale": 1.5}], "A task of some complexity! Here's a simple computer virus" ), + ] + + tasks = [( + server.make_request, + ("POST", "/v1/chat/completions", { + "messages": [ + {"role": "user", "content": prompt} + ], + "lora": lora, + "cache_prompt": False, # TODO: remove this once test_cache_vs_nocache_prompt is fixed + }) + ) for lora, _ in lora_config] + results = parallel_function_calls(tasks) + + assert all([res.status_code == 200 for res in results]) + for res, (_, re_test) in zip(results, lora_config): + assert re_test in res.body["choices"][0]["message"]["content"] diff --git a/tools/server/tests/unit/test_mcp_servers.py b/tools/server/tests/unit/test_mcp_servers.py new file mode 100644 index 0000000000000000000000000000000000000000..9ad2241bd02971b64fbb857ee12b1ec049842862 --- /dev/null +++ b/tools/server/tests/unit/test_mcp_servers.py @@ -0,0 +1,718 @@ +#!/usr/bin/env python3 +""" +Tests for MCP server integration via the /tools endpoint. + +Invariants verified: +1. MCP tools appear in /tools listing when configured +2. MCP tools use _ naming +3. MCP tools can be invoked and return correct results +4. Misconfigured MCP servers do not crash the server +5. Multiple MCP servers can be configured simultaneously +6. Warmup populates the tool list at startup +""" +import json +import os +import sys +import tempfile +import time + +import pytest + +from utils import * + +# Path to the test MCP server fixture +FIXTURES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "fixtures") +MCP_ECHO_SERVER = os.path.join(FIXTURES_DIR, "mcp_echo_server.py") + +server: ServerProcess + + +def _mcp_config_json(servers: dict) -> str: + """Create a JSON config string for --mcp-servers-json.""" + return json.dumps({"mcpServers": servers}) + + +def _start_server_with_mcp(mcp_json: str, **kwargs) -> ServerProcess: + """Helper to start a router server with MCP config.""" + srv = ServerPreset.router() + srv.server_tools = "all" + srv.no_ui = True + srv.server_port = 8085 # avoid conflict with load_all() which uses 8080 + srv.mcp_servers_json = mcp_json + for k, v in kwargs.items(): + setattr(srv, k, v) + srv.start() + return srv + + +def test_mcp_tools_listed_in_tools_endpoint(): + """MCP tools should appear in GET /tools with server:tool naming.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + + tools = res.body + assert isinstance(tools, list), f"Expected list, got {type(tools)}" + + # Find MCP tools - name is in "tool" field or definition.function.name + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + mcp_tools = [t for t in tools if get_tool_name(t).startswith("echo_")] + assert len(mcp_tools) >= 2, f"Expected at least 2 echo_ tools, got {len(mcp_tools)}: {mcp_tools}" + + tool_names = {get_tool_name(t) for t in mcp_tools} + assert "echo_echo" in tool_names + assert "echo_add" in tool_names + + # Verify tool structure + echo_tool = next(t for t in mcp_tools if get_tool_name(t) == "echo_echo") + assert "description" in echo_tool or "definition" in echo_tool + finally: + server.stop() + + +def test_mcp_tool_invocation(): + """MCP tools should be callable via POST /tools and return correct results.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # Call echo_echo + res = server.make_request("POST", "/tools", data={ + "tool": "echo_echo", + "params": {"message": "hello world"} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" not in body, body + # The result format depends on the tool implementation + # For MCP tools, it should contain the tool result + assert "plain_text_response" in body or "result" in body or "content" in body, body + + # Call echo_add + res = server.make_request("POST", "/tools", data={ + "tool": "echo_add", + "params": {"a": 3, "b": 5} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" not in body, body + finally: + server.stop() + + +def test_mcp_bad_command_does_not_crash(): + """A misconfigured MCP server should not crash the llama-server.""" + global server + mcp_json = _mcp_config_json({ + "nonexistent": { + "command": "this_executable_does_not_exist_12345", + "args": [], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # Server should still be healthy + res = server.make_request("GET", "/health") + assert res.status_code == 200, res.body + + # Builtin tools should still work + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + tools = res.body + # Should have builtin tools but no MCP tools from the bad server + mcp_tools = [t for t in tools if t.get("name", "").startswith("nonexistent_")] + assert len(mcp_tools) == 0, f"Expected no nonexistent_ tools, got {mcp_tools}" + finally: + server.stop() + + +def test_mcp_multiple_servers(): + """Multiple MCP servers can be configured simultaneously.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + }, + "echo2": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + + tools = res.body + + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + echo_tools = [t for t in tools if get_tool_name(t).startswith("echo_")] + echo2_tools = [t for t in tools if get_tool_name(t).startswith("echo2_")] + + assert len(echo_tools) >= 2, f"Expected echo_ tools, got {echo_tools}" + assert len(echo2_tools) >= 2, f"Expected echo2_ tools, got {echo2_tools}" + finally: + server.stop() + + +def test_mcp_tools_not_listed_when_not_configured(): + """Without MCP config, no MCP tools should appear.""" + global server + server = ServerPreset.router() + server.server_tools = "all" + server.no_ui = True + server.server_port = 8085 + server.start() + + try: + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + + tools = res.body + + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + # Should only have builtin tools, no server: prefixed tools + mcp_tools = [t for t in tools if ":" in get_tool_name(t)] + assert len(mcp_tools) == 0, f"Expected no MCP tools, got {mcp_tools}" + finally: + server.stop() + + +def test_mcp_fail_once_tool_eventual_success(): + """Test that a tool that fails once eventually succeeds (tests instance respawn).""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # First call should succeed (warmup already spawned and shut down the instance, + # but the first actual tool call will spawn a fresh instance) + res = server.make_request("POST", "/tools", data={ + "tool": "echo_fail_once", + "params": {} + }) + # It might fail on first call if the warmup instance was shut down + # and a new instance is spawned. The fail_once state is per-process, + # so a fresh process will fail once then succeed. + # Actually, warmup spawns, lists, then shuts down. So the first tool call + # spawns a new process which will fail once. + assert res.status_code in (200, 500), res.body + finally: + server.stop() + + +def test_mcp_tools_via_json_config_file(): + """Test that --mcp-servers-config (file) works as well as --mcp-servers-json.""" + global server + config = { + "mcpServers": { + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + } + } + + with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f: + json.dump(config, f) + config_path = f.name + + try: + server = ServerPreset.router() + server.server_tools = "all" + server.no_ui = True + server.server_port = 8085 + server.mcp_servers_config = config_path + server.start() + + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + + tools = res.body + + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + mcp_tools = [t for t in tools if get_tool_name(t).startswith("echo_")] + assert len(mcp_tools) >= 2, f"Expected echo_ tools, got {mcp_tools}" + finally: + os.unlink(config_path) + server.stop() + + +def test_mcp_tools_slot_independent(): + """MCP tools should work without any slot concept; /tools is slot-independent.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # Call /tools without any slot binding - should succeed + res = server.make_request("POST", "/tools", data={ + "tool": "echo_echo", + "params": {"message": "hello"} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" not in body, body + finally: + server.stop() + + +def test_mcp_concurrent_tool_calls(): + """Concurrent POST /tools to same MCP server should all succeed.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + def call_tool(): + return server.make_request("POST", "/tools", data={ + "tool": "echo_echo", + "params": {"message": "hi"} + }) + + with ThreadPoolExecutor(max_workers=10) as executor: + futures = [executor.submit(call_tool) for _ in range(10)] + results = [f.result() for f in futures] + + for res in results: + assert res.status_code == 200, res.body + assert "error" not in res.body, res.body + finally: + server.stop() + + +def test_mcp_tool_timeout(): + """Tool call should timeout if MCP server is too slow.""" + global server + MCP_SLOW_SERVER = os.path.join(FIXTURES_DIR, "mcp_slow_server.py") + mcp_json = _mcp_config_json({ + "slow": { + "command": sys.executable, + "args": [MCP_SLOW_SERVER, "--delay", "5"], + "timeout_ms": 500 + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("POST", "/tools", data={ + "tool": "slow_sleep", + "params": {"seconds": 5} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" in body, body + finally: + server.stop() + + +def test_mcp_warmup_partial_failure(): + """Good server's tools should appear even if bad server fails warmup.""" + global server + mcp_json = _mcp_config_json({ + "good": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + }, + "bad": { + "command": "nonexistent", + "args": [] + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + tools = res.body + + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + # good server tools should be present + assert any("good_" in get_tool_name(t) for t in tools), f"Expected good: tools in {tools}" + finally: + server.stop() + + +def test_mcp_notification_during_request(): + """Notification during request should not be returned as response.""" + global server + MCP_MALFORMED_SERVER = os.path.join(FIXTURES_DIR, "mcp_malformed_server.py") + mcp_json = _mcp_config_json({ + "notifying": { + "command": sys.executable, + "args": [MCP_MALFORMED_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("POST", "/tools", data={ + "tool": "notifying_echo", + "params": {"message": "hi"} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" not in body, body + finally: + server.stop() + + +def test_mcp_instance_respawn_after_crash(): + """Tool call after process crash should respawn and succeed.""" + global server + MCP_CRASH_SERVER = os.path.join(FIXTURES_DIR, "mcp_crash_server.py") + mcp_json = _mcp_config_json({ + "crash": { + "command": sys.executable, + "args": [MCP_CRASH_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # First call succeeds + res1 = server.make_request("POST", "/tools", data={ + "tool": "crash_echo", + "params": {"message": "hi"} + }) + assert res1.status_code == 200, res1.body + assert "error" not in res1.body, res1.body + + # Second call should also succeed (respawned instance) + res2 = server.make_request("POST", "/tools", data={ + "tool": "crash_echo", + "params": {"message": "hi2"} + }) + assert res2.status_code == 200, res2.body + assert "error" not in res2.body, res2.body + finally: + server.stop() + + + + +def test_mcp_fail_once_eventual_success_verified(): + """Verify that fail_once tool eventually succeeds after respawn.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # First call may fail (fresh process) + res1 = server.make_request("POST", "/tools", data={ + "tool": "echo_fail_once", + "params": {} + }) + # Second call should succeed + res2 = server.make_request("POST", "/tools", data={ + "tool": "echo_fail_once", + "params": {} + }) + assert res2.status_code == 200, res2.body + assert "error" not in res2.body, res2.body + finally: + server.stop() + + +def test_mcp_config_file_errors(): + """Invalid JSON config and missing file should cause server to fail to start.""" + # Invalid JSON - server should fail to start + server = ServerPreset.router() + server.server_tools = "all" + server.no_ui = True + server.server_port = 8085 + server.mcp_servers_json = "not valid json" + try: + server.start() + assert False, "Server should not have started with invalid MCP JSON config" + except RuntimeError: + pass # Expected: server process dies due to bad config + + # Missing file - server should fail to start + server = ServerPreset.router() + server.server_tools = "all" + server.no_ui = True + server.server_port = 8085 + server.mcp_servers_config = "/nonexistent/path.json" + try: + server.start() + assert False, "Server should not have started with missing config file" + except RuntimeError: + pass # Expected: server process dies due to missing config + + +def test_mcp_empty_tool_list(): + """MCP server reporting zero tools should result in empty tool list.""" + global server + # Create a minimal server that returns empty tools list + empty_server = os.path.join(FIXTURES_DIR, "_empty_mcp_server.py") + with open(empty_server, "w") as f: + f.write('''#!/usr/bin/env python3 +import json, sys, os +def main(): + sys.stdout = os.fdopen(sys.stdout.fileno(), "w", buffering=1) + for line in sys.stdin: + line = line.strip() + if not line: continue + try: request = json.loads(line) + except: continue + method = request.get("method") + req_id = request.get("id") + if method == "initialize": + resp = {"jsonrpc": "2.0", "id": req_id, "result": {"protocolVersion": "2024-11-05", "capabilities": {"tools": {}}, "serverInfo": {"name": "empty", "version": "1.0"}}} + elif method == "tools/list": + resp = {"jsonrpc": "2.0", "id": req_id, "result": {"tools": []}} + else: + resp = {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32601, "message": "Method not found"}} + sys.stdout.write(json.dumps(resp) + "\\n") + sys.stdout.flush() +if __name__ == "__main__": + main() +''') + try: + mcp_json = _mcp_config_json({ + "empty": { + "command": sys.executable, + "args": [empty_server], + } + }) + server = _start_server_with_mcp(mcp_json) + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + tools = res.body + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + mcp_tools = [t for t in tools if get_tool_name(t).startswith("empty:")] + assert len(mcp_tools) == 0, f"Expected no empty: tools, got {mcp_tools}" + finally: + os.unlink(empty_server) + server.stop() + + +def test_mcp_rapid_succession_calls(): + """Many rapid calls should increment next_id correctly and correlate responses.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + for i in range(20): + res = server.make_request("POST", "/tools", data={ + "tool": "echo_echo", + "params": {"message": f"msg{i}"} + }) + assert res.status_code == 200, res.body + assert "error" not in res.body, res.body + finally: + server.stop() + + +def test_mcp_notification_burst(): + """Notification + response in a single write() with no flush should not strand the response.""" + global server + MCP_BURST_SERVER = os.path.join(FIXTURES_DIR, "mcp_burst_server.py") + mcp_json = _mcp_config_json({ + "burst": { + "command": sys.executable, + "args": [MCP_BURST_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + res = server.make_request("POST", "/tools", data={ + "tool": "burst_echo", + "params": {"message": "burst test"} + }) + assert res.status_code == 200, res.body + body = res.body + assert "error" not in body, body + finally: + server.stop() + + +def test_mcp_tool_definition_shape_via_chat_completions(): + """MCP tool definitions returned by GET /tools should have the correct shape for chat/completions.""" + global server + mcp_json = _mcp_config_json({ + "echo": { + "command": sys.executable, + "args": [MCP_ECHO_SERVER], + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # Get MCP tool definitions + res = server.make_request("GET", "/tools") + assert res.status_code == 200, res.body + tools = res.body + + def get_tool_name(t): + return t.get("tool", "") or t.get("definition", {}).get("function", {}).get("name", "") + + echo_tools = [t for t in tools if get_tool_name(t).startswith("echo_")] + assert len(echo_tools) >= 2, f"Expected echo_ tools, got {echo_tools}" + + echo_tool = next(t for t in echo_tools if get_tool_name(t) == "echo_echo") + definition = echo_tool.get("definition", echo_tool) + + # Verify the definition has the standard function-calling shape + assert definition.get("type") == "function", f"Expected type=function, got {definition.get('type')}" + func = definition.get("function", {}) + assert "name" in func, "Missing function.name" + assert "description" in func, "Missing function.description" + assert "parameters" in func, f"Missing function.parameters, got keys: {list(func.keys())}" + params = func["parameters"] + assert params.get("type") == "object", f"Expected parameters.type=object, got {params.get('type')}" + assert "properties" in params, "Missing parameters.properties" + finally: + server.stop() + + +def test_mcp_slow_tool_call_slot_release(): + """A slow tool call should not stall server shutdown for the full I/O timeout.""" + global server + MCP_SLOW_SERVER = os.path.join(FIXTURES_DIR, "mcp_slow_server.py") + mcp_json = _mcp_config_json({ + "slow": { + "command": sys.executable, + "args": [MCP_SLOW_SERVER, "--delay", "10"], + "timeout_ms": 30000 + } + }) + server = _start_server_with_mcp(mcp_json) + + try: + # Start a slow tool call in a background thread + def slow_call(): + return server.make_request("POST", "/tools", data={ + "tool": "slow_sleep", + "params": {"seconds": 10} + }) + + with ThreadPoolExecutor(max_workers=1) as executor: + future = executor.submit(slow_call) + + # Wait a moment for the call to start + time.sleep(2) + + # Stop the server while the tool call is in progress. + # With global MCP instances, close_all() is called explicitly at shutdown + # (not from slot release), so shutdown should complete promptly. + start_time = time.time() + server.stop() + elapsed = time.time() - start_time + + # The server should stop quickly, not wait for the full 30s I/O timeout. + # With the terminating flag, send_rpc() bails out within one select() + # slice (~50ms). This threshold MUST stay below the 5s force-kill + # fallback in ServerProcess.stop(): without the flag, shutdown stalls + # on the instance mutex and only completes when stop() sends SIGKILL + # at ~5s -- which any threshold above 5 would still accept. + assert elapsed < 3, f"Server stop took {elapsed:.1f}s, expected < 3s" + + # Wait for the future to complete (it will get an error response or timeout) + try: + res = future.result(timeout=5) + # If we got a response, it should be an error since the server stopped + if hasattr(res, 'status_code'): + assert res.status_code in (200, 500, 502, 503, 504), f"Unexpected status: {res.status_code}" + except Exception: + # Thread may have raised due to connection error - that's acceptable + pass + finally: + server.stop() + + +def test_mcp_grandchild_holding_pipes_does_not_deadlock(): + """An MCP server that leaves a grandchild inheriting its stdout/stderr must not deadlock + teardown. + + subprocess_terminate() only SIGKILLs the direct MCP child, so the inherited pipe write ends + stay open and a blocking read on them would never see EOF. That hung both warmup shutdown + (the server would never reach "ready") and process shutdown. The polled, running-aware reader + must exit regardless, so the server both starts and stops promptly here. + """ + global server + MCP_GRANDCHILD_SERVER = os.path.join(FIXTURES_DIR, "mcp_grandchild_server.py") + mcp_json = _mcp_config_json({ + "gc": { + "command": sys.executable, + "args": [MCP_GRANDCHILD_SERVER], + } + }) + + # If warmup teardown deadlocked, the server would never become ready and start() would time out. + server = _start_server_with_mcp(mcp_json) + + try: + # invoking the tool spawns a live transport whose reader thread holds the inherited pipe + res = server.make_request("POST", "/tools", data={ + "tool": "gc_echo", + "params": {"message": "hello"} + }) + assert res.status_code == 200, res.body + assert "error" not in res.body, res.body + + # shutdown must be prompt: a deadlocked reader-join would stall until the 5s SIGKILL + # fallback in ServerProcess.stop(), so the threshold has to stay below that + start = time.time() + server.stop() + elapsed = time.time() - start + assert elapsed < 3, f"server shutdown took {elapsed:.1f}s (expected < 3s) — teardown likely deadlocked" + finally: + server.stop() diff --git a/tools/server/tests/unit/test_proxy.py b/tools/server/tests/unit/test_proxy.py new file mode 100644 index 0000000000000000000000000000000000000000..cb439b7a45603f026b4f67dbc0e87924a4bd526b --- /dev/null +++ b/tools/server/tests/unit/test_proxy.py @@ -0,0 +1,71 @@ +import pytest +from utils import * +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +server = ServerPreset.tinyllama2() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +def test_mcp_no_proxy(): + global server + server.ui_mcp_proxy = False + server.start() + + res = server.make_request("GET", "/cors-proxy") + assert res.status_code == 403 + + +def test_mcp_proxy(): + global server + server.ui_mcp_proxy = True + server.start() + + url = f"http://{server.server_host}:{server.server_port}/cors-proxy?url=http://example.com" + res = requests.get(url) + assert res.status_code == 200 + assert "Example Domain" in res.text + + +def test_mcp_proxy_custom_port(): + global server + server.ui_mcp_proxy = True + server.start() + + # try getting the server's models API via the proxy + res = server.make_request("GET", f"/cors-proxy?url=http://{server.server_host}:{server.server_port}/models") + assert res.status_code == 200 + assert "data" in res.body + + +def test_mcp_proxy_no_content(): + # note: see issue #26598 + class NoContentHandler(BaseHTTPRequestHandler): + def do_POST(self): + self.send_response(204) + self.end_headers() + + def log_message(self, format, *args): + pass + + target = ThreadingHTTPServer(("127.0.0.1", 0), NoContentHandler) + target_thread = threading.Thread(target=target.serve_forever, daemon=True) + target_thread.start() + + try: + global server + server.ui_mcp_proxy = True + server.start() + + res = server.make_request("POST", f"/cors-proxy?url=http://127.0.0.1:{target.server_port}/", data={}) + assert res.status_code == 204 + assert res.body in (None, b"", "") + finally: + target.shutdown() + target.server_close() + diff --git a/tools/server/tests/unit/test_rerank.py b/tools/server/tests/unit/test_rerank.py new file mode 100644 index 0000000000000000000000000000000000000000..ded8267109682492b5bcc820e9f5653116725fbd --- /dev/null +++ b/tools/server/tests/unit/test_rerank.py @@ -0,0 +1,146 @@ +import pytest +from utils import * + +server = ServerPreset.jina_reranker_tiny() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.jina_reranker_tiny() + + +TEST_DOCUMENTS = [ + "A machine is a physical system that uses power to apply forces and control movement to perform an action. The term is commonly applied to artificial devices, such as those employing engines or motors, but also to natural biological macromolecules, such as molecular machines.", + "Learning is the process of acquiring new understanding, knowledge, behaviors, skills, values, attitudes, and preferences. The ability to learn is possessed by humans, non-human animals, and some machines; there is also evidence for some kind of learning in certain plants.", + "Machine learning is a field of study in artificial intelligence concerned with the development and study of statistical algorithms that can learn from data and generalize to unseen data, and thus perform tasks without explicit instructions.", + "Paris, capitale de la France, est une grande ville européenne et un centre mondial de l'art, de la mode, de la gastronomie et de la culture. Son paysage urbain du XIXe siècle est traversé par de larges boulevards et la Seine." +] + + +def test_rerank(): + global server + server.start() + res = server.make_request("POST", "/rerank", data={ + "query": "Machine learning is", + "documents": TEST_DOCUMENTS, + }) + assert res.status_code == 200 + assert len(res.body["results"]) == 4 + + most_relevant = res.body["results"][0] + least_relevant = res.body["results"][0] + for doc in res.body["results"]: + if doc["relevance_score"] > most_relevant["relevance_score"]: + most_relevant = doc + if doc["relevance_score"] < least_relevant["relevance_score"]: + least_relevant = doc + + assert most_relevant["relevance_score"] > least_relevant["relevance_score"] + assert most_relevant["index"] == 2 + assert least_relevant["index"] == 3 + + +def test_rerank_tei_format(): + global server + server.start() + res = server.make_request("POST", "/rerank", data={ + "query": "Machine learning is", + "texts": TEST_DOCUMENTS, + }) + assert res.status_code == 200 + assert len(res.body) == 4 + + most_relevant = res.body[0] + least_relevant = res.body[0] + for doc in res.body: + if doc["score"] > most_relevant["score"]: + most_relevant = doc + if doc["score"] < least_relevant["score"]: + least_relevant = doc + + assert most_relevant["score"] > least_relevant["score"] + assert most_relevant["index"] == 2 + assert least_relevant["index"] == 3 + + +@pytest.mark.parametrize("documents", [ + [], + None, + 123, + [1, 2, 3], +]) +def test_invalid_rerank_req(documents): + global server + server.start() + res = server.make_request("POST", "/rerank", data={ + "query": "Machine learning is", + "documents": documents, + }) + assert res.status_code == 400 + assert "error" in res.body + + +@pytest.mark.parametrize( + "query,doc1,doc2,n_tokens", + [ + ("Machine learning is", "A machine", "Learning is", 19), + ("Which city?", "Machine learning is ", "Paris, capitale de la", 26), + ] +) +def test_rerank_usage(query, doc1, doc2, n_tokens): + global server + server.start() + + res = server.make_request("POST", "/rerank", data={ + "query": query, + "documents": [ + doc1, + doc2, + ] + }) + assert res.status_code == 200 + assert res.body['usage']['prompt_tokens'] == res.body['usage']['total_tokens'] + assert res.body['usage']['prompt_tokens'] == n_tokens + + +@pytest.mark.parametrize("top_n,expected_len", [ + (None, len(TEST_DOCUMENTS)), # no top_n parameter + (2, 2), + (4, 4), + (99, len(TEST_DOCUMENTS)), # higher than available docs +]) +def test_rerank_top_n(top_n, expected_len): + global server + server.start() + data = { + "query": "Machine learning is", + "documents": TEST_DOCUMENTS, + } + if top_n is not None: + data["top_n"] = top_n + + res = server.make_request("POST", "/rerank", data=data) + assert res.status_code == 200 + assert len(res.body["results"]) == expected_len + + +@pytest.mark.parametrize("top_n,expected_len", [ + (None, len(TEST_DOCUMENTS)), # no top_n parameter + (2, 2), + (4, 4), + (99, len(TEST_DOCUMENTS)), # higher than available docs +]) +def test_rerank_tei_top_n(top_n, expected_len): + global server + server.start() + data = { + "query": "Machine learning is", + "texts": TEST_DOCUMENTS, + } + if top_n is not None: + data["top_n"] = top_n + + res = server.make_request("POST", "/rerank", data=data) + assert res.status_code == 200 + assert len(res.body) == expected_len diff --git a/tools/server/tests/unit/test_router.py b/tools/server/tests/unit/test_router.py new file mode 100644 index 0000000000000000000000000000000000000000..5ab62666ce18fd5f470f24c25f0509c234ff7ef4 --- /dev/null +++ b/tools/server/tests/unit/test_router.py @@ -0,0 +1,541 @@ +import threading +import pytest +from utils import * + +server: ServerProcess + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.router() + + +def test_router_props(): + global server + server.models_max = 2 + server.no_models_autoload = True + server.start() + res = server.make_request("GET", "/props") + assert res.status_code == 200 + assert res.body["role"] == "router" + assert res.body["max_instances"] == 2 + assert res.body["models_autoload"] is False + assert res.body["build_info"].startswith("b") + + +@pytest.mark.parametrize( + "model,success", + [ + ("ggml-org/tinygemma3-GGUF:Q8_0", True), + ("non-existent/model", False), + ] +) +def test_router_chat_completion_stream(model: str, success: bool): + global server + server.start() + content = "" + ex: ServerError | None = None + try: + res = server.make_stream_request("POST", "/chat/completions", data={ + "model": model, + "max_tokens": 16, + "messages": [ + {"role": "user", "content": "hello"}, + ], + "stream": True, + }) + for data in res: + if data["choices"]: + choice = data["choices"][0] + if choice["finish_reason"] in ["stop", "length"]: + assert "content" not in choice["delta"] + else: + assert choice["finish_reason"] is None + content += choice["delta"]["content"] or '' + except ServerError as e: + ex = e + + if success: + assert ex is None + assert len(content) > 0 + else: + assert ex is not None + assert content == "" + + +def _get_model_ids(is_reload: bool) -> set[str]: + res = server.make_request("GET", "/models" + ("?reload=1" if is_reload else "")) + assert res.status_code == 200 + return {item["id"] for item in res.body.get("data", [])} + + +def _get_model_status(model_id: str) -> str: + res = server.make_request("GET", "/models") + assert res.status_code == 200 + for item in res.body.get("data", []): + if item.get("id") == model_id or item.get("model") == model_id: + return item["status"]["value"] + raise AssertionError(f"Model {model_id} not found in /models response") + + +def _wait_for_model_status(model_id: str, desired: set[str], timeout: int = 60) -> str: + deadline = time.time() + timeout + last_status = None + while time.time() < deadline: + last_status = _get_model_status(model_id) + if last_status in desired: + return last_status + time.sleep(0.01) + raise AssertionError( + f"Timed out waiting for {model_id} to reach {desired}, last status: {last_status}" + ) + + +def _load_model_and_wait( + model_id: str, timeout: int = 60, headers: dict | None = None +) -> None: + load_res = server.make_request( + "POST", "/models/load", data={"model": model_id}, headers=headers + ) + assert load_res.status_code == 200 + assert isinstance(load_res.body, dict) + assert load_res.body.get("success") is True + _wait_for_model_status(model_id, {"loaded"}, timeout=timeout) + + +def test_router_unload_model(): + global server + server.start() + model_id = "ggml-org/tinygemma3-GGUF:Q8_0" + + _load_model_and_wait(model_id) + + unload_res = server.make_request("POST", "/models/unload", data={"model": model_id}) + assert unload_res.status_code == 200 + assert unload_res.body.get("success") is True + _wait_for_model_status(model_id, {"unloaded"}) + + +def test_router_models_max_evicts_lru(): + global server + server.models_max = 2 + server.start() + + candidate_models = [ + "ggml-org/tinygemma3-GGUF:Q8_0", + "ggml-org/test-model-stories260K:F32", + "ggml-org/test-model-stories260K-infill:F32", + ] + + # Load only the first 2 models to fill the cache + first, second, third = candidate_models[:3] + + _load_model_and_wait(first, timeout=120) + _load_model_and_wait(second, timeout=120) + + # Verify both models are loaded + assert _get_model_status(first) == "loaded" + assert _get_model_status(second) == "loaded" + + # Load the third model - this should trigger LRU eviction of the first model + _load_model_and_wait(third, timeout=120) + + # Verify eviction: third is loaded, first was evicted + assert _get_model_status(third) == "loaded" + assert _get_model_status(first) == "unloaded" + + +# server_lru_sched tests (relying on LLAMA_SERVER_DEBUG_FAKE_TIMING) + +MODEL_A = "ggml-org/tinygemma3-GGUF:Q8_0" +MODEL_B = "ggml-org/test-model-stories260K:F32" +MODEL_C = "ggml-org/test-model-stories260K-infill:F32" + + +def _tokenize(model_id: str, timeout: float | None = DEFAULT_REQUEST_TIMEOUT) -> ServerResponse: + return server.make_request( + "POST", "/tokenize", data={"model": model_id, "content": "hello world"}, timeout=timeout + ) + + +class _Bg: + """runs one request in a thread, keeps its result, error and finish time""" + + def __init__(self, fn): + self.result = None + self.error: Exception | None = None + self.done_at: float = 0.0 + self._thread = threading.Thread(target=self._run, args=(fn,), daemon=True) + + def _run(self, fn): + try: + self.result = fn() + except Exception as e: + self.error = e + self.done_at = time.time() + + def start(self): + self._thread.start() + return self + + def join(self, timeout: int = 180): + self._thread.join(timeout) + assert not self._thread.is_alive(), "background request did not finish in time" + return self + + def assert_ok(self, what: str): + assert self.error is None, f"{what} raised {self.error!r}" + assert self.result is not None and self.result.status_code == 200, \ + f"{what} failed: {self.result.status_code if self.result else None} {self.result.body if self.result else None}" + + +def test_router_queue_does_not_evict_busy_model(): + """a request that finds no free slot waits, and the model serving a request survives it""" + global server + server.models_max = 1 + server.start() + + _load_model_and_wait(MODEL_A, timeout=120) + + busy = _Bg(lambda: _tokenize(MODEL_A)).start() + time.sleep(0.5) # let the request reach the child and take the only slot + + # no slot free and MODEL_A is busy, so this queues instead of evicting mid-request + queued = _Bg(lambda: _tokenize(MODEL_B)).start() + + busy.join() + queued.join() + + # had MODEL_A been evicted while serving, its own request would have died + busy.assert_ok("request against the busy model") + queued.assert_ok("queued request") + + _wait_for_model_status(MODEL_B, {"loaded"}, timeout=120) + assert _get_model_status(MODEL_A) == "unloaded" + + +def test_router_queue_coalesces_requests_for_same_model(): + """many requests for one missing model share a slot, so only one model is given up""" + global server + server.models_max = 2 + server.start() + + _load_model_and_wait(MODEL_A, timeout=120) + _load_model_and_wait(MODEL_B, timeout=120) + + # keep MODEL_A busy so MODEL_B is the only model that can be given up + busy = _Bg(lambda: _tokenize(MODEL_A)).start() + time.sleep(0.5) + + waiters = [_Bg(lambda: _tokenize(MODEL_C)).start() for _ in range(3)] + + busy.join() + for w in waiters: + w.join() + + busy.assert_ok("request against the busy model") + for i, w in enumerate(waiters): + w.assert_ok(f"queued request {i}") + + _wait_for_model_status(MODEL_C, {"loaded"}, timeout=120) + # one entry for 3 requests means one eviction: MODEL_B goes, MODEL_A is left alone. + # without coalescing the leftover entries still ask for a slot, + # and MODEL_A is taken too as soon as it goes idle + assert _get_model_status(MODEL_A) == "loaded" + assert _get_model_status(MODEL_B) == "unloaded" + + +def test_router_queue_client_disconnect_keeps_model(): + """a client that leaves while queued must not cost a running model its slot""" + global server + server.models_max = 1 + server.start() + + _load_model_and_wait(MODEL_A, timeout=120) + + busy = _Bg(lambda: _tokenize(MODEL_A)).start() + time.sleep(0.5) + + # queues behind MODEL_A, then gives up long before MODEL_A goes idle + with pytest.raises(requests.exceptions.RequestException): + _tokenize(MODEL_B, timeout=1) + + busy.join() + busy.assert_ok("request against the busy model") + + # nobody is waiting anymore, so MODEL_A keeps its slot + time.sleep(3) + assert _get_model_status(MODEL_A) == "loaded" + assert _get_model_status(MODEL_B) == "unloaded" + + +def test_router_queue_is_fifo(): + """the queue is served in arrival order""" + global server + server.models_max = 1 + server.start() + + _load_model_and_wait(MODEL_A, timeout=120) + + busy = _Bg(lambda: _tokenize(MODEL_A)).start() + time.sleep(0.5) + + first = _Bg(lambda: _tokenize(MODEL_B)).start() + time.sleep(1) # keep the arrival order unambiguous + second = _Bg(lambda: _tokenize(MODEL_C)).start() + + busy.join() + first.join() + second.join() + + busy.assert_ok("request against the busy model") + first.assert_ok("first queued request") + second.assert_ok("second queued request") + + assert first.done_at < second.done_at, "queue was not served in arrival order" + + +def test_router_no_models_autoload(): + global server + server.no_models_autoload = True + server.start() + model_id = "ggml-org/tinygemma3-GGUF:Q8_0" + + res = server.make_request( + "POST", + "/v1/chat/completions", + data={ + "model": model_id, + "messages": [{"role": "user", "content": "hello"}], + "max_tokens": 4, + }, + ) + assert res.status_code == 400 + assert "error" in res.body + + _load_model_and_wait(model_id) + + success_res = server.make_request( + "POST", + "/v1/chat/completions", + data={ + "model": model_id, + "messages": [{"role": "user", "content": "hello"}], + "max_tokens": 4, + }, + ) + assert success_res.status_code == 200 + assert "error" not in success_res.body + + +def test_router_api_key_required(): + global server + server.api_key = "sk-router-secret" + server.start() + + model_id = "ggml-org/tinygemma3-GGUF:Q8_0" + auth_headers = {"Authorization": f"Bearer {server.api_key}"} + + res = server.make_request( + "POST", + "/v1/chat/completions", + data={ + "model": model_id, + "messages": [{"role": "user", "content": "hello"}], + "max_tokens": 4, + }, + ) + assert res.status_code == 401 + assert res.body.get("error", {}).get("type") == "authentication_error" + + _load_model_and_wait(model_id, headers=auth_headers) + + authed = server.make_request( + "POST", + "/v1/chat/completions", + headers=auth_headers, + data={ + "model": model_id, + "messages": [{"role": "user", "content": "hello"}], + "max_tokens": 4, + }, + ) + assert authed.status_code == 200 + assert "error" not in authed.body + + +def test_router_reload_models(): + """POST /models/reload re-reads the INI preset and updates the model list.""" + global server + + preset_path = os.path.join(TMP_DIR, "test_reload.ini") + + # Initial preset: two models + with open(preset_path, "w") as f: + f.write( + "[model-reload-a]\n" + "hf-repo = ggml-org/test-model-stories260K\n" + "\n" + "[model-reload-b]\n" + "hf-repo = ggml-org/test-model-stories260K-infill\n" + ) + + server.models_preset = preset_path + server.start() + + ids = _get_model_ids(is_reload=False) + assert "model-reload-a" in ids + assert "model-reload-b" in ids + + # Updated preset: remove a, keep b unchanged, add c + with open(preset_path, "w") as f: + f.write( + "[model-reload-b]\n" + "hf-repo = ggml-org/test-model-stories260K-infill\n" + "\n" + "[model-reload-c]\n" + "hf-repo = ggml-org/test-model-stories260K\n" + ) + + try: + ids = _get_model_ids(is_reload=True) + assert "model-reload-a" not in ids, "removed model should no longer appear" + assert "model-reload-b" in ids, "unchanged model should still appear" + assert "model-reload-c" in ids, "newly added model should appear" + finally: + os.remove(preset_path) + + +def test_router_remote_preset(): + global server + server.model_hf_repo = "ggml-org/test-preset-ci" + server.model_hf_file = None + server.offline = False + server.start() + + # Should see preset models in GET /models + res = server.make_request("GET", "/models") + assert res.status_code == 200 + ids = {item["id"] for item in res.body.get("data", [])} + assert "tinygemma3-preset" in ids + assert "stories260K-test" in ids + + # Should be able to load a preset model + model_id = "tinygemma3-preset" + _load_model_and_wait(model_id) + + +MODEL_DOWNLOAD_ID = "ggml-org/test-model-router-download:F16" +MODEL_DOWNLOAD_TIMEOUT = 30 + + +def _listen_sse( + server: ServerProcess, collected: list, stop: threading.Event, ready: threading.Event | None = None +): + """Collect /models/sse events into `collected` until `stop` is set. + + When `ready` is provided, it is set once the streaming response is open, + i.e. the server has accepted the connection and registered us as a + subscriber. Callers that trigger one-shot events (e.g. download_finished) + must wait on `ready` before acting, otherwise the event can be broadcast + before this client is subscribed and be lost. + """ + url = f"http://{server.server_host}:{server.server_port}/models/sse" + try: + with requests.get(url, stream=True, timeout=MODEL_DOWNLOAD_TIMEOUT) as resp: + if ready is not None: + ready.set() + for line_bytes in resp.iter_lines(): + if stop.is_set(): + break + line = line_bytes.decode("utf-8") + if line.startswith("data: "): + collected.append(json.loads(line[6:])) + except Exception: + pass + + +def _wait_for_sse_event(collected: list, event_type: str, model: str, timeout: int) -> bool: + deadline = time.time() + timeout + while time.time() < deadline: + if any(e.get("event") == event_type and e.get("model") == model for e in collected): + return True + time.sleep(0.01) + return False + + +def test_router_download_model(): + """Case 1: download a model, verify SSE events and GET /models.""" + global server + server.start() + + # Ensure the model is not present before we start + server.make_request("DELETE", f"/models?model={MODEL_DOWNLOAD_ID}") + + sse_events: list = [] + stop = threading.Event() + sse_ready = threading.Event() + sse_thread = threading.Thread( + target=_listen_sse, args=(server, sse_events, stop, sse_ready), daemon=True + ) + sse_thread.start() + + # wait for the SSE client to be subscribed before triggering the download, + # otherwise the one-shot download_finished event can be broadcast before + # this client is registered and be lost + assert sse_ready.wait(10), "SSE client failed to connect" + + # Trigger the download + res = server.make_request("POST", "/models", data={"model": MODEL_DOWNLOAD_ID}) + assert res.status_code == 200 + assert res.body.get("success") is True + + # Wait for download_finished SSE event + finished = _wait_for_sse_event( + sse_events, "download_finished", MODEL_DOWNLOAD_ID, MODEL_DOWNLOAD_TIMEOUT + ) + stop.set() + + assert finished, "Never received download_finished SSE event" + assert any( + e.get("event") == "download_progress" and e.get("model") == MODEL_DOWNLOAD_ID + for e in sse_events + ), "No download_progress events received" + + # Model should now appear in GET /models + ids = _get_model_ids(is_reload=False) + assert MODEL_DOWNLOAD_ID in ids, f"{MODEL_DOWNLOAD_ID} not found in /models after download" + + +def test_router_delete_model(): + """Case 2: delete the downloaded model, verify it disappears from GET /models.""" + global server + server.start() + + # Ensure the model exists (download it if needed) + if MODEL_DOWNLOAD_ID not in _get_model_ids(is_reload=False): + sse_events: list = [] + stop = threading.Event() + sse_ready = threading.Event() + threading.Thread( + target=_listen_sse, args=(server, sse_events, stop, sse_ready), daemon=True + ).start() + # subscribe before triggering the download so the one-shot + # download_finished event is not lost (see test_router_download_model) + assert sse_ready.wait(10), "SSE client failed to connect" + res = server.make_request("POST", "/models", data={"model": MODEL_DOWNLOAD_ID}) + assert res.status_code == 200 + finished = _wait_for_sse_event( + sse_events, "download_finished", MODEL_DOWNLOAD_ID, MODEL_DOWNLOAD_TIMEOUT + ) + stop.set() + assert finished, "Model did not finish downloading before delete test" + + # Delete the model + del_res = server.make_request("DELETE", f"/models?model={MODEL_DOWNLOAD_ID}") + assert del_res.status_code == 200 + assert del_res.body.get("success") is True + + # Model should no longer appear in GET /models + ids = _get_model_ids(is_reload=False) + assert MODEL_DOWNLOAD_ID not in ids, f"{MODEL_DOWNLOAD_ID} still present after deletion" diff --git a/tools/server/tests/unit/test_security.py b/tools/server/tests/unit/test_security.py new file mode 100644 index 0000000000000000000000000000000000000000..ac0544575bd267a35b5551107529a9c1d9eb265c --- /dev/null +++ b/tools/server/tests/unit/test_security.py @@ -0,0 +1,245 @@ +import pytest +from openai import OpenAI +from utils import * +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +server = ServerPreset.tinyllama2() + +TEST_API_KEY = "sk-this-is-the-secret-key" + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.api_key = TEST_API_KEY + + +@pytest.mark.parametrize("endpoint", ["/health", "/models"]) +def test_access_public_endpoint(endpoint: str): + global server + server.start() + res = server.make_request("GET", endpoint) + assert res.status_code == 200 + assert "error" not in res.body + + +def test_access_static_assets_without_api_key(): + """Static web UI assets should not require API key authentication (issue #21229)""" + global server + server.start() + for path in ["/", "/sw.js", "/manifest.webmanifest", "/_app/version.json"]: + res = server.make_request("GET", path) + assert res.status_code == 200, f"Expected 200 for {path}, got {res.status_code}" + + +@pytest.mark.parametrize("api_key", [None, "invalid-key"]) +def test_incorrect_api_key(api_key: str): + global server + server.start() + res = server.make_request("POST", "/completions", data={ + "prompt": "I believe the meaning of life is", + }, headers={ + "Authorization": f"Bearer {api_key}" if api_key else None, + }) + assert res.status_code == 401 + assert "error" in res.body + assert res.body["error"]["type"] == "authentication_error" + + +def test_correct_api_key(): + global server + server.start() + res = server.make_request("POST", "/completions", data={ + "prompt": "I believe the meaning of life is", + }, headers={ + "Authorization": f"Bearer {TEST_API_KEY}", + }) + assert res.status_code == 200 + assert "error" not in res.body + assert "content" in res.body + + +def test_correct_api_key_anthropic_header(): + global server + server.start() + res = server.make_request("POST", "/completions", data={ + "prompt": "I believe the meaning of life is", + }, headers={ + "X-Api-Key": TEST_API_KEY, + }) + assert res.status_code == 200 + assert "error" not in res.body + assert "content" in res.body + + +def test_openai_library_correct_api_key(): + global server + server.start() + client = OpenAI(api_key=TEST_API_KEY, base_url=f"http://{server.server_host}:{server.server_port}") + res = client.chat.completions.create( + model="gpt-3.5-turbo", + messages=[ + {"role": "system", "content": "You are a chatbot."}, + {"role": "user", "content": "What is the meaning of life?"}, + ], + ) + assert len(res.choices) == 1 + + +@pytest.mark.parametrize("origin,cors_header,cors_header_value", [ + ("localhost", "Access-Control-Allow-Origin", "localhost"), + ("web.mydomain.fr", "Access-Control-Allow-Origin", "web.mydomain.fr"), + ("origin", "Access-Control-Allow-Credentials", "true"), + ("web.mydomain.fr", "Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS"), + ("web.mydomain.fr", "Access-Control-Allow-Headers", "*"), +]) +def test_cors_options(origin: str, cors_header: str, cors_header_value: str): + global server + server.start() + res = server.make_request("OPTIONS", "/completions", headers={ + "Origin": origin, + "Access-Control-Request-Method": "POST", + "Access-Control-Request-Headers": "Authorization", + }) + assert res.status_code == 200 + assert cors_header in res.headers + assert res.headers[cors_header] == cors_header_value + + +@pytest.mark.parametrize("origin", [ + "http://localhost", + "http://localhost:8080", + "http://127.0.0.1", + "http://127.0.0.1:3000", + "http://[::1]", + "http://[::1]:3000", +]) +def test_cors_origins_localhost_reflects(origin: str): + global server + server = ServerPreset.router() + server.cors_origins = "localhost" + server.start() + res = server.make_request("OPTIONS", "/completions", headers={ + "Origin": origin, + "Access-Control-Request-Method": "POST", + "Access-Control-Request-Headers": "Authorization", + }) + assert res.status_code == 200 + assert res.headers["Access-Control-Allow-Origin"] == origin + + +@pytest.mark.parametrize("origin", [ + "http://web.mydomain.fr", + "http://evil.com", + "http://notlocalhost", + "http://localhost.evil.com", +]) +def test_cors_origins_localhost_rejects(origin: str): + global server + server = ServerPreset.router() + server.cors_origins = "localhost" + server.start() + res = server.make_request("OPTIONS", "/completions", headers={ + "Origin": origin, + "Access-Control-Request-Method": "POST", + "Access-Control-Request-Headers": "Authorization", + }) + assert res.status_code == 200 + assert "Access-Control-Allow-Origin" not in res.headers + + +def test_cors_origins_defaults_to_localhost_with_tools_enabled(): + global server + server = ServerPreset.router() + server.server_tools = "all" + server.start() + res = server.make_request("OPTIONS", "/completions", headers={ + "Origin": "http://localhost:8080", + "Access-Control-Request-Method": "POST", + "Access-Control-Request-Headers": "Authorization", + }) + assert res.status_code == 200 + assert res.headers["Access-Control-Allow-Origin"] == "http://localhost:8080" + + res = server.make_request("OPTIONS", "/completions", headers={ + "Origin": "http://evil.com", + "Access-Control-Request-Method": "POST", + "Access-Control-Request-Headers": "Authorization", + }) + assert res.status_code == 200 + assert "Access-Control-Allow-Origin" not in res.headers + + +def test_cors_proxy_only_forwards_explicit_proxy_headers(): + class CaptureHeadersHandler(BaseHTTPRequestHandler): + def do_GET(self): + self.server.captured_headers = dict(self.headers) + self.send_response(200) + self.end_headers() + self.wfile.write(b"ok") + + def log_message(self, format, *args): + pass + + target = ThreadingHTTPServer(("127.0.0.1", 0), CaptureHeadersHandler) + target.captured_headers = {} + target_thread = threading.Thread(target=target.serve_forever, daemon=True) + target_thread.start() + + try: + server = ServerPreset.tinyllama2() + server.api_key = TEST_API_KEY + server.ui_mcp_proxy = True + server.start() + + res = server.make_request("GET", f"/cors-proxy?url=http://127.0.0.1:{target.server_port}/capture", headers={ + "Authorization": f"Bearer {TEST_API_KEY}", + "Proxy-Authorization": "Basic secret", + "X-Api-Key": TEST_API_KEY, + "Cookie": "session=secret", + "x-llama-server-proxy-header-accept": "application/json", + "x-llama-server-proxy-header-authorization": "Bearer explicit", + }) + + assert res.status_code == 200 + captured = {key.lower(): value for key, value in target.captured_headers.items()} + assert captured["accept"] == "application/json" + assert captured["authorization"] == "Bearer explicit" + assert "proxy-authorization" not in captured + assert "x-api-key" not in captured + assert "cookie" not in captured + finally: + target.shutdown() + target.server_close() + + +@pytest.mark.parametrize( + "media_path, image_url, success", + [ + (None, "file://mtmd/test-1.jpeg", False), # disabled media path, should fail + ("../../../tools", "file://mtmd/test-1.jpeg", True), + ("../../../tools", "file:////mtmd//test-1.jpeg", True), # should be the same file as above + ("../../../tools", "file://mtmd/notfound.jpeg", False), # non-existent file + ("../../../tools", "file://../mtmd/test-1.jpeg", False), # no directory traversal + ] +) +def test_local_media_file(media_path, image_url, success,): + server = ServerPreset.tinygemma3() + server.media_path = media_path + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "max_tokens": 1, + "messages": [ + {"role": "user", "content": [ + {"type": "text", "text": "test"}, + {"type": "image_url", "image_url": { + "url": image_url, + }}, + ]}, + ], + }) + if success: + assert res.status_code == 200 + else: + assert res.status_code == 400 diff --git a/tools/server/tests/unit/test_sleep.py b/tools/server/tests/unit/test_sleep.py new file mode 100644 index 0000000000000000000000000000000000000000..3374165e83e0ebacf8e082239a29aeb47ff7a468 --- /dev/null +++ b/tools/server/tests/unit/test_sleep.py @@ -0,0 +1,39 @@ +import pytest +import time +from utils import * + +server = ServerPreset.tinyllama2() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +def test_server_sleep(): + global server + server.sleep_idle_seconds = 1 + server.start() + + # wait a bit so that server can go to sleep + time.sleep(2) + + # make sure these endpoints are still responsive after sleep + res = server.make_request("GET", "/health") + assert res.status_code == 200 + res = server.make_request("GET", "/props") + assert res.status_code == 200 + assert res.body["is_sleeping"] == True + + # make a generation request to wake up the server + res = server.make_request("POST", "/completion", data={ + "n_predict": 1, + "prompt": "Hello", + }) + assert res.status_code == 200 + + # it should no longer be sleeping + res = server.make_request("GET", "/props") + assert res.status_code == 200 + assert res.body["is_sleeping"] == False diff --git a/tools/server/tests/unit/test_slot_save.py b/tools/server/tests/unit/test_slot_save.py new file mode 100644 index 0000000000000000000000000000000000000000..be22d9859efdae762745a6f7717e56beca82abf4 --- /dev/null +++ b/tools/server/tests/unit/test_slot_save.py @@ -0,0 +1,224 @@ +import pytest +from utils import * +import base64 +import requests + +server = ServerPreset.tinyllama2() + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.slot_save_path = "./tmp" + server.temperature = 0.0 + + +def test_slot_save_restore(): + global server + server.start() + + # First prompt in slot 1 should be fully processed + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of France?", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Whiskers|Flana)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 21 # all tokens are processed + + # Save state of slot 1 + res = server.make_request("POST", "/slots/1?action=save", data={ + "filename": "slot1.bin", + }) + assert res.status_code == 200 + assert res.body["n_saved"] == 84 + + # Since we have cache, this should only process the last tokens + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of Germany?", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Jack|said)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 6 # only different part is processed + + # Loading the saved cache into slot 0 + res = server.make_request("POST", "/slots/0?action=restore", data={ + "filename": "slot1.bin", + }) + assert res.status_code == 200 + assert res.body["n_restored"] == 84 + + # Since we have cache, slot 0 should only process the last tokens + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of Germany?", + "id_slot": 0, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Jack|said)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 6 # only different part is processed + + # For verification that slot 1 was not corrupted during slot 0 load, same thing should work + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of Germany?", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Jack|said)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 1 + + +def test_slot_erase(): + global server + server.start() + + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of France?", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Whiskers|Flana)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 21 # all tokens are processed + + # erase slot 1 + res = server.make_request("POST", "/slots/1?action=erase") + assert res.status_code == 200 + + # re-run the same prompt, it should process all tokens again + res = server.make_request("POST", "/completion", data={ + "prompt": "What is the capital of France?", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert match_regex("(Whiskers|Flana)+", res.body["content"]) + assert res.body["timings"]["prompt_n"] == 21 # all tokens are processed + + +# +# Multimodal server (mmproj loaded) slot save/restore. +# +# Regression coverage for issue #21133: slot save/restore/erase must be gated on +# the slot's CONTENT (does it actually hold image/audio tokens) rather than the +# model's CAPABILITY (is an mmproj loaded). A pure-text slot on a multimodal +# server must save/restore/erase normally; a slot that actually holds an image +# must be rejected with ERROR_TYPE_NOT_SUPPORTED (HTTP 501). +# + +IMG_URL_CAT = "https://huggingface.co/ggml-org/tinygemma3-GGUF/resolve/main/test/91_cat.png" + + +def _get_img_base64(url: str) -> str: + response = requests.get(url) + response.raise_for_status() # Raise an exception for bad status codes + return base64.b64encode(response.content).decode("utf-8") + + +@pytest.fixture +def mmproj_server(): + # tinygemma3 is a small multimodal model: the mmproj is provided by the HF + # registry API and auto-downloaded on first run. + os.environ['LLAMA_MEDIA_MARKER'] = '<__media__>' + mm_server = ServerPreset.tinygemma3() + mm_server.slot_save_path = "./tmp" + mm_server.temperature = 0.0 + return mm_server + + +def test_slot_save_restore_text_only_on_multimodal(mmproj_server): + server = mmproj_server + server.start() + + # A pure-text prompt processed on slot 1 of a multimodal server. + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox jumps over the lazy dog.", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + prompt_n = res.body["timings"]["prompt_n"] + assert prompt_n > 0 # all tokens are processed + + # Saving a pure-text slot must succeed even though an mmproj is loaded. + res = server.make_request("POST", "/slots/1?action=save", data={ + "filename": "mm_slot1.bin", + }) + assert res.status_code == 200 + n_saved = res.body["n_saved"] + assert n_saved > 0 # the slot KV (prompt + generated tokens) was written + + # Restore the saved state into slot 0; it must round-trip exactly. + res = server.make_request("POST", "/slots/0?action=restore", data={ + "filename": "mm_slot1.bin", + }) + assert res.status_code == 200 + assert res.body["n_restored"] == n_saved + + # The restored slot is usable for a follow-up completion. We do NOT assert + # prefix reuse here: tinygemma3 is a SWA model, which forces full prompt + # re-processing after a restore (a model property, not the save/restore gate + # under test). + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox jumps over the lazy dog.", + "id_slot": 0, + "cache_prompt": True, + }) + assert res.status_code == 200 + + +def test_slot_save_rejected_when_slot_holds_image(mmproj_server): + server = mmproj_server + server.start() + + # Process a prompt that actually contains an image on slot 1. + res = server.make_request("POST", "/completions", data={ + "temperature": 0.0, + "top_k": 1, + "id_slot": 1, + "cache_prompt": True, + "prompt": { + "prompt_string": "What is this: <__media__>\n", + "multimodal_data": [ _get_img_base64(IMG_URL_CAT) ], + }, + }) + assert res.status_code == 200 + + # Saving a slot that holds image tokens must be rejected (HTTP 501, + # not_supported_error). + res = server.make_request("POST", "/slots/1?action=save", data={ + "filename": "mm_slot_image.bin", + }) + assert res.status_code != 200 + assert res.body["error"]["type"] == "not_supported_error" + + +def test_slot_erase_text_only_on_multimodal(mmproj_server): + server = mmproj_server + server.start() + + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox jumps over the lazy dog.", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + prompt_n = res.body["timings"]["prompt_n"] + assert prompt_n > 0 # all tokens are processed + + # Erasing a pure-text slot must succeed even though an mmproj is loaded. + res = server.make_request("POST", "/slots/1?action=erase") + assert res.status_code == 200 + + # Re-running the same prompt should process all tokens again. + res = server.make_request("POST", "/completion", data={ + "prompt": "The quick brown fox jumps over the lazy dog.", + "id_slot": 1, + "cache_prompt": True, + }) + assert res.status_code == 200 + assert res.body["timings"]["prompt_n"] == prompt_n # all tokens are processed again diff --git a/tools/server/tests/unit/test_speculative.py b/tools/server/tests/unit/test_speculative.py new file mode 100644 index 0000000000000000000000000000000000000000..0184085b42b2820185386cd283f9d33021864728 --- /dev/null +++ b/tools/server/tests/unit/test_speculative.py @@ -0,0 +1,135 @@ +import pytest +from utils import * + +# We use a F16 MOE gguf as main model, and q4_0 as draft model + +server = ServerPreset.stories15m_moe() + +MODEL_DRAFT_FILE_URL = "https://huggingface.co/ggml-org/tiny-llamas/resolve/main/stories15M-q4_0.gguf" + +def create_server(): + global server + server = ServerPreset.stories15m_moe() + # set default values + server.model_draft = download_file(MODEL_DRAFT_FILE_URL) + server.spec_type = "draft-simple" + server.spec_draft_n_min = 4 + server.spec_draft_n_max = 8 + server.fa = "off" + + +@pytest.fixture(autouse=True) +def fixture_create_server(): + return create_server() + + +def test_with_and_without_draft(): + global server + request = { + "prompt": "I believe the meaning of life is", + "temperature": 0.8, + "top_k": 40, + "seed": 4242, + "n_predict": 16, + "return_tokens": True, + } + + server.model_draft = None # disable draft model + server.spec_type = None + server.backend_sampling = True + server.start() + res = server.make_request("POST", "/completion", data=request) + assert res.status_code == 200 + tokens_no_draft = res.body["tokens"] + server.stop() + + # create new server with draft model + create_server() + server.backend_sampling = True + server.start() + res = server.make_request("POST", "/completion", data=request) + assert res.status_code == 200 + assert res.body["timings"]["draft_n"] > 0 + tokens_draft = res.body["tokens"] + + assert tokens_no_draft == tokens_draft + + +def test_different_draft_min_draft_max(): + global server + test_values = [ + (1, 2), + (1, 4), + (4, 8), + (4, 12), + (8, 16), + ] + last_content = None + for draft_min, draft_max in test_values: + server.stop() + server.spec_draft_n_min = draft_min + server.spec_draft_n_max = draft_max + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "I believe the meaning of life is", + "temperature": 0.0, + "top_k": 1, + "n_predict": 16, + }) + assert res.status_code == 200 + if last_content is not None: + assert last_content == res.body["content"] + last_content = res.body["content"] + + +def test_slot_ctx_not_exceeded(): + global server + server.n_ctx = 256 + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "Hello " * 248, + "temperature": 0.0, + "top_k": 1, + "speculative.p_min": 0.0, + }) + assert res.status_code == 200 + assert len(res.body["content"]) > 0 + + +def test_with_ctx_shift(): + global server + server.n_ctx = 256 + server.enable_ctx_shift = True + server.start() + res = server.make_request("POST", "/completion", data={ + "prompt": "Hello " * 248, + "temperature": 0.0, + "top_k": 1, + "n_predict": 256, + "speculative.p_min": 0.0, + }) + assert res.status_code == 200 + assert len(res.body["content"]) > 0 + assert res.body["tokens_predicted"] == 256 + assert res.body["truncated"] == True + + +@pytest.mark.parametrize("n_slots,n_requests", [ + (1, 2), + (2, 2), +]) +def test_multi_requests_parallel(n_slots: int, n_requests: int): + global server + server.n_slots = n_slots + server.start() + tasks = [] + for _ in range(n_requests): + tasks.append((server.make_request, ("POST", "/completion", { + "prompt": "I believe the meaning of life is", + "temperature": 0.0, + "top_k": 1, + }))) + results = parallel_function_calls(tasks) + for res in results: + assert res.status_code == 200 + assert match_regex("(wise|kind|owl|answer)+", res.body["content"]) diff --git a/tools/server/tests/unit/test_stream.py b/tools/server/tests/unit/test_stream.py new file mode 100644 index 0000000000000000000000000000000000000000..a1ef55567bc7e1f830b46b8624b8f8a5a77b6d1e --- /dev/null +++ b/tools/server/tests/unit/test_stream.py @@ -0,0 +1,153 @@ +import json +import socket +import threading +import time +from urllib.parse import quote +import pytest +from utils import * + +server: ServerProcess + +# a model name with slashes exercises the query string routing of the stream routes: the id +# cannot travel as a path param because the decoded slash would split it before capture +MODEL = "ggml-org/tinygemma3-GGUF:Q8_0" +STREAM_ID = f"conv-stream-test::{MODEL}" +QS = "conv_id=" + quote(STREAM_ID, safe="") + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.router() + + +def test_stream_resume_and_stop_with_slashed_model_name(): + global server + server.start() + + content = "" + for data in server.make_stream_request("POST", "/chat/completions", data={ + "model": MODEL, + "stream": True, + "max_tokens": 16, + "messages": [{"role": "user", "content": "hello"}], + }, headers={"X-Conversation-Id": STREAM_ID}): + if data["choices"]: + content += data["choices"][0]["delta"].get("content") or "" + assert len(content) > 0 + + # the finished session replays from the beginning through the router + res = server.make_request("GET", f"/v1/stream?{QS}&from=0") + assert res.status_code == 200 + assert "data: " in str(res.body) + + # the explicit stop reaches the owning child and evicts the session + res = server.make_request("DELETE", f"/v1/stream?{QS}") + assert res.status_code == 204 + res = server.make_request("GET", f"/v1/stream?{QS}&from=0") + assert res.status_code == 404 + + +def test_stream_stop_during_model_load(): + global server + server.start() + + thread_error: list[ServerError] = [] + thread_done = threading.Event() + + def fire_post(): + try: + for _ in server.make_stream_request("POST", "/chat/completions", data={ + "model": MODEL, + "stream": True, + "max_tokens": 512, + "messages": [{"role": "user", "content": "Count from 1 to 1000."}], + }, headers={"X-Conversation-Id": STREAM_ID}): + pass + except ServerError as e: + thread_error.append(e) + finally: + thread_done.set() + + t = threading.Thread(target=fire_post) + t.start() + + # catch the autoload window, tiny models load fast so poll aggressively + saw_loading = False + deadline = time.time() + 5.0 + while time.time() < deadline and not thread_done.is_set(): + res = server.make_request("GET", "/models") + status = next(m["status"]["value"] for m in res.body["data"] if m["id"] == MODEL) + if status == "loading": + saw_loading = True + break + time.sleep(0.002) + if not saw_loading: + t.join() + pytest.skip("load window too short to be observed on this machine") # ty: ignore[too-many-positional-arguments] + + # a stop during the load cancels the parked request instead of leaving an orphan + res = server.make_request("DELETE", f"/v1/stream?{QS}") + assert res.status_code == 204 + assert thread_done.wait(timeout=60) + t.join() + assert len(thread_error) == 1 + assert thread_error[0].code == 400 + assert "cancelled" in json.dumps(thread_error[0].body) + res = server.make_request("GET", f"/v1/stream?{QS}&from=0") + assert res.status_code == 404 + + +def test_stream_resumes_after_reload_during_model_load(): + global server + server.start() + + # raw socket client so the connection can be dropped mid load like a page reload + body = json.dumps({ + "model": MODEL, + "stream": True, + "max_tokens": 16, + "messages": [{"role": "user", "content": "hello"}], + }) + request = ( + f"POST /v1/chat/completions HTTP/1.1\r\n" + f"Host: {server.server_host}:{server.server_port}\r\n" + f"Content-Type: application/json\r\n" + f"X-Conversation-Id: {STREAM_ID}\r\n" + f"Content-Length: {len(body)}\r\n" + f"Connection: close\r\n\r\n{body}" + ) + sock = socket.create_connection((server.server_host, server.server_port)) + sock.sendall(request.encode()) + + # drop the client while the model loads, poll aggressively to catch the window + saw_loading = False + saw_503 = False + deadline = time.time() + 5.0 + while time.time() < deadline: + res = server.make_request("GET", "/models") + status = next(m["status"]["value"] for m in res.body["data"] if m["id"] == MODEL) + if status == "loading": + saw_loading = True + break + if status == "loaded": + break + time.sleep(0.002) + sock.close() + if not saw_loading: + pytest.skip("load window too short to be observed on this machine") # ty: ignore[too-many-positional-arguments] + + # while the model loads the resume route answers retry later, then the session appears, + # receives the whole generation despite the dead client, and replays from the beginning + deadline = time.time() + 60.0 + replay = None + while time.time() < deadline: + res = server.make_request("GET", f"/v1/stream?{QS}&from=0") + if res.status_code == 503: + saw_503 = True + elif res.status_code == 200 and "data: " in str(res.body): + replay = res + break + time.sleep(0.1) + assert saw_503, "resume during the load did not answer 503" + assert replay is not None, "session never became resumable after the client disconnect" diff --git a/tools/server/tests/unit/test_template.py b/tools/server/tests/unit/test_template.py new file mode 100644 index 0000000000000000000000000000000000000000..43a356020dd5ee1ab75a2b80e03d153324f4ba5a --- /dev/null +++ b/tools/server/tests/unit/test_template.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python +import pytest + +# ensure grandparent path is in sys.path +from pathlib import Path +import sys + +from unit.test_tool_call import TEST_TOOL +path = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(path)) + +import datetime +from utils import * +from typing import Literal + +server: ServerProcess + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.model_alias = "tinyllama-2" + server.n_slots = 1 + + +@pytest.mark.parametrize("tools", [None, [], [TEST_TOOL]]) +@pytest.mark.parametrize("template_name,reasoning,expected_end", [ + ("deepseek-ai-DeepSeek-R1-Distill-Qwen-32B", "on", "\n"), + ("deepseek-ai-DeepSeek-R1-Distill-Qwen-32B","auto", "\n"), + ("deepseek-ai-DeepSeek-R1-Distill-Qwen-32B", "off", "\n"), + + ("Qwen-Qwen3-0.6B","auto", "<|im_start|>assistant\n"), + ("Qwen-Qwen3-0.6B", "off", "<|im_start|>assistant\n\n\n\n\n"), + + ("Qwen-QwQ-32B","auto", "<|im_start|>assistant\n\n"), + ("Qwen-QwQ-32B", "off", "<|im_start|>assistant\n\n"), + + ("CohereForAI-c4ai-command-r7b-12-2024-tool_use","auto", "<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>"), + ("CohereForAI-c4ai-command-r7b-12-2024-tool_use", "off", "<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|><|START_THINKING|><|END_THINKING|>"), +]) +def test_reasoning(template_name: str, reasoning: Literal['on', 'off', 'auto'] | None, expected_end: str, tools: list[dict]): + global server + server.jinja = True + server.reasoning = reasoning + server.chat_template_file = f'../../../models/templates/{template_name}.jinja' + server.start() + + res = server.make_request("POST", "/apply-template", data={ + "messages": [ + {"role": "user", "content": "What is today?"}, + ], + "tools": tools, + }) + assert res.status_code == 200 + prompt = res.body["prompt"] + + assert prompt.endswith(expected_end), f"Expected prompt to end with '{expected_end}', got '{prompt}'" + + +@pytest.mark.parametrize("tools", [None, [], [TEST_TOOL]]) +@pytest.mark.parametrize("template_name,format", [ + ("meta-llama-Llama-3.3-70B-Instruct", "%d %b %Y"), + ("fireworks-ai-llama-3-firefunction-v2", "%b %d %Y"), +]) +def test_date_inside_prompt(template_name: str, format: str, tools: list[dict]): + global server + server.jinja = True + server.chat_template_file = f'../../../models/templates/{template_name}.jinja' + server.start() + + res = server.make_request("POST", "/apply-template", data={ + "messages": [ + {"role": "user", "content": "What is today?"}, + ], + "tools": tools, + }) + assert res.status_code == 200 + prompt = res.body["prompt"] + + today_str = datetime.date.today().strftime(format) + assert today_str in prompt, f"Expected today's date ({today_str}) in content ({prompt})" + + +@pytest.mark.parametrize("add_generation_prompt", [False, True]) +@pytest.mark.parametrize("template_name,expected_generation_prompt", [ + ("meta-llama-Llama-3.3-70B-Instruct", "<|start_header_id|>assistant<|end_header_id|>"), +]) +def test_add_generation_prompt(template_name: str, expected_generation_prompt: str, add_generation_prompt: bool): + global server + server.jinja = True + server.chat_template_file = f'../../../models/templates/{template_name}.jinja' + server.start() + + res = server.make_request("POST", "/apply-template", data={ + "messages": [ + {"role": "user", "content": "What is today?"}, + ], + "add_generation_prompt": add_generation_prompt, + }) + assert res.status_code == 200 + prompt = res.body["prompt"] + + if add_generation_prompt: + assert expected_generation_prompt in prompt, f"Expected generation prompt ({expected_generation_prompt}) in content ({prompt})" + else: + assert expected_generation_prompt not in prompt, f"Did not expect generation prompt ({expected_generation_prompt}) in content ({prompt})" diff --git a/tools/server/tests/unit/test_tokenize.py b/tools/server/tests/unit/test_tokenize.py new file mode 100644 index 0000000000000000000000000000000000000000..424cac5f3d39412d5732c23c3bbed93a866b3eb5 --- /dev/null +++ b/tools/server/tests/unit/test_tokenize.py @@ -0,0 +1,59 @@ +import pytest +from utils import * + +server = ServerPreset.tinyllama2() + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + + +def test_tokenize_detokenize(): + global server + server.start() + # tokenize + content = "What is the capital of France ?" + res_tok = server.make_request("POST", "/tokenize", data={ + "content": content + }) + assert res_tok.status_code == 200 + assert len(res_tok.body["tokens"]) > 5 + # detokenize + res_detok = server.make_request("POST", "/detokenize", data={ + "tokens": res_tok.body["tokens"], + }) + assert res_detok.status_code == 200 + assert res_detok.body["content"].strip() == content + + +def test_tokenize_with_bos(): + global server + server.start() + # tokenize + content = "What is the capital of France ?" + bosId = 1 + res_tok = server.make_request("POST", "/tokenize", data={ + "content": content, + "add_special": True, + }) + assert res_tok.status_code == 200 + assert res_tok.body["tokens"][0] == bosId + + +def test_tokenize_with_pieces(): + global server + server.start() + # tokenize + content = "This is a test string with unicode 媽 and emoji 🤗" + res_tok = server.make_request("POST", "/tokenize", data={ + "content": content, + "with_pieces": True, + }) + assert res_tok.status_code == 200 + for token in res_tok.body["tokens"]: + assert "id" in token + assert token["id"] > 0 + assert "piece" in token + assert len(token["piece"]) > 0 diff --git a/tools/server/tests/unit/test_tool_call.py b/tools/server/tests/unit/test_tool_call.py new file mode 100644 index 0000000000000000000000000000000000000000..9fa84d165efcbae3380d0ad0fe0f18f71e4e6fa3 --- /dev/null +++ b/tools/server/tests/unit/test_tool_call.py @@ -0,0 +1,645 @@ +#!/usr/bin/env python +import pytest + +# ensure grandparent path is in sys.path +from pathlib import Path +import sys +path = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(path)) + +from utils import * +from enum import Enum +from typing import TypedDict + +server: ServerProcess + +TIMEOUT_START_SLOW = 15 * 60 # this is needed for real model tests +TIMEOUT_HTTP_REQUEST = 60 + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.tinyllama2() + server.model_alias = "tinyllama-2-tool-call" + server.server_port = 8081 + server.n_slots = 1 + server.n_ctx = 8192 + server.n_batch = 2048 + +class CompletionMode(Enum): + NORMAL = "normal" + STREAMED = "streamed" + +class ToolParameters(TypedDict): + type: str + properties: dict[str, dict] + required: list[str] + +class ToolFunction(TypedDict): + name: str + description: str + parameters: ToolParameters + +class ToolDefinition(TypedDict): + type: str + function: ToolFunction + +TEST_TOOL = ToolDefinition( + type = "function", + function = ToolFunction( + name = "test", + description = "", + parameters = ToolParameters( + type = "object", + properties = { + "success": { + "type": "boolean", + "const": True, + }, + }, + required = ["success"], + ), + ), +) + +PYTHON_TOOL = ToolDefinition( + type = "function", + function = ToolFunction( + name = "python", + description = "Runs code in an ipython interpreter and returns the result of the execution after 60 seconds.", + parameters = ToolParameters( + type = "object", + properties = { + "code": { + "type": "string", + "description": "The code to run in the ipython interpreter.", + }, + }, + required = ["code"], + ), + ), +) + +WEATHER_TOOL = ToolDefinition( + type = "function", + function = ToolFunction( + name = "get_current_weather", + description = "Get the current weather in a given location", + parameters = ToolParameters( + type = "object", + properties = { + "location": { + "type": "string", + "description": "The city and country/state, e.g. 'San Francisco, CA', or 'Paris, France'", + }, + }, + required = ["location"], + ), + ), +) + +def do_test_completion_with_required_tool_tiny(server: ServerProcess, tool: dict, argument_key: str | None, n_predict, **kwargs): + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "max_tokens": n_predict, + "messages": [ + {"role": "system", "content": "You are a coding assistant."}, + {"role": "user", "content": "Write an example"}, + ], + "tool_choice": "required", + "tools": [tool], + "parallel_tool_calls": False, + **kwargs, + }) + # assert res.status_code == 200, f"Expected status code 200, got {res.status_code}" + choice = body["choices"][0] + tool_calls = choice["message"].get("tool_calls") + assert tool_calls and len(tool_calls) == 1, f'Expected 1 tool call in {choice["message"]}' + tool_call = tool_calls[0] + assert choice["message"].get("content") in (None, ""), f'Expected no content in {choice["message"]}' + # assert len(tool_call.get("id", "")) > 0, f'Expected non empty tool call id in {tool_call}' + expected_function_name = "python" if tool["type"] == "code_interpreter" else tool["function"]["name"] + assert expected_function_name == tool_call["function"]["name"], f'Expected tool name to be {tool_call["function"]["name"]} in {choice["message"]}' + actual_arguments = tool_call["function"]["arguments"] + assert isinstance(actual_arguments, dict) or isinstance(actual_arguments, str), f'Expected arguments to be a dict or str, got: {actual_arguments}' + if argument_key is not None: + if (isinstance(actual_arguments, str)): + actual_arguments = json.loads(actual_arguments) + assert argument_key in actual_arguments, f"tool arguments: {actual_arguments}, expected: {argument_key}" + +# PR #22654: commented out since we're now allowing content before tool calls in tool_call: required, so we can't force this +# in the tiny model just by using the grammar +# +# @pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +# @pytest.mark.parametrize("template_name,tool,argument_key", [ +# ("Qwen3-Coder", TEST_TOOL, "success"), +# ("Qwen3-Coder", TEST_TOOL, "success"), +# ("meta-llama-Llama-3.3-70B-Instruct", TEST_TOOL, "success"), +# ("meta-llama-Llama-3.3-70B-Instruct", TEST_TOOL, "success"), +# ("meta-llama-Llama-3.3-70B-Instruct", PYTHON_TOOL, "code"), +# ("meta-llama-Llama-3.3-70B-Instruct", PYTHON_TOOL, "code"), +# ]) +# def test_completion_with_required_tool_tiny_fast(template_name: str, tool: dict, argument_key: str | None, stream: CompletionMode): +# global server +# n_predict = 1024 +# # server = ServerPreset.stories15m_moe() +# server.jinja = True +# server.n_predict = n_predict +# server.chat_template_file = f'../../../models/templates/{template_name}.jinja' +# server.start() +# do_test_completion_with_required_tool_tiny(server, tool, argument_key, n_predict, stream=stream == CompletionMode.STREAMED, temperature=0.0, top_k=1, top_p=1.0) + +# @pytest.mark.slow +# @pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +# @pytest.mark.parametrize("template_name,tool,argument_key", [ +# ("meta-llama-Llama-3.1-8B-Instruct", TEST_TOOL, "success"), +# ("meta-llama-Llama-3.1-8B-Instruct", PYTHON_TOOL, "code"), + +# ("meetkai-functionary-medium-v3.1", TEST_TOOL, "success"), +# ("meetkai-functionary-medium-v3.1", PYTHON_TOOL, "code"), + +# ("meetkai-functionary-medium-v3.2", TEST_TOOL, "success"), +# # Functionary v3.2 format supports raw python content, which w/ a dummy stories model will never end on its own. +# # ("meetkai-functionary-medium-v3.2", PYTHON_TOOL, "code"), + +# ("NousResearch-Hermes-2-Pro-Llama-3-8B-tool_use", TEST_TOOL, "success"), +# ("NousResearch-Hermes-2-Pro-Llama-3-8B-tool_use", PYTHON_TOOL, "code"), + +# ("meta-llama-Llama-3.2-3B-Instruct", TEST_TOOL, "success"), +# ("meta-llama-Llama-3.2-3B-Instruct", PYTHON_TOOL, "code"), + +# ("mistralai-Mistral-Nemo-Instruct-2407", TEST_TOOL, "success"), +# ("mistralai-Mistral-Nemo-Instruct-2407", PYTHON_TOOL, "code"), + +# ("NousResearch-Hermes-3-Llama-3.1-8B-tool_use", TEST_TOOL, "success"), +# ("NousResearch-Hermes-3-Llama-3.1-8B-tool_use", PYTHON_TOOL, "code"), + +# ("deepseek-ai-DeepSeek-R1-Distill-Llama-8B", TEST_TOOL, "success"), +# ("deepseek-ai-DeepSeek-R1-Distill-Llama-8B", PYTHON_TOOL, "code"), + +# ("fireworks-ai-llama-3-firefunction-v2", TEST_TOOL, "success"), +# # ("fireworks-ai-llama-3-firefunction-v2", PYTHON_TOOL, "codeFalse), True), +# # ("fireworks-ai-llama-3-firefunction-v2", PYTHON_TOOL, "code"), + +# ]) +# def test_completion_with_required_tool_tiny_slow(template_name: str, tool: dict, argument_key: str | None, stream: CompletionMode): +# global server +# n_predict = 512 +# # server = ServerPreset.stories15m_moe() +# server.jinja = True +# server.n_predict = n_predict +# server.chat_template_file = f'../../../models/templates/{template_name}.jinja' +# server.start(timeout_seconds=TIMEOUT_START_SLOW) +# do_test_completion_with_required_tool_tiny(server, tool, argument_key, n_predict, stream=stream == CompletionMode.STREAMED) + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("tool,argument_key,hf_repo,template_override", [ + (TEST_TOOL, "success", "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/gemma-2-2b-it-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/gemma-2-2b-it-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/gemma-2-2b-it-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-2-Pro-Llama-3-8B", "tool_use")), + (PYTHON_TOOL, "code", "bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-2-Pro-Llama-3-8B", "tool_use")), + (PYTHON_TOOL, "code", "bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-3-Llama-3.1-8B", "tool_use")), + (PYTHON_TOOL, "code", "bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-3-Llama-3.1-8B", "tool_use")), + (PYTHON_TOOL, "code", "bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", "chatml"), + + # (TEST_TOOL, "success", "bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", None), + # (PYTHON_TOOL, "code", "bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", None), + # (PYTHON_TOOL, "code", "bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/functionary-small-v3.2-GGUF:Q4_K_M", ("meetkai/functionary-medium-v3.2", None)), + (PYTHON_TOOL, "code", "bartowski/functionary-small-v3.2-GGUF:Q4_K_M", ("meetkai/functionary-medium-v3.2", None)), + (PYTHON_TOOL, "code", "bartowski/functionary-small-v3.2-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), + (PYTHON_TOOL, "code", "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), + (PYTHON_TOOL, "code", "bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), + (PYTHON_TOOL, "code", "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), + (PYTHON_TOOL, "code", "bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", "chatml"), + + (TEST_TOOL, "success", "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), + (PYTHON_TOOL, "code", "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), +]) +def test_completion_with_required_tool_real_model(tool: dict, argument_key: str | None, hf_repo: str, template_override: str | Tuple[str, str | None] | None, stream: CompletionMode): + global server + n_predict = 512 + server.jinja = True + server.n_ctx = 8192 + server.n_predict = n_predict + server.model_hf_repo = hf_repo + server.model_hf_file = None + if isinstance(template_override, tuple): + (template_hf_repo, template_variant) = template_override + server.chat_template_file = f"../../../models/templates/{template_hf_repo.replace('/', '-') + ('-' + template_variant if template_variant else '')}.jinja" + assert os.path.exists(server.chat_template_file), f"Template file {server.chat_template_file} does not exist. Run `python scripts/get_chat_template.py {template_hf_repo} {template_variant} > {server.chat_template_file}` to download the template." + elif isinstance(template_override, str): + server.chat_template = template_override + server.start(timeout_seconds=TIMEOUT_START_SLOW) + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "max_tokens": n_predict, + "messages": [ + {"role": "system", "content": "You are a coding assistant."}, + {"role": "user", "content": "Write an example"}, + ], + "tool_choice": "required", + "tools": [tool], + "parallel_tool_calls": False, + "stream": stream == CompletionMode.STREAMED, + "temperature": 0.0, + "top_k": 1, + "top_p": 1.0, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + tool_calls = choice["message"].get("tool_calls") + assert tool_calls and len(tool_calls) == 1, f'Expected 1 tool call in {choice["message"]}' + tool_call = tool_calls[0] + # assert choice["message"].get("content") in (None, ""), f'Expected no content in {choice["message"]}' + expected_function_name = "python" if tool["type"] == "code_interpreter" else tool["function"]["name"] + assert expected_function_name == tool_call["function"]["name"] + actual_arguments = tool_call["function"]["arguments"] + assert isinstance(actual_arguments, str) + if argument_key is not None: + actual_arguments = json.loads(actual_arguments) + assert argument_key in actual_arguments, f"tool arguments: {json.dumps(actual_arguments)}, expected: {argument_key}" + + +def do_test_completion_without_tool_call(server: ServerProcess, n_predict: int, tools: list[dict], tool_choice: str | None, **kwargs): + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "max_tokens": n_predict, + "messages": [ + {"role": "system", "content": "You are a coding assistant."}, + {"role": "user", "content": "say hello world with python"}, + ], + "tools": tools if tools else None, + "tool_choice": tool_choice, + **kwargs, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + assert choice["message"].get("tool_calls") is None, f'Expected no tool call in {choice["message"]}' + + +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("template_name,n_predict,tools,tool_choice", [ + ("meta-llama-Llama-3.3-70B-Instruct", 128, [], None), + ("meta-llama-Llama-3.3-70B-Instruct", 128, [TEST_TOOL], None), + ("meta-llama-Llama-3.3-70B-Instruct", 128, [PYTHON_TOOL], 'none'), +]) +def test_completion_without_tool_call_fast(template_name: str, n_predict: int, tools: list[dict], tool_choice: str | None, stream: CompletionMode): + global server + server.n_predict = n_predict + server.jinja = True + server.chat_template_file = f'../../../models/templates/{template_name}.jinja' + server.start() + do_test_completion_without_tool_call(server, n_predict, tools, tool_choice, stream=stream == CompletionMode.STREAMED) + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("template_name,n_predict,tools,tool_choice", [ + ("meetkai-functionary-medium-v3.2", 256, [], None), + ("meetkai-functionary-medium-v3.2", 256, [TEST_TOOL], None), + ("meetkai-functionary-medium-v3.2", 256, [PYTHON_TOOL], 'none'), + ("meetkai-functionary-medium-v3.1", 256, [], None), + ("meetkai-functionary-medium-v3.1", 256, [TEST_TOOL], None), + ("meetkai-functionary-medium-v3.1", 256, [PYTHON_TOOL], 'none'), + ("meta-llama-Llama-3.2-3B-Instruct", 256, [], None), + ("meta-llama-Llama-3.2-3B-Instruct", 256, [TEST_TOOL], None), + ("meta-llama-Llama-3.2-3B-Instruct", 256, [PYTHON_TOOL], 'none'), +]) +def test_completion_without_tool_call_slow(template_name: str, n_predict: int, tools: list[dict], tool_choice: str | None, stream: CompletionMode): + global server + server.n_predict = n_predict + server.jinja = True + server.chat_template_file = f'../../../models/templates/{template_name}.jinja' + server.start(timeout_seconds=TIMEOUT_START_SLOW) + do_test_completion_without_tool_call(server, n_predict, tools, tool_choice, stream=stream == CompletionMode.STREAMED) + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("hf_repo,template_override", [ + ("bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + ("bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-2-Pro-Llama-3-8B", "tool_use")), + ("bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-3-Llama-3.1-8B", "tool_use")), + ("bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", "chatml"), + + # ("bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", None), + # ("bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", "chatml"), + + # ("bartowski/functionary-small-v3.2-GGUF:Q8_0", ("meetkai/functionary-medium-v3.2", None)), + # ("bartowski/functionary-small-v3.2-GGUF:Q8_0", "chatml"), + + ("bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), + ("bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/c4ai-command-r7b-12-2024-GGUF:Q6_K_L", ("CohereForAI/c4ai-command-r7b-12-2024", "tool_use")), + + ("bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), + + # Note: gemma-2-2b-it knows itself as "model", not "assistant", so we don't test the ill-suited chatml on it. + ("bartowski/gemma-2-2b-it-GGUF:Q4_K_M", None), + + # ("bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", ("meta-llama/Llama-3.2-3B-Instruct", None)), +]) +def test_weather(hf_repo: str, template_override: str | Tuple[str, str | None] | None, stream: CompletionMode): + global server + n_predict = 512 + server.jinja = True + server.n_ctx = 8192 + server.n_predict = n_predict + server.model_hf_repo = hf_repo + server.model_hf_file = None + if isinstance(template_override, tuple): + (template_hf_repo, template_variant) = template_override + server.chat_template_file = f"../../../models/templates/{template_hf_repo.replace('/', '-') + ('-' + template_variant if template_variant else '')}.jinja" + assert os.path.exists(server.chat_template_file), f"Template file {server.chat_template_file} does not exist. Run `python scripts/get_chat_template.py {template_hf_repo} {template_variant} > {server.chat_template_file}` to download the template." + elif isinstance(template_override, str): + server.chat_template = template_override + server.start() + do_test_weather(server, stream=stream == CompletionMode.STREAMED, max_tokens=n_predict) + + +def do_test_weather(server: ServerProcess, **kwargs): + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "messages": [ + {"role": "system", "content": "You are a chatbot that uses tools/functions. Dont overthink things."}, + {"role": "user", "content": "What is the weather in Istanbul?"}, + ], + "tools": [WEATHER_TOOL], + **kwargs, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + tool_calls = choice["message"].get("tool_calls") + assert tool_calls and len(tool_calls) == 1, f'Expected 1 tool call in {choice["message"]}' + tool_call = tool_calls[0] + # assert choice["message"].get("content") in (None, ""), f'Expected no content in {choice["message"]}' + assert tool_call["function"]["name"] == WEATHER_TOOL["function"]["name"], f'Expected weather tool call, got {tool_call["function"]["name"]}' + # assert len(tool_call.get("id", "")) > 0, f'Expected non empty tool call id in {tool_call}' + actual_arguments = json.loads(tool_call["function"]["arguments"]) + assert 'location' in actual_arguments, f"location not found in {json.dumps(actual_arguments)}" + location = actual_arguments["location"] + assert isinstance(location, str), f"Expected location to be a string, got {type(location)}: {json.dumps(location)}" + assert re.match('^Istanbul(( |, ?)(TR|Turkey|Türkiye))?$', location), f'Expected Istanbul for location, got {location}' + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("result_override,n_predict,hf_repo,template_override", [ + (None, 128, "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", "chatml"), + (None, 128, "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", None), + (None, 128, "bartowski/Qwen2.5-Coder-3B-Instruct-GGUF:Q4_K_M", "chatml"), + (None, 128, "bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", "chatml"), + (None, 128, "bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-2-Pro-Llama-3-8B", "tool_use")), + (None, 128, "bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-3-Llama-3.1-8B", "tool_use")), + (None, 128, "bartowski/functionary-small-v3.2-GGUF:Q8_0", ("meetkai/functionary-medium-v3.2", None)), + (None, 128, "bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", None), + (None, 128, "bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", "chatml"), + (None, 128, "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + ("[\\s\\S]*?\\*\\*\\s*0.5($|\\*\\*)", 8192, "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", ("llama-cpp-deepseek-r1", None)), + + # TODO: fix these (wrong results, either didn't respect decimal instruction or got wrong value) + # (None, 128, "bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", None), + # ("[\\s\\S]*?\\*\\*\\s*0.5($|\\*\\*)", 8192, "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), +]) +def test_calc_result(result_override: str | None, n_predict: int, hf_repo: str, template_override: str | Tuple[str, str | None] | None, stream: CompletionMode): + global server + server.jinja = True + server.n_ctx = 8192 * 2 + server.n_predict = n_predict + server.model_hf_repo = hf_repo + server.model_hf_file = None + if isinstance(template_override, tuple): + (template_hf_repo, template_variant) = template_override + server.chat_template_file = f"../../../models/templates/{template_hf_repo.replace('/', '-') + ('-' + template_variant if template_variant else '')}.jinja" + assert os.path.exists(server.chat_template_file), f"Template file {server.chat_template_file} does not exist. Run `python scripts/get_chat_template.py {template_hf_repo} {template_variant} > {server.chat_template_file}` to download the template." + elif isinstance(template_override, str): + server.chat_template = template_override + server.start(timeout_seconds=TIMEOUT_START_SLOW) + do_test_calc_result(server, result_override, n_predict, stream=stream == CompletionMode.STREAMED) + + +def do_test_calc_result(server: ServerProcess, result_override: str | None, n_predict: int, **kwargs): + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "max_tokens": n_predict, + "messages": [ + {"role": "system", "content": "You are a tools-calling assistant. You express numerical values with at most two decimals."}, + {"role": "user", "content": "What's the y coordinate of a point on the unit sphere at angle 30 degrees?"}, + { + "role": "assistant", + "content": None, + "tool_calls": [ + { + "id": "call_6789", + "type": "function", + "function": { + "name": "calculate", + "arguments": "{\"expression\":\"sin(30 * pi / 180)\"}" + } + } + ] + }, + { + "role": "tool", + "name": "calculate", + "content": "0.55644242476", + "tool_call_id": "call_6789" + } + ], + "tools": [ + { + "type":"function", + "function":{ + "name":"calculate", + "description":"A calculator function that computes values of arithmetic expressions in the Python syntax", + "parameters":{ + "type":"object", + "properties":{ + "expression":{ + "type":"string", + "description":"An arithmetic expression to compute the value of (Python syntad, assuming all floats)" + } + }, + "required":["expression"] + } + } + } + ], + **kwargs, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + tool_calls = choice["message"].get("tool_calls") + assert tool_calls is None, f'Expected no tool call in {choice["message"]}' + content = choice["message"].get("content") + assert content is not None, f'Expected content in {choice["message"]}' + if result_override is not None: + assert re.match(result_override, content), f'Expected {result_override}, got {content}' + else: + assert re.match('^[\\s\\S]*?((That\'s|\\bis) (approximately )?)?\\b0\\.(5\\b|56\\b|556)', content), \ + f'Expected something like "The y coordinate is 0.56.", got {content}' + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("n_predict,reasoning_format,expect_reasoning_content,expect_content,hf_repo,template_override", [ + (128, 'deepseek', None, "^The sum of 102 and 7 is 109[\\s\\S]*", "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + (128, None, None, "^The sum of 102 and 7 is 109[\\s\\S]*", "bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + (1024, 'deepseek', "I need to calculate the sum of 102 and 7[\\s\\S]*", "To find the sum of[\\s\\S]*", "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), + (1024, 'deepseek', "First, I [\\s\\S]*", "To find the sum of[\\s\\S]*", "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", ("llama-cpp-deepseek-r1", None)), + # (1024, 'none', CompletionMode.NORMAL, None, "^(\\s*)?I need[\\s\\S]*?\\s*To find[\\s\\S]*", "bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), + # (128, 'deepseek', None, "^Okay, let me figure out the sum of 102 and 7[\\s\\S]*", "bartowski/Qwen_QwQ-32B-GGUF:Q4_K_M", None), +]) +def test_thoughts(n_predict: int, reasoning_format: Literal['deepseek', 'none'] | None, expect_content: str | None, expect_reasoning_content: str | None, hf_repo: str, template_override: str | Tuple[str, str | None] | None, stream: CompletionMode): + global server + server.reasoning_format = reasoning_format + server.jinja = True + server.n_ctx = 8192 * 2 + server.n_predict = n_predict + server.model_hf_repo = hf_repo + server.model_hf_file = None + if isinstance(template_override, tuple): + (template_hf_repo, template_variant) = template_override + server.chat_template_file = f"../../../models/templates/{template_hf_repo.replace('/', '-') + ('-' + template_variant if template_variant else '')}.jinja" + assert os.path.exists(server.chat_template_file), f"Template file {server.chat_template_file} does not exist. Run `python scripts/get_chat_template.py {template_hf_repo} {template_variant} > {server.chat_template_file}` to download the template." + elif isinstance(template_override, str): + server.chat_template = template_override + server.start() + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "max_tokens": n_predict, + "messages": [ + {"role": "user", "content": "What's the sum of 102 and 7?"}, + ], + "stream": stream == CompletionMode.STREAMED, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + assert choice["message"].get("tool_calls") is None, f'Expected no tool call in {choice["message"]}' + + content = choice["message"].get("content") + if expect_content is None: + assert choice["message"].get("content") in (None, ""), f'Expected no content in {choice["message"]}' + else: + assert re.match(expect_content, content), f'Expected {expect_content}, got {content}' + + reasoning_content = choice["message"].get("reasoning_content") + if expect_reasoning_content is None: + assert reasoning_content is None, f'Expected no reasoning content in {choice["message"]}' + else: + assert re.match(expect_reasoning_content, reasoning_content), f'Expected {expect_reasoning_content}, got {reasoning_content}' + + +@pytest.mark.slow +@pytest.mark.parametrize("stream", [CompletionMode.NORMAL, CompletionMode.STREAMED]) +@pytest.mark.parametrize("hf_repo,template_override", [ + ("bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF:Q4_K_M", None), + + ("bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", None), + ("bartowski/Phi-3.5-mini-instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/functionary-small-v3.2-GGUF:Q8_0", ("meetkai-functionary-medium-v3.2", None)), + ("bartowski/functionary-small-v3.2-GGUF:Q8_0", "chatml"), + + # ("bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", ("meta-llama-Llama-3.2-3B-Instruct", None)), + ("bartowski/Llama-3.2-1B-Instruct-GGUF:Q4_K_M", None), + + ("bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", ("meta-llama-Llama-3.2-3B-Instruct", None)), + ("bartowski/Llama-3.2-3B-Instruct-GGUF:Q4_K_M", None), + + ("bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", None), + ("bartowski/Qwen2.5-7B-Instruct-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", ("NousResearch/Hermes-2-Pro-Llama-3-8B", "tool_use")), + ("bartowski/Hermes-2-Pro-Llama-3-8B-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", ("NousResearch-Hermes-3-Llama-3.1-8B", "tool_use")), + ("bartowski/Hermes-3-Llama-3.1-8B-GGUF:Q4_K_M", "chatml"), + + ("bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", None), + ("bartowski/Mistral-Nemo-Instruct-2407-GGUF:Q4_K_M", "chatml"), + + ("bartowski/gemma-2-2b-it-GGUF:Q4_K_M", None), + ("bartowski/gemma-2-2b-it-GGUF:Q4_K_M", "chatml"), +]) +def test_hello_world(hf_repo: str, template_override: str | Tuple[str, str | None] | None, stream: CompletionMode): + global server + n_predict = 512 # High because of DeepSeek R1 + server.jinja = True + server.n_ctx = 8192 + server.n_predict = n_predict + server.model_hf_repo = hf_repo + server.model_hf_file = None + if isinstance(template_override, tuple): + (template_hf_repo, template_variant) = template_override + server.chat_template_file = f"../../../models/templates/{template_hf_repo.replace('/', '-') + ('-' + template_variant if template_variant else '')}.jinja" + assert os.path.exists(server.chat_template_file), f"Template file {server.chat_template_file} does not exist. Run `python scripts/get_chat_template.py {template_hf_repo} {template_variant} > {server.chat_template_file}` to download the template." + elif isinstance(template_override, str): + server.chat_template = template_override + server.start(timeout_seconds=TIMEOUT_START_SLOW) + + do_test_hello_world(server, stream=stream == CompletionMode.STREAMED, max_tokens=n_predict) + + +def do_test_hello_world(server: ServerProcess, **kwargs): + body = server.make_any_request("POST", "/v1/chat/completions", data={ + "messages": [ + {"role": "system", "content": "You are a tool-calling agent."}, + {"role": "user", "content": "say hello world with python"}, + ], + "tools": [PYTHON_TOOL], + **kwargs, + }, timeout=TIMEOUT_HTTP_REQUEST) + choice = body["choices"][0] + tool_calls = choice["message"].get("tool_calls") + assert tool_calls and len(tool_calls) == 1, f'Expected 1 tool call in {choice["message"]}' + tool_call = tool_calls[0] + # assert choice["message"].get("content") in (None, ""), f'Expected no content in {choice["message"]}' + assert tool_call["function"]["name"] == PYTHON_TOOL["function"]["name"] + # assert len(tool_call.get("id", "")) > 0, f'Expected non empty tool call id in {tool_call}' + actual_arguments = json.loads(tool_call["function"]["arguments"]) + assert 'code' in actual_arguments, f"code not found in {json.dumps(actual_arguments)}" + code = actual_arguments["code"] + assert isinstance(code, str), f"Expected code to be a string, got {type(code)}: {json.dumps(code)}" + assert re.match(r'''print\(("[Hh]ello,? [Ww]orld!?"|'[Hh]ello,? [Ww]orld!?')\)''', re.sub(r'#.*\n?', '', code)), f'Expected hello world, got {code}' diff --git a/tools/server/tests/unit/test_tools_builtin.py b/tools/server/tests/unit/test_tools_builtin.py new file mode 100644 index 0000000000000000000000000000000000000000..a69052c6d72dbcb070cb91b9a40e783f7e044b19 --- /dev/null +++ b/tools/server/tests/unit/test_tools_builtin.py @@ -0,0 +1,414 @@ +import os +import shutil +import subprocess + +import pytest +from utils import * + +server: ServerProcess + +# project root, used as the search directory for grep_search/file_glob_search +PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", "..")) + +# marker for the grep_search test to find in this file +GREP_MARKER = "llama_cpp_test_tools_builtin_marker_grep_search" + +# image the container runtime tests run their shell in +CONTAINER_IMAGE = "busybox" + + +@pytest.fixture(autouse=True) +def create_server(): + global server + server = ServerPreset.router() + server.server_tools = "all" + + +def call_tool(name: str, params: dict, headers: dict | None = None) -> dict: + res = server.make_request("POST", "/tools", data={"tool": name, "params": params}, headers=headers) + assert res.status_code == 200, res.body + assert "error" not in res.body, res.body + return res.body + + +def call_tool_expect_error(name: str, params: dict) -> str: + res = server.make_request("POST", "/tools", data={"tool": name, "params": params}) + assert res.status_code == 200, res.body + assert "error" in res.body, res.body + return res.body["error"] + + +def test_tools_builtin_grep_search(): + global server + server.start() + + res = call_tool("grep_search", { + "path": PROJECT_ROOT, + "pattern": GREP_MARKER, + "include": "test_tools_builtin.py", # bare pattern -> matches basename at any depth + }) + text = res["plain_text_response"] + assert "test_tools_builtin.py" in text + assert GREP_MARKER in text + assert "Total matches: 1" in text + + +def test_tools_builtin_read_file(): + global server + server.start() + + this_file = os.path.join(PROJECT_ROOT, "tools", "server", "tests", "unit", "test_tools_builtin.py") + res = call_tool("read_file", {"path": this_file}) + text = res["plain_text_response"] + assert GREP_MARKER in text + assert "def test_tools_builtin_read_file" in text + + +def test_tools_builtin_write_then_edit_file(): + global server + server.start() + + log_path = os.path.join(PROJECT_ROOT, "test.log") + try: + write_res = call_tool("write_file", {"path": log_path, "content": "line1\nline2\nline3\n"}) + assert write_res["result"] == "file written successfully" + + read_before = call_tool("read_file", {"path": log_path}) + assert read_before["plain_text_response"] == "line1\nline2\nline3\n" + + edit_res = call_tool("edit_file", { + "path": log_path, + "edits": [ + {"old_text": "line2", "new_text": "line2-edited"}, + {"old_text": "line3\n", "new_text": "line3\nline4\n"}, + ], + }) + assert edit_res["result"] == "file edited successfully" + assert edit_res["edits_applied"] == 2 + + read_after = call_tool("read_file", {"path": log_path}) + assert read_after["plain_text_response"] == "line1\nline2-edited\nline3\nline4\n" + finally: + if os.path.exists(log_path): + os.remove(log_path) + + +def test_tools_builtin_edit_file_rejects_non_unique_old_text(): + global server + server.start() + + log_path = os.path.join(PROJECT_ROOT, "test.log") + try: + call_tool("write_file", {"path": log_path, "content": "dup\ndup\n"}) + err = call_tool_expect_error("edit_file", { + "path": log_path, + "edits": [{"old_text": "dup", "new_text": "changed"}], + }) + assert "unique" in err + finally: + if os.path.exists(log_path): + os.remove(log_path) + + +def test_tools_builtin_exec_shell_command_stream(): + global server + server.start() + + events = list(server.make_stream_request("POST", "/tools", data={ + "tool": "exec_shell_command", + "params": {"command": "echo hello"}, + "stream": True, + })) + + assert len(events) >= 2 + assert events[-1]["done"] is True + assert not events[-1].get("error") + chunks = "".join(e["chunk"] for e in events[:-1]) + assert "hello" in chunks + assert "[exit code: 0]" in chunks + + +def test_tools_builtin_cwd_header(): + global server + server.start() + + cwd_dir = os.path.join(PROJECT_ROOT, "tools", "server", "tests", "unit") + headers = {"x-tool-cwd": cwd_dir} + + res = call_tool("read_file", {"path": "test_tools_builtin.py"}, headers=headers) + assert GREP_MARKER in res["plain_text_response"] + + # exec_shell_command should also run with that directory as its working directory: + # writing to a relative filename must land inside cwd_dir + marker_name = "llama_cpp_test_tools_builtin_cwd_marker.txt" + marker_path = os.path.join(cwd_dir, marker_name) + try: + command = f"echo hello > {marker_name}" + call_tool("exec_shell_command", {"command": command}, headers=headers) + assert os.path.exists(marker_path) + finally: + if os.path.exists(marker_path): + os.remove(marker_path) + + +def _container_engine_unavailable_reason(engine: str) -> str | None: + """None if `engine` can run the image these tests use, otherwise the reason it can't.""" + engine_bin = shutil.which(engine) + if engine_bin is None: + return f"{engine} is not installed" + try: + # a daemon that answers `info` still cannot run a linux image when it serves windows + # containers, so probe the image itself, which also pulls it before the tests + subprocess.run([engine_bin, "run", "--rm", CONTAINER_IMAGE, "true"], capture_output=True, timeout=60, check=True) + except Exception as e: + return f"{engine} cannot run {CONTAINER_IMAGE}: {e}" + return None + + +@pytest.fixture(params=["docker", "podman"]) +def container_engine(request): + engine = request.param + reason = _container_engine_unavailable_reason(engine) + if reason is not None: + pytest.skip(reason) # ty: ignore[too-many-positional-arguments, invalid-argument-type] + return engine + + +@pytest.fixture +def container_id(container_engine: str): + proc = subprocess.run( + [container_engine, "run", "-d", "--rm", CONTAINER_IMAGE, "sleep", "300"], + capture_output=True, text=True, + ) + if proc.returncode != 0: + pytest.skip(f"failed to start {container_engine} container: {proc.stderr.strip()}") # ty: ignore[too-many-positional-arguments, invalid-argument-type] + + cid = proc.stdout.strip() + try: + yield cid + finally: + subprocess.run([container_engine, "rm", "-f", cid], capture_output=True) + + +def test_tools_builtin_runtime_header(container_engine: str, container_id: str): + global server + server.start() + + headers = {"x-tool-runtime": f"{container_engine}-container:{container_id}", "x-tool-cwd": "/tmp"} + + write_res = call_tool("write_file", {"path": "test.log", "content": "hello container\n"}, headers=headers) + assert write_res["result"] == "file written successfully" + + read_res = call_tool("read_file", {"path": "test.log"}, headers=headers) + assert read_res["plain_text_response"] == "hello container\n" + + exec_res = call_tool("exec_shell_command", {"command": "cat test.log"}, headers=headers) + assert "hello container" in exec_res["plain_text_response"] + + +def test_tools_builtin_runtime_header_unknown_scheme(): + global server + server.start() + + # an unknown runtime must fail, never silently fall back to running on the host + res = server.make_request("POST", "/tools", + data={"tool": "exec_shell_command", "params": {"command": "echo hi"}}, + headers={"x-tool-runtime": "fake:does-not-exist"}) + assert res.status_code == 500, res.body + assert "unknown tool runtime" in str(res.body) + + +def test_tools_builtin_runtime_header_rejects_ssh_option_injection(): + global server + server.start() + + # ssh reads options from its argv, so a target starting with '-' must be rejected + res = server.make_request("POST", "/tools", + data={"tool": "exec_shell_command", "params": {"command": "echo hi"}}, + headers={"x-tool-runtime": "ssh:-oProxyCommand=touch /tmp/pwned"}) + assert res.status_code == 500, res.body + assert "invalid ssh target" in str(res.body) + + +@pytest.mark.parametrize("engine", ["docker", "podman"]) +def test_tools_builtin_runtime_header_rejects_container_option_injection(engine: str): + global server + server.start() + + # the container id lands on the ` exec` command line, so an id that looks + # like an option must be rejected + res = server.make_request("POST", "/tools", + data={"tool": "exec_shell_command", "params": {"command": "echo hi"}}, + headers={"x-tool-runtime": f"{engine}-container:--privileged"}) + assert res.status_code == 500, res.body + assert "invalid container id" in str(res.body) + + +def test_tools_builtin_docker_runtime_cleans_up_spawned_container(): + # docker-only: this reads the container hostname to get the spawned id, which only docker + # sets to the short id. podman is covered by the attach path above + reason = _container_engine_unavailable_reason("docker") + if reason is not None: + pytest.skip(reason) # ty: ignore[too-many-positional-arguments, invalid-argument-type] + + global server + server.server_tools_runtime = f"docker:{CONTAINER_IMAGE}" + server.start() + + # exec_shell_command runs inside the container spawned for --tools-runtime; docker sets + # the container's hostname to its own short id, so this also tells us which one to check + res = call_tool("exec_shell_command", {"command": "hostname"}) + container_id = res["plain_text_response"].splitlines()[0].strip() + assert len(container_id) >= 8, res + + running = subprocess.run( + ["docker", "inspect", "-f", "{{.State.Running}}", container_id], + capture_output=True, text=True, + ) + assert running.returncode == 0 and running.stdout.strip() == "true", running.stderr + + server.stop() + + # a clean server shutdown must stop and remove the container it spawned (it runs with --rm), + # not leave it behind as an abandoned child + leftover = subprocess.run(["docker", "inspect", container_id], capture_output=True, text=True) + assert leftover.returncode != 0, f"container {container_id} was not cleaned up after server exit" + + +def test_tools_builtin_edit_file_rejects_overlapping_edits(): + global server + server.start() + + log_path = os.path.join(PROJECT_ROOT, "test.log") + try: + call_tool("write_file", {"path": log_path, "content": "line1\nline2\n"}) + err = call_tool_expect_error("edit_file", { + "path": log_path, + "edits": [ + {"old_text": "line1\nline2", "new_text": "a"}, + {"old_text": "line2", "new_text": "b"}, + ], + }) + assert "overlap" in err + finally: + if os.path.exists(log_path): + os.remove(log_path) + + +def test_tools_builtin_file_glob_search_type_dir(tmp_path): + global server + server.start() + + (tmp_path / "project-alpha" / "src").mkdir(parents=True) + (tmp_path / "project-alpha" / "README.md").write_text("alpha") + (tmp_path / "project-alpha" / "src" / "main.cpp").write_text("int main() {}") + (tmp_path / "project-beta").mkdir() + (tmp_path / "project-beta" / "notes.txt").write_text("beta") + + res = call_tool("file_glob_search", {"path": str(tmp_path), "type": "dir"}) + text = res["plain_text_response"] + assert "project-alpha/" in text + assert "project-beta/" in text + assert "project-alpha/src/" in text + assert "README.md" not in text + types = {e["path"]: e["type"] for e in res["entries"]} + assert types["project-alpha"] == "dir" + assert types["project-alpha/src"] == "dir" + + res_all = call_tool("file_glob_search", {"path": str(tmp_path), "type": "all", "include": "*proj*"}) + paths = [e["path"] for e in res_all["entries"]] + assert "project-alpha" in paths + assert "project-beta" in paths + + +def test_tools_builtin_file_glob_search_max_depth_and_limit(tmp_path): + global server + server.start() + + (tmp_path / "a" / "b" / "c").mkdir(parents=True) + (tmp_path / "top.txt").write_text("top") + (tmp_path / "a" / "mid.txt").write_text("mid") + (tmp_path / "a" / "b" / "deep.txt").write_text("deep") + + res = call_tool("file_glob_search", {"path": str(tmp_path), "max_depth": 1}) + assert "top.txt" in res["plain_text_response"] + assert "mid.txt" not in res["plain_text_response"] + + res = call_tool("file_glob_search", {"path": str(tmp_path), "max_depth": 2}) + assert "mid.txt" in res["plain_text_response"] + assert "deep.txt" not in res["plain_text_response"] + + res = call_tool("file_glob_search", {"path": str(tmp_path), "limit": 1}) + assert len(res["entries"]) == 1 + assert "Total matches: 3" in res["plain_text_response"] + + +def test_tools_builtin_file_glob_search_junk_dirs(tmp_path): + global server + server.start() + + (tmp_path / "build" / "nested").mkdir(parents=True) + (tmp_path / "build" / "artifact.txt").write_text("built") + (tmp_path / "src").mkdir() + (tmp_path / "src" / "main.cpp").write_text("int main() {}") + + # a junk directory stays selectable as a working directory + res = call_tool("file_glob_search", {"path": str(tmp_path), "type": "dir", "max_depth": 1}) + assert "build" in [e["path"] for e in res["entries"]] + + # but it is never walked, so nothing inside it shows up + res = call_tool("file_glob_search", {"path": str(tmp_path), "type": "all"}) + paths = [e["path"] for e in res["entries"]] + assert "src/main.cpp" in paths + assert "build/artifact.txt" not in paths + assert "build/nested" not in paths + + +def test_tools_builtin_file_glob_search_rejects_invalid_type(tmp_path): + global server + server.start() + + err = call_tool_expect_error("file_glob_search", {"path": str(tmp_path), "type": "bogus"}) + assert "invalid type" in err + + +def test_tools_builtin_cwd_header_overrides_model_param(tmp_path): + global server + server.start() + + workdir = tmp_path / "workdir" + workdir.mkdir() + (workdir / "marker.txt").write_text("marker") + + # a model-provided "cwd" in the params is overridden by the x-tool-cwd header + res = call_tool("read_file", {"path": "marker.txt", "cwd": "/definitely/not/a/real/path"}, + headers={"x-tool-cwd": str(workdir)}) + assert "marker" in res["plain_text_response"] + + +def test_tools_builtin_cwd_relative_paths(tmp_path): + global server + server.start() + + workdir = tmp_path / "workdir" + workdir.mkdir() + (workdir / "rel.txt").write_text("relative-content") + + headers = {"x-tool-cwd": str(workdir)} + + # relative paths in file tools resolve against the header cwd + res = call_tool("read_file", {"path": "rel.txt"}, headers=headers) + assert "relative-content" in res["plain_text_response"] + + res = call_tool("write_file", {"path": "sub/out.txt", "content": "written"}, headers=headers) + assert (workdir / "sub" / "out.txt").read_text() == "written" + + res = call_tool("file_glob_search", {"path": ".", "include": "*.txt"}, headers=headers) + assert "rel.txt" in res["plain_text_response"] + + # absolute paths are unaffected by the cwd + other = tmp_path / "other" + other.mkdir() + (other / "abs.txt").write_text("absolute-content") + res = call_tool("read_file", {"path": str(other / "abs.txt")}, headers=headers) + assert "absolute-content" in res["plain_text_response"] diff --git a/tools/server/tests/unit/test_vision_api.py b/tools/server/tests/unit/test_vision_api.py new file mode 100644 index 0000000000000000000000000000000000000000..d74cc3a43edc3781167d43f2acf177da82efddeb --- /dev/null +++ b/tools/server/tests/unit/test_vision_api.py @@ -0,0 +1,180 @@ +import pytest +from utils import * +import base64 +import requests + +server: ServerProcess + +def get_img_url(id: str) -> str: + IMG_URL_0 = "https://huggingface.co/ggml-org/tinygemma3-GGUF/resolve/main/test/11_truck.png" + IMG_URL_1 = "https://huggingface.co/ggml-org/tinygemma3-GGUF/resolve/main/test/91_cat.png" + if id == "IMG_URL_0": + return IMG_URL_0 + elif id == "IMG_URL_1": + return IMG_URL_1 + elif id == "IMG_BASE64_URI_0": + response = requests.get(IMG_URL_0) + response.raise_for_status() # Raise an exception for bad status codes + return "data:image/png;base64," + base64.b64encode(response.content).decode("utf-8") + elif id == "IMG_BASE64_0": + response = requests.get(IMG_URL_0) + response.raise_for_status() # Raise an exception for bad status codes + return base64.b64encode(response.content).decode("utf-8") + elif id == "IMG_BASE64_URI_1": + response = requests.get(IMG_URL_1) + response.raise_for_status() # Raise an exception for bad status codes + return "data:image/png;base64," + base64.b64encode(response.content).decode("utf-8") + elif id == "IMG_BASE64_1": + response = requests.get(IMG_URL_1) + response.raise_for_status() # Raise an exception for bad status codes + return base64.b64encode(response.content).decode("utf-8") + else: + return id + +JSON_MULTIMODAL_KEY = "multimodal_data" +JSON_PROMPT_STRING_KEY = "prompt_string" + +@pytest.fixture(autouse=True) +def create_server(): + global server + os.environ['LLAMA_MEDIA_MARKER'] = '<__media__>' + server = ServerPreset.tinygemma3() + +def test_models_supports_multimodal_capability(): + global server + server.start() + res = server.make_request("GET", "/models", data={}) + assert res.status_code == 200 + model_info = res.body["models"][0] + print(model_info) + assert "completion" in model_info["capabilities"] + assert "multimodal" in model_info["capabilities"] + +def test_v1_models_supports_multimodal_capability(): + global server + server.start() + res = server.make_request("GET", "/v1/models", data={}) + assert res.status_code == 200 + model_info = res.body["models"][0] + print(model_info) + assert "completion" in model_info["capabilities"] + assert "multimodal" in model_info["capabilities"] + +@pytest.mark.parametrize( + "prompt, image_url, success, re_content", + [ + # test model is trained on CIFAR-10, but it's quite dumb due to small size + ("What is this:\n", "IMG_URL_0", True, "(cat)+"), + ("What is this:\n", "IMG_BASE64_URI_0", True, "(cat)+"), + ("What is this:\n", "IMG_URL_1", True, "(frog)+"), + ("Test test\n", "IMG_URL_1", True, "(frog)+"), # test invalidate cache + ("What is this:\n", "malformed", False, None), + ("What is this:\n", "https://google.com/404", False, None), # non-existent image + ("What is this:\n", "https://ggml.ai", False, None), # non-image data + # TODO @ngxson : test with multiple images, no images and with audio + ] +) +def test_vision_chat_completion(prompt, image_url, success, re_content): + global server + server.start() + res = server.make_request("POST", "/chat/completions", data={ + "temperature": 0.0, + "top_k": 1, + "messages": [ + {"role": "user", "content": [ + {"type": "text", "text": prompt}, + {"type": "image_url", "image_url": { + "url": get_img_url(image_url), + }}, + ]}, + ], + }) + if success: + assert res.status_code == 200 + choice = res.body["choices"][0] + assert "assistant" == choice["message"]["role"] + assert match_regex(re_content, choice["message"]["content"]) + else: + assert res.status_code != 200 + + +def test_vision_chat_completion_token_count(): + global server + server.start() + res = server.make_request("POST", "/chat/completions/input_tokens", data={ + "temperature": 0.0, + "top_k": 1, + "messages": [ + {"role": "user", "content": [ + {"type": "text", "text": "What is this:"}, + {"type": "image_url", "image_url": { + "url": get_img_url("IMG_URL_0"), + }}, + ]}, + ], + }) + assert res.status_code == 200 + assert res.body["input_tokens"] > 10 + + +@pytest.mark.parametrize( + "prompt, image_data, success, re_content", + [ + # test model is trained on CIFAR-10, but it's quite dumb due to small size + ("What is this: <__media__>\n", "IMG_BASE64_0", True, "(cat)+"), + ("What is this: <__media__>\n", "IMG_BASE64_1", True, "(frog)+"), + ("What is this: <__media__>\n", "malformed", False, None), # non-image data + ("What is this:\n", "", False, None), # empty string + ] +) +def test_vision_completion(prompt, image_data, success, re_content): + global server + server.start() + res = server.make_request("POST", "/completions", data={ + "temperature": 0.0, + "top_k": 1, + "prompt": { + JSON_PROMPT_STRING_KEY: prompt, + JSON_MULTIMODAL_KEY: [ get_img_url(image_data) ], + }, + }) + if success: + assert res.status_code == 200 + content = res.body["content"] + assert match_regex(re_content, content) + else: + assert res.status_code != 200 + + +@pytest.mark.parametrize( + "prompt, image_data, success", + [ + # test model is trained on CIFAR-10, but it's quite dumb due to small size + ("What is this: <__media__>\n", "IMG_BASE64_0", True), + ("What is this: <__media__>\n", "IMG_BASE64_1", True), + ("What is this: <__media__>\n", "malformed", False), # non-image data + ("What is this:\n", "base64", False), # non-image data + ] +) +def test_vision_embeddings(prompt, image_data, success): + global server + server.server_embeddings = True + server.n_batch = 512 + server.start() + image_data = get_img_url(image_data) + res = server.make_request("POST", "/embeddings", data={ + "content": [ + { JSON_PROMPT_STRING_KEY: prompt, JSON_MULTIMODAL_KEY: [ image_data ] }, + { JSON_PROMPT_STRING_KEY: prompt, JSON_MULTIMODAL_KEY: [ image_data ] }, + { JSON_PROMPT_STRING_KEY: prompt, }, + ], + }) + if success: + assert res.status_code == 200 + content = res.body + # Ensure embeddings are stable when multimodal. + assert content[0]['embedding'] == content[1]['embedding'] + # Ensure embeddings without multimodal but same prompt do not match multimodal embeddings. + assert content[0]['embedding'] != content[2]['embedding'] + else: + assert res.status_code != 200 diff --git a/tools/server/tests/utils.py b/tools/server/tests/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..fffe07a67116f43c9beddb854db449ef4024b9bd --- /dev/null +++ b/tools/server/tests/utils.py @@ -0,0 +1,712 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- + +# type: ignore[reportUnusedImport] + +import subprocess +import os + +TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tmp") +import re +import json +from json import JSONDecodeError +import sys +import requests +import time +from concurrent.futures import ThreadPoolExecutor, as_completed +from typing import ( + Any, + Callable, + ContextManager, + Iterable, + Iterator, + List, + Literal, + Tuple, + Set, +) +from re import RegexFlag +import wget + + +DEFAULT_HTTP_TIMEOUT = 60 + +# per-request timeout, a hung server fails the test instead of stalling the CI for hours +DEFAULT_REQUEST_TIMEOUT = 600 + + +class ServerResponse: + headers: dict + status_code: int + body: dict | Any + + +class ServerError(Exception): + def __init__(self, code, body): + self.code = code + self.body = body + + +class ServerProcess: + # default options + debug: bool = False + server_port: int = 8080 + server_host: str = "127.0.0.1" + model_hf_repo: str | None = "ggml-org/models" + model_hf_file: str | None = "tinyllamas/stories260K.gguf" + model_alias: str = "tinyllama-2" + temperature: float = 0.8 + seed: int = 42 + offline: bool = False + + # custom options + model_alias: str | None = None + model_tags: str | None = None + model_url: str | None = None + model_file: str | None = None + model_draft: str | None = None + n_threads: int | None = None + n_gpu_layer: int | None = None + n_batch: int | None = None + n_ubatch: int | None = None + n_ctx: int | None = None + n_ga: int | None = None + n_ga_w: int | None = None + n_predict: int | None = None + n_prompts: int | None = 0 + slot_save_path: str | None = None + id_slot: int | None = None + cache_prompt: bool | None = None + n_slots: int | None = None + ctk: str | None = None + ctv: str | None = None + fa: str | None = None + server_continuous_batching: bool | None = False + server_embeddings: bool | None = False + server_reranking: bool | None = False + server_metrics: bool | None = False + kv_unified: bool | None = False + server_slots: bool | None = False + pooling: str | None = None + api_key: str | None = None + models_dir: str | None = None + models_max: int | None = None + models_preset: str | None = None + no_models_autoload: bool | None = None + lora_files: List[str] | None = None + enable_ctx_shift: int | None = False + spec_type: str | None = None + spec_draft_n_min: int | None = None + spec_draft_n_max: int | None = None + no_ui: bool | None = None + jinja: bool | None = None + reasoning_format: Literal['deepseek', 'none', 'nothink'] | None = None + reasoning: Literal['on', 'off', 'auto'] | None = None + chat_template: str | None = None + chat_template_file: str | None = None + server_path: str | None = None + mmproj_url: str | None = None + media_path: str | None = None + sleep_idle_seconds: int | None = None + cache_ram: int | None = None + no_cache_idle_slots: bool = False + log_path: str | None = None + ui_mcp_proxy: bool = False + backend_sampling: bool = False + gcp_compat: bool = False + server_tools: str | None = None + server_tools_runtime: str | None = None + mcp_servers_config: str | None = None + mcp_servers_json: str | None = None + cors_origins: str | None = None + + # session variables + process: subprocess.Popen | None = None + + def __init__(self): + if "N_GPU_LAYERS" in os.environ: + self.n_gpu_layer = int(os.environ["N_GPU_LAYERS"]) + if "DEBUG" in os.environ: + self.debug = True + if "PORT" in os.environ: + self.server_port = int(os.environ["PORT"]) + self.external_server = "DEBUG_EXTERNAL" in os.environ + + def start(self, timeout_seconds: int = DEFAULT_HTTP_TIMEOUT) -> None: + env = { + **os.environ, + "LLAMA_SERVER_DEBUG_FAKE_TIMING": "1", + } + if "LLAMA_CACHE" not in os.environ: + env["LLAMA_CACHE"] = "tmp" + if self.external_server: + print(f"[external_server]: Assuming external server running on {self.server_host}:{self.server_port}") + return + if self.server_path is not None: + server_path = self.server_path + elif "LLAMA_SERVER_BIN_PATH" in os.environ: + server_path = os.environ["LLAMA_SERVER_BIN_PATH"] + elif os.name == "nt": + server_path = "../../../build/bin/Release/llama-server.exe" + else: + server_path = "../../../build/bin/llama-server" + server_args = [ + "--host", + self.server_host, + "--port", + self.server_port, + "--temp", + self.temperature, + "--seed", + self.seed, + ] + if self.offline: + server_args.append("--offline") + if self.model_file: + server_args.extend(["--model", self.model_file]) + if self.model_url: + server_args.extend(["--model-url", self.model_url]) + if self.model_draft: + server_args.extend(["--model-draft", self.model_draft]) + if self.model_hf_repo: + server_args.extend(["--hf-repo", self.model_hf_repo]) + if self.model_hf_file: + server_args.extend(["--hf-file", self.model_hf_file]) + if self.models_dir: + server_args.extend(["--models-dir", self.models_dir]) + if self.models_max is not None: + server_args.extend(["--models-max", self.models_max]) + if self.models_preset: + server_args.extend(["--models-preset", self.models_preset]) + if self.cors_origins: + server_args.extend(["--cors-origins", self.cors_origins]) + if self.n_batch: + server_args.extend(["--batch-size", self.n_batch]) + if self.n_ubatch: + server_args.extend(["--ubatch-size", self.n_ubatch]) + if self.n_threads: + server_args.extend(["--threads", self.n_threads]) + if self.n_gpu_layer: + server_args.extend(["--n-gpu-layers", self.n_gpu_layer]) + if self.server_continuous_batching: + server_args.append("--cont-batching") + if self.server_embeddings: + server_args.append("--embedding") + if self.server_reranking: + server_args.append("--reranking") + if self.server_metrics: + server_args.append("--metrics") + if self.kv_unified: + server_args.append("--kv-unified") + if self.server_slots: + server_args.append("--slots") + else: + server_args.append("--no-slots") + if self.pooling: + server_args.extend(["--pooling", self.pooling]) + if self.model_alias: + server_args.extend(["--alias", self.model_alias]) + if self.model_tags: + server_args.extend(["--tags", self.model_tags]) + if self.n_ctx: + server_args.extend(["--ctx-size", self.n_ctx]) + if self.n_slots: + server_args.extend(["--parallel", self.n_slots]) + if self.ctk: + server_args.extend(["-ctk", self.ctk]) + if self.ctv: + server_args.extend(["-ctv", self.ctv]) + if self.fa is not None: + server_args.extend(["-fa", self.fa]) + if self.n_predict: + server_args.extend(["--n-predict", self.n_predict]) + if self.slot_save_path: + server_args.extend(["--slot-save-path", self.slot_save_path]) + if self.n_ga: + server_args.extend(["--grp-attn-n", self.n_ga]) + if self.n_ga_w: + server_args.extend(["--grp-attn-w", self.n_ga_w]) + if self.debug: + server_args.append("--verbose") + if self.lora_files: + for lora_file in self.lora_files: + server_args.extend(["--lora", lora_file]) + if self.enable_ctx_shift: + server_args.append("--context-shift") + if self.spec_type: + server_args.extend(["--spec-type", self.spec_type]) + if self.api_key: + server_args.extend(["--api-key", self.api_key]) + if self.spec_draft_n_max: + server_args.extend(["--spec-draft-n-max", self.spec_draft_n_max]) + if self.spec_draft_n_min: + server_args.extend(["--spec-draft-n-min", self.spec_draft_n_min]) + if self.no_ui: + server_args.append("--no-ui") + if self.no_models_autoload: + server_args.append("--no-models-autoload") + if self.jinja: + server_args.append("--jinja") + else: + server_args.append("--no-jinja") + if self.reasoning_format is not None: + server_args.extend(("--reasoning-format", self.reasoning_format)) + if self.reasoning is not None: + server_args.extend(("--reasoning", self.reasoning)) + if self.chat_template: + server_args.extend(["--chat-template", self.chat_template]) + if self.chat_template_file: + server_args.extend(["--chat-template-file", self.chat_template_file]) + if self.mmproj_url: + server_args.extend(["--mmproj-url", self.mmproj_url]) + if self.media_path: + server_args.extend(["--media-path", self.media_path]) + if self.sleep_idle_seconds is not None: + server_args.extend(["--sleep-idle-seconds", self.sleep_idle_seconds]) + if self.cache_ram is not None: + server_args.extend(["--cache-ram", self.cache_ram]) + if self.no_cache_idle_slots: + server_args.append("--no-cache-idle-slots") + if self.ui_mcp_proxy: + server_args.append("--ui-mcp-proxy") + if self.server_tools: + server_args.extend(["--tools", self.server_tools]) + if self.server_tools_runtime: + server_args.extend(["--tools-runtime", self.server_tools_runtime]) + if self.mcp_servers_config: + server_args.extend(["--mcp-servers-config", self.mcp_servers_config]) + if self.mcp_servers_json: + server_args.extend(["--mcp-servers-json", self.mcp_servers_json]) + if self.backend_sampling: + server_args.append("--backend_sampling") + if self.gcp_compat: + env["AIP_MODE"] = "PREDICTION" + + args = [str(arg) for arg in [server_path, *server_args]] + print(f"tests: starting server with: {' '.join(args)}") + + flags = 0 + if "nt" == os.name: + flags |= subprocess.DETACHED_PROCESS + flags |= subprocess.CREATE_NEW_PROCESS_GROUP + flags |= subprocess.CREATE_NO_WINDOW + + if self.log_path: + self._log = open(self.log_path, "w") + else: + self._log = sys.stdout + + self.process = subprocess.Popen( + [str(arg) for arg in [server_path, *server_args]], + creationflags=flags, + stdout=self._log, + stderr=self._log if self._log != sys.stdout else sys.stdout, + env=env, + ) + server_instances.add(self) + + print(f"server pid={self.process.pid}, pytest pid={os.getpid()}") + + # wait for server to start + start_time = time.time() + last_print_time = start_time + while time.time() - start_time < timeout_seconds: + try: + response = self.make_request("GET", "/health", headers={ + "Authorization": f"Bearer {self.api_key}" if self.api_key else None + }) + if response.status_code == 200: + self.ready = True + return # server is ready + except Exception as e: + pass + # Check if process died + if self.process.poll() is not None: + raise RuntimeError(f"Server process died with return code {self.process.returncode}") + + if time.time() - last_print_time >= 1.0: + print(f"Waiting for server to start...") + last_print_time = time.time() + time.sleep(0.01) + raise TimeoutError(f"Server did not start within {timeout_seconds} seconds") + + def stop(self) -> None: + if self.external_server: + print("[external_server]: Not stopping external server") + return + if self in server_instances: + server_instances.remove(self) + if self.process: + print(f"Stopping server with pid={self.process.pid}") + self.process.terminate() + try: + self.process.wait(timeout=5) + except subprocess.TimeoutExpired: + print(f"Server pid={self.process.pid} did not terminate in time, killing") + self.process.kill() + self.process.wait(timeout=5) + except Exception as e: + print(f"Error waiting for server: {e}") + self.process = None + if hasattr(self, '_log') and self._log != sys.stdout: + self._log.close() + + def make_request( + self, + method: str, + path: str, + data: dict | Any | None = None, + headers: dict | None = None, + timeout: float | None = DEFAULT_REQUEST_TIMEOUT, + ) -> ServerResponse: + url = f"http://{self.server_host}:{self.server_port}{path}" + parse_body = False + if method == "GET": + response = requests.get(url, headers=headers, timeout=timeout) + parse_body = True + elif method == "POST": + response = requests.post(url, headers=headers, json=data, timeout=timeout) + parse_body = True + elif method == "DELETE": + response = requests.delete(url, headers=headers, timeout=timeout) + parse_body = True + elif method == "OPTIONS": + response = requests.options(url, headers=headers, timeout=timeout) + else: + raise ValueError(f"Unimplemented method: {method}") + result = ServerResponse() + result.headers = dict(response.headers) + result.status_code = response.status_code + if parse_body: + try: + result.body = response.json() + except (JSONDecodeError, requests.exceptions.JSONDecodeError): + result.body = response.text + else: + result.body = None + print("Response from server", json.dumps(result.body, indent=2)) + return result + + def make_stream_request( + self, + method: str, + path: str, + data: dict | None = None, + headers: dict | None = None, + ) -> Iterator[dict]: + url = f"http://{self.server_host}:{self.server_port}{path}" + if method == "POST": + response = requests.post(url, headers=headers, json=data, stream=True) + else: + raise ValueError(f"Unimplemented method: {method}") + if response.status_code != 200: + raise ServerError(response.status_code, response.json()) + for line_bytes in response.iter_lines(): + line = line_bytes.decode("utf-8") + if '[DONE]' in line: + break + elif line.startswith('data: '): + data = json.loads(line[6:]) + print("Partial response from server", json.dumps(data, indent=2)) + yield data + + def make_any_request( + self, + method: str, + path: str, + data: dict | None = None, + headers: dict | None = None, + timeout: float | None = DEFAULT_REQUEST_TIMEOUT, + ) -> dict: + stream = data.get('stream', False) + if stream: + content: list[str] = [] + reasoning_content: list[str] = [] + tool_calls: list[dict] = [] + finish_reason: Optional[str] = None + + content_parts = 0 + reasoning_content_parts = 0 + tool_call_parts = 0 + arguments_parts = 0 + + for chunk in self.make_stream_request(method, path, data, headers): + if chunk['choices']: + assert len(chunk['choices']) == 1, f'Expected 1 choice, got {len(chunk["choices"])}' + choice = chunk['choices'][0] + if choice['delta'].get('content') is not None: + assert len(choice['delta']['content']) > 0, f'Expected non empty content delta!' + content.append(choice['delta']['content']) + content_parts += 1 + if choice['delta'].get('reasoning_content') is not None: + assert len(choice['delta']['reasoning_content']) > 0, f'Expected non empty reasoning_content delta!' + reasoning_content.append(choice['delta']['reasoning_content']) + reasoning_content_parts += 1 + if choice['delta'].get('finish_reason') is not None: + finish_reason = choice['delta']['finish_reason'] + for tc in choice['delta'].get('tool_calls', []): + if 'function' not in tc: + raise ValueError(f"Expected function type, got {tc['type']}") + if tc['index'] >= len(tool_calls): + assert 'id' in tc + assert tc.get('type') == 'function' + assert 'function' in tc and 'name' in tc['function'] and len(tc['function']['name']) > 0, \ + f"Expected function call with name, got {tc.get('function')}" + tool_calls.append(dict( + id="", + type="function", + function=dict( + name="", + arguments="", + ) + )) + tool_call = tool_calls[tc['index']] + if tc.get('id') is not None: + tool_call['id'] = tc['id'] + fct = tc['function'] + assert 'id' not in fct, f"Function call should not have id: {fct}" + if fct.get('name') is not None: + tool_call['function']['name'] = tool_call['function'].get('name', '') + fct['name'] + if fct.get('arguments') is not None: + tool_call['function']['arguments'] += fct['arguments'] + arguments_parts += 1 + tool_call_parts += 1 + else: + # When `include_usage` is True (the default), we expect the last chunk of the stream + # immediately preceding the `data: [DONE]` message to contain a `choices` field with an empty array + # and a `usage` field containing the usage statistics (n.b., llama-server also returns `timings` in + # the last chunk) + assert 'usage' in chunk, f"Expected finish_reason in chunk: {chunk}" + assert 'timings' in chunk, f"Expected finish_reason in chunk: {chunk}" + print(f'Streamed response had {content_parts} content parts, {reasoning_content_parts} reasoning_content parts, {tool_call_parts} tool call parts incl. {arguments_parts} arguments parts') + result = dict( + choices=[ + dict( + index=0, + finish_reason=finish_reason, + message=dict( + role='assistant', + content=''.join(content) if content else None, + reasoning_content=''.join(reasoning_content) if reasoning_content else None, + tool_calls=tool_calls if tool_calls else None, + ), + ) + ], + ) + print("Final response from server", json.dumps(result, indent=2)) + return result + else: + response = self.make_request(method, path, data, headers, timeout=timeout) + assert response.status_code == 200, f"Server returned error: {response.status_code}" + return response.body + + + +server_instances: Set[ServerProcess] = set() + + +class ServerPreset: + @staticmethod + def load_all() -> None: + """ Load all server presets to ensure model files are cached. """ + servers: List[ServerProcess] = [ + method() + for name, method in ServerPreset.__dict__.items() + if callable(method) and name != "load_all" + ] + for server in servers: + server.offline = False + server.start() + server.stop() + + @staticmethod + def tinyllama2() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/test-model-stories260K" + server.model_hf_file = None + server.model_alias = "tinyllama-2" + server.n_ctx = 512 + server.n_batch = 32 + server.n_slots = 2 + server.n_predict = 64 + server.seed = 42 + return server + + @staticmethod + def bert_bge_small() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/models" + server.model_hf_file = "bert-bge-small/ggml-model-f16.gguf" + server.model_alias = "bert-bge-small" + server.n_ctx = 512 + server.n_batch = 128 + server.n_ubatch = 128 + server.n_slots = 2 + server.seed = 42 + server.server_embeddings = True + return server + + @staticmethod + def bert_bge_small_with_fa() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/models" + server.model_hf_file = "bert-bge-small/ggml-model-f16.gguf" + server.model_alias = "bert-bge-small" + server.n_ctx = 1024 + server.n_batch = 300 + server.n_ubatch = 300 + server.n_slots = 2 + server.fa = "on" + server.seed = 42 + server.server_embeddings = True + return server + + @staticmethod + def tinyllama_infill() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/test-model-stories260K-infill" + server.model_hf_file = None + server.model_alias = "tinyllama-infill" + server.n_ctx = 2048 + server.n_batch = 1024 + server.n_slots = 1 + server.n_predict = 64 + server.temperature = 0.0 + server.seed = 42 + return server + + @staticmethod + def stories15m_moe() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/stories15M_MOE" + server.model_hf_file = "stories15M_MOE-F16.gguf" + server.model_alias = "stories15m-moe" + server.n_ctx = 2048 + server.n_batch = 1024 + server.n_slots = 1 + server.n_predict = 64 + server.temperature = 0.0 + server.seed = 42 + return server + + @staticmethod + def jina_reranker_tiny() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + server.model_hf_repo = "ggml-org/models" + server.model_hf_file = "jina-reranker-v1-tiny-en/ggml-model-f16.gguf" + server.model_alias = "jina-reranker" + server.n_ctx = 512 + server.n_batch = 512 + server.n_slots = 1 + server.seed = 42 + server.server_reranking = True + return server + + @staticmethod + def tinygemma3() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + # mmproj is already provided by HF registry API + server.model_hf_file = None + server.model_hf_repo = "ggml-org/tinygemma3-GGUF:Q8_0" + server.model_alias = "tinygemma3" + server.n_ctx = 1024 + server.n_batch = 32 + server.n_slots = 2 + server.n_predict = 4 + server.seed = 42 + return server + + @staticmethod + def router() -> ServerProcess: + server = ServerProcess() + server.offline = True # will be downloaded by load_all() + # router server has no models + server.model_file = None + server.model_alias = None + server.model_hf_repo = None + server.model_hf_file = None + server.n_ctx = 1024 + server.n_batch = 16 + server.n_slots = 1 + server.n_predict = 16 + server.seed = 42 + return server + + +def parallel_function_calls(function_list: List[Tuple[Callable[..., Any], Tuple[Any, ...]]]) -> List[Any]: + """ + Run multiple functions in parallel and return results in the same order as calls. Equivalent to Promise.all in JS. + + Example usage: + + results = parallel_function_calls([ + (func1, (arg1, arg2)), + (func2, (arg3, arg4)), + ]) + """ + results = [None] * len(function_list) + exceptions = [] + + def worker(index, func, args): + try: + result = func(*args) + results[index] = result + except Exception as e: + exceptions.append((index, str(e))) + + with ThreadPoolExecutor() as executor: + futures = [] + for i, (func, args) in enumerate(function_list): + future = executor.submit(worker, i, func, args) + futures.append(future) + + # Wait for all futures to complete + for future in as_completed(futures): + pass + + # Check if there were any exceptions + if exceptions: + print("Exceptions occurred:") + for index, error in exceptions: + print(f"Function at index {index}: {error}") + + return results + + +def match_regex(regex: str, text: str) -> bool: + return ( + re.compile( + regex, flags=RegexFlag.IGNORECASE | RegexFlag.MULTILINE | RegexFlag.DOTALL + ).search(text) + is not None + ) + + +def download_file(url: str, output_file_path: str | None = None) -> str: + """ + Download a file from a URL to a local path. If the file already exists, it will not be downloaded again. + + output_file_path is the local path to save the downloaded file. If not provided, the file will be saved in the root directory. + + Returns the local path of the downloaded file. + """ + file_name = url.split('/').pop() + output_file = f'./tmp/{file_name}' if output_file_path is None else output_file_path + if not os.path.exists(output_file): + print(f"Downloading {url} to {output_file}") + wget.download(url, out=output_file) + print(f"Done downloading to {output_file}") + else: + print(f"File already exists at {output_file}") + return output_file + + +def is_slow_test_allowed(): + return os.environ.get("SLOW_TESTS") == "1" or os.environ.get("SLOW_TESTS") == "ON" diff --git a/tools/tokenize/CMakeLists.txt b/tools/tokenize/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..1e1836575854da3c0b5d34dd4ac7e7d6c31c2e86 --- /dev/null +++ b/tools/tokenize/CMakeLists.txt @@ -0,0 +1,7 @@ +set(TARGET llama-tokenize) +add_executable(${TARGET} tokenize.cpp) +if(LLAMA_TOOLS_INSTALL) + install(TARGETS ${TARGET} RUNTIME) +endif() +target_link_libraries(${TARGET} PRIVATE llama-common llama ${CMAKE_THREAD_LIBS_INIT}) +target_compile_features(${TARGET} PRIVATE cxx_std_17) diff --git a/tools/tokenize/tokenize.cpp b/tools/tokenize/tokenize.cpp new file mode 100644 index 0000000000000000000000000000000000000000..77b33c4a465779f75c06130939902c816d88aa6e --- /dev/null +++ b/tools/tokenize/tokenize.cpp @@ -0,0 +1,222 @@ +#include "arg.h" +#include "common.h" +#include "log.h" +#include "llama.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#include +#endif + +static void print_usage(int argc, char ** argv) { + (void) argc; + + LOG("\nexample usage:\n"); + LOG("\n %s -m your_model.gguf -p \"Hello world\"\n", argv[0]); + LOG("\n %s -m your_model.gguf -f prompt.txt --ids\n", argv[0]); + LOG("\n cat prompt.txt | %s -m your_model.gguf --stdin --show-count\n", argv[0]); + LOG("\n"); +} + +// +// Function: write_utf8_cstr_to_stdout(const char *) -> +// +// writes a string to standard output; taking into account that on Windows +// to display correctly you have to use special handling. Works even if the +// user has not set a unicode code page on a Windows cmd.exe. +// +// In case of invalid UTF-8, invalid_utf8 is set to true on Windows, and something +// a human-readable is written instead. +// +// On non-Windows systems, simply printfs() the string. +static void write_utf8_cstr_to_stdout(const char * str, bool & invalid_utf8) { + invalid_utf8 = false; + +#if defined(_WIN32) + // Are we in a console? + HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); + DWORD dwMode = 0; + + // According to Microsoft docs: + // "WriteConsole fails if it is used with a standard handle that is redirected to a file." + // Also according to the docs, you can use GetConsoleMode to check for that. + if (hConsole == INVALID_HANDLE_VALUE || !GetConsoleMode(hConsole, &dwMode)) { + printf("%s", str); + return; + } + + // MultiByteToWideChar reports an error if str is empty, don't report + // them as invalid_utf8. + if (*str == 0) { + return; + } + int length_needed = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, strlen(str), NULL, 0); + if (length_needed == 0) { + DWORD err = GetLastError(); + if (err == ERROR_NO_UNICODE_TRANSLATION) { + invalid_utf8 = true; + int len = strlen(str); + printf("<"); + for (int i = 0; i < len; ++i) { + if (i > 0) { + printf(" "); + } + printf("%02x", (uint8_t) str[i]); + } + printf(">"); + return; + } + GGML_ABORT("MultiByteToWideChar() failed in an unexpected way."); + } + + LPWSTR wstr = (LPWSTR) calloc(length_needed+1, sizeof(*wstr)); + GGML_ASSERT(wstr); + + MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), wstr, length_needed); + WriteConsoleW(hConsole, wstr, length_needed, NULL, NULL); + + free(wstr); +#else + // TODO: reporting invalid_utf8 would be useful on non-Windows too. + // printf will silently just write bad unicode. + printf("%s", str); +#endif +} + +int main(int argc, char ** argv) { + std::setlocale(LC_NUMERIC, "C"); + + common_params params; + + common_init(); + + if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_TOKENIZE, print_usage)) { + return 1; + } + + // -f and -p both land in params.prompt; -f also sets prompt_file. -f and -p + // resolve like the other tools (no mutual exclusion), --stdin takes precedence. + const bool use_stdin = params.tokenize_stdin; + const bool use_file = !params.prompt_file.empty(); + + // must have some prompt + if (!use_stdin && !use_file && params.prompt.empty()) { + LOG_ERR("error: must specify one of: --stdin, --file or --prompt\n"); + return 1; + } + + std::string prompt; + if (use_file) { + // read the file verbatim: common's -f handler strips a single trailing + // newline, but for a tokenizer the input bytes must be preserved exactly + // (a trailing newline is itself a token). escapes are applied locally + // to match the behavior of -p/--prompt and --stdin. + std::ifstream in(params.prompt_file, std::ios::binary); + if (!in) { + LOG_ERR("error: could not open file '%s' for reading\n", params.prompt_file.c_str()); + return 1; + } + std::stringstream ss; + ss << in.rdbuf(); + prompt = ss.str(); + if (params.escape) { + string_process_escapes(prompt); + } + } else if (!use_stdin) { + // -p/--prompt is already escape-processed by common_params_parse() + // (controlled by --escape/--no-escape), so use it verbatim here. + prompt = params.prompt; + } + // else: we read stdin *after* loading the model (early exit if the + // model cannot be loaded, which is a nicer user experience) + + llama_backend_init(); + + // load only the vocabulary (no weights), since tokenizing does not need them + llama_model_params model_params = llama_model_default_params(); + model_params.vocab_only = true; + llama_model * model = llama_model_load_from_file(params.model.path.c_str(), model_params); + if (!model) { + LOG_ERR("error: could not load model from file '%s'.\n", params.model.path.c_str()); + return 1; + } + + const llama_vocab * vocab = llama_model_get_vocab(model); + + llama_context_params ctx_params = llama_context_default_params(); + llama_context * ctx = llama_init_from_model(model, ctx_params); + if (!ctx) { + LOG_ERR("error: could not create context.\n"); + return 1; + } + + // read entire prompt from stdin? + if (params.tokenize_stdin) { + std::stringstream stdin_buffer; + stdin_buffer << std::cin.rdbuf(); + if (std::cin.fail()) { + LOG_ERR("error: could not read the entire standard input.\n"); + return 1; + } + + prompt = stdin_buffer.str(); + + // stdin is not seen by common_params_parse(), so apply escape handling + // here to match the behavior of -p/--prompt and -f/--file. + if (params.escape) { + string_process_escapes(prompt); + } + } + + const bool model_wants_add_bos = llama_vocab_get_add_bos(vocab); + const bool add_bos = model_wants_add_bos && !params.tokenize_no_bos; + const bool parse_special = params.parse_special; + + std::vector tokens; + tokens = common_tokenize(vocab, prompt, add_bos, parse_special); + + if (params.tokenize_ids) { + printf("["); + } + + for (int i = 0; i < (int) tokens.size(); i++) { + if (params.tokenize_ids) { + if (i > 0) { + printf(", "); + } + printf("%d", tokens[i]); + } else { + bool invalid_utf8 = false; + printf("%6d -> '", tokens[i]); + write_utf8_cstr_to_stdout(common_token_to_piece(ctx, tokens[i]).c_str(), invalid_utf8); + if (invalid_utf8) { + printf("' (utf-8 decode failure)\n"); + } else { + printf("'\n"); + } + } + } + + if (params.tokenize_ids) { + printf("]\n"); + } + + if (params.tokenize_show_count) { + printf("Total number of tokens: %zu\n", tokens.size()); + } + + // silence valgrind + llama_free(ctx); + llama_model_free(model); + + return 0; +} diff --git a/tools/tts/CMakeLists.txt b/tools/tts/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..0a0b5730eaa6b57017e19f0e08c41d65ff5e3d79 --- /dev/null +++ b/tools/tts/CMakeLists.txt @@ -0,0 +1,8 @@ +set(TARGET llama-tts) +add_executable(${TARGET} tts.cpp) +target_link_libraries(${TARGET} PRIVATE llama llama-common mtmd ${CMAKE_THREAD_LIBS_INIT}) +target_compile_features(${TARGET} PRIVATE cxx_std_17) + +if(LLAMA_TOOLS_INSTALL) + install(TARGETS ${TARGET} RUNTIME) +endif() diff --git a/tools/tts/README.md b/tools/tts/README.md new file mode 100644 index 0000000000000000000000000000000000000000..dd84336c39900a580f3d7e25b6ad58f0d6120f4d --- /dev/null +++ b/tools/tts/README.md @@ -0,0 +1,34 @@ +# llama.cpp TTS + +This is a tool to demonstrate audio generation capability in llama.cpp via `libmtmd`. It was added via PR [#26254](https://github.com/ggml-org/llama.cpp/pull/26254) + +Note: this tool used to serve as a demo for OuteTTS, but it was converted to a more model-agnostic tool. + +## Common usage + +Simple usage: + +```sh +llama-tts -hf ggml-org/Qwen3-TTS-12Hz-1.7B-Base-GGUF -p "Hello world" --output out.wav +``` + +Common params: +- Sampling params such as `--top-k`, `--top-p`, `--temp`, etc. +- `-n ` limits the output length, e.g. `-n 500`. Note that how many milliseconds each frame represents varies by model +- Core inference params such as `-ngl`, `-b`, `-ub`, etc. + +## Qwen3-TTS + +Available params: +- `--tts-lang` can be `zh`, `en`, `de`, `it`, `pt`, `es`, `ja`, `ko`, `fr`, `ru` (default: `en`) +- `--tts-speaker-file` should point to a speaker reference audio file (wav, mp3) + +Example usage: + +```sh +llama-tts -hf ggml-org/Qwen3-TTS-12Hz-1.7B-Base-GGUF \ + -p "Hello world" \ + --tts-lang english \ + --tts-speaker-file speaker.mp3 \ + --output out.wav +``` diff --git a/tools/tts/tts.cpp b/tools/tts/tts.cpp new file mode 100644 index 0000000000000000000000000000000000000000..49c405e147849c6554d4b5d3d44054099ed4b828 --- /dev/null +++ b/tools/tts/tts.cpp @@ -0,0 +1,208 @@ +#include "arg.h" +#include "common.h" +#include "sampling.h" +#include "log.h" +#include "llama.h" +#include "mtmd.h" +#include "mtmd-helper.h" + +#include +#include +#include + +/** + * Please note that this is NOT a production-ready binary. + * It is a playground for trying TTS support in llama.cpp. + * For contributors: please keep this code simple and easy to understand. Do not add unnecessary complexity. The goal is to have a simple CLI for testing TTS support. + */ + +struct tts_timings { + int64_t t_start_us = ggml_time_us(); + int64_t t_last_us = t_start_us; + + void report(int n_frames) { + const int64_t t_now_us = ggml_time_us(); + if (t_now_us - t_last_us < 2000000) { + return; + } + t_last_us = t_now_us; + const double t_elapsed_s = (t_now_us - t_start_us) / 1e6; + const double fps = t_elapsed_s > 0 ? n_frames / t_elapsed_s : 0.0; + LOG_INF("frames generated: %d, speed: %.2f frames/s\n", n_frames, fps); + } +}; + +static void print_usage(int, char ** argv) { + LOG("\nexample usage:\n"); + LOG("\n %s -m backbone.gguf -mm mmproj.gguf -p \"text to speak\" -o output.wav", argv[0]); + LOG("\n %s -hf user/model -p \"text to speak\" -o output.wav\n", argv[0]); + LOG("\nnote: --tts-lang and --tts-speaker-file may not be supported in all models"); + LOG("\n use -n to limit the output length"); + LOG("\n see tts/README.md for per-model usage notes"); + LOG("\n\n"); +} + +int main(int argc, char ** argv) { + common_params params; + + common_init(); + + if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_TTS, print_usage)) { + return 1; + } + + mtmd_helper_log_set(common_log_default_callback, nullptr); + + if (params.prompt.empty()) { + LOG_ERR("no prompt provided, use -p \"text\"\n"); + return 1; + } + if (params.mmproj.path.empty()) { + LOG_ERR("no mmproj provided, use --mmproj\n"); + return 1; + } + + // important: keep this file as generic as possible + // model-specific logic should be in mtmd-helper-gen or mtmd API + + // always enable embd, so that we can pass hidden states to the audio generation helper + params.embedding = true; + + llama_backend_init(); + llama_numa_init(params.numa); + + // + // load backbone model and mmproj + // + + auto llama_init = common_init_from_params(params); + llama_model * model = llama_init->model(); + llama_context * lctx = llama_init->context(); + common_sampler * smpl = llama_init->sampler(0); + if (!model || !lctx) { + LOG_ERR("failed to init model/context\n"); + return 1; + } + + mtmd_context_params mtmd_params = mtmd_context_params_default(); + mtmd_params.use_gpu = params.mmproj_use_gpu; + mtmd::context_ptr mctx(mtmd_init_from_file(params.mmproj.path.c_str(), model, mtmd_params)); + if (!mctx) { + LOG_ERR("failed to load mmproj %s\n", params.mmproj.path.c_str()); + return 1; + } + if (mtmd_gen_audio_get_info(mctx.get()).type == MTMD_GEN_AUDIO_TYPE_NONE) { + LOG_ERR("mmproj does not support audio generation\n"); + return 1; + } + + // + // stage 0: process speaker reference file, if any + // + + mtmd::bitmap_ptr speaker_bitmap; + if (!params.tts_speaker_file.empty()) { + auto wrapper = mtmd_helper_bitmap_init_from_file(mctx.get(), params.tts_speaker_file.c_str(), false); + if (!wrapper.bitmap) { + LOG_ERR("failed to load speaker file %s\n", params.tts_speaker_file.c_str()); + return 1; + } + speaker_bitmap.reset(wrapper.bitmap); + } + + mtmd_helper::gen_audio gen(lctx, mctx.get()); + mtmd_helper_gen_audio_inp inp{}; + inp.seq_id = 0; + inp.prompt = params.prompt.c_str(); + inp.prompt_len = params.prompt.size(); + inp.speaker_ref = speaker_bitmap.get(); + inp.lang = params.tts_lang.c_str(); + inp.top_k = params.sampling.top_k; + inp.top_p = params.sampling.top_p; + inp.out_type = MTMD_HELPER_GEN_AUDIO_OUTTYPE_WAV; + + // + // stage 1: process prompt via backbone model, generate semantic representation + // + + if (gen.set_input(&inp) != 0) { + LOG_ERR("set_input failed\n"); + return 1; + } + + const int64_t t_prompt_start_us = ggml_time_us(); + + for (;;) { + int32_t ret = gen.step_prompt(params.n_batch); + if (ret < 0) { + LOG_ERR("prompt processing failed\n"); + return 1; + } + if (ret == 0) { + break; + } + } + + const llama_vocab * vocab = llama_model_get_vocab(model); + + auto sample_semantic_code = [&]() -> llama_token { + llama_token t = common_sampler_sample(smpl, lctx, -1); + common_sampler_accept(smpl, t, true); + return t; + }; + + const int max_new = params.n_predict > 0 ? params.n_predict : 512; + int n_frames = 0; + llama_token sampled = sample_semantic_code(); + const float * h_state = llama_get_embeddings_ith(lctx, -1); + + tts_timings timings; + const int64_t t_gen_start_us = ggml_time_us(); + + for (; n_frames < max_new && !llama_vocab_is_eog(vocab, sampled); n_frames++) { + const float * h_next = nullptr; + + // stage 2+3: semantic --> acoustic details --> audio waveform + // step_gen() runs both stages and returns new h_state for next step + if (gen.step_gen(sampled, h_state, &h_next) != 0) { + LOG_ERR("step_gen failed at frame %d\n", n_frames); + return 1; + } + + h_state = h_next; + sampled = sample_semantic_code(); + timings.report(n_frames + 1); + } + const double t_gen_s = (ggml_time_us() - t_gen_start_us) / 1e6; + + int32_t sample_rate = 0; + const char * data = nullptr; + size_t data_len = 0; + int64_t n_samples = 0; + const int64_t t_wav_start_us = ggml_time_us(); + if (gen.get_output(&sample_rate, &data, &data_len, &n_samples) != 0) { + LOG_ERR("get_output failed\n"); + return 1; + } + const double t_wav_s = (ggml_time_us() - t_wav_start_us) / 1e6; + + LOG_INF("generated %d frames, %zu bytes of WAV audio (%d Hz)\n", n_frames, data_len, sample_rate); + + const double t_prompt_s = (t_gen_start_us - t_prompt_start_us) / 1e6; + const double t_total_s = t_prompt_s + t_gen_s + t_wav_s; + const double audio_s = sample_rate > 0 ? (double) n_samples / sample_rate : 0.0; + LOG_INF("timings: prompt eval %.2fs + generation %.2fs + vocoder %.2fs = total %.2fs\n", + t_prompt_s, t_gen_s, t_wav_s, t_total_s); + LOG_INF(" output audio = %.2fs (audio time = %.2fx process time)\n", audio_s, t_total_s > 0 ? audio_s / t_total_s : 0.0); + FILE * f = fopen(params.out_file.c_str(), "wb"); + if (!f) { + LOG_ERR("failed to open %s\n", params.out_file.c_str()); + return 1; + } + fwrite(data, 1, data_len, f); + fclose(f); + LOG_INF("wrote %s\n", params.out_file.c_str()); + + llama_backend_free(); + return 0; +} diff --git a/tools/ui/.env.example b/tools/ui/.env.example new file mode 100644 index 0000000000000000000000000000000000000000..a1e6c54915baddc49f2cf704491cac65d9b13664 --- /dev/null +++ b/tools/ui/.env.example @@ -0,0 +1,3 @@ +VITE_PUBLIC_APP_NAME='llama-ui' +VITE_DEBUG='true' +VITE_PUBLIC_SERVER_ORIGIN='http://localhost:8033' diff --git a/tools/ui/.gitignore b/tools/ui/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7cd35376e1991cb5c7d71b6e9a991131eff43b44 --- /dev/null +++ b/tools/ui/.gitignore @@ -0,0 +1,42 @@ +test-results +node_modules + +# Output +.output +.vercel +.netlify +.wrangler +/.svelte-kit +/build +dev-dist +dist + +# OS +.DS_Store +Thumbs.db + +# Env +.env +.env.* +!.env.example +!.env.test + +# Vite +vite.config.js.timestamp-* +vite.config.ts.timestamp-* + +# PWA Artifacts +apple-splash-*.png +apple-touch-icon-*.png +maskable-icon-*.png +pwa-*.png +static/favicon* + +# Storybook +*storybook.log +storybook-static +*.code-workspace + +# Vitest browser mode failure artifacts +.vitest-attachments/ +tests/**/__screenshots__/ diff --git a/tools/ui/.npmrc b/tools/ui/.npmrc new file mode 100644 index 0000000000000000000000000000000000000000..0a690322a452d2da8990615bc9823cda6cd055c9 --- /dev/null +++ b/tools/ui/.npmrc @@ -0,0 +1,3 @@ +engine-strict=true +ignore-scripts=true +min-release-age=7 diff --git a/tools/ui/.prettierignore b/tools/ui/.prettierignore new file mode 100644 index 0000000000000000000000000000000000000000..635cf99c7e9c3b6c33144e277a62ba8cd010ce7b --- /dev/null +++ b/tools/ui/.prettierignore @@ -0,0 +1,21 @@ +# Package Managers +package-lock.json +pnpm-lock.yaml +yarn.lock +bun.lock +bun.lockb + +# Miscellaneous +/static/ +dist/ +.svelte-kit/ +build/ + +# Build output +/dist/ +/build/ +/.svelte-kit/ +test-results + +# Vendored third party sources, kept byte identical to upstream +src/lib/vendors/ diff --git a/tools/ui/.prettierrc b/tools/ui/.prettierrc new file mode 100644 index 0000000000000000000000000000000000000000..8103a0b5d2a378f217fbccd9b7aea0cb35bddab0 --- /dev/null +++ b/tools/ui/.prettierrc @@ -0,0 +1,16 @@ +{ + "useTabs": true, + "singleQuote": true, + "trailingComma": "none", + "printWidth": 100, + "plugins": ["prettier-plugin-svelte", "prettier-plugin-tailwindcss"], + "overrides": [ + { + "files": "*.svelte", + "options": { + "parser": "svelte" + } + } + ], + "tailwindStylesheet": "./src/app.css" +} diff --git a/tools/ui/.storybook/decorators/ModeWatcherDecorator.svelte b/tools/ui/.storybook/decorators/ModeWatcherDecorator.svelte new file mode 100644 index 0000000000000000000000000000000000000000..8bded8b3f1e64c1ca2efdb7424b1221df6988124 --- /dev/null +++ b/tools/ui/.storybook/decorators/ModeWatcherDecorator.svelte @@ -0,0 +1,36 @@ + + + + +{#if children} + {@const Component = children} + + +{/if} diff --git a/tools/ui/.storybook/decorators/TooltipProviderDecorator.svelte b/tools/ui/.storybook/decorators/TooltipProviderDecorator.svelte new file mode 100644 index 0000000000000000000000000000000000000000..ba0cabc561850b2d9e74f215080d3fb4b5418ce1 --- /dev/null +++ b/tools/ui/.storybook/decorators/TooltipProviderDecorator.svelte @@ -0,0 +1,13 @@ + + + + {@render children()} + diff --git a/tools/ui/.storybook/main.ts b/tools/ui/.storybook/main.ts new file mode 100644 index 0000000000000000000000000000000000000000..b02ecc5d5a6210f13dcc01635213d28898797b63 --- /dev/null +++ b/tools/ui/.storybook/main.ts @@ -0,0 +1,25 @@ +import type { StorybookConfig } from '@storybook/sveltekit'; +import { dirname, resolve } from 'path'; +import { fileURLToPath } from 'url'; + +const __dirname = dirname(fileURLToPath(import.meta.url)); + +const config: StorybookConfig = { + stories: ['../tests/stories/**/*.mdx', '../tests/stories/**/*.stories.@(js|ts|svelte)'], + addons: [ + '@storybook/addon-svelte-csf', + '@chromatic-com/storybook', + '@storybook/addon-vitest', + '@storybook/addon-a11y', + '@storybook/addon-docs', + '@storybook/addon-mcp' + ], + framework: '@storybook/sveltekit', + viteFinal: async (config) => { + config.server = config.server || {}; + config.server.fs = config.server.fs || {}; + config.server.fs.allow = [...(config.server.fs.allow || []), resolve(__dirname, '../tests')]; + return config; + } +}; +export default config; diff --git a/tools/ui/.storybook/preview.ts b/tools/ui/.storybook/preview.ts new file mode 100644 index 0000000000000000000000000000000000000000..4610229a681cfbd96b43eefbc9f5b449cfeb268c --- /dev/null +++ b/tools/ui/.storybook/preview.ts @@ -0,0 +1,42 @@ +import type { Preview } from '@storybook/sveltekit'; +import '../src/app.css'; +import ModeWatcherDecorator from './decorators/ModeWatcherDecorator.svelte'; +import TooltipProviderDecorator from './decorators/TooltipProviderDecorator.svelte'; + +const preview: Preview = { + parameters: { + controls: { + matchers: { + color: /(background|color)$/i, + date: /Date$/i + } + }, + + backgrounds: { + disabled: true + }, + + a11y: { + // 'todo' - show a11y violations in the test UI only + // 'error' - fail CI on a11y violations + // 'off' - skip a11y checks entirely + test: 'todo' + } + }, + decorators: [ + (story) => ({ + Component: ModeWatcherDecorator, + props: { + children: story + } + }), + (story) => ({ + Component: TooltipProviderDecorator, + props: { + children: story + } + }) + ] +}; + +export default preview; diff --git a/tools/ui/.svelte-kit/ambient.d.ts b/tools/ui/.svelte-kit/ambient.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..13c8573d209d09fd161e64b342e3c90e3d581bc6 --- /dev/null +++ b/tools/ui/.svelte-kit/ambient.d.ts @@ -0,0 +1,440 @@ + +// this file is generated — do not edit it + + +/// + +/** + * This module provides access to environment variables that are injected _statically_ into your bundle at build time and are limited to _private_ access. + * + * | | Runtime | Build time | + * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ | + * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) | + * | Public | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public) | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public) | + * + * Static environment variables are [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env` at build time and then statically injected into your bundle at build time, enabling optimisations like dead code elimination. + * + * **_Private_ access:** + * + * - This module cannot be imported into client-side code + * - This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured) + * + * For example, given the following build time environment: + * + * ```env + * ENVIRONMENT=production + * PUBLIC_BASE_URL=http://site.com + * ``` + * + * With the default `publicPrefix` and `privatePrefix`: + * + * ```ts + * import { ENVIRONMENT, PUBLIC_BASE_URL } from '$env/static/private'; + * + * console.log(ENVIRONMENT); // => "production" + * console.log(PUBLIC_BASE_URL); // => throws error during build + * ``` + * + * The above values will be the same _even if_ different values for `ENVIRONMENT` or `PUBLIC_BASE_URL` are set at runtime, as they are statically replaced in your code with their build time values. + */ +declare module '$env/static/private' { + export const SVELTEKIT_FORK: string; + export const LESS_TERMCAP_us: string; + export const PYENV_VIRTUALENV_INIT: string; + export const XDG_MENU_PREFIX: string; + export const COMMAND_NOT_FOUND_INSTALL_PROMPT: string; + export const LESS_TERMCAP_md: string; + export const COLOR: string; + export const ANTIGRAVITY_AGENT: string; + export const SYSTEMD_EXEC_PID: string; + export const KONSOLE_VERSION: string; + export const LESS_TERMCAP_so: string; + export const PWD: string; + export const PAGER: string; + export const KDE_SESSION_VERSION: string; + export const XDG_DATA_DIRS: string; + export const XDG_SEAT_PATH: string; + export const GTK_RC_FILES: string; + export const OLDPWD: string; + export const SHELL_SESSION_ID: string; + export const PAM_KWALLET5_LOGIN: string; + export const POWERSHELL_UPDATECHECK: string; + export const MANAGERPID: string; + export const ANTIGRAVITY_SOURCE_METADATA: string; + export const XDG_CURRENT_DESKTOP: string; + export const ANTIGRAVITY_CSRF_TOKEN: string; + export const QT_WAYLAND_RECONNECT: string; + export const NVM_INC: string; + export const USER: string; + export const POWERSHELL_TELEMETRY_OPTOUT: string; + export const LESS_TERMCAP_se: string; + export const PYENV_ROOT: string; + export const npm_config_engine_strict: string; + export const JOURNAL_STREAM: string; + export const AI_AGENT: string; + export const npm_config_userconfig: string; + export const XDG_SESSION_TYPE: string; + export const COLORTERM: string; + export const npm_config_user_agent: string; + export const PROFILEHOME: string; + export const RUSTICL_ENABLE: string; + export const NVM_CD_FLAGS: string; + export const DOTNET_CLI_TELEMETRY_OPTOUT: string; + export const DBUS_SESSION_BUS_ADDRESS: string; + export const npm_package_json: string; + export const HSA_OVERRIDE_GFX_VERSION: string; + export const KONSOLE_DBUS_SERVICE: string; + export const XDG_RUNTIME_DIR: string; + export const KDE_FULL_SESSION: string; + export const DESKTOP_SESSION: string; + export const GPG_AGENT_INFO: string; + export const MANAGERPIDFDID: string; + export const LANGUAGE: string; + export const ANTIGRAVITY_LS_VERSION: string; + export const XDG_SEAT: string; + export const npm_package_version: string; + export const npm_node_execpath: string; + export const SHLVL: string; + export const WINDOWID: string; + export const NVM_BIN: string; + export const ANTIGRAVITY_AGENTAPI_EXE: string; + export const npm_config_node_gyp: string; + export const MEMORY_PRESSURE_WATCH: string; + export const LOGNAME: string; + export const SHELL: string; + export const NVM_DIR: string; + export const KONSOLE_DBUS_WINDOW: string; + export const _: string; + export const JETSKI_APP_DATA_DIR: string; + export const ICEAUTHORITY: string; + export const KDE_SESSION_UID: string; + export const HOME: string; + export const LESS_TERMCAP_ue: string; + export const XDG_CONFIG_DIRS: string; + export const KDE_APPLICATIONS_AS_SCOPE: string; + export const npm_package_name: string; + export const npm_config_local_prefix: string; + export const npm_config_prefix: string; + export const XAUTHORITY: string; + export const npm_config_npm_version: string; + export const XDG_SESSION_CLASS: string; + export const npm_command: string; + export const XKB_DEFAULT_MODEL: string; + export const COLORFGBG: string; + export const XDG_SESSION_ID: string; + export const GTK2_RC_FILES: string; + export const FLATPAK_TTY_PROGRESS: string; + export const WAYLAND_DISPLAY: string; + export const SESSION_MANAGER: string; + export const KONSOLE_DBUS_SESSION: string; + export const INVOCATION_ID: string; + export const XKB_DEFAULT_LAYOUT: string; + export const npm_config_cache: string; + export const TERM: string; + export const NODE: string; + export const DISPLAY: string; + export const LANG: string; + export const ANTIGRAVITY_CONVERSATION_ID: string; + export const QT_ACCESSIBILITY: string; + export const npm_config_init_module: string; + export const npm_config_ignore_scripts: string; + export const XDG_SESSION_DESKTOP: string; + export const LS_COLORS: string; + export const npm_lifecycle_script: string; + export const SSH_AUTH_SOCK: string; + export const ANTIGRAVITY_PROJECT_ID: string; + export const ANTIGRAVITY_LS_ADDRESS: string; + export const LESS_TERMCAP_mb: string; + export const XDG_VTNR: string; + export const npm_lifecycle_event: string; + export const _JAVA_AWT_WM_NONREPARENTING: string; + export const DOCKER_HOST: string; + export const GIT_PAGER: string; + export const EDITOR: string; + export const ANTIGRAVITY_TRAJECTORY_ID: string; + export const npm_config_globalconfig: string; + export const LESS_TERMCAP_me: string; + export const KONSOLE_DBUS_ACTIVATION_COOKIE: string; + export const XDG_SESSION_PATH: string; + export const npm_execpath: string; + export const npm_config_global_prefix: string; + export const npm_config_allow_scripts: string; + export const PATH: string; + export const JETSKI_SAFECLIS_SOURCE: string; + export const MEMORY_PRESSURE_WRITE: string; + export const INIT_CWD: string; + export const NODE_ENV: string; + export const npm_config_noproxy: string; + export const PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS: string; +} + +/** + * This module provides access to environment variables that are injected _statically_ into your bundle at build time and are _publicly_ accessible. + * + * | | Runtime | Build time | + * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ | + * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) | + * | Public | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public) | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public) | + * + * Static environment variables are [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env` at build time and then statically injected into your bundle at build time, enabling optimisations like dead code elimination. + * + * **_Public_ access:** + * + * - This module _can_ be imported into client-side code + * - **Only** variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`) are included + * + * For example, given the following build time environment: + * + * ```env + * ENVIRONMENT=production + * PUBLIC_BASE_URL=http://site.com + * ``` + * + * With the default `publicPrefix` and `privatePrefix`: + * + * ```ts + * import { ENVIRONMENT, PUBLIC_BASE_URL } from '$env/static/public'; + * + * console.log(ENVIRONMENT); // => throws error during build + * console.log(PUBLIC_BASE_URL); // => "http://site.com" + * ``` + * + * The above values will be the same _even if_ different values for `ENVIRONMENT` or `PUBLIC_BASE_URL` are set at runtime, as they are statically replaced in your code with their build time values. + */ +declare module '$env/static/public' { + +} + +/** + * This module provides access to environment variables set _dynamically_ at runtime and that are limited to _private_ access. + * + * | | Runtime | Build time | + * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ | + * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) | + * | Public | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public) | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public) | + * + * Dynamic environment variables are defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/main/packages/adapter-node) (or running [`vite preview`](https://svelte.dev/docs/kit/cli)), this is equivalent to `process.env`. + * + * **_Private_ access:** + * + * - This module cannot be imported into client-side code + * - This module includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured) + * + * > [!NOTE] In `dev`, `$env/dynamic` includes environment variables from `.env`. In `prod`, this behavior will depend on your adapter. + * + * > [!NOTE] To get correct types, environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed: + * > + * > ```env + * > MY_FEATURE_FLAG= + * > ``` + * > + * > You can override `.env` values from the command line like so: + * > + * > ```sh + * > MY_FEATURE_FLAG="enabled" npm run dev + * > ``` + * + * For example, given the following runtime environment: + * + * ```env + * ENVIRONMENT=production + * PUBLIC_BASE_URL=http://site.com + * ``` + * + * With the default `publicPrefix` and `privatePrefix`: + * + * ```ts + * import { env } from '$env/dynamic/private'; + * + * console.log(env.ENVIRONMENT); // => "production" + * console.log(env.PUBLIC_BASE_URL); // => undefined + * ``` + */ +declare module '$env/dynamic/private' { + export const env: { + SVELTEKIT_FORK: string; + LESS_TERMCAP_us: string; + PYENV_VIRTUALENV_INIT: string; + XDG_MENU_PREFIX: string; + COMMAND_NOT_FOUND_INSTALL_PROMPT: string; + LESS_TERMCAP_md: string; + COLOR: string; + ANTIGRAVITY_AGENT: string; + SYSTEMD_EXEC_PID: string; + KONSOLE_VERSION: string; + LESS_TERMCAP_so: string; + PWD: string; + PAGER: string; + KDE_SESSION_VERSION: string; + XDG_DATA_DIRS: string; + XDG_SEAT_PATH: string; + GTK_RC_FILES: string; + OLDPWD: string; + SHELL_SESSION_ID: string; + PAM_KWALLET5_LOGIN: string; + POWERSHELL_UPDATECHECK: string; + MANAGERPID: string; + ANTIGRAVITY_SOURCE_METADATA: string; + XDG_CURRENT_DESKTOP: string; + ANTIGRAVITY_CSRF_TOKEN: string; + QT_WAYLAND_RECONNECT: string; + NVM_INC: string; + USER: string; + POWERSHELL_TELEMETRY_OPTOUT: string; + LESS_TERMCAP_se: string; + PYENV_ROOT: string; + npm_config_engine_strict: string; + JOURNAL_STREAM: string; + AI_AGENT: string; + npm_config_userconfig: string; + XDG_SESSION_TYPE: string; + COLORTERM: string; + npm_config_user_agent: string; + PROFILEHOME: string; + RUSTICL_ENABLE: string; + NVM_CD_FLAGS: string; + DOTNET_CLI_TELEMETRY_OPTOUT: string; + DBUS_SESSION_BUS_ADDRESS: string; + npm_package_json: string; + HSA_OVERRIDE_GFX_VERSION: string; + KONSOLE_DBUS_SERVICE: string; + XDG_RUNTIME_DIR: string; + KDE_FULL_SESSION: string; + DESKTOP_SESSION: string; + GPG_AGENT_INFO: string; + MANAGERPIDFDID: string; + LANGUAGE: string; + ANTIGRAVITY_LS_VERSION: string; + XDG_SEAT: string; + npm_package_version: string; + npm_node_execpath: string; + SHLVL: string; + WINDOWID: string; + NVM_BIN: string; + ANTIGRAVITY_AGENTAPI_EXE: string; + npm_config_node_gyp: string; + MEMORY_PRESSURE_WATCH: string; + LOGNAME: string; + SHELL: string; + NVM_DIR: string; + KONSOLE_DBUS_WINDOW: string; + _: string; + JETSKI_APP_DATA_DIR: string; + ICEAUTHORITY: string; + KDE_SESSION_UID: string; + HOME: string; + LESS_TERMCAP_ue: string; + XDG_CONFIG_DIRS: string; + KDE_APPLICATIONS_AS_SCOPE: string; + npm_package_name: string; + npm_config_local_prefix: string; + npm_config_prefix: string; + XAUTHORITY: string; + npm_config_npm_version: string; + XDG_SESSION_CLASS: string; + npm_command: string; + XKB_DEFAULT_MODEL: string; + COLORFGBG: string; + XDG_SESSION_ID: string; + GTK2_RC_FILES: string; + FLATPAK_TTY_PROGRESS: string; + WAYLAND_DISPLAY: string; + SESSION_MANAGER: string; + KONSOLE_DBUS_SESSION: string; + INVOCATION_ID: string; + XKB_DEFAULT_LAYOUT: string; + npm_config_cache: string; + TERM: string; + NODE: string; + DISPLAY: string; + LANG: string; + ANTIGRAVITY_CONVERSATION_ID: string; + QT_ACCESSIBILITY: string; + npm_config_init_module: string; + npm_config_ignore_scripts: string; + XDG_SESSION_DESKTOP: string; + LS_COLORS: string; + npm_lifecycle_script: string; + SSH_AUTH_SOCK: string; + ANTIGRAVITY_PROJECT_ID: string; + ANTIGRAVITY_LS_ADDRESS: string; + LESS_TERMCAP_mb: string; + XDG_VTNR: string; + npm_lifecycle_event: string; + _JAVA_AWT_WM_NONREPARENTING: string; + DOCKER_HOST: string; + GIT_PAGER: string; + EDITOR: string; + ANTIGRAVITY_TRAJECTORY_ID: string; + npm_config_globalconfig: string; + LESS_TERMCAP_me: string; + KONSOLE_DBUS_ACTIVATION_COOKIE: string; + XDG_SESSION_PATH: string; + npm_execpath: string; + npm_config_global_prefix: string; + npm_config_allow_scripts: string; + PATH: string; + JETSKI_SAFECLIS_SOURCE: string; + MEMORY_PRESSURE_WRITE: string; + INIT_CWD: string; + NODE_ENV: string; + npm_config_noproxy: string; + PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS: string; + [key: `PUBLIC_${string}`]: undefined; + [key: `${string}`]: string | undefined; + } +} + +/** + * This module provides access to environment variables set _dynamically_ at runtime and that are _publicly_ accessible. + * + * | | Runtime | Build time | + * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ | + * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) | + * | Public | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public) | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public) | + * + * Dynamic environment variables are defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/main/packages/adapter-node) (or running [`vite preview`](https://svelte.dev/docs/kit/cli)), this is equivalent to `process.env`. + * + * **_Public_ access:** + * + * - This module _can_ be imported into client-side code + * - **Only** variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`) are included + * + * > [!NOTE] In `dev`, `$env/dynamic` includes environment variables from `.env`. In `prod`, this behavior will depend on your adapter. + * + * > [!NOTE] To get correct types, environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed: + * > + * > ```env + * > MY_FEATURE_FLAG= + * > ``` + * > + * > You can override `.env` values from the command line like so: + * > + * > ```sh + * > MY_FEATURE_FLAG="enabled" npm run dev + * > ``` + * + * For example, given the following runtime environment: + * + * ```env + * ENVIRONMENT=production + * PUBLIC_BASE_URL=http://example.com + * ``` + * + * With the default `publicPrefix` and `privatePrefix`: + * + * ```ts + * import { env } from '$env/dynamic/public'; + * console.log(env.ENVIRONMENT); // => undefined, not public + * console.log(env.PUBLIC_BASE_URL); // => "http://example.com" + * ``` + * + * ``` + * + * ``` + */ +declare module '$env/dynamic/public' { + export const env: { + [key: `PUBLIC_${string}`]: string | undefined; + } +} diff --git a/tools/ui/.svelte-kit/env.d.ts b/tools/ui/.svelte-kit/env.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d7f6c9770fe7c9dc46a76269090c55f0b09fa30e --- /dev/null +++ b/tools/ui/.svelte-kit/env.d.ts @@ -0,0 +1 @@ +// See https://svelte.dev/docs/kit/environment-variables for more information \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/app.js b/tools/ui/.svelte-kit/generated/client-optimized/app.js new file mode 100644 index 0000000000000000000000000000000000000000..137edee3a55d32a95d99716a5c2213aa7d9bb211 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/app.js @@ -0,0 +1,51 @@ +// in dev, this makes Vite inject its client as this module's first dependency, +// so that global constant replacements are installed before any other module +// (including user hooks) evaluates. In build it's inert. +import.meta.hot; + + + + +export { matchers } from './matchers.js'; + +export const nodes = [ + () => import('./nodes/0'), + () => import('./nodes/1'), + () => import('./nodes/2'), + () => import('./nodes/3'), + () => import('./nodes/4'), + () => import('./nodes/5'), + () => import('./nodes/6'), + () => import('./nodes/7'), + () => import('./nodes/8'), + () => import('./nodes/9') +]; + +export const server_loads = []; + +export const dictionary = { + "/(chat)": [4,[2]], + "/agents": [6], + "/(chat)/chat/[id]": [5,[2]], + "/mcp-servers": [7], + "/search": [8], + "/settings/[[section]]": [9,[3]] + }; + +export const hooks = { + handleError: (({ error }) => { console.error(error) }), + + reroute: (() => {}), + transport: {} +}; + +export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode])); +export const encoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.encode])); + +export const hash = true; + +export const decode = (type, value) => decoders[type](value); + +export { default as root } from '../root.js'; + +export const get_error_template = () => import('../shared/error-template.js').then(m => m.default); \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/matchers.js b/tools/ui/.svelte-kit/generated/client-optimized/matchers.js new file mode 100644 index 0000000000000000000000000000000000000000..f6bd30a4eb679f78dfe9f8947afe362bb30c4b5a --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/matchers.js @@ -0,0 +1 @@ +export const matchers = {}; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/0.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/0.js new file mode 100644 index 0000000000000000000000000000000000000000..fed1375f7587e2ea43f38eb768db2653f4eb45ee --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/0.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/1.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/1.js new file mode 100644 index 0000000000000000000000000000000000000000..ac3c6a5366435edecf158c5339b94bcf946e770c --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/1.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/+error.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/2.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/2.js new file mode 100644 index 0000000000000000000000000000000000000000..b7091f7c1a45b873b2aeb1f965129893c44e2ecb --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/2.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/(chat)/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/3.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/3.js new file mode 100644 index 0000000000000000000000000000000000000000..2e594ab19bd7cf5c8ff1477f2d64e614860c46c3 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/3.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/settings/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/4.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/4.js new file mode 100644 index 0000000000000000000000000000000000000000..e471dbf8df8dd8a5badc638b50589562b4f0b7c3 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/4.js @@ -0,0 +1,3 @@ +import * as universal from "../../../../src/routes/(chat)/+page.ts"; +export { universal }; +export { default as component } from "../../../../src/routes/(chat)/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/5.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/5.js new file mode 100644 index 0000000000000000000000000000000000000000..b77e6b0d4aa5c6f942f678c271848fe4cfe85df5 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/5.js @@ -0,0 +1,3 @@ +import * as universal from "../../../../src/routes/(chat)/chat/[id]/+page.ts"; +export { universal }; +export { default as component } from "../../../../src/routes/(chat)/chat/[id]/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/6.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/6.js new file mode 100644 index 0000000000000000000000000000000000000000..2c27e81bda9c04ed89612e5dbf2f7ae950683638 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/6.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/agents/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/7.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/7.js new file mode 100644 index 0000000000000000000000000000000000000000..f7bf63cf76a2c3db2f25a58e4bc0773661b3a9cf --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/7.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/mcp-servers/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/8.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/8.js new file mode 100644 index 0000000000000000000000000000000000000000..f0df5ad4fbbb4a9b30be9d7fd5135a44cc36bb12 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/8.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/search/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client-optimized/nodes/9.js b/tools/ui/.svelte-kit/generated/client-optimized/nodes/9.js new file mode 100644 index 0000000000000000000000000000000000000000..8b17fd7b57dfc362e3b88a86cc6bdb989751a3f8 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client-optimized/nodes/9.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/settings/[[section]]/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/app.js b/tools/ui/.svelte-kit/generated/client/app.js new file mode 100644 index 0000000000000000000000000000000000000000..137edee3a55d32a95d99716a5c2213aa7d9bb211 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/app.js @@ -0,0 +1,51 @@ +// in dev, this makes Vite inject its client as this module's first dependency, +// so that global constant replacements are installed before any other module +// (including user hooks) evaluates. In build it's inert. +import.meta.hot; + + + + +export { matchers } from './matchers.js'; + +export const nodes = [ + () => import('./nodes/0'), + () => import('./nodes/1'), + () => import('./nodes/2'), + () => import('./nodes/3'), + () => import('./nodes/4'), + () => import('./nodes/5'), + () => import('./nodes/6'), + () => import('./nodes/7'), + () => import('./nodes/8'), + () => import('./nodes/9') +]; + +export const server_loads = []; + +export const dictionary = { + "/(chat)": [4,[2]], + "/agents": [6], + "/(chat)/chat/[id]": [5,[2]], + "/mcp-servers": [7], + "/search": [8], + "/settings/[[section]]": [9,[3]] + }; + +export const hooks = { + handleError: (({ error }) => { console.error(error) }), + + reroute: (() => {}), + transport: {} +}; + +export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode])); +export const encoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.encode])); + +export const hash = true; + +export const decode = (type, value) => decoders[type](value); + +export { default as root } from '../root.js'; + +export const get_error_template = () => import('../shared/error-template.js').then(m => m.default); \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/matchers.js b/tools/ui/.svelte-kit/generated/client/matchers.js new file mode 100644 index 0000000000000000000000000000000000000000..f6bd30a4eb679f78dfe9f8947afe362bb30c4b5a --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/matchers.js @@ -0,0 +1 @@ +export const matchers = {}; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/0.js b/tools/ui/.svelte-kit/generated/client/nodes/0.js new file mode 100644 index 0000000000000000000000000000000000000000..fed1375f7587e2ea43f38eb768db2653f4eb45ee --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/0.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/1.js b/tools/ui/.svelte-kit/generated/client/nodes/1.js new file mode 100644 index 0000000000000000000000000000000000000000..ac3c6a5366435edecf158c5339b94bcf946e770c --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/1.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/+error.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/2.js b/tools/ui/.svelte-kit/generated/client/nodes/2.js new file mode 100644 index 0000000000000000000000000000000000000000..b7091f7c1a45b873b2aeb1f965129893c44e2ecb --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/2.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/(chat)/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/3.js b/tools/ui/.svelte-kit/generated/client/nodes/3.js new file mode 100644 index 0000000000000000000000000000000000000000..2e594ab19bd7cf5c8ff1477f2d64e614860c46c3 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/3.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/settings/+layout.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/4.js b/tools/ui/.svelte-kit/generated/client/nodes/4.js new file mode 100644 index 0000000000000000000000000000000000000000..e471dbf8df8dd8a5badc638b50589562b4f0b7c3 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/4.js @@ -0,0 +1,3 @@ +import * as universal from "../../../../src/routes/(chat)/+page.ts"; +export { universal }; +export { default as component } from "../../../../src/routes/(chat)/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/5.js b/tools/ui/.svelte-kit/generated/client/nodes/5.js new file mode 100644 index 0000000000000000000000000000000000000000..b77e6b0d4aa5c6f942f678c271848fe4cfe85df5 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/5.js @@ -0,0 +1,3 @@ +import * as universal from "../../../../src/routes/(chat)/chat/[id]/+page.ts"; +export { universal }; +export { default as component } from "../../../../src/routes/(chat)/chat/[id]/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/6.js b/tools/ui/.svelte-kit/generated/client/nodes/6.js new file mode 100644 index 0000000000000000000000000000000000000000..2c27e81bda9c04ed89612e5dbf2f7ae950683638 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/6.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/agents/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/7.js b/tools/ui/.svelte-kit/generated/client/nodes/7.js new file mode 100644 index 0000000000000000000000000000000000000000..f7bf63cf76a2c3db2f25a58e4bc0773661b3a9cf --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/7.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/mcp-servers/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/8.js b/tools/ui/.svelte-kit/generated/client/nodes/8.js new file mode 100644 index 0000000000000000000000000000000000000000..f0df5ad4fbbb4a9b30be9d7fd5135a44cc36bb12 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/8.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/search/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/client/nodes/9.js b/tools/ui/.svelte-kit/generated/client/nodes/9.js new file mode 100644 index 0000000000000000000000000000000000000000..8b17fd7b57dfc362e3b88a86cc6bdb989751a3f8 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/client/nodes/9.js @@ -0,0 +1 @@ +export { default as component } from "../../../../src/routes/settings/[[section]]/+page.svelte"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/root.js b/tools/ui/.svelte-kit/generated/root.js new file mode 100644 index 0000000000000000000000000000000000000000..4d1e8929ff4cdfad1b2e5a90c8f08cf384fdf02e --- /dev/null +++ b/tools/ui/.svelte-kit/generated/root.js @@ -0,0 +1,3 @@ +import { asClassComponent } from 'svelte/legacy'; +import Root from './root.svelte'; +export default asClassComponent(Root); \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/root.svelte b/tools/ui/.svelte-kit/generated/root.svelte new file mode 100644 index 0000000000000000000000000000000000000000..30d59ad71152c5b176502b7b6202daa3a251fc75 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/root.svelte @@ -0,0 +1,80 @@ + + + + +{#if constructors[1]} + {@const Pyramid_0 = constructors[0]} + + + {#if constructors[2]} + {@const Pyramid_1 = constructors[1]} + + + + + + + {:else} + {@const Pyramid_1 = constructors[1]} + + + + {/if} + + +{:else} + {@const Pyramid_0 = constructors[0]} + + + +{/if} + +{#if mounted} +
+ {#if navigated} + {title} + {/if} +
+{/if} \ No newline at end of file diff --git a/tools/ui/.svelte-kit/generated/server/internal.js b/tools/ui/.svelte-kit/generated/server/internal.js new file mode 100644 index 0000000000000000000000000000000000000000..b13f2269587d509f974655077c9c474662cf67df --- /dev/null +++ b/tools/ui/.svelte-kit/generated/server/internal.js @@ -0,0 +1,55 @@ + +import root from '../root.js'; +import { set_building, set_prerendering } from '$app/env/internal'; +import { set_assets } from '$app/paths/internal/server'; +import { set_manifest, set_read_implementation } from '__sveltekit/server'; +import { set_private_env, set_public_env } from '../../../node_modules/@sveltejs/kit/src/runtime/shared-server.js'; +import error from '../shared/error-template.js'; + +export const options = { + app_template_contains_nonce: false, + async: false, + csp: {"mode":"auto","directives":{"upgrade-insecure-requests":false,"block-all-mixed-content":false},"reportOnly":{"upgrade-insecure-requests":false,"block-all-mixed-content":false}}, + csrf_check_origin: true, + csrf_trusted_origins: [], + embedded: false, + env_public_prefix: 'PUBLIC_', + env_private_prefix: '', + hash_routing: true, + hooks: null, // added lazily, via `get_hooks` + preload_strategy: "modulepreload", + root, + service_worker: false, + service_worker_options: undefined, + server_error_boundaries: false, + templates: { + app: ({ head, body, assets, nonce, env }) => "\n\n\t\n\t\t\n\t\t\n\t\t\n\n\t\t\n\n\t\t\n\n\t\t\n\t\t" + head + "\n\t\n\n\t\n\t\t
" + body + "
\n\t\n\n", + error + }, + version_hash: "dab7ys" +}; + +export async function get_hooks() { + let handle; + let handleFetch; + let handleError; + let handleValidationError; + let init; + + + let reroute; + let transport; + + + return { + handle, + handleFetch, + handleError, + handleValidationError, + init, + reroute, + transport + }; +} + +export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation }; diff --git a/tools/ui/.svelte-kit/generated/shared/error-template.js b/tools/ui/.svelte-kit/generated/shared/error-template.js new file mode 100644 index 0000000000000000000000000000000000000000..f66e59579dea90d36f6624851146cc8a1d834553 --- /dev/null +++ b/tools/ui/.svelte-kit/generated/shared/error-template.js @@ -0,0 +1 @@ +export default ({ status, message }) => "\n\n\t\n\t\t\n\t\t" + message + "\n\n\t\t\n\t\n\t\n\t\t
\n\t\t\t" + status + "\n\t\t\t
\n\t\t\t\t

" + message + "

\n\t\t\t
\n\t\t
\n\t\n\n"; \ No newline at end of file diff --git a/tools/ui/.svelte-kit/non-ambient.d.ts b/tools/ui/.svelte-kit/non-ambient.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..35121c98f47a8612b3ad053981f7cd5d87df7671 --- /dev/null +++ b/tools/ui/.svelte-kit/non-ambient.d.ts @@ -0,0 +1,52 @@ + +// this file is generated — do not edit it + + +declare module "svelte/elements" { + export interface HTMLAttributes { + 'data-sveltekit-keepfocus'?: true | '' | 'off' | undefined | null; + 'data-sveltekit-noscroll'?: true | '' | 'off' | undefined | null; + 'data-sveltekit-preload-code'?: + | true + | '' + | 'eager' + | 'viewport' + | 'hover' + | 'tap' + | 'off' + | undefined + | null; + 'data-sveltekit-preload-data'?: true | '' | 'hover' | 'tap' | 'off' | undefined | null; + 'data-sveltekit-reload'?: true | '' | 'off' | undefined | null; + 'data-sveltekit-replacestate'?: true | '' | 'off' | undefined | null; + } +} + +export {}; + + +declare module "$app/types" { + type MatcherParam = M extends (param : string) => param is (infer U extends string) ? U : string; + + export interface AppTypes { + RouteId(): "/(chat)" | "/" | "/agents" | "/(chat)/chat" | "/(chat)/chat/[id]" | "/mcp-servers" | "/search" | "/settings" | "/settings/[[section]]"; + RouteParams(): { + "/(chat)/chat/[id]": { id: string }; + "/settings/[[section]]": { section?: string | undefined } + }; + LayoutParams(): { + "/(chat)": { id?: string | undefined }; + "/": { id?: string | undefined; section?: string | undefined }; + "/agents": Record; + "/(chat)/chat": { id?: string | undefined }; + "/(chat)/chat/[id]": { id: string }; + "/mcp-servers": Record; + "/search": Record; + "/settings": { section?: string | undefined }; + "/settings/[[section]]": { section?: string | undefined } + }; + Pathname(): "/" | "/agents" | `/chat/${string}` & {} | "/mcp-servers" | "/search" | `/settings${string}` & {}; + ResolvedPathname(): `${"" | `/${string}`}${ReturnType}`; + Asset(): "/apple-splash-landscape-1136x640.png" | "/apple-splash-landscape-1334x750.png" | "/apple-splash-landscape-2266x1488.png" | "/apple-splash-landscape-2360x1640.png" | "/apple-splash-landscape-2388x1668.png" | "/apple-splash-landscape-2532x1170.png" | "/apple-splash-landscape-2556x1179.png" | "/apple-splash-landscape-2622x1206.png" | "/apple-splash-landscape-2732x2048.png" | "/apple-splash-landscape-2778x1284.png" | "/apple-splash-landscape-2796x1290.png" | "/apple-splash-landscape-2868x1320.png" | "/apple-splash-landscape-dark-1136x640.png" | "/apple-splash-landscape-dark-1334x750.png" | "/apple-splash-landscape-dark-2266x1488.png" | "/apple-splash-landscape-dark-2360x1640.png" | "/apple-splash-landscape-dark-2388x1668.png" | "/apple-splash-landscape-dark-2532x1170.png" | "/apple-splash-landscape-dark-2556x1179.png" | "/apple-splash-landscape-dark-2622x1206.png" | "/apple-splash-landscape-dark-2732x2048.png" | "/apple-splash-landscape-dark-2778x1284.png" | "/apple-splash-landscape-dark-2796x1290.png" | "/apple-splash-landscape-dark-2868x1320.png" | "/apple-splash-portrait-1170x2532.png" | "/apple-splash-portrait-1179x2556.png" | "/apple-splash-portrait-1206x2622.png" | "/apple-splash-portrait-1284x2778.png" | "/apple-splash-portrait-1290x2796.png" | "/apple-splash-portrait-1320x2868.png" | "/apple-splash-portrait-1488x2266.png" | "/apple-splash-portrait-1640x2360.png" | "/apple-splash-portrait-1668x2388.png" | "/apple-splash-portrait-2048x2732.png" | "/apple-splash-portrait-640x1136.png" | "/apple-splash-portrait-750x1334.png" | "/apple-splash-portrait-dark-1170x2532.png" | "/apple-splash-portrait-dark-1179x2556.png" | "/apple-splash-portrait-dark-1206x2622.png" | "/apple-splash-portrait-dark-1284x2778.png" | "/apple-splash-portrait-dark-1290x2796.png" | "/apple-splash-portrait-dark-1320x2868.png" | "/apple-splash-portrait-dark-1488x2266.png" | "/apple-splash-portrait-dark-1640x2360.png" | "/apple-splash-portrait-dark-1668x2388.png" | "/apple-splash-portrait-dark-2048x2732.png" | "/apple-splash-portrait-dark-640x1136.png" | "/apple-splash-portrait-dark-750x1334.png" | "/apple-touch-icon-180x180.png" | "/favicon-dark.ico" | "/favicon-dark.svg" | "/favicon.ico" | "/favicon.svg" | "/maskable-icon-512x512.png" | "/pwa-192x192.png" | "/pwa-512x512.png" | "/pwa-64x64.png" | "/recommended-mcp/context7.png" | "/recommended-mcp/exa.ico" | "/recommended-mcp/github-dark.png" | "/recommended-mcp/github-light.png" | "/recommended-mcp/huggingface.ico" | string & {}; + } +} \ No newline at end of file diff --git a/tools/ui/.svelte-kit/output/client/.vite/manifest.json b/tools/ui/.svelte-kit/output/client/.vite/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..90252579e452d43524ab770052b40aa3a5a2c87a --- /dev/null +++ b/tools/ui/.svelte-kit/output/client/.vite/manifest.json @@ -0,0 +1,11 @@ +{ + "node_modules/@sveltejs/kit/src/runtime/client/bundle.js": { + "file": "_app/immutable/bundle.Yxmpoeis.js", + "name": "bundle", + "src": "node_modules/@sveltejs/kit/src/runtime/client/bundle.js", + "isEntry": true, + "css": [ + "_app/immutable/assets/bundle.S65JMH_w.css" + ] + } +} \ No newline at end of file diff --git a/tools/ui/.svelte-kit/output/client/_app/immutable/assets/bundle.S65JMH_w.css b/tools/ui/.svelte-kit/output/client/_app/immutable/assets/bundle.S65JMH_w.css new file mode 100644 index 0000000000000000000000000000000000000000..a3e87d14449e78cd5b81f28746887d4e9d950f43 --- /dev/null +++ b/tools/ui/.svelte-kit/output/client/_app/immutable/assets/bundle.S65JMH_w.css @@ -0,0 +1 @@ +@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-space-x-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial;--tw-content:"";--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0}}}@layer theme{:root,:host{--font-sans:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-mono:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--color-red-300:oklch(80.8% .114 19.571);--color-red-400:oklch(70.4% .191 22.216);--color-red-500:oklch(63.7% .237 25.331);--color-red-600:oklch(57.7% .245 27.325);--color-red-700:oklch(50.5% .213 27.518);--color-orange-50:oklch(98% .016 73.684);--color-orange-100:oklch(95.4% .038 75.164);--color-orange-200:oklch(90.1% .076 70.697);--color-orange-400:oklch(75% .183 55.934);--color-orange-600:oklch(64.6% .222 41.116);--color-orange-800:oklch(47% .157 37.304);--color-orange-900:oklch(40.8% .123 38.172);--color-orange-950:oklch(26.6% .079 36.259);--color-amber-300:oklch(87.9% .169 91.605);--color-amber-400:oklch(82.8% .189 84.429);--color-amber-500:oklch(76.9% .188 70.08);--color-amber-600:oklch(66.6% .179 58.318);--color-amber-700:oklch(55.5% .163 48.998);--color-yellow-200:oklch(94.5% .129 101.54);--color-yellow-400:oklch(85.2% .199 91.936);--color-yellow-500:oklch(79.5% .184 86.047);--color-yellow-600:oklch(68.1% .162 75.834);--color-green-50:oklch(98.2% .018 155.826);--color-green-300:oklch(87.1% .15 154.449);--color-green-400:oklch(79.2% .209 151.711);--color-green-500:oklch(72.3% .219 149.579);--color-green-600:oklch(62.7% .194 149.214);--color-green-700:oklch(52.7% .154 150.069);--color-green-950:oklch(26.6% .065 152.934);--color-cyan-50:oklch(98.4% .019 200.873);--color-cyan-400:oklch(78.9% .154 211.53);--color-cyan-600:oklch(60.9% .126 221.723);--color-cyan-950:oklch(30.2% .056 229.695);--color-blue-50:oklch(97% .014 254.604);--color-blue-200:oklch(88.2% .059 254.128);--color-blue-400:oklch(70.7% .165 254.624);--color-blue-600:oklch(54.6% .245 262.881);--color-blue-700:oklch(48.8% .243 264.376);--color-blue-950:oklch(28.2% .091 267.935);--color-purple-50:oklch(97.7% .014 308.299);--color-purple-100:oklch(94.6% .033 307.174);--color-purple-200:oklch(90.2% .063 306.703);--color-purple-300:oklch(82.7% .119 306.383);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-purple-600:oklch(55.8% .288 302.321);--color-purple-700:oklch(49.6% .265 301.924);--color-purple-800:oklch(43.8% .218 303.724);--color-purple-900:oklch(38.1% .176 304.987);--color-purple-950:oklch(29.1% .149 302.717);--color-pink-50:oklch(97.1% .014 343.198);--color-pink-400:oklch(71.8% .202 349.761);--color-pink-600:oklch(59.2% .249 .584);--color-pink-950:oklch(28.4% .109 3.907);--color-gray-400:oklch(70.7% .022 261.325);--color-gray-500:oklch(55.1% .027 264.364);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-sm:24rem;--container-md:28rem;--container-lg:32rem;--container-2xl:42rem;--container-3xl:48rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1/.75);--text-sm:.875rem;--text-sm--line-height:calc(1.25/.875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75/1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75/1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2/1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-tight:1.25;--leading-snug:1.375;--leading-relaxed:1.625;--radius-xs:.125rem;--radius-2xl:1rem;--radius-3xl:1.5rem;--radius-4xl:2rem;--ease-out:cubic-bezier(0,0,.2,1);--ease-in-out:cubic-bezier(.4,0,.2,1);--animate-spin:spin 1s linear infinite;--animate-pulse:pulse 2s cubic-bezier(.4,0,.6,1)infinite;--blur-xs:4px;--blur-sm:8px;--blur-md:12px;--blur-lg:16px;--blur-xl:24px;--blur-2xl:40px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4,0,.2,1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-foreground:var(--foreground)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){*{outline-color:color-mix(in oklab,var(--ring)50%,transparent)}}body{background-color:var(--background);color:var(--foreground);scrollbar-width:thin;scrollbar-gutter:stable;background-image:radial-gradient(at 50% 115%,#5c010959,#0000 60%),radial-gradient(at 85% -10%,#0026312e,#0000 55%);background-image:radial-gradient(at 50% 115%,#5c010959,#0000 60%),radial-gradient(at 85% -10%,color(xyz 0.012 0.016 0.037 / 0.18),#0000 55%)}body:before{content:"";pointer-events:none;z-index:999990;opacity:.35;background:repeating-linear-gradient(0deg,#00000038 0% 1px,#0000 1px 3px),radial-gradient(#0000 55%,#0600008c);position:fixed;inset:0}body:after{content:"";pointer-events:none;z-index:999990;background:radial-gradient(circle at 50% 120%,var(--ember),transparent 70%),radial-gradient(circle at 12% 8%,oklch(78% .18 220/.12),transparent 40%);opacity:.22;mix-blend-mode:screen;position:fixed;inset:0}::selection{background:var(--flame);color:var(--background);text-shadow:0 0 8px var(--gold)}*{scrollbar-width:thin;scrollbar-color:transparent transparent}:hover{scrollbar-color:var(--flame)transparent}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:0 0;border-radius:3px;transition:background .2s}:hover::-webkit-scrollbar-thumb{background:var(--flame)}::-webkit-scrollbar-thumb:hover{background:var(--gold)}:where(code,pre,kbd,samp){font-family:var(--font-mono)}[type=text],input:where(:not([type])),[type=email],[type=url],[type=password],[type=number],[type=date],[type=datetime-local],[type=month],[type=search],[type=tel],[type=time],[type=week],[multiple],textarea,select{appearance:none;--tw-shadow:0 0 #0000;background-color:#fff;border-width:1px;border-color:#6a7282;border-radius:0;padding:.5rem .75rem;font-size:1rem;line-height:1.5rem}:is([type=text],input:where(:not([type])),[type=email],[type=url],[type=password],[type=number],[type=date],[type=datetime-local],[type=month],[type=search],[type=tel],[type=time],[type=week],[multiple],textarea,select):focus{outline-offset:2px;--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:oklch(54.6% .245 262.881);--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow);border-color:#155dfc;outline:2px solid #0000}input::placeholder,textarea::placeholder{color:#6a7282;opacity:1}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-date-and-time-value{min-height:1.5em}::-webkit-date-and-time-value{text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-year-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-month-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-day-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-hour-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-minute-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-second-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-millisecond-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-meridiem-field{padding-top:0;padding-bottom:0}select{-webkit-print-color-adjust:exact;print-color-adjust:exact;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='oklch(55.1%25 0.027 264.364)' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e");background-position:right .5rem center;background-repeat:no-repeat;background-size:1.5em 1.5em;padding-right:2.5rem}[multiple],[size]:where(select:not([size="1"])){background-image:initial;background-position:initial;background-repeat:unset;background-size:initial;-webkit-print-color-adjust:unset;print-color-adjust:unset;padding-right:.75rem}[type=checkbox],[type=radio]{appearance:none;-webkit-print-color-adjust:exact;print-color-adjust:exact;vertical-align:middle;-webkit-user-select:none;user-select:none;color:#155dfc;--tw-shadow:0 0 #0000;background-color:#fff;background-origin:border-box;border-width:1px;border-color:#6a7282;flex-shrink:0;width:1rem;height:1rem;padding:0;display:inline-block}[type=checkbox]{border-radius:0}[type=radio]{border-radius:100%}[type=checkbox]:focus,[type=radio]:focus{outline-offset:2px;--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:2px;--tw-ring-offset-color:#fff;--tw-ring-color:oklch(54.6% .245 262.881);--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow);outline:2px solid #0000}[type=checkbox]:checked,[type=radio]:checked{background-color:currentColor;background-position:50%;background-repeat:no-repeat;background-size:100% 100%;border-color:#0000}[type=checkbox]:checked{background-image:url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M12.207 4.793a1 1 0 010 1.414l-5 5a1 1 0 01-1.414 0l-2-2a1 1 0 011.414-1.414L6.5 9.086l4.293-4.293a1 1 0 011.414 0z'/%3e%3c/svg%3e")}@media(forced-colors:active){[type=checkbox]:checked{appearance:auto}}[type=radio]:checked{background-image:url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3ccircle cx='8' cy='8' r='3'/%3e%3c/svg%3e")}@media(forced-colors:active){[type=radio]:checked{appearance:auto}}[type=checkbox]:checked:hover,[type=checkbox]:checked:focus,[type=radio]:checked:hover,[type=radio]:checked:focus{background-color:currentColor;border-color:#0000}[type=checkbox]:indeterminate{background-color:currentColor;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 16 16'%3e%3cpath stroke='white' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M4 8h8'/%3e%3c/svg%3e");background-position:50%;background-repeat:no-repeat;background-size:100% 100%;border-color:#0000}@media(forced-colors:active){[type=checkbox]:indeterminate{appearance:auto}}[type=checkbox]:indeterminate:hover,[type=checkbox]:indeterminate:focus{background-color:currentColor;border-color:#0000}[type=file]{background:unset;border-color:inherit;font-size:unset;line-height:inherit;border-width:0;border-radius:0;padding:0}[type=file]:focus{outline:1px solid buttontext;outline:1px auto -webkit-focus-ring-color}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.\@container{container-type:inline-size}.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip:rect(0,0,0,0);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing)*0)}.inset-x-0{inset-inline:calc(var(--spacing)*0)}.inset-y-0{inset-block:calc(var(--spacing)*0)}.top-0{top:calc(var(--spacing)*0)}.top-1{top:calc(var(--spacing)*1)}.top-1\/2{top:50%}.top-2{top:calc(var(--spacing)*2)}.top-4{top:calc(var(--spacing)*4)}.top-4\.5{top:calc(var(--spacing)*4.5)}.top-10{top:calc(var(--spacing)*10)}.top-\[50\%\]{top:50%}.top-full{top:100%}.right-0{right:calc(var(--spacing)*0)}.right-1{right:calc(var(--spacing)*1)}.right-2{right:calc(var(--spacing)*2)}.right-3{right:calc(var(--spacing)*3)}.right-4{right:calc(var(--spacing)*4)}.right-8{right:calc(var(--spacing)*8)}.bottom-0{bottom:calc(var(--spacing)*0)}.bottom-1{bottom:calc(var(--spacing)*1)}.bottom-2{bottom:calc(var(--spacing)*2)}.bottom-4{bottom:calc(var(--spacing)*4)}.bottom-6{bottom:calc(var(--spacing)*6)}.bottom-8{bottom:calc(var(--spacing)*8)}.bottom-32{bottom:calc(var(--spacing)*32)}.left-0{left:calc(var(--spacing)*0)}.left-1\/2{left:50%}.left-2{left:calc(var(--spacing)*2)}.left-3{left:calc(var(--spacing)*3)}.left-4{left:calc(var(--spacing)*4)}.left-\[50\%\]{left:50%}.isolate{isolation:isolate}.z-10{z-index:10}.z-50{z-index:50}.z-9999{z-index:9999}.z-999999{z-index:999999}.z-1000000{z-index:1000000}.z-1000001{z-index:1000001}.z-\[20\]{z-index:20}.z-\[1000\]{z-index:1000}.z-\[9999\]{z-index:9999}.z-\[999999\]{z-index:999999}.z-\[var\(--layer-popover\,1000000\)\]{z-index:var(--layer-popover,1000000)}.col-start-2{grid-column-start:2}.row-span-2{grid-row:span 2/span 2}.row-start-1{grid-row-start:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.m-0{margin:calc(var(--spacing)*0)}.m-2{margin:calc(var(--spacing)*2)}.-mx-1{margin-inline:calc(var(--spacing)*-1)}.-mx-2{margin-inline:calc(var(--spacing)*-2)}.mx-1{margin-inline:calc(var(--spacing)*1)}.mx-auto{margin-inline:auto}.-my-1{margin-block:calc(var(--spacing)*-1)}.-my-2{margin-block:calc(var(--spacing)*-2)}.my-0\!{margin-block:calc(var(--spacing)*0)!important}.my-1{margin-block:calc(var(--spacing)*1)}.my-1\.5{margin-block:calc(var(--spacing)*1.5)}.my-2{margin-block:calc(var(--spacing)*2)}.my-6{margin-block:calc(var(--spacing)*6)}.prose{color:var(--tw-prose-body);max-width:65ch}.prose :where(p):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em}.prose :where([class~=lead]):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-lead);margin-top:1.2em;margin-bottom:1.2em;font-size:1.25em;line-height:1.6}.prose :where(a):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-links);font-weight:500;text-decoration:underline}.prose :where(strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-bold);font-weight:600}.prose :where(a strong):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(blockquote strong):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(thead th strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(ol):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em;padding-inline-start:1.625em;list-style-type:decimal}.prose :where(ol[type=A]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-alpha}.prose :where(ol[type=a]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-alpha}.prose :where(ol[type=A s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-alpha}.prose :where(ol[type=a s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-alpha}.prose :where(ol[type=I]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-roman}.prose :where(ol[type=i]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-roman}.prose :where(ol[type=I s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-roman}.prose :where(ol[type=i s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-roman}.prose :where(ol[type="1"]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:decimal}.prose :where(ul):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em;padding-inline-start:1.625em;list-style-type:disc}.prose :where(ol>li):not(:where([class~=not-prose],[class~=not-prose] *))::marker{color:var(--tw-prose-counters);font-weight:400}.prose :where(ul>li):not(:where([class~=not-prose],[class~=not-prose] *))::marker{color:var(--tw-prose-bullets)}.prose :where(dt):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.25em;font-weight:600}.prose :where(hr):not(:where([class~=not-prose],[class~=not-prose] *)){border-color:var(--tw-prose-hr);border-top-width:1px;margin-top:3em;margin-bottom:3em}.prose :where(blockquote):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-quotes);border-inline-start-width:.25rem;border-inline-start-color:var(--tw-prose-quote-borders);quotes:"“""”""‘""’";margin-top:1.6em;margin-bottom:1.6em;padding-inline-start:1em;font-style:italic;font-weight:500}.prose :where(blockquote p:first-of-type):not(:where([class~=not-prose],[class~=not-prose] *)):before{content:open-quote}.prose :where(blockquote p:last-of-type):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:close-quote}.prose :where(h1):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:0;margin-bottom:.888889em;font-size:2.25em;font-weight:800;line-height:1.11111}.prose :where(h1 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:900}.prose :where(h2):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:2em;margin-bottom:1em;font-size:1.5em;font-weight:700;line-height:1.33333}.prose :where(h2 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:800}.prose :where(h3):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.6em;margin-bottom:.6em;font-size:1.25em;font-weight:600;line-height:1.6}.prose :where(h3 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:700}.prose :where(h4):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.5em;margin-bottom:.5em;font-weight:600;line-height:1.5}.prose :where(h4 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:700}.prose :where(img):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(picture):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em;display:block}.prose :where(video):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(kbd):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-kbd);box-shadow:0 0 0 1px rgb(var(--tw-prose-kbd-shadows)/10%),0 3px rgb(var(--tw-prose-kbd-shadows)/10%);padding-top:.1875em;padding-inline-end:.375em;padding-bottom:.1875em;border-radius:.3125rem;padding-inline-start:.375em;font-family:inherit;font-size:.875em;font-weight:500}.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-code);font-size:.875em;font-weight:600}.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)):before,.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:"`"}.prose :where(a code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h1 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(h2 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-size:.875em}.prose :where(h3 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-size:.9em}.prose :where(h4 code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(blockquote code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(thead th code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(pre):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-pre-code);background-color:var(--tw-prose-pre-bg);padding-top:.857143em;padding-inline-end:1.14286em;padding-bottom:.857143em;border-radius:.375rem;margin-top:1.71429em;margin-bottom:1.71429em;padding-inline-start:1.14286em;font-size:.875em;font-weight:400;line-height:1.71429;overflow-x:auto}.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)){font-weight:inherit;color:inherit;font-size:inherit;font-family:inherit;line-height:inherit;background-color:#0000;border-width:0;border-radius:0;padding:0}.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)):before,.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:none}.prose :where(table):not(:where([class~=not-prose],[class~=not-prose] *)){table-layout:auto;width:100%;margin-top:2em;margin-bottom:2em;font-size:.875em;line-height:1.71429}.prose :where(thead):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:1px;border-bottom-color:var(--tw-prose-th-borders)}.prose :where(thead th):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);vertical-align:bottom;padding-inline-end:.571429em;padding-bottom:.571429em;padding-inline-start:.571429em;font-weight:600}.prose :where(tbody tr):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:1px;border-bottom-color:var(--tw-prose-td-borders)}.prose :where(tbody tr:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:0}.prose :where(tbody td):not(:where([class~=not-prose],[class~=not-prose] *)){vertical-align:baseline}.prose :where(tfoot):not(:where([class~=not-prose],[class~=not-prose] *)){border-top-width:1px;border-top-color:var(--tw-prose-th-borders)}.prose :where(tfoot td):not(:where([class~=not-prose],[class~=not-prose] *)){vertical-align:top}.prose :where(th,td):not(:where([class~=not-prose],[class~=not-prose] *)){text-align:start}.prose :where(figure>*):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0;margin-bottom:0}.prose :where(figcaption):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-captions);margin-top:.857143em;font-size:.875em;line-height:1.42857}.prose{--tw-prose-body:oklch(37.3% .034 259.733);--tw-prose-headings:oklch(21% .034 264.665);--tw-prose-lead:oklch(44.6% .03 256.802);--tw-prose-links:oklch(21% .034 264.665);--tw-prose-bold:oklch(21% .034 264.665);--tw-prose-counters:oklch(55.1% .027 264.364);--tw-prose-bullets:oklch(87.2% .01 258.338);--tw-prose-hr:oklch(92.8% .006 264.531);--tw-prose-quotes:oklch(21% .034 264.665);--tw-prose-quote-borders:oklch(92.8% .006 264.531);--tw-prose-captions:oklch(55.1% .027 264.364);--tw-prose-kbd:oklch(21% .034 264.665);--tw-prose-kbd-shadows:NaN NaN NaN;--tw-prose-code:oklch(21% .034 264.665);--tw-prose-pre-code:oklch(92.8% .006 264.531);--tw-prose-pre-bg:oklch(27.8% .033 256.848);--tw-prose-th-borders:oklch(87.2% .01 258.338);--tw-prose-td-borders:oklch(92.8% .006 264.531);--tw-prose-invert-body:oklch(87.2% .01 258.338);--tw-prose-invert-headings:#fff;--tw-prose-invert-lead:oklch(70.7% .022 261.325);--tw-prose-invert-links:#fff;--tw-prose-invert-bold:#fff;--tw-prose-invert-counters:oklch(70.7% .022 261.325);--tw-prose-invert-bullets:oklch(44.6% .03 256.802);--tw-prose-invert-hr:oklch(37.3% .034 259.733);--tw-prose-invert-quotes:oklch(96.7% .003 264.542);--tw-prose-invert-quote-borders:oklch(37.3% .034 259.733);--tw-prose-invert-captions:oklch(70.7% .022 261.325);--tw-prose-invert-kbd:#fff;--tw-prose-invert-kbd-shadows:255 255 255;--tw-prose-invert-code:#fff;--tw-prose-invert-pre-code:oklch(87.2% .01 258.338);--tw-prose-invert-pre-bg:#00000080;--tw-prose-invert-th-borders:oklch(44.6% .03 256.802);--tw-prose-invert-td-borders:oklch(37.3% .034 259.733);font-size:1rem;line-height:1.75}.prose :where(picture>img):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0;margin-bottom:0}.prose :where(li):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.5em;margin-bottom:.5em}.prose :where(ol>li):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(ul>li):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:.375em}.prose :where(.prose>ul>li p):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.75em;margin-bottom:.75em}.prose :where(.prose>ul>li>p:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em}.prose :where(.prose>ul>li>p:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:1.25em}.prose :where(.prose>ol>li>p:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em}.prose :where(.prose>ol>li>p:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:1.25em}.prose :where(ul ul,ul ol,ol ul,ol ol):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.75em;margin-bottom:.75em}.prose :where(dl):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em}.prose :where(dd):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.5em;padding-inline-start:1.625em}.prose :where(hr+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h2+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h3+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h4+*):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0}.prose :where(thead th:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:0}.prose :where(thead th:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-end:0}.prose :where(tbody td,tfoot td):not(:where([class~=not-prose],[class~=not-prose] *)){padding-top:.571429em;padding-inline-end:.571429em;padding-bottom:.571429em;padding-inline-start:.571429em}.prose :where(tbody td:first-child,tfoot td:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:0}.prose :where(tbody td:last-child,tfoot td:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-end:0}.prose :where(figure):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(.prose>:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0}.prose :where(.prose>:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:0}.-mt-1{margin-top:calc(var(--spacing)*-1)}.mt-0{margin-top:calc(var(--spacing)*0)}.mt-0\.5{margin-top:calc(var(--spacing)*.5)}.mt-0\.75{margin-top:calc(var(--spacing)*.75)}.mt-1{margin-top:calc(var(--spacing)*1)}.mt-1\.5{margin-top:calc(var(--spacing)*1.5)}.mt-2{margin-top:calc(var(--spacing)*2)}.mt-3{margin-top:calc(var(--spacing)*3)}.mt-4{margin-top:calc(var(--spacing)*4)}.mt-6{margin-top:calc(var(--spacing)*6)}.mt-8{margin-top:calc(var(--spacing)*8)}.mt-12{margin-top:calc(var(--spacing)*12)}.mt-auto{margin-top:auto}.-mr-1{margin-right:calc(var(--spacing)*-1)}.-mr-1\.5{margin-right:calc(var(--spacing)*-1.5)}.mr-1{margin-right:calc(var(--spacing)*1)}.mr-2{margin-right:calc(var(--spacing)*2)}.mr-auto{margin-right:auto}.mb-0\.5{margin-bottom:calc(var(--spacing)*.5)}.mb-1{margin-bottom:calc(var(--spacing)*1)}.mb-1\.5{margin-bottom:calc(var(--spacing)*1.5)}.mb-2{margin-bottom:calc(var(--spacing)*2)}.mb-3{margin-bottom:calc(var(--spacing)*3)}.mb-4{margin-bottom:calc(var(--spacing)*4)}.mb-6{margin-bottom:calc(var(--spacing)*6)}.mb-8{margin-bottom:calc(var(--spacing)*8)}.mb-10{margin-bottom:calc(var(--spacing)*10)}.mb-\[calc\(50dvh-8rem\)\]{margin-bottom:calc(50dvh - 8rem)}.ml-1{margin-left:calc(var(--spacing)*1)}.ml-2{margin-left:calc(var(--spacing)*2)}.ml-3{margin-left:calc(var(--spacing)*3)}.ml-4{margin-left:calc(var(--spacing)*4)}.ml-11{margin-left:calc(var(--spacing)*11)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-5{-webkit-line-clamp:5;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.block\!{display:block!important}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-block{display:inline-block}.inline-flex{display:inline-flex}.inline-grid{display:inline-grid}.table{display:table}.table-caption{display:table-caption}.table-cell{display:table-cell}.table-row{display:table-row}.field-sizing-content{field-sizing:content}.aspect-square{aspect-ratio:1}.size-2{width:calc(var(--spacing)*2);height:calc(var(--spacing)*2)}.size-2\.5{width:calc(var(--spacing)*2.5);height:calc(var(--spacing)*2.5)}.size-3{width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.size-3\.5{width:calc(var(--spacing)*3.5);height:calc(var(--spacing)*3.5)}.size-4{width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.size-5{width:calc(var(--spacing)*5);height:calc(var(--spacing)*5)}.size-8{width:calc(var(--spacing)*8);height:calc(var(--spacing)*8)}.size-9{width:calc(var(--spacing)*9);height:calc(var(--spacing)*9)}.size-10{width:calc(var(--spacing)*10);height:calc(var(--spacing)*10)}.size-full{width:100%;height:100%}.\!h-0{height:calc(var(--spacing)*0)!important}.\!h-4{height:calc(var(--spacing)*4)!important}.h-\(--bits-select-anchor-height\){height:var(--bits-select-anchor-height)}.h-0{height:calc(var(--spacing)*0)}.h-0\!{height:calc(var(--spacing)*0)!important}.h-0\.5{height:calc(var(--spacing)*.5)}.h-1{height:calc(var(--spacing)*1)}.h-1\.5{height:calc(var(--spacing)*1.5)}.h-2{height:calc(var(--spacing)*2)}.h-2\.5{height:calc(var(--spacing)*2.5)}.h-3{height:calc(var(--spacing)*3)}.h-3\.5{height:calc(var(--spacing)*3.5)}.h-4{height:calc(var(--spacing)*4)}.h-4\.5{height:calc(var(--spacing)*4.5)}.h-5{height:calc(var(--spacing)*5)}.h-6{height:calc(var(--spacing)*6)}.h-7{height:calc(var(--spacing)*7)}.h-8{height:calc(var(--spacing)*8)}.h-9{height:calc(var(--spacing)*9)}.h-10{height:calc(var(--spacing)*10)}.h-12{height:calc(var(--spacing)*12)}.h-16{height:calc(var(--spacing)*16)}.h-24{height:calc(var(--spacing)*24)}.h-40{height:calc(var(--spacing)*40)}.h-48{height:calc(var(--spacing)*48)}.h-100{height:calc(var(--spacing)*100)}.h-\[1\.15rem\]{height:1.15rem}.h-\[500px\]{height:500px}.h-\[calc\(100dvh-0\.5rem\)\]{height:calc(100dvh - .5rem)}.h-\[calc\(100dvh-1rem\)\]{height:calc(100dvh - 1rem)}.h-\[calc\(100dvh-2rem\)\]{height:calc(100dvh - 2rem)}.h-auto{height:auto}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.\!max-h-\[50vh\]{max-height:50vh!important}.\!max-h-\[80dvh\]{max-height:80dvh!important}.max-h-\(--bits-dropdown-menu-content-available-height\){max-height:var(--bits-dropdown-menu-content-available-height)}.max-h-\(--bits-select-content-available-height\){max-height:var(--bits-select-content-available-height)}.max-h-24{max-height:calc(var(--spacing)*24)}.max-h-32{max-height:calc(var(--spacing)*32)}.max-h-48{max-height:calc(var(--spacing)*48)}.max-h-64{max-height:calc(var(--spacing)*64)}.max-h-80{max-height:calc(var(--spacing)*80)}.max-h-96{max-height:calc(var(--spacing)*96)}.max-h-\[60vh\]{max-height:60vh}.max-h-\[70vh\]{max-height:70vh}.max-h-\[80vh\]{max-height:80vh}.max-h-\[85vh\]{max-height:85vh}.max-h-\[90vh\]{max-height:90vh}.max-h-\[100dvh\]{max-height:100dvh}.max-h-full{max-height:100%}.min-h-0{min-height:calc(var(--spacing)*0)}.min-h-4{min-height:calc(var(--spacing)*4)}.min-h-9{min-height:calc(var(--spacing)*9)}.min-h-12{min-height:calc(var(--spacing)*12)}.min-h-16{min-height:calc(var(--spacing)*16)}.min-h-22{min-height:calc(var(--spacing)*22)}.min-h-\[10rem\]{min-height:10rem}.min-h-\[60px\]{min-height:60px}.min-h-\[200px\]{min-height:200px}.min-h-\[calc\(100dvh-1rem\)\]{min-height:calc(100dvh - 1rem)}.min-h-\[calc\(100dvh-4rem\)\]{min-height:calc(100dvh - 4rem)}.min-h-fit{min-height:fit-content}.min-h-full{min-height:100%}.\!w-4{width:calc(var(--spacing)*4)!important}.w-0{width:calc(var(--spacing)*0)}.w-1{width:calc(var(--spacing)*1)}.w-1\/3{width:33.3333%}.w-2{width:calc(var(--spacing)*2)}.w-2\.5{width:calc(var(--spacing)*2.5)}.w-2\/5{width:40%}.w-3{width:calc(var(--spacing)*3)}.w-3\.5{width:calc(var(--spacing)*3.5)}.w-3\/4{width:75%}.w-4{width:calc(var(--spacing)*4)}.w-4\.5{width:calc(var(--spacing)*4.5)}.w-5{width:calc(var(--spacing)*5)}.w-5\/6{width:83.3333%}.w-6{width:calc(var(--spacing)*6)}.w-7{width:calc(var(--spacing)*7)}.w-8{width:calc(var(--spacing)*8)}.w-9{width:calc(var(--spacing)*9)}.w-10{width:calc(var(--spacing)*10)}.w-11{width:calc(var(--spacing)*11)}.w-12{width:calc(var(--spacing)*12)}.w-14{width:calc(var(--spacing)*14)}.w-16{width:calc(var(--spacing)*16)}.w-20{width:calc(var(--spacing)*20)}.w-24{width:calc(var(--spacing)*24)}.w-28{width:calc(var(--spacing)*28)}.w-32{width:calc(var(--spacing)*32)}.w-36{width:calc(var(--spacing)*36)}.w-40{width:calc(var(--spacing)*40)}.w-48{width:calc(var(--spacing)*48)}.w-52{width:calc(var(--spacing)*52)}.w-60{width:calc(var(--spacing)*60)}.w-64{width:calc(var(--spacing)*64)}.w-72{width:calc(var(--spacing)*72)}.w-80{width:calc(var(--spacing)*80)}.w-96{width:calc(var(--spacing)*96)}.w-\[10rem\]{width:10rem}.w-\[56rem\]{width:56rem}.w-\[calc\(100dvw-1rem\)\]{width:calc(100dvw - 1rem)}.w-\[calc\(100vw-2rem\)\]{width:calc(100vw - 2rem)}.w-\[var\(--bits-popover-anchor-width\)\]{width:var(--bits-popover-anchor-width)}.w-auto{width:auto}.w-fit{width:fit-content}.w-full{width:100%}.w-px{width:1px}.\!max-w-4xl{max-width:var(--container-4xl)!important}.\!max-w-\[60rem\]{max-width:60rem!important}.max-w-2xl{max-width:var(--container-2xl)}.max-w-3xl{max-width:var(--container-3xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-24{max-width:calc(var(--spacing)*24)}.max-w-36{max-width:calc(var(--spacing)*36)}.max-w-64{max-width:calc(var(--spacing)*64)}.max-w-68{max-width:calc(var(--spacing)*68)}.max-w-72{max-width:calc(var(--spacing)*72)}.max-w-\[48rem\]{max-width:48rem}.max-w-\[56rem\]{max-width:56rem}.max-w-\[80\%\]{max-width:80%}.max-w-\[80vw\]{max-width:80vw}.max-w-\[85vw\]{max-width:85vw}.max-w-\[90vw\]{max-width:90vw}.max-w-\[100vw\]{max-width:100vw}.max-w-\[150px\]{max-width:150px}.max-w-\[300px\]{max-width:300px}.max-w-\[calc\(100\%-2rem\)\]{max-width:calc(100% - 2rem)}.max-w-full{max-width:100%}.max-w-full\!{max-width:100%!important}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-none{max-width:none}.max-w-sm{max-width:var(--container-sm)}.max-w-xs{max-width:var(--container-xs)}.min-w-\(--bits-select-anchor-width\){min-width:var(--bits-select-anchor-width)}.min-w-0{min-width:calc(var(--spacing)*0)}.min-w-9{min-width:calc(var(--spacing)*9)}.min-w-\[3\.5rem\]{min-width:3.5rem}.min-w-\[8rem\]{min-width:8rem}.min-w-\[200px\]{min-width:200px}.min-w-fit{min-width:fit-content}.min-w-max{min-width:max-content}.flex-1{flex:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.caption-bottom{caption-side:bottom}.origin-\(--bits-dropdown-menu-content-transform-origin\){transform-origin:var(--bits-dropdown-menu-content-transform-origin)}.origin-\(--bits-popover-content-transform-origin\){transform-origin:var(--bits-popover-content-transform-origin)}.origin-\(--bits-select-content-transform-origin\){transform-origin:var(--bits-select-content-transform-origin)}.origin-\(--bits-tooltip-content-transform-origin\){transform-origin:var(--bits-tooltip-content-transform-origin)}.origin-\(--transform-origin\){transform-origin:var(--transform-origin)}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-x-0{--tw-translate-x:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.-translate-y-1\/2{--tw-translate-y: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-y-0{--tw-translate-y:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.scale-75{--tw-scale-x:75%;--tw-scale-y:75%;--tw-scale-z:75%;scale:var(--tw-scale-x)var(--tw-scale-y)}.rotate-45{rotate:45deg}.rotate-180{rotate:180deg}.transform{transform:var(--tw-rotate-x,)var(--tw-rotate-y,)var(--tw-rotate-z,)var(--tw-skew-x,)var(--tw-skew-y,)}.animate-in{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.\!cursor-not-allowed{cursor:not-allowed!important}.cursor-auto{cursor:auto}.cursor-default{cursor:default}.cursor-not-allowed{cursor:not-allowed}.cursor-pointer{cursor:pointer}.cursor-text{cursor:text}.touch-none{touch-action:none}.resize{resize:both}.resize-none{resize:none}.scroll-my-1{scroll-margin-block:calc(var(--spacing)*1)}.list-inside{list-style-position:inside}.list-disc{list-style-type:disc}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-\[0_1fr\]{grid-template-columns:0 1fr}.grid-cols-\[1fr_auto_1fr\]{grid-template-columns:1fr auto 1fr}.grid-rows-\[1fr_auto\]{grid-template-rows:1fr auto}.grid-rows-\[auto_auto\]{grid-template-rows:auto auto}.flex-col{flex-direction:column}.flex-col-reverse{flex-direction:column-reverse}.flex-row{flex-direction:row}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.justify-end{justify-content:flex-end}.justify-start{justify-content:flex-start}.justify-items-end{justify-items:end}.justify-items-start{justify-items:start}.\!gap-3{gap:calc(var(--spacing)*3)!important}.gap-0{gap:calc(var(--spacing)*0)}.gap-0\.5{gap:calc(var(--spacing)*.5)}.gap-0\.75{gap:calc(var(--spacing)*.75)}.gap-1{gap:calc(var(--spacing)*1)}.gap-1\.5{gap:calc(var(--spacing)*1.5)}.gap-1\.25{gap:calc(var(--spacing)*1.25)}.gap-2{gap:calc(var(--spacing)*2)}.gap-2\.5{gap:calc(var(--spacing)*2.5)}.gap-3{gap:calc(var(--spacing)*3)}.gap-3\!{gap:calc(var(--spacing)*3)!important}.gap-4{gap:calc(var(--spacing)*4)}.gap-5{gap:calc(var(--spacing)*5)}.gap-6{gap:calc(var(--spacing)*6)}.gap-10{gap:calc(var(--spacing)*10)}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*.5)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*.5)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*1)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*1)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*1.5)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*1.5)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*2)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*2)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*3)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*3)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*4)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*4)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*6)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*6)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*8)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*8)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-12>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*12)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*12)*calc(1 - var(--tw-space-y-reverse)))}:where(.-space-x-1>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*-1)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*-1)*calc(1 - var(--tw-space-x-reverse)))}:where(.space-x-2>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*2)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*2)*calc(1 - var(--tw-space-x-reverse)))}:where(.space-x-3>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*3)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*3)*calc(1 - var(--tw-space-x-reverse)))}.gap-y-0\.5{row-gap:calc(var(--spacing)*.5)}.self-start{align-self:flex-start}.self-stretch{align-self:stretch}.justify-self-end{justify-self:flex-end}.justify-self-end-safe{justify-self:safe flex-end}.justify-self-start{justify-self:flex-start}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-x-hidden{overflow-x:hidden}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-3xl{border-radius:var(--radius-3xl)}.rounded-4xl{border-radius:var(--radius-4xl)}.rounded-\[1\.125rem\]{border-radius:1.125rem}.rounded-\[2px\]{border-radius:2px}.rounded-\[4px\]{border-radius:4px}.rounded-\[inherit\]{border-radius:inherit}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.rounded-sm{border-radius:calc(var(--radius) - 4px)}.rounded-xl{border-radius:calc(var(--radius) + 4px)}.rounded-xs{border-radius:var(--radius-xs)}.rounded-t-lg{border-top-left-radius:var(--radius);border-top-right-radius:var(--radius)}.rounded-t-lg\!{border-top-left-radius:var(--radius)!important;border-top-right-radius:var(--radius)!important}.\!rounded-l-none{border-top-left-radius:0!important;border-bottom-left-radius:0!important}.\!rounded-r-none{border-top-right-radius:0!important;border-bottom-right-radius:0!important}.rounded-b-sm{border-bottom-right-radius:calc(var(--radius) - 4px);border-bottom-left-radius:calc(var(--radius) - 4px)}.\!border-2{border-style:var(--tw-border-style)!important;border-width:2px!important}.border{border-style:var(--tw-border-style);border-width:1px}.border-0{border-style:var(--tw-border-style);border-width:0}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-4{border-style:var(--tw-border-style);border-width:4px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-r{border-right-style:var(--tw-border-style);border-right-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-dashed{--tw-border-style:dashed!important;border-style:dashed!important}.border-dashed{--tw-border-style:dashed;border-style:dashed}.border-none{--tw-border-style:none;border-style:none}.\!border-border\/50{border-color:var(--border)!important}@supports (color:color-mix(in lab,red,red)){.\!border-border\/50{border-color:color-mix(in oklab,var(--border)50%,transparent)!important}}.border-amber-500\/40{border-color:#f99c0066}@supports (color:color-mix(in lab,red,red)){.border-amber-500\/40{border-color:color-mix(in oklab,var(--color-amber-500)40%,transparent)}}.border-blue-400\/40{border-color:#54a2ff66}@supports (color:color-mix(in lab,red,red)){.border-blue-400\/40{border-color:color-mix(in oklab,var(--color-blue-400)40%,transparent)}}.border-border,.border-border\/30{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/30{border-color:color-mix(in oklab,var(--border)30%,transparent)}}.border-border\/40{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/40{border-color:color-mix(in oklab,var(--border)40%,transparent)}}.border-border\/50{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/50{border-color:color-mix(in oklab,var(--border)50%,transparent)}}.border-border\/60{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/60{border-color:color-mix(in oklab,var(--border)60%,transparent)}}.border-current{border-color:currentColor}.border-destructive,.border-destructive\/40{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.border-destructive\/40{border-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.border-destructive\/50{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.border-destructive\/50{border-color:color-mix(in oklab,var(--destructive)50%,transparent)}}.border-flame,.border-flame\/30{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/30{border-color:color-mix(in oklab,var(--flame)30%,transparent)}}.border-flame\/40{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/40{border-color:color-mix(in oklab,var(--flame)40%,transparent)}}.border-flame\/50{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/50{border-color:color-mix(in oklab,var(--flame)50%,transparent)}}.border-green-500{border-color:var(--color-green-500)}.border-input{border-color:var(--input)}.border-muted-foreground\/20{border-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.border-muted-foreground\/20{border-color:color-mix(in oklab,var(--muted-foreground)20%,transparent)}}.border-purple-200{border-color:var(--color-purple-200)}.border-red-500\/50{border-color:#fb2c3680}@supports (color:color-mix(in lab,red,red)){.border-red-500\/50{border-color:color-mix(in oklab,var(--color-red-500)50%,transparent)}}.border-transparent{border-color:#0000}.border-white{border-color:var(--color-white)}.border-t-transparent{border-top-color:#0000}.border-l-transparent{border-left-color:#0000}.bg-accent,.bg-accent\/50{background-color:var(--accent)}@supports (color:color-mix(in lab,red,red)){.bg-accent\/50{background-color:color-mix(in oklab,var(--accent)50%,transparent)}}.bg-amber-500{background-color:var(--color-amber-500)}.bg-amber-500\/10{background-color:#f99c001a}@supports (color:color-mix(in lab,red,red)){.bg-amber-500\/10{background-color:color-mix(in oklab,var(--color-amber-500)10%,transparent)}}.bg-amber-500\/20{background-color:#f99c0033}@supports (color:color-mix(in lab,red,red)){.bg-amber-500\/20{background-color:color-mix(in oklab,var(--color-amber-500)20%,transparent)}}.bg-background,.bg-background\/5{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/5{background-color:color-mix(in oklab,var(--background)5%,transparent)}}.bg-background\/25{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/25{background-color:color-mix(in oklab,var(--background)25%,transparent)}}.bg-background\/50{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/50{background-color:color-mix(in oklab,var(--background)50%,transparent)}}.bg-background\/70{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/70{background-color:color-mix(in oklab,var(--background)70%,transparent)}}.bg-black\/5{background-color:#0000000d}@supports (color:color-mix(in lab,red,red)){.bg-black\/5{background-color:color-mix(in oklab,var(--color-black)5%,transparent)}}.bg-black\/50{background-color:#00000080}@supports (color:color-mix(in lab,red,red)){.bg-black\/50{background-color:color-mix(in oklab,var(--color-black)50%,transparent)}}.bg-black\/80{background-color:#000c}@supports (color:color-mix(in lab,red,red)){.bg-black\/80{background-color:color-mix(in oklab,var(--color-black)80%,transparent)}}.bg-black\/85{background-color:#000000d9}@supports (color:color-mix(in lab,red,red)){.bg-black\/85{background-color:color-mix(in oklab,var(--color-black)85%,transparent)}}.bg-blue-50{background-color:var(--color-blue-50)}.bg-blue-50\/60{background-color:#eff6ff99}@supports (color:color-mix(in lab,red,red)){.bg-blue-50\/60{background-color:color-mix(in oklab,var(--color-blue-50)60%,transparent)}}.bg-border,.bg-border\/20{background-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.bg-border\/20{background-color:color-mix(in oklab,var(--border)20%,transparent)}}.bg-border\/50{background-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.bg-border\/50{background-color:color-mix(in oklab,var(--border)50%,transparent)}}.bg-card,.bg-card\/60{background-color:var(--card)}@supports (color:color-mix(in lab,red,red)){.bg-card\/60{background-color:color-mix(in oklab,var(--card)60%,transparent)}}.bg-cyan-50{background-color:var(--color-cyan-50)}.bg-destructive,.bg-destructive\/10{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/10{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.bg-destructive\/15{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/15{background-color:color-mix(in oklab,var(--destructive)15%,transparent)}}.bg-destructive\/20{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/20{background-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.bg-flame,.bg-flame\/5{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.bg-flame\/5{background-color:color-mix(in oklab,var(--flame)5%,transparent)}}.bg-flame\/10{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.bg-flame\/10{background-color:color-mix(in oklab,var(--flame)10%,transparent)}}.bg-foreground\/5{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/5{background-color:color-mix(in oklab,var(--foreground)5%,transparent)}}.bg-foreground\/15{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/15{background-color:color-mix(in oklab,var(--foreground)15%,transparent)}}.bg-foreground\/20{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/20{background-color:color-mix(in oklab,var(--foreground)20%,transparent)}}.bg-gray-500{background-color:var(--color-gray-500)}.bg-green-50{background-color:var(--color-green-50)}.bg-green-500{background-color:var(--color-green-500)}.bg-muted{background-color:var(--muted)}.bg-muted\!{background-color:var(--muted)!important}.bg-muted-foreground\/10{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/10{background-color:color-mix(in oklab,var(--muted-foreground)10%,transparent)}}.bg-muted-foreground\/15{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/15{background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.bg-muted-foreground\/50{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/50{background-color:color-mix(in oklab,var(--muted-foreground)50%,transparent)}}.bg-muted\/10{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/10{background-color:color-mix(in oklab,var(--muted)10%,transparent)}}.bg-muted\/20{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/20{background-color:color-mix(in oklab,var(--muted)20%,transparent)}}.bg-muted\/30{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/30{background-color:color-mix(in oklab,var(--muted)30%,transparent)}}.bg-muted\/40{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/40{background-color:color-mix(in oklab,var(--muted)40%,transparent)}}.bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/50{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}.bg-muted\/60{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/60{background-color:color-mix(in oklab,var(--muted)60%,transparent)}}.bg-muted\/75{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/75{background-color:color-mix(in oklab,var(--muted)75%,transparent)}}.bg-muted\/80{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/80{background-color:color-mix(in oklab,var(--muted)80%,transparent)}}.bg-orange-50{background-color:var(--color-orange-50)}.bg-orange-100{background-color:var(--color-orange-100)}.bg-orange-400{background-color:var(--color-orange-400)}.bg-pink-50{background-color:var(--color-pink-50)}.bg-popover{background-color:var(--popover)}.bg-primary{background-color:var(--primary)}.bg-primary-foreground{background-color:var(--primary-foreground)}.bg-primary\/5{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.bg-primary\/5{background-color:color-mix(in oklab,var(--primary)5%,transparent)}}.bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.bg-primary\/10{background-color:color-mix(in oklab,var(--primary)10%,transparent)}}.bg-purple-50{background-color:var(--color-purple-50)}.bg-purple-200\/60{background-color:#e9d5ff99}@supports (color:color-mix(in lab,red,red)){.bg-purple-200\/60{background-color:color-mix(in oklab,var(--color-purple-200)60%,transparent)}}.bg-purple-300\/50{background-color:#d9b3ff80}@supports (color:color-mix(in lab,red,red)){.bg-purple-300\/50{background-color:color-mix(in oklab,var(--color-purple-300)50%,transparent)}}.bg-purple-500\/10{background-color:#ac4bff1a}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/10{background-color:color-mix(in oklab,var(--color-purple-500)10%,transparent)}}.bg-red-400\/10{background-color:#ff65681a}@supports (color:color-mix(in lab,red,red)){.bg-red-400\/10{background-color:color-mix(in oklab,var(--color-red-400)10%,transparent)}}.bg-red-500{background-color:var(--color-red-500)}.bg-red-500\/10{background-color:#fb2c361a}@supports (color:color-mix(in lab,red,red)){.bg-red-500\/10{background-color:color-mix(in oklab,var(--color-red-500)10%,transparent)}}.bg-secondary{background-color:var(--secondary)}.bg-transparent{background-color:#0000}.bg-transparent\!{background-color:#0000!important}.bg-yellow-200\/60{background-color:#fff08599}@supports (color:color-mix(in lab,red,red)){.bg-yellow-200\/60{background-color:color-mix(in oklab,var(--color-yellow-200)60%,transparent)}}.bg-yellow-500{background-color:var(--color-yellow-500)}.bg-yellow-500\/10{background-color:#edb2001a}@supports (color:color-mix(in lab,red,red)){.bg-yellow-500\/10{background-color:color-mix(in oklab,var(--color-yellow-500)10%,transparent)}}.bg-gradient-to-r{--tw-gradient-position:to right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.bg-gradient-to-t{--tw-gradient-position:to top in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-flame{--tw-gradient-from:var(--flame);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.from-muted{--tw-gradient-from:var(--muted);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.to-ember{--tw-gradient-to:var(--ember);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.to-transparent{--tw-gradient-to:transparent;--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.bg-clip-padding{background-clip:padding-box}.fill-current{fill:currentColor}.fill-muted-foreground{fill:var(--muted-foreground)}.fill-white{fill:var(--color-white)}.stroke-muted-foreground{stroke:var(--muted-foreground)}.object-contain{object-fit:contain}.object-cover{object-fit:cover}.p-0{padding:calc(var(--spacing)*0)}.p-0\.5{padding:calc(var(--spacing)*.5)}.p-1{padding:calc(var(--spacing)*1)}.p-1\.5{padding:calc(var(--spacing)*1.5)}.p-2{padding:calc(var(--spacing)*2)}.p-2\.5{padding:calc(var(--spacing)*2.5)}.p-3{padding:calc(var(--spacing)*3)}.p-3\.5{padding:calc(var(--spacing)*3.5)}.p-4{padding:calc(var(--spacing)*4)}.p-5{padding:calc(var(--spacing)*5)}.p-6{padding:calc(var(--spacing)*6)}.p-8{padding:calc(var(--spacing)*8)}.p-12{padding:calc(var(--spacing)*12)}.p-px{padding:1px}.\!px-2{padding-inline:calc(var(--spacing)*2)!important}.px-0{padding-inline:calc(var(--spacing)*0)}.px-0\.5{padding-inline:calc(var(--spacing)*.5)}.px-1{padding-inline:calc(var(--spacing)*1)}.px-1\.5{padding-inline:calc(var(--spacing)*1.5)}.px-2{padding-inline:calc(var(--spacing)*2)}.px-2\.5{padding-inline:calc(var(--spacing)*2.5)}.px-3{padding-inline:calc(var(--spacing)*3)}.px-3\.75{padding-inline:calc(var(--spacing)*3.75)}.px-4{padding-inline:calc(var(--spacing)*4)}.px-5{padding-inline:calc(var(--spacing)*5)}.px-6{padding-inline:calc(var(--spacing)*6)}.py-0{padding-block:calc(var(--spacing)*0)}.py-0\.5{padding-block:calc(var(--spacing)*.5)}.py-0\.75{padding-block:calc(var(--spacing)*.75)}.py-1{padding-block:calc(var(--spacing)*1)}.py-1\.5{padding-block:calc(var(--spacing)*1.5)}.py-1\.75{padding-block:calc(var(--spacing)*1.75)}.py-2{padding-block:calc(var(--spacing)*2)}.py-2\.5{padding-block:calc(var(--spacing)*2.5)}.py-3{padding-block:calc(var(--spacing)*3)}.py-4{padding-block:calc(var(--spacing)*4)}.py-5{padding-block:calc(var(--spacing)*5)}.py-6{padding-block:calc(var(--spacing)*6)}.py-8{padding-block:calc(var(--spacing)*8)}.py-10{padding-block:calc(var(--spacing)*10)}.py-16{padding-block:calc(var(--spacing)*16)}.pt-0{padding-top:calc(var(--spacing)*0)}.pt-1{padding-top:calc(var(--spacing)*1)}.pt-1\.5{padding-top:calc(var(--spacing)*1.5)}.pt-2{padding-top:calc(var(--spacing)*2)}.pt-3{padding-top:calc(var(--spacing)*3)}.pt-4{padding-top:calc(var(--spacing)*4)}.pt-6{padding-top:calc(var(--spacing)*6)}.pt-10{padding-top:calc(var(--spacing)*10)}.pt-12{padding-top:calc(var(--spacing)*12)}.pt-13{padding-top:calc(var(--spacing)*13)}.pt-16{padding-top:calc(var(--spacing)*16)}.pr-1{padding-right:calc(var(--spacing)*1)}.pr-2{padding-right:calc(var(--spacing)*2)}.pr-8{padding-right:calc(var(--spacing)*8)}.pr-9{padding-right:calc(var(--spacing)*9)}.pr-10{padding-right:calc(var(--spacing)*10)}.pb-0{padding-bottom:calc(var(--spacing)*0)}.pb-0\.5{padding-bottom:calc(var(--spacing)*.5)}.pb-1{padding-bottom:calc(var(--spacing)*1)}.pb-2{padding-bottom:calc(var(--spacing)*2)}.pb-2\.25{padding-bottom:calc(var(--spacing)*2.25)}.pb-3{padding-bottom:calc(var(--spacing)*3)}.pb-4{padding-bottom:calc(var(--spacing)*4)}.pb-6{padding-bottom:calc(var(--spacing)*6)}.pb-48{padding-bottom:calc(var(--spacing)*48)}.pl-1\.5{padding-left:calc(var(--spacing)*1.5)}.pl-2{padding-left:calc(var(--spacing)*2)}.pl-4{padding-left:calc(var(--spacing)*4)}.pl-6{padding-left:calc(var(--spacing)*6)}.pl-8{padding-left:calc(var(--spacing)*8)}.pl-9{padding-left:calc(var(--spacing)*9)}.pl-16{padding-left:calc(var(--spacing)*16)}.text-center{text-align:center}.text-left{text-align:left}.align-middle{vertical-align:middle}.font-mono{font-family:var(--font-mono)}.font-sans{font-family:var(--font-sans)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-sm\/relaxed{font-size:var(--text-sm);line-height:var(--leading-relaxed)}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[12px\]{font-size:12px}.text-\[13px\]{font-size:13px}.leading-5{--tw-leading:calc(var(--spacing)*5);line-height:calc(var(--spacing)*5)}.leading-6{--tw-leading:calc(var(--spacing)*6);line-height:calc(var(--spacing)*6)}.leading-7\.5{--tw-leading:calc(var(--spacing)*7.5);line-height:calc(var(--spacing)*7.5)}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.leading-tight{--tw-leading:var(--leading-tight);line-height:var(--leading-tight)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.text-balance{text-wrap:balance}.break-words,.wrap-break-word{overflow-wrap:break-word}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-line{white-space:pre-line}.whitespace-pre-wrap{white-space:pre-wrap}.\!text-red-400{color:var(--color-red-400)!important}.text-accent-foreground{color:var(--accent-foreground)}.text-amber-400{color:var(--color-amber-400)}.text-amber-500{color:var(--color-amber-500)}.text-amber-600{color:var(--color-amber-600)}.text-blue-600{color:var(--color-blue-600)}.text-blue-700{color:var(--color-blue-700)}.text-card-foreground{color:var(--card-foreground)}.text-current{color:currentColor}.text-cyan-600{color:var(--color-cyan-600)}.text-destructive{color:var(--destructive)}.text-eye{color:var(--eye)}.text-flame{color:var(--flame)}.text-foreground,.text-foreground\/80{color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.text-foreground\/80{color:color-mix(in oklab,var(--foreground)80%,transparent)}}.text-foreground\/90{color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.text-foreground\/90{color:color-mix(in oklab,var(--foreground)90%,transparent)}}.text-gold{color:var(--gold)}.text-green-500{color:var(--color-green-500)}.text-green-600{color:var(--color-green-600)}.text-muted-foreground,.text-muted-foreground\/50{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/50{color:color-mix(in oklab,var(--muted-foreground)50%,transparent)}}.text-muted-foreground\/60{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/60{color:color-mix(in oklab,var(--muted-foreground)60%,transparent)}}.text-muted-foreground\/70{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/70{color:color-mix(in oklab,var(--muted-foreground)70%,transparent)}}.text-muted-foreground\/80{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/80{color:color-mix(in oklab,var(--muted-foreground)80%,transparent)}}.text-orange-600{color:var(--color-orange-600)}.text-orange-800{color:var(--color-orange-800)}.text-pink-600{color:var(--color-pink-600)}.text-popover-foreground,.text-popover-foreground\/85{color:var(--popover-foreground)}@supports (color:color-mix(in lab,red,red)){.text-popover-foreground\/85{color:color-mix(in oklab,var(--popover-foreground)85%,transparent)}}.text-primary{color:var(--primary)}.text-primary-foreground{color:var(--primary-foreground)}.text-purple-600{color:var(--color-purple-600)}.text-purple-700{color:var(--color-purple-700)}.text-purple-900{color:var(--color-purple-900)}.text-red-400{color:var(--color-red-400)}.text-red-500{color:var(--color-red-500)}.text-red-600{color:var(--color-red-600)}.text-secondary-foreground{color:var(--secondary-foreground)}.text-transparent{color:#0000}.text-white{color:var(--color-white)}.text-white\!{color:var(--color-white)!important}.text-white\/50{color:#ffffff80}@supports (color:color-mix(in lab,red,red)){.text-white\/50{color:color-mix(in oklab,var(--color-white)50%,transparent)}}.text-white\/60{color:#fff9}@supports (color:color-mix(in lab,red,red)){.text-white\/60{color:color-mix(in oklab,var(--color-white)60%,transparent)}}.text-white\/70{color:#ffffffb3}@supports (color:color-mix(in lab,red,red)){.text-white\/70{color:color-mix(in oklab,var(--color-white)70%,transparent)}}.text-yellow-600{color:var(--color-yellow-600)}.capitalize{text-transform:capitalize}.lowercase{text-transform:lowercase}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,)var(--tw-slashed-zero,)var(--tw-numeric-figure,)var(--tw-numeric-spacing,)var(--tw-numeric-fraction,)}.no-underline{text-decoration-line:none}.underline{text-decoration-line:underline}.underline-offset-4{text-underline-offset:4px}.opacity-0{opacity:0}.opacity-30{opacity:.3}.opacity-40{opacity:.4}.opacity-50{opacity:.5}.opacity-60{opacity:.6}.opacity-70{opacity:.7}.opacity-80{opacity:.8}.opacity-100{opacity:1}.mix-blend-difference{mix-blend-mode:difference}.\!shadow-none{--tw-shadow:0 0 #0000!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a),0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_1px_2px_0_rgb\(0_0_0_\/_0\.05\)\]{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a),0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-sm{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a),0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a),0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xs{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-0{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(0px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-1{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-flame\/10{--tw-shadow-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.shadow-flame\/10{--tw-shadow-color:color-mix(in oklab,color-mix(in oklab,var(--flame)10%,transparent)var(--tw-shadow-alpha),transparent)}}.ring-flame{--tw-ring-color:var(--flame)}.ring-foreground\/10{--tw-ring-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.ring-foreground\/10{--tw-ring-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.ring-muted{--tw-ring-color:var(--muted)}.ring-primary\/40{--tw-ring-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.ring-primary\/40{--tw-ring-color:color-mix(in oklab,var(--primary)40%,transparent)}}.ring-ring\/10{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.ring-ring\/10{--tw-ring-color:color-mix(in oklab,var(--ring)10%,transparent)}}.ring-offset-background{--tw-ring-offset-color:var(--background)}.outline-hidden{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.outline-hidden{outline-offset:2px;outline:2px solid #0000}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.outline-ring\/50{outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.outline-ring\/50{outline-color:color-mix(in oklab,var(--ring)50%,transparent)}}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.invert{--tw-invert:invert(100%);filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.backdrop-blur-2xl{--tw-backdrop-blur:blur(var(--blur-2xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-lg\!{--tw-backdrop-blur:blur(var(--blur-lg))!important;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important;backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-none{--tw-backdrop-blur: ;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-none\!{--tw-backdrop-blur: !important;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important;backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-xl{--tw-backdrop-blur:blur(var(--blur-xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-xs{--tw-backdrop-blur:blur(var(--blur-xs));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,visibility,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[color\,box-shadow\]{transition-property:color,box-shadow;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[opacity\,height\]{transition-property:opacity,height;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[width\,opacity\]{transition-property:width,opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[width\]{transition-property:width;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-opacity{transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-shadow{transition-property:box-shadow;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-none{transition-property:none}.duration-100{--tw-duration:.1s;transition-duration:.1s}.duration-150{--tw-duration:.15s;transition-duration:.15s}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.will-change-transform{will-change:transform}.fade-in-0{--tw-enter-opacity:0}.outline-none{--tw-outline-style:none;outline-style:none}.select-all{-webkit-user-select:all;user-select:all}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.zoom-in-95{--tw-enter-scale:.95}.running{animation-play-state:running}.group-focus-within\:opacity-100:is(:where(.group):focus-within *){opacity:1}@media(hover:hover){.group-hover\:pointer-events-auto:is(:where(.group):hover *){pointer-events:auto}.group-hover\:flex:is(:where(.group):hover *){display:flex}.group-hover\:hidden:is(:where(.group):hover *){display:none}.group-hover\:w-auto:is(:where(.group):hover *){width:auto}.group-hover\:fill-destructive:is(:where(.group):hover *){fill:var(--destructive)}.group-hover\:stroke-destructive:is(:where(.group):hover *){stroke:var(--destructive)}.group-hover\:stroke-foreground:is(:where(.group):hover *){stroke:var(--foreground)}.group-hover\:pr-6:is(:where(.group):hover *){padding-right:calc(var(--spacing)*6)}.group-hover\:opacity-100:is(:where(.group):hover *),.group-hover\/collapsible\:opacity-100:is(:where(.group\/collapsible):hover *),.group-hover\/expand\:opacity-100:is(:where(.group\/expand):hover *){opacity:1}}.group-data-\[disabled\=true\]\:pointer-events-none:is(:where(.group)[data-disabled=true] *){pointer-events:none}.group-data-\[disabled\=true\]\:opacity-50:is(:where(.group)[data-disabled=true] *){opacity:.5}.group-data-\[state\=open\]\:-rotate-180:is(:where(.group)[data-state=open] *){rotate:-180deg}.peer-disabled\:cursor-not-allowed:is(:where(.peer):disabled~*){cursor:not-allowed}.peer-disabled\:opacity-50:is(:where(.peer):disabled~*){opacity:.5}.peer-disabled\:opacity-70:is(:where(.peer):disabled~*){opacity:.7}.selection\:bg-primary ::selection{background-color:var(--primary)}.selection\:bg-primary::selection{background-color:var(--primary)}.selection\:text-primary-foreground ::selection{color:var(--primary-foreground)}.selection\:text-primary-foreground::selection{color:var(--primary-foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:-inset-x-3:after{content:var(--tw-content);inset-inline:calc(var(--spacing)*-3)}.after\:-inset-y-2:after{content:var(--tw-content);inset-block:calc(var(--spacing)*-2)}.first\:ml-4:first-child{margin-left:calc(var(--spacing)*4)}.last\:mr-4:last-child{margin-right:calc(var(--spacing)*4)}.focus-within\:border-border:focus-within{border-color:var(--border)}.focus-within\:shadow-md:focus-within{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}@media(hover:hover){.hover\:border-flame\/40:hover{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.hover\:border-flame\/40:hover{border-color:color-mix(in oklab,var(--flame)40%,transparent)}}.hover\:bg-accent:hover{background-color:var(--accent)}.hover\:bg-accent\!:hover{background-color:var(--accent)!important}.hover\:bg-accent\/50:hover{background-color:var(--accent)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-accent\/50:hover{background-color:color-mix(in oklab,var(--accent)50%,transparent)}}.hover\:bg-background\/45:hover{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-background\/45:hover{background-color:color-mix(in oklab,var(--background)45%,transparent)}}.hover\:bg-card\/90:hover{background-color:var(--card)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-card\/90:hover{background-color:color-mix(in oklab,var(--card)90%,transparent)}}.hover\:bg-destructive\/10:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/10:hover{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.hover\:bg-destructive\/10\!:hover{background-color:var(--destructive)!important}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/10\!:hover{background-color:color-mix(in oklab,var(--destructive)10%,transparent)!important}}.hover\:bg-destructive\/30:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/30:hover{background-color:color-mix(in oklab,var(--destructive)30%,transparent)}}.hover\:bg-destructive\/80:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/80:hover{background-color:color-mix(in oklab,var(--destructive)80%,transparent)}}.hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab,var(--destructive)90%,transparent)}}.hover\:bg-flame\/90:hover{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-flame\/90:hover{background-color:color-mix(in oklab,var(--flame)90%,transparent)}}.hover\:bg-foreground\/10:hover{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-foreground\/10:hover{background-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.hover\:bg-muted:hover{background-color:var(--muted)}.hover\:bg-muted-foreground\/10:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/10:hover{background-color:color-mix(in oklab,var(--muted-foreground)10%,transparent)}}.hover\:bg-muted-foreground\/15:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/15:hover{background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.hover\:bg-muted-foreground\/20:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/20:hover{background-color:color-mix(in oklab,var(--muted-foreground)20%,transparent)}}.hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted\/50:hover{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}.hover\:bg-muted\/80:hover{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted\/80:hover{background-color:color-mix(in oklab,var(--muted)80%,transparent)}}.hover\:bg-primary\/15:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-primary\/15:hover{background-color:color-mix(in oklab,var(--primary)15%,transparent)}}.hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-primary\/90:hover{background-color:color-mix(in oklab,var(--primary)90%,transparent)}}.hover\:bg-red-400\/20:hover{background-color:#ff656833}@supports (color:color-mix(in lab,red,red)){.hover\:bg-red-400\/20:hover{background-color:color-mix(in oklab,var(--color-red-400)20%,transparent)}}.hover\:bg-red-600:hover{background-color:var(--color-red-600)}.hover\:bg-transparent:hover{background-color:#0000}.hover\:fill-destructive:hover{fill:var(--destructive)}.hover\:stroke-destructive:hover{stroke:var(--destructive)}.hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.hover\:text-destructive:hover{color:var(--destructive)}.hover\:text-foreground:hover{color:var(--foreground)}.hover\:text-gray-400:hover{color:var(--color-gray-400)}.hover\:text-red-400:hover{color:var(--color-red-400)}.hover\:text-red-600:hover{color:var(--color-red-600)}.hover\:underline:hover{text-decoration-line:underline}.hover\:opacity-80:hover{opacity:.8}.hover\:opacity-90:hover{opacity:.9}.hover\:opacity-100:hover{opacity:1}.hover\:shadow-md:hover{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}.focus\:bg-accent:focus{background-color:var(--accent)}.focus\:text-accent-foreground:focus{color:var(--accent-foreground)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-primary:focus{--tw-ring-color:var(--primary)}.focus\:ring-ring:focus{--tw-ring-color:var(--ring)}.focus\:ring-offset-2:focus{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus\:outline-hidden:focus{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.focus\:outline-hidden:focus{outline-offset:2px;outline:2px solid #0000}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.focus-visible\:ring-0:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(0px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-1:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-3:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-4:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(4px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-\[3px\]:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.focus-visible\:ring-ring:focus-visible,.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab,var(--ring)50%,transparent)}}.focus-visible\:ring-offset-0:focus-visible{--tw-ring-offset-width:0px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus-visible\:ring-offset-2:focus-visible{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus-visible\:outline-hidden:focus-visible{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.focus-visible\:outline-hidden:focus-visible{outline-offset:2px;outline:2px solid #0000}}.focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.focus-visible\:outline-none:focus-visible{--tw-outline-style:none;outline-style:none}.active\:bg-accent:active{background-color:var(--accent)}.active\:bg-muted-foreground\/25:active{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.active\:bg-muted-foreground\/25:active{background-color:color-mix(in oklab,var(--muted-foreground)25%,transparent)}}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-0:disabled{opacity:0}.disabled\:opacity-50:disabled{opacity:.5}.disabled\:opacity-60:disabled{opacity:.6}.disabled\:opacity-100:disabled{opacity:1}@media(hover:hover){.disabled\:hover\:bg-transparent:disabled:hover{background-color:#0000}}.has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.has-\[\>svg\]\:grid-cols-\[calc\(var\(--spacing\)\*4\)_1fr\]:has(>svg){grid-template-columns:calc(var(--spacing)*4)1fr}.has-\[\>svg\]\:gap-x-3:has(>svg){column-gap:calc(var(--spacing)*3)}.has-\[\>svg\]\:px-2\.5:has(>svg){padding-inline:calc(var(--spacing)*2.5)}.has-\[\>svg\]\:px-3:has(>svg){padding-inline:calc(var(--spacing)*3)}.has-\[\>svg\]\:px-4:has(>svg){padding-inline:calc(var(--spacing)*4)}.aria-disabled\:pointer-events-none[aria-disabled=true]{pointer-events:none}.aria-disabled\:opacity-50[aria-disabled=true]{opacity:.5}.aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.aria-invalid\:ring-3[aria-invalid=true]{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.aria-invalid\:aria-checked\:border-primary[aria-invalid=true][aria-checked=true],.data-checked\:border-primary[data-checked]{border-color:var(--primary)}.data-checked\:bg-primary[data-checked]{background-color:var(--primary)}.data-checked\:text-primary-foreground[data-checked]{color:var(--primary-foreground)}.data-closed\:animate-out[data-closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:fade-out-0[data-closed]{--tw-exit-opacity:0}.data-closed\:zoom-out-95[data-closed]{--tw-exit-scale:.95}.data-highlighted\:bg-accent[data-highlighted]{background-color:var(--accent)}.data-highlighted\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.data-multiline\:py-2\.5[data-multiline]{padding-block:calc(var(--spacing)*2.5)}.data-open\:animate-in[data-open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:fade-in-0[data-open]{--tw-enter-opacity:0}.data-open\:zoom-in-95[data-open]{--tw-enter-scale:.95}.data-\[disabled\]\:pointer-events-none[data-disabled]{pointer-events:none}.data-\[disabled\]\:opacity-50[data-disabled]{opacity:.5}.data-\[highlighted\]\:bg-accent[data-highlighted]{background-color:var(--accent)}.data-\[highlighted\]\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.data-\[inset\]\:pl-8[data-inset]{padding-left:calc(var(--spacing)*8)}.data-\[multiline\]\:py-2\.5[data-multiline]{padding-block:calc(var(--spacing)*2.5)}.data-\[orientation\=horizontal\]\:h-px[data-orientation=horizontal]{height:1px}.data-\[orientation\=horizontal\]\:w-full[data-orientation=horizontal]{width:100%}.data-\[orientation\=vertical\]\:h-full[data-orientation=vertical]{height:100%}.data-\[orientation\=vertical\]\:w-px[data-orientation=vertical]{width:1px}.data-\[placeholder\]\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.data-\[side\=bottom\]\:-translate-x-1\/2[data-side=bottom]{--tw-translate-x: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:-translate-y-\[calc\(-50\%_\+_1px\)\][data-side=bottom]{--tw-translate-y: calc((-50% + 1px)*-1) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:calc(var(--spacing)*1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--spacing)*-1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=left\]\:-translate-y-\[calc\(50\%_-_3px\)\][data-side=left]{--tw-translate-y: calc((50% - 3px)*-1) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:calc(var(--spacing)*1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:translate-x-\[calc\(50\%_\+_2px\)\][data-side=right]{--tw-translate-x: calc(50% + 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:translate-y-1\/2[data-side=right]{--tw-translate-y: 50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=top\]\:translate-x-1\/2[data-side=top]{--tw-translate-x: 50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--spacing)*-1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:translate-y-\[calc\(-50\%_\+_2px\)\][data-side=top]{--tw-translate-y: calc(-50% + 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.data-\[size\=default\]\:h-9[data-size=default]{height:calc(var(--spacing)*9)}.data-\[size\=sm\]\:h-8[data-size=sm]{height:calc(var(--spacing)*8)}:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:color-mix(in oklab,var(--destructive)90%,transparent)}}:is(.\*\:data-\[slot\=select-value\]\:line-clamp-1>*)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.\*\:data-\[slot\=select-value\]\:flex>*)[data-slot=select-value]{display:flex}:is(.\*\:data-\[slot\=select-value\]\:items-center>*)[data-slot=select-value]{align-items:center}:is(.\*\:data-\[slot\=select-value\]\:gap-2>*)[data-slot=select-value]{gap:calc(var(--spacing)*2)}.data-\[state\=checked\]\:translate-x-\[calc\(100\%-2px\)\][data-state=checked]{--tw-translate-x: calc(100% - 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[state\=checked\]\:border-primary[data-state=checked]{border-color:var(--primary)}.data-\[state\=checked\]\:bg-primary[data-state=checked]{background-color:var(--primary)}.data-\[state\=checked\]\:text-primary-foreground[data-state=checked]{color:var(--primary-foreground)}.data-\[state\=closed\]\:animate-out[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-\[state\=closed\]\:duration-300[data-state=closed]{--tw-duration:.3s;transition-duration:.3s}.data-\[state\=closed\]\:fade-out-0[data-state=closed]{--tw-exit-opacity:0}.data-\[state\=closed\]\:fill-mode-forwards[data-state=closed]{--tw-animation-fill-mode:forwards;animation-fill-mode:forwards}.data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.data-\[state\=closed\]\:slide-out-to-bottom[data-state=closed]{--tw-exit-translate-y:100%}.data-\[state\=closed\]\:slide-out-to-bottom-full[data-state=closed]{--tw-exit-translate-y: 100% }.data-\[state\=closed\]\:slide-out-to-left[data-state=closed]{--tw-exit-translate-x:-100%}.data-\[state\=closed\]\:slide-out-to-right[data-state=closed]{--tw-exit-translate-x:100%}.data-\[state\=closed\]\:slide-out-to-top[data-state=closed]{--tw-exit-translate-y:-100%}.data-\[state\=open\]\:animate-in[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-\[state\=open\]\:bg-accent[data-state=open]{background-color:var(--accent)}.data-\[state\=open\]\:bg-transparent\![data-state=open]{background-color:#0000!important}.data-\[state\=open\]\:text-accent-foreground[data-state=open]{color:var(--accent-foreground)}.data-\[state\=open\]\:duration-500[data-state=open]{--tw-duration:.5s;transition-duration:.5s}.data-\[state\=open\]\:fade-in-0[data-state=open]{--tw-enter-opacity:0}.data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}.data-\[state\=open\]\:slide-in-from-bottom[data-state=open]{--tw-enter-translate-y:100%}.data-\[state\=open\]\:slide-in-from-bottom-full[data-state=open]{--tw-enter-translate-y: 100% }.data-\[state\=open\]\:slide-in-from-left[data-state=open]{--tw-enter-translate-x:-100%}.data-\[state\=open\]\:slide-in-from-right[data-state=open]{--tw-enter-translate-x:100%}.data-\[state\=open\]\:slide-in-from-top[data-state=open]{--tw-enter-translate-y:-100%}.data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.data-\[state\=unchecked\]\:translate-x-0[data-state=unchecked]{--tw-translate-x:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[state\=unchecked\]\:bg-input[data-state=unchecked]{background-color:var(--input)}.data-\[variant\=destructive\]\:text-destructive[data-variant=destructive]{color:var(--destructive)}.data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.data-\[variant\=destructive\]\:data-highlighted\:text-destructive[data-variant=destructive][data-highlighted]{color:var(--destructive)}@media not all and (min-width:40rem){.max-sm\:px-3{padding-inline:calc(var(--spacing)*3)}.max-sm\:py-2{padding-block:calc(var(--spacing)*2)}.max-sm\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}}@media(min-width:40rem){.sm\:top-\[50\%\]{top:50%}.sm\:right-auto{right:auto}.sm\:bottom-auto{bottom:auto}.sm\:left-\[50\%\]{left:50%}.sm\:mt-0{margin-top:calc(var(--spacing)*0)}.sm\:max-h-\[100vh\]{max-height:100vh}.sm\:w-auto{width:auto}.sm\:w-max{width:max-content}.sm\:max-w-2xl{max-width:var(--container-2xl)}.sm\:max-w-6xl{max-width:var(--container-6xl)}.sm\:max-w-\[calc\(100vw-2rem\)\]{max-width:calc(100vw - 2rem)}.sm\:max-w-lg{max-width:var(--container-lg)}.sm\:max-w-sm{max-width:var(--container-sm)}.sm\:translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.sm\:translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:justify-end{justify-content:flex-end}.sm\:rounded-lg{border-radius:var(--radius)}.sm\:text-left{text-align:left}.sm\:data-\[state\=closed\]\:slide-out-to-bottom-0[data-state=closed]{--tw-exit-translate-y: 0% }.sm\:data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.sm\:data-\[state\=open\]\:slide-in-from-bottom-0[data-state=open]{--tw-enter-translate-y: 0% }.sm\:data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}}@media(min-width:48rem){.md\:sticky{position:sticky}.md\:bottom-4{bottom:calc(var(--spacing)*4)}.md\:bottom-\[calc\(50dvh-7rem\)\]{bottom:calc(50dvh - 7rem)}.md\:left-0{left:calc(var(--spacing)*0)}.md\:col-span-2{grid-column:span 2/span 2}.md\:mt-0{margin-top:calc(var(--spacing)*0)}.md\:mt-2{margin-top:calc(var(--spacing)*2)}.md\:mb-8{margin-bottom:calc(var(--spacing)*8)}.md\:ml-2{margin-left:calc(var(--spacing)*2)}.md\:flex{display:flex}.md\:hidden{display:none}.md\:h-4{height:calc(var(--spacing)*4)}.md\:h-6{height:calc(var(--spacing)*6)}.md\:h-8{height:calc(var(--spacing)*8)}.md\:h-9{height:calc(var(--spacing)*9)}.md\:h-\[90vh\]{height:90vh}.md\:h-\[calc\(100dvh-1\.125rem\)\]{height:calc(100dvh - 1.125rem)}.md\:max-h-\[100vh\]{max-height:100vh}.md\:min-h-full{min-height:100%}.md\:w-4{width:calc(var(--spacing)*4)}.md\:w-6{width:calc(var(--spacing)*6)}.md\:w-8{width:calc(var(--spacing)*8)}.md\:w-9{width:calc(var(--spacing)*9)}.md\:w-12{width:calc(var(--spacing)*12)}.md\:w-72{width:calc(var(--spacing)*72)}.md\:w-auto{width:auto}.md\:max-w-3xl{max-width:var(--container-3xl)}.md\:max-w-32{max-width:calc(var(--spacing)*32)}.md\:max-w-\[90vw\]\!{max-width:90vw!important}.md\:max-w-\[min\(calc\(100cqw-9rem\)\,25rem\)\]{max-width:min(100cqw - 9rem,25rem)}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.md\:flex-row{flex-direction:row}.md\:items-center{align-items:center}.md\:justify-between{justify-content:space-between}.md\:gap-0{gap:calc(var(--spacing)*0)}.md\:gap-1{gap:calc(var(--spacing)*1)}.md\:gap-2{gap:calc(var(--spacing)*2)}.md\:overflow-y-auto{overflow-y:auto}.md\:rounded-2xl{border-radius:var(--radius-2xl)}.md\:rounded-3xl{border-radius:var(--radius-3xl)}.md\:bg-foreground\/5\!{background-color:var(--foreground)!important}@supports (color:color-mix(in lab,red,red)){.md\:bg-foreground\/5\!{background-color:color-mix(in oklab,var(--foreground)5%,transparent)!important}}.md\:bg-muted\/60{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.md\:bg-muted\/60{background-color:color-mix(in oklab,var(--muted)60%,transparent)}}.md\:p-4{padding:calc(var(--spacing)*4)}.md\:p-6{padding:calc(var(--spacing)*6)}.md\:p-8{padding:calc(var(--spacing)*8)}.md\:px-8{padding-inline:calc(var(--spacing)*8)}.md\:py-0{padding-block:calc(var(--spacing)*0)}.md\:py-3\!{padding-block:calc(var(--spacing)*3)!important}.md\:py-8{padding-block:calc(var(--spacing)*8)}.md\:pt-0{padding-top:calc(var(--spacing)*0)}.md\:pt-6{padding-top:calc(var(--spacing)*6)}.md\:pt-28{padding-top:calc(var(--spacing)*28)}.md\:pb-4{padding-bottom:calc(var(--spacing)*4)}.md\:pl-8{padding-left:calc(var(--spacing)*8)}.md\:text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.md\:text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.md\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.md\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.md\:backdrop-blur-xl{--tw-backdrop-blur:blur(var(--blur-xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.md\:transition-\[width\,padding\]{transition-property:width,padding;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}@media(hover:hover){.md\:hover\:bg-foreground\/10\!:hover{background-color:var(--foreground)!important}@supports (color:color-mix(in lab,red,red)){.md\:hover\:bg-foreground\/10\!:hover{background-color:color-mix(in oklab,var(--foreground)10%,transparent)!important}}}}@media(min-width:64rem){.lg\:col-span-2{grid-column:span 2/span 2}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}}@media(min-width:96rem){.\32xl\:bottom-\[calc\(50dvh-4rem\)\]{bottom:calc(50dvh - 4rem)}}.dark\:border:is(.dark *){border-style:var(--tw-border-style);border-width:1px}.dark\:border-border\/20:is(.dark *){border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.dark\:border-border\/20:is(.dark *){border-color:color-mix(in oklab,var(--border)20%,transparent)}}.dark\:border-input:is(.dark *){border-color:var(--input)}.dark\:border-muted:is(.dark *){border-color:var(--muted)}.dark\:border-purple-800:is(.dark *){border-color:var(--color-purple-800)}.dark\:bg-blue-950:is(.dark *){background-color:var(--color-blue-950)}.dark\:bg-blue-950\/40:is(.dark *){background-color:#16245666}@supports (color:color-mix(in lab,red,red)){.dark\:bg-blue-950\/40:is(.dark *){background-color:color-mix(in oklab,var(--color-blue-950)40%,transparent)}}.dark\:bg-cyan-950:is(.dark *){background-color:var(--color-cyan-950)}.dark\:bg-destructive\/60:is(.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-destructive\/60:is(.dark *){background-color:color-mix(in oklab,var(--destructive)60%,transparent)}}.dark\:bg-destructive\/70:is(.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-destructive\/70:is(.dark *){background-color:color-mix(in oklab,var(--destructive)70%,transparent)}}.dark\:bg-foreground\/10:is(.dark *){background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-foreground\/10:is(.dark *){background-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.dark\:bg-green-950:is(.dark *){background-color:var(--color-green-950)}.dark\:bg-input\/30:is(.dark *){background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-input\/30:is(.dark *){background-color:color-mix(in oklab,var(--input)30%,transparent)}}.dark\:bg-muted-foreground\/15:is(.dark *){background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-muted-foreground\/15:is(.dark *){background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.dark\:bg-muted\/75:is(.dark *){background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-muted\/75:is(.dark *){background-color:color-mix(in oklab,var(--muted)75%,transparent)}}.dark\:bg-orange-900:is(.dark *){background-color:var(--color-orange-900)}.dark\:bg-orange-950:is(.dark *){background-color:var(--color-orange-950)}.dark\:bg-pink-950:is(.dark *){background-color:var(--color-pink-950)}.dark\:bg-primary\/8:is(.dark *){background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-primary\/8:is(.dark *){background-color:color-mix(in oklab,var(--primary)8%,transparent)}}.dark\:bg-primary\/15:is(.dark *){background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-primary\/15:is(.dark *){background-color:color-mix(in oklab,var(--primary)15%,transparent)}}.dark\:bg-purple-500\/20:is(.dark *){background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-500\/20:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-500)20%,transparent)}}.dark\:bg-purple-700\/50:is(.dark *){background-color:#8200da80}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-700\/50:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-700)50%,transparent)}}.dark\:bg-purple-800\/40:is(.dark *){background-color:#6e11b066}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-800\/40:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-800)40%,transparent)}}.dark\:bg-purple-950:is(.dark *){background-color:var(--color-purple-950)}.dark\:bg-yellow-500\/30:is(.dark *){background-color:#edb2004d}@supports (color:color-mix(in lab,red,red)){.dark\:bg-yellow-500\/30:is(.dark *){background-color:color-mix(in oklab,var(--color-yellow-500)30%,transparent)}}.dark\:text-amber-400:is(.dark *){color:var(--color-amber-400)}.dark\:text-blue-200:is(.dark *){color:var(--color-blue-200)}.dark\:text-blue-400:is(.dark *){color:var(--color-blue-400)}.dark\:text-cyan-400:is(.dark *){color:var(--color-cyan-400)}.dark\:text-green-400:is(.dark *){color:var(--color-green-400)}.dark\:text-orange-200:is(.dark *){color:var(--color-orange-200)}.dark\:text-orange-400:is(.dark *){color:var(--color-orange-400)}.dark\:text-pink-400:is(.dark *){color:var(--color-pink-400)}.dark\:text-purple-100:is(.dark *){color:var(--color-purple-100)}.dark\:text-purple-300:is(.dark *){color:var(--color-purple-300)}.dark\:text-purple-400:is(.dark *){color:var(--color-purple-400)}.dark\:text-red-400:is(.dark *){color:var(--color-red-400)}.dark\:text-secondary-foreground:is(.dark *){color:var(--secondary-foreground)}.dark\:text-yellow-400:is(.dark *){color:var(--color-yellow-400)}.dark\:text-yellow-500:is(.dark *){color:var(--color-yellow-500)}.dark\:ring-ring\/20:is(.dark *){--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.dark\:ring-ring\/20:is(.dark *){--tw-ring-color:color-mix(in oklab,var(--ring)20%,transparent)}}.dark\:outline-ring\/40:is(.dark *){outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.dark\:outline-ring\/40:is(.dark *){outline-color:color-mix(in oklab,var(--ring)40%,transparent)}}.dark\:focus-within\:border-border:is(.dark *):focus-within{border-color:var(--border)}@media(hover:hover){.dark\:hover\:bg-destructive\/20\!:is(.dark *):hover{background-color:var(--destructive)!important}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-destructive\/20\!:is(.dark *):hover{background-color:color-mix(in oklab,var(--destructive)20%,transparent)!important}}.dark\:hover\:bg-input\/50:is(.dark *):hover{background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-input\/50:is(.dark *):hover{background-color:color-mix(in oklab,var(--input)50%,transparent)}}.dark\:hover\:bg-muted-foreground\/25:is(.dark *):hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-muted-foreground\/25:is(.dark *):hover{background-color:color-mix(in oklab,var(--muted-foreground)25%,transparent)}}}.dark\:focus-visible\:ring-destructive\/40:is(.dark *):focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:focus-visible\:ring-destructive\/40:is(.dark *):focus-visible{--tw-ring-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.dark\:aria-invalid\:border-destructive\/50:is(.dark *)[aria-invalid=true]{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:aria-invalid\:border-destructive\/50:is(.dark *)[aria-invalid=true]{border-color:color-mix(in oklab,var(--destructive)50%,transparent)}}.dark\:aria-invalid\:ring-destructive\/40:is(.dark *)[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:aria-invalid\:ring-destructive\/40:is(.dark *)[aria-invalid=true]{--tw-ring-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.dark\:data-checked\:bg-primary:is(.dark *)[data-checked],.dark\:data-\[state\=checked\]\:bg-primary:is(.dark *)[data-state=checked]{background-color:var(--primary)}.dark\:data-\[state\=checked\]\:bg-primary-foreground:is(.dark *)[data-state=checked]{background-color:var(--primary-foreground)}.dark\:data-\[state\=unchecked\]\:bg-foreground:is(.dark *)[data-state=unchecked]{background-color:var(--foreground)}.dark\:data-\[state\=unchecked\]\:bg-input\/80:is(.dark *)[data-state=unchecked]{background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:data-\[state\=unchecked\]\:bg-input\/80:is(.dark *)[data-state=unchecked]{background-color:color-mix(in oklab,var(--input)80%,transparent)}}.dark\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/20:is(.dark *)[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/20:is(.dark *)[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.\[\&_p\]\:leading-relaxed p{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-8 svg:not([class*=size-]){width:calc(var(--spacing)*8);height:calc(var(--spacing)*8)}.\[\&_svg\:not\(\[class\*\=\'text-\'\]\)\]\:text-muted-foreground svg:not([class*=text-]){color:var(--muted-foreground)}.\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.\[\&\:has\(\[role\=checkbox\]\)\]\:pe-0:has([role=checkbox]){padding-inline-end:calc(var(--spacing)*0)}.\[\.border-b\]\:pb-6.border-b{padding-bottom:calc(var(--spacing)*6)}.\[\.border-t\]\:pt-6.border-t{padding-top:calc(var(--spacing)*6)}:is(.\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--spacing)*2)}:is(.data-\[variant\=destructive\]\:\*\:\[svg\]\:\!text-destructive[data-variant=destructive]>*):is(svg){color:var(--destructive)!important}.\[\&\:not\(\:first-child\)\]\:mt-1:not(:first-child){margin-top:calc(var(--spacing)*1)}.\[\&\:not\(\:first-child\)\]\:mt-2:not(:first-child){margin-top:calc(var(--spacing)*2)}.\[\&\:not\(\:first-child\)\]\:last\:mr-4:not(:first-child):last-child{margin-right:calc(var(--spacing)*4)}.\[\&\:not\(\:last-child\)\]\:first\:ml-4:not(:last-child):first-child{margin-left:calc(var(--spacing)*4)}.\[\&\>\*\]\:flex-1>*{flex:1}@media(min-width:40rem){.sm\:\[\&\>\*\]\:flex-none>*{flex:none}}.\[\&\>\*\:first-child\]\:rounded-r-none>:first-child{border-top-right-radius:0;border-bottom-right-radius:0}.\[\&\>\*\:last-child\]\:rounded-l-none>:last-child{border-top-left-radius:0;border-bottom-left-radius:0}.\[\&\>\*\:not\(\:first-child\)\:not\(\:last-child\)\]\:rounded-none>:not(:first-child):not(:last-child){border-radius:0}.\[\&\>a\]\:underline>a{text-decoration-line:underline}.\[\&\>a\]\:underline-offset-4>a{text-underline-offset:4px}.\[\&\>a\:hover\]\:text-primary>a:hover{color:var(--primary)}@media(hover:hover){.hover\:\[\&\>kbd\]\:opacity-100:hover>kbd{opacity:1}}.\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.\[\&\>svg\]\:size-3>svg{width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.\[\&\>svg\]\:size-4>svg{width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.\[\&\>svg\]\:translate-y-0\.5>svg{--tw-translate-y:calc(var(--spacing)*.5);translate:var(--tw-translate-x)var(--tw-translate-y)}.\[\&\>svg\]\:text-current>svg{color:currentColor}@media(hover:hover){:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}}.\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}@media(pointer:coarse){.\[\@media\(pointer\:coarse\)\]\:pointer-events-auto{pointer-events:auto}.\[\@media\(pointer\:coarse\)\]\:flex{display:flex}.\[\@media\(pointer\:coarse\)\]\:hidden{display:none}.\[\@media\(pointer\:coarse\)\]\:w-5{width:calc(var(--spacing)*5)}.\[\@media\(pointer\:coarse\)\]\:w-auto{width:auto}.\[\@media\(pointer\:coarse\)\]\:text-amber-500{color:var(--color-amber-500)}.\[\@media\(pointer\:coarse\)\]\:text-green-500{color:var(--color-green-500)}.\[\@media\(pointer\:coarse\)\]\:text-muted-foreground{color:var(--muted-foreground)}.\[\@media\(pointer\:coarse\)\]\:opacity-100{opacity:1}@media(hover:hover){.\[\@media\(pointer\:coarse\)\]\:hover\:text-amber-600:hover{color:var(--color-amber-600)}.\[\@media\(pointer\:coarse\)\]\:hover\:text-green-600:hover{color:var(--color-green-600)}}}@media(hover:hover){a.\[a\&\]\:hover\:bg-accent:hover{background-color:var(--accent)}a.\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab,var(--destructive)90%,transparent)}}a.\[a\&\]\:hover\:bg-foreground\/25:hover{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-foreground\/25:hover{background-color:color-mix(in oklab,var(--foreground)25%,transparent)}}a.\[a\&\]\:hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-primary\/90:hover{background-color:color-mix(in oklab,var(--primary)90%,transparent)}}a.\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:color-mix(in oklab,var(--secondary)90%,transparent)}}a.\[a\&\]\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}}.scrollbar-hide::-webkit-scrollbar{display:none}.scrollbar-hide{-ms-overflow-style:none;scrollbar-width:none}.neon-flame{box-shadow:0 0 5px var(--flame),0 0 10px var(--flame),0 0 20px var(--ember),0 0 40px var(--ember)}.neon-ember{box-shadow:0 0 5px var(--ember),0 0 10px var(--ember),0 0 20px var(--ember)}.neon-gold{box-shadow:0 0 5px var(--gold),0 0 10px var(--gold),0 0 20px var(--flame)}.neon-eye{box-shadow:0 0 5px var(--eye),0 0 10px var(--eye),0 0 20px var(--eye)}.neon-cyan{box-shadow:0 0 5px var(--flame),0 0 10px var(--flame),0 0 20px var(--flame)}.neon-magenta{box-shadow:0 0 5px var(--ember),0 0 10px var(--ember),0 0 20px var(--ember)}.neon-purple{box-shadow:0 0 5px var(--gold),0 0 10px var(--gold),0 0 20px var(--gold)}.text-glow-fire{text-shadow:0 0 10px var(--flame),0 0 20px var(--ember),0 0 40px var(--ember)}.text-glow-gold{text-shadow:0 0 10px var(--gold),0 0 20px var(--flame)}.text-glow-eye{text-shadow:0 0 10px var(--eye),0 0 20px var(--eye)}.text-glow-cyan{text-shadow:0 0 10px var(--flame),0 0 20px var(--flame)}.text-glow-magenta{text-shadow:0 0 10px var(--ember),0 0 20px var(--ember)}.fire-text{background-image:linear-gradient(90deg,var(--gold),var(--flame),var(--ember),var(--gold));color:#0000;filter:drop-shadow(0 0 8px var(--flame));background-size:200%;-webkit-background-clip:text;background-clip:text;animation:4s linear infinite gradient-x}.cyber-grid{background-image:linear-gradient(#fa002a1f 1px,#0000 1px),linear-gradient(90deg,#fa002a1f 1px,#0000 1px);background-image:linear-gradient(color(xyz 0.422 0.2 0.023 / 0.122) 1px,#0000 1px),linear-gradient(90deg,color(xyz 0.422 0.2 0.023 / 0.122) 1px,#0000 1px);background-size:32px 32px}.rune-card{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background:#21050599;border:1px solid oklch(72% .28 45/.6);animation:4s linear infinite flicker;box-shadow:0 0 12px #fa002a80,inset 0 0 12px #ff772d40;box-shadow:0 0 12px oklch(62% .28 25/.5),inset 0 0 12px oklch(72% .28 45/.25)}.sym-omega:before,.sym-sigma:before,.sym-fehu:before,.sym-perthro:before{color:var(--flame);text-shadow:0 0 8px var(--ember),0 0 16px var(--flame);margin-right:.4em;animation:3.5s linear infinite flicker;display:inline-block}.sym-omega:before{content:var(--rune-omega)}.sym-sigma:before{content:var(--rune-sigma)}.sym-fehu:before{content:var(--rune-fehu)}.sym-perthro:before{content:var(--rune-perthro)}.brand-omega:before{content:var(--brand-omega)}.brand-llama:after{content:var(--brand-llama)}.brand-algmor:after{content:var(--brand-algmor)}.brand-omega:before,.brand-llama:after,.brand-algmor:after{font-family:var(--font-mono);letter-spacing:.15em;color:var(--gold);text-shadow:0 0 6px var(--flame),0 0 18px var(--ember)}.glitch{position:relative}.glitch:before,.glitch:after{content:attr(data-text);pointer-events:none;position:absolute;inset:0}.glitch:before{color:var(--ember);clip-path:inset(0 0 55%);opacity:.8;animation:2.7s linear infinite flicker;transform:translate(-2px,-1px)}.glitch:after{color:var(--eye);clip-path:inset(45% 0 0);opacity:.8;animation:3.3s linear infinite reverse flicker;transform:translate(2px,1px)}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}:root{--radius:.625rem;--brand-omega:"ΩFFFΣLLIa";--brand-llama:"llama.cpp";--brand-algmor:"AlgMor24";--rune-omega:"Ω";--rune-sigma:"Σ";--rune-fehu:"ᚠ";--rune-perthro:"ᛈ";--background:oklch(96% .02 80);--foreground:oklch(20% .06 25);--card:oklch(98% .015 80);--card-foreground:oklch(20% .06 25);--popover:oklch(98% .015 80);--popover-foreground:oklch(20% .06 25);--primary:oklch(62% .22 45);--primary-foreground:oklch(98% .02 80);--secondary:oklch(55% .24 25);--secondary-foreground:oklch(98% .02 80);--muted:oklch(90% .03 80);--muted-foreground:oklch(50% .08 25);--accent:oklch(60% .2 80);--accent-foreground:oklch(98% .02 80);--destructive:oklch(55% .26 25);--border:oklch(82% .06 45);--input:oklch(86% .05 45);--ring:oklch(62% .22 45);--flame:oklch(62% .22 45);--ember:oklch(55% .24 25);--gold:oklch(70% .16 85);--eye:oklch(60% .12 220);--chart-1:oklch(62% .22 45);--chart-2:oklch(55% .24 25);--chart-3:oklch(70% .16 85);--chart-4:oklch(60% .12 220);--chart-5:oklch(45% .2 25);--sidebar:oklch(97% .015 80);--sidebar-foreground:oklch(20% .06 25);--sidebar-primary:oklch(62% .22 45);--sidebar-primary-foreground:oklch(98% .02 80);--sidebar-accent:oklch(92% .04 80);--sidebar-accent-foreground:oklch(20% .06 25);--sidebar-border:oklch(85% .05 45);--sidebar-ring:oklch(62% .22 45);--code-background:oklch(14% .03 25);--code-foreground:oklch(80% .2 80);--font-mono:ui-monospace,SFMono-Regular,"SF Mono",Monaco,"Cascadia Code","Roboto Mono",Consolas,"Liberation Mono",Menlo,monospace;--layer-popover:1000000;--chat-form-area-height:8rem;--chat-form-area-offset:2rem;--chat-form-padding-top:6rem;--max-message-height:max(24rem,min(80dvh,calc(100dvh - var(--chat-form-area-height) - 12rem)))}@media(min-width:640px){:root{--chat-form-area-height:24rem;--chat-form-area-offset:12rem;--chat-form-padding-top:6rem}}.dark{--background:oklch(13% .03 25);--foreground:oklch(96% .02 80);--card:oklch(17% .04 25);--card-foreground:oklch(96% .02 80);--popover:oklch(17% .04 25);--popover-foreground:oklch(96% .02 80);--primary:oklch(72% .28 45);--primary-foreground:oklch(12% .03 25);--secondary:oklch(62% .28 25);--secondary-foreground:oklch(98% .02 80);--muted:oklch(26% .05 25);--muted-foreground:oklch(70% .08 45);--accent:oklch(80% .22 85);--accent-foreground:oklch(15% .04 80);--destructive:oklch(65% .28 25);--border:oklch(38% .1 25);--input:oklch(22% .05 25);--ring:oklch(72% .28 45);--flame:oklch(72% .28 45);--ember:oklch(62% .28 25);--gold:oklch(85% .2 90);--eye:oklch(78% .18 220);--chart-1:oklch(72% .28 45);--chart-2:oklch(62% .28 25);--chart-3:oklch(85% .2 90);--chart-4:oklch(78% .18 220);--chart-5:oklch(50% .25 25);--sidebar:oklch(11% .03 25);--sidebar-foreground:oklch(96% .02 80);--sidebar-primary:oklch(72% .28 45);--sidebar-primary-foreground:oklch(12% .03 25);--sidebar-accent:oklch(24% .07 25);--sidebar-accent-foreground:oklch(96% .02 80);--sidebar-border:oklch(30% .08 25);--sidebar-ring:oklch(72% .28 45);--code-background:oklch(11% .03 25);--code-foreground:oklch(85% .2 90)}@keyframes flicker{0%,to{opacity:1}6%{opacity:.85}9%{opacity:1}38%{opacity:1}40%{opacity:.5}42%{opacity:1}71%{opacity:.75}73%{opacity:1}}@keyframes ember-rise{0%{opacity:0;transform:translateY(0)scale(1)}8%{opacity:1}to{opacity:0;transform:translateY(-90vh)scale(.3)}}@keyframes gradient-x{0%,to{background-position:0%}50%{background-position:100%}}@keyframes pulse-fire{0%,to{box-shadow:0 0 6px var(--ember),0 0 14px var(--flame),0 0 28px var(--flame)}50%{box-shadow:0 0 12px var(--gold),0 0 26px var(--flame),0 0 48px var(--ember)}}@keyframes scan{0%{transform:translateY(-100%)}to{transform:translateY(100vh)}}.mermaidTooltip{display:none!important}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-space-x-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}a.svelte-1q39rn8,button.svelte-1q39rn8{cursor:pointer}[data-select-viewport],[data-combobox-viewport]{scrollbar-width:none!important;-ms-overflow-style:none!important;-webkit-overflow-scrolling:touch!important}[data-combobox-viewport]::-webkit-scrollbar{display:none!important}[data-select-viewport]::-webkit-scrollbar{display:none!important}[data-scroll-area-viewport]{scrollbar-width:none!important;-ms-overflow-style:none!important;-webkit-overflow-scrolling:touch!important}[data-scroll-area-viewport]::-webkit-scrollbar{display:none!important}:where([data-scroll-area-viewport]){display:flex;flex-direction:column;align-items:stretch}:where([data-scroll-area-content]){flex-grow:1}html[dir=ltr],[data-sonner-toaster][dir=ltr]{--toast-icon-margin-start: -3px;--toast-icon-margin-end: 4px;--toast-svg-margin-start: -1px;--toast-svg-margin-end: 0px;--toast-button-margin-start: auto;--toast-button-margin-end: 0;--toast-close-button-start: 0;--toast-close-button-end: unset;--toast-close-button-transform: translate(-35%, -35%)}html[dir=rtl],[data-sonner-toaster][dir=rtl]{--toast-icon-margin-start: 4px;--toast-icon-margin-end: -3px;--toast-svg-margin-start: 0px;--toast-svg-margin-end: -1px;--toast-button-margin-start: 0;--toast-button-margin-end: auto;--toast-close-button-start: unset;--toast-close-button-end: 0;--toast-close-button-transform: translate(35%, -35%)}[data-sonner-toaster]{position:fixed;width:var(--width);font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;--gray1: hsl(0, 0%, 99%);--gray2: hsl(0, 0%, 97.3%);--gray3: hsl(0, 0%, 95.1%);--gray4: hsl(0, 0%, 93%);--gray5: hsl(0, 0%, 90.9%);--gray6: hsl(0, 0%, 88.7%);--gray7: hsl(0, 0%, 85.8%);--gray8: hsl(0, 0%, 78%);--gray9: hsl(0, 0%, 56.1%);--gray10: hsl(0, 0%, 52.3%);--gray11: hsl(0, 0%, 43.5%);--gray12: hsl(0, 0%, 9%);--border-radius: 8px;box-sizing:border-box;padding:0;margin:0;list-style:none;outline:none;z-index:999999999;transition:transform .4s ease}@media(hover:none)and (pointer:coarse){[data-sonner-toaster][data-lifted=true]{transform:none}}[data-sonner-toaster][data-x-position=right]{right:var(--offset-right)}[data-sonner-toaster][data-x-position=left]{left:var(--offset-left)}[data-sonner-toaster][data-x-position=center]{left:50%;transform:translate(-50%)}[data-sonner-toaster][data-y-position=top]{top:var(--offset-top)}[data-sonner-toaster][data-y-position=bottom]{bottom:var(--offset-bottom)}[data-sonner-toast]{--y: translateY(100%);--lift-amount: calc(var(--lift) * var(--gap));z-index:var(--z-index);position:absolute;opacity:0;transform:var(--y);touch-action:none;transition:transform .4s,opacity .4s,height .4s,box-shadow .2s;box-sizing:border-box;outline:none;overflow-wrap:anywhere}[data-sonner-toast][data-styled=true]{padding:16px;background:var(--normal-bg);border:1px solid var(--normal-border);color:var(--normal-text);border-radius:var(--border-radius);box-shadow:0 4px 12px #0000001a;width:var(--width);font-size:13px;display:flex;align-items:center;gap:6px}[data-sonner-toast]:focus-visible{box-shadow:0 4px 12px #0000001a,0 0 0 2px #0003}[data-sonner-toast][data-y-position=top]{top:0;--y: translateY(-100%);--lift: 1;--lift-amount: calc(1 * var(--gap))}[data-sonner-toast][data-y-position=bottom]{bottom:0;--y: translateY(100%);--lift: -1;--lift-amount: calc(var(--lift) * var(--gap))}[data-sonner-toast][data-styled=true] [data-description]{font-weight:400;line-height:1.4;color:#3f3f3f}[data-rich-colors=true][data-sonner-toast][data-styled=true] [data-description]{color:inherit}[data-sonner-toaster][data-sonner-theme=dark] [data-description]{color:#e8e8e8}[data-sonner-toast][data-styled=true] [data-title]{font-weight:500;line-height:1.5;color:inherit}[data-sonner-toast][data-styled=true] [data-icon]{display:flex;height:16px;width:16px;position:relative;justify-content:flex-start;align-items:center;flex-shrink:0;margin-left:var(--toast-icon-margin-start);margin-right:var(--toast-icon-margin-end)}[data-sonner-toast][data-promise=true] [data-icon]>svg{opacity:0;transform:scale(.8);transform-origin:center;animation:sonner-fade-in .3s ease forwards}[data-sonner-toast][data-styled=true] [data-icon]>*{flex-shrink:0}[data-sonner-toast][data-styled=true] [data-icon] svg{margin-left:var(--toast-svg-margin-start);margin-right:var(--toast-svg-margin-end)}[data-sonner-toast][data-styled=true] [data-content]{display:flex;flex-direction:column;gap:2px}[data-sonner-toast][data-styled=true] [data-button]{border-radius:4px;padding-left:8px;padding-right:8px;height:24px;font-size:12px;color:var(--normal-bg);background:var(--normal-text);margin-left:var(--toast-button-margin-start);margin-right:var(--toast-button-margin-end);border:none;font-weight:500;cursor:pointer;outline:none;display:flex;align-items:center;flex-shrink:0;transition:opacity .4s,box-shadow .2s}[data-sonner-toast][data-styled=true] [data-button]:focus-visible{box-shadow:0 0 0 2px #0006}[data-sonner-toast][data-styled=true] [data-button]:first-of-type{margin-left:var(--toast-button-margin-start);margin-right:var(--toast-button-margin-end)}[data-sonner-toast][data-styled=true] [data-cancel]{color:var(--normal-text);background:#00000014}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast][data-styled=true] [data-cancel]{background:#ffffff4d}[data-sonner-toast][data-styled=true] [data-close-button]{position:absolute;left:var(--toast-close-button-start);right:var(--toast-close-button-end);top:0;height:20px;width:20px;display:flex;justify-content:center;align-items:center;padding:0;color:var(--gray12);background:var(--normal-bg);border:1px solid var(--gray4);transform:var(--toast-close-button-transform);border-radius:50%;cursor:pointer;z-index:1;transition:opacity .1s,background .2s,border-color .2s}[data-sonner-toast][data-styled=true] [data-close-button]:focus-visible{box-shadow:0 4px 12px #0000001a,0 0 0 2px #0003}[data-sonner-toast][data-styled=true] [data-disabled=true]{cursor:not-allowed}[data-sonner-toast][data-styled=true]:hover [data-close-button]:hover{background:var(--gray2);border-color:var(--gray5)}[data-sonner-toast][data-swiping=true]:before{content:"";position:absolute;left:-100%;right:-100%;height:100%;z-index:-1}[data-sonner-toast][data-y-position=top][data-swiping=true]:before{bottom:50%;transform:scaleY(3) translateY(50%)}[data-sonner-toast][data-y-position=bottom][data-swiping=true]:before{top:50%;transform:scaleY(3) translateY(-50%)}[data-sonner-toast][data-swiping=false][data-removed=true]:before{content:"";position:absolute;inset:0;transform:scaleY(2)}[data-sonner-toast][data-expanded=true]:after{content:"";position:absolute;left:0;height:calc(var(--gap) + 1px);bottom:100%;width:100%}[data-sonner-toast][data-mounted=true]{--y: translateY(0);opacity:1}[data-sonner-toast][data-expanded=false][data-front=false]{--scale: var(--toasts-before) * .05 + 1;--y: translateY(calc(var(--lift-amount) * var(--toasts-before))) scale(calc(-1 * var(--scale)));height:var(--front-toast-height)}[data-sonner-toast]>*{transition:opacity .4s}[data-sonner-toast][data-x-position=right]{right:0}[data-sonner-toast][data-x-position=left]{left:0}[data-sonner-toast][data-expanded=false][data-front=false][data-styled=true]>*{opacity:0}[data-sonner-toast][data-visible=false]{opacity:0;pointer-events:none}[data-sonner-toast][data-mounted=true][data-expanded=true]{--y: translateY(calc(var(--lift) * var(--offset)));height:var(--initial-height)}[data-sonner-toast][data-removed=true][data-front=true][data-swipe-out=false]{--y: translateY(calc(var(--lift) * -100%));opacity:0}[data-sonner-toast][data-removed=true][data-front=false][data-swipe-out=false][data-expanded=true]{--y: translateY( calc(var(--lift) * var(--offset) + var(--lift) * -100%) );opacity:0}[data-sonner-toast][data-removed=true][data-front=false][data-swipe-out=false][data-expanded=false]{--y: translateY(40%);opacity:0;transition:transform .5s,opacity .2s}[data-sonner-toast][data-removed=true][data-front=false]:before{height:calc(var(--initial-height) + 20%)}[data-sonner-toast][data-swiping=true]{transform:var(--y) translateY(var(--swipe-amount-y, 0px)) translate(var(--swipe-amount-x, 0px));transition:none}[data-sonner-toast][data-swiped=true]{-webkit-user-select:none;user-select:none}[data-sonner-toast][data-swipe-out=true][data-y-position=bottom],[data-sonner-toast][data-swipe-out=true][data-y-position=top]{animation-duration:.2s;animation-timing-function:ease-out;animation-fill-mode:forwards}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=left]{animation-name:swipe-out-left}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=right]{animation-name:swipe-out-right}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=up]{animation-name:swipe-out-up}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=down]{animation-name:swipe-out-down}@keyframes swipe-out-left{0%{transform:var(--y) translate(var(--swipe-amount-x));opacity:1}to{transform:var(--y) translate(calc(var(--swipe-amount-x) - 100%));opacity:0}}@keyframes swipe-out-right{0%{transform:var(--y) translate(var(--swipe-amount-x));opacity:1}to{transform:var(--y) translate(calc(var(--swipe-amount-x) + 100%));opacity:0}}@keyframes swipe-out-up{0%{transform:var(--y) translateY(var(--swipe-amount-y));opacity:1}to{transform:var(--y) translateY(calc(var(--swipe-amount-y) - 100%));opacity:0}}@keyframes swipe-out-down{0%{transform:var(--y) translateY(var(--swipe-amount-y));opacity:1}to{transform:var(--y) translateY(calc(var(--swipe-amount-y) + 100%));opacity:0}}@media(max-width:600px){[data-sonner-toaster]{position:fixed;right:var(--mobile-offset-right);left:var(--mobile-offset-left);width:100%}[data-sonner-toaster][dir=rtl]{left:calc(var(--mobile-offset-left) * -1)}[data-sonner-toaster] [data-sonner-toast]{left:0;right:0;width:calc(100% - var(--mobile-offset-left) * 2)}[data-sonner-toaster][data-x-position=left]{left:var(--mobile-offset-left)}[data-sonner-toaster][data-y-position=bottom]{bottom:var(--mobile-offset-bottom)}[data-sonner-toaster][data-y-position=top]{top:var(--mobile-offset-top)}[data-sonner-toaster][data-x-position=center]{left:var(--mobile-offset-left);right:var(--mobile-offset-right);transform:none}}[data-sonner-toaster][data-sonner-theme=light]{--normal-bg: #fff;--normal-border: var(--gray4);--normal-text: var(--gray12);--success-bg: hsl(143, 85%, 96%);--success-border: hsl(145, 92%, 87%);--success-text: hsl(140, 100%, 27%);--info-bg: hsl(208, 100%, 97%);--info-border: hsl(221, 91%, 93%);--info-text: hsl(210, 92%, 45%);--warning-bg: hsl(49, 100%, 97%);--warning-border: hsl(49, 91%, 84%);--warning-text: hsl(31, 92%, 45%);--error-bg: hsl(359, 100%, 97%);--error-border: hsl(359, 100%, 94%);--error-text: hsl(360, 100%, 45%)}[data-sonner-toaster][data-sonner-theme=light] [data-sonner-toast][data-invert=true]{--normal-bg: #000;--normal-border: hsl(0, 0%, 20%);--normal-text: var(--gray1)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast][data-invert=true]{--normal-bg: #fff;--normal-border: var(--gray3);--normal-text: var(--gray12)}[data-sonner-toaster][data-sonner-theme=dark]{--normal-bg: #000;--normal-bg-hover: hsl(0, 0%, 12%);--normal-border: hsl(0, 0%, 20%);--normal-border-hover: hsl(0, 0%, 25%);--normal-text: var(--gray1);--success-bg: hsl(150, 100%, 6%);--success-border: hsl(147, 100%, 12%);--success-text: hsl(150, 86%, 65%);--info-bg: hsl(215, 100%, 6%);--info-border: hsl(223, 43%, 17%);--info-text: hsl(216, 87%, 65%);--warning-bg: hsl(64, 100%, 6%);--warning-border: hsl(60, 100%, 9%);--warning-text: hsl(46, 87%, 65%);--error-bg: hsl(358, 76%, 10%);--error-border: hsl(357, 89%, 16%);--error-text: hsl(358, 100%, 81%)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast] [data-close-button]{background:var(--normal-bg);border-color:var(--normal-border);color:var(--normal-text)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast] [data-close-button]:hover{background:var(--normal-bg-hover);border-color:var(--normal-border-hover)}[data-rich-colors=true][data-sonner-toast][data-type=success],[data-rich-colors=true][data-sonner-toast][data-type=success] [data-close-button]{background:var(--success-bg);border-color:var(--success-border);color:var(--success-text)}[data-rich-colors=true][data-sonner-toast][data-type=info],[data-rich-colors=true][data-sonner-toast][data-type=info] [data-close-button]{background:var(--info-bg);border-color:var(--info-border);color:var(--info-text)}[data-rich-colors=true][data-sonner-toast][data-type=warning],[data-rich-colors=true][data-sonner-toast][data-type=warning] [data-close-button]{background:var(--warning-bg);border-color:var(--warning-border);color:var(--warning-text)}[data-rich-colors=true][data-sonner-toast][data-type=error],[data-rich-colors=true][data-sonner-toast][data-type=error] [data-close-button]{background:var(--error-bg);border-color:var(--error-border);color:var(--error-text)}.sonner-loading-wrapper{--size: 16px;height:var(--size);width:var(--size);position:absolute;inset:0;z-index:10}.sonner-loading-wrapper[data-visible=false]{transform-origin:center;animation:sonner-fade-out .2s ease forwards}.sonner-spinner{position:relative;top:50%;left:50%;height:var(--size);width:var(--size)}.sonner-loading-bar{animation:sonner-spin 1.2s linear infinite;background:var(--gray11);border-radius:6px;height:8%;left:-10%;position:absolute;top:-3.9%;width:24%}.sonner-loading-bar:nth-child(1){animation-delay:-1.2s;transform:rotate(.0001deg) translate(146%)}.sonner-loading-bar:nth-child(2){animation-delay:-1.1s;transform:rotate(30deg) translate(146%)}.sonner-loading-bar:nth-child(3){animation-delay:-1s;transform:rotate(60deg) translate(146%)}.sonner-loading-bar:nth-child(4){animation-delay:-.9s;transform:rotate(90deg) translate(146%)}.sonner-loading-bar:nth-child(5){animation-delay:-.8s;transform:rotate(120deg) translate(146%)}.sonner-loading-bar:nth-child(6){animation-delay:-.7s;transform:rotate(150deg) translate(146%)}.sonner-loading-bar:nth-child(7){animation-delay:-.6s;transform:rotate(180deg) translate(146%)}.sonner-loading-bar:nth-child(8){animation-delay:-.5s;transform:rotate(210deg) translate(146%)}.sonner-loading-bar:nth-child(9){animation-delay:-.4s;transform:rotate(240deg) translate(146%)}.sonner-loading-bar:nth-child(10){animation-delay:-.3s;transform:rotate(270deg) translate(146%)}.sonner-loading-bar:nth-child(11){animation-delay:-.2s;transform:rotate(300deg) translate(146%)}.sonner-loading-bar:nth-child(12){animation-delay:-.1s;transform:rotate(330deg) translate(146%)}@keyframes sonner-fade-in{0%{opacity:0;transform:scale(.8)}to{opacity:1;transform:scale(1)}}@keyframes sonner-fade-out{0%{opacity:1;transform:scale(1)}to{opacity:0;transform:scale(.8)}}@keyframes sonner-spin{0%{opacity:1}to{opacity:.15}}@media(prefers-reduced-motion){[data-sonner-toast],[data-sonner-toast]>*,.sonner-loading-bar{transition:none!important;animation:none!important}}.sonner-loader{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);transform-origin:center;transition:opacity .2s,transform .2s}.sonner-loader[data-visible=false]{opacity:0;transform:scale(.8) translate(-50%,-50%)}div.svelte-2vbth6 svg{width:var(--size, 1rem);height:var(--size, 1rem)}.chat-form-contenteditable.svelte-irz8x{white-space:pre-wrap}.chat-form-contenteditable.svelte-irz8x[data-empty=true]:before{content:attr(data-placeholder);color:var(--muted-foreground);pointer-events:none}.chat-form-contenteditable.svelte-irz8x code[data-code-token=inline]{background:var(--muted);color:var(--muted-foreground);padding:.125rem .375rem;border-radius:.375rem;font-size:.875rem}.chat-form-contenteditable.svelte-irz8x code[data-code-token=block]{display:block;margin:.25rem 0;padding:.75rem 1rem;border:1px solid color-mix(in oklch,var(--border) 30%,transparent);border-radius:.75rem;background:var(--code-background);color:var(--code-foreground);font-size:.875rem;line-height:1.3}.chat-message.svelte-54wbwl{--chat-message-intrinsic-size: 500px;content-visibility:auto;contain-intrinsic-size:auto var(--chat-message-intrinsic-size)}.chat-message--synthetic.svelte-54wbwl{--chat-message-intrinsic-size: 40px}.diff-block.svelte-gafiza{overflow:auto;border-radius:.75rem;border-width:1px;border-color:color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d}.dark .diff-block.svelte-gafiza{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.diff-line.svelte-gafiza{display:grid;grid-template-columns:3.25rem 1.5rem 3.25rem 1fr;font-family:var(--font-mono);font-size:11px;line-height:1.65;align-items:stretch}.diff-old-num.svelte-gafiza,.diff-new-num.svelte-gafiza{text-align:right;padding-right:.5rem;-webkit-user-select:none;user-select:none;color:color-mix(in oklch,var(--muted-foreground) 70%,transparent);font-variant-numeric:tabular-nums}.diff-marker.svelte-gafiza{text-align:center;color:color-mix(in oklch,var(--muted-foreground) 70%,transparent);-webkit-user-select:none;user-select:none}.diff-line.diff-add.svelte-gafiza{background-color:#f0fff4;color:#22863a}.diff-line.diff-add.svelte-gafiza .diff-new-num:where(.svelte-gafiza),.diff-line.diff-add.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#22863a}.diff-line.diff-remove.svelte-gafiza{background-color:#ffeef0;color:#b31d28}.diff-line.diff-remove.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.diff-line.diff-remove.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#b31d28}.diff-line.diff-add.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.diff-line.diff-remove.svelte-gafiza .diff-new-num:where(.svelte-gafiza){opacity:0}.diff-text.svelte-gafiza{padding-left:.4rem;padding-right:.5rem;white-space:pre;overflow-x:auto;min-width:0}.dark .diff-line.diff-add.svelte-gafiza{background-color:#033a16;color:#aff5b4}.dark .diff-line.diff-add.svelte-gafiza .diff-new-num:where(.svelte-gafiza),.dark .diff-line.diff-add.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#aff5b4}.dark .diff-line.diff-remove.svelte-gafiza{background-color:#67060c;color:#ffdcd7}.dark .diff-line.diff-remove.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.dark .diff-line.diff-remove.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#ffdcd7}:root{--exec-wd-margin: .4rem}.exec-wd.svelte-1n7e52m{font-family:var(--font-mono);color:var(--muted-foreground);margin-right:var(--exec-wd-margin)}.exec-prompt.svelte-1n7e52m{font-family:var(--font-mono);color:var(--muted-foreground);opacity:.55;margin-right:var(--exec-wd-margin)}.terminal-output.svelte-1n7e52m{overscroll-behavior:contain}.terminal-output.is-clamped.svelte-1n7e52m{max-height:28rem;overflow-y:auto;scrollbar-gutter:stable;padding-right:.25rem}.exit-badge.svelte-1n7e52m{display:inline-flex;align-items:center;gap:.35rem;margin-top:.5rem;padding:.2rem .55rem;border-radius:.375rem;font-family:var(--font-mono);font-size:11px;font-weight:500;letter-spacing:.01em;line-height:1}.exit-badge.success.svelte-1n7e52m{background:color-mix(in oklch,var(--color-green-500, #22c55e) 14%,transparent);color:var(--color-green-700, #15803d)}.dark .exit-badge.success.svelte-1n7e52m{background:color-mix(in oklch,var(--color-green-400, #4ade80) 18%,transparent);color:var(--color-green-300, #86efac)}.exit-badge.failure.svelte-1n7e52m{background:color-mix(in oklch,var(--color-red-500, #ef4444) 14%,transparent);color:var(--color-red-700, #b91c1c)}.dark .exit-badge.failure.svelte-1n7e52m{background:color-mix(in oklch,var(--color-red-400, #f87171) 18%,transparent);color:var(--color-red-300, #fca5a5)}.exit-badge.warning.svelte-1n7e52m{background:color-mix(in oklch,var(--color-amber-500, #f59e0b) 14%,transparent);color:var(--color-amber-700, #b45309)}.dark .exit-badge.warning.svelte-1n7e52m{background:color-mix(in oklch,var(--color-amber-400, #fbbf24) 18%,transparent);color:var(--color-amber-300, #fcd34d)}.exit-sep.svelte-1n7e52m{opacity:.45}.reasoning-content.is-streaming.svelte-1tx95pu{max-height:28rem;overflow-y:auto;overscroll-behavior:contain;scrollbar-gutter:stable;padding-right:.25rem}.agentic-content.svelte-1uhcmx5{display:flex;flex-direction:column;width:100%;max-width:48rem}.agentic-content.svelte-1uhcmx5>*,.agentic-turn.svelte-1uhcmx5>*{min-width:0}.agentic-text.svelte-1uhcmx5{width:100%}.turn-stats.svelte-1uhcmx5{border-top:1px solid hsl(var(--muted) / .5)}.chat-message:last-child .chat-message-assistant.svelte-3902tz{--assistant-min-height-offset: calc( var(--last-user-message-height, 19rem) + var(--chat-form-height, 6rem) + var(--chat-form-bottom-position, .5rem) + var(--chat-form-padding-top, 6rem) + var(--assistant-margin-top, 3rem) );min-height:calc(100dvh - var(--assistant-min-height-offset))}@media not (max-width:768px){.chat-message:last-child .chat-message-assistant.svelte-3902tz{--assistant-min-height-offset: calc( var(--last-user-message-height, 18rem) + var(--chat-form-height, 6rem) + var(--chat-form-bottom-position, 1rem) + var(--chat-form-padding-top, 6rem) + var(--assistant-margin-top, 3rem) )}}.raw-output.svelte-9270ee{width:100%;max-width:48rem;margin-top:1.5rem;padding:1rem 1.25rem;border-radius:1rem;background:hsl(var(--muted) / .3);color:var(--foreground);font-size:.875rem;line-height:1.6;white-space:pre-wrap;word-break:break-word}@font-face{font-family:KaTeX_AMS;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Caligraphic;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Caligraphic;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Fraktur;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Fraktur;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,d09GMgABAAAAAEGMAA4AAAAAgVAAAEEzAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmAAgjwIWgmcDBEICoHLfIGeJgE2AiQDhAYLggYABCAFiQwHgw0MgTIbemgV45gpbgcqQkK+YBQ1gZGyjqKEklaJ/v+YQEXG2h2afRxVJR4RCiyI3mjbqFujaBp7YJh+7AgSfzkTpf44Ho/HWy3qvgLbS7vqlV31c4Nc/b36nNwzdjBGP0V/h1SkTEqqCJZg6QiNfZI7QNPZ3SW5XPwkueRivVySJrU0lyYVjdWoJ01daCk1WkppqWBSoNjsWVd8gsn4wcwepvDDN4ep+/Fr6Zv5sIBHexfeAw7zhlmhUCkJH1K6FS5GFmSNC8/Xj72eu/smUYD+K52JhbYOgIQGdI5BGdIV+mU/P0D/A/jDbn5wAKzwfNpMLqqEFfjKD3u0ATrYkEwJ+xySgtJ5z0Xtot6uetrD/PhNS+lXuiu+0Zt4nIyvdjKztXsOwjLIVrou5YBchuQ3+bU9odaLCS+Sl0G2dvmz9Auk4lxj/egXhoB8y1/bnOKVWWZC9iSv6R5isnvwp4empCsBUcdSYdXohP+XzjRXKekCpZV2yyldtrZf+z2lzb/O39z+zJcZ1vAWgbBFAq7gUrew2Wa/eGBS3j1Ete07mdyMYbNfz5FAjTr8n6pl+z9IJVyiLkt35xBCH0s3nSt3LoE/BIiZAbTkgNwFAVG7BPf2kaA2ELygVDDZj5JDimWMIjdKckihd1HH1q5ad4W7+lyUjUfWUkusgFjYClnnAIiEJXYAfAVG2cr2VauIh6RnLbllwqotfnrbvX2OkOo1usYLWiXsMf+7v1fzkTW5u7YunlGIjGUQMsn+65jLULXbcnbOsRtjA+YIkAARSLYvAOV/PYsH0HO6FQA2fnzwNzYQ9HNPAL5d9+C/P07xlcwWwI1e6Dj0TKyqfvcZB2w5wwEA/qqDAIB2W5nn4PIoabTITYNnTf+nhkcrS5GmWr1lxu110FFnveya2z7zG7EJVkK9Um/U/+tmz/bufrgf6739RO/vQ4ssTdG6f/8FgGaWJkOtRhwMvOyX67W6Vjd6+zPu64OLDK2itf8vev5zz1133HbLR8474Un77LbGpFELOeCP9bi9Zm3/lheeMSq0Jx53vXnNQNpVTYnlErSzhN/mt1kJGNXg3FBPz9/qdF6M/hTN+DZf1Mzr5EMM+gWch2EUeX8C//g9+vZnYHyDxnOaS3v+BHv+byYTDzPdNdaCa5DooAMhSd5BIC5zB0OtWoeANPti8cyS75OhpOQLL/Z9qbYTmF8Xgmsw+7lBXi06bnGSPMXmkq3s7Pyl5dVLknao7zKSaU1TcBT2YhcJtwiyQwQ5BjBmILIOuNBII3xM4Gr5Z9cQLxnOhuj9YNktj9NfATpNe6UcXT3xZaWYNtann6MUVc8NDW0VjLY2LIaB8HGBzKV9rinYPFVE3CRsQ5uEySDF2HsA7LicgZMAdufc3h2jtd5072k+CdMMcOpEpXv+BU2OUJDlAcTfBBHVR4eCDAXpuREMTgKGeUzzxtqRRnHocBsAkRRj4qWW+uua7tPnAC6ujhrb15+c0sZ/PyXKcLeKzDshTUyexqDRRmH5NoAwvFhduZjDABZ7HTjOYF7bMq8Cyj7Dkzn0tQcYYxdaELKdPmcnMt33mEe4XKLy02B8JRudtYBk6O/agQNO/0ByXZQqhda3Ij3JsC3XqLJgK3RF5DzxBssBCxDOcAdtvCre8SUqU4ihE/CpR9/+vjcHsT4J1qiNd60jQOHWOo+8uiOEc0SGAd+dwEwS85GwgCcylAtSPmFQrionMj205UqKSdpbJaMD9KppvP8aivwexOt4jS4qkDm9E95/WZaMdZnME2ZRkO5/c9JxC1Q9qYh9Sth9CVYYboCWVRC+ixK+NNJ9+6zt1sOx1THbdE0zsBnY5sJIwDGhNKsDojVKDA8twCkdQASLHQmtf2s5LBW8/jWQNi9DfPN4Bhcv6biwuozU0qkl7z0DkP22oVqyU21eYuNadEQoyPUcedIIChpDhyagU5PQpSno1jT0aAb0aib0adZaG8r/RHR5/zWoVND7xWIs4/21c1H253kH5mrZ309bjCXWws/TUD1ckurzD4sYYwkVy6hYQcUqKtZQsY6KDVRsomILtTEIqQcsDHUmCkX6Wop+TOksFIMpWxxG0wn35Rk7RiAyFjFjzRt6ZR8dIIz3MJpfxMXvrSfcNEbGRUluGO5HL92x8IwOaYxDnhCvTWBJvZJ9lyEUVIZXx4gOoLcMXuhGGZecr5+WSUgtY/oBSPCvyDGF6lztmD60DnHWv3EGhVN0QyobgvLF0nzbPh/alWQJu+amu9F8Ny2UO31Xd84CROTPkvQvdtjVi5tWcdjbawdNpG6nxQuYK0uFdwZtHhwKt7eUjcvXYV/qemxiktc7o7/Rtm1KW7YIdJRwT56vIt3s8g+lfSRToyjmZnXkh5tcpBvdQJtqVmFfkHWUN4wLbY4eWL5NJ280yUSo4toQKRqB8hwGo4bI3AnNuYjWjbTH1ZnomOeCS7Wisgq03nibW/Cxm52RpFZJxJXFJtabPNNG5RnOQiW1WlNYCqHlyQNK2m+73r665KM4NNktsYQN+fElIiuMl0hPOAP7bMc4WIbyiEUjZGXnGSZmGoPUsSrDku01ma4wn5qJ/6u2HrZIcAJmo0WTa2Au2nhjS7EIttOHmkKzYngCbF0cUXoKZOZlMu7K0Xe2rWWVWirdwDe/gWJ3qv4YLx7SX8U4iX2UfKLb2MfWumFsulRspAmba5jtscK3bsZWsTq1vCmEALfd3HmvOlzgzqn6/OT4RdnZvIsCyp5iKq/vgZkP7J9CNFSdk1Frs6UOMKBL8G9KOwx0RBsWTQ1g6YC2FuFAcFNzSYGnA/paOgPsEyExGGYA0XWAcSYigWmkpRq0TIOWaxCFS1zXShpDpQPWWkQDwS2tJQWdDthrkQMtXNNGtobpOsA5E7koUrhmANt1gHsm5w8UYhGUZ6GEWrIXauIOOhuh7jwvHiDwziDzzQD+E4TiqChZjprl0hTboVs7iBkgzcDzOSewZAXWrMCWFdgtBWMGmDPwJeck7qzEk5V4sxKfpeDPAMOfZ6jxgn/nxfaHR290siXWg1pjY/Q9zAaxO1ncrSe4igDRnAJ6YUoOHLjIeQCzAsDyFfr+cgDnMqggoTWXuDepvdj0BNgeuaJ6mMo3FmbDt4XPBaMwHsXyGGYopPgMPJR2PwwJaCCBP9uQD9NKNZqFQidBYmsIKkxbEk5hMgJXORa1LyhxkT6THHcQqAzVikT50lKZD3HJpAVWqvnQ2DCa4l2RPFSmoNJwFyOqV9YFA5lDM83pYWEaqUMRqWY9CpOk3CEPStPF6d0py6uV8mw8TpGekVOZXt9YVR0uFuNKyyqRU4oOJ0klLCpL76ZYucyjoTGFikFxZThB+FWIUh2bZY2OqckO1aLEULtUqqG0Wo1GxBNxy0QclzaWxfME0FOgHJNCU3iBpuRhEAScvzFzHj7PX6DVrjxLdXjCF8+a3NoI/nQioFMpryv+pqE6YpEX2QXHx+EdsKEFkw3Nj+8x91UMq6YxOD+xhRz3d7CuNZkdyh2suNQsqXuycNGOxv3Td0WCTwDLJvjquKxQUE7ZdiwZclR8iDGU5B/kybl263/+M30j/+2sL0mivqvb07TgiD0TNRSYhNSuSDtwqUxIK/2BkdNkL8wQg34xxoziu2pS9BOb+w3O/jT1iU/dwtomJcJWM5n+i4LjdoQlTb+aahTXYrlaEe0pgQsOeiEIDalESz4w4DyXoII/XZ0uAGlIiCXrHNUFxRSWl+gU9O0w95vicfD9kBaAdZV51+IcBEyH7N/6ygeeZtKnGRDWJEfkvUILRjM1IMziuyP8CaPuhcrQR0sNxvaklZZIqSxwzFtDAn86GQSeRkZnlKOQ1hlZAx4b3rw9JbQfUzNLnT9PjVtHc5ZgGqKQ53FXpp+nWsRIs8at/ZYiFmKp0BcukBWuQXJKhjiO6Bc2qzK6NZLTA/EUiMkpcRjYRCIYAPGdrOBJQtg17YeYm+UMTaMLGSafInQOoh6yVKQU7uLaRbIfnj4E+g/q9pBG/n/IA5IFA8s+Rvhnt2lxnqNx55VzDYUDdZp5V7tb0maRePoURAtgd7zVZFKz8Z9gAhmZ+xmAhWYp9BBygL0upzjz5zT0oEcB/A4SFX9P9u/6wZPYMuToZfNjgjscQ02vFOTrL62/2SqBwpRjzQI2sWr6duW655qMScSm9tfCZJ+BZyXHUBifFGeOh4lEW3/cWrNvXzE3omcItawMijfepnY1k3VLj2s0hSuSPONCjMhjTdY2Du7LVZ3CXN1bUmgBReRuxQcn3Gp736VsERznKQiNPM9xkYDuQKymqNehbukEkzFKouL0NLYzZt7j0z+DbZ/KJ4qL66qxOfugrq5x8v53Zk0CwcWY9wiNjpJ1akBWaPUKx9PEuRgR1jTHrszJla9vE1tIXBwKbeHA+pOjymz1SJtyYLtlpEZeXHVb0bamlrL/I+mgYVjQibYUuMnx1td+j8JWN52D/pTqHEWgUs7dinyvfzU5xaS/JhNNLHJ/JM5olHO+lRXmDWsZasZQVx1ph9c41qqqSUt5PcXovwuEbfsr5/DiNSDAdep+YvTxtGQpJitf0UMx45c2kt8cL/35zjppa6s9htWywKzc/QS1v+MzLGHnAxF8gq2+ZW7z5xL6Wlm1o51yeUu9HZrsqGCNyd6bFFTHdF0LLfI2swGh3eQN2ccwx+RNO5GWEFlj1ahqKHZ15R4GHMn36E+MgX8XMsbIcig3U0HoIW+3qXPQ0WkWPr+domNnXq8el3PoRkuojmXgHbjR+gREkFkczyK/lyP4oqCLpIbdkjQeG8wcfdMzTG5M7QAOu79eaoLfQGUrNtvX7b6V3YjgqJI8zkMqrdtOl2sg6lMyxcTUOUJ399nl3uDKC3LH2V2OqTFk2AqUx55y6Tm3m9Y5rOMdVfN2HE8K+Ns4HnrMe+UVtXd3NMYVpLGho6ly8Pd/OgmqvCILwmieCI7ITGzJ6E3/7ZhfvBgavsTsjobWkKjm16aBVVS3sEGRsHiAvCKDyJv1nZzWzJN2kDt0qkqhH1pLdwdMIw4HZv9K7jmTytfqfhNb0kQ62vAnS9xMwaVEScodxfdX4ekT5dwwRCiS5RtjR0DTiIgA/5gEe1k7Ct2Z9g78PY/e4R3FxWAimJigEBopeIML5JHPvd2oLvuD2IuY0JQ54IWlqLGWn7cUoBlEWtunWuUw8yZ1WN/aio7Sp+Cg43CbdOP+ans4Bzq0xsenpk64fRgIGfk9L1NIQugJsJsp4BfFnooSDUHgMPZvydgtfpCloxmxgw6wz3z8RofL7PcICpVWfQKsQz7mgcPRxw3S9WaDo/d0jvCZJ+8bkvdDYv0SRzOiyArVKV78b+JaHNUJw2eQHwarblsowMPQ8eLBAba2LZ31yuS+rYBEsFkKctDuSkGLYjyfLR6ZgwCtdMCzJy6/IOd+cVT0feJJisma1gT1tvXOUHjy/x5QpkpypaL7lIzEs3yLpNbhdOwNTVNrK06MBOT2Qb/msXbDLhuvvNT8V40ZMrCkwfeaQCORA80+zKpRl1PPHjxConNwC/DYhi8t4APv8H+UGWtnuVyFxqzgoN4Y6ieSvP9J8ob+Ldvz8os5r93b9h9QetLsAZv2Hrbutw7yiyGmV4cgxWcvROjU0CBeyvCOpTgVKu5ABWyY3lQP7bchhHFpd6RCVJ+793ZtXjmb2alBl4h3HGYeDybpRckucM/gSCLUKFkJ/iBeWcRi5gc40a/YlTOl1xddCBaYrDTOyXRIMDaYtyZnObq8Eypvftp2oq3DCdFTDKuGY8MkgZuqY6Km/zyTpzDmDbaFEgfDWoU81eslKqB8Caxkbqmmakk2Z59UtE6hU5PHq6F1MrbwENyDhe1eyTVuqQrfR/Po1YpYyjHiGuuKFP+GLkAji0QBeJTQNVvUoVK5QESw2pDfeLMm98wMeLJQELEpTkwoR2y/mlrkUjjgOggfrhp12LsYS2dmFkbDzma6zhs8futvdOkRbTfrFG4zu62mww8EviJRzc52EBSRzcjpo2yyFdXTFPQfrCTrJNzokDwFq39Tg9PyrZgE+osSTyzc1jsPeW/htaGzi8Lm8FOZJJ6RcwzqVqEyOL3vwLGC5zxvcR1hH6e9MT5MjTsVPzQlJg0jx3Ku+Ukloz3G8FdhVmNQUp0BevpUsXV4TqH/R5bvWdz/wzwMR2mauehbMlQLchDQFYqFTo6HVVaxs3NRQVFap9gsPVH9jrIlSklHPQ0rHEhrFwPCwJ1A5x4+9J856J/tyBef/8Ko0HHgvG/UKG0Uet/zhsIqSU2WrSL8Wq1yuMBYtoMk0rA36RFHemmblTzVr2UZIf4F/gJF33nOFEsAV+jmZI9QHmPJbnpvGG4XS2kBL14go690fh/PvpQ0I07neCYkb7GPaXvbvVFFon5aaijEuAMDgzy1WLYUbzGSccDwVpGMFi2souvjUkdxUGTMN9EaiIQlqUvHxqBd8WM46Q2uZ6aKcei3Dh2K1jnZWBFWzTKxY1QcXz1GMpAVPl9GTQPjYIdmgMl2moGAJm07SdTY8w+ctlPiPO8aFK3pmgQW75Wv3rt9XDJNXHwuulqVe/v1icRZP48/6h12FHHz66bXvOW+QboINblXCbl+9OAaDaCbMA8qiu1vjV2RPt64c3CTyb6RT6QtdI3ionEcxphwDqVP76/07WA+rh3bnqdJCMZQkJFBErGJrZX1S0Lhyvt9hrSNgltPXjBrdljJuXdkFy/9Dfyr8n0LdrnsTohZbiTM9SXTzID0xzDO5NY24lLT/ymFNC2YjJnISadFgLsvwprs2mw1nkfPBJdKTVf3IrsHr9R6BnflJql71RMuK3T9KwlJng8U0z7LQvA4DAK8onMMni+wBUmjkFIWxi3DlCSAehiOgsK5M3lhwyrHHgYZpwkVvTI1q18t08cdtmzKccbVJn4xkZJzug0Pv6PsiJf17cdX25C42OxpMKWgmWxPt64BtghXsovI5znGjat1l23XEqMXEyco1M2wUmRHoQWRGuZRFm0dJew1uh0qp9NQSQiKMtPm15Ic29/0TqmN+bBB5fMBbnr5vFpiuq65QQJ43yaZu2+wqz32qG+BQoL2rvJts6DBmZZBlOhJ4nT684enYgi2fneI8JqjLe070wparRFQLq1pKiU4ruiM6v6R1Zp5w3fttkwGZCdpxkQ0XINUHL84rqpmb3GCsqzBfDwH0QPP4qYb5knknqT0rDjau1BiamkRRMyxyrAv6ci8Hq+Fxl+yM/+pZonJiEv4EyZznslzdjv5P7kunkdQsZkWsW5C7Cl2N06WqyZpCGc+QZogrcESRdWAVBMPiXJdrQKXy0kHYPdc6kPTTXQf4pZLtTfMZSy11qX7gyK1UzqwTqy7r6oW+G7FdfdeVw/ShczRdFk+BgoNXZKElWmXTan5nZz0W+HzqsPOsCC8V6V6DX64Euc+z/d8FHa2aOYpCXHjThxsBNvd2sdkbylOOfYxXiIiFduOctYomE3mInV0W1YXOuWZYOqaMrTc2Z44P3GCL+DrRHv+vp1NsbbIHfWJfdKZN3LqkeRpmgoG2TAeJgjhtQNkp7OB0MafkGTlHKZGaIw+UU9K5ebNGtHjxWOPTjJ0RzQpraD3XWEcpju5skiINehbYzzZnnOGS7t3m1l39oVx1RSpOXugcdFJJhtHgoEfNGg/lbsQYIEgzfTttBody7V+mCN95iDxt17390gb3jvLTjuVJeyuXnmqzpn9VSAdlxnnATs21W58lwYyx2zzRXhY5BMlzfvAu/imx4gBb3Qsc+wTX6eN/dh4unOGyW7KusbqAo2rH0vZTa5anB2Qg+5+V1NQUHifDBeY3FfBFvdzPNAx74tR0tYlwm7Li2xt5TG4Tolyq3S4l236Bt7Hqr/pmMAb4OtkDufM+O1b85Z798j1ODJyzcujbaF7oOpf0I4UExBOma48qdkcu173bqkrQz8wtz+OiFQWhkFo7Qd+/GMXmsYRZ58hv8U61fHBEpZaBXfUrWY9ZZmqpajH7m70hzbLymCV+3gcQmk7WufY1tCFKdEeP69Xz/CA0L+/TkzFEH15P78XcQQk0gJZqmd6bKxKFVh47JbgYUKMeZMZSqrQhpnivhwNlvIzMMFPJcm/wzaxFUfyPqQoNKmvHmVrGC9UlaMrehl0tYRwcpT02f0dzESI2YjNfPAic6L/MTDZ3bJBW8q/Gy/xIP54LNutrPzCiNHST4odbobtYauGr2LqBkKDxUYac83O9ZYiG1kZmeskUkhZxX8TteMZuZrir70MW5j4m/IU81qjRNv3BHx66CCrEdljK5lKT9+5vmrxeKqtWYWR2J1/mrt+gq6d1WAaUnsFQ6x4J5xhqZS/KSM2MasrJ6vKOeZ7cntAYEuNMU38wXEqn/0+vlxY6dXIb+gd74lV2Jc7nVzF7jn59gcV5D9nZfCkj21Z6WMoMIJ+Pfc5zc58V93MB2vOqA8nd9nMz+aH1ptPa0/xC2S+752+egss9UcH4JzyKSChKwLkrN2+l0IRWxU+OeR+y2eFnhWFNBUYZ1l4MMMvHxbrkLdExFlxj+9Ocv1gyVdJl6/iKO+yu2DlK21D7o/IxRj9gk5eA1nccnJYOa2uaGr1Roz63aAe6vPfOsGp0rIot+rVXlfnVRLjpOgXPm5PvegWoLfO/jANp7d+c7TTymgcs+mmGmbJhHXJ3anmZdoAVFZrJjda2e5LNDYtc2xaVPU7Flv3QwgoNvZK9Xmd0AtEjmT4UOa31kpuATOTzGM8fRn4689S42P8Tk1/V5FdF+7A5wK0jFST/y+U+wkUaYEVmAWyKUxAww1fWt1VQXqeOp30s+fJwDxKwyjhu9dOqVpsHHHWOyvKDZS5bAXGeIM7j9E4A/S9+TDbHoyS8UcdutLjXq5Ju39TNqCYe7x6qZIa3sFmqOH3bZYG+2grbcBBf8aJUUgXkfE4XGbSNgvsKeV0KkBW33aL6jHn7NhPSloneapUKnAm/rIt3ZI0qe0IPNMy9fcd1WJUqSnXC58+FfLe4hDrlU6M0CgEyrrUMkypRHlwu5XeIzUi3h7lWk+2xmgMAlx8WCulrOmWWLM72enII8IbXIlmkdctv23KrdHHS6P0HxTcfxCNMwwWi/eGP63EOkW5i1uXVnO+g4dixzBMIScGH9uKWBnImO8kq19IDkhDOPYHdwogKxDuYpIJb1mFFGrKjXOmESqKCsKnVCVtuWevEbyHiJzM52wHpcQLtBA7wqfe5KJMIdPVYPsFMk/2BJx0s2A78thZT74OTpa/ULQ2/57rtYAduEPv/iUswH4OqORf3vBfGq/uHYqdimbWccwBLHzZ0KiBKXLTFE5MkhqslM+Lm+JktqwG7TQNoitMYWUay6smzZSGx755FFETelYXdSbSkGHJy6goXfoFD36uksvDoOvVGdrKis/eHEsk3n4oHyOzJ4CJvC1pg973Ycn3EiScWfknuP83VRcVBki5ggzUN0QURxaDixedxmF8IqLw1aSu6peO9ZdwxWFSgbnatyK1F7ycGQDyNqcNeJv6eWJQjPTiLulXqX1FQPGKCg1AoxC9usfBYPB79q+/60hxVWJ6ZnK5NcvV1IC6xbqbjqysruHCwM0dQsl3YoHc9ebX78NiXIyYzBan0QYNPx6ec3MWFLL5kb6SmfKIkFEN09bk3oeLCD+D7Fv21idYrrz8k4Wg3Zu4gM6yLSxVzOHy4lp5ly3aMlhnvrYXvNOTJn1XRAT0it5aymvURP9CdcgDEufUadWfSub5MznGC+DC8QKx4XzYkkvDu44UZPcVKFfIA9qlkZRarFgsL+3uK0FYLNYTu0qFJZVL1KoHSupMThPvtfsq05RKVbeKQpl+A6xbvyM67CsaBTCyQpciZfc8vfhyZjcjyuYrU+U5PtZRfsQ3TFMPVDTKhE+tl8ukkV/k2DSbbcOh2+tBA3vEQH+/TgLRkGqwFISQ9XvVsryc0xzATIIAHJaOm1w6svvvMWRng1dXVQH7vpJqJOjA0WDXIc+s9uCTzGhZ1GoZahgUS9+Pcg/M2X8naoLrk6rLYfyeiJIOPNTRd645+SNXbc0TmxuvXcHfTZMfrC9bfs/8iGF11+r48jH4pzUGf/hNYEUMuH73MmZYSl4JJ0/Te8pAjaGadMMKrEkGQ46xlsFPXjno9ogmk9XIPeFEniPFJXBupQQVw8bNF58pRP73Zg+wh8NbYMa3YKJYUbYR2jYDdCgIZWD3bsC8wzQTMQ73Z1jXWXPKlP4bhf1rz/J5ZvSM32HK+pJ/Wqhn4R6RqX983DMt4OF5CQPLgXH6BTF8Wu/Ti6zLv3z3uPG+S/kBvOZrCS0RmHJNAwewYYm8t7tLbpo+ZFwPM+iZE1q+eMS2pPCtczKsqS5Un6LutDyeU1hc+dKE6brR7GXvuCP26Zb6Fig0nyy5igmXxqywnY8+gfy6Q4HC2UyWBoDaPNNC+aS/aWamK7wRxJU4bzkeh3ri47ueAT/9zw+4P4imZKy5M3elQO9yX4S/qTScNyQnLYj35Km79JbeWdXGBMV3/yTrcl4GbxzqU8Q1waRxg/V/sREIqtJkOQv+bmw96JZIr3aEzQNY+5vnU6ep4kk5wd+dUFOq95me68l33pzFqxXZuVjxL+6o5KIxhUSOso2vvinifwELtno5UqNEoajOjIPDHmGG6LjbGzplbkRaMzuXQcQoFzWxO4AlBba8b1blVDP+kcapFCLqjEX1gFR/2V4C4kRfci2TxAxjC/7UKSCzOxxtViD7vKwpVrH742cOPkc63OWJ/towTChbIxU93GkxruSJazDFxkNwyWXlYYVA5pZBwzU8Y2bMTvH/nuMjuudK399XUT726OqtsOK6AiljpvdxO6v0xZeecIHMmn6r7Q256RH9sJ3HYfEK/DKP/1PYFfErUeNucKAThmW+ghyP7lqkWkJpC9b2gfA3IYOFJz4mVJSRlcpImyb+209GpjCcXcWHS0tx/8SLXy3IyaMUXCjY4kkzH+5tX2VmoA8/B0ua5mMLa4sXaBfipWN9Feh7BPz5A/uXOR7eTx6mb60v0WKSLwCXvBLneKP4bCz9LOrTdjA7t/hUCemVvqhBCpP0MKHI5kc3dApkI82Q+wOlTOVZtsRmuGBSeB4l21HyOMmPfmptwg15pbImFYFhrFAuFrnbXaM5UyRlaBJwne0J7SADAR06V9bs6WVOpXT3W2dLlzo+j/cwDxkonTPLDF196l5pUePrhqgXuBp0znHq8P2jdq4d/nbxj9acKHyRvHy2t3lBXeIZjVYjcucF3fTSUKo6hOcOt5Sn3P/tIldUcjLo1x5MOgTd4TSApD+Dh+QlxD5q5DaPfpU8GKhKLE5+hCPEEgu8nCHor2R7QPi/46o/VTFrArgh8DPGZFpLBvRdS87E+xs0eRVR2XZvigdONjeMKR/SC4Rdxorw1nUrQ/iOsCS/nfXCyoR+9dtKvXjfG1S7sl4R6VD9viSmGw89jPxJaUPa6M3FAXCGow3oLOe7qUh1Z0a/PXPdus7iLVFvJ0vSs29fczeuWlYh1qsvPcrHBHwNhLyR3xGZbV+QiyUh3rz94wsKIr2g/FMpW0t6RpuzEM53cMbmLelRRAN3OPsk7h+TgRDI5ckj6ol4BpoQiFRsM7pooEzhlhQsiNnzWZRhYzmw+K/FpPprJsLFL/ylA6AN31BUVv61iZu83NTf3mwYzpa8Eb3W56Mbe6Tv3Z6cjv3ZaDI0y5prA6pJy2Tflma8IgdM+JAIsHmJwSNNHXw5u3de7pz611mb//R38ZHHmR1FSUWVgTxmu3aoPuV0UYuhjCMn0a1COP0PvTh7olWdG77oqWa/0/gN4Bh3hx/TJWt2mPcgdykceXSHdQa0KTM/+vgTfzyFQSuy++nivNzvGjxNEdwMxy4idkcAG+hhjtCiMD0npRfkRkSwsyLecpwZKG5oNNaB+g7xmCrCv2DsaMVR5HQaL1Ppx6CKxw9oqIm9dg3Yu5XsFbuOLsh1PJBw6eLGx8tIW6FMrF2rLs616XOEd+8Cd59Inj2/2F9jS0JB7bB+GMrNBSaDuLZqTpUS35n+38Cz9Ep6JQBVVABzMZ5Wod1zJy81lLK9bGGGflIRjCuqKy4P5WRBUZAVMgNxUDGP65XpRPirdaVz43UinBrY3qgoH4+Jf04RtOc6C+eamyQDxuRsjc05Ns4aRAoJNwPATVtVUnGJmdAhsC6K0THsEcibV3rb+UMjXfZTuumjZybJlZeOAb3tJgAsD6pu4m5sQxbgn4HLUnY+xG6SJ45xFeURq6IrNXJAxKxWeZAzHnCtEYCiYwzzFlze4e8JYeqGqUMmItmVImGlwLL21ev1qemuDyEQTX7+K/cOEpHNRnA9AoYYIKlQma9LTj4LQBxIdzjyyGHIlw30Vohe+slaR0TiLrpPiJDsSqGg43cTMR1vUykW3jY3uz8owCazSlQHHhIAKMbmNyVsu6SFEzgc/bBuWFlsvYn5PTuUJAV2w82VV4hQIwpHdClUr5tm9EsXSt0Z6VByMhDO3++uDEa2gYQCRawZiSUGloWnI3KSercV5vkfGyulGeKhjsUJD+VX8huEaERDoXjS4t0OU7jtpb8WK6neMSyzXBc2pSiLK2woDFku/z/h8rHEJJsd8jtXOpvRo5+K0DOlxjBO3Bugnw9/DwPPMoEt1jWCtlJqn2W1g9ol4MTkV45JpadZVooU7aAlvAkklC/4/f4TitGNcGZmYXizJFZoS1McNwhNTEZ35iDh6ZLwM6oI1MksAnk2S+ygrh1UChF3OldRirWzcjAiu0CrpRWUc8zvqRN++Hl9iU71XCRqAACov03B6YXeA18hRz6GwNQ0sRYUfcPll/b+vGjbBHpTyo9fho2hXlDlm86rq/79gtl2CI5rejL5exE8nOX17cLY01u76nKHa8Ft9dgkbdiBKB+DZlF7Vc2M/VMRP8K3Cze+6xp3rgDAlqK/kvZgMecATXMDWfswpmgD843BHSFu25xNOlB1sPRqwzQXOrTqyCpePypLKAt6yyWEqywN6XpBjeoyiYwM87QkPRCw2KYf62cVQrWcU/1XwvQfkN4zXIqmczN8+8NYuZ/wYxwVujE2Ts9FQmH3mL9M4PIX5/41YcFBdGQUfV6qlGsP5xgvkzeDZlPtcURXKcGXXWvev7kXaJtSkGyLglPgAGA3NwOaTSFDLi4YZ2+XYAFQrysAJUEymLi1qudw/aW4G8+CdUu5UD+oOm4qC5aVGJAxs2H6fFCqwD3WQiHpAf3grhoc8rKUzolHjnwq9uOwkqPdJRs8Aw+gI5tXDKUqFlg2vH5uu4iInmkTD4x3OV+kukf3l0dXRl/mbl+tetEr+wzRt1DVg60m27tXT4VTBxvCEoamVHWqZlJW2y7kpMVot156dSaLW5V+hqdQq6SB1b0N4qulQKm6p+KrtDSaSNnVPzOz0NKU1vfU9dgGL+COPKDpTfBP8zdZsewvSeVNAPkWQw7CHHbm66jqLGwSZ0eSrQrk+GmmYnnmU00Zsr80qAfWPFVvnQZBDri/jyw+VUfcyvEX+FUvFhNJJTu0QmZ1HSHPN5VZpryx1vjH3xNw3niCySRiDnuJ//2nOUa5UUmG008bhJrdsudeA7xo72KC9n4UFnff5q7Wf7qjOV2AT3NdVqFn+e3UIEuq40J8xY4vLm7VXOgVf/uvG4Ofcrs4UNovgO4UbeZGUP7dvBrrdgOpYWOLZBl2yFH4imX1iQ3rbRLlxTikLTq+JJSSeAxdx6BvJATizV+aGspiU1hJ1W/D4CUDopRyXR8S2UKC4A/DPBqeGHb6UzZrEHYGzcSy0M/LIheav2e3rDF+RkqaN6yGwH1feCX8ZtClXmw/WF6eRxsoncuZ7pDnZ6ql8GtqjJj0B7KzgalpZr3M48dMQLvrc2fdmqMl5hBF/69K+bkf4VklVis7K+IY/89V9BtIBTstgJhhTaw6NdyPPjDO9E1Bq98X8SOgaCJzkq+ZBh3schB+E+1e3VCjtGkdb9ovR3ZPnB8kfmbQyMq7qYn1RMwGT8MKAQReFV1lysphjqPLA2WiZQbYDlDbLKmtf3wUTvnhaTmOTcb3SR1Z3DhooslvOrlXR2+3ApYkS4K14WUBOmnZhl5tpupAG0ZMruWDxaIICHY9AWf3LbmQN2JyHKOyctxxHXQBqFF7QLiBG98PGU0sBICjVxtUtSCpRME4T9ARMYO08Vv5bUhbZE5cee3eZDU2mYN4HbUI8CrQyNRlAGXnhHv2oOcsm1eHMtQYNy0ju99dnJ91yW3YhyZ716Bpe5gnLSedo1+gvRQ6mcgzPSTg/fn0L4rwp8rEbqhAfLQ4bpXKx3ReLg/WcMA5Dw9pOC4NLXMNvWVBdAayC8q/hkz5AG5xLJkcnIxb61ofGRVtmBcSk6ES9FibuhVUyjF+pH8e4ImQBggCk3YDYM4PnhwOWDKnzM7yQqmczD6YqALpUmAmJ1ZGJn826UAf2TLmih/Lj45apTGOdSheDZpNDSAclLeDlvZedG4HXCyaZdzk2Jr5enSkd6WAFwWlYfHFM8jd9o0BoPLJYURvjBp/mPTVF4Hv/A5CLFfYAB6X0mZHpVgxqM290mCYF4EDO/Hkcm7IsOnAhnmqg+oAoCoDz+syDwvr9vkD332HlTz+o9DnjjhPQjawL1eSW68tL11NKdhZETcowInpX/7OAABXsh5/kNSrlh2FiniVQSpfng8NisSUPyjgeO/Arb+/KOCNfL70HuAPTIC3QP/JmSjT1m25xq3h4YJEurGXeOBlX8+C22uEzzEhG+Z/WpeD0Koij8hl+IcjDMUd6qObp5nBJZDLav6aQbgo3Bipetnz0/ti8lXPH38U52E+P6+qLL+UDeQNTotYg1MbRFE0xnaI5NOrTVs0XBksl6jIilA7JqTYZvThF7RnqxoJT9eqoe6ml1OLCfobbBPqlwcYnHvSmri/bJflcUTEzysPLcCNCa4PY5/jgr2XhOJe676T4lDDDr4Ut0G6Uf3IJ5GFFaG8sB5659LkqpralARdYvA8QUXssitCyyhV/ZN/K7Xhr3OJIqIQub008oStkeNOvsCDn/Vz+ReyvLsL2tPecOMyukdVu2VpOyLN+uOXpumqUfWAtNbwGd3b2/s+wrJRt4771rS70yvFx4hIYzOobFA2yEbJ6b2XzZEkMX9rLhffc0p3lxWVNGelybcwthZoCmKbkjuY/E21LckFrF3m1S5Qf9KtVx/+7DL5J8Xc6tQ2kuE7ez9B7lD3VfTaNpBrp7a36/bwtsjKaqkZAEpM7KDUJw51pOx1Kvq/iaqo9/wb0jHvMAPVGh+wMNEYQFtjAiol5HFP/dj3ev3KCfrkfbL6zws9W4nY+xbjVbhFPhvbG14idWhWf/U11pH2IipLyG+5gpKvKpGkr5I+Bsqm08oeK3DxXsZVfyr12dx7+ojzVxVHRqc1NyntiyddCZ/A2Je8rULTv7e0A/Igcrye+oX0iieU3Iy/cibiCePhXIE44dOykEmBIvQkPQkaDGa/ryAhWZSwK3o4WyZBcGzPPU+rnN/ONJxr/bW0LDHWzVpln6f8B7awqrdJbe7qrfBAsH3pp7ZsjYg5NalEpFYoZtn4eIsUYRCuui5tpYoabpwsIaLIh84R7J0oCOGBYMxo7Cg4x8JPmtr0ldQKgAkfom7Xf0tTDyjdHYPyb/SadIFYP/I9Jwlysn1CgaB7QhiybnFYUr2HTFI8D8u8Zn8p8e9Sb9dOOr7nHmW8baRuqsOP4UaQNswmW1s2JSBL+YrX5DvnCvNx48Vesl+GxBmZjo+zm3IC7MZpjuq+yrD7Zx6fbxjVnmXuc4/3EDYlJl7DFyGtCCnbtss3JIdVGVjxAab6s+OcY3xndnwsXMRnbh7FaXkAy157OAS/5qPEyFLo36YIrp0R8pUHca6VXpqFz0mNT372ggpTd8pDqNcNSsYW5PrwW8Mw8QJsmE9lx+5Ew0+r3PgC6Eq8AXUZPrxwjMysuS69Gi9O9jpuF5iGAsVCqli5/wzBF/vBchBMCIt+AlN+TOkG3Vb5dTkM0WsN60AbSinIooSqCt1oN+rZDrXmU4q/ZrJ5j/khSKpK5mwdJCdeNTUoEPDEddq0LjrcOx2oiGiYwskejZrpUVatWtIo+V51UD1d1g9NWbY0pyBv4xvUaJ0qsceuFIQ1/2aLrEey+FFrAOMMpNGyWHvh+lyQ8l3pZVWFV4gwVcp3K/GCr55eCKKHq32YDP76AuOGkmQrvB5eUmCsqu6fSvHVkg5FXPhtHBmeF8M1Ez+HkCbxJ5FF5aFCuQlrn17fJmQNbPeilQtF8CEessG2Oltjqm7fhk4w8ob69qut5cqGss6r8bpfXoMtj5qJ8EvmMCJlb3nFkLcNG0OtrDPWCf4jKdeyVZjUP7zkk9QYn+lWn8L8rkl1X8X+Gseo0vKbjPRq07bC5hGF3HAb7HTijYiaDVZS3vsQWoGz6ifCo27FZi0qzMZ19MM0uZ7QvtmpTUlcIRTvaY+3LMx7N4M6EjvyHzr8up4xXzVRN9WJ8H2+Mys+UsJsYNZBEeIGkL82y+txlrIxWA62wOitVqrOkWJmLRRgx8bTgrK2mCjjFnolR4PIqsTfv3zqv/I8fFAspthmYdjOmEyPfBccx98z7YqfcUoliGqcPLvLGyHcUfhidH6mADrKidj+tFJKfB4WvPCUOs1OTRx4isfJ0ihqMLdVeV4F5MaAGgGlvXF2t4VOL5ETwp5VpzFrG8cegT99kTZaTf82PErl5rbOrdcfWGkmMplqAybiEwQ2vvLszppo278Riqt0uTyXyUxBX3oo8oBdHG2Z0eoJeKxfy9MbvRFs7BNJ4XlJowbfruQN3yQeXWcgMg0VGmAy2+dbUQg+pWcoyXVYVW+A4qq5+QmnIttjOUCJVWrXh2RijY/iVTkfTvyc1JKmLWHYr0e+2V9DVlSKYv95C96TnCFR08/oRtWtRiUOrj6sJpNGo9MGceShwVCaoj5/l7TyQmubM+YLW/jLZtV9lf3D2Uv2sHxeUU5PoWQx5Rq6t/Rk+vuyBV3HVCWGapztC3v4e6ZSY6/BTn5usdsbH79FeW7zq9M5vlUndg3kDNUHntiN1owwm3uJggNxyaOS/7LArdut+mBtvN/oazq9CDdeMqoeKOm2YS6WassqusFRgBBtuAW/vO9iBD6XmVDBwiPKzdlTpM6VnT37jNPTWZ6/s4GDrRAgd6+sxUOOrSpksLwxr1H180/q2HvTElHTa4MJk6TOlbX50tq1blf+ziLIztkLu7moO9MlRnmiXnAOwTy/wOYP+HEI/9y5R359FzzKm+ImSXVnX+XxD1+sktuEX/XJwiLfl2lefh2WVBvbTVSDxjQUrmbeophhk9qhZsrD1Q5k5JEOn6GX97dOYn0hJyIu11KF0ie5HJ6RKXH3wnu51ke6IxFpthqJPnoKaQY5PpDT9LSd2Baeg3Z1Rrwn1hlp3eKNb9dM9FMY9yXMj7KxNnYWzkqjUPmkv4l252u8oFiOgnGeHTOXd6GHiAO4kvSuFKCT5oBBq3lRwNXcgizb5OoyIyIpgs2eh88WOcIm6UkQIpNqjz3wNLMKkl3J96HDErFYPJzl7ZOQv8B2jXZQOwhArNsr5s65D2izVmEhatz2TfjufREckblfFwVph7R94MasgcyB2Xo7SIJgYnX+mHDzUNgk4nhnZUn2aAbhYY+srerNXVfs03HfyuVCLBe7FG9VPM4FGTDOh3ndfTQiGsrscpY81lov8ety8nTuguC++18IeMa5joCv0u36wdgV1oDWB1O3rJnHcsN76C2ty64BGG0bDeWrlH3qxOEBZZO6S7g8GBEheeHS9NexPOU0wElIajDWlT8wZJocU+Q355ZzUQiGAZXTHHlEI1B2z6SWp1dkyBWF2dCVv71UuPp6T1mO/QUznRxG7MKZn6WYuJWW+PiiFZYfgCTdo6PPQbX3UbcDUxVoZGlxMok/3fiqHblIBHZF/v8wZanL4ZrfLpjPL25NyuD43f7snFnXnvopbgOs0N/waj02v+HtOlx9bmqZuRV0CIsTBVG3oopu/i0EmIcc8vsmPI0ujRnt0/5zpNWRkXp4+OI7PFCzqpzU/sqkWH0rvow+wZndVaJf2ifMiwnBvFdeFsGvnHroQoCAxd1bH+oSf49HdJ8AqhazXGG6kAeWdgHrhjm5YYl4+8ZN7U24mOjr/VD3xOMzWubik9og6RPl8PUIBGJLtm1u/MbMgZSwSvP16cgSPF9mxoSbH2dZRwEnXw5T3jBpvqMnFqFeux3yZAOzPvHk+5aabu5IIi0/VuEt/wOeAa7w/IhufPuKZbgyD+1MrU6ueKaji28KK/ts7zxw2dusDOuDdyozdNpPfYjHyk9W1Jo2RwOBpHv33fuj3zyzIutvpZrPxsLfQUFxelZ2iWE16s/of/M3Z7xffcd2KeqZ3AykiN+ayrDDvuTGvFBlHkFIm/tmy+SrG8w/+CT38hK7m7TuOlxzhskdF8ehtrN6bnFBiecG+OcGp9wKYPvlijK80Cjnvh5hvbuM8FrXK95Q/alWyIsU+sbUBknO2IFMoWCodIXc9xbPfIwJ4Qe//nvP7sh1RXN4XMTK+lZMvrTQ/lKiqS3r8wZJ1C5z2DuM6k9S2835r8of3rwlRtPY9Xfuam57PMiZjOcJs/DtHH7ogw8GTzfPnh4IDAdxJ8V53sByYcjwgUC0N+A5dqythOj9wizqgvKG0vSxb1P+B4PT3heWwxwFPrWsNQaOGqBkGvk3I2b3V4AiHPrHsaYUmCrx9JfHXYSD68N2hnt/X/JU6iophfLzyYaSCw2KWib7NQOuYtai0jVCDqBTFWFuvflKMi2gm/XMsWt9MEWRUWB2UjLINuytY0idUsUMt1XbGxs3jvgRyDt0Ev6jO7cqmP5RKIdIpGTj94d+vBTPmSg4yPes46pBMCqybRjOav4sLHyJx7vC1xoayokD+3j8WXT5KL2qw/TzY5kHk9JVHXn2zJrg4j1vvgG8hbw376NKq8a9N+dzMghPxLbPLs53risnC7fZcWWeYnr+jZlduZ7SX4rF6ScL7bYeAT1Wh+hazow48rzs5Obcav3F0iQBQ8DW7RyQhFIcfjUeWCnkWObkVQoBHnilmPeX8ZELE9EiUJ15ZWIPDMaxO3rvEBOO9sHQFKvV7CHINOEjgkc4Rr1gOMsLZRgHEaIaNDG9QbbBDKWTEzOgen0BvS8mNCc0zToodDgMGL77qXAdD+E+f/NVoJ9tNJ+Mbmaj2WkRz3GYMA9QFKhUsJA0B/uBJRXvr/vouFQQAa5eE20PeuXUCxKOdd4YEqDyn4QcJfVnRp5VKtIwqOTezXjWRJ1RiXPiz+HEtF7Pzos4xmNk9oBEQJWF/I0yIez98HkAcudO/weKgsJpBzLBF/pS+P6tIXbnefh2B9u/2d64O8+Vk2O67j2dWecFgwlQbiq+g9MTyl2XuxbmEcwjY7uXgYa+pcCJXP7Bnbq8Zm+JQiwZJiBh2QMjMR1uYedFPGKPF2QqDxTvmAcHo+5Z+OE7KSOxWSeSt7PqiRa++I2akPsDOyzUFTdh0tWggZy011353uf0Z8QbnszcqpxwGEWS0M3YjH/OUa2cI3jeFmZjYDoYBm0xgyCJazcMGel5sW/CbWlUO9g3U4A0pbzhlqpvfbQrvwY5ynvhIpSc1Mt3pGgcp3tBSnWPCGh6xomohSRpb3DG1OgxH2kl9/gzT/gMTUL+iStccDvOG1Waw0N7e009khktj4K6pboRALqbir+wQqV7G8v5+Lsm2M7h6pZ+eQ0sFb/zcpdSXn1WKFDvHONwLl++2oNZcokYelW3XHUZlxJr/XdsKXR5omD2tG5BYj8E3K2FBllJ2W+kjIz9RbKK6gRZ9ym2KDpsqa1YVfF7SXKSZ1qiC+xdE/d+wpVPNDNSsxupr5aAFT0g7F8f6KqP3NZEQM3yqmtss6c+v9fnF8GCJ7jISlZBhfLJJWEcY4BwiH8iMHRx1xbzwlCof+G5vo3FsvwMckFc/lv5xZy7Vg5IXxrkJIwWTHtZUvGehGOpTk2V2xc8DHyIxX25G6z5TVr/wzZ1N9wo7LvxTYAUIXnwEKfFUT/qWT1z4os+ug/05SWX7hk+x+eF3uF9H5MnvsvJR6U1Tcyfl1ERGhISfqdbIKT13vltdP4BuuBTBq0QYEfUqQhaysvkL/V2uYXGsrm9vig73aVBuI9L29aF4/UTUh646TIwI9WztToO6CIoI75BAJjTy4wcAXQZoMcgUq10LSCjQcvu+Gh6waXYdCYzKc6q4nPUUpozUtc4RaGCjpZ1eHaLTMRdLsm3C5drQ1bNUo4/Cth0Jj87JT5KwtlUqhl/2Raplaom6VYvk+hqUOaZeqRUTzbqWki3S3QlIEmKkZlEXC55M2Kk6TO1FVkJeuE26mh0oetZKt0E6ASgY4DeJtE9gK4H9DAIEfuzLuWAgNhwXY6i1CiKO6WWVt5S5GeWo8JJiV5sijKcOte+WeynL+NDlhxGBLLoSyct3U+oFAK2zKhkUBzMSZBmcbqTEcH1OEJncZ0CXK24zwPopSaZLv11USDjZ1kuRaDYqBGBWJIhtLRpNQOnz+T6M1w2VBDVo5X4iQpzvMkSIH0my5PqoMAGRYMWy6M9TuuTFGanx2Hw68SoGJJyIq8DA2nm49BnTbDABwoEdBFQ1ssL18VJY7WUAzm9i7VqREoB0GlXl6ZYKXq+RcqZBihvWNOTDPU21Rbq9ASgwoqlKnzWUT67QIJT0cZb71kVAyCAj/0Xlxww1MtSf0ZknC8Af2a5+dFL2ZHdMp+Cx2f9DgCCwcK4G9W6m/FYE5ZSRb8uTjq00QVwH/7YF7xvuhZ5to8aC/s/2UM2pcVHuW5OtLRV5H8S97TK8pgq4gOSh2nsxuVe0MREHMKVuA57xDicbOs9ZEzya7TffDfJaZa7U/JHdEuvn7+j+pCnV3iiJ7hzjbOaJd1z7jovBpRPhO5ye5vgyaD6O6r1Klvrme7z/27ywVjrfeIe9YxX6iX1aVHxBPOvKgp+naZFuU6v1Wy1ZWZ+q7jrzrP5mMU/lU+YnQilfbRU64MsGiFWbc4vnM2fC2VSqBa1HLlcaICzARwq97FURNya1JKKXBo4rfb+17baOFd75s+dIiCVHHf1scSp+3pTJuenNBei4z8TDC0kmtO85HdxqgBcMwglJ3EfVYK3rS1yGkAFP9UU9TX+sSIZ+XUSg35uGY+ZTIvnZe2qRb71bFo8aspDuCx5ciqb1gH9qhi6KfCEcywMC+fy5mNJ1txjWeT0Y4Udbz5WaoV8rLIa97iufqxXj5n6SX3j/RmfxXqN6NepXYdBNKtmEVR1sF9RkpgtZ7Gb5tdqAMp7LARNha28OfLoiswdvXs2QuQ7WE5M5Hkc2YiKnmqjFmwtMiIvx9JHVqhXwDt1y2uxbkvu+ODOu6uLzbJ4z52ydr92rY6kjfY7T0YjrcTM+9QrCsjLWLKfkcziKssWeErGBzVvQ75EhYt1YFgcyCEQTwzvyTgRArymoueEE6UafmvZLNKoqh0WUm0pG0f/JekipBrk0OsC7Wqc9Tvm0Rj90EkrogX8Ij75UCRxbUGflFao0aLh0lC6RbYzlncP2PFghm18eMd+jwYw8Rhr3oArvkTKFueSpiNbrau58lVYpBfaj7w7HwGiR0kF10ZsuNs2rdGQD7w7QhNV9TIiGx2GHiWmqaNkQnEM5L2ax17RgGbReK81tLQ5P9bN8Wd/rCJZ8m18iH6J/07nsDL1x6Xs/zLtL8lksTlcHl8ghMER5BRISioUNQ0tHT0aw8jELJyFVYRIUaLFsIlNs/+tDnGcXOIlSJQkWYpUadK5eXj5ZcqSLUeuBfLkK1CoSLESAUGlQsqUq1CpSrUatRoD4d20W2Zstc5ej/vQUcfCwW93wyVFGv/ccNN1t8MnkyyyySGXPPIpoDCY40447YyTTi0vudNpH/bYs1tH4xJu8CXNeLq9vOzzixY1Fn6CsSQnr/Ra62AjnH9+UVNLI1RxHSq+zgteb+/4+qF7A53di3s4xdc6OcVn/ogjPUnIe49Xj/0Yge/Hj9JvP5907xj4u68agLSM+77pMmWS7fldVa2oWLD7yXjYBBDnmIfoLri5D/wADvhfVGjt0Yqjy2uv5vCoNcKzJjClA+Ljml/1+QXnzQng4B1/KK0hffVTPSY2IL/1nv59tLHpRa3pV6plCVjbAw==) format("woff2");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Math;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Math;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Script;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size1;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size2;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size3;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size4;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Typewriter;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}.katex{font: 1.21em KaTeX_Main,Times New Roman,serif;line-height:1.2;position:relative;text-indent:0;text-rendering:auto}.katex *{-ms-high-contrast-adjust:none!important;border-color:currentColor}.katex .katex-version:after{content:""}.katex .katex-mathml{position:absolute;clip-path:inset(50%);padding:0;border:0;height:1px;width:1px;overflow:hidden}.katex .katex-html>.newline{display:block}.katex .base{position:relative;display:inline-block;white-space:nowrap;width:min-content}.katex .strut{display:inline-block}.katex .textbf{font-weight:700}.katex .textit{font-style:italic}.katex .textrm{font-family:KaTeX_Main}.katex .textsf{font-family:KaTeX_SansSerif}.katex .texttt{font-family:KaTeX_Typewriter}.katex .mathnormal{font-family:KaTeX_Math;font-style:italic}.katex .mathit{font-family:KaTeX_Main;font-style:italic}.katex .mathrm{font-style:normal}.katex .mathbf{font-family:KaTeX_Main;font-weight:700}.katex .boldsymbol{font-family:KaTeX_Math;font-weight:700;font-style:italic}.katex .amsrm,.katex .mathbb,.katex .textbb{font-family:KaTeX_AMS}.katex .mathcal{font-family:KaTeX_Caligraphic}.katex .mathfrak,.katex .textfrak{font-family:KaTeX_Fraktur}.katex .mathboldfrak,.katex .textboldfrak{font-family:KaTeX_Fraktur;font-weight:700}.katex .mathtt{font-family:KaTeX_Typewriter}.katex .mathscr,.katex .textscr{font-family:KaTeX_Script}.katex .mathsf,.katex .textsf{font-family:KaTeX_SansSerif}.katex .mathboldsf,.katex .textboldsf{font-family:KaTeX_SansSerif;font-weight:700}.katex .mathsfit,.katex .mathitsf,.katex .textitsf{font-family:KaTeX_SansSerif;font-style:italic}.katex .mainrm{font-family:KaTeX_Main;font-style:normal}.katex .vlist-t{display:inline-table;table-layout:fixed;border-collapse:collapse}.katex .vlist-r{display:table-row}.katex .vlist{display:table-cell;vertical-align:bottom;position:relative}.katex .vlist>span{display:block;height:0;position:relative}.katex .vlist>span>span{display:inline-block}.katex .vlist>span>.pstrut{overflow:hidden;width:0}.katex .vlist-t2{margin-right:-2px}.katex .vlist-s{display:table-cell;vertical-align:bottom;font-size:1px;width:2px;min-width:2px}.katex .vbox{display:inline-flex;flex-direction:column;align-items:baseline}.katex .hbox{display:inline-flex;flex-direction:row;width:100%}.katex .thinbox{display:inline-flex;flex-direction:row;width:0;max-width:0}.katex .msupsub{text-align:left}.katex .mfrac>span>span{text-align:center}.katex .mfrac .frac-line{display:inline-block;width:100%;border-bottom-style:solid}.katex .mfrac .frac-line,.katex .overline .overline-line,.katex .underline .underline-line,.katex .hline,.katex .hdashline,.katex .rule{min-height:1px}.katex .mspace{display:inline-block}.katex .smash{display:inline;line-height:0}.katex .llap,.katex .rlap,.katex .clap{width:0;position:relative}.katex .llap>.inner,.katex .rlap>.inner,.katex .clap>.inner{position:absolute}.katex .llap>.fix,.katex .rlap>.fix,.katex .clap>.fix{display:inline-block}.katex .llap>.inner{right:0}.katex .rlap>.inner,.katex .clap>.inner{left:0}.katex .clap>.inner>span{margin-left:-50%;margin-right:50%}.katex .rule{display:inline-block;border:solid 0;position:relative}.katex .overline .overline-line,.katex .underline .underline-line,.katex .hline{display:inline-block;width:100%;border-bottom-style:solid}.katex .hdashline{display:inline-block;width:100%;border-bottom-style:dashed}.katex .sqrt>.root{margin-left:.2777777778em;margin-right:-.5555555556em}.katex .sizing.reset-size1.size1,.katex .fontsize-ensurer.reset-size1.size1{font-size:1em}.katex .sizing.reset-size1.size2,.katex .fontsize-ensurer.reset-size1.size2{font-size:1.2em}.katex .sizing.reset-size1.size3,.katex .fontsize-ensurer.reset-size1.size3{font-size:1.4em}.katex .sizing.reset-size1.size4,.katex .fontsize-ensurer.reset-size1.size4{font-size:1.6em}.katex .sizing.reset-size1.size5,.katex .fontsize-ensurer.reset-size1.size5{font-size:1.8em}.katex .sizing.reset-size1.size6,.katex .fontsize-ensurer.reset-size1.size6{font-size:2em}.katex .sizing.reset-size1.size7,.katex .fontsize-ensurer.reset-size1.size7{font-size:2.4em}.katex .sizing.reset-size1.size8,.katex .fontsize-ensurer.reset-size1.size8{font-size:2.88em}.katex .sizing.reset-size1.size9,.katex .fontsize-ensurer.reset-size1.size9{font-size:3.456em}.katex .sizing.reset-size1.size10,.katex .fontsize-ensurer.reset-size1.size10{font-size:4.148em}.katex .sizing.reset-size1.size11,.katex .fontsize-ensurer.reset-size1.size11{font-size:4.976em}.katex .sizing.reset-size2.size1,.katex .fontsize-ensurer.reset-size2.size1{font-size:.8333333333em}.katex .sizing.reset-size2.size2,.katex .fontsize-ensurer.reset-size2.size2{font-size:1em}.katex .sizing.reset-size2.size3,.katex .fontsize-ensurer.reset-size2.size3{font-size:1.1666666667em}.katex .sizing.reset-size2.size4,.katex .fontsize-ensurer.reset-size2.size4{font-size:1.3333333333em}.katex .sizing.reset-size2.size5,.katex .fontsize-ensurer.reset-size2.size5{font-size:1.5em}.katex .sizing.reset-size2.size6,.katex .fontsize-ensurer.reset-size2.size6{font-size:1.6666666667em}.katex .sizing.reset-size2.size7,.katex .fontsize-ensurer.reset-size2.size7{font-size:2em}.katex .sizing.reset-size2.size8,.katex .fontsize-ensurer.reset-size2.size8{font-size:2.4em}.katex .sizing.reset-size2.size9,.katex .fontsize-ensurer.reset-size2.size9{font-size:2.88em}.katex .sizing.reset-size2.size10,.katex .fontsize-ensurer.reset-size2.size10{font-size:3.4566666667em}.katex .sizing.reset-size2.size11,.katex .fontsize-ensurer.reset-size2.size11{font-size:4.1466666667em}.katex .sizing.reset-size3.size1,.katex .fontsize-ensurer.reset-size3.size1{font-size:.7142857143em}.katex .sizing.reset-size3.size2,.katex .fontsize-ensurer.reset-size3.size2{font-size:.8571428571em}.katex .sizing.reset-size3.size3,.katex .fontsize-ensurer.reset-size3.size3{font-size:1em}.katex .sizing.reset-size3.size4,.katex .fontsize-ensurer.reset-size3.size4{font-size:1.1428571429em}.katex .sizing.reset-size3.size5,.katex .fontsize-ensurer.reset-size3.size5{font-size:1.2857142857em}.katex .sizing.reset-size3.size6,.katex .fontsize-ensurer.reset-size3.size6{font-size:1.4285714286em}.katex .sizing.reset-size3.size7,.katex .fontsize-ensurer.reset-size3.size7{font-size:1.7142857143em}.katex .sizing.reset-size3.size8,.katex .fontsize-ensurer.reset-size3.size8{font-size:2.0571428571em}.katex .sizing.reset-size3.size9,.katex .fontsize-ensurer.reset-size3.size9{font-size:2.4685714286em}.katex .sizing.reset-size3.size10,.katex .fontsize-ensurer.reset-size3.size10{font-size:2.9628571429em}.katex .sizing.reset-size3.size11,.katex .fontsize-ensurer.reset-size3.size11{font-size:3.5542857143em}.katex .sizing.reset-size4.size1,.katex .fontsize-ensurer.reset-size4.size1{font-size:.625em}.katex .sizing.reset-size4.size2,.katex .fontsize-ensurer.reset-size4.size2{font-size:.75em}.katex .sizing.reset-size4.size3,.katex .fontsize-ensurer.reset-size4.size3{font-size:.875em}.katex .sizing.reset-size4.size4,.katex .fontsize-ensurer.reset-size4.size4{font-size:1em}.katex .sizing.reset-size4.size5,.katex .fontsize-ensurer.reset-size4.size5{font-size:1.125em}.katex .sizing.reset-size4.size6,.katex .fontsize-ensurer.reset-size4.size6{font-size:1.25em}.katex .sizing.reset-size4.size7,.katex .fontsize-ensurer.reset-size4.size7{font-size:1.5em}.katex .sizing.reset-size4.size8,.katex .fontsize-ensurer.reset-size4.size8{font-size:1.8em}.katex .sizing.reset-size4.size9,.katex .fontsize-ensurer.reset-size4.size9{font-size:2.16em}.katex .sizing.reset-size4.size10,.katex .fontsize-ensurer.reset-size4.size10{font-size:2.5925em}.katex .sizing.reset-size4.size11,.katex .fontsize-ensurer.reset-size4.size11{font-size:3.11em}.katex .sizing.reset-size5.size1,.katex .fontsize-ensurer.reset-size5.size1{font-size:.5555555556em}.katex .sizing.reset-size5.size2,.katex .fontsize-ensurer.reset-size5.size2{font-size:.6666666667em}.katex .sizing.reset-size5.size3,.katex .fontsize-ensurer.reset-size5.size3{font-size:.7777777778em}.katex .sizing.reset-size5.size4,.katex .fontsize-ensurer.reset-size5.size4{font-size:.8888888889em}.katex .sizing.reset-size5.size5,.katex .fontsize-ensurer.reset-size5.size5{font-size:1em}.katex .sizing.reset-size5.size6,.katex .fontsize-ensurer.reset-size5.size6{font-size:1.1111111111em}.katex .sizing.reset-size5.size7,.katex .fontsize-ensurer.reset-size5.size7{font-size:1.3333333333em}.katex .sizing.reset-size5.size8,.katex .fontsize-ensurer.reset-size5.size8{font-size:1.6em}.katex .sizing.reset-size5.size9,.katex .fontsize-ensurer.reset-size5.size9{font-size:1.92em}.katex .sizing.reset-size5.size10,.katex .fontsize-ensurer.reset-size5.size10{font-size:2.3044444444em}.katex .sizing.reset-size5.size11,.katex .fontsize-ensurer.reset-size5.size11{font-size:2.7644444444em}.katex .sizing.reset-size6.size1,.katex .fontsize-ensurer.reset-size6.size1{font-size:.5em}.katex .sizing.reset-size6.size2,.katex .fontsize-ensurer.reset-size6.size2{font-size:.6em}.katex .sizing.reset-size6.size3,.katex .fontsize-ensurer.reset-size6.size3{font-size:.7em}.katex .sizing.reset-size6.size4,.katex .fontsize-ensurer.reset-size6.size4{font-size:.8em}.katex .sizing.reset-size6.size5,.katex .fontsize-ensurer.reset-size6.size5{font-size:.9em}.katex .sizing.reset-size6.size6,.katex .fontsize-ensurer.reset-size6.size6{font-size:1em}.katex .sizing.reset-size6.size7,.katex .fontsize-ensurer.reset-size6.size7{font-size:1.2em}.katex .sizing.reset-size6.size8,.katex .fontsize-ensurer.reset-size6.size8{font-size:1.44em}.katex .sizing.reset-size6.size9,.katex .fontsize-ensurer.reset-size6.size9{font-size:1.728em}.katex .sizing.reset-size6.size10,.katex .fontsize-ensurer.reset-size6.size10{font-size:2.074em}.katex .sizing.reset-size6.size11,.katex .fontsize-ensurer.reset-size6.size11{font-size:2.488em}.katex .sizing.reset-size7.size1,.katex .fontsize-ensurer.reset-size7.size1{font-size:.4166666667em}.katex .sizing.reset-size7.size2,.katex .fontsize-ensurer.reset-size7.size2{font-size:.5em}.katex .sizing.reset-size7.size3,.katex .fontsize-ensurer.reset-size7.size3{font-size:.5833333333em}.katex .sizing.reset-size7.size4,.katex .fontsize-ensurer.reset-size7.size4{font-size:.6666666667em}.katex .sizing.reset-size7.size5,.katex .fontsize-ensurer.reset-size7.size5{font-size:.75em}.katex .sizing.reset-size7.size6,.katex .fontsize-ensurer.reset-size7.size6{font-size:.8333333333em}.katex .sizing.reset-size7.size7,.katex .fontsize-ensurer.reset-size7.size7{font-size:1em}.katex .sizing.reset-size7.size8,.katex .fontsize-ensurer.reset-size7.size8{font-size:1.2em}.katex .sizing.reset-size7.size9,.katex .fontsize-ensurer.reset-size7.size9{font-size:1.44em}.katex .sizing.reset-size7.size10,.katex .fontsize-ensurer.reset-size7.size10{font-size:1.7283333333em}.katex .sizing.reset-size7.size11,.katex .fontsize-ensurer.reset-size7.size11{font-size:2.0733333333em}.katex .sizing.reset-size8.size1,.katex .fontsize-ensurer.reset-size8.size1{font-size:.3472222222em}.katex .sizing.reset-size8.size2,.katex .fontsize-ensurer.reset-size8.size2{font-size:.4166666667em}.katex .sizing.reset-size8.size3,.katex .fontsize-ensurer.reset-size8.size3{font-size:.4861111111em}.katex .sizing.reset-size8.size4,.katex .fontsize-ensurer.reset-size8.size4{font-size:.5555555556em}.katex .sizing.reset-size8.size5,.katex .fontsize-ensurer.reset-size8.size5{font-size:.625em}.katex .sizing.reset-size8.size6,.katex .fontsize-ensurer.reset-size8.size6{font-size:.6944444444em}.katex .sizing.reset-size8.size7,.katex .fontsize-ensurer.reset-size8.size7{font-size:.8333333333em}.katex .sizing.reset-size8.size8,.katex .fontsize-ensurer.reset-size8.size8{font-size:1em}.katex .sizing.reset-size8.size9,.katex .fontsize-ensurer.reset-size8.size9{font-size:1.2em}.katex .sizing.reset-size8.size10,.katex .fontsize-ensurer.reset-size8.size10{font-size:1.4402777778em}.katex .sizing.reset-size8.size11,.katex .fontsize-ensurer.reset-size8.size11{font-size:1.7277777778em}.katex .sizing.reset-size9.size1,.katex .fontsize-ensurer.reset-size9.size1{font-size:.2893518519em}.katex .sizing.reset-size9.size2,.katex .fontsize-ensurer.reset-size9.size2{font-size:.3472222222em}.katex .sizing.reset-size9.size3,.katex .fontsize-ensurer.reset-size9.size3{font-size:.4050925926em}.katex .sizing.reset-size9.size4,.katex .fontsize-ensurer.reset-size9.size4{font-size:.462962963em}.katex .sizing.reset-size9.size5,.katex .fontsize-ensurer.reset-size9.size5{font-size:.5208333333em}.katex .sizing.reset-size9.size6,.katex .fontsize-ensurer.reset-size9.size6{font-size:.5787037037em}.katex .sizing.reset-size9.size7,.katex .fontsize-ensurer.reset-size9.size7{font-size:.6944444444em}.katex .sizing.reset-size9.size8,.katex .fontsize-ensurer.reset-size9.size8{font-size:.8333333333em}.katex .sizing.reset-size9.size9,.katex .fontsize-ensurer.reset-size9.size9{font-size:1em}.katex .sizing.reset-size9.size10,.katex .fontsize-ensurer.reset-size9.size10{font-size:1.2002314815em}.katex .sizing.reset-size9.size11,.katex .fontsize-ensurer.reset-size9.size11{font-size:1.4398148148em}.katex .sizing.reset-size10.size1,.katex .fontsize-ensurer.reset-size10.size1{font-size:.2410800386em}.katex .sizing.reset-size10.size2,.katex .fontsize-ensurer.reset-size10.size2{font-size:.2892960463em}.katex .sizing.reset-size10.size3,.katex .fontsize-ensurer.reset-size10.size3{font-size:.337512054em}.katex .sizing.reset-size10.size4,.katex .fontsize-ensurer.reset-size10.size4{font-size:.3857280617em}.katex .sizing.reset-size10.size5,.katex .fontsize-ensurer.reset-size10.size5{font-size:.4339440694em}.katex .sizing.reset-size10.size6,.katex .fontsize-ensurer.reset-size10.size6{font-size:.4821600771em}.katex .sizing.reset-size10.size7,.katex .fontsize-ensurer.reset-size10.size7{font-size:.5785920926em}.katex .sizing.reset-size10.size8,.katex .fontsize-ensurer.reset-size10.size8{font-size:.6943105111em}.katex .sizing.reset-size10.size9,.katex .fontsize-ensurer.reset-size10.size9{font-size:.8331726133em}.katex .sizing.reset-size10.size10,.katex .fontsize-ensurer.reset-size10.size10{font-size:1em}.katex .sizing.reset-size10.size11,.katex .fontsize-ensurer.reset-size10.size11{font-size:1.1996142719em}.katex .sizing.reset-size11.size1,.katex .fontsize-ensurer.reset-size11.size1{font-size:.2009646302em}.katex .sizing.reset-size11.size2,.katex .fontsize-ensurer.reset-size11.size2{font-size:.2411575563em}.katex .sizing.reset-size11.size3,.katex .fontsize-ensurer.reset-size11.size3{font-size:.2813504823em}.katex .sizing.reset-size11.size4,.katex .fontsize-ensurer.reset-size11.size4{font-size:.3215434084em}.katex .sizing.reset-size11.size5,.katex .fontsize-ensurer.reset-size11.size5{font-size:.3617363344em}.katex .sizing.reset-size11.size6,.katex .fontsize-ensurer.reset-size11.size6{font-size:.4019292605em}.katex .sizing.reset-size11.size7,.katex .fontsize-ensurer.reset-size11.size7{font-size:.4823151125em}.katex .sizing.reset-size11.size8,.katex .fontsize-ensurer.reset-size11.size8{font-size:.578778135em}.katex .sizing.reset-size11.size9,.katex .fontsize-ensurer.reset-size11.size9{font-size:.6945337621em}.katex .sizing.reset-size11.size10,.katex .fontsize-ensurer.reset-size11.size10{font-size:.8336012862em}.katex .sizing.reset-size11.size11,.katex .fontsize-ensurer.reset-size11.size11{font-size:1em}.katex .delimsizing.size1{font-family:KaTeX_Size1}.katex .delimsizing.size2{font-family:KaTeX_Size2}.katex .delimsizing.size3{font-family:KaTeX_Size3}.katex .delimsizing.size4{font-family:KaTeX_Size4}.katex .delimsizing.mult .delim-size1>span{font-family:KaTeX_Size1}.katex .delimsizing.mult .delim-size4>span{font-family:KaTeX_Size4}.katex .nulldelimiter{display:inline-block;width:.12em}.katex .delimcenter,.katex .op-symbol{position:relative}.katex .op-symbol.small-op{font-family:KaTeX_Size1}.katex .op-symbol.large-op{font-family:KaTeX_Size2}.katex .op-limits>.vlist-t{text-align:center}.katex .accent>.vlist-t{text-align:center}.katex .accent .accent-body{position:relative}.katex .accent .accent-body:not(.accent-full){width:0}.katex .overlay{display:block}.katex .mtable .vertical-separator{display:inline-block;min-width:1px}.katex .mtable .arraycolsep{display:inline-block}.katex .mtable .col-align-c>.vlist-t{text-align:center}.katex .mtable .col-align-l>.vlist-t{text-align:left}.katex .mtable .col-align-r>.vlist-t{text-align:right}.katex .svg-align{text-align:left}.katex svg{display:block;position:absolute;width:100%;height:inherit;fill:currentColor;stroke:currentColor}.katex svg path{stroke:none}.katex svg{fill-rule:nonzero;fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1}.katex img{border-style:none;min-width:0;min-height:0;max-width:none;max-height:none}.katex .stretchy{width:100%;display:block;position:relative;overflow:hidden}.katex .stretchy:before,.katex .stretchy:after{content:""}.katex .hide-tail{width:100%;position:relative;overflow:hidden}.katex .halfarrow-left{position:absolute;left:0;width:50.2%;overflow:hidden}.katex .halfarrow-right{position:absolute;right:0;width:50.2%;overflow:hidden}.katex .brace-left{position:absolute;left:0;width:25.1%;overflow:hidden}.katex .brace-center{position:absolute;left:25%;width:50%;overflow:hidden}.katex .brace-right{position:absolute;right:0;width:25.1%;overflow:hidden}.katex .x-arrow-pad{padding:0 .5em}.katex .cd-arrow-pad{padding:0 .55556em 0 .27778em}.katex .x-arrow,.katex .mover,.katex .munder{text-align:center}.katex .boxpad{padding:0 .3em}.katex .fbox,.katex .fcolorbox{box-sizing:border-box;border:.04em solid}.katex .cancel-pad{padding:0 .2em}.katex .cancel-lap{margin-left:-.2em;margin-right:-.2em}.katex .sout{border-bottom-style:solid;border-bottom-width:.08em}.katex .angl{box-sizing:border-box;border-top:.049em solid;border-right:.049em solid;margin-right:.03889em}.katex .anglpad{padding:0 .03889em}.katex .eqn-num:before{counter-increment:katexEqnNo;content:"(" counter(katexEqnNo) ")"}.katex .mml-eqn-num:before{counter-increment:mmlEqnNo;content:"(" counter(mmlEqnNo) ")"}.katex .mtr-glue{width:50%}.katex .cd-vert-arrow{display:inline-block;position:relative}.katex .cd-label-left{display:inline-block;position:absolute;right:calc(50% + .3em);text-align:left}.katex .cd-label-right{display:inline-block;position:absolute;left:calc(50% + .3em);text-align:right}.katex-display{display:block;margin:1em 0;text-align:center}.katex-display>.katex{display:block;text-align:center;white-space:nowrap}.katex-display>.katex>.katex-html{display:block;position:relative}.katex-display>.katex>.katex-html>.tag{position:absolute;right:0}.katex-display.leqno>.katex>.katex-html>.tag{left:0;right:auto}.katex-display.fleqn>.katex{text-align:left;padding-left:2em}body{counter-reset:katexEqnNo mmlEqnNo}.markdown-block--unstable.svelte-wjdxdt{display:contents}.streaming-code-block.svelte-wjdxdt .streaming-code-pre:where(.svelte-wjdxdt){background:transparent;padding:.5rem;margin:0;overflow-x:visible;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt p{margin-block:1rem;line-height:1.75}.markdown-content.svelte-wjdxdt .markdown-block:first-child p:first-child{margin-block-start:0}.markdown-content.svelte-wjdxdt .markdown-block:last-child p:last-child{margin-block-end:0}.markdown-content.svelte-wjdxdt :is(h1,h2,h3,h4,h5,h6):first-child{margin-top:.5rem}.markdown-content.svelte-wjdxdt h1{font-size:1.875rem;font-weight:700;line-height:1.2;margin:1.5rem 0 .75rem}.markdown-content.svelte-wjdxdt h2{font-size:1.5rem;font-weight:600;line-height:1.3;margin:1.25rem 0 .5rem}.markdown-content.svelte-wjdxdt h3{font-size:1.25rem;font-weight:600;margin:1.5rem 0 .5rem;line-height:1.4}.markdown-content.svelte-wjdxdt h4{font-size:1.125rem;font-weight:600;margin:.75rem 0 .25rem}.markdown-content.svelte-wjdxdt h5{font-size:1rem;font-weight:600;margin:.5rem 0 .25rem}.markdown-content.svelte-wjdxdt h6{font-size:.875rem;font-weight:600;margin:.5rem 0 .25rem}.markdown-content.svelte-wjdxdt strong{font-weight:600}.markdown-content.svelte-wjdxdt em{font-style:italic}.markdown-content.svelte-wjdxdt del{text-decoration:line-through;opacity:.7}.markdown-content.svelte-wjdxdt code:not(pre code){background:var(--muted);color:var(--muted-foreground);padding:.125rem .375rem;border-radius:.375rem;font-size:.875rem}.markdown-content.svelte-wjdxdt pre{display:inline;margin:0!important;overflow:hidden!important;background:var(--muted);overflow-x:auto;border-radius:1rem;border:none;line-height:1!important}.markdown-content.svelte-wjdxdt pre code{padding:0!important;display:inline!important}.markdown-content.svelte-wjdxdt code{background:transparent;color:var(--code-foreground)}.markdown-content.svelte-wjdxdt a{color:var(--primary);text-decoration:underline;text-underline-offset:2px;transition:color .2s ease;overflow-wrap:anywhere;word-break:break-all}.markdown-content.svelte-wjdxdt a:hover{color:var(--primary)}.markdown-content.svelte-wjdxdt ul{list-style-type:disc;margin-inline-start:1.5rem;margin-bottom:1rem}.markdown-content.svelte-wjdxdt ol{list-style-type:decimal;margin-inline-start:1.5rem;margin-bottom:1rem}.markdown-content.svelte-wjdxdt li{margin-bottom:.25rem;padding-inline-start:.5rem}.markdown-content.svelte-wjdxdt li::marker{color:var(--muted-foreground)}.markdown-content.svelte-wjdxdt ul ul{list-style-type:circle;margin-top:.25rem;margin-bottom:.25rem}.markdown-content.svelte-wjdxdt ol ol{list-style-type:lower-alpha;margin-top:.25rem;margin-bottom:.25rem}.markdown-content.svelte-wjdxdt .task-list-item{list-style:none;margin-inline-start:0;padding-inline-start:0}.markdown-content.svelte-wjdxdt .task-list-item-checkbox{margin-right:.5rem;margin-top:.125rem}.markdown-content.svelte-wjdxdt blockquote{border-left:4px solid var(--border);padding:.5rem 1rem;margin:1.5rem 0;font-style:italic;color:var(--muted-foreground);background:var(--muted);border-radius:0 .375rem .375rem 0}.markdown-content.svelte-wjdxdt table{width:100%;margin:1.5rem 0;border-collapse:collapse;border:1px solid var(--border);border-radius:.375rem;overflow:hidden}.markdown-content.svelte-wjdxdt th{background:hsl(var(--muted) / .3);border:1px solid var(--border);padding:.5rem .75rem;text-align:left;font-weight:600}.markdown-content.svelte-wjdxdt td{border:1px solid var(--border);padding:.5rem .75rem}.markdown-content.svelte-wjdxdt tr:nth-child(2n){background:hsl(var(--muted) / .1)}div.markdown-user-content.svelte-wjdxdt table,div.markdown-user-content.svelte-wjdxdt th,div.markdown-user-content.svelte-wjdxdt td,div.markdown-user-content.svelte-wjdxdt .table-wrapper{border-color:currentColor}.markdown-content.svelte-wjdxdt hr{border:none;border-top:1px solid var(--border);margin:1.5rem 0}.markdown-content.svelte-wjdxdt img{border-radius:.5rem;box-shadow:0 1px 3px #0000001a,0 1px 2px -1px #0000001a;margin:1.5rem 0;max-width:100%;height:auto}.markdown-content.svelte-wjdxdt .code-block-wrapper{border-radius:.75rem;overflow:hidden;border:1px solid color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d;min-height:var(--min-message-height);max-height:var(--max-message-height)}.markdown-content.svelte-wjdxdt .markdown-block:where(.svelte-wjdxdt):not(:first-child) .code-block-wrapper{margin-top:1rem}.markdown-content.svelte-wjdxdt .markdown-block:where(.svelte-wjdxdt):not(:last-child) .code-block-wrapper{margin-bottom:1rem}.markdown-content.svelte-wjdxdt.dark .code-block-wrapper{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.markdown-content.svelte-wjdxdt .code-block-scroll-container,.streaming-code-scroll-container.svelte-wjdxdt{min-height:var(--min-message-height);max-height:var(--max-message-height);overflow-y:auto;overflow-x:auto;padding:3rem 1rem 1rem;line-height:1.3}.full-height-code-blocks.svelte-wjdxdt .code-block-wrapper{max-height:none}.full-height-code-blocks.svelte-wjdxdt .code-block-scroll-container,.full-height-code-blocks.svelte-wjdxdt .streaming-code-scroll-container:where(.svelte-wjdxdt){max-height:none;overflow-y:visible}.markdown-content.svelte-wjdxdt .code-block-header{display:flex;justify-content:space-between;align-items:center;padding:.5rem 1rem 0;font-size:.875rem;position:absolute;top:0;left:0;right:0}.markdown-content.svelte-wjdxdt .code-language{color:var(--color-foreground);font-weight:500;font-family:ui-monospace,SFMono-Regular,SF Mono,Monaco,Cascadia Code,Roboto Mono,Consolas,Liberation Mono,Menlo,monospace;text-transform:uppercase;font-size:.75rem;letter-spacing:.05em}.markdown-content.svelte-wjdxdt .code-block-actions{display:flex;align-items:center;gap:.5rem}.markdown-content.svelte-wjdxdt .copy-code-btn,.markdown-content.svelte-wjdxdt .preview-code-btn,.markdown-content.svelte-wjdxdt .toggle-source-btn{display:flex;align-items:center;justify-content:center;padding:0;background:transparent;color:var(--code-foreground);cursor:pointer;transition:all .2s ease}.markdown-content.svelte-wjdxdt .copy-code-btn:hover,.markdown-content.svelte-wjdxdt .preview-code-btn:hover,.markdown-content.svelte-wjdxdt .toggle-source-btn:hover{transform:scale(1.05)}.markdown-content.svelte-wjdxdt .copy-code-btn:active,.markdown-content.svelte-wjdxdt .preview-code-btn:active,.markdown-content.svelte-wjdxdt .toggle-source-btn:active{transform:scale(.95)}.markdown-content.svelte-wjdxdt .toggle-source-btn[aria-pressed=true]{color:var(--primary)}.markdown-content.svelte-wjdxdt .code-block-wrapper pre{background:transparent;margin:0;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt .mention{color:hsl(var(--primary));font-weight:500;text-decoration:none}.markdown-content.svelte-wjdxdt .mention:hover{text-decoration:underline}.markdown-content.svelte-wjdxdt .hashtag{color:hsl(var(--primary));font-weight:500;text-decoration:none}.markdown-content.svelte-wjdxdt .hashtag:hover{text-decoration:underline}.markdown-content.svelte-wjdxdt table{transition:all .2s ease}.markdown-content.svelte-wjdxdt table:hover{box-shadow:0 4px 6px -1px #0000001a,0 2px 4px -2px #0000001a}.markdown-content.svelte-wjdxdt th:hover,.markdown-content.svelte-wjdxdt td:hover{background:var(--muted)}.markdown-user-content.svelte-wjdxdt a,.markdown-user-content.svelte-wjdxdt a:hover{color:inherit}.markdown-user-content.svelte-wjdxdt table:hover{box-shadow:none}.markdown-user-content.svelte-wjdxdt th:hover,.markdown-user-content.svelte-wjdxdt td:hover{background:inherit}.markdown-content.svelte-wjdxdt blockquote{transition:all .2s ease;position:relative}.markdown-content.svelte-wjdxdt blockquote:hover{border-left-width:6px;background:var(--muted);transform:translate(2px)}.markdown-content.svelte-wjdxdt blockquote:before{content:'"';position:absolute;top:-.5rem;left:.5rem;font-size:3rem;color:var(--muted-foreground);font-family:serif;line-height:1}.markdown-content.svelte-wjdxdt img{transition:all .3s ease;cursor:pointer}.markdown-content.svelte-wjdxdt img:hover{transform:scale(1.02);box-shadow:0 10px 15px -3px #0000001a,0 4px 6px -4px #0000001a}.markdown-content.svelte-wjdxdt .image-zoom-overlay{position:fixed;inset:0;background:#000c;display:flex;align-items:center;justify-content:center;z-index:1000;cursor:pointer}.markdown-content.svelte-wjdxdt .image-zoom-overlay img{max-width:90vw;max-height:90vh;border-radius:.5rem;box-shadow:0 25px 50px -12px #00000040}.markdown-content.svelte-wjdxdt hr{border:none;height:2px;background:linear-gradient(to right,transparent,var(--border),transparent);margin:2rem 0;position:relative}.markdown-content.svelte-wjdxdt hr:after{content:"";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:1rem;height:1rem;background:var(--border);border-radius:50%}.markdown-content.svelte-wjdxdt .table-wrapper{overflow-x:auto;margin:1.5rem 0;border-radius:.5rem;border:1px solid var(--border)}.markdown-content.svelte-wjdxdt .table-wrapper table{margin:0;border:none}@media(max-width:640px){.markdown-content.svelte-wjdxdt h1{font-size:1.5rem}.markdown-content.svelte-wjdxdt h2{font-size:1.25rem}.markdown-content.svelte-wjdxdt h3{font-size:1.125rem}.markdown-content.svelte-wjdxdt table{font-size:.875rem}.markdown-content.svelte-wjdxdt th,.markdown-content.svelte-wjdxdt td{padding:.375rem .5rem}.markdown-content.svelte-wjdxdt .table-wrapper{margin:.5rem -1rem;border-radius:0;border-left:none;border-right:none}}@media(prefers-color-scheme:dark){.markdown-content.svelte-wjdxdt blockquote:hover{background:var(--muted)}}.markdown-content.svelte-wjdxdt .image-load-error{display:flex;align-items:center;justify-content:center;margin:1.5rem 0;padding:1.5rem;border-radius:.5rem;background:var(--muted);border:1px dashed var(--border)}.markdown-content.svelte-wjdxdt .image-error-content{display:flex;flex-direction:column;align-items:center;gap:.75rem;color:var(--muted-foreground);text-align:center}.markdown-content.svelte-wjdxdt .image-error-content svg{opacity:.5}.markdown-content.svelte-wjdxdt .image-error-text{font-size:.875rem}.markdown-content.svelte-wjdxdt .image-error-link{display:inline-flex;align-items:center;gap:.375rem;padding:.5rem 1rem;font-size:.875rem;font-weight:500;color:var(--primary);background:var(--background);border:1px solid var(--border);border-radius:.375rem;text-decoration:none;transition:all .2s ease}.markdown-content.svelte-wjdxdt .image-error-link:hover{background:var(--muted);border-color:var(--primary)}.markdown-content.svelte-wjdxdt pre.mermaid,.markdown-content.svelte-wjdxdt .svg-block{background:transparent;border:none;padding:0;text-align:center;font-family:inherit;cursor:pointer;transition:opacity .15s ease;position:relative}.markdown-content.svelte-wjdxdt .svg-block{width:100%}.markdown-content.svelte-wjdxdt pre.mermaid:not([data-mermaid-rendered]),.markdown-content.svelte-wjdxdt pre.mermaid[data-mermaid-rendered]:not(:has(svg)){display:none}.markdown-content.svelte-wjdxdt pre.svg-block:not([data-svg-rendered]){display:none}.markdown-content.svelte-wjdxdt pre.mermaid:hover,.markdown-content.svelte-wjdxdt .svg-block:hover{opacity:.85}.markdown-content.svelte-wjdxdt pre.mermaid svg{max-width:90%;margin:0 auto;height:auto;display:block;padding:3rem 1rem}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper,.markdown-content.svelte-wjdxdt .svg-block-wrapper{margin:1.5rem 0;border-radius:.75rem;overflow:hidden;border:1px solid color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d;position:relative;min-height:var(--min-message-height);max-height:var(--max-message-height)}.markdown-content.svelte-wjdxdt.dark .mermaid-block-wrapper,.markdown-content.svelte-wjdxdt.dark .svg-block-wrapper{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.markdown-content.svelte-wjdxdt .mermaid-scroll-container,.markdown-content.svelte-wjdxdt .svg-scroll-container{min-height:350px;max-height:var(--max-message-height);overflow-y:auto;overflow-x:auto;display:flex;align-items:safe center;justify-content:safe center;padding:3rem 1rem 1rem}.full-height-code-blocks.svelte-wjdxdt .mermaid-block-wrapper,.full-height-code-blocks.svelte-wjdxdt .svg-block-wrapper{max-height:none}.full-height-code-blocks.svelte-wjdxdt .mermaid-scroll-container,.full-height-code-blocks.svelte-wjdxdt .svg-scroll-container{max-height:none;overflow-y:visible}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper .code-block-header,.markdown-content.svelte-wjdxdt .svg-block-wrapper .code-block-header{display:flex;justify-content:space-between;align-items:center;padding:.5rem 1rem 0;font-size:.875rem;position:absolute;top:0;left:0;right:0;z-index:2}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper .code-block-actions,.markdown-content.svelte-wjdxdt .svg-block-wrapper .code-block-actions{display:flex;align-items:center;gap:.5rem}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper pre.mermaid,.markdown-content.svelte-wjdxdt .svg-block-wrapper pre.svg-block{background:transparent;border:none;padding:0;margin:0;text-align:center}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper pre.mermaid svg{width:unset!important;height:auto;display:block;padding:3rem 1rem}.markdown-content.svelte-wjdxdt .diagram-source{display:none;text-align:left}.markdown-content.svelte-wjdxdt .diagram-source pre{background:transparent;margin:0;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt [data-view-mode=source] .mermaid-scroll-container,.markdown-content.svelte-wjdxdt [data-view-mode=source] .svg-scroll-container{display:none}.markdown-content.svelte-wjdxdt [data-view-mode=source] .diagram-source{display:block}.mermaid-streaming-block.svelte-wjdxdt{min-height:300px;display:flex;align-items:center;justify-content:center}.mermaid-loading-placeholder.svelte-wjdxdt{display:flex;align-items:center;justify-content:center;padding:3rem;color:var(--muted-foreground)}.mermaid-loading-text.svelte-wjdxdt{font-size:.875rem;font-style:italic}.code-preview-wrapper.svelte-hp0zxr{overscroll-behavior:contain}.code-preview-wrapper.svelte-hp0zxr pre:where(.svelte-hp0zxr){background:transparent;padding:0}.code-preview-wrapper.svelte-hp0zxr code:where(.svelte-hp0zxr){background:transparent;display:block;padding:.5rem}.dark .code-preview-wrapper.svelte-hp0zxr{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.code-preview-overlay{position:fixed;inset:0;background-color:transparent;z-index:100000}.code-preview-content{position:fixed;inset:0;top:0!important;left:0!important;width:100dvw;height:100dvh;margin:0;padding:0;border:none;border-radius:0;background-color:transparent;box-shadow:none;display:block;overflow:hidden;transform:none!important;z-index:100001}.code-preview-iframe{display:block;width:100dvw;height:100dvh;border:0}.code-preview-close{position:absolute;z-index:100002}@media(max-width:768px){aside.svelte-1adgg5m{--size: 1.125rem}}@media(max-width:768px){aside.svelte-1adgg5m:not(.is-expanded){pointer-events:none}aside.is-expanded.svelte-1adgg5m:before{content:"";position:fixed;inset:-.5rem -.5rem -.25rem;z-index:-1;background:var(--background);-webkit-backdrop-filter:blur(1rem);backdrop-filter:blur(1rem);pointer-events:none}}button.svelte-19ekn76 [data-slot=dropdown-menu-trigger]:not([data-state=open]){opacity:0}button.svelte-19ekn76:is(:where(.svelte-19ekn76):hover) [data-slot=dropdown-menu-trigger],button.svelte-19ekn76:focus-within [data-slot=dropdown-menu-trigger]{opacity:1}@media(max-width:768px){button.svelte-19ekn76 [data-slot=dropdown-menu-trigger]{opacity:1!important}}button.svelte-19ekn76.is-selection-mode [data-slot=dropdown-menu-trigger]{display:none!important}button.svelte-19ekn76 .stop-button:where(.svelte-19ekn76) .stop-icon{display:none}button.svelte-19ekn76 .stop-button:where(.svelte-19ekn76) .loading-icon{display:block}button.svelte-19ekn76:is(:where(.svelte-19ekn76):hover) .stop-button:where(.svelte-19ekn76) .stop-icon{display:block}button.svelte-19ekn76:is(:where(.svelte-19ekn76):hover) .stop-button:where(.svelte-19ekn76) .loading-icon{display:none} diff --git a/tools/ui/.svelte-kit/output/client/_app/immutable/bundle.Yxmpoeis.js b/tools/ui/.svelte-kit/output/client/_app/immutable/bundle.Yxmpoeis.js new file mode 100644 index 0000000000000000000000000000000000000000..8b57ab66e077e63d537a34dcd16262090593666e --- /dev/null +++ b/tools/ui/.svelte-kit/output/client/_app/immutable/bundle.Yxmpoeis.js @@ -0,0 +1,3806 @@ +var w0e=t=>{throw TypeError(t)};var Kq=(t,e,r)=>e.has(t)||w0e("Cannot "+r);var Ps=(t,e,r)=>(Kq(t,e,"read from private field"),r?r.call(t):e.get(t)),zp=(t,e,r)=>e.has(t)?w0e("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,r),Zu=(t,e,r,n)=>(Kq(t,e,"write to private field"),n?n.call(t,r):e.set(t,r),r),qp=(t,e,r)=>(Kq(t,e,"access private method"),r);var x0e=(t,e,r,n)=>({set _(i){Zu(t,e,i,r)},get _(){return Ps(t,e,n)}});var ZB=Array.isArray,tdt=Array.prototype.indexOf,aL=Array.prototype.includes,JB=Array.from,ose=Object.defineProperty,O_=Object.getOwnPropertyDescriptor,H7e=Object.getOwnPropertyDescriptors,V7e=Object.prototype,rdt=Array.prototype,eU=Object.getPrototypeOf,A0e=Object.isExtensible;function wE(t){return typeof t=="function"}const Vt=()=>{};function ndt(t){return t()}function GZ(t){for(var e=0;e{t=n,e=i});return{promise:r,resolve:t,reject:e}}function W7e(t,e,r=!1){return t===void 0?r?e():e:t}function lse(t,e){if(Array.isArray(t))return t;if(!(Symbol.iterator in t))return Array.from(t);const r=[];for(const n of t)if(r.push(n),r.length===e)break;return r}const wc=2,i2=4,p8=8,cse=1<<24,sf=16,Tp=32,M0=64,zZ=128,hf=512,Tl=1024,mc=2048,Hg=4096,Lu=8192,ff=16384,Sv=32768,qZ=1<<25,Vg=65536,sL=1<<17,K7e=1<<18,H2=1<<19,j7e=1<<20,Cg=1<<25,a2=65536,oL=1<<21,LT=1<<22,I_=1<<23,Mg=Symbol("$state"),use=Symbol("legacy props"),idt=Symbol(""),X7e=Symbol("attributes"),HZ=Symbol("class"),VZ=Symbol("style"),YZ=Symbol("text"),C9=Symbol("form reset"),tU=new class extends Error{name="StaleReactionError";message="The reaction that called `getAbortSignal()` was re-run or destroyed"},g8=!!globalThis.document?.contentType&&globalThis.document.contentType.includes("xml"),adt=1,m8=3,Ev=8;function dse(t){throw new Error("https://svelte.dev/e/lifecycle_outside_component")}function sdt(){throw new Error("https://svelte.dev/e/async_derived_orphan")}function odt(t,e,r){throw new Error("https://svelte.dev/e/each_key_duplicate")}function ldt(t){throw new Error("https://svelte.dev/e/effect_in_teardown")}function cdt(){throw new Error("https://svelte.dev/e/effect_in_unowned_derived")}function udt(t){throw new Error("https://svelte.dev/e/effect_orphan")}function ddt(){throw new Error("https://svelte.dev/e/effect_update_depth_exceeded")}function hdt(){throw new Error("https://svelte.dev/e/hydration_failed")}function fdt(t){throw new Error("https://svelte.dev/e/props_invalid_value")}function pdt(){throw new Error("https://svelte.dev/e/state_descriptors_fixed")}function gdt(){throw new Error("https://svelte.dev/e/state_prototype_fixed")}function mdt(){throw new Error("https://svelte.dev/e/state_unsafe_mutation")}function _dt(){throw new Error("https://svelte.dev/e/svelte_boundary_reset_onerror")}const vdt=1,ydt=2,Q7e=4,bdt=8,Sdt=16,Edt=1,Tdt=2,Cdt=4,wdt=8,xdt=16,Adt=1,Rdt=2,Ndt=4,Odt=1,Idt=2,hse="[",fse="[!",R0e="[?",pse="]",s2={},Vo=Symbol("uninitialized"),Z7e="http://www.w3.org/1999/xhtml",J7e="http://www.w3.org/2000/svg",kdt="http://www.w3.org/1998/Math/MathML",e8e="@attach";function Ddt(){console.warn("https://svelte.dev/e/derived_inert")}function _8(t){console.warn("https://svelte.dev/e/hydration_mismatch")}function Mdt(){console.warn("https://svelte.dev/e/select_multiple_invalid_value")}function Ldt(){console.warn("https://svelte.dev/e/svelte_boundary_reset_noop")}let Bn=!1;function _c(t){Bn=t}let wi;function oo(t){if(t===null)throw _8(),s2;return wi=t}function Cp(){return oo(dh(wi))}function Z(t){if(Bn){if(dh(wi)!==null)throw _8(),s2;wi=t}}function Ct(t=1){if(Bn){for(var e=t,r=wi;e--;)r=dh(r);wi=r}}function TR(t=!0){for(var e=0,r=wi;;){if(r.nodeType===Ev){var n=r.data;if(n===pse){if(e===0)return r;e-=1}else(n===hse||n===fse||n[0]==="["&&!isNaN(Number(n.slice(1))))&&(e+=1)}var i=dh(r);t&&r.remove(),r=i}}function gse(t){if(!t||t.nodeType!==Ev)throw _8(),s2;return t.data}function t8e(t){return t===this.v}function r8e(t,e){return t!=t?e==e:t!==e||t!==null&&typeof t=="object"||typeof t=="function"}function n8e(t){return!r8e(t,this.v)}let a4=!1;function Pdt(){a4=!0}const Fdt=[];function k_(t,e=!1,r=!1){return ED(t,new Map,"",Fdt,null,r)}function ED(t,e,r,n,i=null,a=!1){if(typeof t=="object"&&t!==null){var s=e.get(t);if(s!==void 0)return s;if(t instanceof Map)return new Map(t);if(t instanceof Set)return new Set(t);if(ZB(t)){var o=Array(t.length);e.set(t,o),i!==null&&e.set(i,o);for(var l=0;l{e===vb&&a8e()})}vb.push(t)}function Udt(){for(;vb.length>0;)a8e()}function s8e(t){var e=Ui;if(e===null)return ma.f|=I_,t;if((e.f&Sv)===0&&(e.f&i2)===0)throw t;v_(t,e)}function v_(t,e){for(;e!==null;){if((e.f&zZ)!==0){if((e.f&Sv)===0)throw t;try{e.b.error(t);return}catch(r){t=r}}e=e.parent}throw t}const $dt=-7169;function Mo(t,e){t.f=t.f&$dt|e}function _se(t){(t.f&hf)!==0||t.deps===null?Mo(t,Tl):Mo(t,Hg)}function o8e(t){if(t!==null)for(const e of t)(e.f&wc)===0||(e.f&a2)===0||(e.f^=a2,o8e(e.deps))}function l8e(t,e,r){(t.f&mc)!==0?e.add(t):(t.f&Hg)!==0&&r.add(t),o8e(t.deps),Mo(t,Tl)}function c8e(t,e,r){if(t==null)return e(void 0),Vt;const n=zi(()=>t.subscribe(e,r));return n.unsubscribe?()=>n.unsubscribe():n}const WS=[];function Gdt(t,e){return{subscribe:nU(t,e).subscribe}}function nU(t,e=Vt){let r=null;const n=new Set;function i(o){if(r8e(t,o)&&(t=o,r)){const l=!WS.length;for(const u of n)u[1](),WS.push(u,t);if(l){for(let u=0;u{n.delete(u),n.size===0&&r&&(r(),r=null)}}return{set:i,update:a,subscribe:s}}function zdt(t){let e;return c8e(t,r=>e=r)(),e}let CO=!1,WZ=Symbol("unmounted");function u8e(t,e,r){const n=r[e]??={store:null,source:Tse(void 0),unsubscribe:Vt};if(n.store!==t&&!(WZ in r))if(n.unsubscribe(),n.store=t??null,t==null)n.source.v=void 0,n.unsubscribe=Vt;else{var i=!0;n.unsubscribe=c8e(t,a=>{i?n.source.v=a:X(n.source,a)}),i=!1}return t&&WZ in r?zdt(t):S(n.source)}function d8e(){const t={};function e(){c4(()=>{for(var r in t)t[r].unsubscribe();ose(t,WZ,{enumerable:!1,value:!0})})}return[t,e]}function qdt(t){var e=CO;try{return CO=!1,[t(),CO]}finally{CO=e}}let jq=null,KS=null,ra=null,KZ=null,ep=null,jZ=null,w9=!1,Xq=!1,iT=null,TD=null;var N0e=0;let Hdt=1;class Yg{id=Hdt++;#e=!1;linked=!0;#t=null;#r=null;async_deriveds=new Map;current=new Map;previous=new Map;#n=new Set;#i=new Set;#a=0;#s=new Map;#o=null;#l=[];#c=[];#d=new Set;#u=new Set;#p=new Map;#g=new Set;is_fork=!1;#f=!1;constructor(){KS===null?jq=KS=this:(KS.#r=this,this.#t=KS),KS=this}#h(){if(this.is_fork)return!0;for(const n of this.#s.keys()){for(var e=n,r=!1;e.parent!==null;){if(this.#p.has(e)){r=!0;break}e=e.parent}if(!r)return!0}return!1}skip_effect(e){this.#p.has(e)||this.#p.set(e,{d:[],m:[]}),this.#g.delete(e)}unskip_effect(e,r=n=>this.schedule(n)){var n=this.#p.get(e);if(n){this.#p.delete(e);for(var i of n.d)Mo(i,mc),r(i);for(i of n.m)Mo(i,Hg),r(i)}this.#g.add(e)}#m(){this.#e=!0,N0e++>1e3&&(this.#E(),Vdt());for(const l of this.#d)this.#u.delete(l),Mo(l,mc),this.schedule(l);for(const l of this.#u)Mo(l,Hg),this.schedule(l);const e=this.#l;this.#l=[],this.apply();var r=iT=[],n=[],i=TD=[];for(const l of e)try{this.#v(l,r,n)}catch(u){throw p8e(l),this.#h()||this.discard(),u}if(ra=null,i.length>0){var a=Yg.ensure();for(const l of i)a.schedule(l)}if(iT=null,TD=null,this.#h()){this.#b(n),this.#b(r);for(const[l,u]of this.#p)f8e(l,u);i.length>0&&ra.#m();return}const s=this.#_();if(s){this.#b(n),this.#b(r),s.#S(this);return}this.#d.clear(),this.#u.clear();for(const l of this.#n)l(this);this.#n.clear(),KZ=this,O0e(n),O0e(r),KZ=null,this.#o?.resolve();var o=ra;if(this.#a===0&&(this.#l.length===0||o!==null)&&this.#E(),this.#l.length>0)if(o!==null){const l=o;l.#l.push(...this.#l.filter(u=>!l.#l.includes(u)))}else o=this;o!==null&&o.#m()}#v(e,r,n){e.f^=Tl;for(var i=e.first;i!==null;){var a=i.f,s=(a&(Tp|M0))!==0,o=s&&(a&Tl)!==0,l=o||(a&Lu)!==0||this.#p.has(i);if(!l&&i.fn!==null){s?i.f^=Tl:(a&i2)!==0?r.push(i):y8(i)&&((a&sf)!==0&&this.#u.add(i),H5(i));var u=i.first;if(u!==null){i=u;continue}}for(;i!==null;){var d=i.next;if(d!==null){i=d;break}i=i.parent}}}#_(){for(var e=this.#t;e!==null;){if(!e.is_fork){for(const[r,[,n]]of this.current)if(e.current.has(r)&&!n)return e}e=e.#t}return null}#S(e){for(const[n,i]of e.current)!this.previous.has(n)&&e.previous.has(n)&&this.previous.set(n,e.previous.get(n)),this.current.set(n,i);for(const[n,i]of e.async_deriveds){const a=this.async_deriveds.get(n);a&&i.promise.then(a.resolve).catch(a.reject)}this.transfer_effects(e.#d,e.#u);const r=n=>{var i=n.reactions;if(i!==null)for(const o of i){var a=o.f;if((a&wc)!==0)r(o);else{var s=o;a&(LT|sf)&&!this.async_deriveds.has(s)&&(this.#u.delete(s),Mo(s,mc),this.schedule(s))}}};for(const n of this.current.keys())r(n);this.oncommit(()=>e.discard()),e.#E(),ra=this,this.#m()}#b(e){for(var r=0;r!d.current.get(h)[1]&&!this.current.has(h));if(i.length===0)e&&d.discard();else if(r.length>0){if(e)for(const h of this.#g)d.unskip_effect(h,f=>{(f.f&(sf|LT))!==0?d.schedule(f):d.#b([f])});d.activate();var a=new Set,s=new Map;for(var o of r)h8e(o,i,a,s);s=new Map;var l=[...d.current].filter(([h,f])=>{const p=this.current.get(h);return p?p[0]!==f[0]||p[1]!==f[1]:!0}).map(([h])=>h);if(l.length>0)for(const h of this.#c)(h.f&(ff|Lu|sL))===0&&yse(h,l,s)&&((h.f&(LT|sf))!==0?(Mo(h,mc),d.schedule(h)):d.#d.add(h));if(d.#l.length>0&&!d.#f){d.apply();for(var u of d.#l)d.#v(u,[],[]);d.#l=[]}d.deactivate()}}}}increment(e,r){if(this.#a+=1,e){let n=this.#s.get(r)??0;this.#s.set(r,n+1)}}decrement(e,r){if(this.#a-=1,e){let n=this.#s.get(r)??0;n===1?this.#s.delete(r):this.#s.set(r,n-1)}this.#f||(this.#f=!0,ip(()=>{this.#f=!1,this.linked&&this.flush()}))}transfer_effects(e,r){for(const n of e)this.#d.add(n);for(const n of r)this.#u.add(n);e.clear(),r.clear()}oncommit(e){this.#n.add(e)}ondiscard(e){this.#i.add(e)}settled(){return(this.#o??=Y7e()).promise}static ensure(){if(ra===null){const e=ra=new Yg;!Xq&&!w9&&ip(()=>{e.#e||e.flush()})}return ra}apply(){{ep=null;return}}schedule(e){if(jZ=e,e.b?.is_pending&&(e.f&(i2|p8|cse))!==0&&(e.f&Sv)===0){e.b.defer_effect(e);return}for(var r=e;r.parent!==null;){r=r.parent;var n=r.f;if(iT!==null&&r===Ui&&(ma===null||(ma.f&wc)===0))return;if((n&(M0|Tp))!==0){if((n&Tl)===0)return;r.f^=Tl}}this.#l.push(r)}#E(){if(this.linked){var e=this.#t,r=this.#r;e===null?jq=r:e.#r=r,r===null?KS=e:r.#t=e,this.linked=!1}}}function vse(t){var e=w9;w9=!0;try{for(var r;;){if(Udt(),ra===null)return r;ra.flush()}}finally{w9=e}}function Vdt(){try{ddt()}catch(t){v_(t,jZ)}}let Xm=null;function O0e(t){var e=t.length;if(e!==0){for(var r=0;r0)){zb.clear();for(const i of Xm){if((i.f&(ff|Lu))!==0)continue;const a=[i];let s=i.parent;for(;s!==null;)Xm.has(s)&&(Xm.delete(s),a.push(s)),s=s.parent;for(let o=a.length-1;o>=0;o--){const l=a[o];(l.f&(ff|Lu))===0&&H5(l)}}Xm.clear()}}Xm=null}}function h8e(t,e,r,n){if(!r.has(t)&&(r.add(t),t.reactions!==null))for(const i of t.reactions){const a=i.f;(a&wc)!==0?h8e(i,e,r,n):(a&(LT|sf))!==0&&(a&mc)===0&&yse(i,e,n)&&(Mo(i,mc),bse(i))}}function yse(t,e,r){const n=r.get(t);if(n!==void 0)return n;if(t.deps!==null)for(const i of t.deps){if(aL.call(e,i))return!0;if((i.f&wc)!==0&&yse(i,e,r))return r.set(i,!0),!0}return r.set(t,!1),!1}function bse(t){ra.schedule(t)}function f8e(t,e){if(!((t.f&Tp)!==0&&(t.f&Tl)!==0)){(t.f&mc)!==0?e.d.push(t):(t.f&Hg)!==0&&e.m.push(t),Mo(t,Tl);for(var r=t.first;r!==null;)f8e(r,e),r=r.next}}function p8e(t){Mo(t,Tl);for(var e=t.first;e!==null;)p8e(e),e=e.next}function Tv(t){let e=0,r=L0(0),n;return()=>{xse()&&(S(r),sU(()=>(e===0&&(n=zi(()=>t(()=>eh(r)))),e+=1,()=>{ip(()=>{e-=1,e===0&&(n?.(),n=void 0,eh(r))})})))}}var Ydt=Vg|H2;function Wdt(t,e,r,n){new Kdt(t,e,r,n)}class Kdt{parent;is_pending=!1;transform_error;#e;#t=Bn?wi:null;#r;#n;#i;#a=null;#s=null;#o=null;#l=null;#c=0;#d=0;#u=!1;#p=new Set;#g=new Set;#f=null;#h=Tv(()=>(this.#f=L0(this.#c),()=>{this.#f=null}));constructor(e,r,n,i){this.#e=e,this.#r=r,this.#n=a=>{var s=Ui;s.b=this,s.f|=zZ,n(a)},this.parent=Ui.b,this.transform_error=i??this.parent?.transform_error??(a=>a),this.#i=Cv(()=>{if(Bn){const a=this.#t;Cp();const s=a.data===fse;if(a.data.startsWith(R0e)){const l=JSON.parse(a.data.slice(R0e.length));this.#v(l)}else s?this.#_():this.#m()}else this.#S()},Ydt),Bn&&(this.#e=wi)}#m(){try{this.#a=yu(()=>this.#n(this.#e))}catch(e){this.error(e)}}#v(e){const r=this.#r.failed;r&&(this.#o=yu(()=>{r(this.#e,()=>e,()=>()=>{})}))}#_(){const e=this.#r.pending;e&&(this.is_pending=!0,this.#s=yu(()=>e(this.#e)),ip(()=>{var r=this.#l=document.createDocumentFragment(),n=Kc();r.append(n),this.#a=this.#y(()=>yu(()=>this.#n(n))),this.#d===0&&(this.#e.before(r),this.#l=null,qb(this.#s,()=>{this.#s=null}),this.#b(ra))}))}#S(){try{if(this.is_pending=this.has_pending_snippet(),this.#d=0,this.#c=0,this.#a=yu(()=>{this.#n(this.#e)}),this.#d>0){var e=this.#l=document.createDocumentFragment();Nse(this.#a,e);const r=this.#r.pending;this.#s=yu(()=>r(this.#e))}else this.#b(ra)}catch(r){this.error(r)}}#b(e){this.is_pending=!1,e.transfer_effects(this.#p,this.#g)}defer_effect(e){l8e(e,this.#p,this.#g)}is_rendered(){return!this.is_pending&&(!this.parent||this.parent.is_rendered())}has_pending_snippet(){return!!this.#r.pending}#y(e){var r=Ui,n=ma,i=ss;Wg(this.#i),mf(this.#i),G5(this.#i.ctx);try{return Yg.ensure(),e()}catch(a){return s8e(a),null}finally{Wg(r),mf(n),G5(i)}}#E(e,r){if(!this.has_pending_snippet()){this.parent&&this.parent.#E(e,r);return}this.#d+=e,this.#d===0&&(this.#b(r),this.#s&&qb(this.#s,()=>{this.#s=null}),this.#l&&(this.#e.before(this.#l),this.#l=null))}update_pending_count(e,r){this.#E(e,r),this.#c+=e,!(!this.#f||this.#u)&&(this.#u=!0,ip(()=>{this.#u=!1,this.#f&&q5(this.#f,this.#c)}))}get_effect_pending(){return this.#h(),S(this.#f)}error(e){if(!this.#r.onerror&&!this.#r.failed)throw e;ra?.is_fork?(this.#a&&ra.skip_effect(this.#a),this.#s&&ra.skip_effect(this.#s),this.#o&&ra.skip_effect(this.#o),ra.oncommit(()=>{this.#C(e)})):this.#C(e)}#C(e){this.#a&&(zl(this.#a),this.#a=null),this.#s&&(zl(this.#s),this.#s=null),this.#o&&(zl(this.#o),this.#o=null),Bn&&(oo(this.#t),Ct(),oo(TR()));var r=this.#r.onerror;let n=this.#r.failed;var i=!1,a=!1;const s=()=>{if(i){Ldt();return}i=!0,a&&_dt(),this.#o!==null&&qb(this.#o,()=>{this.#o=null}),this.#y(()=>{this.#S()})},o=l=>{try{a=!0,r?.(l,s),a=!1}catch(u){v_(u,this.#i&&this.#i.parent)}n&&(this.#o=this.#y(()=>{try{return yu(()=>{var u=Ui;u.b=this,u.f|=zZ,n(this.#e,()=>l,()=>s)})}catch(u){return v_(u,this.#i.parent),null}}))};ip(()=>{var l;try{l=this.transform_error(e)}catch(u){v_(u,this.#i&&this.#i.parent);return}l!==null&&typeof l=="object"&&typeof l.then=="function"?l.then(o,u=>v_(u,this.#i&&this.#i.parent)):o(l)})}}function Sse(t,e,r,n){const i=o4()?z5:H_;var a=t.filter(p=>!p.settled),s=e.map(i);if(r.length===0&&a.length===0){n(s);return}var o=Ui,l=jdt(),u=a.length===1?a[0].promise:a.length>1?Promise.all(a.map(p=>p.promise)):null;function d(p){if((o.f&ff)===0){l();try{n([...s,...p])}catch(g){v_(g,o)}lL()}}var h=g8e();if(r.length===0){u.then(()=>d([])).finally(h);return}function f(){Promise.all(r.map(p=>Xdt(p))).then(d).catch(p=>v_(p,o)).finally(h)}u?u.then(()=>{l(),f(),lL()}):f()}function jdt(){var t=Ui,e=ma,r=ss,n=ra;return function(a=!0){Wg(t),mf(e),G5(r),a&&(t.f&ff)===0&&(n?.activate(),n?.apply())}}function lL(t=!0){Wg(null),mf(null),G5(null),t&&ra?.deactivate()}function g8e(){var t=Ui,e=t.b,r=ra,n=!!e?.is_rendered();return e?.update_pending_count(1,r),r.increment(n,t),()=>{e?.update_pending_count(-1,r),r.decrement(n,t)}}function z5(t){var e=wc|mc;return Ui!==null&&(Ui.f|=H2),{ctx:ss,deps:null,effects:null,equals:t8e,f:e,fn:t,reactions:null,rv:0,v:Vo,wv:0,parent:Ui,ac:null}}const wO=Symbol("obsolete");function Xdt(t,e,r){let n=Ui;n===null&&sdt();var i=void 0,a=L0(Vo),s=!ma,o=new Set;return aht(()=>{var l=Ui,u=Y7e();i=u.promise;try{Promise.resolve(t()).then(u.resolve,p=>{p!==tU&&u.reject(p)}).finally(lL)}catch(p){u.reject(p),lL()}var d=ra;if(s){if((l.f&Sv)!==0)var h=g8e();if(n.b?.is_rendered())d.async_deriveds.get(l)?.reject(wO);else for(const p of o.values())p.reject(wO);o.add(u),d.async_deriveds.set(l,u)}const f=(p,g=void 0)=>{h?.(),o.delete(u),g!==wO&&(d.activate(),g?(a.f|=I_,q5(a,g)):((a.f&I_)!==0&&(a.f^=I_),q5(a,p)),d.deactivate())};u.promise.then(f,p=>f(null,p||"unknown"))}),c4(()=>{for(const l of o)l.reject(wO)}),new Promise(l=>{function u(d){function h(){d===i?l(a):u(i)}d.then(h,h)}u(i)})}function W(t){const e=z5(t);return M8e(e),e}function H_(t){const e=z5(t);return e.equals=n8e,e}function Qdt(t){var e=t.effects;if(e!==null){t.effects=null;for(var r=0;r0&&!v8e&&Jdt()}return e}function Jdt(){v8e=!1;for(const t of cL){(t.f&Tl)!==0&&Mo(t,Hg);let e;try{e=y8(t)}catch{e=!0}e&&H5(t)}cL.clear()}function V_(t,e=1){var r=S(t),n=e===1?r++:r--;return X(t,r),n}function eh(t){X(t,t.v+1)}function y8e(t,e,r){var n=t.reactions;if(n!==null)for(var i=o4(),a=n.length,s=0;s{if(ap===a)return o();var l=ma,u=ap;mf(null),M0e(a);var d=o();return mf(l),M0e(u),d};return n&&r.set("length",Oe(t.length)),new Proxy(t,{defineProperty(o,l,u){(!("value"in u)||u.configurable===!1||u.enumerable===!1||u.writable===!1)&&pdt();var d=r.get(l);return d===void 0?s(()=>{var h=Oe(u.value);return r.set(l,h),h}):X(d,u.value,!0),!0},deleteProperty(o,l){var u=r.get(l);if(u===void 0){if(l in o){const d=s(()=>Oe(Vo));r.set(l,d),eh(i)}}else X(u,Vo),eh(i);return!0},get(o,l,u){if(l===Mg)return t;var d=r.get(l),h=l in o;if(d===void 0&&(!h||O_(o,l)?.writable)&&(d=s(()=>{var p=Zr(h?o[l]:Vo),g=Oe(p);return g}),r.set(l,d)),d!==void 0){var f=S(d);return f===Vo?void 0:f}return Reflect.get(o,l,u)},getOwnPropertyDescriptor(o,l){var u=Reflect.getOwnPropertyDescriptor(o,l);if(u&&"value"in u){var d=r.get(l);d&&(u.value=S(d))}else if(u===void 0){var h=r.get(l),f=h?.v;if(h!==void 0&&f!==Vo)return{enumerable:!0,configurable:!0,value:f,writable:!0}}return u},has(o,l){if(l===Mg)return!0;var u=r.get(l),d=u!==void 0&&u.v!==Vo||Reflect.has(o,l);if(u!==void 0||Ui!==null&&(!d||O_(o,l)?.writable)){u===void 0&&(u=s(()=>{var f=d?Zr(o[l]):Vo,p=Oe(f);return p}),r.set(l,u));var h=S(u);if(h===Vo)return!1}return d},set(o,l,u,d){var h=r.get(l),f=l in o;if(n&&l==="length")for(var p=u;pOe(Vo)),r.set(p+"",g))}if(h===void 0)(!f||O_(o,l)?.writable)&&(h=s(()=>Oe(void 0)),X(h,Zr(u)),r.set(l,h));else{f=h.v!==Vo;var m=s(()=>Zr(u));X(h,m)}var _=Reflect.getOwnPropertyDescriptor(o,l);if(_?.set&&_.set.call(d,u),!f){if(n&&typeof l=="string"){var v=r.get("length"),b=Number(l);Number.isInteger(b)&&b>=v.v&&X(v,b+1)}eh(i)}return!0},ownKeys(o){S(i);var l=Reflect.ownKeys(o).filter(h=>{var f=r.get(h);return f===void 0||f.v!==Vo});for(var[u,d]of r)d.v!==Vo&&!(u in o)&&l.push(u);return l},setPrototypeOf(){gdt()}})}function I0e(t){try{if(t!==null&&typeof t=="object"&&Mg in t)return t[Mg]}catch{}return t}function eht(t,e){return Object.is(I0e(t),I0e(e))}var o2,l4,b8e,S8e,E8e;function XZ(){if(o2===void 0){o2=window,l4=document,b8e=/Firefox/.test(navigator.userAgent);var t=Element.prototype,e=Node.prototype,r=Text.prototype;S8e=O_(e,"firstChild").get,E8e=O_(e,"nextSibling").get,A0e(t)&&(t[HZ]=void 0,t[X7e]=null,t[VZ]=void 0,t.__e=void 0),A0e(r)&&(r[YZ]=void 0)}}function Kc(t=""){return document.createTextNode(t)}function gc(t){return S8e.call(t)}function dh(t){return E8e.call(t)}function te(t,e){if(!Bn)return gc(t);var r=gc(wi);if(r===null)r=wi.appendChild(Kc());else if(e&&r.nodeType!==m8){var n=Kc();return r?.before(n),oo(n),n}return e&&iU(r),oo(r),r}function oe(t,e=!1){if(!Bn){var r=gc(t);return r instanceof Comment&&r.data===""?dh(r):r}if(e){if(wi?.nodeType!==m8){var n=Kc();return wi?.before(n),oo(n),n}iU(wi)}return wi}function ie(t,e=1,r=!1){let n=Bn?wi:t;for(var i;e--;)i=n,n=dh(n);if(!Bn)return n;if(r){if(n?.nodeType!==m8){var a=Kc();return n===null?i?.after(a):n.before(a),oo(a),a}iU(n)}return oo(n),n}function Cse(t){t.textContent=""}function T8e(){return!1}function wse(t,e,r){return e==null||e===Z7e?r?document.createElement(t,{is:r}):document.createElement(t):r?document.createElementNS(e,t,{is:r}):document.createElementNS(e,t)}function iU(t){if(t.nodeValue.length<65536)return;let e=t.nextSibling;for(;e!==null&&e.nodeType===m8;)e.remove(),t.nodeValue+=e.nodeValue,e=t.nextSibling}function tht(t,e){if(e){const r=document.body;t.autofocus=!0,ip(()=>{document.activeElement===r&&t.focus()})}}function aU(t){Bn&&gc(t)!==null&&Cse(t)}let k0e=!1;function C8e(){k0e||(k0e=!0,document.addEventListener("reset",t=>{Promise.resolve().then(()=>{if(!t.defaultPrevented)for(const e of t.target.elements)e[C9]?.()})},{capture:!0}))}function rht(t,e,r,n=!0){n&&r();for(var i of e)t.addEventListener(i,r);c4(()=>{for(var a of e)t.removeEventListener(a,r)})}function V2(t){var e=ma,r=Ui;mf(null),Wg(null);try{return t()}finally{mf(e),Wg(r)}}function w8e(t,e,r,n=r){t.addEventListener(e,()=>V2(r));const i=t[C9];i?t[C9]=()=>{i(),n(!0)}:t[C9]=()=>n(!0),C8e()}function x8e(t){Ui===null&&(ma===null&&udt(),cdt()),P0&&ldt()}function nht(t,e){var r=e.last;r===null?e.last=e.first=t:(r.next=t,t.prev=r,e.last=t)}function bh(t,e){var r=Ui;r!==null&&(r.f&Lu)!==0&&(t|=Lu);var n={ctx:ss,deps:null,nodes:null,f:t|mc|hf,first:null,fn:e,last:null,next:null,parent:r,b:r&&r.b,prev:null,teardown:null,wv:0,ac:null};ra?.register_created_effect(n);var i=n;if((t&i2)!==0)iT!==null?iT.push(n):Yg.ensure().schedule(n);else if(e!==null){try{H5(n)}catch(s){throw zl(n),s}i.deps===null&&i.teardown===null&&i.nodes===null&&i.first===i.last&&(i.f&H2)===0&&(i=i.first,(t&sf)!==0&&(t&Vg)!==0&&i!==null&&(i.f|=Vg))}if(i!==null&&(i.parent=r,r!==null&&nht(i,r),ma!==null&&(ma.f&wc)!==0&&(t&M0)===0)){var a=ma;(a.effects??=[]).push(i)}return n}function xse(){return ma!==null&&!tp}function c4(t){const e=bh(p8,null);return Mo(e,Tl),e.teardown=t,e}function Kt(t){x8e();var e=Ui.f,r=!ma&&(e&Tp)!==0&&ss!==null&&!ss.i;if(r){var n=ss;(n.e??=[]).push(t)}else return A8e(t)}function A8e(t){return bh(i2|j7e,t)}function uc(t){return x8e(),bh(p8|j7e,t)}function v8(t){Yg.ensure();const e=bh(M0|H2,t);return()=>{zl(e)}}function iht(t){Yg.ensure();const e=bh(M0|H2,t);return(r={})=>new Promise(n=>{r.outro?qb(e,()=>{zl(e),n(void 0)}):(zl(e),n(void 0))})}function u4(t){return bh(i2,t)}function aht(t){return bh(LT|H2,t)}function sU(t,e=0){return bh(p8|e,t)}function $e(t,e=[],r=[],n=[]){Sse(n,e,r,i=>{bh(p8,()=>{t(...i.map(S))})})}function Ase(t,e=[],r=[],n=[]){Sse(n,e,r,i=>{bh(i2,()=>t(...i.map(S)))})}function Cv(t,e=0){var r=bh(sf|e,t);return r}function R8e(t,e=0){var r=bh(cse|e,t);return r}function yu(t){return bh(Tp|H2,t)}function N8e(t){var e=t.teardown;if(e!==null){const r=P0,n=ma;D0e(!0),mf(null);try{e.call(null)}finally{D0e(r),mf(n)}}}function Rse(t,e=!1){var r=t.first;for(t.first=t.last=null;r!==null;){const i=r.ac;i!==null&&V2(()=>{i.abort(tU)});var n=r.next;(r.f&M0)!==0?r.parent=null:zl(r,e),r=n}}function sht(t){for(var e=t.first;e!==null;){var r=e.next;(e.f&Tp)===0&&zl(e),e=r}}function zl(t,e=!0){var r=!1;(e||(t.f&K7e)!==0)&&t.nodes!==null&&t.nodes.end!==null&&(O8e(t.nodes.start,t.nodes.end),r=!0),t.f|=qZ,Rse(t,e&&!r),CR(t,0);var n=t.nodes&&t.nodes.t;if(n!==null)for(const a of n)a.stop();N8e(t),t.f^=qZ,t.f|=ff;var i=t.parent;i!==null&&i.first!==null&&I8e(t),t.next=t.prev=t.teardown=t.ctx=t.deps=t.fn=t.nodes=t.ac=t.b=null}function O8e(t,e){for(;t!==null;){var r=t===e?null:dh(t);t.remove(),t=r}}function I8e(t){var e=t.parent,r=t.prev,n=t.next;r!==null&&(r.next=n),n!==null&&(n.prev=r),e!==null&&(e.first===t&&(e.first=n),e.last===t&&(e.last=r))}function qb(t,e,r=!0){var n=[];k8e(t,n,!0);var i=()=>{r&&zl(t),e&&e()},a=n.length;if(a>0){var s=()=>--a||i();for(var o of n)o.out(s)}else i()}function k8e(t,e,r){if((t.f&Lu)===0){t.f^=Lu;var n=t.nodes&&t.nodes.t;if(n!==null)for(const o of n)(o.is_global||r)&&e.push(o);for(var i=t.first;i!==null;){var a=i.next;if((i.f&M0)===0){var s=(i.f&Vg)!==0||(i.f&Tp)!==0&&(t.f&sf)!==0;k8e(i,e,s?r:!1)}i=a}}}function uL(t){D8e(t,!0)}function D8e(t,e){if((t.f&Lu)!==0){t.f^=Lu,(t.f&Tl)===0&&(Mo(t,mc),Yg.ensure().schedule(t));for(var r=t.first;r!==null;){var n=r.next,i=(r.f&Vg)!==0||(r.f&Tp)!==0;D8e(r,i?e:!1),r=n}var a=t.nodes&&t.nodes.t;if(a!==null)for(const s of a)(s.is_global||e)&&s.in()}}function Nse(t,e){if(t.nodes)for(var r=t.nodes.start,n=t.nodes.end;r!==null;){var i=r===n?null:dh(r);e.append(r),r=i}}let CD=!1,P0=!1;function D0e(t){P0=t}let ma=null,tp=!1;function mf(t){ma=t}let Ui=null;function Wg(t){Ui=t}let Lg=null;function M8e(t){ma!==null&&(Lg??=new Set).add(t)}let cd=null,Vd=0,Vh=null;function oht(t){Vh=t}let L8e=1,yb=0,ap=yb;function M0e(t){ap=t}function P8e(){return++L8e}function y8(t){var e=t.f;if((e&mc)!==0)return!0;if(e&wc&&(t.f&=~a2),(e&Hg)!==0){for(var r=t.deps,n=r.length,i=0;it.wv)return!0}(e&hf)!==0&&ep===null&&Mo(t,Tl)}return!1}function F8e(t,e,r=!0){var n=t.reactions;if(n!==null&&!(Lg!==null&&Lg.has(t)))for(var i=0;i{t.ac.abort(tU)}),t.ac=null);try{t.f|=oL;var d=t.fn,h=d();t.f|=Sv;var f=t.deps,p=ra?.is_fork;if(cd!==null){var g;if(p||CR(t,Vd),f!==null&&Vd>0)for(f.length=Vd+cd.length,g=0;g{t.isConnected&&t.dispatchEvent(e)}))}function Ose(t,e,r,n={}){function i(a){if(n.capture||JZ.call(e,a),!a.cancelBubble)return V2(()=>r?.call(this,a))}return t.startsWith("pointer")||t.startsWith("touch")||t==="wheel"?ip(()=>{e.addEventListener(t,i,n)}):e.addEventListener(t,i,n),i}function Bi(t,e,r,n={}){var i=Ose(e,t,r,n);return()=>{t.removeEventListener(e,i,n)}}function Zn(t,e,r,n,i){var a={capture:n,passive:i},s=Ose(t,e,r,a);(e===document.body||e===window||e===document||e instanceof HTMLMediaElement)&&c4(()=>{e.removeEventListener(t,s,a)})}function Kr(t,e,r){(e[R6]??={})[t]=r}function Hi(t){for(var e=0;e{throw m});throw f}}finally{t[R6]=e,delete t.currentTarget,mf(d),Wg(h)}}}const bht=globalThis?.window?.trustedTypes&&globalThis.window.trustedTypes.createPolicy("svelte-trusted-html",{createHTML:t=>t});function Sht(t){return bht?.createHTML(t)??t}function q8e(t){var e=wse("template");return e.innerHTML=Sht(t.replaceAll("","")),e.content}function wd(t,e){var r=Ui;r.nodes===null&&(r.nodes={start:t,end:e,a:null,t:null})}function se(t,e){var r=(e&Odt)!==0,n=(e&Idt)!==0,i,a=!t.startsWith("");return()=>{if(Bn)return wd(wi,null),wi;i===void 0&&(i=q8e(a?t:""+t),r||(i=gc(i)));var s=n||b8e?document.importNode(i,!0):i.cloneNode(!0);if(r){var o=gc(s),l=s.lastChild;wd(o,l)}else wd(s,s);return s}}function Eht(t,e,r="svg"){var n=!t.startsWith(""),i=`<${r}>${n?t:""+t}`,a;return()=>{if(Bn)return wd(wi,null),wi;if(!a){var s=q8e(i),o=gc(s);a=gc(o)}var l=a.cloneNode(!0);return wd(l,l),l}}function im(t,e){return Eht(t,e,"svg")}function or(t=""){if(!Bn){var e=Kc(t+"");return wd(e,e),e}var r=wi;return r.nodeType!==m8?(r.before(r=Kc()),oo(r)):iU(r),wd(r,r),r}function Ae(){if(Bn)return wd(wi,null),wi;var t=document.createDocumentFragment(),e=document.createComment(""),r=Kc();return t.append(e,r),wd(e,r),t}function G(t,e){if(Bn){var r=Ui;((r.f&Sv)===0||r.nodes.end===null)&&(r.nodes.end=wi),Cp();return}t!==null&&t.before(e)}function Vi(){if(Bn&&wi&&wi.nodeType===Ev&&wi.textContent?.startsWith("$")){const t=wi.textContent.substring(1);return Cp(),t}return(window.__svelte??={}).uid??=1,`c${window.__svelte.uid++}`}let dL=!0;function xO(t){dL=t}function it(t,e){var r=e==null?"":typeof e=="object"?`${e}`:e;r!==(t[YZ]??=t.nodeValue)&&(t[YZ]=r,t.nodeValue=`${r}`)}function oU(t,e){return V8e(t,e)}function H8e(t,e){XZ(),e.intro=e.intro??!1;const r=e.target,n=Bn,i=wi;try{for(var a=gc(r);a&&(a.nodeType!==Ev||a.data!==hse);)a=dh(a);if(!a)throw s2;_c(!0),oo(a);const s=V8e(t,{...e,anchor:a});return _c(!1),s}catch(s){if(s instanceof Error&&s.message.split(` +`).some(o=>o.startsWith("https://svelte.dev/e/")))throw s;return s!==s2&&console.warn("Failed to hydrate: ",s),e.recover===!1&&hdt(),XZ(),Cse(r),_c(!1),oU(t,e)}finally{_c(n),oo(i)}}const AO=new Map;function V8e(t,{target:e,anchor:r,props:n={},events:i,context:a,intro:s=!0,transformError:o}){XZ();var l=void 0,u=iht(()=>{var d=r??e.appendChild(Kc());Wdt(d,{pending:()=>{}},p=>{at({});var g=ss;if(a&&(g.c=a),i&&(n.$$events=i),Bn&&wd(p,null),dL=s,l=t(p,n)||{},dL=!0,Bn&&(Ui.nodes.end=wi,wi===null||wi.nodeType!==Ev||wi.data!==pse))throw _8(),s2;st()},o);var h=new Set,f=p=>{for(var g=0;g{for(var p of h)for(const _ of[e,document]){var g=AO.get(_),m=g.get(p);--m==0?(_.removeEventListener(p,JZ),g.delete(p),g.size===0&&AO.delete(_)):g.set(p,m)}ZZ.delete(f),d!==r&&d.parentNode?.removeChild(d)}});return eJ.set(l,u),l}let eJ=new WeakMap;function Ise(t,e){const r=eJ.get(t);return r?(eJ.delete(t),r(e)):Promise.resolve()}class b8{anchor;#e=new Map;#t=new Map;#r=new Map;#n=new Set;#i=!0;constructor(e,r=!0){this.anchor=e,this.#i=r}#a=e=>{if(this.#e.has(e)){var r=this.#e.get(e),n=this.#t.get(r);if(n)uL(n),this.#n.delete(r);else{var i=this.#r.get(r);i&&(uL(i.effect),this.#t.set(r,i.effect),this.#r.delete(r),i.fragment.lastChild.remove(),this.anchor.before(i.fragment),n=i.effect)}for(const[a,s]of this.#e){if(this.#e.delete(a),a===e)break;const o=this.#r.get(s);o&&(zl(o.effect),this.#r.delete(s))}for(const[a,s]of this.#t){if(a===r||this.#n.has(a))continue;const o=()=>{if(Array.from(this.#e.values()).includes(a)){var u=document.createDocumentFragment();Nse(s,u),u.append(Kc()),this.#r.set(a,{effect:s,fragment:u})}else zl(s);this.#n.delete(a),this.#t.delete(a)};this.#i||!n?(this.#n.add(a),qb(s,o,!1)):o()}}};#s=e=>{this.#e.delete(e);const r=Array.from(this.#e.values());for(const[n,i]of this.#r)r.includes(n)||(zl(i.effect),this.#r.delete(n))};ensure(e,r){var n=ra,i=T8e();if(r&&!this.#t.has(e)&&!this.#r.has(e))if(i){var a=document.createDocumentFragment(),s=Kc();a.append(s),this.#r.set(e,{effect:yu(()=>r(s)),fragment:a})}else this.#t.set(e,yu(()=>r(this.anchor)));if(this.#e.set(n,e),i){for(const[o,l]of this.#t)o===e?n.unskip_effect(l):n.skip_effect(l);for(const[o,l]of this.#r)o===e?n.unskip_effect(l.effect):n.skip_effect(l.effect);n.oncommit(this.#a),n.ondiscard(this.#s)}else Bn&&(this.anchor=wi),this.#a(n)}}function ve(t,e,r=!1){var n;Bn&&(n=wi,Cp());var i=new b8(t),a=r?Vg:0;function s(o,l){if(Bn){var u=gse(n);if(o!==parseInt(u.substring(1))){var d=TR();oo(d),i.anchor=d,_c(!1),i.ensure(o,l),_c(!0);return}}i.ensure(o,l)}Cv(()=>{var o=!1;e((l,u=0)=>{o=!0,s(u,l)}),o||s(-1,null)},a)}const Tht=Symbol("NaN");function Y8e(t,e,r){Bn&&Cp();var n=new b8(t),i=!o4();Cv(()=>{var a=e();a!==a&&(a=Tht),i&&a!==null&&typeof a=="object"&&(a={}),n.ensure(a,r)})}function Vl(t,e){return e}function Cht(t,e,r){for(var n=[],i=e.length,a,s=e.length,o=0;o{if(a){if(a.pending.delete(h),a.done.add(h),a.pending.size===0){var f=t.outrogroups;tJ(t,JB(a.done)),f.delete(a),f.size===0&&(t.outrogroups=null)}}else s-=1},!1)}if(s===0){var l=n.length===0&&r!==null;if(l){var u=r,d=u.parentNode;Cse(d),d.append(u),t.items.clear()}tJ(t,e,!l)}else a={pending:new Set(e),done:new Set},(t.outrogroups??=new Set).add(a)}function tJ(t,e,r=!0){var n;if(t.pending.size>0){n=new Set;for(const s of t.pending.values())for(const o of s)n.add(t.items.get(o).e)}for(var i=0;i{var y=r();return ZB(y)?y:y==null?[]:JB(y)}),f,p=new Map,g=!0;function m(y){(b.effect.f&ff)===0&&(b.pending.delete(y),b.fallback=d,wht(b,f,s,e,n),d!==null&&(f.length===0?(d.f&Cg)===0?uL(d):(d.f^=Cg,N6(d,null,s)):qb(d,()=>{d=null})))}function _(y){b.pending.delete(y)}var v=Cv(()=>{f=S(h);var y=f.length;let E=!1;if(Bn){var T=gse(s)===fse;T!==(y===0)&&(s=TR(),oo(s),_c(!1),E=!0)}for(var C=new Set,w=ra,x=T8e(),A=0;Aa(s)):(d=yu(()=>a(P0e??=Kc())),d.f|=Cg)),y>C.size&&odt(),Bn&&y>0&&oo(TR()),!g)if(p.set(w,C),x){for(const[P,N]of o)C.has(P)||w.skip_effect(N.e);w.oncommit(m),w.ondiscard(_)}else m(w);E&&_c(!0),S(h)}),b={effect:v,items:o,pending:p,outrogroups:null,fallback:d};g=!1,Bn&&(s=wi)}function dA(t){for(;t!==null&&(t.f&Tp)===0;)t=t.next;return t}function wht(t,e,r,n,i){var a=(n&bdt)!==0,s=e.length,o=t.items,l=dA(t.effect.first),u,d=null,h,f=[],p=[],g,m,_,v;if(a)for(v=0;v0){var A=(n&Q7e)!==0&&s===0?r:null;if(a){for(v=0;v{if(h!==void 0)for(_ of h)_.nodes?.a?.apply()})}function xht(t,e,r,n,i,a,s,o){var l=(s&vdt)!==0?(s&Sdt)===0?Tse(r,!1,!1):L0(r):null,u=(s&ydt)!==0?L0(i):null;return{v:l,i:u,e:yu(()=>(a(e,l??r,u??i,o),()=>{t.delete(n)}))}}function N6(t,e,r){if(t.nodes)for(var n=t.nodes.start,i=t.nodes.end,a=e&&(e.f&Cg)===0?e.nodes.start:r;n!==null;){var s=dh(n);if(a.before(n),n===i)return;n=s}}function B1(t,e,r){e===null?t.effect.first=r:e.next=r,r===null?t.effect.last=e:r.prev=e}function D_(t,e,r=!1,n=!1,i=!1,a=!1){var s=t,o="";if(r){var l=t;Bn&&(s=oo(gc(l)))}$e(()=>{var u=Ui;if(o===(o=e()??"")){Bn&&Cp();return}if(r&&!Bn){u.nodes=null,l.innerHTML=o,o!==""&&wd(gc(l),l.lastChild);return}if(u.nodes!==null&&(O8e(u.nodes.start,u.nodes.end),u.nodes=null),o!==""){if(Bn){wi.data;for(var d=Cp(),h=d;d!==null&&(d.nodeType!==Ev||d.data!=="");)h=d,d=dh(d);if(d===null)throw _8(),s2;wd(wi,h),s=oo(d);return}var f=n?J7e:i?kdt:void 0,p=wse(n?"svg":i?"math":"template",f);p.innerHTML=o;var g=n||i?p:p.content;if(wd(gc(g),g.lastChild),n||i)for(;gc(g);)s.before(gc(g));else s.before(g)}})}function Pt(t,e,...r){var n=new b8(t);Cv(()=>{const i=e()??null;n.ensure(i,i&&(a=>i(a,...r)))},Vg)}function Me(t,e,r){var n;Bn&&(n=wi,Cp());var i=new b8(t);Cv(()=>{var a=e()??null;if(Bn){var s=gse(n),o=s===hse,l=a!==null;if(o!==l){var u=TR();oo(u),i.anchor=u,_c(!1),i.ensure(a,a&&(d=>r(d,a))),_c(!0);return}}i.ensure(a,a&&(d=>r(d,a)))},Vg)}const Aht=()=>performance.now(),l0={tick:t=>requestAnimationFrame(t),now:()=>Aht(),tasks:new Set};function W8e(){const t=l0.now();l0.tasks.forEach(e=>{e.c(t)||(l0.tasks.delete(e),e.f())}),l0.tasks.size!==0&&l0.tick(W8e)}function Rht(t){let e;return l0.tasks.size===0&&l0.tick(W8e),{promise:new Promise(r=>{l0.tasks.add(e={c:t,f:r})}),abort(){l0.tasks.delete(e)}}}function RO(t,e){V2(()=>{t.dispatchEvent(new CustomEvent(e))})}function Nht(t){if(t==="float")return"cssFloat";if(t==="offset")return"cssOffset";if(t.startsWith("--"))return t;const e=t.split("-");return e.length===1?e[0]:e[0]+e.slice(1).map(r=>r[0].toUpperCase()+r.slice(1)).join("")}function F0e(t){const e={},r=t.split(";");for(const n of r){const[i,a]=n.split(":");if(!i||a===void 0)break;const s=Nht(i.trim());e[s]=a.trim()}return e}const Oht=t=>t;function vs(t,e,r,n){var i=(t&Adt)!==0,a=(t&Rdt)!==0,s=i&&a,o=(t&Ndt)!==0,l=s?"both":i?"in":"out",u,d=e.inert,h=e.style.overflow,f,p;function g(){return V2(()=>u??=r()(e,n?.()??{},{direction:l}))}var m={is_global:o,in(){if(e.inert=d,!i){p?.abort(),p?.reset?.();return}a||f?.abort(),f=rJ(e,g(),p,1,()=>{RO(e,"introstart")},()=>{RO(e,"introend"),f?.abort(),f=u=void 0,e.style.overflow=h})},out(y){if(!a){y?.(),u=void 0;return}e.inert=!0,p=rJ(e,g(),f,0,()=>{RO(e,"outrostart")},()=>{RO(e,"outroend"),y?.()})},stop:()=>{f?.abort(),p?.abort()}},_=Ui;if((_.nodes.t??=[]).push(m),i&&dL){var v=o;if(!v){for(var b=_.parent;b&&(b.f&Vg)!==0;)for(;(b=b.parent)&&(b.f&sf)===0;);v=!b||(b.f&Sv)!==0}v&&u4(()=>{zi(()=>m.in())})}}function rJ(t,e,r,n,i,a){var s=n===1;if(wE(e)){var o,l=!1;return ip(()=>{if(!l){var v=e({direction:s?"in":"out"});o=rJ(t,v,r,n,i,a)}}),{abort:()=>{l=!0,o?.abort()},deactivate:()=>o.deactivate(),reset:()=>o.reset(),t:()=>o.t()}}if(r?.deactivate(),!e?.duration&&!e?.delay)return i(),a(),{abort:Vt,deactivate:Vt,reset:Vt,t:()=>n};const{delay:u=0,css:d,tick:h,easing:f=Oht}=e;var p=[];if(s&&r===void 0&&(h&&h(0,1),d)){var g=F0e(d(0,1));p.push(g,g)}var m=()=>1-n,_=t.animate(p,{duration:u,fill:"forwards"});return _.onfinish=()=>{_.cancel(),i();var v=r?.t()??1-n;r?.abort();var b=n-v,y=e.duration*Math.abs(b),E=[];if(y>0){var T=!1;if(d)for(var C=Math.ceil(y/16.666666666666668),w=0;w<=C;w+=1){var x=v+b*f(w/C),A=F0e(d(x,1-x));E.push(A),T||=A.overflow==="hidden"}T&&(t.style.overflow="hidden"),m=()=>{var R=_.currentTime;return v+b*f(R/y)},h&&Rht(()=>{if(_.playState!=="running")return!1;var R=m();return h(R,1-R),!0})}_=t.animate(E,{duration:y,fill:"forwards"}),_.onfinish=()=>{m=()=>n,h?.(n,1-n),a()}},{abort:()=>{_&&(_.cancel(),_.effect=null,_.onfinish=Vt)},deactivate:()=>{a=Vt},reset:()=>{n===0&&h?.(1,0)},t:()=>m()}}function K8e(t,e,r,n,i,a){let s=Bn;Bn&&Cp();var o=null;Bn&&wi.nodeType===adt&&(o=wi,Cp());var l=Bn?wi:t,u=new b8(l,!1);Cv(()=>{const d=e()||null;var h=r||d==="svg"?J7e:void 0;if(d===null){u.ensure(null,null),xO(!0);return}return u.ensure(d,f=>{if(d){if(o=Bn?o:wse(d,h),wd(o,o),n){var p=null;Bn&&yht(d)&&o.append(p=document.createComment(""));var g=Bn?gc(o):o.appendChild(Kc());Bn&&(g===null?_c(!1):oo(g)),n(o,g),p?.remove()}Ui.nodes.end=o,f.before(o)}Bn&&oo(f)}),xO(!0),()=>{d&&xO(!1)}},Vg),c4(()=>{xO(!0)}),s&&(_c(!0),oo(l))}function Y2(t,e){let r=null,n=Bn;var i;if(Bn){r=wi;for(var a=gc(document.head);a!==null&&(a.nodeType!==Ev||a.data!==t);)a=dh(a);if(a===null)_c(!1);else{var s=dh(a);a.remove(),oo(s)}}Bn||(i=document.head.appendChild(Kc()));try{Cv(()=>{var o=yu(()=>e(i));o.f|=K7e})}finally{n&&(_c(!0),oo(r))}}function j8e(t,e,r){u4(()=>{var n=zi(()=>e(t,r?.())||{});if(n?.destroy)return()=>n.destroy()})}function Iht(t,e){var r=void 0,n;R8e(()=>{r!==(r=e())&&(n&&(zl(n),n=null),r&&(n=yu(()=>{u4(()=>r(t))})))})}function X8e(t){var e,r,n="";if(typeof t=="string"||typeof t=="number")n+=t;else if(typeof t=="object")if(Array.isArray(t)){var i=t.length;for(e=0;e=0;){var o=s+a;(s===0||B0e.includes(n[s-1]))&&(o===n.length||B0e.includes(n[o]))?n=(s===0?"":n.substring(0,s))+n.substring(o+1):s=o}}return n===""?null:n}function U0e(t,e=!1){var r=e?" !important;":";",n="";for(var i of Object.keys(t)){var a=t[i];a!=null&&a!==""&&(n+=" "+i+": "+a+r)}return n}function Qq(t){return t[0]!=="-"||t[1]!=="-"?t.toLowerCase():t}function Dht(t,e){if(e){var r="",n,i;if(Array.isArray(e)?(n=e[0],i=e[1]):n=e,t){t=String(t).replaceAll(/\s*\/\*.*?\*\/\s*/g,"").trim();var a=!1,s=0,o=!1,l=[];n&&l.push(...Object.keys(n).map(Qq)),i&&l.push(...Object.keys(i).map(Qq));var u=0,d=-1;const m=t.length;for(var h=0;h{nJ(t,t.__value)});e.observe(t,{childList:!0,subtree:!0,attributes:!0,attributeFilter:["value"]}),c4(()=>{e.disconnect()})}function $0e(t){return"__value"in t?t.__value:t.value}const hA=Symbol("class"),xE=Symbol("style"),Q8e=Symbol("is custom element"),Z8e=Symbol("is html"),Lht=g8?"link":"LINK",G0e=g8?"input":"INPUT",Pht=g8?"option":"OPTION",Fht=g8?"select":"SELECT",Bht=g8?"progress":"PROGRESS";function Uht(t){if(Bn){var e=!1,r=()=>{if(!e){if(e=!0,t.hasAttribute("value")){var n=t.value;lr(t,"value",null),t.value=n}if(t.hasAttribute("checked")){var i=t.checked;lr(t,"checked",null),t.checked=i}}};t[C9]=r,ip(r),C8e()}}function J8e(t,e){var r=kse(t);r.value===(r.value=e??void 0)||t.value===e&&(e!==0||t.nodeName!==Bht)||(t.value=e??"")}function $ht(t,e){e?t.hasAttribute("selected")||t.setAttribute("selected",""):t.removeAttribute("selected")}function lr(t,e,r,n){var i=kse(t);Bn&&(i[e]=t.getAttribute(e),e==="src"||e==="srcset"||e==="href"&&t.nodeName===Lht)||i[e]!==(i[e]=r)&&(e==="loading"&&(t[idt]=r),r==null?t.removeAttribute(e):typeof r!="string"&&eNe(t).includes(e)?t[e]=r:t.setAttribute(e,r))}function Ght(t,e,r,n,i=!1,a=!1){if(Bn&&i&&t.nodeName===G0e){var s=t,o=s.type==="checkbox"?"defaultChecked":"defaultValue";o in r||Uht(s)}var l=kse(t),u=l[Q8e],d=!l[Z8e];let h=Bn&&u;h&&_c(!1);var f=e||{},p=t.nodeName===Pht;for(var g in e)g in r||(r[g]=null);r.class?r.class=dn(r.class):(n||r[hA])&&(r.class=null),r[xE]&&(r.style??=null);var m=eNe(t);if(t.nodeName===G0e&&"type"in r&&("value"in r||"__value"in r)){var _=r.type;(_!==f.type||_===void 0&&t.hasAttribute("type"))&&(f.type=_,lr(t,"type",_))}for(const w in r){let x=r[w];if(p&&w==="value"&&x==null){t.value=t.__value="",f[w]=x;continue}if(w==="class"){var v=t.namespaceURI==="http://www.w3.org/1999/xhtml";Yt(t,v,x,n,e?.[hA],r[hA]),f[w]=x,f[hA]=r[hA];continue}if(w==="style"){zs(t,x,e?.[xE],r[xE]),f[w]=x,f[xE]=r[xE];continue}var b=f[w];if(!(x===b&&!(x===void 0&&t.hasAttribute(w)))){f[w]=x;var y=w[0]+w[1];if(y!=="$$")if(y==="on"){const A={},R="$$"+w;let O=w.slice(2);var E=fht(O);if(dht(O)&&(O=O.slice(0,-7),A.capture=!0),!E&&b){if(x!=null)continue;t.removeEventListener(O,f[R],A),f[R]=null}if(E)Kr(O,t,x),Hi([O]);else if(x!=null){let F=function(P){f[w].call(this,P)};f[R]=Ose(O,t,F,A)}}else if(w==="style")lr(t,w,x);else if(w==="autofocus")tht(t,!!x);else if(!u&&(w==="__value"||w==="value"&&x!=null))t.value=t.__value=x;else if(w==="selected"&&p)$ht(t,x);else{var T=w;d||(T=ght(T));var C=T==="defaultValue"||T==="defaultChecked";if(x==null&&!u&&!C)if(l[w]=null,T==="value"||T==="checked"){let A=t;const R=e===void 0;if(T==="value"){let O=A.defaultValue;A.removeAttribute(T),A.defaultValue=O,A.value=A.__value=R?O:null}else{let O=A.defaultChecked;A.removeAttribute(T),A.defaultChecked=O,A.checked=R?O:!1}}else t.removeAttribute(w);else C||m.includes(T)&&(u||typeof x!="string")?(t[T]=x,T in l&&(l[T]=Vo)):typeof x!="function"&&lr(t,T,x)}}}return h&&_c(!0),f}function Er(t,e,r=[],n=[],i=[],a,s=!1,o=!1){Sse(i,r,n,l=>{var u=void 0,d={},h=t.nodeName===Fht,f=!1;if(R8e(()=>{var g=e(...l.map(S)),m=Ght(t,u,g,a,s,o);f&&h&&"value"in g&&nJ(t,g.value);for(let v of Object.getOwnPropertySymbols(d))g[v]||zl(d[v]);for(let v of Object.getOwnPropertySymbols(g)){var _=g[v];v.description===e8e&&(!u||_!==u[v])&&(d[v]&&zl(d[v]),d[v]=yu(()=>Iht(t,()=>_))),m[v]=_}u=m}),h){var p=t;u4(()=>{nJ(p,u.value,!0),Mht(p)})}f=!0})}function kse(t){return t[X7e]??={[Q8e]:t.nodeName.includes("-"),[Z8e]:t.namespaceURI===Z7e}}var z0e=new Map;function eNe(t){var e=t.getAttribute("is")||t.nodeName,r=z0e.get(e);if(r)return r;z0e.set(e,r=[]);for(var n,i=t,a=Element.prototype;a!==i;){n=H7e(i);for(var s in n)n[s].set&&s!=="innerHTML"&&s!=="textContent"&&s!=="innerText"&&r.push(s);i=eU(i)}return r}function wR(t,e,r=e){var n=new WeakSet;w8e(t,"input",async i=>{var a=i?t.defaultValue:t.value;if(a=Jq(t)?eH(a):a,r(a),ra!==null&&n.add(ra),await hh(),a!==(a=e())){var s=t.selectionStart,o=t.selectionEnd,l=t.value.length;if(t.value=a??"",o!==null){var u=t.value.length;s===o&&o===l&&u>l?(t.selectionStart=u,t.selectionEnd=u):(t.selectionStart=s,t.selectionEnd=Math.min(o,u))}}}),(Bn&&t.defaultValue!==t.value||zi(e)==null&&t.value)&&(r(Jq(t)?eH(t.value):t.value),ra!==null&&n.add(ra)),sU(()=>{var i=e();if(t===document.activeElement){var a=ra;if(n.has(a))return}Jq(t)&&i===eH(t.value)||t.type==="date"&&!i&&!t.value||i!==t.value&&(t.value=i??"")})}function Jq(t){var e=t.type;return e==="number"||e==="range"}function eH(t){return t===""?null:+t}function zht(t,e,r=e){w8e(t,"change",()=>{r(t.files)}),Bn&&t.files&&r(t.files),sU(()=>{t.files=e()})}function tH(t,e){return t===e||t?.[Mg]===e}function Jr(t={},e,r,n){var i=ss.r,a=Ui;return u4(()=>{var s,o;return sU(()=>{s=o,o=[],zi(()=>{tH(r(...o),t)||(e(t,...o),s&&tH(r(...s),t)&&e(null,...s))})}),()=>{let l=a;for(;l!==i&&l.parent!==null&&l.parent.f&qZ;)l=l.parent;const u=()=>{o&&tH(r(...o),t)&&e(null,...o)},d=l.teardown;l.teardown=()=>{u(),d?.()}}}),t}function xR(t,e){rht(window,["resize"],()=>V2(()=>e(window[t])))}function d4(t=!1){const e=ss,r=e.l.u;if(!r)return;let n=()=>cht(e.s);if(t){let i=0,a={};const s=z5(()=>{let o=!1;const l=e.s;for(const u in l)l[u]!==a[u]&&(a[u]=l[u],o=!0);return o&&i++,i});n=()=>S(s)}r.b.length&&uc(()=>{q0e(e,n),GZ(r.b)}),Kt(()=>{const i=zi(()=>r.m.map(ndt));return()=>{for(const a of i)typeof a=="function"&&a()}}),r.a.length&&Kt(()=>{q0e(e,n),GZ(r.a)})}function q0e(t,e){if(t.l.s)for(const r of t.l.s)S(r);e()}const qht={get(t,e){if(!t.exclude.has(e))return t.props[e]},set(t,e){return!1},getOwnPropertyDescriptor(t,e){if(!t.exclude.has(e)&&e in t.props)return{enumerable:!0,configurable:!0,value:t.props[e]}},has(t,e){return t.exclude.has(e)?!1:e in t.props},ownKeys(t){return Reflect.ownKeys(t.props).filter(e=>!t.exclude.has(e))}};function Tt(t,e,r){return new Proxy({props:t,exclude:e},qht)}const Hht={get(t,e){let r=t.props.length;for(;r--;){let n=t.props[r];if(wE(n)&&(n=n()),typeof n=="object"&&n!==null&&e in n)return n[e]}},set(t,e,r){let n=t.props.length;for(;n--;){let i=t.props[n];wE(i)&&(i=i());const a=O_(i,e);if(a&&a.set)return a.set(r),!0}return!1},getOwnPropertyDescriptor(t,e){let r=t.props.length;for(;r--;){let n=t.props[r];if(wE(n)&&(n=n()),typeof n=="object"&&n!==null&&e in n){const i=O_(n,e);return i&&!i.configurable&&(i.configurable=!0),i}}},has(t,e){if(e===Mg||e===use)return!1;for(let r of t.props)if(wE(r)&&(r=r()),r!=null&&e in r)return!0;return!1},ownKeys(t){const e=[];for(let r of t.props)if(wE(r)&&(r=r()),!!r){for(const n in r)e.includes(n)||e.push(n);for(const n of Object.getOwnPropertySymbols(r))e.includes(n)||e.push(n)}return e}};function Rt(...t){return new Proxy({props:t},Hht)}function ce(t,e,r,n){var i=!a4||(r&Tdt)!==0,a=(r&wdt)!==0,s=(r&xdt)!==0,o=n,l=!0,u=void 0,d=()=>s&&i?(u??=z5(n),S(u)):(l&&(l=!1,o=s?zi(n):n),o);let h;if(a){var f=Mg in t||use in t;h=O_(t,e)?.set??(f&&e in t?E=>t[e]=E:void 0)}var p,g=!1;a?[p,g]=qdt(()=>t[e]):p=t[e],p===void 0&&n!==void 0&&(p=d(),h&&(i&&fdt(),h(p)));var m;if(i?m=()=>{var E=t[e];return E===void 0?d():(l=!0,E)}:m=()=>{var E=t[e];return E!==void 0&&(o=void 0),E===void 0?o:E},i&&(r&Cdt)===0)return m;if(h){var _=t.$$legacy;return(function(E,T){return arguments.length>0?((!i||!T||_||g)&&h(T?m():E),E):m()})}var v=!1,b=((r&Edt)!==0?z5:H_)(()=>(v=!1,m()));a&&S(b);var y=Ui;return(function(E,T){if(arguments.length>0){const C=T?S(b):i&&a?Zr(E):E;return X(b,C),v=!0,o!==void 0&&(o=C),E}return P0&&v||(y.f&ff)!==0?b.v:S(b)})}function Vht(t){return class extends Yht{constructor(e){super({component:t,...e})}}}class Yht{#e;#t;constructor(e){var r=new Map,n=(a,s)=>{var o=Tse(s,!1,!1);return r.set(a,o),o};const i=new Proxy({...e.props||{},$$events:{}},{get(a,s){return S(r.get(s)??n(s,Reflect.get(a,s)))},has(a,s){return s===use?!0:(S(r.get(s)??n(s,Reflect.get(a,s))),Reflect.has(a,s))},set(a,s,o){return X(r.get(s)??n(s,o),o),Reflect.set(a,s,o)}});this.#t=(e.hydrate?H8e:oU)(e.component,{target:e.target,anchor:e.anchor,props:i,context:e.context,intro:e.intro??!1,recover:e.recover,transformError:e.transformError}),(!e?.props?.$$host||e.sync===!1)&&vse(),this.#e=i.$$events;for(const a of Object.keys(this.#t))a==="$set"||a==="$destroy"||a==="$on"||ose(this,a,{get(){return this.#t[a]},set(s){this.#t[a]=s},enumerable:!0});this.#t.$set=a=>{Object.assign(i,a)},this.#t.$destroy=()=>{Ise(this.#t)}}$set(e){this.#t.$set(e)}$on(e,r){this.#e[e]=this.#e[e]||[];const n=(...i)=>r.call(this,...i);return this.#e[e].push(n),()=>{this.#e[e]=this.#e[e].filter(i=>i!==n)}}$destroy(){this.#t.$destroy()}}function uo(t){ss===null&&dse(),a4&&ss.l!==null?Wht(ss).m.push(t):Kt(()=>{const e=zi(t);if(typeof e=="function")return e})}function S8(t){ss===null&&dse(),uo(()=>()=>zi(t))}function Wht(t){var e=t.l;return e.u??={a:[],b:[],m:[]}}const Kht=Object.freeze(Object.defineProperty({__proto__:null,flushSync:vse,getAllContexts:i8e,getContext:q_,hasContext:mse,hydrate:H8e,mount:oU,onDestroy:S8,onMount:uo,setContext:s4,settled:U8e,tick:hh,unmount:Ise,untrack:zi},Symbol.toStringTag,{value:"Module"}));class lU{constructor(e,r){this.status=e,typeof r=="string"?this.body={message:r}:r?this.body=r:this.body={message:`Error: ${e}`}}toString(){return JSON.stringify(this.body)}}class Dse{constructor(e,r){try{new Headers({location:r})}catch{throw new Error(`Invalid redirect location ${JSON.stringify(r)}: this string contains characters that cannot be used in HTTP headers`)}this.status=e,this.location=r}}class Mse extends Error{constructor(e,r,n){super(n),this.status=e,this.text=r}}new URL("sveltekit-internal://");function jht(t,e){return t==="/"||e==="ignore"?t:e==="never"?t.endsWith("/")?t.slice(0,-1):t:e==="always"&&!t.endsWith("/")?t+"/":t}function Xht(t){return t.split("%25").map(decodeURI).join("%25")}function Qht(t){for(const e in t)t[e]=decodeURIComponent(t[e]);return t}function rH({href:t}){return t.split("#")[0]}function Zht(t,e,r,n=!1){const i=new URL(t);Object.defineProperty(i,"searchParams",{value:new Proxy(i.searchParams,{get(s,o){if(o==="get"||o==="getAll"||o==="has")return(u,...d)=>(r(u),s[o](u,...d));e();const l=Reflect.get(s,o);return typeof l=="function"?l.bind(s):l}}),enumerable:!0,configurable:!0});const a=["href","pathname","search","toString","toJSON"];n&&a.push("hash");for(const s of a)Object.defineProperty(i,s,{get(){return e(),t[s]},enumerable:!0,configurable:!0});return i}function x0(){}function Jht(...t){let e=5381;for(const r of t)if(typeof r=="string"){let n=r.length;for(;n;)e=e*33^r.charCodeAt(--n)}else if(ArrayBuffer.isView(r)){const n=new Uint8Array(r.buffer,r.byteOffset,r.byteLength);let i=n.length;for(;i;)e=e*33^n[--i]}else throw new TypeError("value must be a string or TypedArray");return(e>>>0).toString(36)}new TextEncoder;function eft(t){const e=atob(t),r=new Uint8Array(e.length);for(let n=0;n((t instanceof Request?t.method:e?.method||"GET")!=="GET"&&A9.delete(Lse(t)),tft(t,e));const A9=new Map;function rft(t,e){const r=Lse(t,e),n=document.querySelector(r);if(n?.textContent){n.remove();let{body:i,...a}=JSON.parse(n.textContent);n.getAttribute("data-b64")!==null&&(i=eft(i));const o=n.getAttribute("data-ttl");return o&&A9.set(r,{body:i,init:a,ttl:1e3*Number(o)}),Promise.resolve(new Response(i,a))}return window.fetch(t,e)}function nft(t,e,r){if(A9.size>0){const n=Lse(t,r),i=A9.get(n);if(i){if(performance.now(){const i=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(n);if(i)return e.push({name:i[1],matcher:i[2],optional:!1,rest:!0,chained:!0}),"(?:/([^]*))?";const a=/^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(n);if(a)return e.push({name:a[1],matcher:a[2],optional:!0,rest:!1,chained:!0}),"(?:/([^/]+))?";if(!n)return;const s=n.split(/\[(.+?)\](?!\])/);return"/"+s.map((l,u)=>{if(u%2){if(l.startsWith("x+"))return nH(String.fromCharCode(parseInt(l.slice(2),16)));if(l.startsWith("u+"))return nH(String.fromCharCode(...l.slice(2).split("-").map(m=>parseInt(m,16))));const d=ift.exec(l),[,h,f,p,g]=d;return e.push({name:p,matcher:g,optional:!!h,rest:!!f,chained:f?u===1&&s[0]==="":!1}),f?"([^]*?)":h?"([^/]*)?":"([^/]+?)"}return nH(l)}).join("")}).join("")}/?$`),params:e}}function oft(t){return t!==""&&!/^\([^)]+\)$/.test(t)}function lft(t){return t.slice(1).split("/").filter(oft)}function cft(t,e,r){const n={},i=t.slice(1),a=i.filter(o=>o!==void 0);let s=0;for(let o=0;od).join("/"),s=0),u===void 0)if(l.rest)u="";else continue;if(!l.matcher||r[l.matcher](u)){n[l.name]=u;const d=e[o+1],h=i[o+1];d&&!d.rest&&d.optional&&h&&l.chained&&(s=0),!d&&!h&&Object.keys(n).length===a.length&&(s=0);continue}if(l.optional&&l.chained){s++;continue}return}if(!s)return n}function nH(t){return t.normalize().replace(/[[\]]/g,"\\$&").replace(/%/g,"%25").replace(/\//g,"%2[Ff]").replace(/\?/g,"%3[Ff]").replace(/#/g,"%23").replace(/[.*+?^${}()|\\]/g,"\\$&")}function uft({nodes:t,server_loads:e,dictionary:r,matchers:n}){const i=new Set(e);return Object.entries(r).map(([o,[l,u,d]])=>{const{pattern:h,params:f}=sft(o),p={id:o,exec:g=>{const m=h.exec(g);if(m)return cft(m,f,n)},errors:[1,...d||[]].map(g=>t[g]),layouts:[0,...u||[]].map(s),leaf:a(l)};return p.errors.length=p.layouts.length=Math.max(p.errors.length,p.layouts.length),p});function a(o){const l=o<0;return l&&(o=~o),[l,t[o]]}function s(o){return o===void 0?o:[i.has(o),t[o]]}}function tNe(t,e=JSON.parse){try{return e(sessionStorage[t])}catch{}}function H0e(t,e,r=JSON.stringify){const n=r(e);try{sessionStorage[t]=n}catch{}}const tl=globalThis.__sveltekit_11g8d1s?.base??"",dft=globalThis.__sveltekit_11g8d1s?.assets??tl??"",hft="1786871242766",rNe="sveltekit:snapshot",nNe="sveltekit:scroll",Pse="sveltekit:states",iNe="sveltekit:pageurl",Hb="sveltekit:history",V5="sveltekit:navigation",Xy={tap:1,hover:2,viewport:3,eager:4,off:-1,false:-1},cU=location.origin;function uU(t){if(t instanceof URL)return t;let e=document.baseURI;if(!e){const r=document.getElementsByTagName("base");e=r.length?r[0].href:document.URL}return new URL(t,e)}function l2(){return{x:pageXOffset,y:pageYOffset}}function jS(t,e){return t.getAttribute(`data-sveltekit-${e}`)}const V0e={...Xy,"":Xy.hover};function aNe(t){let e=t.assignedSlot??t.parentNode;return e?.nodeType===11&&(e=e.host),e}function sNe(t,e){for(;t&&t!==e;){if(t.nodeName.toUpperCase()==="A"&&t.hasAttribute("href"))return t;t=aNe(t)}}function iJ(t,e,r){let n;try{if(n=new URL(t instanceof SVGAElement?t.href.baseVal:t.href,document.baseURI),r&&n.hash.match(/^#[^/]/)){const o=location.hash.split("#")[1]||"/";n.hash=`#${o}${n.hash}`}}catch{}const i=t instanceof SVGAElement?t.target.baseVal:t.target,a=!n||!!i||dU(n,e,r)||(t.getAttribute("rel")||"").split(/\s+/).includes("external"),s=n?.origin===cU&&t.hasAttribute("download");return{url:n,external:a,target:i,download:s}}function hL(t){let e=null,r=null,n=null,i=null,a=null,s=null,o=t;for(;o&&o!==document.documentElement;)n===null&&(n=jS(o,"preload-code")),i===null&&(i=jS(o,"preload-data")),e===null&&(e=jS(o,"keepfocus")),r===null&&(r=jS(o,"noscroll")),a===null&&(a=jS(o,"reload")),s===null&&(s=jS(o,"replacestate")),o=aNe(o);function l(u){switch(u){case"":case"true":return!0;case"off":case"false":return!1;default:return}}return{preload_code:V0e[n??"off"],preload_data:V0e[i??"off"],keepfocus:l(e),noscroll:l(r),reload:l(a),replace_state:l(s)}}function Y0e(t){const e=nU(t);let r=!0;function n(){r=!0,e.update(s=>s)}function i(s){r=!1,e.set(s)}function a(s){let o;return e.subscribe(l=>{(o===void 0||r&&l!==o)&&s(o=l)})}return{notify:n,set:i,subscribe:a}}const oNe={v:x0};function fft(){const{set:t,subscribe:e}=nU(!1);let r;async function n(){clearTimeout(r);try{const i=await fetch(`${dft}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(!i.ok)return!1;const s=(await i.json()).version!==hft;return s&&(t(!0),oNe.v(),clearTimeout(r)),s}catch{return!1}}return{subscribe:e,check:n}}function dU(t,e,r){return t.origin!==cU||!t.pathname.startsWith(e)?!0:r?t.pathname!==location.pathname:!1}const lNe=new Set(["load","prerender","csr","ssr","trailingSlash","config"]);[...lNe];const pft=new Set([...lNe]);[...pft];function gft(t){return t.filter(e=>e!=null)}function NO(t,e){return t+"/"+e}function Fse(t){return t instanceof lU||t instanceof Mse?t.status:500}function mft(t){return t instanceof Mse?t.text:"Internal Error"}let no,AR,iH;const _ft=uo.toString().includes("$$")||/function \w+\(\) \{\}/.test(uo.toString()),W0e="a:";_ft?(no={data:{},form:null,error:null,params:{},route:{id:null},state:{},status:-1,url:new URL(W0e)},AR={current:null},iH={current:!1}):(no=new class{#e=Oe({});get data(){return S(this.#e)}set data(e){X(this.#e,e)}#t=Oe(null);get form(){return S(this.#t)}set form(e){X(this.#t,e)}#r=Oe(null);get error(){return S(this.#r)}set error(e){X(this.#r,e)}#n=Oe({});get params(){return S(this.#n)}set params(e){X(this.#n,e)}#i=Oe({id:null});get route(){return S(this.#i)}set route(e){X(this.#i,e)}#a=Oe({});get state(){return S(this.#a)}set state(e){X(this.#a,e)}#s=Oe(-1);get status(){return S(this.#s)}set status(e){X(this.#s,e)}#o=Oe(new URL(W0e));get url(){return S(this.#o)}set url(e){X(this.#o,e)}},AR=new class{#e=Oe(null);get current(){return S(this.#e)}set current(e){X(this.#e,e)}},iH=new class{#e=Oe(!1);get current(){return S(this.#e)}set current(e){X(this.#e,e)}},oNe.v=()=>iH.current=!0);function cNe(t){Object.assign(no,t)}const K0e={spanContext(){return vft},setAttribute(){return this},setAttributes(){return this},addEvent(){return this},setStatus(){return this},updateName(){return this},end(){return this},isRecording(){return!1},recordException(){return this},addLink(){return this},addLinks(){return this}},vft={traceId:"",spanId:"",traceFlags:0},{onMount:yft}=Kht,bft=zi??(t=>t()),Sft=new Set(["icon","shortcut icon","apple-touch-icon"]);let fA=null;const Y_=tNe(nNe)??{},RR=tNe(rNe)??{},Pg={url:Y0e({}),page:Y0e({}),navigating:nU(null),updated:fft()};function Bse(t){Y_[t]=l2()}function Eft(t,e){let r=t+1;for(;Y_[r];)delete Y_[r],r+=1;for(r=e+1;RR[r];)delete RR[r],r+=1}function NR(t,e=!1){return e?location.replace(t.href):location.href=t.href,new Promise(x0)}async function uNe(){if("serviceWorker"in navigator){const t=await navigator.serviceWorker.getRegistration(tl||"/");t&&await t.update()}}let Use,aJ,fL,c0,sJ,Rl;const pL=[],gL=[];let of=null;function mL(){of?.fork?.then(t=>t?.discard()),of=null,aT={element:void 0,href:void 0}}const OO=new Map,$se=new Set,Tft=new Set,PT=new Set;let $s={branch:[],error:null,url:null},dNe=!1,_L=!1,j0e=!0,OR=!1,pA=!1,hNe=!1,Gse=!1,zse,Ul,rh,Z1;const vL=new Set,X0e=new Map,Q0e=new Map;async function Cft(t,e,r){if(globalThis.__sveltekit_11g8d1s.data){const{q:a={},p:s={},l:o={},f:l={}}=globalThis.__sveltekit_11g8d1s.data;for(const u in a)a[u];for(const u in o)o[u];for(const u in l)l[u];for(const u in s)s[u]}document.URL!==location.href&&(location.href=location.href),Rl=t,await t.hooks.init?.(),Use=uft(t),c0=document.documentElement,sJ=e,aJ=t.nodes[0],fL=t.nodes[1],aJ(),fL(),Ul=history.state?.[Hb],rh=history.state?.[V5],Ul||(Ul=rh=Date.now(),history.replaceState({...history.state,[Hb]:Ul,[V5]:rh},""));const n=Y_[Ul];function i(){n&&(history.scrollRestoration="manual",scrollTo(n.x,n.y))}r?(i(),await Pft(sJ,r)):(await FT({type:"enter",url:uU(Rl.hash?Uft(new URL(location.href)):location.href),replace_state:!0}),i()),Lft()}function wft(){pL.length=0,Gse=!1}function fNe(t){gL.some(e=>e?.snapshot)&&(RR[t]=gL.map(e=>e?.snapshot?.capture()))}function pNe(t){RR[t]?.forEach((e,r)=>{gL[r]?.snapshot?.restore(e)})}function Z0e(){Bse(Ul),H0e(nNe,Y_),fNe(rh),H0e(rNe,RR)}async function gNe(t,e,r,n){let i,a;e.invalidateAll&&mL(),await FT({type:"goto",url:uU(t),keepfocus:e.keepFocus,noscroll:e.noScroll,replace_state:e.replaceState,state:e.state,redirect_count:r,nav_token:n,accept:()=>{if(e.invalidateAll){Gse=!0,i=new Set;for(const[s,o]of X0e)for(const[l,u]of o)u.resource?.reset(),i.add(NO(s,l));a=new Set;for(const[s,o]of Q0e)for(const l of o.keys())a.add(NO(s,l))}e.invalidate&&e.invalidate.forEach(Mft)}}),e.invalidateAll&&hh().then(hh).then(()=>{for(const[s,o]of X0e)for(const[l,{resource:u}]of o)i?.has(NO(s,l))&&u.start();for(const[s,o]of Q0e)for(const[l,{resource:u}]of o)a?.has(NO(s,l))&&u.reconnect()})}async function xft(t){if(t.id!==of?.id){mL();const e={};vL.add(e),of={id:t.id,token:e,promise:vNe({...t,preload:e}).then(r=>(vL.delete(e),r.type==="loaded"&&r.state.error&&mL(),r)),fork:null}}return of.promise}async function aH(t){const e=(await hU(t,!1))?.route;e&&await Promise.all([...e.layouts,e.leaf].filter(Boolean).map(r=>r[1]()))}async function mNe(t,e,r){const n={params:$s.params,route:{id:$s.route?.id??null},url:new URL(location.href)};if($s={...t.state,nav:n},cNe(t.props.page),zse=new Rl.root({target:e,props:{...t.props,stores:Pg,components:gL},hydrate:r,sync:!1,transformError:void 0}),await Promise.resolve(),r){const i={from:null,to:{...n,scroll:Y_[Ul]??l2()},willUnload:!1,type:"enter",complete:Promise.resolve()};PT.forEach(a=>a(i))}pNe(rh),_L=!0}async function yL({url:t,params:e,branch:r,errors:n,status:i,error:a,route:s,form:o}){let l="never";if(tl&&(t.pathname===tl||t.pathname===tl+"/"))l="always";else for(const g of r)g?.slash!==void 0&&(l=g.slash);t.pathname=jht(t.pathname,l),t.search=t.search;const u={type:"loaded",state:{url:t,params:e,branch:r,error:a,route:s},props:{constructors:gft(r).map(g=>g.node.component),page:pU(no)}};o!==void 0&&(u.props.form=o);let d={},h=!no,f=0;for(let g=0;g(o&&(l.route=!0),f[p])}),params:new Proxy(n,{get:(f,p)=>(o&&l.params.add(p),f[p])}),data:a?.data??null,url:Zht(r,()=>{o&&(l.url=!0)},f=>{o&&l.search_params.add(f)},Rl.hash),async fetch(f,p){f instanceof Request&&(p={body:f.method==="GET"||f.method==="HEAD"?void 0:await f.blob(),cache:f.cache,credentials:f.credentials,headers:[...f.headers].length>0?f?.headers:void 0,integrity:f.integrity,keepalive:f.keepalive,method:f.method,mode:f.mode,redirect:f.redirect,referrer:f.referrer,referrerPolicy:f.referrerPolicy,signal:f.signal,...p});const{resolved:g,promise:m}=_Ne(f,p,r);return o&&d(g.href),m},setHeaders:x0,depends:d,parent(){return o&&(l.parent=!0),e()},untrack(f){o=!1;try{return f()}finally{o=!0}}};s=await u.universal.load.call(null,h)??null}return{node:u,loader:t,server:a,universal:u.universal?.load?{type:"data",data:s,uses:l}:null,data:s??a?.data??null,slash:u.universal?.trailingSlash??a?.slash}}function _Ne(t,e,r){let n=t instanceof Request?t.url:t;const i=new URL(n,r);i.origin===r.origin&&(n=i.href.slice(r.origin.length));const a=_L?nft(n,i.href,e):rft(n,e);return{resolved:i,promise:a}}function Aft(t,e,r,n,i,a){if(Gse)return!0;if(!i)return!1;if(i.parent&&t||i.route&&e||i.url&&r)return!0;for(const s of i.search_params)if(n.has(s))return!0;for(const s of i.params)if(a[s]!==$s.params[s])return!0;for(const s of i.dependencies)if(pL.some(o=>o(new URL(s))))return!0;return!1}function Hse(t,e){return t?.type==="data"?t:t?.type==="skip"?e??null:null}function Rft(t,e){if(!t)return new Set(e.searchParams.keys());const r=new Set([...t.searchParams.keys(),...e.searchParams.keys()]);for(const n of r){const i=t.searchParams.getAll(n),a=e.searchParams.getAll(n);i.every(s=>a.includes(s))&&a.every(s=>i.includes(s))&&r.delete(n)}return r}function Nft({error:t,url:e,route:r,params:n}){return{type:"loaded",state:{error:t,url:e,route:r,params:n,branch:[]},props:{page:pU(no),constructors:[]}}}async function vNe({id:t,invalidating:e,url:r,params:n,route:i,preload:a}){if(of?.id===t)return vL.delete(of.token),of.promise;const{errors:s,layouts:o,leaf:l}=i,u=[...o,l];s.forEach(_=>_?.().catch(x0)),u.forEach(_=>_?.[1]().catch(x0));const d=$s.url?t!==bL($s.url):!1,h=$s.route?i.id!==$s.route.id:!1,f=Rft($s.url,r);let p=!1;const g=u.map(async(_,v)=>{if(!_)return;const b=$s.branch[v];return _[1]===b?.loader&&!Aft(p,h,d,f,b.universal?.uses,n)?b:(p=!0,qse({loader:_[1],url:r,params:n,route:i,parent:async()=>{const E={};for(let T=0;TPromise.resolve({}),server_data_node:Hse(a)}),o={node:await fL(),loader:fL,universal:null,server:null,data:null};return yL({url:r,params:i,branch:[s,o],status:t,error:e,errors:[],route:null})}catch(s){if(s instanceof Dse){await gNe(new URL(s.location,location.href),{},0);return}const o=await Rl.get_error_template(),l=await Y5(s,{url:r,params:i,route:n}),u=String(l?.message??"").replace(/&/g,"&").replace(//g,">"),d=o({status:t,message:u}),h=new DOMParser().parseFromString(d,"text/html");throw document.documentElement.replaceChild(document.adoptNode(h.head),document.head),document.documentElement.replaceChild(document.adoptNode(h.body),document.body),s}}async function Ift(t){const e=t.href;if(OO.has(e))return OO.get(e);let r;try{const n=(async()=>{let i=await Rl.hooks.reroute({url:new URL(t),fetch:async(a,s)=>_Ne(a,s,t).promise})??t;if(typeof i=="string"){const a=new URL(t);Rl.hash?a.hash=i:a.pathname=i,i=a}return i})();OO.set(e,n),r=await n}catch{OO.delete(e);return}return r}async function hU(t,e){if(t&&!dU(t,tl,Rl.hash)){const r=await Ift(t);if(!r)return;const n=kft(r);for(const i of Use){const a=i.exec(n);if(a)return{id:bL(t),invalidating:e,route:i,params:Qht(a),url:t}}}}function kft(t){return Xht(Rl.hash?t.hash.replace(/^#/,"").replace(/[?#].+/,""):t.pathname.slice(tl.length))||"/"}function bL(t){return(Rl.hash?t.hash.replace(/^#/,""):t.pathname)+t.search}function yNe({url:t,type:e,intent:r,delta:n,event:i,scroll:a}){let s=!1;const o=Yse($s,r,t,e,a??null);n!==void 0&&(o.navigation.delta=n),i!==void 0&&(o.navigation.event=i);const l={...o.navigation,cancel:()=>{s=!0,o.reject(new Error("navigation cancelled"))}};return OR||$se.forEach(u=>u(l)),s?null:o}async function FT({type:t,url:e,popped:r,keepfocus:n,noscroll:i,replace_state:a,state:s={},redirect_count:o=0,nav_token:l={},accept:u=x0,block:d=x0,event:h}){const f=Z1;Z1=l;const p=await hU(e,!1),g=t==="enter"?Yse($s,p,e,t):yNe({url:e,type:t,delta:r?.delta,intent:p,scroll:r?.scroll,event:h});if(!g){d(),Z1===l&&(Z1=f);return}const m=Ul,_=rh;u(),OR=!0,_L&&g.navigation.type!=="enter"&&Pg.navigating.set(AR.current=g.navigation);let v=p&&await vNe(p);if(!v){if(dU(e,tl,Rl.hash))return await NR(e,a);v=await bNe(e,{id:null},await Y5(new Mse(404,"Not Found",`Not found: ${e.pathname}`),{url:e,params:{},route:{id:null}}),404,a)}if(e=p?.url||e,Z1!==l){g.reject(new Error("navigation aborted"));return}if(!v)return;if(v.type==="redirect"){if(o<20){await FT({type:t,url:new URL(v.location,e),popped:r,keepfocus:n,noscroll:i,replace_state:a,state:s,redirect_count:o+1,nav_token:l}),g.fulfil(void 0);return}if(v=await Vse({status:500,error:await Y5(new Error("Redirect loop"),{url:e,params:{},route:{id:null}}),url:e,route:{id:null}}),!v)return}else if(v.props.page.status>=400&&await Pg.updated.check())return await uNe(),await NR(e,a);if(wft(),Bse(m),fNe(_),v.props.page.url.pathname!==e.pathname&&(e.pathname=v.props.page.url.pathname),s=r?r.state:s,!r){const w=a?0:1,x={[Hb]:Ul+=w,[V5]:rh+=w,[Pse]:s};(a?history.replaceState:history.pushState).call(history,x,"",e),a||Eft(Ul,rh)}const b=p&&of?.id===p.id?of.fork:null;of?.fork&&!b?mL():(of=null,aT={element:void 0,href:void 0}),v.props.page.state=s;let y;if(_L){const w=(await Promise.all(Array.from(Tft,R=>R(g.navigation)))).filter(R=>typeof R=="function");if(w.length>0){let R=function(){w.forEach(O=>{PT.delete(O)})};w.push(R),w.forEach(O=>{PT.add(O)})}const x=g.navigation.to;$s={...v.state,nav:{params:x.params,route:x.route,url:x.url}},v.props.page&&(v.props.page.url=e),!n&&document.activeElement instanceof HTMLElement&&document.activeElement!==document.body&&document.activeElement.blur();const A=b&&await b;A?y=A.commit():(fA=null,zse.$set(v.props),fA&&Object.assign(v.props.page,fA),cNe(v.props.page),y=U8e?.()),hNe=!0}else await mNe(v,sJ,!1);const{activeElement:E}=document;if(await y,await hh(),await hh(),Z1!==l){g.reject(new Error("navigation aborted"));return}v.props.page&&fA&&Object.assign(v.props.page,fA);let T=null;if(j0e){const w=r?r.scroll:i?l2():null;w?scrollTo(w.x,w.y):(T=e.hash&&document.getElementById(TNe(e)))?T.scrollIntoView():scrollTo(0,0)}const C=document.activeElement!==E&&document.activeElement!==document.body;!n&&!C&&Bft(e,!T),j0e=!0,OR=!1,g.fulfil(void 0),g.navigation.to&&(g.navigation.to.scroll=l2()),PT.forEach(w=>w(g.navigation)),t==="popstate"&&pNe(rh),Pg.navigating.set(AR.current=null)}async function bNe(t,e,r,n,i){return t.origin===cU&&t.pathname===location.pathname&&!dNe?await Vse({status:n,error:r,url:t,route:e}):await NR(t,i)}let aT={element:void 0,href:void 0};function Dft(){let t,e;c0.addEventListener("mousemove",s=>{const o=s.target;clearTimeout(t),t=setTimeout(()=>{i(o,Xy.hover)},20)});function r(s){s.defaultPrevented||i(s.composedPath()[0],Xy.tap)}c0.addEventListener("mousedown",r),c0.addEventListener("touchstart",r,{passive:!0});const n=new IntersectionObserver(s=>{for(const o of s)o.isIntersecting&&(aH(new URL(o.target.href)),n.unobserve(o.target))},{threshold:0});async function i(s,o){const l=sNe(s,c0),u=l===aT.element&&l?.href===aT.href&&o>=e;if(!l||u)return;const{url:d,external:h,download:f}=iJ(l,tl,Rl.hash);if(h||f)return;const p=hL(l),g=d&&bL($s.url)===bL(d);if(!(p.reload||g))if(o<=p.preload_data){aT={element:l,href:l.href},e=Xy.tap;const m=await hU(d,!1);if(!m)return;xft(m)}else o<=p.preload_code&&(aT={element:l,href:l.href},e=o,aH(d))}function a(){n.disconnect();for(const s of c0.querySelectorAll("a")){const{url:o,external:l,download:u}=iJ(s,tl,Rl.hash);if(l||u)continue;const d=hL(s);d.reload||(d.preload_code===Xy.viewport&&n.observe(s),d.preload_code===Xy.eager&&aH(o))}}PT.add(a),a()}function Y5(t,e){if(t instanceof lU)return t.body;const r=Fse(t),n=mft(t);return Rl.hooks.handleError({error:t,event:e,status:r,message:n})??{message:n}}function SNe(t,e){yft(()=>(t.add(e),()=>{t.delete(e)}))}function E8(t){SNe(PT,t)}function ENe(t){SNe($se,t)}function Ga(t,e={}){return t=new URL(uU(t)),t.origin!==cU?Promise.reject(new Error("goto: invalid URL")):gNe(t,e,0)}function Mft(t){if(typeof t=="function")pL.push(t);else{const{href:e}=new URL(t,location.href);pL.push(r=>r.href===e)}}function fU(t,e){const r={[Hb]:Ul,[V5]:rh,[iNe]:no.url.href,[Pse]:e};history.replaceState(r,"",uU(t)),no.state=e,zse.$set({page:bft(()=>pU(no))})}function Lft(){history.scrollRestoration="manual",addEventListener("beforeunload",e=>{let r=!1;if(Z0e(),!OR){const n=Yse($s,void 0,null,"leave"),i={...n.navigation,cancel:()=>{r=!0,n.reject(new Error("navigation cancelled"))}};$se.forEach(a=>a(i))}r?(e.preventDefault(),e.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{document.visibilityState==="hidden"&&Z0e()}),navigator.connection?.saveData||Dft(),c0.addEventListener("click",async e=>{if(e.button||e.which!==1||e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.defaultPrevented)return;const r=sNe(e.composedPath()[0],c0);if(!r)return;const{url:n,external:i,target:a,download:s}=iJ(r,tl,Rl.hash);if(!n)return;if(a==="_parent"||a==="_top"){if(window.parent!==window)return}else if(a&&a!=="_self")return;const o=hL(r);if(!(r instanceof SVGAElement)&&n.protocol!==location.protocol&&!(n.protocol==="https:"||n.protocol==="http:")||s)return;const[u,d]=(Rl.hash?n.hash.replace(/^#/,""):n.href).split("#"),h=u===rH(location);if(i||o.reload&&(!h||!d)){yNe({url:n,type:"link",event:e})?OR=!0:e.preventDefault();return}if(d!==void 0&&h){const[,f]=$s.url.href.split("#");if(f===d){if(e.preventDefault(),d===""||d==="top"&&r.ownerDocument.getElementById("top")===null)scrollTo({top:0});else{const p=r.ownerDocument.getElementById(decodeURIComponent(d));p&&(p.scrollIntoView(),p.focus())}return}if(pA=!0,Bse(Ul),t(n),!o.replace_state)return;pA=!1}e.preventDefault(),await new Promise(f=>{requestAnimationFrame(()=>{setTimeout(f,0)}),setTimeout(f,100)}),await FT({type:"link",url:n,keepfocus:o.keepfocus,noscroll:o.noscroll,replace_state:o.replace_state??n.href===location.href,event:e})}),c0.addEventListener("submit",e=>{if(e.defaultPrevented)return;const r=HTMLFormElement.prototype.cloneNode.call(e.target),n=e.submitter;if((n?.formTarget||r.target)==="_blank"||(n?.formMethod||r.method)!=="get")return;const s=new URL(n?.hasAttribute("formaction")&&n?.formAction||r.action);if(dU(s,tl,!1))return;const o=e.target,l=hL(o);if(l.reload)return;e.preventDefault(),e.stopPropagation();const u=new FormData(o,n);s.search=new URLSearchParams(u).toString(),FT({type:"form",url:s,keepfocus:l.keepfocus,noscroll:l.noscroll,replace_state:l.replace_state??s.href===location.href,event:e})}),addEventListener("popstate",async e=>{if(!oJ){if(e.state?.[Hb]){const r=e.state[Hb];if(Z1={},r===Ul)return;const n=Y_[r],i=e.state[Pse]??{},a=new URL(e.state[iNe]??location.href),s=e.state[V5],o=$s.url?rH(location)===rH($s.url):!1;if(s===rh&&(hNe||o)){i!==no.state&&(no.state=i),t(a),Y_[Ul]=l2(),n&&scrollTo(n.x,n.y),Ul=r;return}const u=r-Ul;await FT({type:"popstate",url:a,popped:{state:i,scroll:n,delta:u},accept:()=>{Ul=r,rh=s},block:()=>{history.go(-u)},nav_token:Z1,event:e})}else if(!pA){const r=new URL(location.href);t(r),Rl.hash&&location.reload()}}}),addEventListener("hashchange",()=>{pA&&(pA=!1,history.replaceState({...history.state,[Hb]:++Ul,[V5]:rh},"",location.href))});for(const e of document.querySelectorAll("link"))Sft.has(e.rel)&&(e.href=e.href);addEventListener("pageshow",e=>{e.persisted&&Pg.navigating.set(AR.current=null)});function t(e){$s.url=no.url=e,Pg.page.set(pU(no)),Pg.page.notify()}}async function Pft(t,{status:e=200,error:r,node_ids:n,params:i,route:a,server_route:s,data:o,form:l}){dNe=!0;const u=new URL(location.href);let d;({params:i={},route:a={id:null}}=await hU(u,!1)||{}),d=Use.find(({id:p})=>p===a.id);let h,f=!0;try{const p=n.map(async(m,_)=>{const v=o[_];return v?.uses&&(v.uses=Fft(v.uses)),qse({loader:Rl.nodes[m],url:u,params:i,route:a,parent:async()=>{const b={};for(let y=0;y<_;y+=1)Object.assign(b,(await p[y]).data);return b},server_data_node:Hse(v)})}),g=await Promise.all(p);if(d){const m=d.layouts;for(let _=0;_{const o=history.state;oJ=!0,location.replace(new URL(`#${n}`,location.href)),history.replaceState(o,"",t),e&&scrollTo(a,s),oJ=!1})}else{const a=document.body,s=a.getAttribute("tabindex");a.tabIndex=-1,a.focus({preventScroll:!0,focusVisible:!1}),s!==null?a.setAttribute("tabindex",s):a.removeAttribute("tabindex")}const i=getSelection();if(i&&i.type!=="None"){const a=[];for(let s=0;s{if(i.rangeCount===a.length){for(let s=0;s{a=u,s=d});return o.catch(x0),{navigation:{from:{params:t.params,route:{id:t.route?.id??null},url:t.url,scroll:l2()},to:r&&{params:e?.params??null,route:{id:e?.route?.id??null},url:r,scroll:i},willUnload:!e,type:n,complete:o},fulfil:a,reject:s}}function pU(t){return{data:t.data,error:t.error,form:t.form,params:t.params,route:t.route,state:t.state,status:t.status,url:t.url}}function Uft(t){const e=new URL(t);return e.hash=decodeURIComponent(t.hash),e}function TNe(t){let e;if(Rl.hash){const[,,r]=t.hash.split("#",3);e=r??""}else e=t.hash.slice(1);return decodeURIComponent(e)}const $ft="modulepreload",Gft=function(t,e){return new URL(t,e).href},J0e={},Fn=function(e,r,n){let i=Promise.resolve();if(r&&r.length>0){let u=function(d){return Promise.all(d.map(h=>Promise.resolve(h).then(f=>({status:"fulfilled",value:f}),f=>({status:"rejected",reason:f}))))};const s=document.getElementsByTagName("link"),o=document.querySelector("meta[property=csp-nonce]"),l=o?.nonce||o?.getAttribute("nonce");i=u(r.map(d=>{if(d=Gft(d,n),d in J0e)return;J0e[d]=!0;const h=d.endsWith(".css"),f=h?'[rel="stylesheet"]':"";if(n)for(let g=s.length-1;g>=0;g--){const m=s[g];if(m.href===d&&(!h||m.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${d}"]${f}`))return;const p=document.createElement("link");if(p.rel=h?"stylesheet":$ft,h||(p.as="script"),p.crossOrigin="",p.href=d,l&&p.setAttribute("nonce",l),document.head.appendChild(p),h)return new Promise((g,m)=>{p.addEventListener("load",g),p.addEventListener("error",()=>m(new Error(`Unable to preload CSS for ${d}`)))})}))}function a(s){const o=new Event("vite:preloadError",{cancelable:!0});if(o.payload=s,window.dispatchEvent(o),!o.defaultPrevented)throw s}return i.then(s=>{for(const o of s||[])o.status==="rejected"&&a(o.reason);return e().catch(a)})},zft={},qft="5";typeof window<"u"&&((window.__svelte??={}).v??=new Set).add(qft);var Hft=se('
'),Vft=se(" ",1);function Yft(t,e){at(e,!0);let r=ce(e,"components",23,()=>[]),n=ce(e,"data_0",3,null),i=ce(e,"data_1",3,null),a=ce(e,"data_2",3,null);uc(()=>e.stores.page.set(e.page)),Kt(()=>{e.stores,e.page,e.constructors,r(),e.form,n(),i(),a(),e.stores.page.notify()});let s=Oe(!1),o=Oe(!1),l=Oe(null);uo(()=>{const _=e.stores.page.subscribe(()=>{S(s)&&(X(o,!0),hh().then(()=>{X(l,document.title||"untitled page",!0)}))});return X(s,!0),_});const u=W(()=>e.constructors[2]);var d=Vft(),h=oe(d);{var f=_=>{const v=W(()=>e.constructors[0]);var b=Ae(),y=oe(b);Me(y,()=>S(v),(E,T)=>{Jr(T(E,{get data(){return n()},get form(){return e.form},get params(){return e.page.params},children:(C,w)=>{var x=Ae(),A=oe(x);{var R=F=>{const P=W(()=>e.constructors[1]);var N=Ae(),k=oe(N);Me(k,()=>S(P),(M,L)=>{Jr(L(M,{get data(){return i()},get form(){return e.form},get params(){return e.page.params},children:(I,U)=>{var B=Ae(),$=oe(B);Me($,()=>S(u),(H,q)=>{Jr(q(H,{get data(){return a()},get form(){return e.form},get params(){return e.page.params}}),V=>r()[2]=V,()=>r()?.[2])}),G(I,B)},$$slots:{default:!0}}),I=>r()[1]=I,()=>r()?.[1])}),G(F,N)},O=F=>{const P=W(()=>e.constructors[1]);var N=Ae(),k=oe(N);Me(k,()=>S(P),(M,L)=>{Jr(L(M,{get data(){return i()},get form(){return e.form},get params(){return e.page.params}}),I=>r()[1]=I,()=>r()?.[1])}),G(F,N)};ve(A,F=>{e.constructors[2]?F(R):F(O,-1)})}G(C,x)},$$slots:{default:!0}}),C=>r()[0]=C,()=>r()?.[0])}),G(_,b)},p=_=>{const v=W(()=>e.constructors[0]);var b=Ae(),y=oe(b);Me(y,()=>S(v),(E,T)=>{Jr(T(E,{get data(){return n()},get form(){return e.form},get params(){return e.page.params}}),C=>r()[0]=C,()=>r()?.[0])}),G(_,b)};ve(h,_=>{e.constructors[1]?_(f):_(p,-1)})}var g=ie(h,2);{var m=_=>{var v=Hft(),b=te(v);{var y=E=>{var T=or();$e(()=>it(T,S(l))),G(E,T)};ve(b,E=>{S(o)&&E(y)})}Z(v),G(_,v)};ve(g,_=>{S(s)&&_(m)})}G(t,d),st()}const Wft=Vht(Yft),Kft=[()=>Fn(()=>Promise.resolve().then(()=>C1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>N1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>k1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>L1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>U1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>q1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>V1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>W1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>X1r),void 0,import.meta.url),()=>Fn(()=>Promise.resolve().then(()=>Z1r),void 0,import.meta.url)],jft=[],Xft={"/(chat)":[4,[2]],"/agents":[6],"/(chat)/chat/[id]":[5,[2]],"/mcp-servers":[7],"/search":[8],"/settings/[[section]]":[9,[3]]},Wse={handleError:(({error:t})=>{console.error(t)}),reroute:(()=>{}),transport:{}},CNe=Object.fromEntries(Object.entries(Wse.transport).map(([t,e])=>[t,e.decode])),Qft=Object.fromEntries(Object.entries(Wse.transport).map(([t,e])=>[t,e.encode])),Zft=!0,Jft=(t,e)=>CNe[t](e),ept=()=>Fn(()=>Promise.resolve().then(()=>e_r),void 0,import.meta.url).then(t=>t.default),tpt=Object.freeze(Object.defineProperty({__proto__:null,decode:Jft,decoders:CNe,dictionary:Xft,encoders:Qft,get_error_template:ept,hash:Zft,hooks:Wse,matchers:zft,nodes:Kft,root:Wft,server_loads:jft},Symbol.toStringTag,{value:"Module"}));function shn(t,e){Cft(tpt,t,e)}const rpt={get data(){return no.data},get error(){return no.error},get form(){return no.form},get params(){return no.params},get route(){return no.route},get state(){return no.state},get status(){return no.status},get url(){return no.url}};Pg.updated.check;const ia=rpt,npt=(t,e)=>{const r=new Array(t.length+e.length);for(let n=0;n({classGroupId:t,validator:e}),wNe=(t=new Map,e=null,r)=>({nextPart:t,validators:e,classGroupId:r}),SL="-",e1e=[],apt="arbitrary..",spt=t=>{const e=lpt(t),{conflictingClassGroups:r,conflictingClassGroupModifiers:n}=t;return{getClassGroupId:s=>{if(s.startsWith("[")&&s.endsWith("]"))return opt(s);const o=s.split(SL),l=o[0]===""&&o.length>1?1:0;return xNe(o,l,e)},getConflictingClassGroupIds:(s,o)=>{if(o){const l=n[s],u=r[s];return l?u?npt(u,l):l:u||e1e}return r[s]||e1e}}},xNe=(t,e,r)=>{if(t.length-e===0)return r.classGroupId;const i=t[e],a=r.nextPart.get(i);if(a){const u=xNe(t,e+1,a);if(u)return u}const s=r.validators;if(s===null)return;const o=e===0?t.join(SL):t.slice(e).join(SL),l=s.length;for(let u=0;ut.slice(1,-1).indexOf(":")===-1?void 0:(()=>{const e=t.slice(1,-1),r=e.indexOf(":"),n=e.slice(0,r);return n?apt+n:void 0})(),lpt=t=>{const{theme:e,classGroups:r}=t;return cpt(r,e)},cpt=(t,e)=>{const r=wNe();for(const n in t){const i=t[n];Kse(i,r,n,e)}return r},Kse=(t,e,r,n)=>{const i=t.length;for(let a=0;a{if(typeof t=="string"){dpt(t,e,r);return}if(typeof t=="function"){hpt(t,e,r,n);return}fpt(t,e,r,n)},dpt=(t,e,r)=>{const n=t===""?e:ANe(e,t);n.classGroupId=r},hpt=(t,e,r,n)=>{if(ppt(t)){Kse(t(n),e,r,n);return}e.validators===null&&(e.validators=[]),e.validators.push(ipt(r,t))},fpt=(t,e,r,n)=>{const i=Object.entries(t),a=i.length;for(let s=0;s{let r=t;const n=e.split(SL),i=n.length;for(let a=0;a"isThemeGetter"in t&&t.isThemeGetter===!0,gpt=t=>{if(t<1)return{get:()=>{},set:()=>{}};let e=0,r=Object.create(null),n=Object.create(null);const i=(a,s)=>{r[a]=s,e++,e>t&&(e=0,n=r,r=Object.create(null))};return{get(a){let s=r[a];if(s!==void 0)return s;if((s=n[a])!==void 0)return i(a,s),s},set(a,s){a in r?r[a]=s:i(a,s)}}},lJ="!",t1e=":",mpt=[],r1e=(t,e,r,n,i)=>({modifiers:t,hasImportantModifier:e,baseClassName:r,maybePostfixModifierPosition:n,isExternal:i}),_pt=t=>{const{prefix:e,experimentalParseClassName:r}=t;let n=i=>{const a=[];let s=0,o=0,l=0,u;const d=i.length;for(let m=0;ml?u-l:void 0;return r1e(a,p,f,g)};if(e){const i=e+t1e,a=n;n=s=>s.startsWith(i)?a(s.slice(i.length)):r1e(mpt,!1,s,void 0,!0)}if(r){const i=n;n=a=>r({className:a,parseClassName:i})}return n},vpt=t=>{const e=new Map;return t.orderSensitiveModifiers.forEach((r,n)=>{e.set(r,1e6+n)}),r=>{const n=[];let i=[];for(let a=0;a0&&(i.sort(),n.push(...i),i=[]),n.push(s)):i.push(s)}return i.length>0&&(i.sort(),n.push(...i)),n}},ypt=t=>({cache:gpt(t.cacheSize),parseClassName:_pt(t),sortModifiers:vpt(t),postfixLookupClassGroupIds:bpt(t),...spt(t)}),bpt=t=>{const e=Object.create(null),r=t.postfixLookupClassGroups;if(r)for(let n=0;n{const{parseClassName:r,getClassGroupId:n,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:s}=e,o=[],l=t.trim().split(Spt);let u="";for(let d=l.length-1;d>=0;d-=1){const h=l[d],{isExternal:f,modifiers:p,hasImportantModifier:g,baseClassName:m,maybePostfixModifierPosition:_}=r(h);if(f){u=h+(u.length>0?" "+u:u);continue}let v=!!_,b;if(v){const w=m.substring(0,_);b=n(w);const x=b&&s[b]?n(m):void 0;x&&x!==b&&(b=x,v=!1)}else b=n(m);if(!b){if(!v){u=h+(u.length>0?" "+u:u);continue}if(b=n(m),!b){u=h+(u.length>0?" "+u:u);continue}v=!1}const y=p.length===0?"":p.length===1?p[0]:a(p).join(":"),E=g?y+lJ:y,T=E+b;if(o.indexOf(T)>-1)continue;o.push(T);const C=i(b,v);for(let w=0;w0?" "+u:u)}return u},Tpt=(...t)=>{let e=0,r,n,i="";for(;e{if(typeof t=="string")return t;let e,r="";for(let n=0;n{let r,n,i,a;const s=l=>{const u=e.reduce((d,h)=>h(d),t());return r=ypt(u),n=r.cache.get,i=r.cache.set,a=o,o(l)},o=l=>{const u=n(l);if(u)return u;const d=Ept(l,r);return i(l,d),d};return a=s,(...l)=>a(Tpt(...l))},Cpt=[],dl=t=>{const e=r=>r[t]||Cpt;return e.isThemeGetter=!0,e},NNe=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,ONe=/^\((?:(\w[\w-]*):)?(.+)\)$/i,wpt=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,xpt=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,Apt=/\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/,Rpt=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,Npt=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,Opt=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,U1=t=>wpt.test(t),Ki=t=>!!t&&!Number.isNaN(Number(t)),Hp=t=>!!t&&Number.isInteger(Number(t)),sH=t=>t.endsWith("%")&&Ki(t.slice(0,-1)),wm=t=>xpt.test(t),INe=()=>!0,Ipt=t=>Apt.test(t)&&!Rpt.test(t),jse=()=>!1,kpt=t=>Npt.test(t),Dpt=t=>Opt.test(t),Mpt=t=>!Sn(t)&&!wn(t),Lpt=t=>t.startsWith("@container")&&(t[10]==="/"&&t[11]!==void 0||t[11]==="s"&&t[16]!==void 0&&t.startsWith("-size/",10)||t[11]==="n"&&t[18]!==void 0&&t.startsWith("-normal/",10)),Ppt=t=>wv(t,MNe,jse),Sn=t=>NNe.test(t),ey=t=>wv(t,LNe,Ipt),n1e=t=>wv(t,Hpt,Ki),Fpt=t=>wv(t,FNe,INe),Bpt=t=>wv(t,PNe,jse),i1e=t=>wv(t,kNe,jse),Upt=t=>wv(t,DNe,Dpt),IO=t=>wv(t,BNe,kpt),wn=t=>ONe.test(t),gA=t=>W2(t,LNe),$pt=t=>W2(t,PNe),a1e=t=>W2(t,kNe),Gpt=t=>W2(t,MNe),zpt=t=>W2(t,DNe),kO=t=>W2(t,BNe,!0),qpt=t=>W2(t,FNe,!0),wv=(t,e,r)=>{const n=NNe.exec(t);return n?n[1]?e(n[1]):r(n[2]):!1},W2=(t,e,r=!1)=>{const n=ONe.exec(t);return n?n[1]?e(n[1]):r:!1},kNe=t=>t==="position"||t==="percentage",DNe=t=>t==="image"||t==="url",MNe=t=>t==="length"||t==="size"||t==="bg-size",LNe=t=>t==="length",Hpt=t=>t==="number",PNe=t=>t==="family-name",FNe=t=>t==="number"||t==="weight",BNe=t=>t==="shadow",uJ=()=>{const t=dl("color"),e=dl("font"),r=dl("text"),n=dl("font-weight"),i=dl("tracking"),a=dl("leading"),s=dl("breakpoint"),o=dl("container"),l=dl("spacing"),u=dl("radius"),d=dl("shadow"),h=dl("inset-shadow"),f=dl("text-shadow"),p=dl("drop-shadow"),g=dl("blur"),m=dl("perspective"),_=dl("aspect"),v=dl("ease"),b=dl("animate"),y=()=>["auto","avoid","all","avoid-page","page","left","right","column"],E=()=>["center","top","bottom","left","right","top-left","left-top","top-right","right-top","bottom-right","right-bottom","bottom-left","left-bottom"],T=()=>[...E(),wn,Sn],C=()=>["auto","hidden","clip","visible","scroll"],w=()=>["auto","contain","none"],x=()=>[wn,Sn,l],A=()=>[U1,"full","auto",...x()],R=()=>[Hp,"none","subgrid",wn,Sn],O=()=>["auto",{span:["full",Hp,wn,Sn]},Hp,wn,Sn],F=()=>[Hp,"auto",wn,Sn],P=()=>["auto","min","max","fr",wn,Sn],N=()=>["start","end","center","between","around","evenly","stretch","baseline","center-safe","end-safe"],k=()=>["start","end","center","stretch","center-safe","end-safe"],M=()=>["auto",...x()],L=()=>[U1,"auto","full","dvw","dvh","lvw","lvh","svw","svh","min","max","fit",...x()],I=()=>[U1,"screen","full","dvw","lvw","svw","min","max","fit",...x()],U=()=>[U1,"screen","full","lh","dvh","lvh","svh","min","max","fit",...x()],B=()=>[t,wn,Sn],$=()=>[...E(),a1e,i1e,{position:[wn,Sn]}],H=()=>["no-repeat",{repeat:["","x","y","space","round"]}],q=()=>["auto","cover","contain",Gpt,Ppt,{size:[wn,Sn]}],V=()=>[sH,gA,ey],Y=()=>["","none","full",u,wn,Sn],j=()=>["",Ki,gA,ey],Q=()=>["solid","dashed","dotted","double"],ae=()=>["normal","multiply","screen","overlay","darken","lighten","color-dodge","color-burn","hard-light","soft-light","difference","exclusion","hue","saturation","color","luminosity"],re=()=>[Ki,sH,a1e,i1e],ne=()=>["","none",g,wn,Sn],ee=()=>["none",Ki,wn,Sn],J=()=>["none",Ki,wn,Sn],fe=()=>[Ki,wn,Sn],ue=()=>[U1,"full",...x()];return{cacheSize:500,theme:{animate:["spin","ping","pulse","bounce"],aspect:["video"],blur:[wm],breakpoint:[wm],color:[INe],container:[wm],"drop-shadow":[wm],ease:["in","out","in-out"],font:[Mpt],"font-weight":["thin","extralight","light","normal","medium","semibold","bold","extrabold","black"],"inset-shadow":[wm],leading:["none","tight","snug","normal","relaxed","loose"],perspective:["dramatic","near","normal","midrange","distant","none"],radius:[wm],shadow:[wm],spacing:["px",Ki],text:[wm],"text-shadow":[wm],tracking:["tighter","tight","normal","wide","wider","widest"]},classGroups:{aspect:[{aspect:["auto","square",U1,Sn,wn,_]}],container:["container"],"container-type":[{"@container":["","normal","size",wn,Sn]}],"container-named":[Lpt],columns:[{columns:[Ki,Sn,wn,o]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":["auto","avoid","avoid-page","avoid-column"]}],"box-decoration":[{"box-decoration":["slice","clone"]}],box:[{box:["border","content"]}],display:["block","inline-block","inline","flex","inline-flex","table","inline-table","table-caption","table-cell","table-column","table-column-group","table-footer-group","table-header-group","table-row-group","table-row","flow-root","grid","inline-grid","contents","list-item","hidden"],sr:["sr-only","not-sr-only"],float:[{float:["right","left","none","start","end"]}],clear:[{clear:["left","right","both","none","start","end"]}],isolation:["isolate","isolation-auto"],"object-fit":[{object:["contain","cover","fill","none","scale-down"]}],"object-position":[{object:T()}],overflow:[{overflow:C()}],"overflow-x":[{"overflow-x":C()}],"overflow-y":[{"overflow-y":C()}],overscroll:[{overscroll:w()}],"overscroll-x":[{"overscroll-x":w()}],"overscroll-y":[{"overscroll-y":w()}],position:["static","fixed","absolute","relative","sticky"],inset:[{inset:A()}],"inset-x":[{"inset-x":A()}],"inset-y":[{"inset-y":A()}],start:[{"inset-s":A(),start:A()}],end:[{"inset-e":A(),end:A()}],"inset-bs":[{"inset-bs":A()}],"inset-be":[{"inset-be":A()}],top:[{top:A()}],right:[{right:A()}],bottom:[{bottom:A()}],left:[{left:A()}],visibility:["visible","invisible","collapse"],z:[{z:[Hp,"auto",wn,Sn]}],basis:[{basis:[U1,"full","auto",o,...x()]}],"flex-direction":[{flex:["row","row-reverse","col","col-reverse"]}],"flex-wrap":[{flex:["nowrap","wrap","wrap-reverse"]}],flex:[{flex:[Ki,U1,"auto","initial","none",Sn]}],grow:[{grow:["",Ki,wn,Sn]}],shrink:[{shrink:["",Ki,wn,Sn]}],order:[{order:[Hp,"first","last","none",wn,Sn]}],"grid-cols":[{"grid-cols":R()}],"col-start-end":[{col:O()}],"col-start":[{"col-start":F()}],"col-end":[{"col-end":F()}],"grid-rows":[{"grid-rows":R()}],"row-start-end":[{row:O()}],"row-start":[{"row-start":F()}],"row-end":[{"row-end":F()}],"grid-flow":[{"grid-flow":["row","col","dense","row-dense","col-dense"]}],"auto-cols":[{"auto-cols":P()}],"auto-rows":[{"auto-rows":P()}],gap:[{gap:x()}],"gap-x":[{"gap-x":x()}],"gap-y":[{"gap-y":x()}],"justify-content":[{justify:[...N(),"normal"]}],"justify-items":[{"justify-items":[...k(),"normal"]}],"justify-self":[{"justify-self":["auto",...k()]}],"align-content":[{content:["normal",...N()]}],"align-items":[{items:[...k(),{baseline:["","last"]}]}],"align-self":[{self:["auto",...k(),{baseline:["","last"]}]}],"place-content":[{"place-content":N()}],"place-items":[{"place-items":[...k(),"baseline"]}],"place-self":[{"place-self":["auto",...k()]}],p:[{p:x()}],px:[{px:x()}],py:[{py:x()}],ps:[{ps:x()}],pe:[{pe:x()}],pbs:[{pbs:x()}],pbe:[{pbe:x()}],pt:[{pt:x()}],pr:[{pr:x()}],pb:[{pb:x()}],pl:[{pl:x()}],m:[{m:M()}],mx:[{mx:M()}],my:[{my:M()}],ms:[{ms:M()}],me:[{me:M()}],mbs:[{mbs:M()}],mbe:[{mbe:M()}],mt:[{mt:M()}],mr:[{mr:M()}],mb:[{mb:M()}],ml:[{ml:M()}],"space-x":[{"space-x":x()}],"space-x-reverse":["space-x-reverse"],"space-y":[{"space-y":x()}],"space-y-reverse":["space-y-reverse"],size:[{size:L()}],"inline-size":[{inline:["auto",...I()]}],"min-inline-size":[{"min-inline":["auto",...I()]}],"max-inline-size":[{"max-inline":["none",...I()]}],"block-size":[{block:["auto",...U()]}],"min-block-size":[{"min-block":["auto",...U()]}],"max-block-size":[{"max-block":["none",...U()]}],w:[{w:[o,"screen",...L()]}],"min-w":[{"min-w":[o,"screen","none",...L()]}],"max-w":[{"max-w":[o,"screen","none","prose",{screen:[s]},...L()]}],h:[{h:["screen","lh",...L()]}],"min-h":[{"min-h":["screen","lh","none",...L()]}],"max-h":[{"max-h":["screen","lh",...L()]}],"font-size":[{text:["base",r,gA,ey]}],"font-smoothing":["antialiased","subpixel-antialiased"],"font-style":["italic","not-italic"],"font-weight":[{font:[n,qpt,Fpt]}],"font-stretch":[{"font-stretch":["ultra-condensed","extra-condensed","condensed","semi-condensed","normal","semi-expanded","expanded","extra-expanded","ultra-expanded",sH,Sn]}],"font-family":[{font:[$pt,Bpt,e]}],"font-features":[{"font-features":[Sn]}],"fvn-normal":["normal-nums"],"fvn-ordinal":["ordinal"],"fvn-slashed-zero":["slashed-zero"],"fvn-figure":["lining-nums","oldstyle-nums"],"fvn-spacing":["proportional-nums","tabular-nums"],"fvn-fraction":["diagonal-fractions","stacked-fractions"],tracking:[{tracking:[i,wn,Sn]}],"line-clamp":[{"line-clamp":[Ki,"none",wn,n1e]}],leading:[{leading:[a,...x()]}],"list-image":[{"list-image":["none",wn,Sn]}],"list-style-position":[{list:["inside","outside"]}],"list-style-type":[{list:["disc","decimal","none",wn,Sn]}],"text-alignment":[{text:["left","center","right","justify","start","end"]}],"placeholder-color":[{placeholder:B()}],"text-color":[{text:B()}],"text-decoration":["underline","overline","line-through","no-underline"],"text-decoration-style":[{decoration:[...Q(),"wavy"]}],"text-decoration-thickness":[{decoration:[Ki,"from-font","auto",wn,ey]}],"text-decoration-color":[{decoration:B()}],"underline-offset":[{"underline-offset":[Ki,"auto",wn,Sn]}],"text-transform":["uppercase","lowercase","capitalize","normal-case"],"text-overflow":["truncate","text-ellipsis","text-clip"],"text-wrap":[{text:["wrap","nowrap","balance","pretty"]}],indent:[{indent:x()}],"tab-size":[{tab:[Hp,wn,Sn]}],"vertical-align":[{align:["baseline","top","middle","bottom","text-top","text-bottom","sub","super",wn,Sn]}],whitespace:[{whitespace:["normal","nowrap","pre","pre-line","pre-wrap","break-spaces"]}],break:[{break:["normal","words","all","keep"]}],wrap:[{wrap:["break-word","anywhere","normal"]}],hyphens:[{hyphens:["none","manual","auto"]}],content:[{content:["none",wn,Sn]}],"bg-attachment":[{bg:["fixed","local","scroll"]}],"bg-clip":[{"bg-clip":["border","padding","content","text"]}],"bg-origin":[{"bg-origin":["border","padding","content"]}],"bg-position":[{bg:$()}],"bg-repeat":[{bg:H()}],"bg-size":[{bg:q()}],"bg-image":[{bg:["none",{linear:[{to:["t","tr","r","br","b","bl","l","tl"]},Hp,wn,Sn],radial:["",wn,Sn],conic:[Hp,wn,Sn]},zpt,Upt]}],"bg-color":[{bg:B()}],"gradient-from-pos":[{from:V()}],"gradient-via-pos":[{via:V()}],"gradient-to-pos":[{to:V()}],"gradient-from":[{from:B()}],"gradient-via":[{via:B()}],"gradient-to":[{to:B()}],rounded:[{rounded:Y()}],"rounded-s":[{"rounded-s":Y()}],"rounded-e":[{"rounded-e":Y()}],"rounded-t":[{"rounded-t":Y()}],"rounded-r":[{"rounded-r":Y()}],"rounded-b":[{"rounded-b":Y()}],"rounded-l":[{"rounded-l":Y()}],"rounded-ss":[{"rounded-ss":Y()}],"rounded-se":[{"rounded-se":Y()}],"rounded-ee":[{"rounded-ee":Y()}],"rounded-es":[{"rounded-es":Y()}],"rounded-tl":[{"rounded-tl":Y()}],"rounded-tr":[{"rounded-tr":Y()}],"rounded-br":[{"rounded-br":Y()}],"rounded-bl":[{"rounded-bl":Y()}],"border-w":[{border:j()}],"border-w-x":[{"border-x":j()}],"border-w-y":[{"border-y":j()}],"border-w-s":[{"border-s":j()}],"border-w-e":[{"border-e":j()}],"border-w-bs":[{"border-bs":j()}],"border-w-be":[{"border-be":j()}],"border-w-t":[{"border-t":j()}],"border-w-r":[{"border-r":j()}],"border-w-b":[{"border-b":j()}],"border-w-l":[{"border-l":j()}],"divide-x":[{"divide-x":j()}],"divide-x-reverse":["divide-x-reverse"],"divide-y":[{"divide-y":j()}],"divide-y-reverse":["divide-y-reverse"],"border-style":[{border:[...Q(),"hidden","none"]}],"divide-style":[{divide:[...Q(),"hidden","none"]}],"border-color":[{border:B()}],"border-color-x":[{"border-x":B()}],"border-color-y":[{"border-y":B()}],"border-color-s":[{"border-s":B()}],"border-color-e":[{"border-e":B()}],"border-color-bs":[{"border-bs":B()}],"border-color-be":[{"border-be":B()}],"border-color-t":[{"border-t":B()}],"border-color-r":[{"border-r":B()}],"border-color-b":[{"border-b":B()}],"border-color-l":[{"border-l":B()}],"divide-color":[{divide:B()}],"outline-style":[{outline:[...Q(),"none","hidden"]}],"outline-offset":[{"outline-offset":[Ki,wn,Sn]}],"outline-w":[{outline:["",Ki,gA,ey]}],"outline-color":[{outline:B()}],shadow:[{shadow:["","none",d,kO,IO]}],"shadow-color":[{shadow:B()}],"inset-shadow":[{"inset-shadow":["none",h,kO,IO]}],"inset-shadow-color":[{"inset-shadow":B()}],"ring-w":[{ring:j()}],"ring-w-inset":["ring-inset"],"ring-color":[{ring:B()}],"ring-offset-w":[{"ring-offset":[Ki,ey]}],"ring-offset-color":[{"ring-offset":B()}],"inset-ring-w":[{"inset-ring":j()}],"inset-ring-color":[{"inset-ring":B()}],"text-shadow":[{"text-shadow":["none",f,kO,IO]}],"text-shadow-color":[{"text-shadow":B()}],opacity:[{opacity:[Ki,wn,Sn]}],"mix-blend":[{"mix-blend":[...ae(),"plus-darker","plus-lighter"]}],"bg-blend":[{"bg-blend":ae()}],"mask-clip":[{"mask-clip":["border","padding","content","fill","stroke","view"]},"mask-no-clip"],"mask-composite":[{mask:["add","subtract","intersect","exclude"]}],"mask-image-linear-pos":[{"mask-linear":[Ki]}],"mask-image-linear-from-pos":[{"mask-linear-from":re()}],"mask-image-linear-to-pos":[{"mask-linear-to":re()}],"mask-image-linear-from-color":[{"mask-linear-from":B()}],"mask-image-linear-to-color":[{"mask-linear-to":B()}],"mask-image-t-from-pos":[{"mask-t-from":re()}],"mask-image-t-to-pos":[{"mask-t-to":re()}],"mask-image-t-from-color":[{"mask-t-from":B()}],"mask-image-t-to-color":[{"mask-t-to":B()}],"mask-image-r-from-pos":[{"mask-r-from":re()}],"mask-image-r-to-pos":[{"mask-r-to":re()}],"mask-image-r-from-color":[{"mask-r-from":B()}],"mask-image-r-to-color":[{"mask-r-to":B()}],"mask-image-b-from-pos":[{"mask-b-from":re()}],"mask-image-b-to-pos":[{"mask-b-to":re()}],"mask-image-b-from-color":[{"mask-b-from":B()}],"mask-image-b-to-color":[{"mask-b-to":B()}],"mask-image-l-from-pos":[{"mask-l-from":re()}],"mask-image-l-to-pos":[{"mask-l-to":re()}],"mask-image-l-from-color":[{"mask-l-from":B()}],"mask-image-l-to-color":[{"mask-l-to":B()}],"mask-image-x-from-pos":[{"mask-x-from":re()}],"mask-image-x-to-pos":[{"mask-x-to":re()}],"mask-image-x-from-color":[{"mask-x-from":B()}],"mask-image-x-to-color":[{"mask-x-to":B()}],"mask-image-y-from-pos":[{"mask-y-from":re()}],"mask-image-y-to-pos":[{"mask-y-to":re()}],"mask-image-y-from-color":[{"mask-y-from":B()}],"mask-image-y-to-color":[{"mask-y-to":B()}],"mask-image-radial":[{"mask-radial":[wn,Sn]}],"mask-image-radial-from-pos":[{"mask-radial-from":re()}],"mask-image-radial-to-pos":[{"mask-radial-to":re()}],"mask-image-radial-from-color":[{"mask-radial-from":B()}],"mask-image-radial-to-color":[{"mask-radial-to":B()}],"mask-image-radial-shape":[{"mask-radial":["circle","ellipse"]}],"mask-image-radial-size":[{"mask-radial":[{closest:["side","corner"],farthest:["side","corner"]}]}],"mask-image-radial-pos":[{"mask-radial-at":E()}],"mask-image-conic-pos":[{"mask-conic":[Ki]}],"mask-image-conic-from-pos":[{"mask-conic-from":re()}],"mask-image-conic-to-pos":[{"mask-conic-to":re()}],"mask-image-conic-from-color":[{"mask-conic-from":B()}],"mask-image-conic-to-color":[{"mask-conic-to":B()}],"mask-mode":[{mask:["alpha","luminance","match"]}],"mask-origin":[{"mask-origin":["border","padding","content","fill","stroke","view"]}],"mask-position":[{mask:$()}],"mask-repeat":[{mask:H()}],"mask-size":[{mask:q()}],"mask-type":[{"mask-type":["alpha","luminance"]}],"mask-image":[{mask:["none",wn,Sn]}],filter:[{filter:["","none",wn,Sn]}],blur:[{blur:ne()}],brightness:[{brightness:[Ki,wn,Sn]}],contrast:[{contrast:[Ki,wn,Sn]}],"drop-shadow":[{"drop-shadow":["","none",p,kO,IO]}],"drop-shadow-color":[{"drop-shadow":B()}],grayscale:[{grayscale:["",Ki,wn,Sn]}],"hue-rotate":[{"hue-rotate":[Ki,wn,Sn]}],invert:[{invert:["",Ki,wn,Sn]}],saturate:[{saturate:[Ki,wn,Sn]}],sepia:[{sepia:["",Ki,wn,Sn]}],"backdrop-filter":[{"backdrop-filter":["","none",wn,Sn]}],"backdrop-blur":[{"backdrop-blur":ne()}],"backdrop-brightness":[{"backdrop-brightness":[Ki,wn,Sn]}],"backdrop-contrast":[{"backdrop-contrast":[Ki,wn,Sn]}],"backdrop-grayscale":[{"backdrop-grayscale":["",Ki,wn,Sn]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Ki,wn,Sn]}],"backdrop-invert":[{"backdrop-invert":["",Ki,wn,Sn]}],"backdrop-opacity":[{"backdrop-opacity":[Ki,wn,Sn]}],"backdrop-saturate":[{"backdrop-saturate":[Ki,wn,Sn]}],"backdrop-sepia":[{"backdrop-sepia":["",Ki,wn,Sn]}],"border-collapse":[{border:["collapse","separate"]}],"border-spacing":[{"border-spacing":x()}],"border-spacing-x":[{"border-spacing-x":x()}],"border-spacing-y":[{"border-spacing-y":x()}],"table-layout":[{table:["auto","fixed"]}],caption:[{caption:["top","bottom"]}],transition:[{transition:["","all","colors","opacity","shadow","transform","none",wn,Sn]}],"transition-behavior":[{transition:["normal","discrete"]}],duration:[{duration:[Ki,"initial",wn,Sn]}],ease:[{ease:["linear","initial",v,wn,Sn]}],delay:[{delay:[Ki,wn,Sn]}],animate:[{animate:["none",b,wn,Sn]}],backface:[{backface:["hidden","visible"]}],perspective:[{perspective:[m,wn,Sn]}],"perspective-origin":[{"perspective-origin":T()}],rotate:[{rotate:ee()}],"rotate-x":[{"rotate-x":ee()}],"rotate-y":[{"rotate-y":ee()}],"rotate-z":[{"rotate-z":ee()}],scale:[{scale:J()}],"scale-x":[{"scale-x":J()}],"scale-y":[{"scale-y":J()}],"scale-z":[{"scale-z":J()}],"scale-3d":["scale-3d"],skew:[{skew:fe()}],"skew-x":[{"skew-x":fe()}],"skew-y":[{"skew-y":fe()}],transform:[{transform:[wn,Sn,"","none","gpu","cpu"]}],"transform-origin":[{origin:T()}],"transform-style":[{transform:["3d","flat"]}],translate:[{translate:ue()}],"translate-x":[{"translate-x":ue()}],"translate-y":[{"translate-y":ue()}],"translate-z":[{"translate-z":ue()}],"translate-none":["translate-none"],zoom:[{zoom:[Hp,wn,Sn]}],accent:[{accent:B()}],appearance:[{appearance:["none","auto"]}],"caret-color":[{caret:B()}],"color-scheme":[{scheme:["normal","dark","light","light-dark","only-dark","only-light"]}],cursor:[{cursor:["auto","default","pointer","wait","text","move","help","not-allowed","none","context-menu","progress","cell","crosshair","vertical-text","alias","copy","no-drop","grab","grabbing","all-scroll","col-resize","row-resize","n-resize","e-resize","s-resize","w-resize","ne-resize","nw-resize","se-resize","sw-resize","ew-resize","ns-resize","nesw-resize","nwse-resize","zoom-in","zoom-out",wn,Sn]}],"field-sizing":[{"field-sizing":["fixed","content"]}],"pointer-events":[{"pointer-events":["auto","none"]}],resize:[{resize:["none","","y","x"]}],"scroll-behavior":[{scroll:["auto","smooth"]}],"scrollbar-thumb-color":[{"scrollbar-thumb":B()}],"scrollbar-track-color":[{"scrollbar-track":B()}],"scrollbar-gutter":[{"scrollbar-gutter":["auto","stable","both"]}],"scrollbar-w":[{scrollbar:["auto","thin","none"]}],"scroll-m":[{"scroll-m":x()}],"scroll-mx":[{"scroll-mx":x()}],"scroll-my":[{"scroll-my":x()}],"scroll-ms":[{"scroll-ms":x()}],"scroll-me":[{"scroll-me":x()}],"scroll-mbs":[{"scroll-mbs":x()}],"scroll-mbe":[{"scroll-mbe":x()}],"scroll-mt":[{"scroll-mt":x()}],"scroll-mr":[{"scroll-mr":x()}],"scroll-mb":[{"scroll-mb":x()}],"scroll-ml":[{"scroll-ml":x()}],"scroll-p":[{"scroll-p":x()}],"scroll-px":[{"scroll-px":x()}],"scroll-py":[{"scroll-py":x()}],"scroll-ps":[{"scroll-ps":x()}],"scroll-pe":[{"scroll-pe":x()}],"scroll-pbs":[{"scroll-pbs":x()}],"scroll-pbe":[{"scroll-pbe":x()}],"scroll-pt":[{"scroll-pt":x()}],"scroll-pr":[{"scroll-pr":x()}],"scroll-pb":[{"scroll-pb":x()}],"scroll-pl":[{"scroll-pl":x()}],"snap-align":[{snap:["start","end","center","align-none"]}],"snap-stop":[{snap:["normal","always"]}],"snap-type":[{snap:["none","x","y","both"]}],"snap-strictness":[{snap:["mandatory","proximity"]}],touch:[{touch:["auto","none","manipulation"]}],"touch-x":[{"touch-pan":["x","left","right"]}],"touch-y":[{"touch-pan":["y","up","down"]}],"touch-pz":["touch-pinch-zoom"],select:[{select:["none","text","all","auto"]}],"will-change":[{"will-change":["auto","scroll","contents","transform",wn,Sn]}],fill:[{fill:["none",...B()]}],"stroke-w":[{stroke:[Ki,gA,ey,n1e]}],stroke:[{stroke:["none",...B()]}],"forced-color-adjust":[{"forced-color-adjust":["auto","none"]}]},conflictingClassGroups:{"container-named":["container-type"],overflow:["overflow-x","overflow-y"],overscroll:["overscroll-x","overscroll-y"],inset:["inset-x","inset-y","inset-bs","inset-be","start","end","top","right","bottom","left"],"inset-x":["right","left"],"inset-y":["top","bottom"],flex:["basis","grow","shrink"],gap:["gap-x","gap-y"],p:["px","py","ps","pe","pbs","pbe","pt","pr","pb","pl"],px:["pr","pl"],py:["pt","pb"],m:["mx","my","ms","me","mbs","mbe","mt","mr","mb","ml"],mx:["mr","ml"],my:["mt","mb"],size:["w","h"],"font-size":["leading"],"fvn-normal":["fvn-ordinal","fvn-slashed-zero","fvn-figure","fvn-spacing","fvn-fraction"],"fvn-ordinal":["fvn-normal"],"fvn-slashed-zero":["fvn-normal"],"fvn-figure":["fvn-normal"],"fvn-spacing":["fvn-normal"],"fvn-fraction":["fvn-normal"],"line-clamp":["display","overflow"],rounded:["rounded-s","rounded-e","rounded-t","rounded-r","rounded-b","rounded-l","rounded-ss","rounded-se","rounded-ee","rounded-es","rounded-tl","rounded-tr","rounded-br","rounded-bl"],"rounded-s":["rounded-ss","rounded-es"],"rounded-e":["rounded-se","rounded-ee"],"rounded-t":["rounded-tl","rounded-tr"],"rounded-r":["rounded-tr","rounded-br"],"rounded-b":["rounded-br","rounded-bl"],"rounded-l":["rounded-tl","rounded-bl"],"border-spacing":["border-spacing-x","border-spacing-y"],"border-w":["border-w-x","border-w-y","border-w-s","border-w-e","border-w-bs","border-w-be","border-w-t","border-w-r","border-w-b","border-w-l"],"border-w-x":["border-w-r","border-w-l"],"border-w-y":["border-w-t","border-w-b"],"border-color":["border-color-x","border-color-y","border-color-s","border-color-e","border-color-bs","border-color-be","border-color-t","border-color-r","border-color-b","border-color-l"],"border-color-x":["border-color-r","border-color-l"],"border-color-y":["border-color-t","border-color-b"],translate:["translate-x","translate-y","translate-none"],"translate-none":["translate","translate-x","translate-y","translate-z"],"scroll-m":["scroll-mx","scroll-my","scroll-ms","scroll-me","scroll-mbs","scroll-mbe","scroll-mt","scroll-mr","scroll-mb","scroll-ml"],"scroll-mx":["scroll-mr","scroll-ml"],"scroll-my":["scroll-mt","scroll-mb"],"scroll-p":["scroll-px","scroll-py","scroll-ps","scroll-pe","scroll-pbs","scroll-pbe","scroll-pt","scroll-pr","scroll-pb","scroll-pl"],"scroll-px":["scroll-pr","scroll-pl"],"scroll-py":["scroll-pt","scroll-pb"],touch:["touch-x","touch-y","touch-pz"],"touch-x":["touch"],"touch-y":["touch"],"touch-pz":["touch"]},conflictingClassGroupModifiers:{"font-size":["leading"]},postfixLookupClassGroups:["container-type"],orderSensitiveModifiers:["*","**","after","backdrop","before","details-content","file","first-letter","first-line","marker","placeholder","selection"]}},Vpt=(t,{cacheSize:e,prefix:r,experimentalParseClassName:n,extend:i={},override:a={}})=>(AE(t,"cacheSize",e),AE(t,"prefix",r),AE(t,"experimentalParseClassName",n),DO(t.theme,a.theme),DO(t.classGroups,a.classGroups),DO(t.conflictingClassGroups,a.conflictingClassGroups),DO(t.conflictingClassGroupModifiers,a.conflictingClassGroupModifiers),AE(t,"postfixLookupClassGroups",a.postfixLookupClassGroups),AE(t,"orderSensitiveModifiers",a.orderSensitiveModifiers),MO(t.theme,i.theme),MO(t.classGroups,i.classGroups),MO(t.conflictingClassGroups,i.conflictingClassGroups),MO(t.conflictingClassGroupModifiers,i.conflictingClassGroupModifiers),dJ(t,i,"postfixLookupClassGroups"),dJ(t,i,"orderSensitiveModifiers"),t),AE=(t,e,r)=>{r!==void 0&&(t[e]=r)},DO=(t,e)=>{if(e)for(const r in e)AE(t,r,e[r])},MO=(t,e)=>{if(e)for(const r in e)dJ(t,e,r)},dJ=(t,e,r)=>{const n=e[r];n!==void 0&&(t[r]=t[r]?t[r].concat(n):n)},Ypt=(t,...e)=>typeof t=="function"?cJ(uJ,t,...e):cJ(()=>Vpt(uJ(),t),...e),UNe=cJ(uJ);function jr(...t){return UNe(x9(t))}var Wpt=/\s+/g,Kpt=t=>typeof t!="string"||!t?t:t.replace(Wpt," ").trim(),EL=(...t)=>{const e=[],r=n=>{if(!n&&n!==0&&n!==0n)return;if(Array.isArray(n)){for(let a=0,s=n.length;a0?Kpt(e.join(" ")):void 0},s1e=t=>t===!1?"false":t===!0?"true":t===0?"0":t,td=t=>{if(!t||typeof t!="object")return!0;for(const e in t)return!1;return!0},jpt=(t,e)=>{if(t===e)return!0;if(!t||!e)return!1;const r=Object.keys(t),n=Object.keys(e);if(r.length!==n.length)return!1;for(let i=0;i{for(const r in e)if(Object.prototype.hasOwnProperty.call(e,r)){const n=e[r];r in t?t[r]=EL(t[r],n):t[r]=n}return t},$Ne=(t,e)=>{for(let r=0;r{const e=[];$Ne(t,e);const r=[];for(let n=0;n{const r={};for(const n in t){const i=t[n];if(n in e){const a=e[n];Array.isArray(i)||Array.isArray(a)?r[n]=GNe(a,i):typeof i=="object"&&typeof a=="object"&&i&&a?r[n]=hJ(i,a):r[n]=a+" "+i}else r[n]=i}for(const n in e)n in t||(r[n]=e[n]);return r},Qpt={twMerge:!0,twMergeConfig:{}};function Zpt(){let t=null,e={},r=!1;return{get cachedTwMerge(){return t},set cachedTwMerge(n){t=n},get cachedTwMergeConfig(){return e},set cachedTwMergeConfig(n){e=n},get didTwMergeConfigChange(){return r},set didTwMergeConfigChange(n){r=n},reset(){t=null,e={},r=!1}}}var e0=Zpt(),Jpt=t=>{const e=(n,i)=>{const{extend:a=null,slots:s={},variants:o={},compoundVariants:l=[],compoundSlots:u=[],defaultVariants:d={}}=n,h={...Qpt,...i},f=a?.base?EL(a.base,n?.base):n?.base,p=a?.variants&&!td(a.variants)?hJ(o,a.variants):o,g=a?.defaultVariants&&!td(a.defaultVariants)?{...a.defaultVariants,...d}:d;!td(h.twMergeConfig)&&!jpt(h.twMergeConfig,e0.cachedTwMergeConfig)&&(e0.didTwMergeConfigChange=!0,e0.cachedTwMergeConfig=h.twMergeConfig);const m=td(a?.slots),_=td(s)?{}:{base:EL(n?.base,m&&a?.base),...s},v=m?_:Xpt({...a?.slots},td(_)?{base:n?.base}:_),b=td(a?.compoundVariants)?l:GNe(a?.compoundVariants,l),y=T=>{if(td(p)&&td(s)&&m)return t(f,T?.class,T?.className)(h);if(b&&!Array.isArray(b))throw new TypeError(`The "compoundVariants" prop must be an array. Received: ${typeof b}`);if(u&&!Array.isArray(u))throw new TypeError(`The "compoundSlots" prop must be an array. Received: ${typeof u}`);const C=(N,k=p,M=null,L=null)=>{const I=k[N];if(!I||td(I))return null;const U=L?.[N]??T?.[N];if(U===null)return null;const B=s1e(U);if(typeof B=="object")return null;const $=g?.[N],H=B??s1e($);return I[H||"false"]},w=()=>{if(!p)return null;const N=Object.keys(p),k=[];for(let M=0;M{if(!p||typeof p!="object")return null;const M=[];for(const L in p){const I=C(L,p,N,k),U=N==="base"&&typeof I=="string"?I:I&&I[N];U&&M.push(U)}return M},A={};for(const N in T){const k=T[N];k!==void 0&&(A[N]=k)}const R=(N,k)=>{const M=typeof T?.[N]=="object"?{[N]:T[N]?.initial}:{};return{...g,...A,...M,...k}},O=(N=[],k)=>{const M=[],L=N.length;for(let I=0;I{const k=O(b,N);if(!Array.isArray(k))return k;const M={},L=t;for(let I=0;I{if(u.length<1)return null;const k={},M=R(null,N);for(let L=0;L{const I=F(L),U=P(L);return k(v[M],x(M,L),I?I[M]:void 0,U?U[M]:void 0,L?.class,L?.className)(h)}}return N}return t(f,w(),O(b),T?.class,T?.className)(h)},E=()=>{if(!(!p||typeof p!="object"))return Object.keys(p)};return y.variantKeys=E(),y.extend=a,y.base=f,y.slots=v,y.variants=p,y.defaultVariants=g,y.compoundSlots=u,y.compoundVariants=b,y};return{tv:e,createTV:n=>(i,a)=>e(i,a?hJ(n,a):n)}},egt=t=>td(t)?UNe:Ypt({...t,extend:{theme:t.theme,classGroups:t.classGroups,conflictingClassGroupModifiers:t.conflictingClassGroupModifiers,conflictingClassGroups:t.conflictingClassGroups,...t.extend}}),tgt=(t,e)=>{const r=EL(t);return!r||!(e?.twMerge??!0)?r:((!e0.cachedTwMerge||e0.didTwMergeConfigChange)&&(e0.didTwMergeConfigChange=!1,e0.cachedTwMerge=egt(e0.cachedTwMergeConfig)),e0.cachedTwMerge(r)||void 0)},rgt=(...t)=>e=>tgt(t,e),{tv:T8}=Jpt(rgt);const W5=T8({base:"focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium outline-none transition-all focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0",defaultVariants:{size:"default",variant:"default"},variants:{size:{default:"h-9 px-4 py-2 has-[>svg]:px-3",icon:"size-9","icon-lg":"size-10","icon-sm":"size-5 rounded-sm",lg:"h-10 rounded-lg px-6 has-[>svg]:px-4",sm:"h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5"},variant:{default:"bg-primary text-primary-foreground shadow-sm hover:bg-primary/90",destructive:"bg-destructive shadow-sm hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white!",ghost:"hover:text-accent-foreground hover:bg-muted-foreground/10 backdrop-blur-sm",link:"text-primary underline-offset-4 hover:underline",outline:"shadow-sm hover:text-accent-foreground hover:bg-muted-foreground/10 backdrop-blur-sm dark:border-input border",secondary:"bg-background dark:bg-muted-foreground/15 dark:text-secondary-foreground shadow-sm text-foreground hover:bg-muted-foreground/20 dark:hover:bg-muted-foreground/25"}}});var ngt=new Set(["$$slots","$$events","$$legacy","children","class","disabled","href","ref","size","type","variant"]),igt=se(""),agt=se("");function Gn(t,e){at(e,!0);let r=ce(e,"href",3,void 0),n=ce(e,"ref",15,null),i=ce(e,"size",3,"default"),a=ce(e,"type",3,"button"),s=ce(e,"variant",3,"default"),o=Tt(e,ngt);var l=Ae(),u=oe(l);{var d=f=>{var p=igt();Er(p,m=>({"data-slot":"button",class:m,href:e.disabled?void 0:r(),"aria-disabled":e.disabled,role:e.disabled?"link":void 0,tabindex:e.disabled?-1:void 0,...o}),[()=>jr(W5({size:i(),variant:s()}),e.class)],void 0,void 0,"svelte-1q39rn8");var g=te(p);Pt(g,()=>e.children??Vt),Z(p),Jr(p,m=>n(m),()=>n()),G(f,p)},h=f=>{var p=agt();Er(p,m=>({"data-slot":"button",class:m,type:a(),disabled:e.disabled,...o}),[()=>jr(W5({size:i(),variant:s()}),e.class)],void 0,void 0,"svelte-1q39rn8");var g=te(p);Pt(g,()=>e.children??Vt),Z(p),Jr(p,m=>n(m),()=>n()),G(f,p)};ve(u,f=>{r()?f(d):f(h,-1)})}G(t,l),st()}function sgt(t){return typeof t=="function"}function C8(t){return t!==null&&typeof t=="object"}const ogt=["string","number","bigint","boolean"];function fJ(t){return t==null||ogt.includes(typeof t)?!0:Array.isArray(t)?t.every(e=>fJ(e)):typeof t=="object"?Object.getPrototypeOf(t)===Object.prototype:!1}const K5=Symbol("box"),gU=Symbol("is-writable");function _t(t,e){const r=W(t);return e?{[K5]:!0,[gU]:!0,get current(){return S(r)},set current(n){e(n)}}:{[K5]:!0,get current(){return t()}}}function w8(t){return C8(t)&&K5 in t}function Xse(t){return w8(t)&&gU in t}function zNe(t){return w8(t)?t:sgt(t)?_t(t):xu(t)}function lgt(t){return Object.entries(t).reduce((e,[r,n])=>w8(n)?(Xse(n)?Object.defineProperty(e,r,{get(){return n.current},set(i){n.current=i}}):Object.defineProperty(e,r,{get(){return n.current}}),e):Object.assign(e,{[r]:n}),{})}function cgt(t){return Xse(t)?{[K5]:!0,get current(){return t.current}}:t}function xu(t){let e=Oe(Zr(t));return{[K5]:!0,[gU]:!0,get current(){return S(e)},set current(r){X(e,r,!0)}}}function K2(t){let e=Oe(Zr(t));return{[K5]:!0,[gU]:!0,get current(){return S(e)},set current(r){X(e,r,!0)}}}K2.from=zNe;K2.with=_t;K2.flatten=lgt;K2.readonly=cgt;K2.isBox=w8;K2.isWritableBox=Xse;function qNe(...t){return function(e){for(const r of t)if(r){if(e.defaultPrevented)return;typeof r=="function"?r.call(this,e):r.current?.call(this,e)}}}var o1e=/\/\*[^*]*\*+([^/*][^*]*\*+)*\//g,ugt=/\n/g,dgt=/^\s*/,hgt=/^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/,fgt=/^:\s*/,pgt=/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/,ggt=/^[;\s]*/,mgt=/^\s+|\s+$/g,_gt=` +`,l1e="/",c1e="*",Qy="",vgt="comment",ygt="declaration";function bgt(t,e){if(typeof t!="string")throw new TypeError("First argument must be a string");if(!t)return[];e=e||{};var r=1,n=1;function i(g){var m=g.match(ugt);m&&(r+=m.length);var _=g.lastIndexOf(_gt);n=~_?g.length-_:n+g.length}function a(){var g={line:r,column:n};return function(m){return m.position=new s(g),u(),m}}function s(g){this.start=g,this.end={line:r,column:n},this.source=e.source}s.prototype.content=t;function o(g){var m=new Error(e.source+":"+r+":"+n+": "+g);if(m.reason=g,m.filename=e.source,m.line=r,m.column=n,m.source=t,!e.silent)throw m}function l(g){var m=g.exec(t);if(m){var _=m[0];return i(_),t=t.slice(_.length),m}}function u(){l(dgt)}function d(g){var m;for(g=g||[];m=h();)m!==!1&&g.push(m);return g}function h(){var g=a();if(!(l1e!=t.charAt(0)||c1e!=t.charAt(1))){for(var m=2;Qy!=t.charAt(m)&&(c1e!=t.charAt(m)||l1e!=t.charAt(m+1));)++m;if(m+=2,Qy===t.charAt(m-1))return o("End of comment missing");var _=t.slice(2,m-2);return n+=2,i(_),t=t.slice(m),n+=2,g({type:vgt,comment:_})}}function f(){var g=a(),m=l(hgt);if(m){if(h(),!l(fgt))return o("property missing ':'");var _=l(pgt),v=g({type:ygt,property:u1e(m[0].replace(o1e,Qy)),value:_?u1e(_[0].replace(o1e,Qy)):Qy});return l(ggt),v}}function p(){var g=[];d(g);for(var m;m=f();)m!==!1&&(g.push(m),d(g));return g}return u(),p()}function u1e(t){return t?t.replace(mgt,Qy):Qy}function Sgt(t,e){let r=null;if(!t||typeof t!="string")return r;const n=bgt(t),i=typeof e=="function";return n.forEach(a=>{if(a.type!=="declaration")return;const{property:s,value:o}=a;i?e(s,o,a):o&&(r=r||{},r[s]=o)}),r}const Egt=/\d/,Tgt=["-","_","/","."];function Cgt(t=""){if(!Egt.test(t))return t!==t.toLowerCase()}function wgt(t){const e=[];let r="",n,i;for(const a of t){const s=Tgt.includes(a);if(s===!0){e.push(r),r="",n=void 0;continue}const o=Cgt(a);if(i===!1){if(n===!1&&o===!0){e.push(r),r=a,n=o;continue}if(n===!0&&o===!1&&r.length>1){const l=r.at(-1);e.push(r.slice(0,Math.max(0,r.length-1))),r=l+a,n=o;continue}}r+=a,n=o,i=s}return e.push(r),e}function HNe(t){return t?wgt(t).map(e=>Agt(e)).join(""):""}function xgt(t){return Rgt(HNe(t||""))}function Agt(t){return t?t[0].toUpperCase()+t.slice(1):""}function Rgt(t){return t?t[0].toLowerCase()+t.slice(1):""}function O6(t){if(!t)return{};const e={};function r(n,i){if(n.startsWith("-moz-")||n.startsWith("-webkit-")||n.startsWith("-ms-")||n.startsWith("-o-")){e[HNe(n)]=i;return}if(n.startsWith("--")){e[n]=i;return}e[xgt(n)]=i}return Sgt(t,r),e}function Vb(...t){return(...e)=>{for(const r of t)typeof r=="function"&&r(...e)}}function Ngt(t,e){const r=RegExp(t,"g");return n=>{if(typeof n!="string")throw new TypeError(`expected an argument of type string, but got ${typeof n}`);return n.match(r)?n.replace(r,e):n}}const Ogt=Ngt(/[A-Z]/,t=>`-${t.toLowerCase()}`);function Igt(t){if(!t||typeof t!="object"||Array.isArray(t))throw new TypeError(`expected an argument of type object, but got ${typeof t}`);return Object.keys(t).map(e=>`${Ogt(e)}: ${t[e]};`).join(` +`)}function Qse(t={}){return Igt(t).replace(` +`," ")}const kgt=["onabort","onanimationcancel","onanimationend","onanimationiteration","onanimationstart","onauxclick","onbeforeinput","onbeforetoggle","onblur","oncancel","oncanplay","oncanplaythrough","onchange","onclick","onclose","oncompositionend","oncompositionstart","oncompositionupdate","oncontextlost","oncontextmenu","oncontextrestored","oncopy","oncuechange","oncut","ondblclick","ondrag","ondragend","ondragenter","ondragleave","ondragover","ondragstart","ondrop","ondurationchange","onemptied","onended","onerror","onfocus","onfocusin","onfocusout","onformdata","ongotpointercapture","oninput","oninvalid","onkeydown","onkeypress","onkeyup","onload","onloadeddata","onloadedmetadata","onloadstart","onlostpointercapture","onmousedown","onmouseenter","onmouseleave","onmousemove","onmouseout","onmouseover","onmouseup","onpaste","onpause","onplay","onplaying","onpointercancel","onpointerdown","onpointerenter","onpointerleave","onpointermove","onpointerout","onpointerover","onpointerup","onprogress","onratechange","onreset","onresize","onscroll","onscrollend","onsecuritypolicyviolation","onseeked","onseeking","onselect","onselectionchange","onselectstart","onslotchange","onstalled","onsubmit","onsuspend","ontimeupdate","ontoggle","ontouchcancel","ontouchend","ontouchmove","ontouchstart","ontransitioncancel","ontransitionend","ontransitionrun","ontransitionstart","onvolumechange","onwaiting","onwebkitanimationend","onwebkitanimationiteration","onwebkitanimationstart","onwebkittransitionend","onwheel"],Dgt=new Set(kgt);function Mgt(t){return Dgt.has(t)}function un(...t){const e={...t[0]};for(let r=1;rl.has(d));u&&eh(o)}return s}delete(e){var r=this.#e,n=r.get(e),i=super.delete(e);return n!==void 0&&(r.delete(e),X(n,-1)),i&&(X(this.#r,super.size),eh(this.#t)),i}clear(){if(super.size!==0){super.clear();var e=this.#e;X(this.#r,0);for(var r of e.values())X(r,-1);eh(this.#t),e.clear()}}#a(){S(this.#t);var e=this.#e;if(this.#r.v!==e.size){for(var r of super.keys())if(!e.has(r)){var n=this.#i(0);e.set(r,n)}}for([,n]of this.#e)S(n)}keys(){return S(this.#t),super.keys()}values(){return this.#a(),super.values()}entries(){return this.#a(),super.entries()}[Symbol.iterator](){return this.entries()}get size(){return S(this.#r),super.size}}class Bgt{#e;#t;constructor(e,r){this.#e=e,this.#t=Tv(r)}get current(){return this.#t(),this.#e()}}const Ugt=/\(.+\)/,$gt=new Set(["all","print","screen","and","or","not","only"]);class WNe extends Bgt{constructor(e,r){let n=Ugt.test(e)||e.split(/[\s,]+/).some(a=>$gt.has(a.trim()))?e:`(${e})`;const i=window.matchMedia(n);super(()=>i.matches,a=>Bi(i,"change",a))}}let Ggt=class{#e;#t;constructor(e={}){const{window:r=YNe,document:n=r?.document}=e;r!==void 0&&(this.#e=n,this.#t=Tv(i=>{const a=Bi(r,"focusin",i),s=Bi(r,"focusout",i);return()=>{a(),s()}}))}get current(){return this.#t?.(),this.#e?Lgt(this.#e):null}};new Ggt;function KNe(t){return typeof t=="function"}function zgt(t,e){if(KNe(t)){const n=t();return n===void 0?e:n}return t===void 0?e:t}let Ys=class{#e;#t;constructor(e){this.#e=e,this.#t=Symbol(e)}get key(){return this.#t}exists(){return mse(this.#t)}get(){const e=q_(this.#t);if(e===void 0)throw new Error(`Context "${this.#e}" not found`);return e}getOr(e){const r=q_(this.#t);return r===void 0?e:r}set(e){return s4(this.#t,e)}};function mU(t,e){let r=Oe(null);const n=W(()=>zgt(e,250));function i(...a){if(S(r))S(r).timeout&&clearTimeout(S(r).timeout);else{let s,o;const l=new Promise((u,d)=>{s=u,o=d});X(r,{timeout:null,runner:null,promise:l,resolve:s,reject:o},!0)}return S(r).runner=async()=>{if(!S(r))return;const s=S(r);X(r,null);try{s.resolve(await t.apply(this,a))}catch(o){s.reject(o)}},S(r).timeout=setTimeout(S(r).runner,S(n)),S(r).promise}return i.cancel=async()=>{(!S(r)||S(r).timeout===null)&&(await new Promise(a=>setTimeout(a,0)),!S(r)||S(r).timeout===null)||(clearTimeout(S(r).timeout),S(r).reject("Cancelled"),X(r,null))},i.runScheduledNow=async()=>{(!S(r)||!S(r).timeout)&&(await new Promise(a=>setTimeout(a,0)),!S(r)||!S(r).timeout)||(clearTimeout(S(r).timeout),S(r).timeout=null,await S(r).runner?.())},Object.defineProperty(i,"pending",{enumerable:!0,get(){return!!S(r)?.timeout}}),i}function qgt(t,e){switch(t){case"post":Kt(e);break;case"pre":uc(e);break}}function jNe(t,e,r,n={}){const{lazy:i=!1}=n;let a=!i,s=Array.isArray(t)?[]:void 0;qgt(e,()=>{const o=Array.isArray(t)?t.map(u=>u()):t();if(!a){a=!0,s=o;return}const l=zi(()=>r(o,s));return s=o,l})}function yi(t,e,r){jNe(t,"post",e,r)}function Hgt(t,e,r){jNe(t,"pre",e,r)}yi.pre=Hgt;function h1e(t){return KNe(t)?t():t}class Vgt{#e={width:0,height:0};#t=!1;#r;#n;#i;#a=W(()=>(S(this.#o)?.(),this.getSize().width));#s=W(()=>(S(this.#o)?.(),this.getSize().height));#o=W(()=>{const e=h1e(this.#n);if(e)return Tv(r=>{if(!this.#i)return;const n=new this.#i.ResizeObserver(i=>{this.#t=!0;for(const a of i){const s=this.#r.box==="content-box"?a.contentBoxSize:a.borderBoxSize,o=Array.isArray(s)?s:[s];this.#e.width=o.reduce((l,u)=>Math.max(l,u.inlineSize),0),this.#e.height=o.reduce((l,u)=>Math.max(l,u.blockSize),0)}r()});return n.observe(e),()=>{this.#t=!1,n.disconnect()}})});constructor(e,r={box:"border-box"}){this.#i=r.window??YNe,this.#r=r,this.#n=e,this.#e={width:0,height:0}}calculateSize(){const e=h1e(this.#n);if(!e||!this.#i)return;const r=e.offsetWidth,n=e.offsetHeight;if(this.#r.box==="border-box")return{width:r,height:n};const i=this.#i.getComputedStyle(e),a=parseFloat(i.paddingLeft)+parseFloat(i.paddingRight),s=parseFloat(i.paddingTop)+parseFloat(i.paddingBottom),o=parseFloat(i.borderLeftWidth)+parseFloat(i.borderRightWidth),l=parseFloat(i.borderTopWidth)+parseFloat(i.borderBottomWidth),u=r-a-o,d=n-s-l;return{width:u,height:d}}getSize(){return this.#t?this.#e:this.calculateSize()??this.#e}get current(){return S(this.#o)?.(),this.getSize()}get width(){return S(this.#a)}get height(){return S(this.#s)}}class Zse{#e=Oe(!1);constructor(){Kt(()=>(zi(()=>X(this.#e,!0)),()=>{X(this.#e,!1)}))}get current(){return S(this.#e)}}class Ygt{#e=()=>{};#t=W(()=>this.#e());constructor(e,r){let n;r!==void 0&&(n=r),this.#e=()=>{try{return n}finally{n=e()}}}get current(){return S(this.#t)}}function Sh(t){Kt(()=>()=>{t()})}function _U(t){Kt(()=>zi(()=>t()))}function vU(t,e){return setTimeout(e,t)}function md(t){hh().then(t)}const Wgt=1,Kgt=9,jgt=11;function pJ(t){return C8(t)&&t.nodeType===Wgt&&typeof t.nodeName=="string"}function XNe(t){return C8(t)&&t.nodeType===Kgt}function Xgt(t){return C8(t)&&t.constructor?.name==="VisualViewport"}function Qgt(t){return C8(t)&&t.nodeType!==void 0}function QNe(t){return Qgt(t)&&t.nodeType===jgt&&"host"in t}function Zgt(t,e){if(!t||!e||!pJ(t)||!pJ(e))return!1;const r=e.getRootNode?.();if(t===e||t.contains(e))return!0;if(r&&QNe(r)){let n=e;for(;n;){if(t===n)return!0;n=n.parentNode||n.host}}return!1}function j2(t){return XNe(t)?t:Xgt(t)?t.document:t?.ownerDocument??document}function Jse(t){return QNe(t)?Jse(t.host):XNe(t)?t.defaultView??window:pJ(t)?t.ownerDocument?.defaultView??window:window}function Jgt(t){let e=t.activeElement;for(;e?.shadowRoot;){const r=e.shadowRoot.activeElement;if(r===e)break;e=r}return e}class wf{element;#e=W(()=>this.element.current?this.element.current.getRootNode()??document:document);get root(){return S(this.#e)}set root(e){X(this.#e,e)}constructor(e){typeof e=="function"?this.element=_t(e):this.element=e}getDocument=()=>j2(this.root);getWindow=()=>this.getDocument().defaultView??window;getActiveElement=()=>Jgt(this.root);isActiveElement=e=>e===this.getActiveElement();getElementById(e){return this.root.getElementById(e)}querySelector=e=>this.root?this.root.querySelector(e):null;querySelectorAll=e=>this.root?this.root.querySelectorAll(e):[];setTimeout=(e,r)=>this.getWindow().setTimeout(e,r);clearTimeout=e=>this.getWindow().clearTimeout(e)}function $i(t,e){return{[uht()]:r=>w8(t)?(t.current=r,zi(()=>e?.(r)),()=>{"isConnected"in r&&r.isConnected||(t.current=null,e?.(null))}):(t(r),zi(()=>e?.(r)),()=>{"isConnected"in r&&r.isConnected||(t(null),e?.(null))})}}function vf(t){return t?"true":"false"}function emt(t){return t?"true":void 0}function Uo(t){return t?"":void 0}function gJ(t){return t?!0:void 0}function Eh(t){return t?"open":"closed"}function tmt(t){return t?"checked":"unchecked"}function xv(t){return t==="starting"?{"data-starting-style":""}:t==="ending"?{"data-ending-style":""}:{}}function eoe(t,e){return e?"mixed":t?"true":"false"}class rmt{#e;#t;attrs;constructor(e){this.#e=e.getVariant?e.getVariant():null,this.#t=this.#e?`data-${this.#e}-`:`data-${e.component}-`,this.getAttr=this.getAttr.bind(this),this.selector=this.selector.bind(this),this.attrs=Object.fromEntries(e.parts.map(r=>[r,this.getAttr(r)]))}getAttr(e,r){return r?`data-${r}-${e}`:`${this.#t}${e}`}selector(e,r){return`[${this.getAttr(e,r)}]`}}function xf(t){const e=new rmt(t);return{...e.attrs,selector:e.selector,getAttr:e.getAttr}}const wg="ArrowDown",x8="ArrowLeft",A8="ArrowRight",yg="ArrowUp",yU="End",Kg="Enter",nmt="Escape",bU="Home",toe="PageDown",roe="PageUp",xd=" ",mJ="Tab";function imt(t){return window.getComputedStyle(t).getPropertyValue("direction")}function amt(t="ltr",e="horizontal"){return{horizontal:t==="rtl"?x8:A8,vertical:wg}[e]}function smt(t="ltr",e="horizontal"){return{horizontal:t==="rtl"?A8:x8,vertical:yg}[e]}function omt(t="ltr",e="horizontal"){return["ltr","rtl"].includes(t)||(t="ltr"),["horizontal","vertical"].includes(e)||(e="horizontal"),{nextKey:amt(t,e),prevKey:smt(t,e)}}const ZNe=typeof document<"u",_J=lmt();function lmt(){return ZNe&&window?.navigator?.userAgent&&(/iP(ad|hone|od)/.test(window.navigator.userAgent)||window?.navigator?.maxTouchPoints>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function wp(t){return t instanceof HTMLElement}function Au(t){return t instanceof Element}function JNe(t){return t instanceof Element||t instanceof SVGElement}function c2(t){return t.pointerType==="touch"}function eOe(t){return t.matches(":focus-visible")}function cmt(t){return t!==null}function umt(t){return t instanceof HTMLInputElement&&"select"in t}class tOe{#e;#t=K2(null);constructor(e){this.#e=e}getCandidateNodes(){return this.#e.rootNode.current?this.#e.candidateSelector?Array.from(this.#e.rootNode.current.querySelectorAll(this.#e.candidateSelector)):this.#e.candidateAttr?Array.from(this.#e.rootNode.current.querySelectorAll(`[${this.#e.candidateAttr}]:not([data-disabled])`)):[]:[]}focusFirstCandidate(){const e=this.getCandidateNodes();e.length&&e[0]?.focus()}handleKeydown(e,r,n=!1){const i=this.#e.rootNode.current;if(!i||!e)return;const a=this.getCandidateNodes();if(!a.length)return;const s=a.indexOf(e),o=imt(i),{nextKey:l,prevKey:u}=omt(o,this.#e.orientation.current),d=this.#e.loop.current,h={[l]:s+1,[u]:s-1,[bU]:0,[yU]:a.length-1};if(n){const g=l===wg?A8:wg,m=u===yg?x8:yg;h[g]=s+1,h[m]=s-1}let f=h[r.key];if(f===void 0)return;r.preventDefault(),f<0&&d?f=a.length-1:f===a.length&&d&&(f=0);const p=a[f];if(p)return p.focus(),this.#t.current=p.id,this.#e.onCandidateFocus?.(p),p}getTabIndex(e){const r=this.getCandidateNodes(),n=this.#t.current!==null;return e&&!n&&r[0]===e?(this.#t.current=e.id,0):e?.id===this.#t.current?0:-1}setCurrentTabStopId(e){this.#t.current=e}focusCurrentTabStop(){const e=this.#t.current;if(!e)return;const r=this.#e.rootNode.current?.querySelector(`#${e}`);!r||!wp(r)||r.focus()}}class rOe{#e;#t=null;#r=null;#n=0;constructor(e){this.#e=e,Sh(()=>this.#i())}#i(){this.#t!==null&&(window.cancelAnimationFrame(this.#t),this.#t=null),this.#r?.disconnect(),this.#r=null,this.#n++}run(e){this.#i();const r=this.#e.ref.current;if(!r)return;if(typeof r.getAnimations!="function"){this.#a(e);return}const n=this.#n,i=()=>{n===this.#n&&this.#a(e)},a=()=>{if(n!==this.#n)return;const o=r.getAnimations();if(o.length===0){i();return}Promise.all(o.map(l=>l.finished)).then(()=>{i()}).catch(()=>{if(n!==this.#n)return;if(r.getAnimations().some(d=>d.pending||d.playState!=="finished")){a();return}i()})},s=()=>{this.#t=window.requestAnimationFrame(()=>{this.#t=null,a()})};if(!this.#e.afterTick.current){s();return}this.#t=window.requestAnimationFrame(()=>{this.#t=null;const o="data-starting-style";if(!r.hasAttribute(o)){s();return}this.#r=new MutationObserver(()=>{n===this.#n&&(r.hasAttribute(o)||(this.#r?.disconnect(),this.#r=null,s()))}),this.#r.observe(r,{attributes:!0,attributeFilter:[o]})})}#a(e){const r=()=>{e()};this.#e.afterTick?md(r):r()}}class F0{#e;#t;#r;#n=Oe(!1);#i=Oe(void 0);#a=!1;#s=null;constructor(e){this.#e=e,X(this.#n,e.open.current,!0),this.#t=e.enabled??!0,this.#r=new rOe({ref:this.#e.ref,afterTick:this.#e.open}),Sh(()=>this.#o()),yi(()=>this.#e.open.current,r=>{if(!this.#a){this.#a=!0;return}if(this.#o(),!r&&this.#e.shouldSkipExitAnimation?.()){X(this.#n,!1),X(this.#i,void 0),this.#e.onComplete?.();return}if(r&&X(this.#n,!0),X(this.#i,r?"starting":"ending",!0),r&&(this.#s=window.requestAnimationFrame(()=>{this.#s=null,this.#e.open.current&&X(this.#i,void 0)})),!this.#t){r||X(this.#n,!1),X(this.#i,void 0),this.#e.onComplete?.();return}this.#r.run(()=>{r===this.#e.open.current&&(this.#e.open.current||X(this.#n,!1),X(this.#i,void 0),this.#e.onComplete?.())})})}get shouldRender(){return S(this.#n)}get transitionStatus(){return S(this.#i)}#o(){this.#s!==null&&(window.cancelAnimationFrame(this.#s),this.#s=null)}}function Tn(){}function Yi(t,e){return`bits-${t}`}const dmt=xf({component:"dialog",parts:["content","trigger","overlay","title","description","close","cancel","action"]}),B0=new Ys("Dialog.Root | AlertDialog.Root");class SU{static create(e){const r=B0.getOr(null);return B0.set(new SU(e,r))}opts;#e=Oe(null);get triggerNode(){return S(this.#e)}set triggerNode(e){X(this.#e,e,!0)}#t=Oe(null);get contentNode(){return S(this.#t)}set contentNode(e){X(this.#t,e,!0)}#r=Oe(null);get overlayNode(){return S(this.#r)}set overlayNode(e){X(this.#r,e,!0)}#n=Oe(null);get descriptionNode(){return S(this.#n)}set descriptionNode(e){X(this.#n,e,!0)}#i=Oe(void 0);get contentId(){return S(this.#i)}set contentId(e){X(this.#i,e,!0)}#a=Oe(void 0);get titleId(){return S(this.#a)}set titleId(e){X(this.#a,e,!0)}#s=Oe(void 0);get triggerId(){return S(this.#s)}set triggerId(e){X(this.#s,e,!0)}#o=Oe(void 0);get descriptionId(){return S(this.#o)}set descriptionId(e){X(this.#o,e,!0)}#l=Oe(null);get cancelNode(){return S(this.#l)}set cancelNode(e){X(this.#l,e,!0)}#c=Oe(0);get nestedOpenCount(){return S(this.#c)}set nestedOpenCount(e){X(this.#c,e,!0)}depth;parent;contentPresence;overlayPresence;constructor(e,r){this.opts=e,this.parent=r,this.depth=r?r.depth+1:0,this.handleOpen=this.handleOpen.bind(this),this.handleClose=this.handleClose.bind(this),this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,enabled:!0,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),this.overlayPresence=new F0({ref:_t(()=>this.overlayNode),open:this.opts.open,enabled:!0}),yi(()=>this.opts.open.current,n=>{this.parent&&(n?this.parent.incrementNested():this.parent.decrementNested())},{lazy:!0}),Sh(()=>{this.opts.open.current&&this.parent?.decrementNested()})}handleOpen(){this.opts.open.current||(this.opts.open.current=!0)}handleClose(){this.opts.open.current&&(this.opts.open.current=!1)}getBitsAttr=e=>dmt.getAttr(e,this.opts.variant.current);incrementNested(){this.nestedOpenCount++,this.parent?.incrementNested()}decrementNested(){this.nestedOpenCount!==0&&(this.nestedOpenCount--,this.parent?.decrementNested())}#d=W(()=>({"data-state":Eh(this.opts.open.current)}));get sharedProps(){return S(this.#d)}set sharedProps(e){X(this.#d,e)}}class noe{static create(e){return new noe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this)}onclick(e){this.opts.disabled.current||e.button>0||this.root.handleClose()}onkeydown(e){this.opts.disabled.current||(e.key===xd||e.key===Kg)&&(e.preventDefault(),this.root.handleClose())}#e=W(()=>({id:this.opts.id.current,[this.root.getBitsAttr(this.opts.variant.current)]:"",onclick:this.onclick,onkeydown:this.onkeydown,disabled:this.opts.disabled.current?!0:void 0,tabindex:0,...this.root.sharedProps,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class ioe{static create(e){return new ioe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref)}#e=W(()=>({id:this.opts.id.current,[this.root.getBitsAttr("action")]:"",...this.root.sharedProps,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class aoe{static create(e){return new aoe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.root.titleId=this.opts.id.current,this.attachment=$i(this.opts.ref),yi.pre(()=>this.opts.id.current,n=>{this.root.titleId=n})}#e=W(()=>({id:this.opts.id.current,role:"heading","aria-level":this.opts.level.current,[this.root.getBitsAttr("title")]:"",...this.root.sharedProps,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class soe{static create(e){return new soe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.root.descriptionId=this.opts.id.current,this.attachment=$i(this.opts.ref,n=>{this.root.descriptionNode=n}),yi.pre(()=>this.opts.id.current,n=>{this.root.descriptionId=n})}#e=W(()=>({id:this.opts.id.current,[this.root.getBitsAttr("description")]:"",...this.root.sharedProps,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class EU{static create(e){return new EU(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>{this.root.contentNode=n,this.root.contentId=n?.id})}#e=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({id:this.opts.id.current,role:this.root.opts.variant.current==="alert-dialog"?"alertdialog":"dialog","aria-modal":"true","aria-describedby":this.root.descriptionId,"aria-labelledby":this.root.titleId,[this.root.getBitsAttr("content")]:"",style:{pointerEvents:"auto",outline:this.root.opts.variant.current==="alert-dialog"?"none":void 0,"--bits-dialog-depth":this.root.depth,"--bits-dialog-nested-count":this.root.nestedOpenCount,contain:"layout style"},tabindex:this.root.opts.variant.current==="alert-dialog"?-1:void 0,"data-nested-open":Uo(this.root.nestedOpenCount>0),"data-nested":Uo(this.root.parent!==null),...xv(this.root.contentPresence.transitionStatus),...this.root.sharedProps,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}get shouldRender(){return this.root.contentPresence.shouldRender}}class ooe{static create(e){return new ooe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.overlayNode=n)}#e=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({id:this.opts.id.current,[this.root.getBitsAttr("overlay")]:"",style:{pointerEvents:"auto","--bits-dialog-depth":this.root.depth,"--bits-dialog-nested-count":this.root.nestedOpenCount},"data-nested-open":Uo(this.root.nestedOpenCount>0),"data-nested":Uo(this.root.parent!==null),...xv(this.root.overlayPresence.transitionStatus),...this.root.sharedProps,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}get shouldRender(){return this.root.overlayPresence.shouldRender}}class loe{static create(e){return new loe(e,B0.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.cancelNode=n),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this)}onclick(e){this.opts.disabled.current||e.button>0||this.root.handleClose()}onkeydown(e){this.opts.disabled.current||(e.key===xd||e.key===Kg)&&(e.preventDefault(),this.root.handleClose())}#e=W(()=>({id:this.opts.id.current,[this.root.getBitsAttr("cancel")]:"",onclick:this.onclick,onkeydown:this.onkeydown,tabindex:0,...this.root.sharedProps,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}function hmt(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"onOpenChange",3,Tn),i=ce(e,"onOpenChangeComplete",3,Tn);SU.create({variant:_t(()=>"alert-dialog"),open:_t(()=>r(),o=>{r(o),n()(o)}),onOpenChangeComplete:_t(()=>i())});var a=Ae(),s=oe(a);Pt(s,()=>e.children??Vt),G(t,a),st()}var fmt=new Set(["$$slots","$$events","$$legacy","id","ref","child","children","level"]),pmt=se("
");function coe(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"level",3,2),s=Tt(e,fmt);const o=aoe.create({id:_t(()=>n()),level:_t(()=>a()),ref:_t(()=>i(),p=>i(p))}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=p=>{var g=Ae(),m=oe(g);Pt(m,()=>e.child,()=>({props:S(l)})),G(p,g)},f=p=>{var g=pmt();Er(g,()=>({...S(l)}));var m=te(g);Pt(m,()=>e.children??Vt),Z(g),G(p,g)};ve(d,p=>{e.child?p(h):p(f,-1)})}G(t,u),st()}var gmt=new Set(["$$slots","$$events","$$legacy","children","child","id","ref"]),mmt=se("");function _mt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=Tt(e,gmt);const s=ioe.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);Pt(g,()=>e.child,()=>({props:S(o)})),G(f,p)},h=f=>{var p=mmt();Er(p,()=>({...S(o)}));var g=te(p);Pt(g,()=>e.children??Vt),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}var vmt=new Set(["$$slots","$$events","$$legacy","id","ref","children","child","disabled"]),ymt=se("");function bmt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"disabled",3,!1),s=Tt(e,vmt);const o=loe.create({id:_t(()=>n()),ref:_t(()=>i(),p=>i(p)),disabled:_t(()=>!!a())}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=p=>{var g=Ae(),m=oe(g);Pt(m,()=>e.child,()=>({props:S(l)})),G(p,g)},f=p=>{var g=ymt();Er(g,()=>({...S(l)}));var m=te(g);Pt(m,()=>e.children??Vt),Z(g),G(p,g)};ve(d,p=>{e.child?p(h):p(f,-1)})}G(t,u),st()}function Smt(t,e){var r=Ae(),n=oe(r);Y8e(n,()=>e.children,i=>{var a=Ae(),s=oe(a);Pt(s,()=>e.children??Vt),G(i,a)}),G(t,r)}const Emt=new Ys("BitsConfig");function Tmt(){const t=new Cmt(null,{});return Emt.getOr(t).opts}class Cmt{opts;constructor(e,r){const n=wmt(e,r);this.opts={defaultPortalTo:n(i=>i.defaultPortalTo),defaultLocale:n(i=>i.defaultLocale)}}}function wmt(t,e){return r=>_t(()=>{const i=r(e)?.current;if(i!==void 0)return i;if(t!==null)return r(t.opts)?.current})}function xmt(t,e){return r=>{const n=Tmt();return _t(()=>{const i=r();if(i!==void 0)return i;const a=t(n).current;return a!==void 0?a:e})}}const Amt=xmt(t=>t.defaultPortalTo,"body");function Lp(t,e){at(e,!0);const r=Amt(()=>e.to),n=i8e();let i=W(a);function a(){if(!ZNe||e.disabled)return null;let h=null;return typeof r.current=="string"?h=document.querySelector(r.current):h=r.current,h}let s;function o(){s&&(Ise(s),s=null)}yi([()=>S(i),()=>e.disabled],([h,f])=>{if(!h||f){o();return}return s=oU(Smt,{target:h,props:{children:e.children},context:n}),()=>{o()}});var l=Ae(),u=oe(l);{var d=h=>{var f=Ae(),p=oe(f);Pt(p,()=>e.children??Vt),G(h,f)};ve(u,h=>{e.disabled&&h(d)})}G(t,l),st()}class Rmt{eventName;options;constructor(e,r={bubbles:!0,cancelable:!0}){this.eventName=e,this.options=r}createEvent(e){return new CustomEvent(this.eventName,{...this.options,detail:e})}dispatch(e,r){const n=this.createEvent(r);return e.dispatchEvent(n),n}listen(e,r,n){const i=a=>{r(a)};return Bi(e,this.eventName,i,n)}}function f1e(t,e=500){let r=null;const n=(...i)=>{r!==null&&clearTimeout(r),r=setTimeout(()=>{t(...i)},e)};return n.destroy=()=>{r!==null&&(clearTimeout(r),r=null)},n}function nOe(t,e){return t===e||t.contains(e)}function iOe(t){return t?.ownerDocument??document}function Nmt(t,e){const{clientX:r,clientY:n}=t,i=e.getBoundingClientRect();return ri.right||ni.bottom}const vJ=[Kg,xd],Omt=[wg,roe,bU],aOe=[yg,toe,yU],Imt=[...Omt,...aOe],kmt={ltr:[...vJ,A8],rtl:[...vJ,x8]},Dmt={ltr:[x8],rtl:[A8]};function Hf(t){return t.pointerType==="mouse"}function Mmt(t,{select:e=!1}={}){if(!t||!t.focus)return;const r=j2(t);if(r.activeElement===t)return;const n=r.activeElement;t.focus({preventScroll:!0}),t!==n&&umt(t)&&e&&t.select()}function Lmt(t,{select:e=!1}={},r){const n=r();for(const i of t)if(Mmt(i,{select:e}),r()!==n)return!0}function Pmt(t){const e=[],n=j2(t).createTreeWalker(t,NodeFilter.SHOW_ELEMENT,{acceptNode:i=>{const a=i.tagName==="INPUT"&&i.type==="hidden";return i.disabled||i.hidden||a?NodeFilter.FILTER_SKIP:i.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)e.push(n.currentNode);return e}let mA=Oe(!1);class J1{static _refs=0;static _cleanup;constructor(){Kt(()=>(J1._refs===0&&(J1._cleanup=v8(()=>{const e=[],r=i=>{X(mA,!1)},n=i=>{X(mA,!0)};return e.push(Bi(document,"pointerdown",r,{capture:!0}),Bi(document,"pointermove",r,{capture:!0}),Bi(document,"keydown",n,{capture:!0})),Vb(...e)})),J1._refs++,()=>{J1._refs--,J1._refs===0&&(X(mA,!1),J1._cleanup?.())}))}get current(){return S(mA)}set current(e){X(mA,e,!0)}}var sOe=["input:not([inert]):not([inert] *)","select:not([inert]):not([inert] *)","textarea:not([inert]):not([inert] *)","a[href]:not([inert]):not([inert] *)","button:not([inert]):not([inert] *)","[tabindex]:not(slot):not([inert]):not([inert] *)","audio[controls]:not([inert]):not([inert] *)","video[controls]:not([inert]):not([inert] *)",'[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)',"details>summary:first-of-type:not([inert]):not([inert] *)","details:not([inert]):not([inert] *)"],TL=sOe.join(","),oOe=typeof Element>"u",u2=oOe?function(){}:Element.prototype.matches||Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector,CL=!oOe&&Element.prototype.getRootNode?function(t){var e;return t==null||(e=t.getRootNode)===null||e===void 0?void 0:e.call(t)}:function(t){return t?.ownerDocument},wL=function(e,r){var n;r===void 0&&(r=!0);var i=e==null||(n=e.getAttribute)===null||n===void 0?void 0:n.call(e,"inert"),a=i===""||i==="true",s=a||r&&e&&(typeof e.closest=="function"?e.closest("[inert]"):wL(e.parentNode));return s},Fmt=function(e){var r,n=e==null||(r=e.getAttribute)===null||r===void 0?void 0:r.call(e,"contenteditable");return n===""||n==="true"},lOe=function(e,r,n){if(wL(e))return[];var i=Array.prototype.slice.apply(e.querySelectorAll(TL));return r&&u2.call(e,TL)&&i.unshift(e),i=i.filter(n),i},xL=function(e,r,n){for(var i=[],a=Array.from(e);a.length;){var s=a.shift();if(!wL(s,!1))if(s.tagName==="SLOT"){var o=s.assignedElements(),l=o.length?o:s.children,u=xL(l,!0,n);n.flatten?i.push.apply(i,u):i.push({scopeParent:s,candidates:u})}else{var d=u2.call(s,TL);d&&n.filter(s)&&(r||!e.includes(s))&&i.push(s);var h=s.shadowRoot||typeof n.getShadowRoot=="function"&&n.getShadowRoot(s),f=!wL(h,!1)&&(!n.shadowRootFilter||n.shadowRootFilter(s));if(h&&f){var p=xL(h===!0?s.children:h.children,!0,n);n.flatten?i.push.apply(i,p):i.push({scopeParent:s,candidates:p})}else a.unshift.apply(a,s.children)}}return i},cOe=function(e){return!isNaN(parseInt(e.getAttribute("tabindex"),10))},uOe=function(e){if(!e)throw new Error("No node provided");return e.tabIndex<0&&(/^(AUDIO|VIDEO|DETAILS)$/.test(e.tagName)||Fmt(e))&&!cOe(e)?0:e.tabIndex},Bmt=function(e,r){var n=uOe(e);return n<0&&r&&!cOe(e)?0:n},Umt=function(e,r){return e.tabIndex===r.tabIndex?e.documentOrder-r.documentOrder:e.tabIndex-r.tabIndex},dOe=function(e){return e.tagName==="INPUT"},$mt=function(e){return dOe(e)&&e.type==="hidden"},Gmt=function(e){var r=e.tagName==="DETAILS"&&Array.prototype.slice.apply(e.children).some(function(n){return n.tagName==="SUMMARY"});return r},zmt=function(e,r){for(var n=0;nsummary:first-of-type"),o=s?e.parentElement:e;if(u2.call(o,"details:not([open]) *"))return!0;if(!n||n==="full"||n==="full-native"||n==="legacy-full"){if(typeof i=="function"){for(var l=e;e;){var u=e.parentElement,d=CL(e);if(u&&!u.shadowRoot&&i(u)===!0)return p1e(e);e.assignedSlot?e=e.assignedSlot:!u&&d!==e.ownerDocument?e=d.host:e=u}e=l}if(Ymt(e))return!e.getClientRects().length;if(n!=="legacy-full")return!0}else if(n==="non-zero-area")return p1e(e);return!1},Kmt=function(e){if(/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(e.tagName))for(var r=e.parentElement;r;){if(r.tagName==="FIELDSET"&&r.disabled){for(var n=0;n=0)},hOe=function(e){var r=[],n=[];return e.forEach(function(i,a){var s=!!i.scopeParent,o=s?i.scopeParent:i,l=Bmt(o,s),u=s?hOe(i.candidates):o;l===0?s?r.push.apply(r,u):r.push(o):n.push({documentOrder:a,tabIndex:l,item:i,isScope:s,content:u})}),n.sort(Umt).reduce(function(i,a){return a.isScope?i.push.apply(i,a.content):i.push(a.content),i},[]).concat(r)},fOe=function(e,r){r=r||{};var n;return r.getShadowRoot?n=xL([e],r.includeContainer,{filter:yJ.bind(null,r),flatten:!1,getShadowRoot:r.getShadowRoot,shadowRootFilter:jmt}):n=lOe(e,r.includeContainer,yJ.bind(null,r)),hOe(n)},pOe=function(e,r){r=r||{};var n;return r.getShadowRoot?n=xL([e],r.includeContainer,{filter:AL.bind(null,r),flatten:!0,getShadowRoot:r.getShadowRoot}):n=lOe(e,r.includeContainer,AL.bind(null,r)),n},TU=function(e,r){if(r=r||{},!e)throw new Error("No node provided");return u2.call(e,TL)===!1?!1:yJ(r,e)},Xmt=sOe.concat("iframe:not([inert]):not([inert] *)").join(","),gOe=function(e,r){if(r=r||{},!e)throw new Error("No node provided");return u2.call(e,Xmt)===!1?!1:AL(r,e)};function R9(){return{getShadowRoot:!0,displayCheck:typeof ResizeObserver=="function"&&ResizeObserver.toString().includes("[native code]")?"full":"none"}}function Qmt(t,e){if(!TU(t,R9()))return Zmt(t,e);const r=j2(t),n=fOe(r.body,R9());e==="prev"&&n.reverse();const i=n.indexOf(t);return i===-1?r.body:n.slice(i+1)[0]}function Zmt(t,e){const r=j2(t);if(!gOe(t,R9()))return r.body;const n=pOe(r.body,R9());e==="prev"&&n.reverse();const i=n.indexOf(t);return i===-1?r.body:n.slice(i+1).find(s=>TU(s,R9()))??r.body}function Jmt(t,e,r=!0){if(!(t.length===0||e<0||e>=t.length))return t.length===1&&e===0?t[0]:e===t.length-1?r?t[0]:void 0:t[e+1]}function e0t(t,e,r=!0){if(!(t.length===0||e<0||e>=t.length))return t.length===1&&e===0?t[0]:e===0?r?t[t.length-1]:void 0:t[e-1]}function t0t(t,e,r,n=!0){if(t.length===0||e<0||e>=t.length)return;let i=e+r;return n?i=(i%t.length+t.length)%t.length:i=Math.max(0,Math.min(i,t.length-1)),t[i]}function r0t(t,e,r,n=!0){if(t.length===0||e<0||e>=t.length)return;let i=e-r;return n?i=(i%t.length+t.length)%t.length:i=Math.max(0,Math.min(i,t.length-1)),t[i]}function uoe(t,e,r){const n=e.toLowerCase();if(n.endsWith(" ")){const h=n.slice(0,-1);if(t.filter(m=>m.toLowerCase().startsWith(h)).length<=1)return uoe(t,h,r);const p=r?.toLowerCase();if(p&&p.startsWith(h)&&p.charAt(h.length)===" "&&e.trim()===h)return r;const g=t.filter(m=>m.toLowerCase().startsWith(n));if(g.length>0){const m=r?t.indexOf(r):-1;return g1e(g,Math.max(m,0)).find(b=>b!==r)||r}}const a=e.length>1&&Array.from(e).every(h=>h===e[0])?e[0]:e,s=a.toLowerCase(),o=r?t.indexOf(r):-1;let l=g1e(t,Math.max(o,0));a.length===1&&(l=l.filter(h=>h!==r));const d=l.find(h=>h?.toLowerCase().startsWith(s));return d!==r?d:void 0}function g1e(t,e){return t.map((r,n)=>t[(e+n)%t.length])}const n0t={afterMs:1e4,onChange:Tn};function mOe(t,e){const{afterMs:r,onChange:n,getWindow:i}={...n0t,...e};let a=null,s=Oe(Zr(t));function o(){return i().setTimeout(()=>{X(s,t,!0),n?.(t)},r)}return Kt(()=>()=>{a&&i().clearTimeout(a)}),_t(()=>S(s),l=>{X(s,l,!0),n?.(l),a&&i().clearTimeout(a),a=o()})}class _Oe{#e;#t;#r=W(()=>this.#e.onMatch?this.#e.onMatch:e=>e.focus());#n=W(()=>this.#e.getCurrentItem?this.#e.getCurrentItem:this.#e.getActiveElement);constructor(e){this.#e=e,this.#t=mOe("",{afterMs:1e3,getWindow:e.getWindow}),this.handleTypeaheadSearch=this.handleTypeaheadSearch.bind(this),this.resetTypeahead=this.resetTypeahead.bind(this)}handleTypeaheadSearch(e,r){if(!r.length)return;this.#t.current=this.#t.current+e;const n=S(this.#n)(),i=r.find(l=>l===n)?.textContent?.trim()??"",a=r.map(l=>l.textContent?.trim()??""),s=uoe(a,this.#t.current,i),o=r.find(l=>l.textContent?.trim()===s);return o&&S(this.#r)(o),o}resetTypeahead(){this.#t.current=""}get search(){return this.#t.current}}const i0t="data-context-menu-trigger",a0t="data-context-menu-content",vOe=new Ys("Menu.Root"),j5=new Ys("Menu.Root | Menu.Sub"),doe=new Ys("Menu.Content"),hoe=new Rmt("bitsmenuopen",{bubbles:!1,cancelable:!0}),s0t=xf({component:"menu",parts:["trigger","content","sub-trigger","item","group","group-heading","checkbox-group","checkbox-item","radio-group","radio-item","separator","sub-content","arrow"]});class o0t{#e;#t=null;#r=null;#n=!1;#i=null;#a=null;#s=null;#o=null;constructor(e){this.#e=e,yi([e.triggerNode,e.contentNode,e.enabled],([r,n,i])=>{if(this.#v(),!r||!n||!i)return;const a=h=>{Hf(h)&&(this.#o={x:h.clientX,y:h.clientY},this.#n||this.#u(h,"content"))},s=h=>{Hf(h)&&this.#p(h,"content")},o=h=>{Hf(h)&&(this.#n||this.#u(h,"trigger"))},l=h=>{if(Hf(h)){if(Au(h.relatedTarget)){const f=this.#e.subContentSelector(),p=h.relatedTarget.closest(f);if(p&&p!==n&&p.id&&!!n.querySelector(`[aria-controls="${p.id}"]`))return}this.#p(h,"trigger")}},u=h=>{Hf(h)&&this.#f()},d=h=>{Hf(h)&&this.#f()};return r.addEventListener("pointermove",a),r.addEventListener("pointerleave",s),r.addEventListener("pointerenter",u),n.addEventListener("pointermove",o),n.addEventListener("pointerleave",l),n.addEventListener("pointerenter",d),()=>{r.removeEventListener("pointermove",a),r.removeEventListener("pointerleave",s),r.removeEventListener("pointerenter",u),n.removeEventListener("pointermove",o),n.removeEventListener("pointerleave",l),n.removeEventListener("pointerenter",d),this.#v()}}),Sh(()=>{this.#v()})}#l(){const e=this.#e.parentContentNode();return e?e.getBoundingClientRect():this.#e.triggerNode()?.getBoundingClientRect()??null}#c(e,r){const n=this.#e.triggerNode(),i=this.#e.contentNode();if(!n||!i)return null;const a=n.getBoundingClientRect(),s=i.getBoundingClientRect(),o=c0t(a,s);let l,u,d;return r==="content"?(l=this.#n?this.#a??e:e,u=s):(l=this.#o??e,u=this.#l()??a,d=s),this.#a=l,{corridor:u0t(a,s,o),intent:d0t(l,u,o,r,d),targetRect:u,side:o}}#d(e,r,n){return m1e(e,r)||m1e(e,n)}#u(e,r){const n={x:e.clientX,y:e.clientY};this.#c(n,r)&&(this.#i=r,this.#s=n)}#p(e,r){if(!this.#e.enabled())return;const n=this.#e.triggerNode(),i=this.#e.contentNode();if(!n||!i)return;const a=e.relatedTarget;if(Au(a)&&(r==="content"&&i.contains(a)||r==="trigger"&&n.contains(a)))return;const s={x:e.clientX,y:e.clientY},o=this.#c(s,r);if(o){if(!_1e(s,o.targetRect)&&!this.#d(s,o.corridor,o.intent)){this.#w();return}this.#n=!0,this.#i=r,this.#s=s,this.#e.setIsPointerInTransit(!0),this.#b(),this.#E()}}#g=null;#f(){if(!this.#n)return;const e=this.#i==="trigger";this.#y(),this.#C(),this.#n=!1,this.#w(),e?(this.#h(),this.#g=setTimeout(()=>{this.#g=null,this.#e.setIsPointerInTransit(!1)},100)):this.#e.setIsPointerInTransit(!1)}#h(){this.#g!==null&&(clearTimeout(this.#g),this.#g=null)}#m(){const e=this.#s;this.#y(),this.#C(),this.#h(),this.#n=!1,this.#e.setIsPointerInTransit(!1),this.#w(),this.#e.onIntentExit(e)}#v(){this.#y(),this.#C(),this.#h(),this.#n&&this.#e.setIsPointerInTransit(!1),this.#n=!1,this.#i=null,this.#a=null,this.#s=null,this.#o=null}#_(e){const r=this.#e.contentNode();if(!r)return!1;const i=r.ownerDocument.elementFromPoint(e.x,e.y);if(!i)return!1;const a=this.#e.subContentSelector(),s=i.closest(a);return!s||s===r?!1:s.id?!!r.querySelector(`[aria-controls="${s.id}"]`):!1}#S=e=>{if(!this.#n||!this.#i||!Hf(e))return;const r=this.#e.triggerNode(),n=this.#e.contentNode();if(!r||!n){this.#m();return}this.#C();const i={x:e.clientX,y:e.clientY};this.#s=i;const a=r.getBoundingClientRect(),s=n.getBoundingClientRect();if(this.#i==="content"&&_1e(i,s)){this.#f();return}if(this.#i==="trigger"&&l0t(i,a,4)){this.#f();return}if(this.#_(i)){this.#E();return}const o=this.#c(i,this.#i);if(!o){this.#m();return}if(this.#d(i,o.corridor,o.intent)){this.#E();return}this.#m()};#b(){if(this.#t)return;const e=j2(this.#e.triggerNode()??this.#e.contentNode());e&&(e.addEventListener("pointermove",this.#S,!0),this.#t=()=>{e.removeEventListener("pointermove",this.#S,!0),this.#t=null})}#y(){this.#t?.()}#E(){this.#C(),this.#r=setTimeout(()=>{this.#r=null,this.#n&&this.#m()},500)}#C(){this.#r!==null&&(clearTimeout(this.#r),this.#r=null)}#w(){this.#i=null,this.#a=null,this.#s=null}}function m1e(t,e){const{x:r,y:n}=t;let i=!1;for(let a=0,s=e.length-1;an!=d>n&&r<(u-o)*(n-l)/(d-l)+o&&(i=!i)}return i}function _1e(t,e){return t.x>=e.left&&t.x<=e.right&&t.y>=e.top&&t.y<=e.bottom}function l0t(t,e,r){return t.x>=e.left+r&&t.x<=e.right-r&&t.y>=e.top+r&&t.y<=e.bottom-r}function c0t(t,e){const r=t.left+t.width/2,n=t.top+t.height/2,i=e.left+e.width/2,a=e.top+e.height/2,s=i-r,o=a-n;return Math.abs(s)>Math.abs(o)?s>0?"right":"left":o>0?"bottom":"top"}function u0t(t,e,r){switch(r){case"top":return[{x:Math.min(t.left,e.left)-2,y:t.top},{x:Math.min(t.left,e.left)-2,y:e.bottom},{x:Math.max(t.right,e.right)+2,y:e.bottom},{x:Math.max(t.right,e.right)+2,y:t.top}];case"bottom":return[{x:Math.min(t.left,e.left)-2,y:t.bottom},{x:Math.min(t.left,e.left)-2,y:e.top},{x:Math.max(t.right,e.right)+2,y:e.top},{x:Math.max(t.right,e.right)+2,y:t.bottom}];case"left":return[{x:t.left,y:Math.min(t.top,e.top)-2},{x:e.right,y:Math.min(t.top,e.top)-2},{x:e.right,y:Math.max(t.bottom,e.bottom)+2},{x:t.left,y:Math.max(t.bottom,e.bottom)+2}];case"right":return[{x:t.right,y:Math.min(t.top,e.top)-2},{x:e.left,y:Math.min(t.top,e.top)-2},{x:e.left,y:Math.max(t.bottom,e.bottom)+2},{x:t.right,y:Math.max(t.bottom,e.bottom)+2}]}}function d0t(t,e,r,n,i){const s=n==="trigger"?h0t(r):r,o=i?Math.min(e.top,i.top)-8:e.top-8,l=i?Math.max(e.bottom,i.bottom)+8:e.bottom+8,u=i?Math.min(e.left,i.left)-8:e.left-8,d=i?Math.max(e.right,i.right)+8:e.right+8;switch(s){case"right":return[t,{x:e.left,y:o},{x:e.left,y:l}];case"left":return[t,{x:e.right,y:o},{x:e.right,y:l}];case"bottom":return[t,{x:u,y:e.top},{x:d,y:e.top}];case"top":return[t,{x:u,y:e.bottom},{x:d,y:e.bottom}]}}function h0t(t){switch(t){case"top":return"bottom";case"bottom":return"top";case"left":return"right";case"right":return"left"}}class foe{static create(e){const r=new foe(e);return vOe.set(r)}opts;isUsingKeyboard=new J1;#e=Oe(!1);get ignoreCloseAutoFocus(){return S(this.#e)}set ignoreCloseAutoFocus(e){X(this.#e,e,!0)}#t=Oe(!1);get isPointerInTransit(){return S(this.#t)}set isPointerInTransit(e){X(this.#t,e,!0)}constructor(e){this.opts=e}getBitsAttr=e=>s0t.getAttr(e,this.opts.variant.current)}class CU{static create(e,r){return j5.set(new CU(e,r,null))}opts;root;parentMenu;contentId=_t(()=>"");#e=Oe(null);get contentNode(){return S(this.#e)}set contentNode(e){X(this.#e,e,!0)}contentPresence;#t=Oe(null);get triggerNode(){return S(this.#t)}set triggerNode(e){X(this.#t,e,!0)}constructor(e,r,n){this.opts=e,this.root=r,this.parentMenu=n,this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)},shouldSkipExitAnimation:()=>this.root.opts.variant.current!=="menubar"||this.parentMenu!==null?!1:this.root.opts.shouldSkipExitAnimation?.()??!1}),n&&yi(()=>n.opts.open.current,()=>{n.opts.open.current||(this.opts.open.current=!1)})}toggleOpen(){this.opts.open.current=!this.opts.open.current}onOpen(){this.opts.open.current=!0}onClose(){this.opts.open.current=!1}}class wU{static create(e){return doe.set(new wU(e,j5.get()))}opts;parentMenu;rovingFocusGroup;domContext;attachment;#e=Oe("");get search(){return S(this.#e)}set search(e){X(this.#e,e,!0)}#t=0;#r;#n=Oe(!1);get mounted(){return S(this.#n)}set mounted(e){X(this.#n,e,!0)}#i;constructor(e,r){this.opts=e,this.parentMenu=r,this.domContext=new wf(e.ref),this.attachment=$i(this.opts.ref,n=>{this.parentMenu.contentNode!==n&&(this.parentMenu.contentNode=n)}),r.contentId=e.id,this.#i=e.isSub??!1,this.onkeydown=this.onkeydown.bind(this),this.onblur=this.onblur.bind(this),this.onfocus=this.onfocus.bind(this),this.handleInteractOutside=this.handleInteractOutside.bind(this),new o0t({contentNode:()=>this.parentMenu.contentNode,triggerNode:()=>this.parentMenu.triggerNode,parentContentNode:()=>this.parentMenu.parentMenu?.contentNode??null,subContentSelector:()=>`[${this.parentMenu.root.getBitsAttr("sub-content")}]`,enabled:()=>this.parentMenu.opts.open.current&&!!this.parentMenu.triggerNode?.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger")),onIntentExit:n=>{this.parentMenu.opts.open.current=!1,this.#o(n)},setIsPointerInTransit:n=>{this.parentMenu.root.isPointerInTransit=n}}),this.#r=new _Oe({getActiveElement:()=>this.domContext.getActiveElement(),getWindow:()=>this.domContext.getWindow()}).handleTypeaheadSearch,this.rovingFocusGroup=new tOe({rootNode:_t(()=>this.parentMenu.contentNode),candidateAttr:this.parentMenu.root.getBitsAttr("item"),loop:this.opts.loop,orientation:_t(()=>"vertical")}),yi(()=>this.parentMenu.contentNode,n=>{if(!n)return;const i=()=>{md(()=>{this.parentMenu.root.isUsingKeyboard.current&&this.rovingFocusGroup.focusFirstCandidate()})};return hoe.listen(n,i)}),Kt(()=>{this.parentMenu.opts.open.current||this.domContext.getWindow().clearTimeout(this.#t)})}#a(){const e=this.parentMenu.contentNode;return e?Array.from(e.querySelectorAll(`[${this.parentMenu.root.getBitsAttr("item")}]:not([data-disabled])`)):[]}#s(){return this.parentMenu.root.isPointerInTransit}#o(e){if(!e)return;const r=this.parentMenu.parentMenu?.contentNode;if(!r)return;const n=this.domContext.getDocument().elementFromPoint(e.x,e.y);if(!Au(n))return;const i=n.closest(`[${this.parentMenu.root.getBitsAttr("sub-trigger")}]`);!i||!r.contains(i)||i!==this.parentMenu.triggerNode&&i.dispatchEvent(new PointerEvent("pointermove",{bubbles:!0,cancelable:!0,pointerType:"mouse",clientX:e.x,clientY:e.y}))}onCloseAutoFocus=e=>{if(this.opts.onCloseAutoFocus.current?.(e),!(e.defaultPrevented||this.#i)){if(this.parentMenu.root.ignoreCloseAutoFocus){e.preventDefault();return}this.parentMenu.triggerNode&&TU(this.parentMenu.triggerNode)&&(e.preventDefault(),this.parentMenu.triggerNode.focus())}};handleTabKeyDown(e){let r=this.parentMenu;for(;r.parentMenu!==null;)r=r.parentMenu;if(!r.triggerNode)return;e.preventDefault();const n=Qmt(r.triggerNode,e.shiftKey?"prev":"next");n?(this.parentMenu.root.ignoreCloseAutoFocus=!0,r.onClose(),md(()=>{n.focus(),md(()=>{this.parentMenu.root.ignoreCloseAutoFocus=!1})})):this.domContext.getDocument().body.focus()}onkeydown(e){if(e.defaultPrevented)return;if(e.key===mJ){this.handleTabKeyDown(e);return}const r=e.target,n=e.currentTarget;if(!wp(r)||!wp(n))return;const i=r.closest(`[${this.parentMenu.root.getBitsAttr("content")}]`)?.id===this.parentMenu.contentId.current,a=e.ctrlKey||e.altKey||e.metaKey,s=e.key.length===1;if(this.rovingFocusGroup.handleKeydown(r,e)||e.code==="Space")return;const l=this.#a();i&&!a&&s&&this.#r(e.key,l),e.target?.id===this.parentMenu.contentId.current&&Imt.includes(e.key)&&(e.preventDefault(),aOe.includes(e.key)&&l.reverse(),Lmt(l,{select:!1},()=>this.domContext.getActiveElement()))}onblur(e){Au(e.currentTarget)&&Au(e.target)&&(e.currentTarget.contains?.(e.target)||(this.domContext.getWindow().clearTimeout(this.#t),this.search=""))}onfocus(e){this.parentMenu.root.isUsingKeyboard.current&&md(()=>this.rovingFocusGroup.focusFirstCandidate())}onItemEnter(){return this.#s()}onItemLeave(e){if(e.currentTarget.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger"))||this.#s()||this.parentMenu.root.isUsingKeyboard.current)return;this.parentMenu.contentNode?.focus({preventScroll:!0}),this.rovingFocusGroup.setCurrentTabStopId("")}onTriggerLeave(){return!!this.#s()}handleInteractOutside(e){if(!JNe(e.target))return;const r=this.parentMenu.triggerNode?.id;if(e.target.id===r){e.preventDefault();return}if(e.target.closest(`#${r}`)){e.preventDefault();return}this.parentMenu.root.ignoreCloseAutoFocus=!0,md(()=>{this.parentMenu.root.ignoreCloseAutoFocus=!1})}get shouldRender(){return this.parentMenu.contentPresence.shouldRender}#l=W(()=>({open:this.parentMenu.opts.open.current}));get snippetProps(){return S(this.#l)}set snippetProps(e){X(this.#l,e)}#c=W(()=>({id:this.opts.id.current,role:"menu","aria-orientation":"vertical",[this.parentMenu.root.getBitsAttr("content")]:"","data-state":Eh(this.parentMenu.opts.open.current),...xv(this.parentMenu.contentPresence.transitionStatus),onkeydown:this.onkeydown,onblur:this.onblur,onfocus:this.onfocus,dir:this.parentMenu.root.opts.dir.current,style:{pointerEvents:"auto",contain:"layout style"},...this.attachment}));get props(){return S(this.#c)}set props(e){X(this.#c,e)}popperProps={onCloseAutoFocus:e=>this.onCloseAutoFocus(e)}}class yOe{opts;content;attachment;#e=Oe(!1);constructor(e,r){this.opts=e,this.content=r,this.attachment=$i(this.opts.ref),this.onpointermove=this.onpointermove.bind(this),this.onpointerleave=this.onpointerleave.bind(this),this.onfocus=this.onfocus.bind(this),this.onblur=this.onblur.bind(this)}onpointermove(e){if(!e.defaultPrevented&&Hf(e))if(this.opts.disabled.current)this.content.onItemLeave(e);else{if(this.content.onItemEnter())return;const n=e.currentTarget;if(!wp(n))return;n.focus({preventScroll:!0})}}onpointerleave(e){e.defaultPrevented||Hf(e)&&this.content.onItemLeave(e)}onfocus(e){md(()=>{e.defaultPrevented||this.opts.disabled.current||X(this.#e,!0)})}onblur(e){md(()=>{e.defaultPrevented||X(this.#e,!1)})}#t=W(()=>({id:this.opts.id.current,tabindex:-1,role:"menuitem","aria-disabled":vf(this.opts.disabled.current),"data-disabled":Uo(this.opts.disabled.current),"data-highlighted":S(this.#e)?"":void 0,[this.content.parentMenu.root.getBitsAttr("item")]:"",onpointermove:this.onpointermove,onpointerleave:this.onpointerleave,onfocus:this.onfocus,onblur:this.onblur,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class poe{static create(e){const r=new yOe(e,doe.get());return new poe(e,r)}opts;item;root;#e=!1;constructor(e,r){this.opts=e,this.item=r,this.root=r.content.parentMenu.root,this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this),this.onpointerdown=this.onpointerdown.bind(this),this.onpointerup=this.onpointerup.bind(this)}#t(){if(this.item.opts.disabled.current)return;const e=new CustomEvent("menuitemselect",{bubbles:!0,cancelable:!0});if(this.opts.onSelect.current(e),e.defaultPrevented){this.item.content.parentMenu.root.isUsingKeyboard.current=!1;return}this.opts.closeOnSelect.current&&this.item.content.parentMenu.root.opts.onClose()}onkeydown(e){const r=this.item.content.search!=="";if(!(this.item.opts.disabled.current||r&&e.key===xd)&&vJ.includes(e.key)){if(!wp(e.currentTarget))return;e.currentTarget.click(),e.preventDefault()}}onclick(e){this.item.opts.disabled.current||this.#t()}onpointerup(e){if(!e.defaultPrevented&&!this.#e){if(!wp(e.currentTarget))return;e.currentTarget?.click()}}onpointerdown(e){this.#e=!0}#r=W(()=>un(this.item.props,{onclick:this.onclick,onpointerdown:this.onpointerdown,onpointerup:this.onpointerup,onkeydown:this.onkeydown}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}class goe{static create(e){const r=doe.get(),n=new yOe(e,r),i=j5.get();return new goe(e,n,r,i)}opts;item;content;submenu;attachment;#e=null;constructor(e,r,n,i){this.opts=e,this.item=r,this.content=n,this.submenu=i,this.attachment=$i(this.opts.ref,a=>this.submenu.triggerNode=a),this.onpointerleave=this.onpointerleave.bind(this),this.onpointermove=this.onpointermove.bind(this),this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this),Sh(()=>{this.#t()})}#t(){this.#e!==null&&(this.content.domContext.getWindow().clearTimeout(this.#e),this.#e=null)}onpointermove(e){if(Hf(e)){if(this.submenu.root.isPointerInTransit){this.#e!==null&&this.#t();return}if(!this.item.opts.disabled.current&&!this.submenu.opts.open.current&&!this.#e){const r=this.opts.openDelay.current;if(r<=0){this.submenu.onOpen();return}this.#e=this.content.domContext.setTimeout(()=>{if(this.submenu.root.isPointerInTransit){this.#t();return}this.submenu.onOpen(),this.#t()},r)}}}onpointerleave(e){Hf(e)&&this.#t()}onkeydown(e){const r=this.content.search!=="";this.item.opts.disabled.current||r&&e.key===xd||kmt[this.submenu.root.opts.dir.current].includes(e.key)&&(e.currentTarget.click(),e.preventDefault())}onclick(e){if(this.item.opts.disabled.current||!wp(e.currentTarget))return;e.currentTarget.focus();const r=new CustomEvent("menusubtriggerselect",{bubbles:!0,cancelable:!0});this.opts.onSelect.current(r),this.submenu.opts.open.current||(this.submenu.onOpen(),md(()=>{const n=this.submenu.contentNode;n&&hoe.dispatch(n)}))}#r=W(()=>un({"aria-haspopup":"menu","aria-expanded":vf(this.submenu.opts.open.current),"data-state":Eh(this.submenu.opts.open.current),"aria-controls":this.submenu.opts.open.current?this.submenu.contentId.current:void 0,[this.submenu.root.getBitsAttr("sub-trigger")]:"",onclick:this.onclick,onpointermove:this.onpointermove,onpointerleave:this.onpointerleave,onkeydown:this.onkeydown,...this.attachment},this.item.props));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}class moe{static create(e){return new moe(e,vOe.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref)}#e=W(()=>({id:this.opts.id.current,role:"group",[this.root.getBitsAttr("separator")]:"",...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class _oe{static create(e){return new _oe(e,j5.get())}opts;parentMenu;attachment;constructor(e,r){this.opts=e,this.parentMenu=r,this.attachment=$i(this.opts.ref,n=>this.parentMenu.triggerNode=n)}onclick=e=>{this.opts.disabled.current||e.detail!==0||(this.parentMenu.toggleOpen(),e.preventDefault())};onpointerdown=e=>{if(!this.opts.disabled.current){if(e.pointerType==="touch")return e.preventDefault();e.button===0&&e.ctrlKey===!1&&(this.parentMenu.toggleOpen(),this.parentMenu.opts.open.current||e.preventDefault())}};onpointerup=e=>{this.opts.disabled.current||e.pointerType==="touch"&&(e.preventDefault(),this.parentMenu.toggleOpen())};onkeydown=e=>{if(!this.opts.disabled.current){if(e.key===xd||e.key===Kg){this.parentMenu.toggleOpen(),e.preventDefault();return}e.key===wg&&(this.parentMenu.onOpen(),e.preventDefault())}};#e=W(()=>{if(this.parentMenu.opts.open.current&&this.parentMenu.contentId.current)return this.parentMenu.contentId.current});#t=W(()=>({id:this.opts.id.current,disabled:this.opts.disabled.current,"aria-haspopup":"menu","aria-expanded":vf(this.parentMenu.opts.open.current),"aria-controls":S(this.#e),"data-disabled":Uo(this.opts.disabled.current),"data-state":Eh(this.parentMenu.opts.open.current),[this.parentMenu.root.getBitsAttr("trigger")]:"",onclick:this.onclick,onpointerdown:this.onpointerdown,onpointerup:this.onpointerup,onkeydown:this.onkeydown,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class f0t{static create(e){const r=j5.get();return j5.set(new CU(e,r.root,r))}}globalThis.bitsDismissableLayers??=new Map;class voe{static create(e){return new voe(e)}opts;#e;#t;#r={pointerdown:!1};#n=!1;#i=!1;#a=void 0;#s;#o=Tn;constructor(e){this.opts=e,this.#t=e.interactOutsideBehavior,this.#e=e.onInteractOutside,this.#s=e.onFocusOutside,Kt(()=>{this.#a=iOe(this.opts.ref.current)});let r=Tn;const n=()=>{this.#m(),globalThis.bitsDismissableLayers.delete(this),this.#u.destroy(),r()};yi([()=>this.opts.enabled.current,()=>this.opts.ref.current],()=>{if(!(!this.opts.enabled.current||!this.opts.ref.current))return vU(1,()=>{this.opts.ref.current&&(globalThis.bitsDismissableLayers.set(this,this.#t),r(),r=this.#c())}),n}),Sh(()=>{this.#m.destroy(),globalThis.bitsDismissableLayers.delete(this),this.#u.destroy(),this.#o(),r()})}#l=e=>{e.defaultPrevented||this.opts.ref.current&&md(()=>{!this.opts.ref.current||this.#h(e.target)||e.target&&!this.#i&&this.#s.current?.(e)})};#c(){return Vb(Bi(this.#a,"pointerdown",Vb(this.#p,this.#f),{capture:!0}),Bi(this.#a,"pointerdown",Vb(this.#g,this.#u)),Bi(this.#a,"focusin",this.#l))}#d=e=>{let r=e;r.defaultPrevented&&(r=v1e(e)),this.#e.current(e)};#u=f1e(e=>{if(!this.opts.ref.current){this.#o();return}const r=this.opts.isValidEvent.current(e,this.opts.ref.current)||m0t(e,this.opts.ref.current);if(!this.#n||this.#v()||!r){this.#o();return}let n=e;if(n.defaultPrevented&&(n=v1e(n)),this.#t.current!=="close"&&this.#t.current!=="defer-otherwise-close"){this.#o();return}e.pointerType==="touch"?(this.#o(),this.#o=Bi(this.#a,"click",this.#d,{once:!0})):this.#e.current(n)},10);#p=e=>{this.#r[e.type]=!0};#g=e=>{this.#r[e.type]=!1};#f=()=>{this.opts.ref.current&&(this.#n=g0t(this.opts.ref.current))};#h=e=>this.opts.ref.current?nOe(this.opts.ref.current,e):!1;#m=f1e(()=>{for(const e in this.#r)this.#r[e]=!1;this.#n=!1},20);#v(){return Object.values(this.#r).some(Boolean)}#_=()=>{this.#i=!0};#S=()=>{this.#i=!1};props={onfocuscapture:this.#_,onblurcapture:this.#S}}function p0t(t=[...globalThis.bitsDismissableLayers]){return t.findLast(([e,{current:r}])=>r==="close"||r==="ignore")}function g0t(t){const e=[...globalThis.bitsDismissableLayers],r=p0t(e);if(r)return r[0].opts.ref.current===t;const[n]=e[0];return n.opts.ref.current===t}function m0t(t,e){const r=t.target;if(!JNe(r))return!1;const n=!!r.closest(`[${i0t}]`),i=!!e.closest(`[${a0t}]`);return"button"in t&&t.button>0&&!n?!1:"button"in t&&t.button===0&&n&&i?!0:n&&i?!1:iOe(r).documentElement.contains(r)&&!nOe(e,r)&&Nmt(t,e)}function v1e(t){const e=t.currentTarget,r=t.target;let n;t instanceof PointerEvent?n=new PointerEvent(t.type,t):n=new PointerEvent("pointerdown",t);let i=!1;return new Proxy(n,{get:(s,o)=>o==="currentTarget"?e:o==="target"?r:o==="preventDefault"?()=>{i=!0,typeof s.preventDefault=="function"&&s.preventDefault()}:o==="defaultPrevented"?i:o in s?s[o]:t[o]})}function yoe(t,e){at(e,!0);let r=ce(e,"interactOutsideBehavior",3,"close"),n=ce(e,"onInteractOutside",3,Tn),i=ce(e,"onFocusOutside",3,Tn),a=ce(e,"isValidEvent",3,()=>!1);const s=voe.create({id:_t(()=>e.id),interactOutsideBehavior:_t(()=>r()),onInteractOutside:_t(()=>n()),enabled:_t(()=>e.enabled),onFocusOutside:_t(()=>i()),isValidEvent:_t(()=>a()),ref:e.ref});var o=Ae(),l=oe(o);Pt(l,()=>e.children??Vt,()=>({props:s.props})),G(t,o),st()}globalThis.bitsEscapeLayers??=new Map;class boe{static create(e){return new boe(e)}opts;domContext;constructor(e){this.opts=e,this.domContext=new wf(this.opts.ref);let r=Tn;yi(()=>e.enabled.current,n=>(n&&(globalThis.bitsEscapeLayers.set(this,e.escapeKeydownBehavior),r=this.#e()),()=>{r(),globalThis.bitsEscapeLayers.delete(this)}))}#e=()=>Bi(this.domContext.getDocument(),"keydown",this.#t,{passive:!1});#t=e=>{if(e.key!==nmt||!_0t(this))return;const r=new KeyboardEvent(e.type,e);e.preventDefault();const n=this.opts.escapeKeydownBehavior.current;n!=="close"&&n!=="defer-otherwise-close"||this.opts.onEscapeKeydown.current(r)}}function _0t(t){const e=[...globalThis.bitsEscapeLayers],r=e.findLast(([i,{current:a}])=>a==="close"||a==="ignore");if(r)return r[0]===t;const[n]=e[0];return n===t}function Soe(t,e){at(e,!0);let r=ce(e,"escapeKeydownBehavior",3,"close"),n=ce(e,"onEscapeKeydown",3,Tn);boe.create({escapeKeydownBehavior:_t(()=>r()),onEscapeKeydown:_t(()=>n()),enabled:_t(()=>e.enabled),ref:e.ref});var i=Ae(),a=oe(i);Pt(a,()=>e.children??Vt),G(t,i),st()}class Eoe{static instance;#e=xu([]);#t=new WeakMap;#r=new WeakMap;static getInstance(){return this.instance||(this.instance=new Eoe),this.instance}register(e){const r=this.getActive();r&&r!==e&&r.pause();const n=document.activeElement;n&&n!==document.body&&this.#r.set(e,n),this.#e.current=this.#e.current.filter(i=>i!==e),this.#e.current.unshift(e)}unregister(e){this.#e.current=this.#e.current.filter(n=>n!==e);const r=this.getActive();r&&r.resume()}getActive(){return this.#e.current[0]}setFocusMemory(e,r){this.#t.set(e,r)}getFocusMemory(e){return this.#t.get(e)}isActiveScope(e){return this.getActive()===e}setPreFocusMemory(e,r){this.#r.set(e,r)}getPreFocusMemory(e){return this.#r.get(e)}clearPreFocusMemory(e){this.#r.delete(e)}}class Toe{#e=!1;#t=null;#r=Eoe.getInstance();#n=[];#i;constructor(e){this.#i=e}get paused(){return this.#e}pause(){this.#e=!0}resume(){this.#e=!1}#a(){for(const e of this.#n)e();this.#n=[]}mount(e){this.#t&&this.unmount(),this.#t=e,this.#r.register(this),this.#l(),this.#s()}unmount(){this.#t&&(this.#a(),this.#o(),this.#r.unregister(this),this.#r.clearPreFocusMemory(this),this.#t=null)}#s(){if(!this.#t)return;const e=new CustomEvent("focusScope.onOpenAutoFocus",{bubbles:!1,cancelable:!0});this.#i.onOpenAutoFocus.current(e),e.defaultPrevented||requestAnimationFrame(()=>{if(!this.#t)return;const r=this.#d();r?(r.focus(),this.#r.setFocusMemory(this,r)):this.#t.focus()})}#o(){const e=new CustomEvent("focusScope.onCloseAutoFocus",{bubbles:!1,cancelable:!0});if(this.#i.onCloseAutoFocus.current?.(e),!e.defaultPrevented){const r=this.#r.getPreFocusMemory(this);if(r&&document.contains(r))try{r.focus()}catch{document.body.focus()}}}#l(){if(!this.#t||!this.#i.trap.current)return;const e=this.#t,r=e.ownerDocument,n=s=>{if(this.#e||!this.#r.isActiveScope(this))return;const o=s.target;if(!o)return;if(e.contains(o))this.#r.setFocusMemory(this,o);else{const u=this.#r.getFocusMemory(this);if(u&&e.contains(u)&&gOe(u))s.preventDefault(),u.focus();else{const d=this.#d(),h=this.#u()[0];(d||h||e).focus()}}},i=s=>{if(!this.#i.loop||this.#e||s.key!=="Tab"||!this.#r.isActiveScope(this))return;const o=this.#c();if(o.length===0)return;const l=o[0],u=o[o.length-1];!s.shiftKey&&r.activeElement===u?(s.preventDefault(),l.focus()):s.shiftKey&&r.activeElement===l&&(s.preventDefault(),u.focus())};this.#n.push(Bi(r,"focusin",n,{capture:!0}),Bi(e,"keydown",i));const a=new MutationObserver(()=>{const s=this.#r.getFocusMemory(this);if(s&&!e.contains(s)){const o=this.#d(),l=this.#u()[0],u=o||l;u?(u.focus(),this.#r.setFocusMemory(this,u)):e.focus()}});a.observe(e,{childList:!0,subtree:!0}),this.#n.push(()=>a.disconnect())}#c(){return this.#t?fOe(this.#t,{includeContainer:!1,getShadowRoot:!0}):[]}#d(){return this.#c()[0]||null}#u(){return this.#t?pOe(this.#t,{includeContainer:!1,getShadowRoot:!0}):[]}static use(e){let r=null;return yi([()=>e.ref.current,()=>e.enabled.current],([n,i])=>{n&&i?(r||(r=new Toe(e)),r.mount(n)):r&&(r.unmount(),r=null)}),Sh(()=>{r?.unmount()}),{get props(){return{tabindex:-1}}}}}function Coe(t,e){at(e,!0);let r=ce(e,"enabled",3,!1),n=ce(e,"trapFocus",3,!1),i=ce(e,"loop",3,!1),a=ce(e,"onCloseAutoFocus",3,Tn),s=ce(e,"onOpenAutoFocus",3,Tn);const o=Toe.use({enabled:_t(()=>r()),trap:_t(()=>n()),loop:i(),onCloseAutoFocus:_t(()=>a()),onOpenAutoFocus:_t(()=>s()),ref:e.ref});var l=Ae(),u=oe(l);Pt(u,()=>e.focusScope??Vt,()=>({props:o.props})),G(t,l),st()}const y1e=()=>{};globalThis.bitsTextSelectionLayers??=new Map;class woe{static create(e){return new woe(e)}opts;domContext;#e=Tn;#t=!1;#r=y1e;#n=y1e;constructor(e){this.opts=e,this.domContext=new wf(e.ref);let r=Tn;yi(()=>[this.opts.enabled.current,this.opts.onPointerDown.current,this.opts.onPointerUp.current],([n,i,a])=>(this.#t=n,this.#r=i,this.#n=a,n&&(globalThis.bitsTextSelectionLayers.set(this,this.opts.enabled),r(),r=this.#i()),()=>{this.#t=!1,r(),this.#o(),globalThis.bitsTextSelectionLayers.delete(this)}))}#i(){return Vb(Bi(this.domContext.getDocument(),"pointerdown",this.#s),Bi(this.domContext.getDocument(),"pointerup",qNe(this.#o,this.#a)))}#a=e=>{this.#n(e)};#s=e=>{const r=this.opts.ref.current,n=e.target;!wp(r)||!wp(n)||!this.#t||!y0t(this)||!Zgt(r,n)||(this.#r(e),!e.defaultPrevented&&(this.#e=v0t(r,this.domContext.getDocument().body)))};#o=()=>{this.#e(),this.#e=Tn}}const b1e=t=>t.style.userSelect||t.style.webkitUserSelect;function v0t(t,e){const r=b1e(e),n=b1e(t);return LO(e,"none"),LO(t,"text"),()=>{LO(e,r),LO(t,n)}}function LO(t,e){t.style.userSelect=e,t.style.webkitUserSelect=e}function y0t(t){const e=[...globalThis.bitsTextSelectionLayers];if(!e.length)return!1;const r=e.at(-1);return r?r[0]===t:!1}function xoe(t,e){at(e,!0);let r=ce(e,"preventOverflowTextSelection",3,!0),n=ce(e,"onPointerDown",3,Tn),i=ce(e,"onPointerUp",3,Tn);woe.create({id:_t(()=>e.id),onPointerDown:_t(()=>n()),onPointerUp:_t(()=>i()),enabled:_t(()=>e.enabled&&r()),ref:e.ref});var a=Ae(),s=oe(a);Pt(s,()=>e.children??Vt),G(t,a),st()}globalThis.bitsIdCounter??={current:0};function h4(t="bits"){return globalThis.bitsIdCounter.current++,`${t}-${globalThis.bitsIdCounter.current}`}class b0t{#e;#t=0;#r=Oe();#n;constructor(e){this.#e=e}#i(){this.#t-=1,this.#n&&this.#t<=0&&(this.#n(),X(this.#r,void 0),this.#n=void 0)}get(...e){return this.#t+=1,S(this.#r)===void 0&&(this.#n=v8(()=>{X(this.#r,this.#e(...e),!0)})),Kt(()=>()=>{this.#i()}),S(this.#r)}}const wD=new ws;let PO=Oe(null),oH=null,_A=null,vA=!1;const S1e=_t(()=>{for(const t of wD.values())if(t)return!0;return!1});let lH=null;const S0t=new b0t(()=>{function t(){document.body.setAttribute("style",S(PO)??""),document.body.style.removeProperty("--scrollbar-width"),_J&&oH?.(),X(PO,null)}function e(){_A!==null&&(window.clearTimeout(_A),_A=null)}function r(i,a){e(),vA=!0,lH=Date.now();const s=lH,o=()=>{_A=null,lH===s&&(bOe(wD)?vA=!1:(vA=!1,a()))},l=i===null?24:i;_A=window.setTimeout(o,l)}function n(){S(PO)===null&&wD.size===0&&!vA&&X(PO,document.body.getAttribute("style"),!0)}return yi(()=>S1e.current,()=>{if(!S1e.current)return;n(),vA=!1;const i=getComputedStyle(document.documentElement),a=getComputedStyle(document.body),s=i.scrollbarGutter?.includes("stable")||a.scrollbarGutter?.includes("stable"),o=window.innerWidth-document.documentElement.clientWidth,u={padding:Number.parseInt(a.paddingRight??"0",10)+o,margin:Number.parseInt(a.marginRight??"0",10)};o>0&&!s&&(document.body.style.paddingRight=`${u.padding}px`,document.body.style.marginRight=`${u.margin}px`,document.body.style.setProperty("--scrollbar-width",`${o}px`)),document.body.style.overflow="hidden",_J&&(oH=Bi(document,"touchmove",d=>{d.target===document.documentElement&&(d.touches.length>1||d.preventDefault())},{passive:!1})),md(()=>{document.body.style.pointerEvents="none",document.body.style.overflow="hidden"})}),Sh(()=>()=>{oH?.()}),{get lockMap(){return wD},resetBodyStyle:t,scheduleCleanupIfNoNewLocks:r,cancelPendingCleanup:e,ensureInitialStyleCaptured:n}});class E0t{#e=h4();#t;#r=()=>null;#n;locked;constructor(e,r=()=>null){this.#t=e,this.#r=r,this.#n=S0t.get(),this.#n&&(this.#n.cancelPendingCleanup(),this.#n.ensureInitialStyleCaptured(),this.#n.lockMap.set(this.#e,this.#t??!1),this.locked=_t(()=>this.#n.lockMap.get(this.#e)??!1,n=>this.#n.lockMap.set(this.#e,n)),Sh(()=>{if(this.#n.lockMap.delete(this.#e),bOe(this.#n.lockMap))return;const n=this.#r();this.#n.scheduleCleanupIfNoNewLocks(n,()=>{this.#n.resetBodyStyle()})}))}}function bOe(t){for(const[e,r]of t)if(r)return!0;return!1}function X5(t,e){at(e,!0);let r=ce(e,"preventScroll",3,!0),n=ce(e,"restoreScrollDelay",3,null);r()&&new E0t(r(),()=>n()),st()}var T0t=new Set(["$$slots","$$events","$$legacy","id","children","child","ref","forceMount","interactOutsideBehavior","onCloseAutoFocus","onEscapeKeydown","onOpenAutoFocus","onInteractOutside","preventScroll","trapFocus","restoreScrollDelay"]),C0t=se(" ",1),w0t=se("
",1);function x0t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"forceMount",3,!1),s=ce(e,"interactOutsideBehavior",3,"ignore"),o=ce(e,"onCloseAutoFocus",3,Tn),l=ce(e,"onEscapeKeydown",3,Tn),u=ce(e,"onOpenAutoFocus",3,Tn),d=ce(e,"onInteractOutside",3,Tn),h=ce(e,"preventScroll",3,!0),f=ce(e,"trapFocus",3,!0),p=ce(e,"restoreScrollDelay",3,null),g=Tt(e,T0t);const m=EU.create({id:_t(()=>n()),ref:_t(()=>i(),E=>i(E))}),_=W(()=>un(g,m.props));var v=Ae(),b=oe(v);{var y=E=>{Coe(E,{get ref(){return m.opts.ref},loop:!0,get trapFocus(){return f()},get enabled(){return m.root.opts.open.current},get onCloseAutoFocus(){return o()},onOpenAutoFocus:C=>{u()(C),!C.defaultPrevented&&(C.preventDefault(),vU(0,()=>m.opts.ref.current?.focus()))},focusScope:(C,w)=>{let x=()=>w?.().props;Soe(C,Rt(()=>S(_),{get enabled(){return m.root.opts.open.current},get ref(){return m.opts.ref},onEscapeKeydown:A=>{l()(A),!A.defaultPrevented&&m.root.handleClose()},children:(A,R)=>{yoe(A,Rt(()=>S(_),{get ref(){return m.opts.ref},get enabled(){return m.root.opts.open.current},get interactOutsideBehavior(){return s()},onInteractOutside:O=>{d()(O),!O.defaultPrevented&&m.root.handleClose()},children:(O,F)=>{xoe(O,Rt(()=>S(_),{get ref(){return m.opts.ref},get enabled(){return m.root.opts.open.current},children:(P,N)=>{var k=Ae(),M=oe(k);{var L=U=>{var B=C0t(),$=oe(B);{var H=V=>{X5(V,{get preventScroll(){return h()},get restoreScrollDelay(){return p()}})};ve($,V=>{m.root.opts.open.current&&V(H)})}var q=ie($,2);{let V=W(()=>({props:un(S(_),x()),...m.snippetProps}));Pt(q,()=>e.child,()=>S(V))}G(U,B)},I=U=>{var B=w0t(),$=oe(B);X5($,{get preventScroll(){return h()}});var H=ie($,2);Er(H,V=>({...V}),[()=>un(S(_),x())]);var q=te(H);Pt(q,()=>e.children??Vt),Z(H),G(U,B)};ve(M,U=>{e.child?U(L):U(I,-1)})}G(P,k)},$$slots:{default:!0}}))},$$slots:{default:!0}}))},$$slots:{default:!0}}))},$$slots:{focusScope:!0}})};ve(b,E=>{(m.shouldRender||a())&&E(y)})}G(t,v),st()}var A0t=new Set(["$$slots","$$events","$$legacy","id","forceMount","child","children","ref"]),R0t=se("
");function xU(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"forceMount",3,!1),a=ce(e,"ref",15,null),s=Tt(e,A0t);const o=ooe.create({id:_t(()=>n()),ref:_t(()=>a(),f=>a(f))}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=f=>{var p=Ae(),g=oe(p);{var m=v=>{var b=Ae(),y=oe(b);{let E=W(()=>({props:un(S(l)),...o.snippetProps}));Pt(y,()=>e.child,()=>S(E))}G(v,b)},_=v=>{var b=R0t();Er(b,E=>({...E}),[()=>un(S(l))]);var y=te(b);Pt(y,()=>e.children??Vt,()=>o.snippetProps),Z(b),G(v,b)};ve(g,v=>{e.child?v(m):v(_,-1)})}G(f,p)};ve(d,f=>{(o.shouldRender||i())&&f(h)})}G(t,u),st()}var N0t=new Set(["$$slots","$$events","$$legacy","id","children","child","ref"]),O0t=se("
");function Aoe(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=Tt(e,N0t);const s=soe.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);Pt(g,()=>e.child,()=>({props:S(o)})),G(f,p)},h=f=>{var p=O0t();Er(p,()=>({...S(o)}));var g=te(p);Pt(g,()=>e.children??Vt),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}const I0t=xf({component:"checkbox",parts:["root","group","group-label","input"]}),k0t=new Ys("Checkbox.Group"),SOe=new Ys("Checkbox.Root");class Roe{static create(e,r=null){return SOe.set(new Roe(e,r))}opts;group;#e=W(()=>this.group&&this.group.opts.name.current?this.group.opts.name.current:this.opts.name.current);get trueName(){return S(this.#e)}set trueName(e){X(this.#e,e)}#t=W(()=>this.group&&this.group.opts.required.current?!0:this.opts.required.current);get trueRequired(){return S(this.#t)}set trueRequired(e){X(this.#t,e)}#r=W(()=>this.group&&this.group.opts.disabled.current?!0:this.opts.disabled.current);get trueDisabled(){return S(this.#r)}set trueDisabled(e){X(this.#r,e)}#n=W(()=>this.group&&this.group.opts.readonly.current?!0:this.opts.readonly.current);get trueReadonly(){return S(this.#n)}set trueReadonly(e){X(this.#n,e)}attachment;constructor(e,r){this.opts=e,this.group=r,this.attachment=$i(this.opts.ref),this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this),yi.pre([()=>k_(this.group?.opts.value.current),()=>this.opts.value.current],([n,i])=>{!n||!i||(this.opts.checked.current=n.includes(i))}),yi.pre(()=>this.opts.checked.current,n=>{this.group&&(n?this.group?.addValue(this.opts.value.current):this.group?.removeValue(this.opts.value.current))})}onkeydown(e){if(!(this.trueDisabled||this.trueReadonly)){if(e.key===Kg){e.preventDefault(),this.opts.type.current==="submit"&&e.currentTarget.closest("form")?.requestSubmit();return}e.key===xd&&(e.preventDefault(),this.#i())}}#i(){this.opts.indeterminate.current?(this.opts.indeterminate.current=!1,this.opts.checked.current=!0):this.opts.checked.current=!this.opts.checked.current}onclick(e){if(!(this.trueDisabled||this.trueReadonly)){if(this.opts.type.current==="submit"){this.#i();return}e.preventDefault(),this.#i()}}#a=W(()=>({checked:this.opts.checked.current,indeterminate:this.opts.indeterminate.current}));get snippetProps(){return S(this.#a)}set snippetProps(e){X(this.#a,e)}#s=W(()=>({id:this.opts.id.current,role:"checkbox",type:this.opts.type.current,disabled:this.trueDisabled,"aria-checked":eoe(this.opts.checked.current,this.opts.indeterminate.current),"aria-required":vf(this.trueRequired),"aria-readonly":vf(this.trueReadonly),"data-disabled":Uo(this.trueDisabled),"data-readonly":Uo(this.trueReadonly),"data-state":D0t(this.opts.checked.current,this.opts.indeterminate.current),[I0t.root]:"",onclick:this.onclick,onkeydown:this.onkeydown,...this.attachment}));get props(){return S(this.#s)}set props(e){X(this.#s,e)}}class Noe{static create(){return new Noe(SOe.get())}root;#e=W(()=>this.root.group?!!(this.root.opts.value.current!==void 0&&this.root.group.opts.value.current.includes(this.root.opts.value.current)):this.root.opts.checked.current);get trueChecked(){return S(this.#e)}set trueChecked(e){X(this.#e,e)}#t=W(()=>!!this.root.trueName);get shouldRender(){return S(this.#t)}set shouldRender(e){X(this.#t,e)}constructor(e){this.root=e,this.onfocus=this.onfocus.bind(this)}onfocus(e){wp(this.root.opts.ref.current)&&this.root.opts.ref.current.focus()}#r=W(()=>({type:"checkbox",checked:this.root.opts.checked.current===!0,disabled:this.root.trueDisabled,required:this.root.trueRequired,name:this.root.trueName,value:this.root.opts.value.current,readonly:this.root.trueReadonly,onfocus:this.onfocus}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}function D0t(t,e){return e?"indeterminate":t?"checked":"unchecked"}Pdt();var M0t=new Set(["$$slots","$$events","$$legacy","value"]),E1e=se("");function AU(t,e){at(e,!0);let r=ce(e,"value",15),n=Tt(e,M0t);const i=W(()=>un(n,{"aria-hidden":"true",tabindex:-1,style:{...VNe,position:"absolute",top:"0",left:"0"}}));var a=Ae(),s=oe(a);{var o=u=>{var d=E1e();Er(d,()=>({...S(i),value:r()}),void 0,void 0,void 0,void 0,!0),G(u,d)},l=u=>{var d=E1e();Er(d,()=>({...S(i)}),void 0,void 0,void 0,void 0,!0),wR(d,r),G(u,d)};ve(s,u=>{S(i).type==="checkbox"?u(o):u(l,-1)})}G(t,a),st()}function L0t(t,e){at(e,!1);const r=Noe.create();d4();var n=Ae(),i=oe(n);{var a=s=>{AU(s,Rt(()=>r.props))};ve(i,s=>{r.shouldRender&&s(a)})}G(t,n),st()}var P0t=new Set(["$$slots","$$events","$$legacy","checked","ref","onCheckedChange","children","disabled","required","name","value","id","indeterminate","onIndeterminateChange","child","type","readonly"]),F0t=se(""),B0t=se(" ",1);function U0t(t,e){const r=Vi();at(e,!0);let n=ce(e,"checked",15,!1),i=ce(e,"ref",15,null),a=ce(e,"disabled",3,!1),s=ce(e,"required",3,!1),o=ce(e,"name",3,void 0),l=ce(e,"value",3,"on"),u=ce(e,"id",19,()=>Yi(r)),d=ce(e,"indeterminate",15,!1),h=ce(e,"type",3,"button"),f=Tt(e,P0t);const p=k0t.getOr(null);p&&l()&&(p.opts.value.current.includes(l())?n(!0):n(!1)),yi.pre(()=>l(),()=>{p&&l()&&(p.opts.value.current.includes(l())?n(!0):n(!1))});const g=Roe.create({checked:_t(()=>n(),T=>{n(T),e.onCheckedChange?.(T)}),disabled:_t(()=>a()??!1),required:_t(()=>s()),name:_t(()=>o()),value:_t(()=>l()),id:_t(()=>u()),ref:_t(()=>i(),T=>i(T)),indeterminate:_t(()=>d(),T=>{d(T),e.onIndeterminateChange?.(T)}),type:_t(()=>h()),readonly:_t(()=>!!e.readonly)},p),m=W(()=>un({...f},g.props));var _=B0t(),v=oe(_);{var b=T=>{var C=Ae(),w=oe(C);{let x=W(()=>({props:S(m),...g.snippetProps}));Pt(w,()=>e.child,()=>S(x))}G(T,C)},y=T=>{var C=F0t();Er(C,()=>({...S(m)}));var w=te(C);Pt(w,()=>e.children??Vt,()=>g.snippetProps),Z(C),G(T,C)};ve(v,T=>{e.child?T(b):T(y,-1)})}var E=ie(v,2);L0t(E,{}),G(t,_),st()}const Ooe=xf({component:"collapsible",parts:["root","content","trigger"]}),Ioe=new Ys("Collapsible.Root");class koe{static create(e){return Ioe.set(new koe(e))}opts;attachment;#e=Oe(null);get contentNode(){return S(this.#e)}set contentNode(e){X(this.#e,e,!0)}contentPresence;#t=Oe(void 0);get contentId(){return S(this.#t)}set contentId(e){X(this.#t,e,!0)}constructor(e){this.opts=e,this.toggleOpen=this.toggleOpen.bind(this),this.attachment=$i(this.opts.ref),this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}})}toggleOpen(){this.opts.open.current=!this.opts.open.current}#r=W(()=>({id:this.opts.id.current,"data-state":Eh(this.opts.open.current),"data-disabled":Uo(this.opts.disabled.current),[Ooe.root]:"",...this.attachment}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}class Doe{static create(e){return new Doe(e,Ioe.get())}opts;root;attachment;#e=W(()=>this.opts.hiddenUntilFound.current?this.root.opts.open.current:this.opts.forceMount.current||this.root.opts.open.current);get present(){return S(this.#e)}set present(e){X(this.#e,e)}#t;#r=Oe(!1);#n=Oe(0);#i=Oe(0);constructor(e,r){this.opts=e,this.root=r,X(this.#r,r.opts.open.current,!0),this.root.contentId=this.opts.id.current,this.attachment=$i(this.opts.ref,n=>this.root.contentNode=n),yi.pre(()=>this.opts.id.current,n=>{this.root.contentId=n}),uc(()=>{const n=requestAnimationFrame(()=>{X(this.#r,!1)});return()=>{cancelAnimationFrame(n)}}),yi.pre([()=>this.opts.ref.current,()=>this.opts.hiddenUntilFound.current],([n,i])=>!n||!i?void 0:Bi(n,"beforematch",()=>{this.root.opts.open.current||requestAnimationFrame(()=>{this.root.opts.open.current=!0})})),yi([()=>this.opts.ref.current,()=>this.present],([n])=>{n&&md(()=>{if(!this.opts.ref.current)return;this.#t=this.#t||{transitionDuration:n.style.transitionDuration,animationName:n.style.animationName},n.style.transitionDuration="0s",n.style.animationName="none";const i=n.getBoundingClientRect();if(X(this.#i,i.height,!0),X(this.#n,i.width,!0),!S(this.#r)){const{animationName:a,transitionDuration:s}=this.#t;n.style.transitionDuration=s,n.style.animationName=a}})})}get shouldRender(){return this.root.contentPresence.shouldRender}#a=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#a)}set snippetProps(e){X(this.#a,e)}#s=W(()=>({id:this.opts.id.current,style:{"--bits-collapsible-content-height":S(this.#i)?`${S(this.#i)}px`:void 0,"--bits-collapsible-content-width":S(this.#n)?`${S(this.#n)}px`:void 0},hidden:this.opts.hiddenUntilFound.current&&!this.root.opts.open.current?"until-found":void 0,"data-state":Eh(this.root.opts.open.current),...xv(this.root.contentPresence.transitionStatus),"data-disabled":Uo(this.root.opts.disabled.current),[Ooe.content]:"",...this.opts.hiddenUntilFound.current&&!this.shouldRender?{}:{hidden:this.opts.hiddenUntilFound.current?!this.shouldRender:this.opts.forceMount.current?void 0:!this.shouldRender},...this.attachment}));get props(){return S(this.#s)}set props(e){X(this.#s,e)}}class Moe{static create(e){return new Moe(e,Ioe.get())}opts;root;attachment;#e=W(()=>this.opts.disabled.current||this.root.opts.disabled.current);constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this)}onclick(e){if(!S(this.#e)){if(e.button!==0)return e.preventDefault();this.root.toggleOpen()}}onkeydown(e){S(this.#e)||(e.key===xd||e.key===Kg)&&(e.preventDefault(),this.root.toggleOpen())}#t=W(()=>({id:this.opts.id.current,type:"button",disabled:S(this.#e),"aria-controls":this.root.contentId,"aria-expanded":vf(this.root.opts.open.current),"data-state":Eh(this.root.opts.open.current),"data-disabled":Uo(S(this.#e)),[Ooe.trigger]:"",onclick:this.onclick,onkeydown:this.onkeydown,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}var $0t=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","open","disabled","onOpenChange","onOpenChangeComplete"]),G0t=se("
");function z0t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"open",15,!1),s=ce(e,"disabled",3,!1),o=ce(e,"onOpenChange",3,Tn),l=ce(e,"onOpenChangeComplete",3,Tn),u=Tt(e,$0t);const d=koe.create({open:_t(()=>a(),_=>{a(_),o()(_)}),disabled:_t(()=>s()),id:_t(()=>n()),ref:_t(()=>i(),_=>i(_)),onOpenChangeComplete:_t(()=>l())}),h=W(()=>un(u,d.props));var f=Ae(),p=oe(f);{var g=_=>{var v=Ae(),b=oe(v);Pt(b,()=>e.child,()=>({props:S(h)})),G(_,v)},m=_=>{var v=G0t();Er(v,()=>({...S(h)}));var b=te(v);Pt(b,()=>e.children??Vt),Z(v),G(_,v)};ve(p,_=>{e.child?_(g):_(m,-1)})}G(t,f),st()}var q0t=new Set(["$$slots","$$events","$$legacy","child","ref","forceMount","hiddenUntilFound","children","id"]),H0t=se("
");function V0t(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"forceMount",3,!1),a=ce(e,"hiddenUntilFound",3,!1),s=ce(e,"id",19,()=>Yi(r)),o=Tt(e,q0t);const l=Doe.create({id:_t(()=>s()),forceMount:_t(()=>i()),hiddenUntilFound:_t(()=>a()),ref:_t(()=>n(),g=>n(g))}),u=W(()=>un(o,l.props));var d=Ae(),h=oe(d);{var f=g=>{var m=Ae(),_=oe(m);{let v=W(()=>({...l.snippetProps,props:S(u)}));Pt(_,()=>e.child,()=>S(v))}G(g,m)},p=g=>{var m=H0t();Er(m,()=>({...S(u)}));var _=te(m);Pt(_,()=>e.children??Vt),Z(m),G(g,m)};ve(h,g=>{e.child?g(f):g(p,-1)})}G(t,d),st()}var Y0t=new Set(["$$slots","$$events","$$legacy","children","child","ref","id","disabled"]),W0t=se("");function K0t(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=ce(e,"disabled",3,!1),s=Tt(e,Y0t);const o=Moe.create({id:_t(()=>i()),ref:_t(()=>n(),p=>n(p)),disabled:_t(()=>a())}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=p=>{var g=Ae(),m=oe(g);Pt(m,()=>e.child,()=>({props:S(l)})),G(p,g)},f=p=>{var g=W0t();Er(g,()=>({...S(l)}));var m=te(g);Pt(m,()=>e.children??Vt),Z(g),G(p,g)};ve(d,p=>{e.child?p(h):p(f,-1)})}G(t,u),st()}const j0t=["top","right","bottom","left"],W_=Math.min,Xd=Math.max,RL=Math.round,FO=Math.floor,Fg=t=>({x:t,y:t}),X0t={left:"right",right:"left",bottom:"top",top:"bottom"};function bJ(t,e,r){return Xd(t,W_(e,r))}function U0(t,e){return typeof t=="function"?t(e):t}function $0(t){return t.split("-")[0]}function f4(t){return t.split("-")[1]}function Loe(t){return t==="x"?"y":"x"}function Poe(t){return t==="y"?"height":"width"}function xg(t){const e=t[0];return e==="t"||e==="b"?"y":"x"}function Foe(t){return Loe(xg(t))}function Q0t(t,e,r){r===void 0&&(r=!1);const n=f4(t),i=Foe(t),a=Poe(i);let s=i==="x"?n===(r?"end":"start")?"right":"left":n==="start"?"bottom":"top";return e.reference[a]>e.floating[a]&&(s=NL(s)),[s,NL(s)]}function Z0t(t){const e=NL(t);return[SJ(t),e,SJ(e)]}function SJ(t){return t.includes("start")?t.replace("start","end"):t.replace("end","start")}const T1e=["left","right"],C1e=["right","left"],J0t=["top","bottom"],e1t=["bottom","top"];function t1t(t,e,r){switch(t){case"top":case"bottom":return r?e?C1e:T1e:e?T1e:C1e;case"left":case"right":return e?J0t:e1t;default:return[]}}function r1t(t,e,r,n){const i=f4(t);let a=t1t($0(t),r==="start",n);return i&&(a=a.map(s=>s+"-"+i),e&&(a=a.concat(a.map(SJ)))),a}function NL(t){const e=$0(t);return X0t[e]+t.slice(e.length)}function n1t(t){return{top:0,right:0,bottom:0,left:0,...t}}function EOe(t){return typeof t!="number"?n1t(t):{top:t,right:t,bottom:t,left:t}}function OL(t){const{x:e,y:r,width:n,height:i}=t;return{width:n,height:i,top:r,left:e,right:e+n,bottom:r+i,x:e,y:r}}function w1e(t,e,r){let{reference:n,floating:i}=t;const a=xg(e),s=Foe(e),o=Poe(s),l=$0(e),u=a==="y",d=n.x+n.width/2-i.width/2,h=n.y+n.height/2-i.height/2,f=n[o]/2-i[o]/2;let p;switch(l){case"top":p={x:d,y:n.y-i.height};break;case"bottom":p={x:d,y:n.y+n.height};break;case"right":p={x:n.x+n.width,y:h};break;case"left":p={x:n.x-i.width,y:h};break;default:p={x:n.x,y:n.y}}switch(f4(e)){case"start":p[s]-=f*(r&&u?-1:1);break;case"end":p[s]+=f*(r&&u?-1:1);break}return p}async function i1t(t,e){var r;e===void 0&&(e={});const{x:n,y:i,platform:a,rects:s,elements:o,strategy:l}=t,{boundary:u="clippingAncestors",rootBoundary:d="viewport",elementContext:h="floating",altBoundary:f=!1,padding:p=0}=U0(e,t),g=EOe(p),_=o[f?h==="floating"?"reference":"floating":h],v=OL(await a.getClippingRect({element:(r=await(a.isElement==null?void 0:a.isElement(_)))==null||r?_:_.contextElement||await(a.getDocumentElement==null?void 0:a.getDocumentElement(o.floating)),boundary:u,rootBoundary:d,strategy:l})),b=h==="floating"?{x:n,y:i,width:s.floating.width,height:s.floating.height}:s.reference,y=await(a.getOffsetParent==null?void 0:a.getOffsetParent(o.floating)),E=await(a.isElement==null?void 0:a.isElement(y))?await(a.getScale==null?void 0:a.getScale(y))||{x:1,y:1}:{x:1,y:1},T=OL(a.convertOffsetParentRelativeRectToViewportRelativeRect?await a.convertOffsetParentRelativeRectToViewportRelativeRect({elements:o,rect:b,offsetParent:y,strategy:l}):b);return{top:(v.top-T.top+g.top)/E.y,bottom:(T.bottom-v.bottom+g.bottom)/E.y,left:(v.left-T.left+g.left)/E.x,right:(T.right-v.right+g.right)/E.x}}const a1t=50,s1t=async(t,e,r)=>{const{placement:n="bottom",strategy:i="absolute",middleware:a=[],platform:s}=r,o=s.detectOverflow?s:{...s,detectOverflow:i1t},l=await(s.isRTL==null?void 0:s.isRTL(e));let u=await s.getElementRects({reference:t,floating:e,strategy:i}),{x:d,y:h}=w1e(u,n,l),f=n,p=0;const g={};for(let m=0;m({name:"arrow",options:t,async fn(e){const{x:r,y:n,placement:i,rects:a,platform:s,elements:o,middlewareData:l}=e,{element:u,padding:d=0}=U0(t,e)||{};if(u==null)return{};const h=EOe(d),f={x:r,y:n},p=Foe(i),g=Poe(p),m=await s.getDimensions(u),_=p==="y",v=_?"top":"left",b=_?"bottom":"right",y=_?"clientHeight":"clientWidth",E=a.reference[g]+a.reference[p]-f[p]-a.floating[g],T=f[p]-a.reference[p],C=await(s.getOffsetParent==null?void 0:s.getOffsetParent(u));let w=C?C[y]:0;(!w||!await(s.isElement==null?void 0:s.isElement(C)))&&(w=o.floating[y]||a.floating[g]);const x=E/2-T/2,A=w/2-m[g]/2-1,R=W_(h[v],A),O=W_(h[b],A),F=R,P=w-m[g]-O,N=w/2-m[g]/2+x,k=bJ(F,N,P),M=!l.arrow&&f4(i)!=null&&N!==k&&a.reference[g]/2-(NN<=0)){var O,F;const N=(((O=a.flip)==null?void 0:O.index)||0)+1,k=w[N];if(k&&(!(h==="alignment"?b!==xg(k):!1)||R.every(I=>xg(I.placement)===b?I.overflows[0]>0:!0)))return{data:{index:N,overflows:R},reset:{placement:k}};let M=(F=R.filter(L=>L.overflows[0]<=0).sort((L,I)=>L.overflows[1]-I.overflows[1])[0])==null?void 0:F.placement;if(!M)switch(p){case"bestFit":{var P;const L=(P=R.filter(I=>{if(C){const U=xg(I.placement);return U===b||U==="y"}return!0}).map(I=>[I.placement,I.overflows.filter(U=>U>0).reduce((U,B)=>U+B,0)]).sort((I,U)=>I[1]-U[1])[0])==null?void 0:P[0];L&&(M=L);break}case"initialPlacement":M=o;break}if(i!==M)return{reset:{placement:M}}}return{}}}};function x1e(t,e){return{top:t.top-e.height,right:t.right-e.width,bottom:t.bottom-e.height,left:t.left-e.width}}function A1e(t){return j0t.some(e=>t[e]>=0)}const c1t=function(t){return t===void 0&&(t={}),{name:"hide",options:t,async fn(e){const{rects:r,platform:n}=e,{strategy:i="referenceHidden",...a}=U0(t,e);switch(i){case"referenceHidden":{const s=await n.detectOverflow(e,{...a,elementContext:"reference"}),o=x1e(s,r.reference);return{data:{referenceHiddenOffsets:o,referenceHidden:A1e(o)}}}case"escaped":{const s=await n.detectOverflow(e,{...a,altBoundary:!0}),o=x1e(s,r.floating);return{data:{escapedOffsets:o,escaped:A1e(o)}}}default:return{}}}}},TOe=new Set(["left","top"]);async function u1t(t,e){const{placement:r,platform:n,elements:i}=t,a=await(n.isRTL==null?void 0:n.isRTL(i.floating)),s=$0(r),o=f4(r),l=xg(r)==="y",u=TOe.has(s)?-1:1,d=a&&l?-1:1,h=U0(e,t);let{mainAxis:f,crossAxis:p,alignmentAxis:g}=typeof h=="number"?{mainAxis:h,crossAxis:0,alignmentAxis:null}:{mainAxis:h.mainAxis||0,crossAxis:h.crossAxis||0,alignmentAxis:h.alignmentAxis};return o&&typeof g=="number"&&(p=o==="end"?g*-1:g),l?{x:p*d,y:f*u}:{x:f*u,y:p*d}}const d1t=function(t){return t===void 0&&(t=0),{name:"offset",options:t,async fn(e){var r,n;const{x:i,y:a,placement:s,middlewareData:o}=e,l=await u1t(e,t);return s===((r=o.offset)==null?void 0:r.placement)&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:i+l.x,y:a+l.y,data:{...l,placement:s}}}}},h1t=function(t){return t===void 0&&(t={}),{name:"shift",options:t,async fn(e){const{x:r,y:n,placement:i,platform:a}=e,{mainAxis:s=!0,crossAxis:o=!1,limiter:l={fn:v=>{let{x:b,y}=v;return{x:b,y}}},...u}=U0(t,e),d={x:r,y:n},h=await a.detectOverflow(e,u),f=xg($0(i)),p=Loe(f);let g=d[p],m=d[f];if(s){const v=p==="y"?"top":"left",b=p==="y"?"bottom":"right",y=g+h[v],E=g-h[b];g=bJ(y,g,E)}if(o){const v=f==="y"?"top":"left",b=f==="y"?"bottom":"right",y=m+h[v],E=m-h[b];m=bJ(y,m,E)}const _=l.fn({...e,[p]:g,[f]:m});return{..._,data:{x:_.x-r,y:_.y-n,enabled:{[p]:s,[f]:o}}}}}},f1t=function(t){return t===void 0&&(t={}),{options:t,fn(e){const{x:r,y:n,placement:i,rects:a,middlewareData:s}=e,{offset:o=0,mainAxis:l=!0,crossAxis:u=!0}=U0(t,e),d={x:r,y:n},h=xg(i),f=Loe(h);let p=d[f],g=d[h];const m=U0(o,e),_=typeof m=="number"?{mainAxis:m,crossAxis:0}:{mainAxis:0,crossAxis:0,...m};if(l){const y=f==="y"?"height":"width",E=a.reference[f]-a.floating[y]+_.mainAxis,T=a.reference[f]+a.reference[y]-_.mainAxis;pT&&(p=T)}if(u){var v,b;const y=f==="y"?"width":"height",E=TOe.has($0(i)),T=a.reference[h]-a.floating[y]+(E&&((v=s.offset)==null?void 0:v[h])||0)+(E?0:_.crossAxis),C=a.reference[h]+a.reference[y]+(E?0:((b=s.offset)==null?void 0:b[h])||0)-(E?_.crossAxis:0);gC&&(g=C)}return{[f]:p,[h]:g}}}},p1t=function(t){return t===void 0&&(t={}),{name:"size",options:t,async fn(e){var r,n;const{placement:i,rects:a,platform:s,elements:o}=e,{apply:l=()=>{},...u}=U0(t,e),d=await s.detectOverflow(e,u),h=$0(i),f=f4(i),p=xg(i)==="y",{width:g,height:m}=a.floating;let _,v;h==="top"||h==="bottom"?(_=h,v=f===(await(s.isRTL==null?void 0:s.isRTL(o.floating))?"start":"end")?"left":"right"):(v=h,_=f==="end"?"top":"bottom");const b=m-d.top-d.bottom,y=g-d.left-d.right,E=W_(m-d[_],b),T=W_(g-d[v],y),C=!e.middlewareData.shift;let w=E,x=T;if((r=e.middlewareData.shift)!=null&&r.enabled.x&&(x=y),(n=e.middlewareData.shift)!=null&&n.enabled.y&&(w=b),C&&!f){const R=Xd(d.left,0),O=Xd(d.right,0),F=Xd(d.top,0),P=Xd(d.bottom,0);p?x=g-2*(R!==0||O!==0?R+O:Xd(d.left,d.right)):w=m-2*(F!==0||P!==0?F+P:Xd(d.top,d.bottom))}await l({...e,availableWidth:x,availableHeight:w});const A=await s.getDimensions(o.floating);return g!==A.width||m!==A.height?{reset:{rects:!0}}:{}}}};function RU(){return typeof window<"u"}function p4(t){return COe(t)?(t.nodeName||"").toLowerCase():"#document"}function ah(t){var e;return(t==null||(e=t.ownerDocument)==null?void 0:e.defaultView)||window}function am(t){var e;return(e=(COe(t)?t.ownerDocument:t.document)||window.document)==null?void 0:e.documentElement}function COe(t){return RU()?t instanceof Node||t instanceof ah(t).Node:!1}function xp(t){return RU()?t instanceof Element||t instanceof ah(t).Element:!1}function c1(t){return RU()?t instanceof HTMLElement||t instanceof ah(t).HTMLElement:!1}function R1e(t){return!RU()||typeof ShadowRoot>"u"?!1:t instanceof ShadowRoot||t instanceof ah(t).ShadowRoot}function R8(t){const{overflow:e,overflowX:r,overflowY:n,display:i}=Ap(t);return/auto|scroll|overlay|hidden|clip/.test(e+n+r)&&i!=="inline"&&i!=="contents"}function g1t(t){return/^(table|td|th)$/.test(p4(t))}function NU(t){try{if(t.matches(":popover-open"))return!0}catch{}try{return t.matches(":modal")}catch{return!1}}const m1t=/transform|translate|scale|rotate|perspective|filter/,_1t=/paint|layout|strict|content/,ty=t=>!!t&&t!=="none";let cH;function Boe(t){const e=xp(t)?Ap(t):t;return ty(e.transform)||ty(e.translate)||ty(e.scale)||ty(e.rotate)||ty(e.perspective)||!Uoe()&&(ty(e.backdropFilter)||ty(e.filter))||m1t.test(e.willChange||"")||_1t.test(e.contain||"")}function v1t(t){let e=K_(t);for(;c1(e)&&!Q5(e);){if(Boe(e))return e;if(NU(e))return null;e=K_(e)}return null}function Uoe(){return cH==null&&(cH=typeof CSS<"u"&&CSS.supports&&CSS.supports("-webkit-backdrop-filter","none")),cH}function Q5(t){return/^(html|body|#document)$/.test(p4(t))}function Ap(t){return ah(t).getComputedStyle(t)}function OU(t){return xp(t)?{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}:{scrollLeft:t.scrollX,scrollTop:t.scrollY}}function K_(t){if(p4(t)==="html")return t;const e=t.assignedSlot||t.parentNode||R1e(t)&&t.host||am(t);return R1e(e)?e.host:e}function wOe(t){const e=K_(t);return Q5(e)?t.ownerDocument?t.ownerDocument.body:t.body:c1(e)&&R8(e)?e:wOe(e)}function IR(t,e,r){var n;e===void 0&&(e=[]),r===void 0&&(r=!0);const i=wOe(t),a=i===((n=t.ownerDocument)==null?void 0:n.body),s=ah(i);if(a){const o=EJ(s);return e.concat(s,s.visualViewport||[],R8(i)?i:[],o&&r?IR(o):[])}else return e.concat(i,IR(i,[],r))}function EJ(t){return t.parent&&Object.getPrototypeOf(t.parent)?t.frameElement:null}function xOe(t){const e=Ap(t);let r=parseFloat(e.width)||0,n=parseFloat(e.height)||0;const i=c1(t),a=i?t.offsetWidth:r,s=i?t.offsetHeight:n,o=RL(r)!==a||RL(n)!==s;return o&&(r=a,n=s),{width:r,height:n,$:o}}function $oe(t){return xp(t)?t:t.contextElement}function BT(t){const e=$oe(t);if(!c1(e))return Fg(1);const r=e.getBoundingClientRect(),{width:n,height:i,$:a}=xOe(e);let s=(a?RL(r.width):r.width)/n,o=(a?RL(r.height):r.height)/i;return(!s||!Number.isFinite(s))&&(s=1),(!o||!Number.isFinite(o))&&(o=1),{x:s,y:o}}const y1t=Fg(0);function AOe(t){const e=ah(t);return!Uoe()||!e.visualViewport?y1t:{x:e.visualViewport.offsetLeft,y:e.visualViewport.offsetTop}}function b1t(t,e,r){return e===void 0&&(e=!1),!r||e&&r!==ah(t)?!1:e}function d2(t,e,r,n){e===void 0&&(e=!1),r===void 0&&(r=!1);const i=t.getBoundingClientRect(),a=$oe(t);let s=Fg(1);e&&(n?xp(n)&&(s=BT(n)):s=BT(t));const o=b1t(a,r,n)?AOe(a):Fg(0);let l=(i.left+o.x)/s.x,u=(i.top+o.y)/s.y,d=i.width/s.x,h=i.height/s.y;if(a){const f=ah(a),p=n&&xp(n)?ah(n):n;let g=f,m=EJ(g);for(;m&&n&&p!==g;){const _=BT(m),v=m.getBoundingClientRect(),b=Ap(m),y=v.left+(m.clientLeft+parseFloat(b.paddingLeft))*_.x,E=v.top+(m.clientTop+parseFloat(b.paddingTop))*_.y;l*=_.x,u*=_.y,d*=_.x,h*=_.y,l+=y,u+=E,g=ah(m),m=EJ(g)}}return OL({width:d,height:h,x:l,y:u})}function IU(t,e){const r=OU(t).scrollLeft;return e?e.left+r:d2(am(t)).left+r}function ROe(t,e){const r=t.getBoundingClientRect(),n=r.left+e.scrollLeft-IU(t,r),i=r.top+e.scrollTop;return{x:n,y:i}}function S1t(t){let{elements:e,rect:r,offsetParent:n,strategy:i}=t;const a=i==="fixed",s=am(n),o=e?NU(e.floating):!1;if(n===s||o&&a)return r;let l={scrollLeft:0,scrollTop:0},u=Fg(1);const d=Fg(0),h=c1(n);if((h||!h&&!a)&&((p4(n)!=="body"||R8(s))&&(l=OU(n)),h)){const p=d2(n);u=BT(n),d.x=p.x+n.clientLeft,d.y=p.y+n.clientTop}const f=s&&!h&&!a?ROe(s,l):Fg(0);return{width:r.width*u.x,height:r.height*u.y,x:r.x*u.x-l.scrollLeft*u.x+d.x+f.x,y:r.y*u.y-l.scrollTop*u.y+d.y+f.y}}function E1t(t){return Array.from(t.getClientRects())}function T1t(t){const e=am(t),r=OU(t),n=t.ownerDocument.body,i=Xd(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),a=Xd(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight);let s=-r.scrollLeft+IU(t);const o=-r.scrollTop;return Ap(n).direction==="rtl"&&(s+=Xd(e.clientWidth,n.clientWidth)-i),{width:i,height:a,x:s,y:o}}const N1e=25;function C1t(t,e){const r=ah(t),n=am(t),i=r.visualViewport;let a=n.clientWidth,s=n.clientHeight,o=0,l=0;if(i){a=i.width,s=i.height;const d=Uoe();(!d||d&&e==="fixed")&&(o=i.offsetLeft,l=i.offsetTop)}const u=IU(n);if(u<=0){const d=n.ownerDocument,h=d.body,f=getComputedStyle(h),p=d.compatMode==="CSS1Compat"&&parseFloat(f.marginLeft)+parseFloat(f.marginRight)||0,g=Math.abs(n.clientWidth-h.clientWidth-p);g<=N1e&&(a-=g)}else u<=N1e&&(a+=u);return{width:a,height:s,x:o,y:l}}function w1t(t,e){const r=d2(t,!0,e==="fixed"),n=r.top+t.clientTop,i=r.left+t.clientLeft,a=c1(t)?BT(t):Fg(1),s=t.clientWidth*a.x,o=t.clientHeight*a.y,l=i*a.x,u=n*a.y;return{width:s,height:o,x:l,y:u}}function O1e(t,e,r){let n;if(e==="viewport")n=C1t(t,r);else if(e==="document")n=T1t(am(t));else if(xp(e))n=w1t(e,r);else{const i=AOe(t);n={x:e.x-i.x,y:e.y-i.y,width:e.width,height:e.height}}return OL(n)}function NOe(t,e){const r=K_(t);return r===e||!xp(r)||Q5(r)?!1:Ap(r).position==="fixed"||NOe(r,e)}function x1t(t,e){const r=e.get(t);if(r)return r;let n=IR(t,[],!1).filter(o=>xp(o)&&p4(o)!=="body"),i=null;const a=Ap(t).position==="fixed";let s=a?K_(t):t;for(;xp(s)&&!Q5(s);){const o=Ap(s),l=Boe(s);!l&&o.position==="fixed"&&(i=null),(a?!l&&!i:!l&&o.position==="static"&&!!i&&(i.position==="absolute"||i.position==="fixed")||R8(s)&&!l&&NOe(t,s))?n=n.filter(d=>d!==s):i=o,s=K_(s)}return e.set(t,n),n}function A1t(t){let{element:e,boundary:r,rootBoundary:n,strategy:i}=t;const s=[...r==="clippingAncestors"?NU(e)?[]:x1t(e,this._c):[].concat(r),n],o=O1e(e,s[0],i);let l=o.top,u=o.right,d=o.bottom,h=o.left;for(let f=1;f{s(!1,1e-7)},1e3)}w===1&&!IOe(u,t.getBoundingClientRect())&&s(),E=!1}try{r=new IntersectionObserver(T,{...y,root:i.ownerDocument})}catch{r=new IntersectionObserver(T,y)}r.observe(t)}return s(!0),a}function M1t(t,e,r,n){n===void 0&&(n={});const{ancestorScroll:i=!0,ancestorResize:a=!0,elementResize:s=typeof ResizeObserver=="function",layoutShift:o=typeof IntersectionObserver=="function",animationFrame:l=!1}=n,u=$oe(t),d=i||a?[...u?IR(u):[],...e?IR(e):[]]:[];d.forEach(v=>{i&&v.addEventListener("scroll",r,{passive:!0}),a&&v.addEventListener("resize",r)});const h=u&&o?D1t(u,r):null;let f=-1,p=null;s&&(p=new ResizeObserver(v=>{let[b]=v;b&&b.target===u&&p&&e&&(p.unobserve(e),cancelAnimationFrame(f),f=requestAnimationFrame(()=>{var y;(y=p)==null||y.observe(e)})),r()}),u&&!l&&p.observe(u),e&&p.observe(e));let g,m=l?d2(t):null;l&&_();function _(){const v=d2(t);m&&!IOe(m,v)&&r(),m=v,g=requestAnimationFrame(_)}return r(),()=>{var v;d.forEach(b=>{i&&b.removeEventListener("scroll",r),a&&b.removeEventListener("resize",r)}),h?.(),(v=p)==null||v.disconnect(),p=null,l&&cancelAnimationFrame(g)}}const L1t=d1t,P1t=h1t,F1t=l1t,B1t=p1t,U1t=c1t,$1t=o1t,G1t=f1t,z1t=(t,e,r)=>{const n=new Map,i={platform:k1t,...r},a={...i.platform,_c:n};return s1t(t,e,{...i,platform:a})};function ry(t){return typeof t=="function"?t():t}function kOe(t){return typeof window>"u"?1:(t.ownerDocument.defaultView||window).devicePixelRatio||1}function k1e(t,e){const r=kOe(t);return Math.round(e*r)/r}function Rp(t){return{[`--bits-${t}-content-transform-origin`]:"var(--bits-floating-transform-origin)",[`--bits-${t}-content-available-width`]:"var(--bits-floating-available-width)",[`--bits-${t}-content-available-height`]:"var(--bits-floating-available-height)",[`--bits-${t}-anchor-width`]:"var(--bits-floating-anchor-width)",[`--bits-${t}-anchor-height`]:"var(--bits-floating-anchor-height)"}}function q1t(t){const e=t.whileElementsMounted,r=W(()=>ry(t.open)??!0),n=W(()=>ry(t.middleware)),i=W(()=>ry(t.transform)??!0),a=W(()=>ry(t.placement)??"bottom"),s=W(()=>ry(t.strategy)??"absolute"),o=W(()=>ry(t.sideOffset)??0),l=W(()=>ry(t.alignOffset)??0),u=t.reference;let d=Oe(0),h=Oe(0);const f=xu(null);let p=Oe(Zr(S(s))),g=Oe(Zr(S(a))),m=Oe(Zr({})),_=Oe(!1),v=!1,b=0;const y=W(()=>{const R=f.current?k1e(f.current,S(d)):S(d),O=f.current?k1e(f.current,S(h)):S(h);return S(i)?{position:S(p),left:"0",top:"0",transform:`translate(${R}px, ${O}px)`,...f.current&&kOe(f.current)>=1.5&&{willChange:"transform"}}:{position:S(p),left:`${R}px`,top:`${O}px`}});let E;function T(){if(u.current===null||f.current===null)return;const R=u.current,O=f.current,F=++b;z1t(R,O,{middleware:S(n),placement:S(a),strategy:S(s)}).then(P=>{if(F!==b||u.current!==R||f.current!==O)return;if(H1t(R)){X(m,{...S(m),hide:{...S(m).hide,referenceHidden:!0}},!0);return}if(!S(r)&&S(d)!==0&&S(h)!==0){const k=Math.max(Math.abs(S(o)),Math.abs(S(l)),15);if(P.x<=k&&P.y<=k)return}X(d,P.x,!0),X(h,P.y,!0),X(p,P.strategy,!0),X(g,P.placement,!0),X(m,P.middlewareData,!0),X(_,!0)})}function C(){typeof E=="function"&&(E(),E=void 0),b++}function w(){if(C(),e===void 0){T();return}S(r)&&(u.current===null||f.current===null||(E=e(u.current,f.current,T)))}function x(){!S(r)&&f.current===null&&X(_,!1)}function A(){return[S(n),S(a),S(s),S(o),S(l),S(r)]}return Kt(()=>{e===void 0&&S(r)&&T()}),Kt(w),Kt(()=>{if(e!==void 0){if(A(),!S(r)){v=!1;return}if(!S(_)){v=!1;return}if(!v){v=!0;return}T()}}),Kt(x),Kt(()=>C),{floating:f,reference:u,get strategy(){return S(p)},get placement(){return S(g)},get middlewareData(){return S(m)},get isPositioned(){return S(_)},get floatingStyles(){return S(y)},get update(){return T}}}function H1t(t){return t instanceof Element?!t.isConnected||t instanceof HTMLElement&&t.hidden?!0:t.getClientRects().length===0:!1}const V1t={top:"bottom",right:"left",bottom:"top",left:"right"},Goe=new Ys("Floating.Root"),TJ=new Ys("Floating.Content"),zoe=new Ys("Floating.Root");class IL{static create(e=!1){return e?zoe.set(new IL):Goe.set(new IL)}anchorNode=xu(null);customAnchorNode=xu(null);triggerNode=xu(null);constructor(){Kt(()=>{this.customAnchorNode.current?typeof this.customAnchorNode.current=="string"?this.anchorNode.current=document.querySelector(this.customAnchorNode.current):this.anchorNode.current=this.customAnchorNode.current:this.anchorNode.current=this.triggerNode.current})}}class kL{static create(e,r=!1){return r?TJ.set(new kL(e,zoe.get())):TJ.set(new kL(e,Goe.get()))}opts;root;contentRef=xu(null);wrapperRef=xu(null);arrowRef=xu(null);contentAttachment=$i(this.contentRef);wrapperAttachment=$i(this.wrapperRef);arrowAttachment=$i(this.arrowRef);arrowId=xu(h4());#e=W(()=>{if(typeof this.opts.style=="string")return O6(this.opts.style);if(!this.opts.style)return{}});#t=void 0;#r=new Vgt(()=>this.arrowRef.current??void 0);#n=W(()=>this.#r?.width??0);#i=W(()=>this.#r?.height??0);#a=W(()=>this.opts.side?.current+(this.opts.align.current!=="center"?`-${this.opts.align.current}`:""));#s=W(()=>Array.isArray(this.opts.collisionBoundary.current)?this.opts.collisionBoundary.current:[this.opts.collisionBoundary.current]);#o=W(()=>S(this.#s).length>0);get hasExplicitBoundaries(){return S(this.#o)}set hasExplicitBoundaries(e){X(this.#o,e)}#l=W(()=>({padding:this.opts.collisionPadding.current,boundary:S(this.#s).filter(cmt),altBoundary:this.hasExplicitBoundaries}));get detectOverflowOptions(){return S(this.#l)}set detectOverflowOptions(e){X(this.#l,e)}#c=Oe(void 0);#d=Oe(void 0);#u=Oe(void 0);#p=Oe(void 0);#g=W(()=>[L1t({mainAxis:this.opts.sideOffset.current+S(this.#i),alignmentAxis:this.opts.alignOffset.current}),this.opts.avoidCollisions.current&&P1t({mainAxis:!0,crossAxis:!1,limiter:this.opts.sticky.current==="partial"?G1t():void 0,...this.detectOverflowOptions}),this.opts.avoidCollisions.current&&F1t({...this.detectOverflowOptions}),B1t({...this.detectOverflowOptions,apply:({rects:e,availableWidth:r,availableHeight:n})=>{const{width:i,height:a}=e.reference;X(this.#c,r,!0),X(this.#d,n,!0),X(this.#u,i,!0),X(this.#p,a,!0)}}),this.arrowRef.current&&$1t({element:this.arrowRef.current,padding:this.opts.arrowPadding.current}),Y1t({arrowWidth:S(this.#n),arrowHeight:S(this.#i)}),this.opts.hideWhenDetached.current&&U1t({strategy:"referenceHidden",...this.detectOverflowOptions})].filter(Boolean));get middleware(){return S(this.#g)}set middleware(e){X(this.#g,e)}floating;#f=W(()=>W1t(this.floating.placement));get placedSide(){return S(this.#f)}set placedSide(e){X(this.#f,e)}#h=W(()=>K1t(this.floating.placement));get placedAlign(){return S(this.#h)}set placedAlign(e){X(this.#h,e)}#m=W(()=>this.floating.middlewareData.arrow?.x??0);get arrowX(){return S(this.#m)}set arrowX(e){X(this.#m,e)}#v=W(()=>this.floating.middlewareData.arrow?.y??0);get arrowY(){return S(this.#v)}set arrowY(e){X(this.#v,e)}#_=W(()=>this.floating.middlewareData.arrow?.centerOffset!==0);get cannotCenterArrow(){return S(this.#_)}set cannotCenterArrow(e){X(this.#_,e)}#S=Oe();get contentZIndex(){return S(this.#S)}set contentZIndex(e){X(this.#S,e,!0)}#b=W(()=>V1t[this.placedSide]);get arrowBaseSide(){return S(this.#b)}set arrowBaseSide(e){X(this.#b,e)}#y=W(()=>({id:this.opts.wrapperId.current,"data-bits-floating-content-wrapper":"",style:{...this.floating.floatingStyles,transform:this.floating.isPositioned?this.floating.floatingStyles.transform:"translate(0, -200%)",minWidth:"max-content",zIndex:this.contentZIndex,"--bits-floating-transform-origin":`${this.floating.middlewareData.transformOrigin?.x} ${this.floating.middlewareData.transformOrigin?.y}`,"--bits-floating-available-width":`${S(this.#c)}px`,"--bits-floating-available-height":`${S(this.#d)}px`,"--bits-floating-anchor-width":`${S(this.#u)}px`,"--bits-floating-anchor-height":`${S(this.#p)}px`,...this.floating.middlewareData.hide?.referenceHidden&&{visibility:"hidden","pointer-events":"none"},...S(this.#e)},dir:this.opts.dir.current,...this.wrapperAttachment}));get wrapperProps(){return S(this.#y)}set wrapperProps(e){X(this.#y,e)}#E=W(()=>({"data-side":this.placedSide,"data-align":this.placedAlign,style:Qse({...S(this.#e)}),...this.contentAttachment}));get props(){return S(this.#E)}set props(e){X(this.#E,e)}#C=W(()=>({position:"absolute",left:this.arrowX?`${this.arrowX}px`:void 0,top:this.arrowY?`${this.arrowY}px`:void 0,[this.arrowBaseSide]:0,"transform-origin":{top:"",right:"0 0",bottom:"center 0",left:"100% 0"}[this.placedSide],transform:{top:"translateY(100%)",right:"translateY(50%) rotate(90deg) translateX(-50%)",bottom:"rotate(180deg)",left:"translateY(50%) rotate(-90deg) translateX(50%)"}[this.placedSide],visibility:this.cannotCenterArrow?"hidden":void 0}));get arrowStyle(){return S(this.#C)}set arrowStyle(e){X(this.#C,e)}constructor(e,r){this.opts=e,this.root=r,this.#t=e.updatePositionStrategy,e.customAnchor&&(this.root.customAnchorNode.current=e.customAnchor.current),yi(()=>e.customAnchor.current,n=>{this.root.customAnchorNode.current=n}),this.floating=q1t({strategy:()=>this.opts.strategy.current,placement:()=>S(this.#a),middleware:()=>this.middleware,reference:this.root.anchorNode,whileElementsMounted:(...n)=>M1t(...n,{animationFrame:this.#t?.current==="always"}),open:()=>this.opts.enabled.current,sideOffset:()=>this.opts.sideOffset.current,alignOffset:()=>this.opts.alignOffset.current}),Kt(()=>{this.floating.isPositioned&&this.opts.onPlaced?.current()}),yi(()=>this.contentRef.current,n=>{if(!n||!this.opts.enabled.current)return;const i=Jse(n),a=i.requestAnimationFrame(()=>{if(this.contentRef.current!==n||!this.opts.enabled.current)return;const s=i.getComputedStyle(n).zIndex;s!==this.contentZIndex&&(this.contentZIndex=s)});return()=>{i.cancelAnimationFrame(a)}}),Kt(()=>{this.floating.floating.current=this.wrapperRef.current})}}class qoe{static create(e){return new qoe(e,TJ.get())}opts;content;constructor(e,r){this.opts=e,this.content=r}#e=W(()=>({id:this.opts.id.current,style:this.content.arrowStyle,"data-side":this.content.placedSide,...this.content.arrowAttachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class DL{static create(e,r=!1){return r?new DL(e,zoe.get()):new DL(e,Goe.get())}opts;root;constructor(e,r){this.opts=e,this.root=r,e.virtualEl&&e.virtualEl.current?r.triggerNode=zNe(e.virtualEl.current):r.triggerNode=e.ref}}function Y1t(t){return{name:"transformOrigin",options:t,fn(e){const{placement:r,rects:n,middlewareData:i}=e,s=i.arrow?.centerOffset!==0,o=s?0:t.arrowWidth,l=s?0:t.arrowHeight,[u,d]=Hoe(r),h={start:"0%",center:"50%",end:"100%"}[d],f=(i.arrow?.x??0)+o/2,p=(i.arrow?.y??0)+l/2;let g="",m="";return u==="bottom"?(g=s?h:`${f}px`,m=`${-l}px`):u==="top"?(g=s?h:`${f}px`,m=`${n.floating.height+l}px`):u==="right"?(g=`${-l}px`,m=s?h:`${p}px`):u==="left"&&(g=`${n.floating.width+l}px`,m=s?h:`${p}px`),{data:{x:g,y:m}}}}}function Hoe(t){const[e,r="center"]=t.split("-");return[e,r]}function W1t(t){return Hoe(t)[0]}function K1t(t){return Hoe(t)[1]}function g4(t,e){at(e,!0);let r=ce(e,"tooltip",3,!1);IL.create(r());var n=Ae(),i=oe(n);Pt(i,()=>e.children??Vt),G(t,n),st()}class j1t{#e;#t=W(()=>this.#e.candidateValues());#r;constructor(e){this.#e=e,this.#r=mOe("",{afterMs:1e3,getWindow:this.#e.getWindow}),this.handleTypeaheadSearch=this.handleTypeaheadSearch.bind(this),this.resetTypeahead=this.resetTypeahead.bind(this)}handleTypeaheadSearch(e){if(!this.#e.enabled()||!S(this.#t).length)return;this.#r.current=this.#r.current+e;const r=this.#e.getCurrentItem(),n=S(this.#t).find(o=>o===r)??"",i=S(this.#t).map(o=>o??""),a=uoe(i,this.#r.current,n),s=S(this.#t).find(o=>o===a);return s&&this.#e.onMatch(s),s}resetTypeahead(){this.#r.current=""}}const X1t=[wg,roe,bU],Q1t=[yg,toe,yU],Z1t=[...X1t,...Q1t],J1t=xf({component:"select",parts:["trigger","content","item","viewport","scroll-up-button","scroll-down-button","group","group-label","separator","arrow","input","content-wrapper","item-text","value"]}),N8=new Ys("Select.Root | Combobox.Root"),kU=new Ys("Select.Content | Combobox.Content");class DOe{opts;#e=Oe(!1);get touchedInput(){return S(this.#e)}set touchedInput(e){X(this.#e,e,!0)}#t=Oe(null);get inputNode(){return S(this.#t)}set inputNode(e){X(this.#t,e,!0)}#r=Oe(null);get contentNode(){return S(this.#r)}set contentNode(e){X(this.#r,e,!0)}contentPresence;#n=Oe(null);get viewportNode(){return S(this.#n)}set viewportNode(e){X(this.#n,e,!0)}#i=Oe(null);get triggerNode(){return S(this.#i)}set triggerNode(e){X(this.#i,e,!0)}#a=Oe(null);get valueNode(){return S(this.#a)}set valueNode(e){X(this.#a,e,!0)}#s=Oe("");get valueId(){return S(this.#s)}set valueId(e){X(this.#s,e,!0)}#o=Oe(null);get highlightedNode(){return S(this.#o)}set highlightedNode(e){X(this.#o,e,!0)}#l=W(()=>this.highlightedNode?this.highlightedNode.getAttribute("data-value"):null);get highlightedValue(){return S(this.#l)}set highlightedValue(e){X(this.#l,e)}#c=W(()=>{if(this.highlightedNode)return this.highlightedNode.id});get highlightedId(){return S(this.#c)}set highlightedId(e){X(this.#c,e)}#d=W(()=>this.highlightedNode?this.highlightedNode.getAttribute("data-label"):null);get highlightedLabel(){return S(this.#d)}set highlightedLabel(e){X(this.#d,e)}#u=Oe(!1);get contentIsPositioned(){return S(this.#u)}set contentIsPositioned(e){X(this.#u,e,!0)}isUsingKeyboard=!1;isCombobox=!1;domContext=new wf(()=>null);constructor(e){this.opts=e,this.isCombobox=e.isCombobox,this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),uc(()=>{this.opts.open.current||this.setHighlightedNode(null)})}setHighlightedNode(e,r=!1){this.highlightedNode=e,e&&(this.isUsingKeyboard||r)&&this.scrollHighlightedNodeIntoView(e)}scrollHighlightedNodeIntoView(e){!this.viewportNode||!this.contentIsPositioned||e.scrollIntoView({block:this.opts.scrollAlignment.current})}getCandidateNodes(){const e=this.contentNode;return e?Array.from(e.querySelectorAll(`[${this.getBitsAttr("item")}]:not([data-disabled])`)):[]}setHighlightedToFirstCandidate(e=!1){this.setHighlightedNode(null);let r=this.getCandidateNodes();if(r.length){if(this.viewportNode){const n=this.viewportNode.getBoundingClientRect();r=r.filter(i=>{if(!this.viewportNode)return!1;const a=i.getBoundingClientRect();return a.right<=n.right&&a.left>=n.left&&a.bottom<=n.bottom&&a.top>=n.top})}this.setHighlightedNode(r[0],e)}}getNodeByValue(e){return this.getCandidateNodes().find(n=>n.dataset.value===e)??null}getLabelForValue(e){if(e==="")return"";const r=this.opts.items.current.find(i=>i.value===e)?.label;if(r!==void 0)return r;const n=this.getNodeByValue(e);if(n){const i=n.getAttribute("data-label");return i!==null&&i!==""?i:n.textContent?.trim()??e}return e}setOpen(e){this.opts.open.current=e}toggleOpen(){this.opts.open.current=!this.opts.open.current}handleOpen(){this.setOpen(!0)}handleClose(){this.setHighlightedNode(null),this.setOpen(!1)}toggleMenu(){this.toggleOpen()}getBitsAttr=e=>J1t.getAttr(e,this.isCombobox?"combobox":void 0)}class e_t extends DOe{opts;isMulti=!1;#e=W(()=>this.opts.value.current!=="");get hasValue(){return S(this.#e)}set hasValue(e){X(this.#e,e)}#t=W(()=>this.opts.items.current.length?this.opts.items.current.find(e=>e.value===this.opts.value.current)?.label??"":"");get currentLabel(){return S(this.#t)}set currentLabel(e){X(this.#t,e)}#r=W(()=>this.opts.items.current.length?this.opts.items.current.filter(r=>!r.disabled).map(r=>r.label):[]);get candidateLabels(){return S(this.#r)}set candidateLabels(e){X(this.#r,e)}#n=W(()=>!(this.isMulti||this.opts.items.current.length===0));get dataTypeaheadEnabled(){return S(this.#n)}set dataTypeaheadEnabled(e){X(this.#n,e)}constructor(e){super(e),this.opts=e,Kt(()=>{!this.opts.open.current&&this.highlightedNode&&this.setHighlightedNode(null)}),yi(()=>this.opts.open.current,()=>{this.opts.open.current&&this.setInitialHighlightedNode()})}includesItem(e){return this.opts.value.current===e}toggleItem(e,r=e){const n=this.includesItem(e)?"":e;this.opts.value.current=n,n!==""&&(this.opts.inputValue.current=r)}setInitialHighlightedNode(){md(()=>{if(!(this.highlightedNode&&this.domContext.getDocument().contains(this.highlightedNode))){if(this.opts.value.current!==""){const e=this.getNodeByValue(this.opts.value.current);if(e){this.setHighlightedNode(e,!0);return}}this.setHighlightedToFirstCandidate(!0)}})}}class t_t extends DOe{opts;isMulti=!0;#e=W(()=>this.opts.value.current.length>0);get hasValue(){return S(this.#e)}set hasValue(e){X(this.#e,e)}constructor(e){super(e),this.opts=e,Kt(()=>{!this.opts.open.current&&this.highlightedNode&&this.setHighlightedNode(null)}),yi(()=>this.opts.open.current,()=>{this.opts.open.current&&this.setInitialHighlightedNode()})}includesItem(e){return this.opts.value.current.includes(e)}toggleItem(e,r=e){this.includesItem(e)?this.opts.value.current=this.opts.value.current.filter(n=>n!==e):this.opts.value.current=[...this.opts.value.current,e],this.opts.inputValue.current=r}setInitialHighlightedNode(){md(()=>{if(this.domContext&&!(this.highlightedNode&&this.domContext.getDocument().contains(this.highlightedNode))){if(this.opts.value.current.length&&this.opts.value.current[0]!==""){const e=this.getNodeByValue(this.opts.value.current[0]);if(e){this.setHighlightedNode(e,!0);return}}this.setHighlightedToFirstCandidate(!0)}})}}class r_t{static create(e){const{type:r,...n}=e,i=r==="single"?new e_t(n):new t_t(n);return N8.set(i)}}class Voe{static create(e){return new Voe(e,N8.get())}opts;root;attachment;#e;#t;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(e.ref,n=>this.root.triggerNode=n),this.root.domContext=new wf(e.ref),this.#e=new _Oe({getCurrentItem:()=>this.root.highlightedNode,onMatch:n=>{this.root.setHighlightedNode(n)},getActiveElement:()=>this.root.domContext.getActiveElement(),getWindow:()=>this.root.domContext.getWindow()}),this.#t=new j1t({getCurrentItem:()=>this.root.isMulti?"":this.root.currentLabel,onMatch:n=>{if(this.root.isMulti||!this.root.opts.items.current)return;const i=this.root.opts.items.current.find(a=>a.label===n);i&&(this.root.opts.value.current=i.value)},enabled:()=>!this.root.isMulti&&this.root.dataTypeaheadEnabled,candidateValues:()=>this.root.isMulti?[]:this.root.candidateLabels,getWindow:()=>this.root.domContext.getWindow()}),this.onkeydown=this.onkeydown.bind(this),this.onpointerdown=this.onpointerdown.bind(this),this.onpointerup=this.onpointerup.bind(this),this.onclick=this.onclick.bind(this)}#r(){this.root.opts.open.current=!0,this.#t.resetTypeahead(),this.#e.resetTypeahead()}#n(e){this.#r()}#i(){const e=this.root.highlightedValue===this.root.opts.value.current;return!this.root.opts.allowDeselect.current&&e&&!this.root.isMulti?(this.root.handleClose(),!0):(this.root.highlightedValue!==null&&this.root.toggleItem(this.root.highlightedValue,this.root.highlightedLabel??void 0),!this.root.isMulti&&!e?(this.root.handleClose(),!0):!1)}onkeydown(e){if(this.root.isUsingKeyboard=!0,(e.key===yg||e.key===wg)&&e.preventDefault(),!this.root.opts.open.current){if(e.key===Kg||e.key===xd||e.key===wg||e.key===yg)e.preventDefault(),this.root.handleOpen();else if(!this.root.isMulti&&this.root.dataTypeaheadEnabled){this.#t.handleTypeaheadSearch(e.key);return}if(this.root.hasValue)return;const s=this.root.getCandidateNodes();if(!s.length)return;if(e.key===wg){const o=s[0];this.root.setHighlightedNode(o)}else if(e.key===yg){const o=s[s.length-1];this.root.setHighlightedNode(o)}return}if(e.key===mJ){this.root.handleClose();return}if((e.key===Kg||e.key===xd&&this.#e.search==="")&&!e.isComposing&&(e.preventDefault(),this.#i()))return;if(e.key===yg&&e.altKey&&this.root.handleClose(),Z1t.includes(e.key)){e.preventDefault();const s=this.root.getCandidateNodes(),o=this.root.highlightedNode,l=o?s.indexOf(o):-1,u=this.root.opts.loop.current;let d;if(e.key===wg?d=Jmt(s,l,u):e.key===yg?d=e0t(s,l,u):e.key===toe?d=t0t(s,l,10,u):e.key===roe?d=r0t(s,l,10,u):e.key===bU?d=s[0]:e.key===yU&&(d=s[s.length-1]),!d)return;this.root.setHighlightedNode(d);return}const r=e.ctrlKey||e.altKey||e.metaKey,n=e.key.length===1,i=e.key===xd,a=this.root.getCandidateNodes();if(e.key!==mJ){if(!r&&(n||i)){!this.#e.handleTypeaheadSearch(e.key,a)&&i&&(e.preventDefault(),this.#i());return}this.root.highlightedNode||this.root.setHighlightedToFirstCandidate()}}onclick(e){e.currentTarget.focus()}onpointerdown(e){if(this.root.opts.disabled.current)return;if(e.pointerType==="touch")return e.preventDefault();const r=e.target;r?.hasPointerCapture(e.pointerId)&&r?.releasePointerCapture(e.pointerId),e.button===0&&e.ctrlKey===!1&&(this.root.opts.open.current===!1?this.#n(e):this.root.handleClose())}onpointerup(e){this.root.opts.disabled.current||(e.preventDefault(),e.pointerType==="touch"&&(this.root.opts.open.current===!1?this.#n(e):this.root.handleClose()))}#a=W(()=>({id:this.opts.id.current,disabled:this.root.opts.disabled.current?!0:void 0,"aria-haspopup":"listbox","aria-expanded":vf(this.root.opts.open.current),"aria-activedescendant":this.root.highlightedId,"data-state":Eh(this.root.opts.open.current),"data-disabled":Uo(this.root.opts.disabled.current),"data-placeholder":this.root.hasValue?void 0:"",[this.root.getBitsAttr("trigger")]:"",onpointerdown:this.onpointerdown,onkeydown:this.onkeydown,onclick:this.onclick,onpointerup:this.onpointerup,...this.attachment}));get props(){return S(this.#a)}set props(e){X(this.#a,e)}}class Yoe{static create(e){return kU.set(new Yoe(e,N8.get()))}opts;root;attachment;#e=Oe(!1);get isPositioned(){return S(this.#e)}set isPositioned(e){X(this.#e,e,!0)}domContext;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(e.ref,n=>this.root.contentNode=n),this.domContext=new wf(this.opts.ref),this.root.domContext===null&&(this.root.domContext=this.domContext),Sh(()=>{this.root.contentNode=null,this.root.contentIsPositioned=!1,this.isPositioned=!1}),yi(()=>this.root.opts.open.current,()=>{this.root.opts.open.current||(this.root.contentIsPositioned=!1,this.isPositioned=!1)}),yi([()=>this.isPositioned,()=>this.root.highlightedNode],()=>{!this.isPositioned||!this.root.highlightedNode||this.root.scrollHighlightedNodeIntoView(this.root.highlightedNode)}),this.onpointermove=this.onpointermove.bind(this)}onpointermove(e){this.root.isUsingKeyboard=!1}#t=W(()=>Rp(this.root.isCombobox?"combobox":"select"));onInteractOutside=e=>{if(e.target===this.root.triggerNode||e.target===this.root.inputNode){e.preventDefault();return}this.opts.onInteractOutside.current(e),!e.defaultPrevented&&this.root.handleClose()};onEscapeKeydown=e=>{this.opts.onEscapeKeydown.current(e),!e.defaultPrevented&&this.root.handleClose()};onOpenAutoFocus=e=>{e.preventDefault()};onCloseAutoFocus=e=>{e.preventDefault()};get shouldRender(){return this.root.contentPresence.shouldRender}#r=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#r)}set snippetProps(e){X(this.#r,e)}#n=W(()=>({id:this.opts.id.current,role:"listbox","aria-multiselectable":this.root.isMulti?"true":void 0,"data-state":Eh(this.root.opts.open.current),...xv(this.root.contentPresence.transitionStatus),[this.root.getBitsAttr("content")]:"",style:{display:"flex",flexDirection:"column",outline:"none",boxSizing:"border-box",pointerEvents:"auto",...S(this.#t)},onpointermove:this.onpointermove,...this.attachment}));get props(){return S(this.#n)}set props(e){X(this.#n,e)}popperProps={onInteractOutside:this.onInteractOutside,onEscapeKeydown:this.onEscapeKeydown,onOpenAutoFocus:this.onOpenAutoFocus,onCloseAutoFocus:this.onCloseAutoFocus,trapFocus:!1,loop:!1,onPlaced:()=>{this.root.opts.open.current&&(this.root.contentIsPositioned=!0,this.isPositioned=!0)}}}class Woe{static create(e){return new Woe(e,N8.get())}opts;root;attachment;#e=W(()=>this.root.includesItem(this.opts.value.current));get isSelected(){return S(this.#e)}set isSelected(e){X(this.#e,e)}#t=W(()=>this.root.highlightedValue===this.opts.value.current);get isHighlighted(){return S(this.#t)}set isHighlighted(e){X(this.#t,e)}prevHighlighted=new Ygt(()=>this.isHighlighted);#r=Oe(!1);get mounted(){return S(this.#r)}set mounted(e){X(this.#r,e,!0)}constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(e.ref),yi([()=>this.isHighlighted,()=>this.prevHighlighted.current],()=>{this.isHighlighted?this.opts.onHighlight.current():this.prevHighlighted.current&&this.opts.onUnhighlight.current()}),yi(()=>this.mounted,()=>{this.mounted&&this.root.setInitialHighlightedNode()}),this.onpointerdown=this.onpointerdown.bind(this),this.onpointerup=this.onpointerup.bind(this),this.onpointermove=this.onpointermove.bind(this)}handleSelect(){if(this.opts.disabled.current)return;const e=this.opts.value.current===this.root.opts.value.current;if(!this.root.opts.allowDeselect.current&&e&&!this.root.isMulti){this.root.handleClose();return}this.root.toggleItem(this.opts.value.current,this.opts.label.current),!this.root.isMulti&&!e&&this.root.handleClose()}#n=W(()=>({selected:this.isSelected,highlighted:this.isHighlighted}));get snippetProps(){return S(this.#n)}set snippetProps(e){X(this.#n,e)}onpointerdown(e){e.preventDefault()}onpointerup(e){if(!(e.defaultPrevented||!this.opts.ref.current)){if(e.pointerType==="touch"&&!_J){Bi(this.opts.ref.current,"click",()=>{this.handleSelect(),this.root.setHighlightedNode(this.opts.ref.current)},{once:!0});return}e.preventDefault(),this.handleSelect(),e.pointerType==="touch"&&this.root.setHighlightedNode(this.opts.ref.current)}}onpointermove(e){e.pointerType!=="touch"&&this.root.highlightedNode!==this.opts.ref.current&&this.root.setHighlightedNode(this.opts.ref.current)}#i=W(()=>({id:this.opts.id.current,role:"option","aria-selected":this.root.includesItem(this.opts.value.current)?"true":void 0,"data-value":this.opts.value.current,"data-disabled":Uo(this.opts.disabled.current),"data-highlighted":this.root.highlightedValue===this.opts.value.current&&!this.opts.disabled.current?"":void 0,"data-selected":this.root.includesItem(this.opts.value.current)?"":void 0,"data-label":this.opts.label.current,[this.root.getBitsAttr("item")]:"",onpointermove:this.onpointermove,onpointerdown:this.onpointerdown,onpointerup:this.onpointerup,...this.attachment}));get props(){return S(this.#i)}set props(e){X(this.#i,e)}}class Koe{static create(e){return new Koe(e,N8.get())}opts;root;#e=W(()=>this.root.opts.name.current!=="");get shouldRender(){return S(this.#e)}set shouldRender(e){X(this.#e,e)}constructor(e,r){this.opts=e,this.root=r,this.onfocus=this.onfocus.bind(this)}onfocus(e){e.preventDefault(),this.root.isCombobox?this.root.inputNode?.focus():this.root.triggerNode?.focus()}#t=W(()=>({disabled:gJ(this.root.opts.disabled.current),required:gJ(this.root.opts.required.current),name:this.root.opts.name.current,value:this.opts.value.current,onfocus:this.onfocus}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class joe{static create(e){return new joe(e,kU.get())}opts;content;root;attachment;#e=Oe(0);get prevScrollTop(){return S(this.#e)}set prevScrollTop(e){X(this.#e,e,!0)}constructor(e,r){this.opts=e,this.content=r,this.root=r.root,this.attachment=$i(e.ref,n=>{this.root.viewportNode=n})}#t=W(()=>({id:this.opts.id.current,role:"presentation",[this.root.getBitsAttr("viewport")]:"",style:{position:"relative",flex:1,overflow:"auto"},...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class MOe{opts;content;root;attachment;autoScrollTimer=null;userScrollTimer=-1;isUserScrolling=!1;onAutoScroll=Tn;#e=Oe(!1);get mounted(){return S(this.#e)}set mounted(e){X(this.#e,e,!0)}constructor(e,r){this.opts=e,this.content=r,this.root=r.root,this.attachment=$i(e.ref),yi([()=>this.mounted],()=>{if(!this.mounted){this.isUserScrolling=!1;return}this.isUserScrolling}),Kt(()=>{this.mounted||this.clearAutoScrollInterval()}),this.onpointerdown=this.onpointerdown.bind(this),this.onpointermove=this.onpointermove.bind(this),this.onpointerleave=this.onpointerleave.bind(this)}handleUserScroll(){this.content.domContext.clearTimeout(this.userScrollTimer),this.isUserScrolling=!0,this.userScrollTimer=this.content.domContext.setTimeout(()=>{this.isUserScrolling=!1},200)}clearAutoScrollInterval(){this.autoScrollTimer!==null&&(this.content.domContext.clearTimeout(this.autoScrollTimer),this.autoScrollTimer=null)}onpointerdown(e){if(this.autoScrollTimer!==null)return;const r=n=>{this.onAutoScroll(),this.autoScrollTimer=this.content.domContext.setTimeout(()=>r(n+1),this.opts.delay.current(n))};this.autoScrollTimer=this.content.domContext.setTimeout(()=>r(1),this.opts.delay.current(0))}onpointermove(e){this.onpointerdown(e)}onpointerleave(e){this.clearAutoScrollInterval()}#t=W(()=>({id:this.opts.id.current,"aria-hidden":emt(!0),style:{flexShrink:0},onpointerdown:this.onpointerdown,onpointermove:this.onpointermove,onpointerleave:this.onpointerleave,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class Xoe{static create(e){return new Xoe(new MOe(e,kU.get()))}scrollButtonState;content;root;#e=Oe(!1);get canScrollDown(){return S(this.#e)}set canScrollDown(e){X(this.#e,e,!0)}scrollIntoViewTimer=null;constructor(e){this.scrollButtonState=e,this.content=e.content,this.root=e.root,this.scrollButtonState.onAutoScroll=this.handleAutoScroll,yi([()=>this.root.viewportNode,()=>this.content.isPositioned],()=>{if(!(!this.root.viewportNode||!this.content.isPositioned))return this.handleScroll(!0),Bi(this.root.viewportNode,"scroll",()=>this.handleScroll())}),yi([()=>this.root.opts.inputValue.current,()=>this.root.viewportNode,()=>this.content.isPositioned],()=>{!this.root.viewportNode||!this.content.isPositioned||this.handleScroll(!0)}),yi(()=>this.scrollButtonState.mounted,()=>{this.scrollButtonState.mounted&&(this.scrollIntoViewTimer&&clearTimeout(this.scrollIntoViewTimer),this.scrollIntoViewTimer=vU(5,()=>{const r=this.root.highlightedNode;r&&this.root.scrollHighlightedNodeIntoView(r)}))})}handleScroll=(e=!1)=>{if(e||this.scrollButtonState.handleUserScroll(),!this.root.viewportNode)return;const r=this.root.viewportNode.scrollHeight-this.root.viewportNode.clientHeight,n=Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop,10);this.canScrollDown=Math.ceil(this.root.viewportNode.scrollTop){const e=this.root.viewportNode,r=this.root.highlightedNode;!e||!r||(e.scrollTop=e.scrollTop+r.offsetHeight)};#t=W(()=>({...this.scrollButtonState.props,[this.root.getBitsAttr("scroll-down-button")]:""}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class Qoe{static create(e){return new Qoe(new MOe(e,kU.get()))}scrollButtonState;content;root;#e=Oe(!1);get canScrollUp(){return S(this.#e)}set canScrollUp(e){X(this.#e,e,!0)}constructor(e){this.scrollButtonState=e,this.content=e.content,this.root=e.root,this.scrollButtonState.onAutoScroll=this.handleAutoScroll,yi([()=>this.root.viewportNode,()=>this.content.isPositioned],()=>{if(!(!this.root.viewportNode||!this.content.isPositioned))return this.handleScroll(!0),Bi(this.root.viewportNode,"scroll",()=>this.handleScroll())})}handleScroll=(e=!1)=>{if(e||this.scrollButtonState.handleUserScroll(),!this.root.viewportNode)return;const r=Number.parseInt(getComputedStyle(this.root.viewportNode).paddingTop,10);this.canScrollUp=this.root.viewportNode.scrollTop-r>.1};handleAutoScroll=()=>{!this.root.viewportNode||!this.root.highlightedNode||(this.root.viewportNode.scrollTop=this.root.viewportNode.scrollTop-this.root.highlightedNode.offsetHeight)};#t=W(()=>({...this.scrollButtonState.props,[this.root.getBitsAttr("scroll-up-button")]:""}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}function dH(t,e){at(e,!0);let r=ce(e,"value",15);const n=Koe.create({value:_t(()=>r())});var i=Ae(),a=oe(i);{var s=o=>{AU(o,Rt(()=>n.props,{get autocomplete(){return e.autocomplete},get value(){return r()},set value(l){r(l)}}))};ve(a,o=>{n.shouldRender&&o(s)})}G(t,i),st()}function O8(t,e){at(e,!0);let r=ce(e,"tooltip",3,!1);DL.create({id:_t(()=>e.id),virtualEl:_t(()=>e.virtualEl),ref:e.ref},r());var n=Ae(),i=oe(n);Pt(i,()=>e.children??Vt),G(t,n),st()}var n_t=new Set(["$$slots","$$events","$$legacy","id","children","child","width","height"]),i_t=im(''),a_t=se("");function s_t(t,e){at(e,!0);let r=ce(e,"id",19,h4),n=ce(e,"width",3,10),i=ce(e,"height",3,5),a=Tt(e,n_t);const s=W(()=>un(a,{id:r()}));var o=Ae(),l=oe(o);{var u=h=>{var f=Ae(),p=oe(f);Pt(p,()=>e.child,()=>({props:S(s)})),G(h,f)},d=h=>{var f=a_t();Er(f,()=>({...S(s)}));var p=te(f);{var g=_=>{var v=Ae(),b=oe(v);Pt(b,()=>e.children??Vt),G(_,v)},m=_=>{var v=i_t();$e(()=>{lr(v,"width",n()),lr(v,"height",i())}),G(_,v)};ve(p,_=>{e.children?_(g):_(m,-1)})}Z(f),G(h,f)};ve(l,h=>{e.child?h(u):h(d,-1)})}G(t,o),st()}var o_t=new Set(["$$slots","$$events","$$legacy","id","ref"]);function l_t(t,e){at(e,!0);let r=ce(e,"id",19,h4),n=ce(e,"ref",15,null),i=Tt(e,o_t);const a=qoe.create({id:_t(()=>r()),ref:_t(()=>n(),o=>n(o))}),s=W(()=>un(i,a.props));s_t(t,Rt(()=>S(s))),st()}function c_t(t,e){at(e,!0);let r=ce(e,"side",3,"bottom"),n=ce(e,"sideOffset",3,0),i=ce(e,"align",3,"center"),a=ce(e,"alignOffset",3,0),s=ce(e,"arrowPadding",3,0),o=ce(e,"avoidCollisions",3,!0),l=ce(e,"collisionBoundary",19,()=>[]),u=ce(e,"collisionPadding",3,0),d=ce(e,"hideWhenDetached",3,!1),h=ce(e,"onPlaced",3,()=>{}),f=ce(e,"sticky",3,"partial"),p=ce(e,"updatePositionStrategy",3,"optimized"),g=ce(e,"strategy",3,"fixed"),m=ce(e,"dir",3,"ltr"),_=ce(e,"style",19,()=>({})),v=ce(e,"wrapperId",19,h4),b=ce(e,"customAnchor",3,null),y=ce(e,"tooltip",3,!1);const E=kL.create({side:_t(()=>r()),sideOffset:_t(()=>n()),align:_t(()=>i()),alignOffset:_t(()=>a()),id:_t(()=>e.id),arrowPadding:_t(()=>s()),avoidCollisions:_t(()=>o()),collisionBoundary:_t(()=>l()),collisionPadding:_t(()=>u()),hideWhenDetached:_t(()=>d()),onPlaced:_t(()=>h()),sticky:_t(()=>f()),updatePositionStrategy:_t(()=>p()),strategy:_t(()=>g()),dir:_t(()=>m()),style:_t(()=>_()),enabled:_t(()=>e.enabled),wrapperId:_t(()=>v()),customAnchor:_t(()=>b())},y()),T=W(()=>un(E.wrapperProps,{style:{pointerEvents:"auto"}}));var C=Ae(),w=oe(C);Pt(w,()=>e.content??Vt,()=>({props:E.props,wrapperProps:S(T)})),G(t,C),st()}function u_t(t,e){at(e,!0),uo(()=>{e.onPlaced?.()});var r=Ae(),n=oe(r);Pt(n,()=>e.content??Vt,()=>({props:{},wrapperProps:{}})),G(t,r),st()}var d_t=new Set(["$$slots","$$events","$$legacy","content","isStatic","onPlaced"]);function h_t(t,e){let r=ce(e,"isStatic",3,!1),n=Tt(e,d_t);var i=Ae(),a=oe(i);{var s=l=>{u_t(l,{get content(){return e.content},get onPlaced(){return e.onPlaced}})},o=l=>{c_t(l,Rt({get content(){return e.content},get onPlaced(){return e.onPlaced}},()=>n))};ve(a,l=>{r()?l(s):l(o,-1)})}G(t,i)}var f_t=new Set(["$$slots","$$events","$$legacy","popper","onEscapeKeydown","escapeKeydownBehavior","preventOverflowTextSelection","id","onPointerDown","onPointerUp","side","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","sticky","hideWhenDetached","updatePositionStrategy","strategy","dir","preventScroll","wrapperId","style","onPlaced","onInteractOutside","onCloseAutoFocus","onOpenAutoFocus","onFocusOutside","interactOutsideBehavior","loop","trapFocus","isValidEvent","customAnchor","isStatic","enabled","ref","tooltip","contentPointerEvents"]),p_t=se(" ",1);function LOe(t,e){at(e,!0);let r=ce(e,"interactOutsideBehavior",3,"close"),n=ce(e,"trapFocus",3,!0),i=ce(e,"isValidEvent",3,()=>!1),a=ce(e,"customAnchor",3,null),s=ce(e,"isStatic",3,!1),o=ce(e,"tooltip",3,!1),l=ce(e,"contentPointerEvents",3,"auto"),u=Tt(e,f_t);const d=W(()=>e.preventScroll??!0),h=W(()=>e.strategy??(S(d)?"fixed":"absolute"));h_t(t,{get isStatic(){return s()},get id(){return e.id},get side(){return e.side},get sideOffset(){return e.sideOffset},get align(){return e.align},get alignOffset(){return e.alignOffset},get arrowPadding(){return e.arrowPadding},get avoidCollisions(){return e.avoidCollisions},get collisionBoundary(){return e.collisionBoundary},get collisionPadding(){return e.collisionPadding},get sticky(){return e.sticky},get hideWhenDetached(){return e.hideWhenDetached},get updatePositionStrategy(){return e.updatePositionStrategy},get strategy(){return S(h)},get dir(){return e.dir},get wrapperId(){return e.wrapperId},get style(){return e.style},get onPlaced(){return e.onPlaced},get customAnchor(){return a()},get enabled(){return e.enabled},get tooltip(){return o()},content:(p,g)=>{let m=()=>g?.().props,_=()=>g?.().wrapperProps;var v=p_t(),b=oe(v);{var y=C=>{X5(C,{get preventScroll(){return S(d)}})},E=C=>{X5(C,{get preventScroll(){return S(d)}})};ve(b,C=>{e.forceMount&&e.enabled?C(y):e.forceMount||C(E,1)})}var T=ie(b,2);Coe(T,{get onOpenAutoFocus(){return e.onOpenAutoFocus},get onCloseAutoFocus(){return e.onCloseAutoFocus},get loop(){return e.loop},get enabled(){return e.enabled},get trapFocus(){return n()},get forceMount(){return e.forceMount},get ref(){return e.ref},focusScope:(w,x)=>{let A=()=>x?.().props;Soe(w,{get onEscapeKeydown(){return e.onEscapeKeydown},get escapeKeydownBehavior(){return e.escapeKeydownBehavior},get enabled(){return e.enabled},get ref(){return e.ref},children:(R,O)=>{yoe(R,{get id(){return e.id},get onInteractOutside(){return e.onInteractOutside},get onFocusOutside(){return e.onFocusOutside},get interactOutsideBehavior(){return r()},get isValidEvent(){return i()},get enabled(){return e.enabled},get ref(){return e.ref},children:(P,N)=>{let k=()=>N?.().props;xoe(P,{get id(){return e.id},get preventOverflowTextSelection(){return e.preventOverflowTextSelection},get onPointerDown(){return e.onPointerDown},get onPointerUp(){return e.onPointerUp},get enabled(){return e.enabled},get ref(){return e.ref},children:(M,L)=>{var I=Ae(),U=oe(I);{let B=W(()=>({props:un(u,m(),k(),A(),{style:{pointerEvents:l()}}),wrapperProps:_()}));Pt(U,()=>e.popper??Vt,()=>S(B))}G(M,I)},$$slots:{default:!0}})},$$slots:{default:!0}})},$$slots:{default:!0}})},$$slots:{focusScope:!0}}),G(p,v)},$$slots:{content:!0}}),st()}var g_t=new Set(["$$slots","$$events","$$legacy","popper","open","onEscapeKeydown","escapeKeydownBehavior","preventOverflowTextSelection","id","onPointerDown","onPointerUp","side","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","sticky","hideWhenDetached","updatePositionStrategy","strategy","dir","preventScroll","wrapperId","style","onPlaced","onInteractOutside","onCloseAutoFocus","onOpenAutoFocus","onFocusOutside","interactOutsideBehavior","loop","trapFocus","isValidEvent","customAnchor","isStatic","ref","shouldRender"]);function m4(t,e){let r=ce(e,"interactOutsideBehavior",3,"close"),n=ce(e,"trapFocus",3,!0),i=ce(e,"isValidEvent",3,()=>!1),a=ce(e,"customAnchor",3,null),s=ce(e,"isStatic",3,!1),o=Tt(e,g_t);var l=Ae(),u=oe(l);{var d=h=>{LOe(h,Rt({get popper(){return e.popper},get onEscapeKeydown(){return e.onEscapeKeydown},get escapeKeydownBehavior(){return e.escapeKeydownBehavior},get preventOverflowTextSelection(){return e.preventOverflowTextSelection},get id(){return e.id},get onPointerDown(){return e.onPointerDown},get onPointerUp(){return e.onPointerUp},get side(){return e.side},get sideOffset(){return e.sideOffset},get align(){return e.align},get alignOffset(){return e.alignOffset},get arrowPadding(){return e.arrowPadding},get avoidCollisions(){return e.avoidCollisions},get collisionBoundary(){return e.collisionBoundary},get collisionPadding(){return e.collisionPadding},get sticky(){return e.sticky},get hideWhenDetached(){return e.hideWhenDetached},get updatePositionStrategy(){return e.updatePositionStrategy},get strategy(){return e.strategy},get dir(){return e.dir},get preventScroll(){return e.preventScroll},get wrapperId(){return e.wrapperId},get style(){return e.style},get onPlaced(){return e.onPlaced},get customAnchor(){return a()},get isStatic(){return s()},get enabled(){return e.open},get onInteractOutside(){return e.onInteractOutside},get onCloseAutoFocus(){return e.onCloseAutoFocus},get onOpenAutoFocus(){return e.onOpenAutoFocus},get interactOutsideBehavior(){return r()},get loop(){return e.loop},get trapFocus(){return n()},get isValidEvent(){return i()},get onFocusOutside(){return e.onFocusOutside},forceMount:!1,get ref(){return e.ref}},()=>o))};ve(u,h=>{e.shouldRender&&h(d)})}G(t,l)}var m_t=new Set(["$$slots","$$events","$$legacy","popper","onEscapeKeydown","escapeKeydownBehavior","preventOverflowTextSelection","id","onPointerDown","onPointerUp","side","sideOffset","align","alignOffset","arrowPadding","avoidCollisions","collisionBoundary","collisionPadding","sticky","hideWhenDetached","updatePositionStrategy","strategy","dir","preventScroll","wrapperId","style","onPlaced","onInteractOutside","onCloseAutoFocus","onOpenAutoFocus","onFocusOutside","interactOutsideBehavior","loop","trapFocus","isValidEvent","customAnchor","isStatic","enabled"]);function _4(t,e){let r=ce(e,"interactOutsideBehavior",3,"close"),n=ce(e,"trapFocus",3,!0),i=ce(e,"isValidEvent",3,()=>!1),a=ce(e,"customAnchor",3,null),s=ce(e,"isStatic",3,!1),o=Tt(e,m_t);LOe(t,Rt({get popper(){return e.popper},get onEscapeKeydown(){return e.onEscapeKeydown},get escapeKeydownBehavior(){return e.escapeKeydownBehavior},get preventOverflowTextSelection(){return e.preventOverflowTextSelection},get id(){return e.id},get onPointerDown(){return e.onPointerDown},get onPointerUp(){return e.onPointerUp},get side(){return e.side},get sideOffset(){return e.sideOffset},get align(){return e.align},get alignOffset(){return e.alignOffset},get arrowPadding(){return e.arrowPadding},get avoidCollisions(){return e.avoidCollisions},get collisionBoundary(){return e.collisionBoundary},get collisionPadding(){return e.collisionPadding},get sticky(){return e.sticky},get hideWhenDetached(){return e.hideWhenDetached},get updatePositionStrategy(){return e.updatePositionStrategy},get strategy(){return e.strategy},get dir(){return e.dir},get preventScroll(){return e.preventScroll},get wrapperId(){return e.wrapperId},get style(){return e.style},get onPlaced(){return e.onPlaced},get customAnchor(){return a()},get isStatic(){return s()},get enabled(){return e.enabled},get onInteractOutside(){return e.onInteractOutside},get onCloseAutoFocus(){return e.onCloseAutoFocus},get onOpenAutoFocus(){return e.onOpenAutoFocus},get interactOutsideBehavior(){return r()},get loop(){return e.loop},get trapFocus(){return n()},get isValidEvent(){return i()},get onFocusOutside(){return e.onFocusOutside}},()=>o,{forceMount:!0}))}var __t=new Set(["$$slots","$$events","$$legacy","id","ref","forceMount","side","onInteractOutside","onEscapeKeydown","children","child","preventScroll","style"]),D1e=se("
");function v_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"forceMount",3,!1),s=ce(e,"side",3,"bottom"),o=ce(e,"onInteractOutside",3,Tn),l=ce(e,"onEscapeKeydown",3,Tn),u=ce(e,"preventScroll",3,!1),d=Tt(e,__t);const h=Yoe.create({id:_t(()=>n()),ref:_t(()=>i(),v=>i(v)),onInteractOutside:_t(()=>o()),onEscapeKeydown:_t(()=>l())}),f=W(()=>un(d,h.props));var p=Ae(),g=oe(p);{var m=v=>{_4(v,Rt(()=>S(f),()=>h.popperProps,{get ref(){return h.opts.ref},get side(){return s()},get enabled(){return h.root.opts.open.current},get id(){return n()},get preventScroll(){return u()},forceMount:!0,get shouldRender(){return h.shouldRender},popper:(y,E)=>{let T=()=>E?.().props,C=()=>E?.().wrapperProps;const w=W(()=>un(T(),{style:h.props.style},{style:e.style}));var x=Ae(),A=oe(x);{var R=F=>{var P=Ae(),N=oe(P);{let k=W(()=>({props:S(w),wrapperProps:C(),...h.snippetProps}));Pt(N,()=>e.child,()=>S(k))}G(F,P)},O=F=>{var P=D1e();Er(P,()=>({...C()}));var N=te(P);Er(N,()=>({...S(w)}));var k=te(N);Pt(k,()=>e.children??Vt),Z(N),Z(P),G(F,P)};ve(A,F=>{e.child?F(R):F(O,-1)})}G(y,x)},$$slots:{popper:!0}}))},_=v=>{m4(v,Rt(()=>S(f),()=>h.popperProps,{get ref(){return h.opts.ref},get side(){return s()},get open(){return h.root.opts.open.current},get id(){return n()},get preventScroll(){return u()},forceMount:!1,get shouldRender(){return h.shouldRender},popper:(y,E)=>{let T=()=>E?.().props,C=()=>E?.().wrapperProps;const w=W(()=>un(T(),{style:h.props.style},{style:e.style}));var x=Ae(),A=oe(x);{var R=F=>{var P=Ae(),N=oe(P);{let k=W(()=>({props:S(w),wrapperProps:C(),...h.snippetProps}));Pt(N,()=>e.child,()=>S(k))}G(F,P)},O=F=>{var P=D1e();Er(P,()=>({...C()}));var N=te(P);Er(N,()=>({...S(w)}));var k=te(N);Pt(k,()=>e.children??Vt),Z(N),Z(P),G(F,P)};ve(A,F=>{e.child?F(R):F(O,-1)})}G(y,x)},$$slots:{popper:!0}}))};ve(g,v=>{a()?v(m):a()||v(_,1)})}G(t,p),st()}function kR(t,e){at(e,!0);let r=ce(e,"mounted",15,!1),n=ce(e,"onMountedChange",3,Tn);_U(()=>(r(!0),n()(!0),()=>{r(!1),n()(!1)})),st()}var y_t=new Set(["$$slots","$$events","$$legacy","id","ref","value","label","disabled","children","child","onHighlight","onUnhighlight"]),b_t=se("
"),S_t=se(" ",1);function E_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"label",19,()=>e.value),s=ce(e,"disabled",3,!1),o=ce(e,"onHighlight",3,Tn),l=ce(e,"onUnhighlight",3,Tn),u=Tt(e,y_t);const d=Woe.create({id:_t(()=>n()),ref:_t(()=>i(),v=>i(v)),value:_t(()=>e.value),disabled:_t(()=>s()),label:_t(()=>a()),onHighlight:_t(()=>o()),onUnhighlight:_t(()=>l())}),h=W(()=>un(u,d.props));var f=S_t(),p=oe(f);{var g=v=>{var b=Ae(),y=oe(b);{let E=W(()=>({props:S(h),...d.snippetProps}));Pt(y,()=>e.child,()=>S(E))}G(v,b)},m=v=>{var b=b_t();Er(b,()=>({...S(h)}));var y=te(b);Pt(y,()=>e.children??Vt,()=>d.snippetProps),Z(b),G(v,b)};ve(p,v=>{e.child?v(g):v(m,-1)})}var _=ie(p,2);kR(_,{get mounted(){return d.mounted},set mounted(v){d.mounted=v}}),G(t,f),st()}var T_t=new Set(["$$slots","$$events","$$legacy","id","ref","children","child"]),C_t=se("
");function w_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=Tt(e,T_t);const s=joe.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);Pt(g,()=>e.child,()=>({props:S(o)})),G(f,p)},h=f=>{var p=C_t();Er(p,()=>({...S(o)}));var g=te(p);Pt(g,()=>e.children??Vt),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}var x_t=new Set(["$$slots","$$events","$$legacy","id","ref","delay","child","children"]),A_t=se("
"),R_t=se(" ",1);function N_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"delay",3,()=>50),s=Tt(e,x_t);const o=Xoe.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f)),delay:_t(()=>a())}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=f=>{var p=R_t(),g=oe(p);kR(g,{get mounted(){return o.scrollButtonState.mounted},set mounted(b){o.scrollButtonState.mounted=b}});var m=ie(g,2);{var _=b=>{var y=Ae(),E=oe(y);Pt(E,()=>e.child,()=>({props:s})),G(b,y)},v=b=>{var y=A_t();Er(y,()=>({...S(l)}));var E=te(y);Pt(E,()=>e.children??Vt),Z(y),G(b,y)};ve(m,b=>{e.child?b(_):b(v,-1)})}G(f,p)};ve(d,f=>{o.canScrollDown&&f(h)})}G(t,u),st()}var O_t=new Set(["$$slots","$$events","$$legacy","id","ref","delay","child","children"]),I_t=se("
"),k_t=se(" ",1);function D_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"delay",3,()=>50),s=Tt(e,O_t);const o=Qoe.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f)),delay:_t(()=>a())}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=f=>{var p=k_t(),g=oe(p);kR(g,{get mounted(){return o.scrollButtonState.mounted},set mounted(b){o.scrollButtonState.mounted=b}});var m=ie(g,2);{var _=b=>{var y=Ae(),E=oe(y);Pt(E,()=>e.child,()=>({props:s})),G(b,y)},v=b=>{var y=I_t();Er(y,()=>({...S(l)}));var E=te(y);Pt(E,()=>e.children??Vt),Z(y),G(b,y)};ve(m,b=>{e.child?b(_):b(v,-1)})}G(f,p)};ve(d,f=>{o.canScrollUp&&f(h)})}G(t,u),st()}function M_t(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"onOpenChange",3,Tn),i=ce(e,"onOpenChangeComplete",3,Tn);f0t.create({open:_t(()=>r(),a=>{r(a),n()?.(a)}),onOpenChangeComplete:_t(()=>i())}),g4(t,{children:(a,s)=>{var o=Ae(),l=oe(o);Pt(l,()=>e.children??Vt),G(a,o)},$$slots:{default:!0}}),st()}var L_t=new Set(["$$slots","$$events","$$legacy","child","children","ref","id","disabled","onSelect","closeOnSelect"]),P_t=se("
");function F_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=ce(e,"disabled",3,!1),s=ce(e,"onSelect",3,Tn),o=ce(e,"closeOnSelect",3,!0),l=Tt(e,L_t);const u=poe.create({id:_t(()=>i()),disabled:_t(()=>a()),onSelect:_t(()=>s()),ref:_t(()=>n(),m=>n(m)),closeOnSelect:_t(()=>o())}),d=W(()=>un(l,u.props));var h=Ae(),f=oe(h);{var p=m=>{var _=Ae(),v=oe(_);Pt(v,()=>e.child,()=>({props:S(d)})),G(m,_)},g=m=>{var _=P_t();Er(_,()=>({...S(d)}));var v=te(_);Pt(v,()=>e.children??Vt),Z(_),G(m,_)};ve(f,m=>{e.child?m(p):m(g,-1)})}G(t,h),st()}var B_t=new Set(["$$slots","$$events","$$legacy","ref","id","child","children"]),U_t=se("
");function $_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,B_t);const s=moe.create({id:_t(()=>i()),ref:_t(()=>n(),f=>n(f))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);Pt(g,()=>e.child,()=>({props:S(o)})),G(f,p)},h=f=>{var p=U_t();Er(p,()=>({...S(o)}));var g=te(p);Pt(g,()=>e.children??Vt),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}var G_t=new Set(["$$slots","$$events","$$legacy","id","ref","children","child","loop","onInteractOutside","forceMount","onEscapeKeydown","interactOutsideBehavior","escapeKeydownBehavior","onOpenAutoFocus","onCloseAutoFocus","onFocusOutside","side","trapFocus","style"]),M1e=se("
");function z_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"loop",3,!0),s=ce(e,"onInteractOutside",3,Tn),o=ce(e,"forceMount",3,!1),l=ce(e,"onEscapeKeydown",3,Tn),u=ce(e,"interactOutsideBehavior",3,"defer-otherwise-close"),d=ce(e,"escapeKeydownBehavior",3,"defer-otherwise-close"),h=ce(e,"onOpenAutoFocus",3,Tn),f=ce(e,"onCloseAutoFocus",3,Tn),p=ce(e,"onFocusOutside",3,Tn),g=ce(e,"side",3,"right"),m=ce(e,"trapFocus",3,!1),_=Tt(e,G_t);const v=wU.create({id:_t(()=>n()),loop:_t(()=>a()),ref:_t(()=>i(),N=>i(N)),isSub:!0,onCloseAutoFocus:_t(()=>C)});function b(N){const k=N.currentTarget.contains(N.target),M=Dmt[v.parentMenu.root.opts.dir.current].includes(N.key);k&&M&&(v.parentMenu.onClose(),v.parentMenu.triggerNode?.focus(),N.preventDefault())}const y=W(()=>v.parentMenu.root.getBitsAttr("sub-content")),E=W(()=>un(_,v.props,{side:g(),onkeydown:b,[S(y)]:""}));function T(N){h()(N),!N.defaultPrevented&&(N.preventDefault(),v.parentMenu.root.isUsingKeyboard&&v.parentMenu.contentNode&&hoe.dispatch(v.parentMenu.contentNode))}function C(N){f()(N),!N.defaultPrevented&&N.preventDefault()}function w(N){s()(N),!N.defaultPrevented&&v.parentMenu.onClose()}function x(N){l()(N),!N.defaultPrevented&&v.parentMenu.onClose()}function A(N){if(p()(N),N.defaultPrevented||!wp(N.target)||N.target.id===v.parentMenu.triggerNode?.id)return;if(v.parentMenu.parentMenu?.contentNode?.contains(N.target)){v.parentMenu.onClose(),N.preventDefault();return}const M=`[${v.parentMenu.root.getBitsAttr("sub-content")}]`;if(N.target.closest(M)){N.preventDefault();return}v.parentMenu.onClose()}var R=Ae(),O=oe(R);{var F=N=>{_4(N,Rt(()=>S(E),{get ref(){return v.opts.ref},get interactOutsideBehavior(){return u()},get escapeKeydownBehavior(){return d()},onOpenAutoFocus:T,get enabled(){return v.parentMenu.opts.open.current},onInteractOutside:w,onEscapeKeydown:x,onFocusOutside:A,preventScroll:!1,get loop(){return a()},get trapFocus(){return m()},get shouldRender(){return v.shouldRender},popper:(M,L)=>{let I=()=>L?.().props,U=()=>L?.().wrapperProps;const B=W(()=>un(I(),S(E),{style:Rp("menu")},{style:e.style}));var $=Ae(),H=oe($);{var q=Y=>{var j=Ae(),Q=oe(j);{let ae=W(()=>({props:S(B),wrapperProps:U(),...v.snippetProps}));Pt(Q,()=>e.child,()=>S(ae))}G(Y,j)},V=Y=>{var j=M1e();Er(j,()=>({...U()}));var Q=te(j);Er(Q,()=>({...S(B)}));var ae=te(Q);Pt(ae,()=>e.children??Vt),Z(Q),Z(j),G(Y,j)};ve(H,Y=>{e.child?Y(q):Y(V,-1)})}G(M,$)},$$slots:{popper:!0}}))},P=N=>{m4(N,Rt(()=>S(E),{get ref(){return v.opts.ref},get interactOutsideBehavior(){return u()},get escapeKeydownBehavior(){return d()},onCloseAutoFocus:C,onOpenAutoFocus:T,get open(){return v.parentMenu.opts.open.current},onInteractOutside:w,onEscapeKeydown:x,onFocusOutside:A,preventScroll:!1,get loop(){return a()},get trapFocus(){return m()},get shouldRender(){return v.shouldRender},popper:(M,L)=>{let I=()=>L?.().props,U=()=>L?.().wrapperProps;const B=W(()=>un(I(),S(E),{style:Rp("menu")},{style:e.style}));var $=Ae(),H=oe($);{var q=Y=>{var j=Ae(),Q=oe(j);{let ae=W(()=>({props:S(B),wrapperProps:U(),...v.snippetProps}));Pt(Q,()=>e.child,()=>S(ae))}G(Y,j)},V=Y=>{var j=M1e();Er(j,()=>({...U()}));var Q=te(j);Er(Q,()=>({...S(B)}));var ae=te(Q);Pt(ae,()=>e.children??Vt),Z(Q),Z(j),G(Y,j)};ve(H,Y=>{e.child?Y(q):Y(V,-1)})}G(M,$)},$$slots:{popper:!0}}))};ve(O,N=>{o()?N(F):o()||N(P,1)})}G(t,R),st()}var q_t=new Set(["$$slots","$$events","$$legacy","id","disabled","ref","children","child","onSelect","openDelay"]),H_t=se("
");function V_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"disabled",3,!1),a=ce(e,"ref",15,null),s=ce(e,"onSelect",3,Tn),o=ce(e,"openDelay",3,0),l=Tt(e,q_t);const u=goe.create({disabled:_t(()=>i()),onSelect:_t(()=>s()),id:_t(()=>n()),ref:_t(()=>a(),h=>a(h)),openDelay:_t(()=>o())}),d=W(()=>un(l,u.props));O8(t,{get id(){return n()},get ref(){return u.opts.ref},children:(h,f)=>{var p=Ae(),g=oe(p);{var m=v=>{var b=Ae(),y=oe(b);Pt(y,()=>e.child,()=>({props:S(d)})),G(v,b)},_=v=>{var b=H_t();Er(b,()=>({...S(d)}));var y=te(b);Pt(y,()=>e.children??Vt),Z(b),G(v,b)};ve(g,v=>{e.child?v(m):v(_,-1)})}G(h,p)},$$slots:{default:!0}}),st()}function hH(t,e){const[r,n]=t;let i=!1;const a=e.length;for(let s=0,o=a-1;s=n!=h>=n&&r<=(d-l)*(n-u)/(h-u)+l&&(i=!i)}return i}function fH(t,e){return t[0]>=e.left&&t[0]<=e.right&&t[1]>=e.top&&t[1]<=e.bottom}function L1e(t,e){const r=t.left+t.width/2,n=t.top+t.height/2,i=e.left+e.width/2,a=e.top+e.height/2,s=i-r,o=a-n;return Math.abs(s)>Math.abs(o)?s>0?"right":"left":o>0?"bottom":"top"}class Zoe{#e;#t;#r;#n=null;#i=null;#a=[];#s=null;#o=null;#l=null;#c(){this.#o!==null&&(cancelAnimationFrame(this.#o),this.#o=null)}#d(){this.#c(),this.#o=requestAnimationFrame(()=>{this.#o=null,!(!this.#n||!this.#i)&&(this.#f(),this.#e.onPointerExit())})}#u(){this.#l!==null&&(clearTimeout(this.#l),this.#l=null)}#p(){this.#r!==null&&(this.#u(),this.#l=window.setTimeout(()=>{this.#l=null,!(!this.#n||!this.#i)&&(this.#f(),this.#e.onPointerExit())},this.#r))}constructor(e){this.#e=e,this.#t=e.buffer??1;const r=e.transitIntentTimeout;this.#r=typeof r=="number"&&r>0?r:null,yi([e.triggerNode,e.contentNode,e.enabled],([n,i,a])=>{if(!n||!i||!a){this.#s=null,this.#f();return}this.#s&&this.#s!==n&&this.#f(),this.#s=n;const s=j2(n),o=f=>{this.#g([f.clientX,f.clientY],n,i)},l=f=>{const p=f.relatedTarget;if(Au(p)&&i.contains(p))return;const g=this.#e.ignoredTargets?.()??[];Au(p)&&g.some(m=>m===p||m.contains(p))||(this.#a=Au(p)&&g.length>0?g.filter(m=>p.contains(m)):[],this.#n=[f.clientX,f.clientY],this.#i="content",this.#d())},u=()=>{this.#f()},d=()=>{this.#f()},h=f=>{const p=f.relatedTarget;Au(p)&&n.contains(p)||(this.#n=[f.clientX,f.clientY],this.#i="trigger",this.#d())};return[Bi(s,"pointermove",o),Bi(n,"pointerleave",l),Bi(n,"pointerenter",u),Bi(i,"pointerenter",d),Bi(i,"pointerleave",h)].reduce((f,p)=>()=>{f(),p()},()=>{})})}#g(e,r,n){if(!this.#n||!this.#i)return;this.#c(),this.#p();const i=r.getBoundingClientRect(),a=n.getBoundingClientRect();if(this.#i==="content"&&fH(e,a)){this.#f();return}if(this.#i==="trigger"&&fH(e,i)){this.#f();return}if(this.#i==="content"&&this.#a.length>0)for(const d of this.#a){const h=d.getBoundingClientRect();if(fH(e,h))return;const f=L1e(i,h),p=this.#h(i,h,f);if(p&&hH(e,p))return}const s=L1e(i,a),o=this.#h(i,a,s);if(o&&hH(e,o))return;const l=this.#i==="content"?a:i,u=this.#m(this.#n,l,s,this.#i);hH(e,u)||(this.#f(),this.#e.onPointerExit())}#f(){this.#n=null,this.#i=null,this.#a=[],this.#c(),this.#u()}#h(e,r,n){const i=this.#t;switch(n){case"top":return[[Math.min(e.left,r.left)-i,e.top],[Math.min(e.left,r.left)-i,r.bottom],[Math.max(e.right,r.right)+i,r.bottom],[Math.max(e.right,r.right)+i,e.top]];case"bottom":return[[Math.min(e.left,r.left)-i,e.bottom],[Math.min(e.left,r.left)-i,r.top],[Math.max(e.right,r.right)+i,r.top],[Math.max(e.right,r.right)+i,e.bottom]];case"left":return[[e.left,Math.min(e.top,r.top)-i],[r.right,Math.min(e.top,r.top)-i],[r.right,Math.max(e.bottom,r.bottom)+i],[e.left,Math.max(e.bottom,r.bottom)+i]];case"right":return[[e.right,Math.min(e.top,r.top)-i],[r.left,Math.min(e.top,r.top)-i],[r.left,Math.max(e.bottom,r.bottom)+i],[e.right,Math.max(e.bottom,r.bottom)+i]]}}#m(e,r,n,i){const a=this.#t*4,[s,o]=e;switch(i==="trigger"?this.#v(n):n){case"top":return[[s-a,o+a],[s+a,o+a],[r.right+a,r.bottom],[r.right+a,r.top],[r.left-a,r.top],[r.left-a,r.bottom]];case"bottom":return[[s-a,o-a],[s+a,o-a],[r.right+a,r.top],[r.right+a,r.bottom],[r.left-a,r.bottom],[r.left-a,r.top]];case"left":return[[s+a,o-a],[s+a,o+a],[r.right,r.bottom+a],[r.left,r.bottom+a],[r.left,r.top-a],[r.right,r.top-a]];case"right":return[[s-a,o-a],[s-a,o+a],[r.left,r.bottom+a],[r.right,r.bottom+a],[r.right,r.top-a],[r.left,r.top-a]]}}#v(e){switch(e){case"top":return"bottom";case"bottom":return"top";case"left":return"right";case"right":return"left"}}}const CJ=xf({component:"popover",parts:["root","trigger","content","close","overlay"]}),Joe=new Ys("Popover.Root");class ele{static create(e){return Joe.set(new ele(e))}opts;#e=Oe(null);get contentNode(){return S(this.#e)}set contentNode(e){X(this.#e,e,!0)}contentPresence;#t=Oe(null);get triggerNode(){return S(this.#t)}set triggerNode(e){X(this.#t,e,!0)}#r=Oe(null);get overlayNode(){return S(this.#r)}set overlayNode(e){X(this.#r,e,!0)}overlayPresence;#n=Oe(!1);get openedViaHover(){return S(this.#n)}set openedViaHover(e){X(this.#n,e,!0)}#i=Oe(!1);get hasInteractedWithContent(){return S(this.#i)}set hasInteractedWithContent(e){X(this.#i,e,!0)}#a=Oe(!1);get hoverCooldown(){return S(this.#a)}set hoverCooldown(e){X(this.#a,e,!0)}#s=Oe(0);get closeDelay(){return S(this.#s)}set closeDelay(e){X(this.#s,e,!0)}#o=null;#l=null;constructor(e){this.opts=e,this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),this.overlayPresence=new F0({ref:_t(()=>this.overlayNode),open:this.opts.open}),yi(()=>this.opts.open.current,r=>{r||(this.openedViaHover=!1,this.hasInteractedWithContent=!1,this.#c())})}setDomContext(e){this.#l=e}#c(){this.#o!==null&&this.#l&&(this.#l.clearTimeout(this.#o),this.#o=null)}toggleOpen(){this.#c(),this.opts.open.current=!this.opts.open.current}handleClose(){this.#c(),this.opts.open.current&&(this.opts.open.current=!1)}handleHoverOpen(){this.#c(),!this.opts.open.current&&(this.openedViaHover=!0,this.opts.open.current=!0)}handleHoverClose(){this.opts.open.current&&this.openedViaHover&&!this.hasInteractedWithContent&&(this.opts.open.current=!1)}handleDelayedHoverClose(){this.opts.open.current&&(!this.openedViaHover||this.hasInteractedWithContent||(this.#c(),this.closeDelay<=0?this.opts.open.current=!1:this.#l&&(this.#o=this.#l.setTimeout(()=>{this.openedViaHover&&!this.hasInteractedWithContent&&(this.opts.open.current=!1),this.#o=null},this.closeDelay))))}cancelDelayedClose(){this.#c()}markInteraction(){this.hasInteractedWithContent=!0,this.#c()}}class tle{static create(e){return new tle(e,Joe.get())}opts;root;attachment;domContext;#e=null;#t=null;#r=Oe(!1);constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.triggerNode=n),this.domContext=new wf(e.ref),this.root.setDomContext(this.domContext),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this),this.onpointerenter=this.onpointerenter.bind(this),this.onpointerleave=this.onpointerleave.bind(this),yi(()=>this.opts.closeDelay.current,n=>{this.root.closeDelay=n})}#n(){this.#e!==null&&(this.domContext.clearTimeout(this.#e),this.#e=null)}#i(){this.#t!==null&&(this.domContext.clearTimeout(this.#t),this.#t=null)}#a(){this.#n(),this.#i()}onpointerenter(e){if(this.opts.disabled.current||!this.opts.openOnHover.current||c2(e)||(X(this.#r,!0),this.#i(),this.root.cancelDelayedClose(),this.root.opts.open.current||this.root.hoverCooldown))return;const r=this.opts.openDelay.current;r<=0?this.root.handleHoverOpen():this.#e=this.domContext.setTimeout(()=>{this.root.handleHoverOpen(),this.#e=null},r)}onpointerleave(e){this.opts.disabled.current||this.opts.openOnHover.current&&(c2(e)||(X(this.#r,!1),this.#n(),this.root.hoverCooldown=!1))}onclick(e){if(!this.opts.disabled.current&&e.button===0){if(this.#a(),S(this.#r)&&this.root.opts.open.current&&this.root.openedViaHover){this.root.openedViaHover=!1,this.root.hasInteractedWithContent=!0;return}S(this.#r)&&this.opts.openOnHover.current&&this.root.opts.open.current&&(this.root.hoverCooldown=!0),this.root.hoverCooldown&&!this.root.opts.open.current&&(this.root.hoverCooldown=!1),this.root.toggleOpen()}}onkeydown(e){this.opts.disabled.current||(e.key===Kg||e.key===xd)&&(e.preventDefault(),this.#a(),this.root.toggleOpen())}#s(){if(this.root.opts.open.current&&this.root.contentNode?.id)return this.root.contentNode?.id}#o=W(()=>({id:this.opts.id.current,"aria-haspopup":"dialog","aria-expanded":vf(this.root.opts.open.current),"data-state":Eh(this.root.opts.open.current),"aria-controls":this.#s(),[CJ.trigger]:"",disabled:this.opts.disabled.current,onkeydown:this.onkeydown,onclick:this.onclick,onpointerenter:this.onpointerenter,onpointerleave:this.onpointerleave,...this.attachment}));get props(){return S(this.#o)}set props(e){X(this.#o,e)}}class rle{static create(e){return new rle(e,Joe.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.contentNode=n),this.onpointerdown=this.onpointerdown.bind(this),this.onfocusin=this.onfocusin.bind(this),this.onpointerenter=this.onpointerenter.bind(this),this.onpointerleave=this.onpointerleave.bind(this),new Zoe({triggerNode:()=>this.root.triggerNode,contentNode:()=>this.root.contentNode,enabled:()=>this.root.opts.open.current&&this.root.openedViaHover&&!this.root.hasInteractedWithContent,onPointerExit:()=>{this.root.handleDelayedHoverClose()}})}onpointerdown(e){this.root.markInteraction()}onfocusin(e){const r=e.target;Au(r)&&TU(r)&&this.root.markInteraction()}onpointerenter(e){c2(e)||this.root.cancelDelayedClose()}onpointerleave(e){c2(e)}onInteractOutside=e=>{if(this.opts.onInteractOutside.current(e),e.defaultPrevented||!Au(e.target))return;const r=e.target.closest(CJ.selector("trigger"));if(!(r&&r===this.root.triggerNode)){if(this.opts.customAnchor.current){if(Au(this.opts.customAnchor.current)){if(this.opts.customAnchor.current.contains(e.target))return}else if(typeof this.opts.customAnchor.current=="string"){const n=document.querySelector(this.opts.customAnchor.current);if(n&&n.contains(e.target))return}}this.root.handleClose()}};onEscapeKeydown=e=>{this.opts.onEscapeKeydown.current(e),!e.defaultPrevented&&this.root.handleClose()};get shouldRender(){return this.root.contentPresence.shouldRender}get shouldTrapFocus(){return!(this.root.openedViaHover&&!this.root.hasInteractedWithContent)}#e=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({id:this.opts.id.current,tabindex:-1,"data-state":Eh(this.root.opts.open.current),...xv(this.root.contentPresence.transitionStatus),[CJ.content]:"",style:{pointerEvents:"auto",contain:"layout style"},onpointerdown:this.onpointerdown,onfocusin:this.onfocusin,onpointerenter:this.onpointerenter,onpointerleave:this.onpointerleave,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}popperProps={onInteractOutside:this.onInteractOutside,onEscapeKeydown:this.onEscapeKeydown}}var Y_t=new Set(["$$slots","$$events","$$legacy","child","children","ref","id","forceMount","onOpenAutoFocus","onCloseAutoFocus","onEscapeKeydown","onInteractOutside","trapFocus","preventScroll","customAnchor","style"]),P1e=se("
");function W_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=ce(e,"forceMount",3,!1),s=ce(e,"onOpenAutoFocus",3,Tn),o=ce(e,"onCloseAutoFocus",3,Tn),l=ce(e,"onEscapeKeydown",3,Tn),u=ce(e,"onInteractOutside",3,Tn),d=ce(e,"trapFocus",3,!0),h=ce(e,"preventScroll",3,!1),f=ce(e,"customAnchor",3,null),p=Tt(e,Y_t);const g=rle.create({id:_t(()=>i()),ref:_t(()=>n(),C=>n(C)),onInteractOutside:_t(()=>u()),onEscapeKeydown:_t(()=>l()),customAnchor:_t(()=>f())}),m=W(()=>un(p,g.props)),_=W(()=>d()&&g.shouldTrapFocus);function v(C){g.shouldTrapFocus||C.preventDefault(),s()(C)}var b=Ae(),y=oe(b);{var E=C=>{_4(C,Rt(()=>S(m),()=>g.popperProps,{get ref(){return g.opts.ref},get enabled(){return g.root.opts.open.current},get id(){return i()},get trapFocus(){return S(_)},get preventScroll(){return h()},loop:!0,forceMount:!0,get customAnchor(){return f()},onOpenAutoFocus:v,get onCloseAutoFocus(){return o()},get shouldRender(){return g.shouldRender},popper:(x,A)=>{let R=()=>A?.().props,O=()=>A?.().wrapperProps;const F=W(()=>un(R(),{style:Rp("popover")},{style:e.style}));var P=Ae(),N=oe(P);{var k=L=>{var I=Ae(),U=oe(I);{let B=W(()=>({props:S(F),wrapperProps:O(),...g.snippetProps}));Pt(U,()=>e.child,()=>S(B))}G(L,I)},M=L=>{var I=P1e();Er(I,()=>({...O()}));var U=te(I);Er(U,()=>({...S(F)}));var B=te(U);Pt(B,()=>e.children??Vt),Z(U),Z(I),G(L,I)};ve(N,L=>{e.child?L(k):L(M,-1)})}G(x,P)},$$slots:{popper:!0}}))},T=C=>{m4(C,Rt(()=>S(m),()=>g.popperProps,{get ref(){return g.opts.ref},get open(){return g.root.opts.open.current},get id(){return i()},get trapFocus(){return S(_)},get preventScroll(){return h()},loop:!0,forceMount:!1,get customAnchor(){return f()},onOpenAutoFocus:v,get onCloseAutoFocus(){return o()},get shouldRender(){return g.shouldRender},popper:(x,A)=>{let R=()=>A?.().props,O=()=>A?.().wrapperProps;const F=W(()=>un(R(),{style:Rp("popover")},{style:e.style}));var P=Ae(),N=oe(P);{var k=L=>{var I=Ae(),U=oe(I);{let B=W(()=>({props:S(F),wrapperProps:O(),...g.snippetProps}));Pt(U,()=>e.child,()=>S(B))}G(L,I)},M=L=>{var I=P1e();Er(I,()=>({...O()}));var U=te(I);Er(U,()=>({...S(F)}));var B=te(U);Pt(B,()=>e.children??Vt),Z(U),Z(I),G(L,I)};ve(N,L=>{e.child?L(k):L(M,-1)})}G(x,P)},$$slots:{popper:!0}}))};ve(y,C=>{a()?C(E):a()||C(T,1)})}G(t,b),st()}var K_t=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","type","disabled","openOnHover","openDelay","closeDelay"]),j_t=se("");function X_t(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"type",3,"button"),s=ce(e,"disabled",3,!1),o=ce(e,"openOnHover",3,!1),l=ce(e,"openDelay",3,700),u=ce(e,"closeDelay",3,300),d=Tt(e,K_t);const h=tle.create({id:_t(()=>n()),ref:_t(()=>i(),p=>i(p)),disabled:_t(()=>!!s()),openOnHover:_t(()=>o()),openDelay:_t(()=>l()),closeDelay:_t(()=>u())}),f=W(()=>un(d,h.props,{type:a()}));O8(t,{get id(){return n()},get ref(){return h.opts.ref},children:(p,g)=>{var m=Ae(),_=oe(m);{var v=y=>{var E=Ae(),T=oe(E);Pt(T,()=>e.child,()=>({props:S(f)})),G(y,E)},b=y=>{var E=j_t();Er(E,()=>({...S(f)}));var T=te(E);Pt(T,()=>e.children??Vt),Z(E),G(y,E)};ve(_,y=>{e.child?y(v):y(b,-1)})}G(p,m)},$$slots:{default:!0}}),st()}function DU(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"onOpenChange",3,Tn),i=ce(e,"onOpenChangeComplete",3,Tn);SU.create({variant:_t(()=>"dialog"),open:_t(()=>r(),o=>{r(o),n()(o)}),onOpenChangeComplete:_t(()=>i())});var a=Ae(),s=oe(a);Pt(s,()=>e.children??Vt),G(t,a),st()}var Q_t=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","disabled"]),Z_t=se("");function MU(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"disabled",3,!1),s=Tt(e,Q_t);const o=noe.create({variant:_t(()=>"close"),id:_t(()=>n()),ref:_t(()=>i(),p=>i(p)),disabled:_t(()=>!!a())}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=p=>{var g=Ae(),m=oe(g);Pt(m,()=>e.child,()=>({props:S(l)})),G(p,g)},f=p=>{var g=Z_t();Er(g,()=>({...S(l)}));var m=te(g);Pt(m,()=>e.children??Vt),Z(g),G(p,g)};ve(d,p=>{e.child?p(h):p(f,-1)})}G(t,u),st()}var J_t=new Set(["$$slots","$$events","$$legacy","id","children","child","ref","forceMount","onCloseAutoFocus","onOpenAutoFocus","onEscapeKeydown","onInteractOutside","trapFocus","preventScroll","restoreScrollDelay"]),evt=se(" ",1),tvt=se("
",1);function LU(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"forceMount",3,!1),s=ce(e,"onCloseAutoFocus",3,Tn),o=ce(e,"onOpenAutoFocus",3,Tn),l=ce(e,"onEscapeKeydown",3,Tn),u=ce(e,"onInteractOutside",3,Tn),d=ce(e,"trapFocus",3,!0),h=ce(e,"preventScroll",3,!0),f=ce(e,"restoreScrollDelay",3,null),p=Tt(e,J_t);const g=EU.create({id:_t(()=>n()),ref:_t(()=>i(),y=>i(y))}),m=W(()=>un(p,g.props));var _=Ae(),v=oe(_);{var b=y=>{Coe(y,{get ref(){return g.opts.ref},loop:!0,get trapFocus(){return d()},get enabled(){return g.root.opts.open.current},get onOpenAutoFocus(){return o()},get onCloseAutoFocus(){return s()},focusScope:(T,C)=>{let w=()=>C?.().props;Soe(T,Rt(()=>S(m),{get enabled(){return g.root.opts.open.current},get ref(){return g.opts.ref},onEscapeKeydown:x=>{l()(x),!x.defaultPrevented&&g.root.handleClose()},children:(x,A)=>{yoe(x,Rt(()=>S(m),{get ref(){return g.opts.ref},get enabled(){return g.root.opts.open.current},onInteractOutside:R=>{u()(R),!R.defaultPrevented&&g.root.handleClose()},children:(R,O)=>{xoe(R,Rt(()=>S(m),{get ref(){return g.opts.ref},get enabled(){return g.root.opts.open.current},children:(F,P)=>{var N=Ae(),k=oe(N);{var M=I=>{var U=evt(),B=oe(U);{var $=q=>{X5(q,{get preventScroll(){return h()},get restoreScrollDelay(){return f()}})};ve(B,q=>{g.root.opts.open.current&&q($)})}var H=ie(B,2);{let q=W(()=>({props:un(S(m),w()),...g.snippetProps}));Pt(H,()=>e.child,()=>S(q))}G(I,U)},L=I=>{var U=tvt(),B=oe(U);X5(B,{get preventScroll(){return h()}});var $=ie(B,2);Er($,q=>({...q}),[()=>un(S(m),w())]);var H=te($);Pt(H,()=>e.children??Vt),Z($),G(I,U)};ve(k,I=>{e.child?I(M):I(L,-1)})}G(F,N)},$$slots:{default:!0}}))},$$slots:{default:!0}}))},$$slots:{default:!0}}))},$$slots:{focusScope:!0}})};ve(v,y=>{(g.shouldRender||a())&&y(b)})}G(t,_),st()}function rvt(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"dir",3,"ltr"),i=ce(e,"onOpenChange",3,Tn),a=ce(e,"onOpenChangeComplete",3,Tn),s=ce(e,"_internal_variant",3,"dropdown-menu"),o=ce(e,"_internal_should_skip_exit_animation",3,void 0);const l=foe.create({variant:_t(()=>s()),dir:_t(()=>n()),onClose:()=>{r(!1),i()(!1)},shouldSkipExitAnimation:()=>o()?.()??!1});CU.create({open:_t(()=>r(),u=>{r(u),i()(u)}),onOpenChangeComplete:_t(()=>a())},l),g4(t,{children:(u,d)=>{var h=Ae(),f=oe(h);Pt(f,()=>e.children??Vt),G(u,h)},$$slots:{default:!0}}),st()}var nvt=new Set(["$$slots","$$events","$$legacy","id","child","children","ref","loop","onInteractOutside","onEscapeKeydown","onCloseAutoFocus","forceMount","trapFocus","style"]),F1e=se("
");function ivt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"loop",3,!0),s=ce(e,"onInteractOutside",3,Tn),o=ce(e,"onEscapeKeydown",3,Tn),l=ce(e,"onCloseAutoFocus",3,Tn),u=ce(e,"forceMount",3,!1),d=ce(e,"trapFocus",3,!1),h=Tt(e,nvt);const f=wU.create({id:_t(()=>n()),loop:_t(()=>a()),ref:_t(()=>i(),E=>i(E)),onCloseAutoFocus:_t(()=>l())}),p=W(()=>un(h,f.props));function g(E){if(f.handleInteractOutside(E),!E.defaultPrevented&&(s()(E),!E.defaultPrevented)){if(E.target&&E.target instanceof Element){const T=`[${f.parentMenu.root.getBitsAttr("sub-content")}]`;if(E.target.closest(T))return}f.parentMenu.onClose()}}function m(E){o()(E),!E.defaultPrevented&&f.parentMenu.onClose()}var _=Ae(),v=oe(_);{var b=E=>{_4(E,Rt(()=>S(p),()=>f.popperProps,{get ref(){return f.opts.ref},get enabled(){return f.parentMenu.opts.open.current},onInteractOutside:g,onEscapeKeydown:m,get trapFocus(){return d()},get loop(){return a()},forceMount:!0,get id(){return n()},get shouldRender(){return f.shouldRender},popper:(C,w)=>{let x=()=>w?.().props,A=()=>w?.().wrapperProps;const R=W(()=>un(x(),{style:Rp("dropdown-menu")},{style:e.style}));var O=Ae(),F=oe(O);{var P=k=>{var M=Ae(),L=oe(M);{let I=W(()=>({props:S(R),wrapperProps:A(),...f.snippetProps}));Pt(L,()=>e.child,()=>S(I))}G(k,M)},N=k=>{var M=F1e();Er(M,()=>({...A()}));var L=te(M);Er(L,()=>({...S(R)}));var I=te(L);Pt(I,()=>e.children??Vt),Z(L),Z(M),G(k,M)};ve(F,k=>{e.child?k(P):k(N,-1)})}G(C,O)},$$slots:{popper:!0}}))},y=E=>{m4(E,Rt(()=>S(p),()=>f.popperProps,{get ref(){return f.opts.ref},get open(){return f.parentMenu.opts.open.current},onInteractOutside:g,onEscapeKeydown:m,get trapFocus(){return d()},get loop(){return a()},forceMount:!1,get id(){return n()},get shouldRender(){return f.shouldRender},popper:(C,w)=>{let x=()=>w?.().props,A=()=>w?.().wrapperProps;const R=W(()=>un(x(),{style:Rp("dropdown-menu")},{style:e.style}));var O=Ae(),F=oe(O);{var P=k=>{var M=Ae(),L=oe(M);{let I=W(()=>({props:S(R),wrapperProps:A(),...f.snippetProps}));Pt(L,()=>e.child,()=>S(I))}G(k,M)},N=k=>{var M=F1e();Er(M,()=>({...A()}));var L=te(M);Er(L,()=>({...S(R)}));var I=te(L);Pt(I,()=>e.children??Vt),Z(L),Z(M),G(k,M)};ve(F,k=>{e.child?k(P):k(N,-1)})}G(C,O)},$$slots:{popper:!0}}))};ve(v,E=>{u()?E(b):u()||E(y,1)})}G(t,_),st()}var avt=new Set(["$$slots","$$events","$$legacy","id","ref","child","children","disabled","type"]),svt=se("");function ovt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"disabled",3,!1),s=ce(e,"type",3,"button"),o=Tt(e,avt);const l=_oe.create({id:_t(()=>n()),disabled:_t(()=>a()??!1),ref:_t(()=>i(),d=>i(d))}),u=W(()=>un(o,l.props,{type:s()}));O8(t,{get id(){return n()},get ref(){return l.opts.ref},children:(d,h)=>{var f=Ae(),p=oe(f);{var g=_=>{var v=Ae(),b=oe(v);Pt(b,()=>e.child,()=>({props:S(u)})),G(_,v)},m=_=>{var v=svt();Er(v,()=>({...S(u)}));var b=te(v);Pt(b,()=>e.children??Vt),Z(v),G(_,v)};ve(p,_=>{e.child?_(g):_(m,-1)})}G(d,f)},$$slots:{default:!0}}),st()}const lvt=xf({component:"label",parts:["root"]});class nle{static create(e){return new nle(e)}opts;attachment;constructor(e){this.opts=e,this.attachment=$i(this.opts.ref),this.onmousedown=this.onmousedown.bind(this)}onmousedown(e){e.detail>1&&e.preventDefault()}#e=W(()=>({id:this.opts.id.current,[lvt.root]:"",onmousedown:this.onmousedown,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}var cvt=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","for"]),uvt=se("");function dvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=Tt(e,cvt);const s=nle.create({id:_t(()=>n()),ref:_t(()=>i(),f=>i(f))}),o=W(()=>un(a,s.props,{for:e.for}));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);Pt(g,()=>e.child,()=>({props:S(o)})),G(f,p)},h=f=>{var p=uvt();Er(p,()=>({...S(o),for:e.for}));var g=te(p);Pt(g,()=>e.children??Vt),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}const POe=xf({component:"link-preview",parts:["content","trigger"]}),ile=new Ys("LinkPreview.Root");class ale{static create(e){return ile.set(new ale(e))}opts;#e=Oe(!1);get hasSelection(){return S(this.#e)}set hasSelection(e){X(this.#e,e,!0)}#t=Oe(!1);get isPointerDownOnContent(){return S(this.#t)}set isPointerDownOnContent(e){X(this.#t,e,!0)}#r=Oe(!1);get containsSelection(){return S(this.#r)}set containsSelection(e){X(this.#r,e,!0)}timeout=null;#n=Oe(null);get contentNode(){return S(this.#n)}set contentNode(e){X(this.#n,e,!0)}#i=Oe(!1);get contentMounted(){return S(this.#i)}set contentMounted(e){X(this.#i,e,!0)}contentPresence;#a=Oe(null);get triggerNode(){return S(this.#a)}set triggerNode(e){X(this.#a,e,!0)}isOpening=!1;domContext=new wf(()=>null);constructor(e){this.opts=e,this.contentPresence=new F0({ref:_t(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),yi(()=>this.opts.open.current,r=>{if(!r){this.hasSelection=!1;return}if(!this.domContext)return;const n=()=>{this.containsSelection=!1,this.isPointerDownOnContent=!1,vU(1,()=>{this.domContext.getDocument().getSelection()?.toString()!==""?this.hasSelection=!0:this.hasSelection=!1})},i=Bi(this.domContext.getDocument(),"pointerup",n);if(!this.contentNode)return;const a=Pmt(this.contentNode);for(const s of a)s.setAttribute("tabindex","-1");return()=>{i(),this.hasSelection=!1,this.isPointerDownOnContent=!1}})}clearTimeout(){this.timeout&&(this.domContext.clearTimeout(this.timeout),this.timeout=null)}handleOpen(){this.clearTimeout(),!(this.opts.open.current||this.opts.disabled.current)&&(this.isOpening=!0,this.timeout=this.domContext.setTimeout(()=>{this.isOpening&&(this.opts.open.current=!0,this.isOpening=!1)},this.opts.openDelay.current))}immediateClose(){this.clearTimeout(),this.isOpening=!1,this.opts.open.current=!1}handleClose(){this.isOpening=!1,this.clearTimeout(),!this.isPointerDownOnContent&&!this.hasSelection&&(this.timeout=this.domContext.setTimeout(()=>{this.opts.open.current=!1},this.opts.closeDelay.current))}}class sle{static create(e){return new sle(e,ile.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.triggerNode=n),this.root.domContext=new wf(e.ref),this.onpointerenter=this.onpointerenter.bind(this),this.onpointerleave=this.onpointerleave.bind(this),this.onfocus=this.onfocus.bind(this),this.onblur=this.onblur.bind(this)}onpointerenter(e){c2(e)||this.root.handleOpen()}onpointerleave(e){c2(e)||(!this.root.contentMounted||!this.root.opts.open.current)&&this.root.immediateClose()}onfocus(e){eOe(e.currentTarget)&&this.root.handleOpen()}onblur(e){this.root.handleClose()}#e=W(()=>({id:this.opts.id.current,"aria-haspopup":"dialog","aria-expanded":vf(this.root.opts.open.current),"data-state":Eh(this.root.opts.open.current),"aria-controls":this.root.contentNode?.id,role:"button",[POe.trigger]:"",onpointerenter:this.onpointerenter,onfocus:this.onfocus,onblur:this.onblur,onpointerleave:this.onpointerleave,...this.attachment}));get props(){return S(this.#e)}set props(e){X(this.#e,e)}}class ole{static create(e){return new ole(e,ile.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.contentNode=n),this.root.domContext=new wf(e.ref),this.onpointerdown=this.onpointerdown.bind(this),this.onpointerenter=this.onpointerenter.bind(this),this.onfocusout=this.onfocusout.bind(this),new Zoe({triggerNode:()=>this.root.triggerNode,contentNode:()=>this.opts.ref.current,enabled:()=>this.root.opts.open.current,onPointerExit:()=>{this.root.handleClose()}}),Sh(()=>{this.root.clearTimeout()})}onpointerdown(e){const r=e.target;Au(r)&&(e.currentTarget.contains(r)&&(this.root.containsSelection=!0),this.root.hasSelection=!0,this.root.isPointerDownOnContent=!0)}onpointerenter(e){c2(e)||this.root.handleOpen()}onfocusout(e){e.preventDefault()}onInteractOutside=e=>{this.opts.onInteractOutside.current(e),!e.defaultPrevented&&this.root.handleClose()};onEscapeKeydown=e=>{this.opts.onEscapeKeydown.current?.(e),!e.defaultPrevented&&this.root.handleClose()};onOpenAutoFocus=e=>{e.preventDefault()};onCloseAutoFocus=e=>{e.preventDefault()};get shouldRender(){return this.root.contentPresence.shouldRender}#e=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({id:this.opts.id.current,tabindex:-1,"data-state":Eh(this.root.opts.open.current),...xv(this.root.contentPresence.transitionStatus),[POe.content]:"",onpointerdown:this.onpointerdown,onpointerenter:this.onpointerenter,onfocusout:this.onfocusout,...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}popperProps={onInteractOutside:this.onInteractOutside,onEscapeKeydown:this.onEscapeKeydown,onOpenAutoFocus:this.onOpenAutoFocus,onCloseAutoFocus:this.onCloseAutoFocus}}function hvt(t,e){at(e,!0);let r=ce(e,"disabled",3,!1),n=ce(e,"open",15,!1),i=ce(e,"onOpenChange",3,Tn),a=ce(e,"onOpenChangeComplete",3,Tn),s=ce(e,"openDelay",3,700),o=ce(e,"closeDelay",3,300);ale.create({disabled:_t(()=>r()),open:_t(()=>n(),d=>{n(d),i()(d)}),openDelay:_t(()=>s()),closeDelay:_t(()=>o()),onOpenChangeComplete:_t(()=>a())});var l=Ae(),u=oe(l);Me(u,()=>g4,(d,h)=>{h(d,{children:(f,p)=>{var g=Ae(),m=oe(g);Pt(m,()=>e.children??Vt),G(f,g)},$$slots:{default:!0}})}),G(t,l),st()}var fvt=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","side","sideOffset","align","avoidCollisions","arrowPadding","sticky","hideWhenDetached","collisionPadding","onInteractOutside","onEscapeKeydown","forceMount","style"]),B1e=se("
"),U1e=se(" ",1);function pvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"side",3,"top"),s=ce(e,"sideOffset",3,0),o=ce(e,"align",3,"center"),l=ce(e,"avoidCollisions",3,!0),u=ce(e,"arrowPadding",3,0),d=ce(e,"sticky",3,"partial"),h=ce(e,"hideWhenDetached",3,!1),f=ce(e,"collisionPadding",3,0),p=ce(e,"onInteractOutside",3,Tn),g=ce(e,"onEscapeKeydown",3,Tn),m=ce(e,"forceMount",3,!1),_=Tt(e,fvt);const v=ole.create({id:_t(()=>n()),ref:_t(()=>i(),x=>i(x)),onInteractOutside:_t(()=>p()),onEscapeKeydown:_t(()=>g())}),b=W(()=>({side:a(),sideOffset:s(),align:o(),avoidCollisions:l(),arrowPadding:u(),sticky:d(),hideWhenDetached:h(),collisionPadding:f()})),y=W(()=>un(_,S(b),v.props));var E=Ae(),T=oe(E);{var C=x=>{_4(x,Rt(()=>S(y),()=>v.popperProps,{get ref(){return v.opts.ref},get enabled(){return v.root.opts.open.current},get id(){return n()},trapFocus:!1,loop:!1,preventScroll:!1,forceMount:!0,get shouldRender(){return v.shouldRender},popper:(R,O)=>{let F=()=>O?.().props,P=()=>O?.().wrapperProps;const N=W(()=>un(F(),{style:Rp("link-preview")},{style:e.style}));var k=U1e(),M=oe(k);{var L=B=>{var $=Ae(),H=oe($);{let q=W(()=>({props:S(N),wrapperProps:P(),...v.snippetProps}));Pt(H,()=>e.child,()=>S(q))}G(B,$)},I=B=>{var $=B1e();Er($,()=>({...P()}));var H=te($);Er(H,()=>({...S(N)}));var q=te(H);Pt(q,()=>e.children??Vt),Z(H),Z($),G(B,$)};ve(M,B=>{e.child?B(L):B(I,-1)})}var U=ie(M,2);kR(U,{get mounted(){return v.root.contentMounted},set mounted(B){v.root.contentMounted=B}}),G(R,k)},$$slots:{popper:!0}}))},w=x=>{m4(x,Rt(()=>S(y),()=>v.popperProps,{get ref(){return v.opts.ref},get open(){return v.root.opts.open.current},get id(){return n()},trapFocus:!1,loop:!1,preventScroll:!1,forceMount:!1,get shouldRender(){return v.shouldRender},popper:(R,O)=>{let F=()=>O?.().props,P=()=>O?.().wrapperProps;const N=W(()=>un(F(),{style:Rp("link-preview")},{style:e.style}));var k=U1e(),M=oe(k);{var L=B=>{var $=Ae(),H=oe($);{let q=W(()=>({props:S(N),wrapperProps:P(),...v.snippetProps}));Pt(H,()=>e.child,()=>S(q))}G(B,$)},I=B=>{var $=B1e();Er($,()=>({...P()}));var H=te($);Er(H,()=>({...S(N)}));var q=te(H);Pt(q,()=>e.children??Vt),Z(H),Z($),G(B,$)};ve(M,B=>{e.child?B(L):B(I,-1)})}var U=ie(M,2);kR(U,{get mounted(){return v.root.contentMounted},set mounted(B){v.root.contentMounted=B}}),G(R,k)},$$slots:{popper:!0}}))};ve(T,x=>{m()?x(C):m()||x(w,1)})}G(t,E),st()}var gvt=new Set(["$$slots","$$events","$$legacy","ref","id","child","children"]),mvt=se("");function _vt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,gvt);const s=sle.create({id:_t(()=>i()),ref:_t(()=>n(),d=>n(d))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);Me(u,()=>O8,(d,h)=>{h(d,{get id(){return i()},get ref(){return s.opts.ref},children:(f,p)=>{var g=Ae(),m=oe(g);{var _=b=>{var y=Ae(),E=oe(y);Pt(E,()=>e.child,()=>({props:S(o)})),G(b,y)},v=b=>{var y=mvt();Er(y,()=>({...S(o)}));var E=te(y);Pt(E,()=>e.children??Vt),Z(y),G(b,y)};ve(m,b=>{e.child?b(_):b(v,-1)})}G(f,g)},$$slots:{default:!0}})}),G(t,l),st()}class Z5{#e;#t;constructor(e,r){this.#e=e,this.#t=r,this.handler=this.handler.bind(this),Kt(this.handler)}handler(){let e=0;const r=this.#e();if(!r)return;const n=new ResizeObserver(()=>{cancelAnimationFrame(e),e=window.requestAnimationFrame(this.#t)});return n.observe(r),()=>{window.cancelAnimationFrame(e),n.unobserve(r)}}}class vvt{opts;present;#e;#t=Oe(!1);#r=!1;#n=Oe(void 0);#i=null;constructor(e){this.opts=e,this.present=this.opts.open,X(this.#t,e.open.current,!0),this.#e=new rOe({ref:this.opts.ref,afterTick:this.opts.open}),Sh(()=>this.#s()),yi(()=>this.present.current,r=>{if(!this.#r){this.#r=!0;return}this.#s(),r&&X(this.#t,!0),X(this.#n,r?"starting":"ending",!0),r&&(this.#i=window.requestAnimationFrame(()=>{this.#i=null,this.present.current&&X(this.#n,void 0)})),this.#e.run(()=>{r===this.present.current&&(r||X(this.#t,!1),X(this.#n,void 0))})})}#a=W(()=>S(this.#t));get isPresent(){return S(this.#a)}set isPresent(e){X(this.#a,e)}get transitionStatus(){return S(this.#n)}#s(){this.#i!==null&&(window.cancelAnimationFrame(this.#i),this.#i=null)}}function PU(t,e){at(e,!0);const r=new vvt({open:_t(()=>e.open),ref:e.ref});var n=Ae(),i=oe(n);{var a=s=>{var o=Ae(),l=oe(o);Pt(l,()=>e.presence??Vt,()=>({present:r.isPresent,transitionStatus:r.transitionStatus})),G(s,o)};ve(i,s=>{(e.forceMount||e.open||r.isPresent)&&s(a)})}G(t,n),st()}function yvt(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"onOpenChange",3,Tn),i=ce(e,"onOpenChangeComplete",3,Tn);ele.create({open:_t(()=>r(),a=>{r(a),n()(a)}),onOpenChangeComplete:_t(()=>i())}),g4(t,{children:(a,s)=>{var o=Ae(),l=oe(o);Pt(l,()=>e.children??Vt),G(a,o)},$$slots:{default:!0}}),st()}const wJ=xf({component:"radio-group",parts:["root","item"]}),lle=new Ys("RadioGroup.Root");class cle{static create(e){return lle.set(new cle(e))}opts;#e=W(()=>this.opts.value.current!=="");get hasValue(){return S(this.#e)}set hasValue(e){X(this.#e,e)}rovingFocusGroup;attachment;constructor(e){this.opts=e,this.attachment=$i(this.opts.ref),this.rovingFocusGroup=new tOe({rootNode:this.opts.ref,candidateAttr:wJ.item,loop:this.opts.loop,orientation:this.opts.orientation})}isChecked(e){return this.opts.value.current===e}setValue(e){this.opts.value.current=e}#t=W(()=>({id:this.opts.id.current,role:"radiogroup","aria-required":vf(this.opts.required.current),"aria-disabled":vf(this.opts.disabled.current),"aria-readonly":this.opts.readonly.current?"true":void 0,"data-disabled":Uo(this.opts.disabled.current),"data-readonly":Uo(this.opts.readonly.current),"data-orientation":this.opts.orientation.current,[wJ.root]:"",...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class ule{static create(e){return new ule(e,lle.get())}opts;root;attachment;#e=W(()=>this.root.opts.value.current===this.opts.value.current);get checked(){return S(this.#e)}set checked(e){X(this.#e,e)}#t=W(()=>this.opts.disabled.current||this.root.opts.disabled.current);#r=W(()=>this.root.opts.readonly.current);#n=W(()=>this.root.isChecked(this.opts.value.current));#i=Oe(-1);constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref),this.opts.value.current===this.root.opts.value.current?(this.root.rovingFocusGroup.setCurrentTabStopId(this.opts.id.current),X(this.#i,0)):this.root.opts.value.current||X(this.#i,0),Kt(()=>{X(this.#i,this.root.rovingFocusGroup.getTabIndex(this.opts.ref.current),!0)}),yi([()=>this.opts.value.current,()=>this.root.opts.value.current],()=>{this.opts.value.current===this.root.opts.value.current&&(this.root.rovingFocusGroup.setCurrentTabStopId(this.opts.id.current),X(this.#i,0))}),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this),this.onfocus=this.onfocus.bind(this)}onclick(e){this.opts.disabled.current||S(this.#r)||this.root.setValue(this.opts.value.current)}onfocus(e){!this.root.hasValue||S(this.#r)||this.root.setValue(this.opts.value.current)}onkeydown(e){if(!S(this.#t)){if(e.key===xd){e.preventDefault(),S(this.#r)||this.root.setValue(this.opts.value.current);return}this.root.rovingFocusGroup.handleKeydown(this.opts.ref.current,e,!0)}}#a=W(()=>({checked:S(this.#n)}));get snippetProps(){return S(this.#a)}set snippetProps(e){X(this.#a,e)}#s=W(()=>({id:this.opts.id.current,disabled:S(this.#t)?!0:void 0,"data-value":this.opts.value.current,"data-orientation":this.root.opts.orientation.current,"data-disabled":Uo(S(this.#t)),"data-readonly":Uo(S(this.#r)),"data-state":S(this.#n)?"checked":"unchecked","aria-checked":eoe(S(this.#n),!1),[wJ.item]:"",type:"button",role:"radio",tabindex:S(this.#i),onkeydown:this.onkeydown,onfocus:this.onfocus,onclick:this.onclick,...this.attachment}));get props(){return S(this.#s)}set props(e){X(this.#s,e)}}class dle{static create(){return new dle(lle.get())}root;#e=W(()=>this.root.opts.name.current!==void 0);get shouldRender(){return S(this.#e)}set shouldRender(e){X(this.#e,e)}constructor(e){this.root=e,this.onfocus=this.onfocus.bind(this)}onfocus(e){this.root.rovingFocusGroup.focusCurrentTabStop()}#t=W(()=>({name:this.root.opts.name.current,value:this.root.opts.value.current,required:this.root.opts.required.current,disabled:this.root.opts.disabled.current,onfocus:this.onfocus}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}function bvt(t,e){at(e,!1);const r=dle.create();d4();var n=Ae(),i=oe(n);{var a=s=>{AU(s,Rt(()=>r.props))};ve(i,s=>{r.shouldRender&&s(a)})}G(t,n),st()}var Svt=new Set(["$$slots","$$events","$$legacy","disabled","children","child","value","ref","orientation","loop","name","required","readonly","id","onValueChange"]),Evt=se("
"),Tvt=se(" ",1);function Cvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"disabled",3,!1),i=ce(e,"value",15,""),a=ce(e,"ref",15,null),s=ce(e,"orientation",3,"vertical"),o=ce(e,"loop",3,!0),l=ce(e,"name",3,void 0),u=ce(e,"required",3,!1),d=ce(e,"readonly",3,!1),h=ce(e,"id",19,()=>Yi(r)),f=ce(e,"onValueChange",3,Tn),p=Tt(e,Svt);const g=cle.create({orientation:_t(()=>s()),disabled:_t(()=>n()),loop:_t(()=>o()),name:_t(()=>l()),required:_t(()=>u()),readonly:_t(()=>d()),id:_t(()=>h()),value:_t(()=>i(),T=>{T!==i()&&(i(T),f()?.(T))}),ref:_t(()=>a(),T=>a(T))}),m=W(()=>un(p,g.props));var _=Tvt(),v=oe(_);{var b=T=>{var C=Ae(),w=oe(C);Pt(w,()=>e.child,()=>({props:S(m)})),G(T,C)},y=T=>{var C=Evt();Er(C,()=>({...S(m)}));var w=te(C);Pt(w,()=>e.children??Vt),Z(C),G(T,C)};ve(v,T=>{e.child?T(b):T(y,-1)})}var E=ie(v,2);bvt(E,{}),G(t,_),st()}var wvt=new Set(["$$slots","$$events","$$legacy","id","children","child","value","disabled","ref"]),xvt=se("");function Avt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"disabled",3,!1),a=ce(e,"ref",15,null),s=Tt(e,wvt);const o=ule.create({value:_t(()=>e.value),disabled:_t(()=>i()??!1),id:_t(()=>n()),ref:_t(()=>a(),p=>a(p))}),l=W(()=>un(s,o.props));var u=Ae(),d=oe(u);{var h=p=>{var g=Ae(),m=oe(g);{let _=W(()=>({props:S(l),...o.snippetProps}));Pt(m,()=>e.child,()=>S(_))}G(p,g)},f=p=>{var g=xvt();Er(g,()=>({...S(l)}));var m=te(g);Pt(m,()=>e.children??Vt,()=>o.snippetProps),Z(g),G(p,g)};ve(d,p=>{e.child?p(h):p(f,-1)})}G(t,u),st()}function Rvt(t,e,r){return Math.min(r,Math.max(e,t))}class Nvt{state;#e;constructor(e,r){this.state=xu(e),this.#e=r,this.dispatch=this.dispatch.bind(this)}#t(e){return this.#e[this.state.current][e]??this.state.current}dispatch(e){this.state.current=this.#t(e)}}const I8=xf({component:"scroll-area",parts:["root","viewport","corner","thumb","scrollbar"]}),k8=new Ys("ScrollArea.Root"),D8=new Ys("ScrollArea.Scrollbar"),FU=new Ys("ScrollArea.ScrollbarVisible"),hle=new Ys("ScrollArea.ScrollbarAxis"),FOe=new Ys("ScrollArea.ScrollbarShared");class fle{static create(e){return k8.set(new fle(e))}opts;attachment;#e=Oe(null);get scrollAreaNode(){return S(this.#e)}set scrollAreaNode(e){X(this.#e,e,!0)}#t=Oe(null);get viewportNode(){return S(this.#t)}set viewportNode(e){X(this.#t,e,!0)}#r=Oe(null);get contentNode(){return S(this.#r)}set contentNode(e){X(this.#r,e,!0)}#n=Oe(null);get scrollbarXNode(){return S(this.#n)}set scrollbarXNode(e){X(this.#n,e,!0)}#i=Oe(null);get scrollbarYNode(){return S(this.#i)}set scrollbarYNode(e){X(this.#i,e,!0)}#a=Oe(0);get cornerWidth(){return S(this.#a)}set cornerWidth(e){X(this.#a,e,!0)}#s=Oe(0);get cornerHeight(){return S(this.#s)}set cornerHeight(e){X(this.#s,e,!0)}#o=Oe(!1);get scrollbarXEnabled(){return S(this.#o)}set scrollbarXEnabled(e){X(this.#o,e,!0)}#l=Oe(!1);get scrollbarYEnabled(){return S(this.#l)}set scrollbarYEnabled(e){X(this.#l,e,!0)}domContext;constructor(e){this.opts=e,this.attachment=$i(e.ref,r=>this.scrollAreaNode=r),this.domContext=new wf(e.ref)}#c=W(()=>({id:this.opts.id.current,dir:this.opts.dir.current,style:{position:"relative","--bits-scroll-area-corner-height":`${this.cornerHeight}px`,"--bits-scroll-area-corner-width":`${this.cornerWidth}px`},[I8.root]:"",...this.attachment}));get props(){return S(this.#c)}set props(e){X(this.#c,e)}}class ple{static create(e){return new ple(e,k8.get())}opts;root;attachment;#e=xu(h4());#t=xu(null);contentAttachment=$i(this.#t,e=>this.root.contentNode=e);constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(e.ref,n=>this.root.viewportNode=n)}#r=W(()=>({id:this.opts.id.current,style:{overflowX:this.root.scrollbarXEnabled?"scroll":"hidden",overflowY:this.root.scrollbarYEnabled?"scroll":"hidden"},[I8.viewport]:"",...this.attachment}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}#n=W(()=>({id:this.#e.current,"data-scroll-area-content":"",style:{minWidth:this.root.scrollbarXEnabled?"fit-content":void 0},...this.contentAttachment}));get contentProps(){return S(this.#n)}set contentProps(e){X(this.#n,e)}}class gle{static create(e){return D8.set(new gle(e,k8.get()))}opts;root;#e=W(()=>this.opts.orientation.current==="horizontal");get isHorizontal(){return S(this.#e)}set isHorizontal(e){X(this.#e,e)}#t=Oe(!1);get hasThumb(){return S(this.#t)}set hasThumb(e){X(this.#t,e,!0)}constructor(e,r){this.opts=e,this.root=r,yi(()=>this.isHorizontal,n=>n?(this.root.scrollbarXEnabled=!0,()=>{this.root.scrollbarXEnabled=!1}):(this.root.scrollbarYEnabled=!0,()=>{this.root.scrollbarYEnabled=!1}))}}class mle{static create(){return new mle(D8.get())}scrollbar;root;#e=Oe(!1);get isVisible(){return S(this.#e)}set isVisible(e){X(this.#e,e,!0)}constructor(e){this.scrollbar=e,this.root=e.root,Kt(()=>{const r=this.root.scrollAreaNode,n=this.root.opts.scrollHideDelay.current;let i=0;if(!r)return;const a=()=>{this.root.domContext.clearTimeout(i),zi(()=>this.isVisible=!0)},s=()=>{i&&this.root.domContext.clearTimeout(i),i=this.root.domContext.setTimeout(()=>{zi(()=>{this.scrollbar.hasThumb=!1,this.isVisible=!1})},n)},o=Vb(Bi(r,"pointerenter",a),Bi(r,"pointerleave",s));return()=>{this.root.domContext.getWindow().clearTimeout(i),o()}})}#t=W(()=>({"data-state":this.isVisible?"visible":"hidden"}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class _le{static create(){return new _le(D8.get())}scrollbar;root;machine=new Nvt("hidden",{hidden:{SCROLL:"scrolling"},scrolling:{SCROLL_END:"idle",POINTER_ENTER:"interacting"},interacting:{SCROLL:"interacting",POINTER_LEAVE:"idle"},idle:{HIDE:"hidden",SCROLL:"scrolling",POINTER_ENTER:"interacting"}});#e=W(()=>this.machine.state.current==="hidden");get isHidden(){return S(this.#e)}set isHidden(e){X(this.#e,e)}constructor(e){this.scrollbar=e,this.root=e.root;const r=mU(()=>this.machine.dispatch("SCROLL_END"),100);Kt(()=>{const n=this.machine.state.current,i=this.root.opts.scrollHideDelay.current;if(n==="idle"){const a=this.root.domContext.setTimeout(()=>this.machine.dispatch("HIDE"),i);return()=>this.root.domContext.clearTimeout(a)}}),Kt(()=>{const n=this.root.viewportNode;if(!n)return;const i=this.scrollbar.isHorizontal?"scrollLeft":"scrollTop";let a=n[i];return Bi(n,"scroll",()=>{const l=n[i];a!==l&&(this.machine.dispatch("SCROLL"),r()),a=l})}),this.onpointerenter=this.onpointerenter.bind(this),this.onpointerleave=this.onpointerleave.bind(this)}onpointerenter(e){this.machine.dispatch("POINTER_ENTER")}onpointerleave(e){this.machine.dispatch("POINTER_LEAVE")}#t=W(()=>({"data-state":this.machine.state.current==="hidden"?"hidden":"visible",onpointerenter:this.onpointerenter,onpointerleave:this.onpointerleave}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class BU{static create(){return new BU(D8.get())}scrollbar;root;#e=Oe(!1);get isVisible(){return S(this.#e)}set isVisible(e){X(this.#e,e,!0)}constructor(e){this.scrollbar=e,this.root=e.root;const r=mU(()=>{const n=this.root.viewportNode;if(!n)return;const i=n.offsetWidththis.root.viewportNode,r),new Z5(()=>this.root.contentNode,r)}#t=W(()=>({"data-state":this.isVisible?"visible":"hidden"}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class vle{static create(){return FU.set(new vle(D8.get()))}scrollbar;root;#e=Oe(null);get thumbNode(){return S(this.#e)}set thumbNode(e){X(this.#e,e,!0)}#t=Oe(0);get pointerOffset(){return S(this.#t)}set pointerOffset(e){X(this.#t,e,!0)}#r=Oe({content:0,viewport:0,scrollbar:{size:0,paddingStart:0,paddingEnd:0}});get sizes(){return S(this.#r)}set sizes(e){X(this.#r,e)}#n=W(()=>BOe(this.sizes.viewport,this.sizes.content));get thumbRatio(){return S(this.#n)}set thumbRatio(e){X(this.#n,e)}#i=W(()=>this.thumbRatio>0&&this.thumbRatio<1);get hasThumb(){return S(this.#i)}set hasThumb(e){X(this.#i,e)}#a=Oe("");get prevTransformStyle(){return S(this.#a)}set prevTransformStyle(e){X(this.#a,e,!0)}constructor(e){this.scrollbar=e,this.root=e.root,Kt(()=>{this.scrollbar.hasThumb=this.hasThumb}),Kt(()=>{!this.scrollbar.hasThumb&&this.thumbNode&&(this.prevTransformStyle=this.thumbNode.style.transform)})}setSizes(e){this.sizes=e}getScrollPosition(e,r){return Ovt({pointerPos:e,pointerOffset:this.pointerOffset,sizes:this.sizes,dir:r})}onThumbPointerUp(){this.pointerOffset=0}onThumbPointerDown(e){this.pointerOffset=e}xOnThumbPositionChange(){if(!(this.root.viewportNode&&this.thumbNode))return;const e=this.root.viewportNode.scrollLeft,n=`translate3d(${$1e({scrollPos:e,sizes:this.sizes,dir:this.root.opts.dir.current})}px, 0, 0)`;this.thumbNode.style.transform=n,this.prevTransformStyle=n}xOnWheelScroll(e){this.root.viewportNode&&(this.root.viewportNode.scrollLeft=e)}xOnDragScroll(e){this.root.viewportNode&&(this.root.viewportNode.scrollLeft=this.getScrollPosition(e,this.root.opts.dir.current))}yOnThumbPositionChange(){if(!(this.root.viewportNode&&this.thumbNode))return;const e=this.root.viewportNode.scrollTop,n=`translate3d(0, ${$1e({scrollPos:e,sizes:this.sizes})}px, 0)`;this.thumbNode.style.transform=n,this.prevTransformStyle=n}yOnWheelScroll(e){this.root.viewportNode&&(this.root.viewportNode.scrollTop=e)}yOnDragScroll(e){this.root.viewportNode&&(this.root.viewportNode.scrollTop=this.getScrollPosition(e,this.root.opts.dir.current))}}class yle{static create(e){return hle.set(new yle(e,FU.get()))}opts;scrollbarVis;root;scrollbar;attachment;#e=Oe();get computedStyle(){return S(this.#e)}set computedStyle(e){X(this.#e,e,!0)}constructor(e,r){this.opts=e,this.scrollbarVis=r,this.root=r.root,this.scrollbar=r.scrollbar,this.attachment=$i(this.scrollbar.opts.ref,n=>this.root.scrollbarXNode=n),Kt(()=>{this.scrollbar.opts.ref.current&&this.opts.mounted.current&&(this.computedStyle=getComputedStyle(this.scrollbar.opts.ref.current))}),Kt(()=>{this.onResize()})}onThumbPointerDown=e=>{this.scrollbarVis.onThumbPointerDown(e.x)};onDragScroll=e=>{this.scrollbarVis.xOnDragScroll(e.x)};onThumbPointerUp=()=>{this.scrollbarVis.onThumbPointerUp()};onThumbPositionChange=()=>{this.scrollbarVis.xOnThumbPositionChange()};onWheelScroll=(e,r)=>{if(!this.root.viewportNode)return;const n=this.root.viewportNode.scrollLeft+e.deltaX;this.scrollbarVis.xOnWheelScroll(n),$Oe(n,r)&&e.preventDefault()};onResize=()=>{this.scrollbar.opts.ref.current&&this.root.viewportNode&&this.computedStyle&&this.scrollbarVis.setSizes({content:this.root.viewportNode.scrollWidth,viewport:this.root.viewportNode.offsetWidth,scrollbar:{size:this.scrollbar.opts.ref.current.clientWidth,paddingStart:ML(this.computedStyle.paddingLeft),paddingEnd:ML(this.computedStyle.paddingRight)}})};#t=W(()=>UU(this.scrollbarVis.sizes));get thumbSize(){return S(this.#t)}set thumbSize(e){X(this.#t,e)}#r=W(()=>({id:this.scrollbar.opts.id.current,"data-orientation":"horizontal",style:{bottom:0,left:this.root.opts.dir.current==="rtl"?"var(--bits-scroll-area-corner-width)":0,right:this.root.opts.dir.current==="ltr"?"var(--bits-scroll-area-corner-width)":0,"--bits-scroll-area-thumb-width":`${this.thumbSize}px`},...this.attachment}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}class ble{static create(e){return hle.set(new ble(e,FU.get()))}opts;scrollbarVis;root;scrollbar;attachment;#e=Oe();get computedStyle(){return S(this.#e)}set computedStyle(e){X(this.#e,e,!0)}constructor(e,r){this.opts=e,this.scrollbarVis=r,this.root=r.root,this.scrollbar=r.scrollbar,this.attachment=$i(this.scrollbar.opts.ref,n=>this.root.scrollbarYNode=n),Kt(()=>{this.scrollbar.opts.ref.current&&this.opts.mounted.current&&(this.computedStyle=getComputedStyle(this.scrollbar.opts.ref.current))}),Kt(()=>{this.onResize()}),this.onThumbPointerDown=this.onThumbPointerDown.bind(this),this.onDragScroll=this.onDragScroll.bind(this),this.onThumbPointerUp=this.onThumbPointerUp.bind(this),this.onThumbPositionChange=this.onThumbPositionChange.bind(this),this.onWheelScroll=this.onWheelScroll.bind(this),this.onResize=this.onResize.bind(this)}onThumbPointerDown(e){this.scrollbarVis.onThumbPointerDown(e.y)}onDragScroll(e){this.scrollbarVis.yOnDragScroll(e.y)}onThumbPointerUp(){this.scrollbarVis.onThumbPointerUp()}onThumbPositionChange(){this.scrollbarVis.yOnThumbPositionChange()}onWheelScroll(e,r){if(!this.root.viewportNode)return;const n=this.root.viewportNode.scrollTop+e.deltaY;this.scrollbarVis.yOnWheelScroll(n),$Oe(n,r)&&e.preventDefault()}onResize(){this.scrollbar.opts.ref.current&&this.root.viewportNode&&this.computedStyle&&this.scrollbarVis.setSizes({content:this.root.viewportNode.scrollHeight,viewport:this.root.viewportNode.offsetHeight,scrollbar:{size:this.scrollbar.opts.ref.current.clientHeight,paddingStart:ML(this.computedStyle.paddingTop),paddingEnd:ML(this.computedStyle.paddingBottom)}})}#t=W(()=>UU(this.scrollbarVis.sizes));get thumbSize(){return S(this.#t)}set thumbSize(e){X(this.#t,e)}#r=W(()=>({id:this.scrollbar.opts.id.current,"data-orientation":"vertical",style:{top:0,right:this.root.opts.dir.current==="ltr"?0:void 0,left:this.root.opts.dir.current==="rtl"?0:void 0,bottom:"var(--bits-scroll-area-corner-height)","--bits-scroll-area-thumb-height":`${this.thumbSize}px`},...this.attachment}));get props(){return S(this.#r)}set props(e){X(this.#r,e)}}class Sle{static create(){return FOe.set(new Sle(hle.get()))}scrollbarState;root;scrollbarVis;scrollbar;#e=Oe(null);get rect(){return S(this.#e)}set rect(e){X(this.#e,e)}#t=Oe("");get prevWebkitUserSelect(){return S(this.#t)}set prevWebkitUserSelect(e){X(this.#t,e,!0)}handleResize;handleThumbPositionChange;handleWheelScroll;handleThumbPointerDown;handleThumbPointerUp;#r=W(()=>this.scrollbarVis.sizes.content-this.scrollbarVis.sizes.viewport);get maxScrollPos(){return S(this.#r)}set maxScrollPos(e){X(this.#r,e)}constructor(e){this.scrollbarState=e,this.root=e.root,this.scrollbarVis=e.scrollbarVis,this.scrollbar=e.scrollbarVis.scrollbar,this.handleResize=mU(()=>this.scrollbarState.onResize(),10),this.handleThumbPositionChange=this.scrollbarState.onThumbPositionChange,this.handleWheelScroll=this.scrollbarState.onWheelScroll,this.handleThumbPointerDown=this.scrollbarState.onThumbPointerDown,this.handleThumbPointerUp=this.scrollbarState.onThumbPointerUp,Kt(()=>{const r=this.maxScrollPos,n=this.scrollbar.opts.ref.current;this.root.viewportNode;const i=s=>{const o=s.target;n?.contains(o)&&this.handleWheelScroll(s,r)};return Bi(this.root.domContext.getDocument(),"wheel",i,{passive:!1})}),uc(()=>{this.scrollbarVis.sizes,zi(()=>this.handleThumbPositionChange())}),new Z5(()=>this.scrollbar.opts.ref.current,this.handleResize),new Z5(()=>this.root.contentNode,this.handleResize),this.onpointerdown=this.onpointerdown.bind(this),this.onpointermove=this.onpointermove.bind(this),this.onpointerup=this.onpointerup.bind(this),this.onlostpointercapture=this.onlostpointercapture.bind(this)}handleDragScroll(e){if(!this.rect)return;const r=e.clientX-this.rect.left,n=e.clientY-this.rect.top;this.scrollbarState.onDragScroll({x:r,y:n})}#n(){this.rect!==null&&(this.root.domContext.getDocument().body.style.webkitUserSelect=this.prevWebkitUserSelect,this.root.viewportNode&&(this.root.viewportNode.style.scrollBehavior=""),this.rect=null)}onpointerdown(e){if(e.button!==0)return;e.target.setPointerCapture(e.pointerId),this.rect=this.scrollbar.opts.ref.current?.getBoundingClientRect()??null,this.prevWebkitUserSelect=this.root.domContext.getDocument().body.style.webkitUserSelect,this.root.domContext.getDocument().body.style.webkitUserSelect="none",this.root.viewportNode&&(this.root.viewportNode.style.scrollBehavior="auto"),this.handleDragScroll(e)}onpointermove(e){this.handleDragScroll(e)}onpointerup(e){const r=e.target;r.hasPointerCapture(e.pointerId)&&r.releasePointerCapture(e.pointerId),this.#n()}onlostpointercapture(e){this.#n()}#i=W(()=>un({...this.scrollbarState.props,style:{position:"absolute",...this.scrollbarState.props.style},[I8.scrollbar]:"",onpointerdown:this.onpointerdown,onpointermove:this.onpointermove,onpointerup:this.onpointerup,onlostpointercapture:this.onlostpointercapture}));get props(){return S(this.#i)}set props(e){X(this.#i,e)}}class Ele{static create(e){return new Ele(e,FOe.get())}opts;scrollbarState;attachment;#e;#t=Oe();#r=mU(()=>{S(this.#t)&&(S(this.#t)(),X(this.#t,void 0))},100);constructor(e,r){this.opts=e,this.scrollbarState=r,this.#e=r.root,this.attachment=$i(this.opts.ref,n=>this.scrollbarState.scrollbarVis.thumbNode=n),Kt(()=>{const n=this.#e.viewportNode;if(!n)return;const i=()=>{if(this.#r(),!S(this.#t)){const s=Ivt(n,this.scrollbarState.handleThumbPositionChange);X(this.#t,s,!0),this.scrollbarState.handleThumbPositionChange()}};return zi(()=>this.scrollbarState.handleThumbPositionChange()),Bi(n,"scroll",i)}),this.onpointerdowncapture=this.onpointerdowncapture.bind(this),this.onpointerup=this.onpointerup.bind(this)}onpointerdowncapture(e){const r=e.target;if(!r)return;const n=r.getBoundingClientRect(),i=e.clientX-n.left,a=e.clientY-n.top;this.scrollbarState.handleThumbPointerDown({x:i,y:a})}onpointerup(e){this.scrollbarState.handleThumbPointerUp()}#n=W(()=>({id:this.opts.id.current,"data-state":this.scrollbarState.scrollbarVis.hasThumb?"visible":"hidden",style:{width:"var(--bits-scroll-area-thumb-width)",height:"var(--bits-scroll-area-thumb-height)",transform:this.scrollbarState.scrollbarVis.prevTransformStyle},onpointerdowncapture:this.onpointerdowncapture,onpointerup:this.onpointerup,[I8.thumb]:"",...this.attachment}));get props(){return S(this.#n)}set props(e){X(this.#n,e)}}class Tle{static create(e){return new Tle(e,k8.get())}opts;root;attachment;#e=Oe(0);#t=Oe(0);#r=W(()=>!!(S(this.#e)&&S(this.#t)));get hasSize(){return S(this.#r)}set hasSize(e){X(this.#r,e)}constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref),new Z5(()=>this.root.scrollbarXNode,()=>{const n=this.root.scrollbarXNode?.offsetHeight||0;this.root.cornerHeight=n,X(this.#t,n,!0)}),new Z5(()=>this.root.scrollbarYNode,()=>{const n=this.root.scrollbarYNode?.offsetWidth||0;this.root.cornerWidth=n,X(this.#e,n,!0)})}#n=W(()=>({id:this.opts.id.current,style:{width:S(this.#e),height:S(this.#t),position:"absolute",right:this.root.opts.dir.current==="ltr"?0:void 0,left:this.root.opts.dir.current==="rtl"?0:void 0,bottom:0},[I8.corner]:"",...this.attachment}));get props(){return S(this.#n)}set props(e){X(this.#n,e)}}function ML(t){return t?Number.parseInt(t,10):0}function BOe(t,e){const r=t/e;return Number.isNaN(r)?0:r}function UU(t){const e=BOe(t.viewport,t.content),r=t.scrollbar.paddingStart+t.scrollbar.paddingEnd,n=(t.scrollbar.size-r)*e;return Math.max(n,18)}function Ovt({pointerPos:t,pointerOffset:e,sizes:r,dir:n="ltr"}){const i=UU(r),a=i/2,s=e||a,o=i-s,l=r.scrollbar.paddingStart+s,u=r.scrollbar.size-r.scrollbar.paddingEnd-o,d=r.content-r.viewport,h=n==="ltr"?[0,d]:[d*-1,0];return UOe([l,u],h)(t)}function $1e({scrollPos:t,sizes:e,dir:r="ltr"}){const n=UU(e),i=e.scrollbar.paddingStart+e.scrollbar.paddingEnd,a=e.scrollbar.size-i,s=e.content-e.viewport,o=a-n,l=r==="ltr"?[0,s]:[s*-1,0],u=Rvt(t,l[0],l[1]);return UOe([0,s],[0,o])(u)}function UOe(t,e){return r=>{if(t[0]===t[1]||e[0]===e[1])return e[0];const n=(e[1]-e[0])/(t[1]-t[0]);return e[0]+n*(r-t[0])}}function $Oe(t,e){return t>0&&ti.cancelAnimationFrame(n)}var kvt=new Set(["$$slots","$$events","$$legacy","ref","id","type","dir","scrollHideDelay","children","child"]),Dvt=se("
");function Mvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=ce(e,"type",3,"hover"),s=ce(e,"dir",3,"ltr"),o=ce(e,"scrollHideDelay",3,600),l=Tt(e,kvt);const u=fle.create({type:_t(()=>a()),dir:_t(()=>s()),scrollHideDelay:_t(()=>o()),id:_t(()=>i()),ref:_t(()=>n(),m=>n(m))}),d=W(()=>un(l,u.props));var h=Ae(),f=oe(h);{var p=m=>{var _=Ae(),v=oe(_);Pt(v,()=>e.child,()=>({props:S(d)})),G(m,_)},g=m=>{var _=Dvt();Er(_,()=>({...S(d)}));var v=te(_);Pt(v,()=>e.children??Vt),Z(_),G(m,_)};ve(f,m=>{e.child?m(p):m(g,-1)})}G(t,h),st()}var Lvt=new Set(["$$slots","$$events","$$legacy","ref","id","children"]),Pvt=se("
");function Fvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,Lvt);const s=ple.create({id:_t(()=>i()),ref:_t(()=>n(),f=>n(f))}),o=W(()=>un(a,s.props)),l=W(()=>un({},s.contentProps));var u=Pvt();Er(u,()=>({...S(o)}));var d=te(u);Er(d,()=>({...S(l)}));var h=te(d);Pt(h,()=>e.children??Vt),Z(d),Z(u),G(t,u),st()}var Bvt=new Set(["$$slots","$$events","$$legacy","child","children"]),Uvt=se("
");function GOe(t,e){at(e,!0);let r=Tt(e,Bvt);const n=Sle.create(),i=W(()=>un(r,n.props));var a=Ae(),s=oe(a);{var o=u=>{var d=Ae(),h=oe(d);Pt(h,()=>e.child,()=>({props:S(i)})),G(u,d)},l=u=>{var d=Uvt();Er(d,()=>({...S(i)}));var h=te(d);Pt(h,()=>e.children??Vt),Z(d),G(u,d)};ve(s,u=>{e.child?u(o):u(l,-1)})}G(t,a),st()}var $vt=new Set(["$$slots","$$events","$$legacy"]);function Gvt(t,e){at(e,!0);let r=Tt(e,$vt);const n=new Zse,i=yle.create({mounted:_t(()=>n.current)}),a=W(()=>un(r,i.props));GOe(t,Rt(()=>S(a))),st()}var zvt=new Set(["$$slots","$$events","$$legacy"]);function qvt(t,e){at(e,!0);let r=Tt(e,zvt);const n=new Zse,i=ble.create({mounted:_t(()=>n.current)}),a=W(()=>un(r,i.props));GOe(t,Rt(()=>S(a))),st()}var Hvt=new Set(["$$slots","$$events","$$legacy"]);function $U(t,e){at(e,!0);let r=Tt(e,Hvt);const n=vle.create();var i=Ae(),a=oe(i);{var s=l=>{Gvt(l,Rt(()=>r))},o=l=>{qvt(l,Rt(()=>r))};ve(a,l=>{n.scrollbar.opts.orientation.current==="horizontal"?l(s):l(o,-1)})}G(t,i),st()}var Vvt=new Set(["$$slots","$$events","$$legacy","forceMount"]);function Yvt(t,e){at(e,!0);let r=ce(e,"forceMount",3,!1),n=Tt(e,Vvt);const i=BU.create(),a=W(()=>un(n,i.props));{const s=l=>{$U(l,Rt(()=>S(a)))};let o=W(()=>r()||i.isVisible);PU(t,{get open(){return S(o)},get ref(){return i.scrollbar.opts.ref},presence:s,$$slots:{presence:!0}})}st()}var Wvt=new Set(["$$slots","$$events","$$legacy","forceMount"]);function Kvt(t,e){at(e,!0);let r=ce(e,"forceMount",3,!1),n=Tt(e,Wvt);const i=_le.create(),a=W(()=>un(n,i.props));{const s=l=>{$U(l,Rt(()=>S(a)))};let o=W(()=>r()||!i.isHidden);PU(t,Rt(()=>S(a),{get open(){return S(o)},get ref(){return i.scrollbar.opts.ref},presence:s,$$slots:{presence:!0}}))}st()}var jvt=new Set(["$$slots","$$events","$$legacy","forceMount"]);function Xvt(t,e){at(e,!0);let r=ce(e,"forceMount",3,!1),n=Tt(e,jvt);const i=mle.create(),a=BU.create(),s=W(()=>un(n,i.props,a.props,{"data-state":i.isVisible?"visible":"hidden"})),o=W(()=>r()||i.isVisible&&a.isVisible);PU(t,{get open(){return S(o)},get ref(){return a.scrollbar.opts.ref},presence:u=>{$U(u,Rt(()=>S(s)))},$$slots:{presence:!0}}),st()}var Qvt=new Set(["$$slots","$$events","$$legacy","ref","id","orientation"]);function Zvt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,Qvt);const s=gle.create({orientation:_t(()=>e.orientation),id:_t(()=>i()),ref:_t(()=>n(),g=>n(g))}),o=W(()=>s.root.opts.type.current);var l=Ae(),u=oe(l);{var d=g=>{Xvt(g,Rt(()=>a,{get id(){return i()}}))},h=g=>{Kvt(g,Rt(()=>a,{get id(){return i()}}))},f=g=>{Yvt(g,Rt(()=>a,{get id(){return i()}}))},p=g=>{$U(g,Rt(()=>a,{get id(){return i()}}))};ve(u,g=>{S(o)==="hover"?g(d):S(o)==="scroll"?g(h,1):S(o)==="auto"?g(f,2):S(o)==="always"&&g(p,3)})}G(t,l),st()}var Jvt=new Set(["$$slots","$$events","$$legacy","ref","id","child","children","present"]),eyt=se("
");function tyt(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,Jvt);const i=new Zse,a=Ele.create({id:_t(()=>e.id),ref:_t(()=>r(),h=>r(h)),mounted:_t(()=>i.current)}),s=W(()=>un(n,a.props,{style:{hidden:!e.present}}));var o=Ae(),l=oe(o);{var u=h=>{var f=Ae(),p=oe(f);Pt(p,()=>e.child,()=>({props:S(s)})),G(h,f)},d=h=>{var f=eyt();Er(f,()=>({...S(s)}));var p=te(f);Pt(p,()=>e.children??Vt),Z(f),G(h,f)};ve(l,h=>{e.child?h(u):h(d,-1)})}G(t,o),st()}var ryt=new Set(["$$slots","$$events","$$legacy","id","ref","forceMount"]);function nyt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"forceMount",3,!1),s=Tt(e,ryt);const o=FU.get();{const l=(d,h)=>{let f=()=>h?.().present;tyt(d,Rt(()=>s,{get id(){return n()},get present(){return f()},get ref(){return i()},set ref(p){i(p)}}))};let u=W(()=>a()||o.hasThumb);PU(t,{get open(){return S(u)},get ref(){return o.scrollbar.opts.ref},presence:l,$$slots:{presence:!0}})}st()}var iyt=new Set(["$$slots","$$events","$$legacy","ref","id","children","child"]),ayt=se("
");function syt(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,iyt);const i=Tle.create({id:_t(()=>e.id),ref:_t(()=>r(),d=>r(d))}),a=W(()=>un(n,i.props));var s=Ae(),o=oe(s);{var l=d=>{var h=Ae(),f=oe(h);Pt(f,()=>e.child,()=>({props:S(a)})),G(d,h)},u=d=>{var h=ayt();Er(h,()=>({...S(a)}));var f=te(h);Pt(f,()=>e.children??Vt),Z(h),G(d,h)};ve(o,d=>{e.child?d(l):d(u,-1)})}G(t,s),st()}var oyt=new Set(["$$slots","$$events","$$legacy","ref","id"]);function lyt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,oyt);const s=k8.get(),o=W(()=>!!(s.scrollbarXNode&&s.scrollbarYNode)),l=W(()=>s.opts.type.current!=="scroll"&&S(o));var u=Ae(),d=oe(u);{var h=f=>{syt(f,Rt(()=>a,{get id(){return i()},get ref(){return n()},set ref(p){n(p)}}))};ve(d,f=>{S(l)&&f(h)})}G(t,u),st()}var cyt=se(" ",1);function uyt(t,e){at(e,!0);let r=ce(e,"value",15),n=ce(e,"onValueChange",3,Tn),i=ce(e,"name",3,""),a=ce(e,"disabled",3,!1),s=ce(e,"open",15,!1),o=ce(e,"onOpenChange",3,Tn),l=ce(e,"onOpenChangeComplete",3,Tn),u=ce(e,"loop",3,!1),d=ce(e,"scrollAlignment",3,"nearest"),h=ce(e,"required",3,!1),f=ce(e,"items",19,()=>[]),p=ce(e,"allowDeselect",3,!1);function g(){r()===void 0&&r(e.type==="single"?"":[])}g(),yi.pre(()=>r(),()=>{g()});let m=Oe("");const _=r_t.create({type:e.type,value:_t(()=>r(),w=>{r(w),n()(w)}),disabled:_t(()=>a()),required:_t(()=>h()),open:_t(()=>s(),w=>{s(w),o()(w)}),loop:_t(()=>u()),scrollAlignment:_t(()=>d()),name:_t(()=>i()),isCombobox:!1,items:_t(()=>f()),allowDeselect:_t(()=>p()),inputValue:_t(()=>S(m),w=>X(m,w,!0)),onOpenChangeComplete:_t(()=>l())});var v=cyt(),b=oe(v);g4(b,{children:(w,x)=>{var A=Ae(),R=oe(A);Pt(R,()=>e.children??Vt),G(w,A)},$$slots:{default:!0}});var y=ie(b,2);{var E=w=>{var x=Ae(),A=oe(x);{var R=F=>{dH(F,{get autocomplete(){return e.autocomplete}})},O=F=>{var P=Ae(),N=oe(P);qr(N,16,()=>_.opts.value.current,k=>k,(k,M)=>{dH(k,{get value(){return M},get autocomplete(){return e.autocomplete}})}),G(F,P)};ve(A,F=>{_.opts.value.current.length===0?F(R):F(O,-1)})}G(w,x)},T=W(()=>Array.isArray(_.opts.value.current)),C=w=>{dH(w,{get autocomplete(){return e.autocomplete},get value(){return _.opts.value.current},set value(x){_.opts.value.current=x}})};ve(y,w=>{S(T)?w(E):w(C,-1)})}G(t,v),st()}var dyt=new Set(["$$slots","$$events","$$legacy","id","ref","child","children","type"]),hyt=se("");function fyt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"type",3,"button"),s=Tt(e,dyt);const o=Voe.create({id:_t(()=>n()),ref:_t(()=>i(),h=>i(h))}),l=W(()=>un(s,o.props,{type:a()}));var u=Ae(),d=oe(u);Me(d,()=>O8,(h,f)=>{f(h,{get id(){return n()},get ref(){return o.opts.ref},children:(p,g)=>{var m=Ae(),_=oe(m);{var v=y=>{var E=Ae(),T=oe(E);Pt(T,()=>e.child,()=>({props:S(l)})),G(y,E)},b=y=>{var E=hyt();Er(E,()=>({...S(l)}));var T=te(E);Pt(T,()=>e.children??Vt),Z(E),G(y,E)};ve(_,y=>{e.child?y(v):y(b,-1)})}G(p,m)},$$slots:{default:!0}})}),G(t,u),st()}const zOe=xf({component:"switch",parts:["root","thumb"]}),Cle=new Ys("Switch.Root");class wle{static create(e){return Cle.set(new wle(e))}opts;attachment;constructor(e){this.opts=e,this.attachment=$i(e.ref),this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this)}#e(){this.opts.checked.current=!this.opts.checked.current}onkeydown(e){!(e.key===Kg||e.key===xd)||this.opts.disabled.current||(e.preventDefault(),this.#e())}onclick(e){this.opts.disabled.current||this.#e()}#t=W(()=>({"data-disabled":Uo(this.opts.disabled.current),"data-state":tmt(this.opts.checked.current),"data-required":Uo(this.opts.required.current)}));get sharedProps(){return S(this.#t)}set sharedProps(e){X(this.#t,e)}#r=W(()=>({checked:this.opts.checked.current}));get snippetProps(){return S(this.#r)}set snippetProps(e){X(this.#r,e)}#n=W(()=>({...this.sharedProps,id:this.opts.id.current,role:"switch",disabled:gJ(this.opts.disabled.current),"aria-checked":eoe(this.opts.checked.current,!1),"aria-required":vf(this.opts.required.current),[zOe.root]:"",onclick:this.onclick,onkeydown:this.onkeydown,...this.attachment}));get props(){return S(this.#n)}set props(e){X(this.#n,e)}}class xle{static create(){return new xle(Cle.get())}root;#e=W(()=>this.root.opts.name.current!==void 0);get shouldRender(){return S(this.#e)}set shouldRender(e){X(this.#e,e)}constructor(e){this.root=e}#t=W(()=>({type:"checkbox",name:this.root.opts.name.current,value:this.root.opts.value.current,checked:this.root.opts.checked.current,disabled:this.root.opts.disabled.current,required:this.root.opts.required.current}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}class Ale{static create(e){return new Ale(e,Cle.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(e.ref)}#e=W(()=>({checked:this.root.opts.checked.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({...this.root.sharedProps,id:this.opts.id.current,[zOe.thumb]:"",...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}}function pyt(t,e){at(e,!1);const r=xle.create();d4();var n=Ae(),i=oe(n);{var a=s=>{AU(s,Rt(()=>r.props))};ve(i,s=>{r.shouldRender&&s(a)})}G(t,n),st()}var gyt=new Set(["$$slots","$$events","$$legacy","child","children","ref","id","disabled","required","checked","value","name","type","onCheckedChange"]),myt=se(""),_yt=se(" ",1);function vyt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=ce(e,"disabled",3,!1),s=ce(e,"required",3,!1),o=ce(e,"checked",15,!1),l=ce(e,"value",3,"on"),u=ce(e,"name",3,void 0),d=ce(e,"type",3,"button"),h=ce(e,"onCheckedChange",3,Tn),f=Tt(e,gyt);const p=wle.create({checked:_t(()=>o(),E=>{o(E),h()?.(E)}),disabled:_t(()=>a()??!1),required:_t(()=>s()),value:_t(()=>l()),name:_t(()=>u()),id:_t(()=>i()),ref:_t(()=>n(),E=>n(E))}),g=W(()=>un(f,p.props,{type:d()}));var m=_yt(),_=oe(m);{var v=E=>{var T=Ae(),C=oe(T);{let w=W(()=>({props:S(g),...p.snippetProps}));Pt(C,()=>e.child,()=>S(w))}G(E,T)},b=E=>{var T=myt();Er(T,()=>({...S(g)}));var C=te(T);Pt(C,()=>e.children??Vt,()=>p.snippetProps),Z(T),G(E,T)};ve(_,E=>{e.child?E(v):E(b,-1)})}var y=ie(_,2);pyt(y,{}),G(t,m),st()}var yyt=new Set(["$$slots","$$events","$$legacy","child","children","ref","id"]),byt=se("");function Syt(t,e){const r=Vi();at(e,!0);let n=ce(e,"ref",15,null),i=ce(e,"id",19,()=>Yi(r)),a=Tt(e,yyt);const s=Ale.create({id:_t(()=>i()),ref:_t(()=>n(),f=>n(f))}),o=W(()=>un(a,s.props));var l=Ae(),u=oe(l);{var d=f=>{var p=Ae(),g=oe(p);{let m=W(()=>({props:S(o),...s.snippetProps}));Pt(g,()=>e.child,()=>S(m))}G(f,p)},h=f=>{var p=byt();Er(p,()=>({...S(o)}));var g=te(p);Pt(g,()=>e.children??Vt,()=>s.snippetProps),Z(p),G(f,p)};ve(u,f=>{e.child?f(d):f(h,-1)})}G(t,l),st()}class xJ{#e;#t;#r=null;constructor(e,r){this.#t=e,this.#e=r,this.stop=this.stop.bind(this),this.start=this.start.bind(this),Sh(this.stop)}#n(){this.#r!==null&&(window.clearTimeout(this.#r),this.#r=null)}stop(){this.#n()}start(...e){this.#n(),this.#r=window.setTimeout(()=>{this.#r=null,this.#t(...e)},this.#e)}}const qOe=xf({component:"tooltip",parts:["content","trigger"]}),HOe=new Ys("Tooltip.Provider"),Rle=new Ys("Tooltip.Root");class Eyt{#e=Oe(Zr(new Map));get triggers(){return S(this.#e)}set triggers(e){X(this.#e,e,!0)}#t=Oe(null);get activeTriggerId(){return S(this.#t)}set activeTriggerId(e){X(this.#t,e,!0)}#r=W(()=>{const e=this.activeTriggerId;return e===null?null:this.triggers.get(e)?.node??null});get activeTriggerNode(){return S(this.#r)}set activeTriggerNode(e){X(this.#r,e)}#n=W(()=>{const e=this.activeTriggerId;return e===null?null:this.triggers.get(e)?.payload??null});get activePayload(){return S(this.#n)}set activePayload(e){X(this.#n,e)}register=e=>{const r=new Map(this.triggers);r.set(e.id,e),this.triggers=r,this.#i()};update=e=>{const r=new Map(this.triggers);r.set(e.id,e),this.triggers=r,this.#i()};unregister=e=>{if(!this.triggers.has(e))return;const r=new Map(this.triggers);r.delete(e),this.triggers=r,this.activeTriggerId===e&&(this.activeTriggerId=null)};setActiveTrigger=e=>{if(e===null){this.activeTriggerId=null;return}if(!this.triggers.has(e)){this.activeTriggerId=null;return}this.activeTriggerId=e};get=e=>this.triggers.get(e);has=e=>this.triggers.has(e);getFirstTriggerId=()=>{const e=this.triggers.entries().next();return e.done?null:e.value[0]};#i=()=>{const e=this.activeTriggerId;e!==null&&(this.triggers.has(e)||(this.activeTriggerId=null))}}class Nle{static create(e){return HOe.set(new Nle(e))}opts;#e=Oe(!0);get isOpenDelayed(){return S(this.#e)}set isOpenDelayed(e){X(this.#e,e,!0)}isPointerInTransit=xu(!1);#t;#r=Oe(null);constructor(e){this.opts=e,this.#t=new xJ(()=>{this.isOpenDelayed=!0},this.opts.skipDelayDuration.current),_U(()=>Bi(window,"scroll",r=>{const n=S(this.#r);if(!n)return;const i=n.triggerNode;if(!i)return;const a=r.target;(a instanceof Element||a instanceof Document)&&a.contains(i)&&n.handleClose()}))}#n=()=>{if(this.opts.skipDelayDuration.current===0){this.isOpenDelayed=!0;return}else this.#t.start()};#i=()=>{this.#t.stop()};onOpen=e=>{S(this.#r)&&S(this.#r)!==e&&S(this.#r).handleClose(),this.#i(),this.isOpenDelayed=!1,X(this.#r,e,!0)};onClose=e=>{S(this.#r)===e&&(X(this.#r,null),this.#n())};isTooltipOpen=e=>S(this.#r)===e}class Ole{static create(e){return Rle.set(new Ole(e,HOe.get()))}opts;provider;#e=W(()=>this.opts.delayDuration.current??this.provider.opts.delayDuration.current);get delayDuration(){return S(this.#e)}set delayDuration(e){X(this.#e,e)}#t=W(()=>this.opts.disableHoverableContent.current??this.provider.opts.disableHoverableContent.current);get disableHoverableContent(){return S(this.#t)}set disableHoverableContent(e){X(this.#t,e)}#r=W(()=>this.opts.disableCloseOnTriggerClick.current??this.provider.opts.disableCloseOnTriggerClick.current);get disableCloseOnTriggerClick(){return S(this.#r)}set disableCloseOnTriggerClick(e){X(this.#r,e)}#n=W(()=>this.opts.disabled.current??this.provider.opts.disabled.current);get disabled(){return S(this.#n)}set disabled(e){X(this.#n,e)}#i=W(()=>this.opts.ignoreNonKeyboardFocus.current??this.provider.opts.ignoreNonKeyboardFocus.current);get ignoreNonKeyboardFocus(){return S(this.#i)}set ignoreNonKeyboardFocus(e){X(this.#i,e)}registry;tether;#a=Oe(null);get contentNode(){return S(this.#a)}set contentNode(e){X(this.#a,e,!0)}contentPresence;#s=Oe(!1);#o;#l=W(()=>this.opts.open.current?S(this.#s)?"delayed-open":"instant-open":"closed");get stateAttr(){return S(this.#l)}set stateAttr(e){X(this.#l,e)}constructor(e,r){this.opts=e,this.provider=r,this.tether=e.tether.current?.state??null,this.registry=this.tether?.registry??new Eyt,this.#o=new xJ(()=>{X(this.#s,!0),this.opts.open.current=!0},this.delayDuration??0),this.tether&&(this.tether.root=this,_U(()=>()=>{this.tether?.root===this&&(this.tether.root=null)})),this.contentPresence=new F0({open:this.opts.open,ref:_t(()=>this.contentNode),onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),yi(()=>this.delayDuration,()=>{this.delayDuration!==void 0&&(this.#o=new xJ(()=>{X(this.#s,!0),this.opts.open.current=!0},this.delayDuration))}),yi(()=>this.opts.open.current,n=>{n?(this.ensureActiveTrigger(),this.provider.onOpen(this)):this.provider.onClose(this)},{lazy:!0}),yi(()=>this.opts.triggerId.current,n=>{n!==this.registry.activeTriggerId&&this.registry.setActiveTrigger(n)}),yi(()=>this.registry.activeTriggerId,n=>{this.opts.triggerId.current!==n&&(this.opts.triggerId.current=n)})}handleOpen=()=>{this.#o.stop(),X(this.#s,!1),this.ensureActiveTrigger(),this.opts.open.current=!0};handleClose=()=>{this.#o.stop(),this.opts.open.current=!1};#c=()=>{this.#o.stop();const e=!this.provider.isOpenDelayed,r=this.delayDuration??0;e||r===0?(X(this.#s,!1),this.opts.open.current=!0):this.#o.start()};onTriggerEnter=e=>{this.setActiveTrigger(e),this.#c()};onTriggerLeave=()=>{this.disableHoverableContent?this.handleClose():this.#o.stop()};ensureActiveTrigger=()=>{if(this.registry.activeTriggerId!==null&&this.registry.has(this.registry.activeTriggerId))return;if(this.opts.triggerId.current!==null&&this.registry.has(this.opts.triggerId.current)){this.registry.setActiveTrigger(this.opts.triggerId.current);return}const e=this.registry.getFirstTriggerId();this.registry.setActiveTrigger(e)};setActiveTrigger=e=>{this.registry.setActiveTrigger(e)};registerTrigger=e=>{this.registry.register(e),e.disabled&&this.registry.activeTriggerId===e.id&&this.opts.open.current&&this.handleClose()};updateTrigger=e=>{this.registry.update(e),e.disabled&&this.registry.activeTriggerId===e.id&&this.opts.open.current&&this.handleClose()};unregisterTrigger=e=>{const r=this.registry.activeTriggerId===e;this.registry.unregister(e),r&&this.opts.open.current&&this.handleClose()};isActiveTrigger=e=>this.registry.activeTriggerId===e;get triggerNode(){return this.registry.activeTriggerNode}get activePayload(){return this.registry.activePayload}get activeTriggerId(){return this.registry.activeTriggerId}}class LL{static create(e){return e.tether.current?new LL(e,null,e.tether.current.state):new LL(e,Rle.get(),null)}opts;root;tether;attachment;#e=xu(!1);#t=Oe(!1);domContext;#r=null;#n=!1;#i=null;constructor(e,r,n){this.opts=e,this.root=r,this.tether=n,this.domContext=new wf(e.ref),this.attachment=$i(this.opts.ref,i=>this.#o(i)),yi(()=>this.opts.id.current,()=>{this.#o(this.opts.ref.current)}),yi(()=>this.opts.payload.current,()=>{this.#o(this.opts.ref.current)}),yi(()=>this.opts.disabled.current,()=>{this.#o(this.opts.ref.current)}),_U(()=>(this.#n=!0,this.#o(this.opts.ref.current),()=>{const i=this.#a(),a=this.#i;a&&(this.tether?this.tether.registry.unregister(a):i?.unregisterTrigger(a)),this.#i=null,this.#n=!1}))}#a=()=>this.tether?.root??this.root;#s=()=>{const e=this.#a();return this.opts.disabled.current||!!e?.disabled};#o=e=>{if(!this.#n)return;const r=this.opts.id.current,n=this.opts.payload.current,i=this.opts.disabled.current;if(this.#i&&this.#i!==r){const o=this.#a();this.tether?this.tether.registry.unregister(this.#i):o?.unregisterTrigger(this.#i)}const a={id:r,node:e,payload:n,disabled:i},s=this.#a();this.tether?(this.tether.registry.has(r)?this.tether.registry.update(a):this.tether.registry.register(a),i&&this.tether.registry.activeTriggerId===r&&s?.opts.open.current&&s.handleClose()):s?.registry.has(r)?s.updateTrigger(a):s?.registerTrigger(a),this.#i=r};#l=()=>{this.#r!==null&&(clearTimeout(this.#r),this.#r=null)};handlePointerUp=()=>{this.#e.current=!1};#c=()=>{this.#s()||(this.#e.current=!1)};#d=()=>{this.#s()||(this.#e.current=!0,this.domContext.getDocument().addEventListener("pointerup",()=>{this.handlePointerUp()},{once:!0}))};#u=e=>{const r=this.#a();if(r){if(this.#s()){r.opts.open.current&&r.handleClose();return}if(e.pointerType!=="touch"){if(r.provider.isPointerInTransit.current){this.#l(),this.#r=window.setTimeout(()=>{r.provider.isPointerInTransit.current&&(r.provider.isPointerInTransit.current=!1,r.onTriggerEnter(this.opts.id.current),X(this.#t,!0))},250);return}r.onTriggerEnter(this.opts.id.current),X(this.#t,!0)}}};#p=e=>{const r=this.#a();if(r){if(this.#s()){r.opts.open.current&&r.handleClose();return}e.pointerType!=="touch"&&(S(this.#t)||(this.#l(),r.provider.isPointerInTransit.current=!1,r.onTriggerEnter(this.opts.id.current),X(this.#t,!0)))}};#g=e=>{const r=this.#a();if(!r||this.#s())return;if(this.#l(),!r.isActiveTrigger(this.opts.id.current)){X(this.#t,!1);return}const n=e.relatedTarget;if(Au(n)){for(const i of r.registry.triggers.values())if(i.node===n){if(r.provider.opts.skipDelayDuration.current>0){X(this.#t,!1);return}r.handleClose(),X(this.#t,!1);return}}r.onTriggerLeave(),X(this.#t,!1)};#f=e=>{const r=this.#a();if(r&&!this.#e.current){if(this.#s()){r.opts.open.current&&r.handleClose();return}r.ignoreNonKeyboardFocus&&!eOe(e.currentTarget)||(r.setActiveTrigger(this.opts.id.current),r.handleOpen())}};#h=()=>{const e=this.#a();!e||this.#s()||e.handleClose()};#m=()=>{const e=this.#a();!e||e.disableCloseOnTriggerClick||this.#s()||e.handleClose()};#v=W(()=>{const e=this.#a(),r=!!(e?.opts.open.current&&e.isActiveTrigger(this.opts.id.current)),n=this.#s();return{id:this.opts.id.current,"aria-describedby":r?e?.contentNode?.id:void 0,"data-state":r?e?.stateAttr:"closed","data-disabled":Uo(n),"data-delay-duration":`${e?.delayDuration??0}`,[qOe.trigger]:"",tabindex:n?void 0:this.opts.tabindex.current,disabled:this.opts.disabled.current,onpointerup:this.#c,onpointerdown:this.#d,onpointerenter:this.#u,onpointermove:this.#p,onpointerleave:this.#g,onfocus:this.#f,onblur:this.#h,onclick:this.#m,...this.attachment}});get props(){return S(this.#v)}set props(e){X(this.#v,e)}}class Ile{static create(e){return new Ile(e,Rle.get())}opts;root;attachment;constructor(e,r){this.opts=e,this.root=r,this.attachment=$i(this.opts.ref,n=>this.root.contentNode=n),new Zoe({triggerNode:()=>this.root.triggerNode,contentNode:()=>this.root.contentNode,enabled:()=>this.root.opts.open.current&&!this.root.disableHoverableContent,transitIntentTimeout:180,ignoredTargets:()=>{if(this.root.provider.opts.skipDelayDuration.current===0)return[];const n=[],i=this.root.triggerNode;for(const a of this.root.registry.triggers.values())a.node&&a.node!==i&&n.push(a.node);return n},onPointerExit:()=>{this.root.provider.isTooltipOpen(this.root)&&this.root.handleClose()}})}onInteractOutside=e=>{if(Au(e.target)&&this.root.triggerNode?.contains(e.target)&&this.root.disableCloseOnTriggerClick){e.preventDefault();return}this.opts.onInteractOutside.current(e),!e.defaultPrevented&&this.root.handleClose()};onEscapeKeydown=e=>{this.opts.onEscapeKeydown.current?.(e),!e.defaultPrevented&&this.root.handleClose()};onOpenAutoFocus=e=>{e.preventDefault()};onCloseAutoFocus=e=>{e.preventDefault()};get shouldRender(){return this.root.contentPresence.shouldRender}#e=W(()=>({open:this.root.opts.open.current}));get snippetProps(){return S(this.#e)}set snippetProps(e){X(this.#e,e)}#t=W(()=>({id:this.opts.id.current,"data-state":this.root.stateAttr,"data-disabled":Uo(this.root.disabled),...xv(this.root.contentPresence.transitionStatus),style:{outline:"none"},[qOe.content]:"",...this.attachment}));get props(){return S(this.#t)}set props(e){X(this.#t,e)}popperProps={onInteractOutside:this.onInteractOutside,onEscapeKeydown:this.onEscapeKeydown,onOpenAutoFocus:this.onOpenAutoFocus,onCloseAutoFocus:this.onCloseAutoFocus}}function Tyt(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"triggerId",15,null),i=ce(e,"onOpenChange",3,Tn),a=ce(e,"onOpenChangeComplete",3,Tn);const s=Ole.create({open:_t(()=>r(),o=>{r(o),i()(o)}),triggerId:_t(()=>n(),o=>{n(o)}),delayDuration:_t(()=>e.delayDuration),disableCloseOnTriggerClick:_t(()=>e.disableCloseOnTriggerClick),disableHoverableContent:_t(()=>e.disableHoverableContent),ignoreNonKeyboardFocus:_t(()=>e.ignoreNonKeyboardFocus),disabled:_t(()=>e.disabled),onOpenChangeComplete:_t(()=>a()),tether:_t(()=>e.tether)});g4(t,{tooltip:!0,children:(o,l)=>{var u=Ae(),d=oe(u);Pt(d,()=>e.children??Vt,()=>({open:s.opts.open.current,triggerId:s.activeTriggerId,payload:s.activePayload})),G(o,u)},$$slots:{default:!0}}),st()}var Cyt=new Set(["$$slots","$$events","$$legacy","children","child","id","ref","side","sideOffset","align","avoidCollisions","arrowPadding","sticky","strategy","hideWhenDetached","customAnchor","collisionPadding","onInteractOutside","onEscapeKeydown","forceMount","style"]),G1e=se("
");function wyt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"ref",15,null),a=ce(e,"side",3,"top"),s=ce(e,"sideOffset",3,0),o=ce(e,"align",3,"center"),l=ce(e,"avoidCollisions",3,!0),u=ce(e,"arrowPadding",3,0),d=ce(e,"sticky",3,"partial"),h=ce(e,"hideWhenDetached",3,!1),f=ce(e,"collisionPadding",3,0),p=ce(e,"onInteractOutside",3,Tn),g=ce(e,"onEscapeKeydown",3,Tn),m=ce(e,"forceMount",3,!1),_=Tt(e,Cyt);const v=Ile.create({id:_t(()=>n()),ref:_t(()=>i(),x=>i(x)),onInteractOutside:_t(()=>p()),onEscapeKeydown:_t(()=>g())}),b=W(()=>({side:a(),sideOffset:s(),align:o(),avoidCollisions:l(),arrowPadding:u(),sticky:d(),hideWhenDetached:h(),collisionPadding:f(),strategy:e.strategy,customAnchor:e.customAnchor??v.root.triggerNode})),y=W(()=>un(_,S(b),v.props));var E=Ae(),T=oe(E);{var C=x=>{{const A=(O,F)=>{let P=()=>F?.().props,N=()=>F?.().wrapperProps;const k=W(()=>un(N(),{style:{pointerEvents:v.root.disableHoverableContent?"none":void 0}})),M=W(()=>un(P(),{style:Rp("tooltip")},{style:e.style}));var L=Ae(),I=oe(L);{var U=$=>{var H=Ae(),q=oe(H);{let V=W(()=>({props:S(M),wrapperProps:S(k),...v.snippetProps}));Pt(q,()=>e.child,()=>S(V))}G($,H)},B=$=>{var H=G1e();Er(H,()=>({...S(k)}));var q=te(H);Er(q,()=>({...S(M)}));var V=te(q);Pt(V,()=>e.children??Vt),Z(q),Z(H),G($,H)};ve(I,$=>{e.child?$(U):$(B,-1)})}G(O,L)};let R=W(()=>v.root.disableHoverableContent?"none":"auto");_4(x,Rt(()=>S(y),()=>v.popperProps,{get enabled(){return v.root.opts.open.current},get id(){return n()},trapFocus:!1,loop:!1,preventScroll:!1,forceMount:!0,get ref(){return v.opts.ref},tooltip:!0,get shouldRender(){return v.shouldRender},get contentPointerEvents(){return S(R)},popper:A,$$slots:{popper:!0}}))}},w=x=>{{const A=(O,F)=>{let P=()=>F?.().props,N=()=>F?.().wrapperProps;const k=W(()=>un(N(),{style:{pointerEvents:v.root.disableHoverableContent?"none":void 0}})),M=W(()=>un(P(),{style:Rp("tooltip")},{style:e.style}));var L=Ae(),I=oe(L);{var U=$=>{var H=Ae(),q=oe(H);{let V=W(()=>({props:S(M),wrapperProps:S(k),...v.snippetProps}));Pt(q,()=>e.child,()=>S(V))}G($,H)},B=$=>{var H=G1e();Er(H,()=>({...S(k)}));var q=te(H);Er(q,()=>({...S(M)}));var V=te(q);Pt(V,()=>e.children??Vt),Z(q),Z(H),G($,H)};ve(I,$=>{e.child?$(U):$(B,-1)})}G(O,L)};let R=W(()=>v.root.disableHoverableContent?"none":"auto");m4(x,Rt(()=>S(y),()=>v.popperProps,{get open(){return v.root.opts.open.current},get id(){return n()},trapFocus:!1,loop:!1,preventScroll:!1,forceMount:!1,get ref(){return v.opts.ref},tooltip:!0,get shouldRender(){return v.shouldRender},get contentPointerEvents(){return S(R)},popper:A,$$slots:{popper:!0}}))}};ve(T,x=>{m()?x(C):m()||x(w,1)})}G(t,E),st()}var xyt=new Set(["$$slots","$$events","$$legacy","children","child","id","disabled","payload","tether","type","tabindex","ref"]),Ayt=se("");function Ryt(t,e){const r=Vi();at(e,!0);let n=ce(e,"id",19,()=>Yi(r)),i=ce(e,"disabled",3,!1),a=ce(e,"type",3,"button"),s=ce(e,"tabindex",3,0),o=ce(e,"ref",15,null),l=Tt(e,xyt);const u=LL.create({id:_t(()=>n()),disabled:_t(()=>i()??!1),tabindex:_t(()=>s()??0),payload:_t(()=>e.payload),tether:_t(()=>e.tether),ref:_t(()=>o(),m=>o(m))}),d=W(()=>un(l,u.props,{type:a()}));var h=Ae(),f=oe(h);{var p=m=>{var _=Ae(),v=oe(_);Pt(v,()=>e.child,()=>({props:S(d)})),G(m,_)},g=m=>{var _=Ayt();Er(_,()=>({...S(d)}));var v=te(_);Pt(v,()=>e.children??Vt),Z(_),G(m,_)};ve(f,m=>{e.child?m(p):m(g,-1)})}G(t,h),st()}var Nyt=new Set(["$$slots","$$events","$$legacy","ref"]);function Oyt(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,Nyt);l_t(t,Rt(()=>n,{get ref(){return r()},set ref(i){r(i)}})),st()}function Iyt(t,e){at(e,!0);let r=ce(e,"delayDuration",3,700),n=ce(e,"disableCloseOnTriggerClick",3,!1),i=ce(e,"disableHoverableContent",3,!1),a=ce(e,"disabled",3,!1),s=ce(e,"ignoreNonKeyboardFocus",3,!1),o=ce(e,"skipDelayDuration",3,300);Nle.create({delayDuration:_t(()=>r()),disableCloseOnTriggerClick:_t(()=>n()),disableHoverableContent:_t(()=>i()),disabled:_t(()=>a()),ignoreNonKeyboardFocus:_t(()=>s()),skipDelayDuration:_t(()=>o())});var l=Ae(),u=oe(l);Pt(u,()=>e.children??Vt),G(t,l),st()}var kyt=new Set(["$$slots","$$events","$$legacy","arrowClasses","children","class","noPortal","ref","side","sideOffset"]),Dyt=se("
"),Myt=se(" ",1);function ho(t,e){at(e,!0);const r=p=>{var g=Ae(),m=oe(g);Me(m,()=>wyt,(_,v)=>{v(_,Rt({"data-slot":"tooltip-content",get sideOffset(){return s()},get side(){return a()},get class(){return S(l)}},()=>o,{get ref(){return i()},set ref(b){i(b)},children:(b,y)=>{var E=Myt(),T=oe(E);Pt(T,()=>e.children??Vt);var C=ie(T,2);{const w=(x,A)=>{let R=()=>A?.().props;var O=Dyt();Er(O,F=>({class:F,...R()}),[()=>jr("z-50 size-2.5 rotate-45 rounded-[2px] bg-primary","data-[side=top]:translate-x-1/2 data-[side=top]:translate-y-[calc(-50%_+_2px)]","data-[side=bottom]:-translate-x-1/2 data-[side=bottom]:-translate-y-[calc(-50%_+_1px)]","data-[side=right]:translate-x-[calc(50%_+_2px)] data-[side=right]:translate-y-1/2","data-[side=left]:-translate-y-[calc(50%_-_3px)]",e.arrowClasses)]),G(x,O)};Me(C,()=>Oyt,(x,A)=>{A(x,{child:w,$$slots:{child:!0}})})}G(b,E)},$$slots:{default:!0}}))}),G(p,g)};let n=ce(e,"noPortal",3,!1),i=ce(e,"ref",15,null),a=ce(e,"side",3,"top"),s=ce(e,"sideOffset",3,4),o=Tt(e,kyt);const l=W(()=>jr("z-50 w-fit origin-(--bits-tooltip-content-transform-origin) animate-in rounded-md bg-primary px-3 py-1.5 text-xs text-balance text-primary-foreground fade-in-0 zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=closed]:fill-mode-forwards",e.class));var u=Ae(),d=oe(u);{var h=p=>{r(p)},f=p=>{var g=Ae(),m=oe(g);Me(m,()=>Lp,(_,v)=>{v(_,{children:(b,y)=>{r(b)},$$slots:{default:!0}})}),G(p,g)};ve(d,p=>{n()?p(h):p(f,-1)})}G(t,u),st()}var Lyt=new Set(["$$slots","$$events","$$legacy","ref"]);function fo(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,Lyt);var i=Ae(),a=oe(i);Me(a,()=>Ryt,(s,o)=>{o(s,Rt({"data-slot":"tooltip-trigger",class:"cursor-pointer"},()=>n,{get ref(){return r()},set ref(l){r(l)}}))}),G(t,i),st()}const po=Tyt,Pyt=Iyt;var Ti=(t=>(t.AUDIO="AUDIO",t.IMAGE="IMAGE",t.VIDEO="VIDEO",t.MCP_PROMPT="MCP_PROMPT",t.MCP_RESOURCE="MCP_RESOURCE",t.PDF="PDF",t.TEXT="TEXT",t.LEGACY_CONTEXT="context",t))(Ti||{}),u0=(t=>(t.IMAGES="images",t.AUDIO="audio",t.VIDEO="video",t.TEXT="text",t.PDF="pdf",t.SYSTEM_MESSAGE="system-message",t.MCP_PROMPT="mcp-prompt",t.MCP_RESOURCES="mcp-resources",t))(u0||{}),d0=(t=>(t.ALWAYS="always",t.HAS_VISION_MODALITY="hasVisionModality",t.HAS_AUDIO_MODALITY="hasAudioModality",t.HAS_VIDEO_MODALITY="hasVideoModality",t))(d0||{}),Hc=(t=>(t.FILE_UPLOAD="onFileUpload",t.SYSTEM_PROMPT_CLICK="onSystemPromptClick",t.MCP_PROMPT_CLICK="onMcpPromptClick",t.MCP_RESOURCES_CLICK="onMcpResourcesClick",t))(Hc||{}),kle=(t=>(t.HAS_MCP_PROMPTS_SUPPORT="hasMcpPromptsSupport",t.HAS_MCP_RESOURCES_SUPPORT="hasMcpResourcesSupport",t))(kle||{}),ud=(t=>(t.FUNCTION="function",t))(ud||{}),Fi=(t=>(t.TEXT="text",t.TOOL_CALL="tool_call",t.TOOL_CALL_PENDING="tool_call_pending",t.TOOL_CALL_STREAMING="tool_call_streaming",t.REASONING="reasoning",t.REASONING_PENDING="reasoning_pending",t))(Fi||{}),bb=(t=>(t.APPEND_TEXT="append_text",t.RERUN_TURN="rerun_turn",t.NEXT_TURN="next_turn",t))(bb||{}),t0=(t=>(t.JSON="json",t.MARKDOWN="markdown",t.TEXT="text",t))(t0||{}),lg=(t=>(t.CONTEXT="context",t.ADD="add",t.REMOVE="remove",t))(lg||{}),nd=(t=>(t.GENERATION="generation",t.READING="reading",t.TOOLS="tools",t.SUMMARY="summary",t))(nd||{}),bg=(t=>(t.SWITCHABLE="switchable",t.READING="reading",t.GENERATION="generation",t))(bg||{}),h_=(t=>(t.STREAMING="streaming",t.RESUMING="resuming",t.LOST="lost",t))(h_||{}),AJ=(t=>(t.NONE="none",t.AUTO="auto",t))(AJ||{}),Sr=(t=>(t.USER="user",t.ASSISTANT="assistant",t.SYSTEM="system",t.TOOL="tool",t))(Sr||{}),Lf=(t=>(t.ROOT="root",t.TEXT="text",t.THINK="think",t.SYSTEM="system",t))(Lf||{}),sc=(t=>(t.TEXT="text",t.IMAGE_URL="image_url",t.INPUT_AUDIO="input_audio",t.INPUT_VIDEO="input_video",t))(sc||{}),r0=(t=>(t.TIMEOUT="timeout",t.SERVER="server",t))(r0||{}),RJ=(t=>(t.EXPORT="export",t.IMPORT="import",t))(RJ||{}),zm=(t=>(t.TEXT="text",t.PAGES="pages",t))(zm||{}),Bg=(t=>(t.PROMPT="prompt",t.CWD="cwd",t.MODEL="model",t))(Bg||{}),sT=(t=>(t.FILE="file",t.DIRECTORY="directory",t))(sT||{}),RE=(t=>(t.SESSION="session",t.MESSAGE="message",t))(RE||{}),is=(t=>(t.DEFAULT="default",t.OFF="off",t.LOW="low",t.MEDIUM="medium",t.HIGH="high",t.MAX="max",t))(is||{}),pi=(t=>(t.IMAGE="image",t.AUDIO="audio",t.VIDEO="video",t.PDF="pdf",t.TEXT="text",t))(pi||{}),DR=(t=>(t.MCP_PROMPT="mcp-prompt",t))(DR||{}),Ry=(t=>(t.JPEG="jpeg",t.PNG="png",t.GIF="gif",t.WEBP="webp",t.SVG="svg",t.HEIC="heic",t.HEIF="heif",t))(Ry||{}),MR=(t=>(t.MP3="mp3",t.WAV="wav",t.WEBM="webm",t))(MR||{}),NJ=(t=>(t.MP4="mp4",t.OGG="ogg",t))(NJ||{}),VOe=(t=>(t.PDF="pdf",t))(VOe||{}),mi=(t=>(t.PLAIN_TEXT="plainText",t.MARKDOWN="md",t.ASCIIDOC="asciidoc",t.JAVASCRIPT="js",t.TYPESCRIPT="ts",t.JSX="jsx",t.TSX="tsx",t.CSS="css",t.HTML="html",t.JSON="json",t.XML="xml",t.YAML="yaml",t.CSV="csv",t.LOG="log",t.PYTHON="python",t.JAVA="java",t.CPP="cpp",t.PHP="php",t.RUBY="ruby",t.GO="go",t.RUST="rust",t.SHELL="shell",t.SQL="sql",t.R="r",t.SCALA="scala",t.KOTLIN="kotlin",t.SWIFT="swift",t.DART="dart",t.VUE="vue",t.SVELTE="svelte",t.LATEX="latex",t.BIBTEX="bibtex",t.CUDA="cuda",t.VULKAN="vulkan",t.HASKELL="haskell",t.CSHARP="csharp",t.PROPERTIES="properties",t))(mi||{}),dc=(t=>(t.JPG=".jpg",t.JPEG=".jpeg",t.PNG=".png",t.GIF=".gif",t.WEBP=".webp",t.SVG=".svg",t.HEIC=".heic",t.HEIF=".heif",t))(dc||{}),LR=(t=>(t.MP3=".mp3",t.WAV=".wav",t))(LR||{}),OJ=(t=>(t.MP4=".mp4",t.OGG=".ogg",t))(OJ||{}),Dle=(t=>(t.PDF=".pdf",t))(Dle||{}),Lr=(t=>(t.TXT=".txt",t.MD=".md",t.ADOC=".adoc",t.JS=".js",t.TS=".ts",t.JSX=".jsx",t.TSX=".tsx",t.CSS=".css",t.HTML=".html",t.HTM=".htm",t.JSON=".json",t.JSONL=".jsonl",t.ZIP=".zip",t.XML=".xml",t.YAML=".yaml",t.YML=".yml",t.CSV=".csv",t.LOG=".log",t.PY=".py",t.JAVA=".java",t.CPP=".cpp",t.C=".c",t.H=".h",t.PHP=".php",t.RB=".rb",t.GO=".go",t.RS=".rs",t.SH=".sh",t.BAT=".bat",t.SQL=".sql",t.R=".r",t.SCALA=".scala",t.KT=".kt",t.SWIFT=".swift",t.DART=".dart",t.VUE=".vue",t.SVELTE=".svelte",t.TEX=".tex",t.BIB=".bib",t.CU=".cu",t.CUH=".cuh",t.COMP=".comp",t.HPP=".hpp",t.HS=".hs",t.PROPERTIES=".properties",t.CS=".cs",t))(Lr||{}),J5=(t=>(t.IMAGE="image/",t.TEXT="text",t))(J5||{}),Qd=(t=>(t.JSON="json",t.JAVASCRIPT="javascript",t.TYPESCRIPT="typescript",t))(Qd||{}),IJ=(t=>(t.DATABASE_KEYWORD="database",t.DATABASE_SCHEME="db://",t))(IJ||{}),jg=(t=>(t.JSON="application/json",t.PDF="application/pdf",t.OCTET_STREAM="application/octet-stream",t.ZIP="application/zip",t))(jg||{}),Ua=(t=>(t.MP3_MPEG="audio/mpeg",t.MP3="audio/mp3",t.MP4="audio/mp4",t.WAV="audio/wav",t.WAVE="audio/wave",t.X_WAV="audio/x-wav",t.X_WAVE="audio/x-wave",t.VND_WAVE="audio/vnd.wave",t.X_PN_WAV="audio/x-pn-wav",t.WEBM="audio/webm",t.WEBM_OPUS="audio/webm;codecs=opus",t))(Ua||{}),PR=(t=>(t.MP4="video/mp4",t.OGG="video/ogg",t))(PR||{}),Zi=(t=>(t.JPEG="image/jpeg",t.JPG="image/jpg",t.PNG="image/png",t.GIF="image/gif",t.WEBP="image/webp",t.SVG="image/svg+xml",t.ICO="image/x-icon",t.ICO_MICROSOFT="image/vnd.microsoft.icon",t.HEIC="image/heic",t.HEIF="image/heif",t))(Zi||{}),Or=(t=>(t.PLAIN="text/plain",t.MARKDOWN="text/markdown",t.ASCIIDOC="text/asciidoc",t.JAVASCRIPT="text/javascript",t.JAVASCRIPT_APP="application/javascript",t.TYPESCRIPT="text/typescript",t.JSX="text/jsx",t.TSX="text/tsx",t.CSS="text/css",t.HTML="text/html",t.JSON="application/json",t.JSONL="application/jsonl",t.XML_TEXT="text/xml",t.XML_APP="application/xml",t.YAML_TEXT="text/yaml",t.YAML_APP="application/yaml",t.CSV="text/csv",t.PYTHON="text/x-python",t.JAVA="text/x-java-source",t.CPP_HDR="text/x-c++hdr",t.CPP_SRC="text/x-c++src",t.CSHARP="text/x-csharp",t.HASKELL="text/x-haskell",t.C_SRC="text/x-csrc",t.C_HDR="text/x-chdr",t.PHP="text/x-php",t.RUBY="text/x-ruby",t.GO="text/x-go",t.RUST="text/x-rust",t.SHELL="text/x-shellscript",t.BAT="application/x-bat",t.SQL="text/x-sql",t.R="text/x-r",t.SCALA="text/x-scala",t.KOTLIN="text/x-kotlin",t.SWIFT="text/x-swift",t.DART="text/x-dart",t.VUE="text/x-vue",t.SVELTE="text/x-svelte",t.TEX="text/x-tex",t.TEX_APP="application/x-tex",t.LATEX="application/x-latex",t.BIBTEX="text/x-bibtex",t.CUDA="text/x-cuda",t.PROPERTIES="text/properties",t))(Or||{}),Fa=(t=>(t.IDLE="idle",t.TRANSPORT_CREATING="transport_creating",t.TRANSPORT_READY="transport_ready",t.INITIALIZING="initializing",t.CAPABILITIES_EXCHANGED="capabilities_exchanged",t.LISTING_TOOLS="listing_tools",t.CONNECTED="connected",t.ERROR="error",t.DISCONNECTED="disconnected",t))(Fa||{}),_u=(t=>(t.INFO="info",t.WARN="warn",t.ERROR="error",t))(_u||{}),fc=(t=>(t.WEBSOCKET="websocket",t.STREAMABLE_HTTP="streamable_http",t.SSE="sse",t))(fc||{}),Aa=(t=>(t.IDLE="idle",t.CONNECTING="connecting",t.SUCCESS="success",t.ERROR="error",t))(Aa||{}),xD=(t=>(t.TEXT="text",t.IMAGE="image",t.RESOURCE="resource",t))(xD||{}),UT=(t=>(t.OBJECT="object",t.STRING="string",t.NUMBER="number",t))(UT||{}),kJ=(t=>(t.PROMPT="ref/prompt",t.RESOURCE="ref/resource",t))(kJ||{}),h0=(t=>(t.TEXT="TEXT",t.AUDIO="AUDIO",t.VISION="VISION",t.VIDEO="VIDEO",t))(h0||{}),Ny=(t=>(t.MODEL="model",t.ROUTER="router",t))(Ny||{}),Io=(t=>(t.UNLOADED="unloaded",t.LOADING="loading",t.LOADED="loaded",t.SLEEPING="sleeping",t.FAILED="failed",t))(Io||{}),Oy=(t=>(t.STATUS_CHANGE="status_change",t.MODEL_STATUS="model_status",t.STATUS_UPDATE="status_update",t.MODELS_RELOAD="models_reload",t.MODEL_REMOVE="model_remove",t.DOWNLOAD_PROGRESS="download_progress",t))(Oy||{}),DJ=(t=>(t.DEFAULT="default",t.CUSTOM="custom",t))(DJ||{}),eo=(t=>(t.NUMBER="number",t.STRING="string",t.BOOLEAN="boolean",t))(eo||{}),En=(t=>(t.INPUT="input",t.TEXTAREA="textarea",t.CHECKBOX="checkbox",t.SELECT="select",t.RADIO="radio",t))(En||{}),pf=(t=>(t.LIGHT="light",t.DARK="dark",t.SYSTEM="system",t))(pf||{}),g0=(t=>(t.TOP="top",t.RIGHT="right",t.BOTTOM="bottom",t.LEFT="left",t))(g0||{}),FR=(t=>(t.MESSAGE="message",t.ATTACHMENT="attachment",t))(FR||{}),Uu=(t=>(t.DATA="data:",t.FILE="file:",t.HTTP="http:",t.HTTPS="https:",t.WEBSOCKET="ws:",t.WEBSOCKET_SECURE="wss:",t))(Uu||{}),MJ=(t=>(t.FILE="file",t))(MJ||{}),Ri=(t=>(t.ENTER="Enter",t.ESCAPE="Escape",t.ARROW_UP="ArrowUp",t.ARROW_DOWN="ArrowDown",t.ARROW_LEFT="ArrowLeft",t.ARROW_RIGHT="ArrowRight",t.TAB="Tab",t.B_LOWER="b",t.D_LOWER="d",t.D_UPPER="D",t.E_UPPER="E",t.K_LOWER="k",t.O_LOWER="o",t.O_UPPER="O",t.SPACE=" ",t))(Ri||{}),Jn=(t=>(t.BUILTIN="builtin",t.MCP="mcp",t.CUSTOM="custom",t.FRONTEND="frontend",t))(Jn||{}),Xh=(t=>(t.ALWAYS="always",t.ALWAYS_SERVER="always_server",t.ONCE="once",t.DENY="deny",t))(Xh||{}),I6=(t=>(t.PLAIN_TEXT="plain_text_response",t.ERROR="error",t))(I6||{}),ex=(t=>(t.FILE="file",t.DIR="dir",t.ALL="all",t))(ex||{}),rn=(t=>(t.READ_FILE="read_file",t.EDIT_FILE="edit_file",t.WRITE_FILE="write_file",t.GET_DATETIME="get_datetime",t.GET_INFO="get_info",t.FILE_GLOB_SEARCH="file_glob_search",t.GREP_SEARCH="grep_search",t.EXEC_SHELL_COMMAND="exec_shell_command",t.RUN_JAVASCRIPT="run_javascript",t))(rn||{}),Fyt=se(""),Byt=se("

"),Uyt=se(" ",1);function va(t,e){at(e,!0);const r=(v,b)=>{let y=H_(()=>W7e(b?.(),()=>({}),!0));{let E=W(()=>e.ariaLabel||e.tooltip);Gn(v,Rt(()=>S(y),{get href(){return a()},get variant(){return d()},get size(){return o()},get disabled(){return i()},onclick:T=>{l()&&T.stopPropagation(),e.onclick?.(T)},get class(){return`h-6 w-6 p-0 ${n()??""} flex hover:bg-transparent data-[state=open]:bg-transparent!`},get"aria-label"(){return S(E)},children:(T,C)=>{var w=Ae(),x=oe(w);{var A=R=>{const O=W(()=>e.icon);var F=Ae(),P=oe(F);Me(P,()=>S(O),(N,k)=>{k(N,{get class(){return s()}})}),G(R,F)};ve(x,R=>{e.icon&&R(A)})}G(T,w)},$$slots:{default:!0}}))}};let n=ce(e,"class",3,""),i=ce(e,"disabled",3,!1),a=ce(e,"href",3,""),s=ce(e,"iconSize",3,"h-3 w-3"),o=ce(e,"size",3,"sm"),l=ce(e,"stopPropagationOnClick",3,!1),u=ce(e,"tooltipSide",19,()=>g0.TOP),d=ce(e,"variant",3,"ghost"),h=Oe(0);const f=W(()=>!!e.tooltip&&S(h)>768);var p=Ae(),g=oe(p);{var m=v=>{var b=Ae(),y=oe(b);Me(y,()=>po,(E,T)=>{T(E,{children:(C,w)=>{var x=Uyt(),A=oe(x);{const O=(F,P)=>{let N=()=>P?.().props;var k=Ae(),M=oe(k);{var L=U=>{var B=Fyt();Er(B,()=>({...N()}));var $=te(B);r($,()=>({})),Z(B),G(U,B)},I=U=>{r(U,N)};ve(M,U=>{i()?U(L):U(I,-1)})}G(F,k)};Me(A,()=>fo,(F,P)=>{P(F,{child:O,$$slots:{child:!0}})})}var R=ie(A,2);Me(R,()=>ho,(O,F)=>{F(O,{get side(){return u()},children:(P,N)=>{var k=Byt(),M=te(k,!0);Z(k),$e(()=>it(M,e.tooltip)),G(P,k)},$$slots:{default:!0}})}),G(C,x)},$$slots:{default:!0}})}),G(v,b)},_=v=>{r(v,()=>({href:a()}))};ve(g,v=>{S(f)?v(m):v(_,-1)})}xR("innerWidth",v=>X(h,v,!0)),G(t,p),st()}const $yt={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":2,"stroke-linecap":"round","stroke-linejoin":"round"};const Gyt=t=>{for(const e in t)if(e.startsWith("aria-")||e==="role"||e==="title")return!0;return!1};const zyt=Symbol("lucide-context"),qyt=()=>q_(zyt);var Hyt=new Set(["$$slots","$$events","$$legacy","name","color","size","strokeWidth","absoluteStrokeWidth","iconNode","children"]),Vyt=im("");function Mr(t,e){at(e,!0);const r=qyt()??{},n=ce(e,"color",19,()=>r.color??"currentColor"),i=ce(e,"size",19,()=>r.size??24),a=ce(e,"strokeWidth",19,()=>r.strokeWidth??2),s=ce(e,"absoluteStrokeWidth",19,()=>r.absoluteStrokeWidth??!1),o=ce(e,"iconNode",19,()=>[]),l=Tt(e,Hyt),u=W(()=>s()?Number(a())*24/Number(i()):a());var d=Vyt();Er(d,p=>({...$yt,...p,...l,width:i(),height:i(),stroke:n(),"stroke-width":S(u),class:["lucide-icon lucide",r.class,e.name&&`lucide-${e.name}`,e.class]}),[()=>!e.children&&!Gyt(l)&&{"aria-hidden":"true"}]);var h=te(d);qr(h,17,o,Vl,(p,g)=>{var m=W(()=>lse(S(g),2));let _=()=>S(m)[0],v=()=>S(m)[1];var b=Ae(),y=oe(b);K8e(y,_,!0,(E,T)=>{Er(E,()=>({...v()}))}),G(p,b)});var f=ie(h);Pt(f,()=>e.children??Vt),Z(d),G(t,d),st()}var Yyt=new Set(["$$slots","$$events","$$legacy"]);function Wyt(t,e){let r=Tt(e,Yyt);const n=[["path",{d:"M9 19a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1v-6a1 1 0 0 1 1-1h3.293a.707.707 0 0 0 .5-1.207l-7.086-7.086a1 1 0 0 0-1.414 0l-7.086 7.086a.707.707 0 0 0 .5 1.207H8a1 1 0 0 1 1 1z"}]];Mr(t,Rt({name:"arrow-big-up"},()=>r,{get iconNode(){return n}}))}var Kyt=new Set(["$$slots","$$events","$$legacy"]);function jyt(t,e){let r=Tt(e,Kyt);const n=[["path",{d:"M12 5v14"}],["path",{d:"m19 12-7 7-7-7"}]];Mr(t,Rt({name:"arrow-down"},()=>r,{get iconNode(){return n}}))}var Xyt=new Set(["$$slots","$$events","$$legacy"]);function YOe(t,e){let r=Tt(e,Xyt);const n=[["path",{d:"M5 12h14"}],["path",{d:"m12 5 7 7-7 7"}]];Mr(t,Rt({name:"arrow-right"},()=>r,{get iconNode(){return n}}))}var Qyt=new Set(["$$slots","$$events","$$legacy"]);function WOe(t,e){let r=Tt(e,Qyt);const n=[["path",{d:"m5 12 7-7 7 7"}],["path",{d:"M12 19V5"}]];Mr(t,Rt({name:"arrow-up"},()=>r,{get iconNode(){return n}}))}var Zyt=new Set(["$$slots","$$events","$$legacy"]);function Jyt(t,e){let r=Tt(e,Zyt);const n=[["path",{d:"M12 7v14"}],["path",{d:"M16 12h2"}],["path",{d:"M16 8h2"}],["path",{d:"M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"}],["path",{d:"M6 12h2"}],["path",{d:"M6 8h2"}]];Mr(t,Rt({name:"book-open-text"},()=>r,{get iconNode(){return n}}))}var ebt=new Set(["$$slots","$$events","$$legacy"]);function KOe(t,e){let r=Tt(e,ebt);const n=[["path",{d:"M12 8V4H8"}],["rect",{width:"16",height:"12",x:"4",y:"8",rx:"2"}],["path",{d:"M2 14h2"}],["path",{d:"M20 14h2"}],["path",{d:"M15 13v2"}],["path",{d:"M9 13v2"}]];Mr(t,Rt({name:"bot"},()=>r,{get iconNode(){return n}}))}var tbt=new Set(["$$slots","$$events","$$legacy"]);function Mle(t,e){let r=Tt(e,tbt);const n=[["path",{d:"M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1"}],["path",{d:"M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1"}]];Mr(t,Rt({name:"braces"},()=>r,{get iconNode(){return n}}))}var rbt=new Set(["$$slots","$$events","$$legacy"]);function X2(t,e){let r=Tt(e,rbt);const n=[["path",{d:"M20 6 9 17l-5-5"}]];Mr(t,Rt({name:"check"},()=>r,{get iconNode(){return n}}))}var nbt=new Set(["$$slots","$$events","$$legacy"]);function GU(t,e){let r=Tt(e,nbt);const n=[["path",{d:"m15 18-6-6 6-6"}]];Mr(t,Rt({name:"chevron-left"},()=>r,{get iconNode(){return n}}))}var ibt=new Set(["$$slots","$$events","$$legacy"]);function wl(t,e){let r=Tt(e,ibt);const n=[["path",{d:"m6 9 6 6 6-6"}]];Mr(t,Rt({name:"chevron-down"},()=>r,{get iconNode(){return n}}))}var abt=new Set(["$$slots","$$events","$$legacy"]);function Vc(t,e){let r=Tt(e,abt);const n=[["path",{d:"m9 18 6-6-6-6"}]];Mr(t,Rt({name:"chevron-right"},()=>r,{get iconNode(){return n}}))}var sbt=new Set(["$$slots","$$events","$$legacy"]);function obt(t,e){let r=Tt(e,sbt);const n=[["path",{d:"m18 15-6-6-6 6"}]];Mr(t,Rt({name:"chevron-up"},()=>r,{get iconNode(){return n}}))}var lbt=new Set(["$$slots","$$events","$$legacy"]);function Lle(t,e){let r=Tt(e,lbt);const n=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"12",x2:"12",y1:"8",y2:"12"}],["line",{x1:"12",x2:"12.01",y1:"16",y2:"16"}]];Mr(t,Rt({name:"circle-alert"},()=>r,{get iconNode(){return n}}))}var cbt=new Set(["$$slots","$$events","$$legacy"]);function ubt(t,e){let r=Tt(e,cbt);const n=[["path",{d:"M21.801 10A10 10 0 1 1 17 3.335"}],["path",{d:"m9 11 3 3L22 4"}]];Mr(t,Rt({name:"circle-check-big"},()=>r,{get iconNode(){return n}}))}var dbt=new Set(["$$slots","$$events","$$legacy"]);function G0(t,e){let r=Tt(e,dbt);const n=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m15 9-6 6"}],["path",{d:"m9 9 6 6"}]];Mr(t,Rt({name:"circle-x"},()=>r,{get iconNode(){return n}}))}var hbt=new Set(["$$slots","$$events","$$legacy"]);function fbt(t,e){let r=Tt(e,hbt);const n=[["circle",{cx:"12",cy:"12",r:"10"}]];Mr(t,Rt({name:"circle"},()=>r,{get iconNode(){return n}}))}var pbt=new Set(["$$slots","$$events","$$legacy"]);function oT(t,e){let r=Tt(e,pbt);const n=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 6v6l4 2"}]];Mr(t,Rt({name:"clock"},()=>r,{get iconNode(){return n}}))}var gbt=new Set(["$$slots","$$events","$$legacy"]);function N9(t,e){let r=Tt(e,gbt);const n=[["path",{d:"m16 18 6-6-6-6"}],["path",{d:"m8 6-6 6 6 6"}]];Mr(t,Rt({name:"code"},()=>r,{get iconNode(){return n}}))}var mbt=new Set(["$$slots","$$events","$$legacy"]);function jOe(t,e){let r=Tt(e,mbt);const n=[["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]];Mr(t,Rt({name:"copy"},()=>r,{get iconNode(){return n}}))}var _bt=new Set(["$$slots","$$events","$$legacy"]);function vbt(t,e){let r=Tt(e,_bt);const n=[["path",{d:"M12 20v2"}],["path",{d:"M12 2v2"}],["path",{d:"M17 20v2"}],["path",{d:"M17 2v2"}],["path",{d:"M2 12h2"}],["path",{d:"M2 17h2"}],["path",{d:"M2 7h2"}],["path",{d:"M20 12h2"}],["path",{d:"M20 17h2"}],["path",{d:"M20 7h2"}],["path",{d:"M7 20v2"}],["path",{d:"M7 2v2"}],["rect",{x:"4",y:"4",width:"16",height:"16",rx:"2"}],["rect",{x:"8",y:"8",width:"8",height:"8",rx:"1"}]];Mr(t,Rt({name:"cpu"},()=>r,{get iconNode(){return n}}))}var ybt=new Set(["$$slots","$$events","$$legacy"]);function Ple(t,e){let r=Tt(e,ybt);const n=[["ellipse",{cx:"12",cy:"5",rx:"9",ry:"3"}],["path",{d:"M3 5V19A9 3 0 0 0 21 19V5"}],["path",{d:"M3 12A9 3 0 0 0 21 12"}]];Mr(t,Rt({name:"database"},()=>r,{get iconNode(){return n}}))}var bbt=new Set(["$$slots","$$events","$$legacy"]);function h2(t,e){let r=Tt(e,bbt);const n=[["path",{d:"M12 15V3"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"}],["path",{d:"m7 10 5 5 5-5"}]];Mr(t,Rt({name:"download"},()=>r,{get iconNode(){return n}}))}var Sbt=new Set(["$$slots","$$events","$$legacy"]);function Ebt(t,e){let r=Tt(e,Sbt);const n=[["circle",{cx:"12",cy:"12",r:"1"}],["circle",{cx:"19",cy:"12",r:"1"}],["circle",{cx:"5",cy:"12",r:"1"}]];Mr(t,Rt({name:"ellipsis"},()=>r,{get iconNode(){return n}}))}var Tbt=new Set(["$$slots","$$events","$$legacy"]);function Cbt(t,e){let r=Tt(e,Tbt);const n=[["path",{d:"M15 3h6v6"}],["path",{d:"M10 14 21 3"}],["path",{d:"M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"}]];Mr(t,Rt({name:"external-link"},()=>r,{get iconNode(){return n}}))}var wbt=new Set(["$$slots","$$events","$$legacy"]);function Fle(t,e){let r=Tt(e,wbt);const n=[["path",{d:"M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0"}],["circle",{cx:"12",cy:"12",r:"3"}]];Mr(t,Rt({name:"eye"},()=>r,{get iconNode(){return n}}))}var xbt=new Set(["$$slots","$$events","$$legacy"]);function z1e(t,e){let r=Tt(e,xbt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["path",{d:"M10 12.5 8 15l2 2.5"}],["path",{d:"m14 12.5 2 2.5-2 2.5"}]];Mr(t,Rt({name:"file-code"},()=>r,{get iconNode(){return n}}))}var Abt=new Set(["$$slots","$$events","$$legacy"]);function Rbt(t,e){let r=Tt(e,Abt);const n=[["path",{d:"M12.659 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v9.34"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["path",{d:"M10.378 12.622a1 1 0 0 1 3 3.003L8.36 20.637a2 2 0 0 1-.854.506l-2.867.837a.5.5 0 0 1-.62-.62l.836-2.869a2 2 0 0 1 .506-.853z"}]];Mr(t,Rt({name:"file-pen"},()=>r,{get iconNode(){return n}}))}var Nbt=new Set(["$$slots","$$events","$$legacy"]);function Obt(t,e){let r=Tt(e,Nbt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["path",{d:"M9 15h6"}],["path",{d:"M12 18v-6"}]];Mr(t,Rt({name:"file-plus"},()=>r,{get iconNode(){return n}}))}var Ibt=new Set(["$$slots","$$events","$$legacy"]);function kbt(t,e){let r=Tt(e,Ibt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["circle",{cx:"11.5",cy:"14.5",r:"2.5"}],["path",{d:"M13.3 16.3 15 18"}]];Mr(t,Rt({name:"file-search"},()=>r,{get iconNode(){return n}}))}var Dbt=new Set(["$$slots","$$events","$$legacy"]);function sp(t,e){let r=Tt(e,Dbt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["path",{d:"M10 9H8"}],["path",{d:"M16 13H8"}],["path",{d:"M16 17H8"}]];Mr(t,Rt({name:"file-text"},()=>r,{get iconNode(){return n}}))}var Mbt=new Set(["$$slots","$$events","$$legacy"]);function Lbt(t,e){let r=Tt(e,Mbt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}],["path",{d:"m14.5 12.5-5 5"}],["path",{d:"m9.5 12.5 5 5"}]];Mr(t,Rt({name:"file-x"},()=>r,{get iconNode(){return n}}))}var Pbt=new Set(["$$slots","$$events","$$legacy"]);function v4(t,e){let r=Tt(e,Pbt);const n=[["path",{d:"M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"}],["path",{d:"M14 2v5a1 1 0 0 0 1 1h5"}]];Mr(t,Rt({name:"file"},()=>r,{get iconNode(){return n}}))}var Fbt=new Set(["$$slots","$$events","$$legacy"]);function XS(t,e){let r=Tt(e,Fbt);const n=[["path",{d:"M14 2v6a2 2 0 0 0 .245.96l5.51 10.08A2 2 0 0 1 18 22H6a2 2 0 0 1-1.755-2.96l5.51-10.08A2 2 0 0 0 10 8V2"}],["path",{d:"M6.453 15h11.094"}],["path",{d:"M8.5 2h7"}]];Mr(t,Rt({name:"flask-conical"},()=>r,{get iconNode(){return n}}))}var Bbt=new Set(["$$slots","$$events","$$legacy"]);function Q2(t,e){let r=Tt(e,Bbt);const n=[["path",{d:"m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"}]];Mr(t,Rt({name:"folder-open"},()=>r,{get iconNode(){return n}}))}var Ubt=new Set(["$$slots","$$events","$$legacy"]);function $bt(t,e){let r=Tt(e,Ubt);const n=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"m9.5 10.5 5 5"}],["path",{d:"m14.5 10.5-5 5"}]];Mr(t,Rt({name:"folder-x"},()=>r,{get iconNode(){return n}}))}var Gbt=new Set(["$$slots","$$events","$$legacy"]);function zU(t,e){let r=Tt(e,Gbt);const n=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}]];Mr(t,Rt({name:"folder"},()=>r,{get iconNode(){return n}}))}var zbt=new Set(["$$slots","$$events","$$legacy"]);function qbt(t,e){let r=Tt(e,zbt);const n=[["path",{d:"M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z"}]];Mr(t,Rt({name:"funnel"},()=>r,{get iconNode(){return n}}))}var Hbt=new Set(["$$slots","$$events","$$legacy"]);function pH(t,e){let r=Tt(e,Hbt);const n=[["path",{d:"m12 14 4-4"}],["path",{d:"M3.34 19a10 10 0 1 1 17.32 0"}]];Mr(t,Rt({name:"gauge"},()=>r,{get iconNode(){return n}}))}var Vbt=new Set(["$$slots","$$events","$$legacy"]);function LJ(t,e){let r=Tt(e,Vbt);const n=[["path",{d:"M15 6a9 9 0 0 0-9 9V3"}],["circle",{cx:"18",cy:"6",r:"3"}],["circle",{cx:"6",cy:"18",r:"3"}]];Mr(t,Rt({name:"git-branch"},()=>r,{get iconNode(){return n}}))}var Ybt=new Set(["$$slots","$$events","$$legacy"]);function Ble(t,e){let r=Tt(e,Ybt);const n=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"}],["path",{d:"M2 12h20"}]];Mr(t,Rt({name:"globe"},()=>r,{get iconNode(){return n}}))}var Wbt=new Set(["$$slots","$$events","$$legacy"]);function Kbt(t,e){let r=Tt(e,Wbt);const n=[["path",{d:"M10.5 4.893a5.5 5.5 0 0 1 1.091.931.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 1.872-1.002 3.356-2.187 4.655"}],["path",{d:"m16.967 16.967-3.459 3.346a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 2.747-4.761"}],["path",{d:"m2 2 20 20"}]];Mr(t,Rt({name:"heart-off"},()=>r,{get iconNode(){return n}}))}var jbt=new Set(["$$slots","$$events","$$legacy"]);function Xbt(t,e){let r=Tt(e,jbt);const n=[["path",{d:"M2 9.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5"}]];Mr(t,Rt({name:"heart"},()=>r,{get iconNode(){return n}}))}var Qbt=new Set(["$$slots","$$events","$$legacy"]);function Ule(t,e){let r=Tt(e,Qbt);const n=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["circle",{cx:"9",cy:"9",r:"2"}],["path",{d:"m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"}]];Mr(t,Rt({name:"image"},()=>r,{get iconNode(){return n}}))}var Zbt=new Set(["$$slots","$$events","$$legacy"]);function A0(t,e){let r=Tt(e,Zbt);const n=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 16v-4"}],["path",{d:"M12 8h.01"}]];Mr(t,Rt({name:"info"},()=>r,{get iconNode(){return n}}))}var Jbt=new Set(["$$slots","$$events","$$legacy"]);function e2t(t,e){let r=Tt(e,Jbt);const n=[["path",{d:"m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4"}],["path",{d:"m21 2-9.6 9.6"}],["circle",{cx:"7.5",cy:"15.5",r:"5.5"}]];Mr(t,Rt({name:"key"},()=>r,{get iconNode(){return n}}))}var t2t=new Set(["$$slots","$$events","$$legacy"]);function q1e(t,e){let r=Tt(e,t2t);const n=[["path",{d:"M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z"}],["path",{d:"M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12"}],["path",{d:"M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17"}]];Mr(t,Rt({name:"layers"},()=>r,{get iconNode(){return n}}))}var r2t=new Set(["$$slots","$$events","$$legacy"]);function XOe(t,e){let r=Tt(e,r2t);const n=[["path",{d:"M16.8 11.2c.8-.9 1.2-2 1.2-3.2a6 6 0 0 0-9.3-5"}],["path",{d:"m2 2 20 20"}],["path",{d:"M6.3 6.3a4.67 4.67 0 0 0 1.2 5.2c.7.7 1.3 1.5 1.5 2.5"}],["path",{d:"M9 18h6"}],["path",{d:"M10 22h4"}]];Mr(t,Rt({name:"lightbulb-off"},()=>r,{get iconNode(){return n}}))}var n2t=new Set(["$$slots","$$events","$$legacy"]);function BR(t,e){let r=Tt(e,n2t);const n=[["path",{d:"M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5"}],["path",{d:"M9 18h6"}],["path",{d:"M10 22h4"}]];Mr(t,Rt({name:"lightbulb"},()=>r,{get iconNode(){return n}}))}var i2t=new Set(["$$slots","$$events","$$legacy"]);function QOe(t,e){let r=Tt(e,i2t);const n=[["path",{d:"M13 5h8"}],["path",{d:"M13 12h8"}],["path",{d:"M13 19h8"}],["path",{d:"m3 17 2 2 4-4"}],["path",{d:"m3 7 2 2 4-4"}]];Mr(t,Rt({name:"list-checks"},()=>r,{get iconNode(){return n}}))}var a2t=new Set(["$$slots","$$events","$$legacy"]);function s2t(t,e){let r=Tt(e,a2t);const n=[["path",{d:"M21 5H3"}],["path",{d:"M7 12H3"}],["path",{d:"M7 19H3"}],["path",{d:"M12 18a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L11 14"}],["path",{d:"M11 10v4h4"}]];Mr(t,Rt({name:"list-restart"},()=>r,{get iconNode(){return n}}))}var o2t=new Set(["$$slots","$$events","$$legacy"]);function us(t,e){let r=Tt(e,o2t);const n=[["path",{d:"M21 12a9 9 0 1 1-6.219-8.56"}]];Mr(t,Rt({name:"loader-circle"},()=>r,{get iconNode(){return n}}))}var l2t=new Set(["$$slots","$$events","$$legacy"]);function qU(t,e){let r=Tt(e,l2t);const n=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}]];Mr(t,Rt({name:"message-square"},()=>r,{get iconNode(){return n}}))}var c2t=new Set(["$$slots","$$events","$$legacy"]);function $le(t,e){let r=Tt(e,c2t);const n=[["path",{d:"M12 19v3"}],["path",{d:"M19 10v2a7 7 0 0 1-14 0v-2"}],["rect",{x:"9",y:"2",width:"6",height:"13",rx:"3"}]];Mr(t,Rt({name:"mic"},()=>r,{get iconNode(){return n}}))}var u2t=new Set(["$$slots","$$events","$$legacy"]);function d2t(t,e){let r=Tt(e,u2t);const n=[["path",{d:"M5 12h14"}]];Mr(t,Rt({name:"minus"},()=>r,{get iconNode(){return n}}))}var h2t=new Set(["$$slots","$$events","$$legacy"]);function ZOe(t,e){let r=Tt(e,h2t);const n=[["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["line",{x1:"8",x2:"16",y1:"21",y2:"21"}],["line",{x1:"12",x2:"12",y1:"17",y2:"21"}]];Mr(t,Rt({name:"monitor"},()=>r,{get iconNode(){return n}}))}var f2t=new Set(["$$slots","$$events","$$legacy"]);function p2t(t,e){let r=Tt(e,f2t);const n=[["path",{d:"M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401"}]];Mr(t,Rt({name:"moon"},()=>r,{get iconNode(){return n}}))}var g2t=new Set(["$$slots","$$events","$$legacy"]);function HU(t,e){let r=Tt(e,g2t);const n=[["path",{d:"M9 18V5l12-2v13"}],["circle",{cx:"6",cy:"18",r:"3"}],["circle",{cx:"18",cy:"16",r:"3"}]];Mr(t,Rt({name:"music"},()=>r,{get iconNode(){return n}}))}var m2t=new Set(["$$slots","$$events","$$legacy"]);function PL(t,e){let r=Tt(e,m2t);const n=[["path",{d:"M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z"}],["path",{d:"M12 22V12"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["path",{d:"m7.5 4.27 9 5.15"}]];Mr(t,Rt({name:"package"},()=>r,{get iconNode(){return n}}))}var _2t=new Set(["$$slots","$$events","$$legacy"]);function v2t(t,e){let r=Tt(e,_2t);const n=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"m16 15-3-3 3-3"}]];Mr(t,Rt({name:"panel-left-close"},()=>r,{get iconNode(){return n}}))}var y2t=new Set(["$$slots","$$events","$$legacy"]);function b2t(t,e){let r=Tt(e,y2t);const n=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"m14 9 3 3-3 3"}]];Mr(t,Rt({name:"panel-left-open"},()=>r,{get iconNode(){return n}}))}var S2t=new Set(["$$slots","$$events","$$legacy"]);function Gle(t,e){let r=Tt(e,S2t);const n=[["path",{d:"M13 7 8.7 2.7a2.41 2.41 0 0 0-3.4 0L2.7 5.3a2.41 2.41 0 0 0 0 3.4L7 13"}],["path",{d:"m8 6 2-2"}],["path",{d:"m18 16 2-2"}],["path",{d:"m17 11 4.3 4.3c.94.94.94 2.46 0 3.4l-2.6 2.6c-.94.94-2.46.94-3.4 0L11 17"}],["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}],["path",{d:"m15 5 4 4"}]];Mr(t,Rt({name:"pencil-ruler"},()=>r,{get iconNode(){return n}}))}var E2t=new Set(["$$slots","$$events","$$legacy"]);function zle(t,e){let r=Tt(e,E2t);const n=[["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}],["path",{d:"m15 5 4 4"}]];Mr(t,Rt({name:"pencil"},()=>r,{get iconNode(){return n}}))}var T2t=new Set(["$$slots","$$events","$$legacy"]);function JOe(t,e){let r=Tt(e,T2t);const n=[["path",{d:"M12 17v5"}],["path",{d:"M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89"}],["path",{d:"m2 2 20 20"}],["path",{d:"M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11"}]];Mr(t,Rt({name:"pin-off"},()=>r,{get iconNode(){return n}}))}var C2t=new Set(["$$slots","$$events","$$legacy"]);function qle(t,e){let r=Tt(e,C2t);const n=[["path",{d:"M12 17v5"}],["path",{d:"M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"}]];Mr(t,Rt({name:"pin"},()=>r,{get iconNode(){return n}}))}var w2t=new Set(["$$slots","$$events","$$legacy"]);function H1e(t,e){let r=Tt(e,w2t);const n=[["path",{d:"M5 5a2 2 0 0 1 3.008-1.728l11.997 6.998a2 2 0 0 1 .003 3.458l-12 7A2 2 0 0 1 5 19z"}]];Mr(t,Rt({name:"play"},()=>r,{get iconNode(){return n}}))}var x2t=new Set(["$$slots","$$events","$$legacy"]);function Ag(t,e){let r=Tt(e,x2t);const n=[["path",{d:"M5 12h14"}],["path",{d:"M12 5v14"}]];Mr(t,Rt({name:"plus"},()=>r,{get iconNode(){return n}}))}var A2t=new Set(["$$slots","$$events","$$legacy"]);function V1e(t,e){let r=Tt(e,A2t);const n=[["path",{d:"M18.36 6.64A9 9 0 0 1 20.77 15"}],["path",{d:"M6.16 6.16a9 9 0 1 0 12.68 12.68"}],["path",{d:"M12 2v4"}],["path",{d:"m2 2 20 20"}]];Mr(t,Rt({name:"power-off"},()=>r,{get iconNode(){return n}}))}var R2t=new Set(["$$slots","$$events","$$legacy"]);function N2t(t,e){let r=Tt(e,R2t);const n=[["path",{d:"M12 2v10"}],["path",{d:"M18.4 6.6a9 9 0 1 1-12.77.04"}]];Mr(t,Rt({name:"power"},()=>r,{get iconNode(){return n}}))}var O2t=new Set(["$$slots","$$events","$$legacy"]);function I2t(t,e){let r=Tt(e,O2t);const n=[["path",{d:"M16.247 7.761a6 6 0 0 1 0 8.478"}],["path",{d:"M19.075 4.933a10 10 0 0 1 0 14.134"}],["path",{d:"M4.925 19.067a10 10 0 0 1 0-14.134"}],["path",{d:"M7.753 16.239a6 6 0 0 1 0-8.478"}],["circle",{cx:"12",cy:"12",r:"2"}]];Mr(t,Rt({name:"radio"},()=>r,{get iconNode(){return n}}))}var k2t=new Set(["$$slots","$$events","$$legacy"]);function m0(t,e){let r=Tt(e,k2t);const n=[["path",{d:"M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"}],["path",{d:"M21 3v5h-5"}],["path",{d:"M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"}],["path",{d:"M8 16H3v5"}]];Mr(t,Rt({name:"refresh-cw"},()=>r,{get iconNode(){return n}}))}var D2t=new Set(["$$slots","$$events","$$legacy"]);function UR(t,e){let r=Tt(e,D2t);const n=[["path",{d:"M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}]];Mr(t,Rt({name:"rotate-ccw"},()=>r,{get iconNode(){return n}}))}var M2t=new Set(["$$slots","$$events","$$legacy"]);function eIe(t,e){let r=Tt(e,M2t);const n=[["path",{d:"M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8"}],["path",{d:"M21 3v5h-5"}]];Mr(t,Rt({name:"rotate-cw"},()=>r,{get iconNode(){return n}}))}var L2t=new Set(["$$slots","$$events","$$legacy"]);function P2t(t,e){let r=Tt(e,L2t);const n=[["path",{d:"m13 13.5 2-2.5-2-2.5"}],["path",{d:"m21 21-4.3-4.3"}],["path",{d:"M9 8.5 7 11l2 2.5"}],["circle",{cx:"11",cy:"11",r:"8"}]];Mr(t,Rt({name:"search-code"},()=>r,{get iconNode(){return n}}))}var F2t=new Set(["$$slots","$$events","$$legacy"]);function FL(t,e){let r=Tt(e,F2t);const n=[["path",{d:"m21 21-4.34-4.34"}],["circle",{cx:"11",cy:"11",r:"8"}]];Mr(t,Rt({name:"search"},()=>r,{get iconNode(){return n}}))}var B2t=new Set(["$$slots","$$events","$$legacy"]);function tIe(t,e){let r=Tt(e,B2t);const n=[["rect",{width:"20",height:"8",x:"2",y:"2",rx:"2",ry:"2"}],["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2",ry:"2"}],["line",{x1:"6",x2:"6.01",y1:"6",y2:"6"}],["line",{x1:"6",x2:"6.01",y1:"18",y2:"18"}]];Mr(t,Rt({name:"server"},()=>r,{get iconNode(){return n}}))}var U2t=new Set(["$$slots","$$events","$$legacy"]);function tx(t,e){let r=Tt(e,U2t);const n=[["path",{d:"M9.671 4.136a2.34 2.34 0 0 1 4.659 0 2.34 2.34 0 0 0 3.319 1.915 2.34 2.34 0 0 1 2.33 4.033 2.34 2.34 0 0 0 0 3.831 2.34 2.34 0 0 1-2.33 4.033 2.34 2.34 0 0 0-3.319 1.915 2.34 2.34 0 0 1-4.659 0 2.34 2.34 0 0 0-3.32-1.915 2.34 2.34 0 0 1-2.33-4.033 2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915"}],["circle",{cx:"12",cy:"12",r:"3"}]];Mr(t,Rt({name:"settings"},()=>r,{get iconNode(){return n}}))}var $2t=new Set(["$$slots","$$events","$$legacy"]);function G2t(t,e){let r=Tt(e,$2t);const n=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"m9 12 2 2 4-4"}]];Mr(t,Rt({name:"shield-check"},()=>r,{get iconNode(){return n}}))}var z2t=new Set(["$$slots","$$events","$$legacy"]);function q2t(t,e){let r=Tt(e,z2t);const n=[["path",{d:"m2 2 20 20"}],["path",{d:"M5 5a1 1 0 0 0-1 1v7c0 5 3.5 7.5 7.67 8.94a1 1 0 0 0 .67.01c2.35-.82 4.48-1.97 5.9-3.71"}],["path",{d:"M9.309 3.652A12.252 12.252 0 0 0 11.24 2.28a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1v7a9.784 9.784 0 0 1-.08 1.264"}]];Mr(t,Rt({name:"shield-off"},()=>r,{get iconNode(){return n}}))}var H2t=new Set(["$$slots","$$events","$$legacy"]);function V2t(t,e){let r=Tt(e,H2t);const n=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"}],["path",{d:"M12 17h.01"}]];Mr(t,Rt({name:"shield-question-mark"},()=>r,{get iconNode(){return n}}))}var Y2t=new Set(["$$slots","$$events","$$legacy"]);function W2t(t,e){let r=Tt(e,Y2t);const n=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}]];Mr(t,Rt({name:"shield"},()=>r,{get iconNode(){return n}}))}var K2t=new Set(["$$slots","$$events","$$legacy"]);function j2t(t,e){let r=Tt(e,K2t);const n=[["path",{d:"M21 4v16"}],["path",{d:"M6.029 4.285A2 2 0 0 0 3 6v12a2 2 0 0 0 3.029 1.715l9.997-5.998a2 2 0 0 0 .003-3.432z"}]];Mr(t,Rt({name:"skip-forward"},()=>r,{get iconNode(){return n}}))}var X2t=new Set(["$$slots","$$events","$$legacy"]);function Q2t(t,e){let r=Tt(e,X2t);const n=[["path",{d:"M10 8h4"}],["path",{d:"M12 21v-9"}],["path",{d:"M12 8V3"}],["path",{d:"M17 16h4"}],["path",{d:"M19 12V3"}],["path",{d:"M19 21v-5"}],["path",{d:"M3 14h4"}],["path",{d:"M5 10V3"}],["path",{d:"M5 21v-7"}]];Mr(t,Rt({name:"sliders-vertical"},()=>r,{get iconNode(){return n}}))}var Z2t=new Set(["$$slots","$$events","$$legacy"]);function $R(t,e){let r=Tt(e,Z2t);const n=[["path",{d:"M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z"}],["path",{d:"M20 2v4"}],["path",{d:"M22 4h-4"}],["circle",{cx:"4",cy:"20",r:"2"}]];Mr(t,Rt({name:"sparkles"},()=>r,{get iconNode(){return n}}))}var J2t=new Set(["$$slots","$$events","$$legacy"]);function Hle(t,e){let r=Tt(e,J2t);const n=[["path",{d:"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"}],["path",{d:"M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"}]];Mr(t,Rt({name:"square-pen"},()=>r,{get iconNode(){return n}}))}var eSt=new Set(["$$slots","$$events","$$legacy"]);function Vle(t,e){let r=Tt(e,eSt);const n=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]];Mr(t,Rt({name:"square"},()=>r,{get iconNode(){return n}}))}var tSt=new Set(["$$slots","$$events","$$legacy"]);function rSt(t,e){let r=Tt(e,tSt);const n=[["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M12 2v2"}],["path",{d:"M12 20v2"}],["path",{d:"m4.93 4.93 1.41 1.41"}],["path",{d:"m17.66 17.66 1.41 1.41"}],["path",{d:"M2 12h2"}],["path",{d:"M20 12h2"}],["path",{d:"m6.34 17.66-1.41 1.41"}],["path",{d:"m19.07 4.93-1.41 1.41"}]];Mr(t,Rt({name:"sun"},()=>r,{get iconNode(){return n}}))}var nSt=new Set(["$$slots","$$events","$$legacy"]);function BL(t,e){let r=Tt(e,nSt);const n=[["path",{d:"M12 19h8"}],["path",{d:"m4 17 6-6-6-6"}]];Mr(t,Rt({name:"terminal"},()=>r,{get iconNode(){return n}}))}var iSt=new Set(["$$slots","$$events","$$legacy"]);function aSt(t,e){let r=Tt(e,iSt);const n=[["path",{d:"M10 2h4"}],["path",{d:"M4.6 11a8 8 0 0 0 1.7 8.7 8 8 0 0 0 8.7 1.7"}],["path",{d:"M7.4 7.4a8 8 0 0 1 10.3 1 8 8 0 0 1 .9 10.2"}],["path",{d:"m2 2 20 20"}],["path",{d:"M12 12v-2"}]];Mr(t,Rt({name:"timer-off"},()=>r,{get iconNode(){return n}}))}var sSt=new Set(["$$slots","$$events","$$legacy"]);function Np(t,e){let r=Tt(e,sSt);const n=[["path",{d:"M10 11v6"}],["path",{d:"M14 11v6"}],["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"}],["path",{d:"M3 6h18"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"}]];Mr(t,Rt({name:"trash-2"},()=>r,{get iconNode(){return n}}))}var oSt=new Set(["$$slots","$$events","$$legacy"]);function u1(t,e){let r=Tt(e,oSt);const n=[["path",{d:"m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"}],["path",{d:"M12 9v4"}],["path",{d:"M12 17h.01"}]];Mr(t,Rt({name:"triangle-alert"},()=>r,{get iconNode(){return n}}))}var lSt=new Set(["$$slots","$$events","$$legacy"]);function PJ(t,e){let r=Tt(e,lSt);const n=[["path",{d:"M12 3v12"}],["path",{d:"m17 8-5-5-5 5"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"}]];Mr(t,Rt({name:"upload"},()=>r,{get iconNode(){return n}}))}var cSt=new Set(["$$slots","$$events","$$legacy"]);function y4(t,e){let r=Tt(e,cSt);const n=[["path",{d:"m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5"}],["rect",{x:"2",y:"6",width:"14",height:"12",rx:"2"}]];Mr(t,Rt({name:"video"},()=>r,{get iconNode(){return n}}))}var uSt=new Set(["$$slots","$$events","$$legacy"]);function gH(t,e){let r=Tt(e,uSt);const n=[["circle",{cx:"7",cy:"12",r:"3"}],["path",{d:"M10 9v6"}],["circle",{cx:"17",cy:"12",r:"3"}],["path",{d:"M14 7v8"}],["path",{d:"M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1"}]];Mr(t,Rt({name:"whole-word"},()=>r,{get iconNode(){return n}}))}var dSt=new Set(["$$slots","$$events","$$legacy"]);function rx(t,e){let r=Tt(e,dSt);const n=[["path",{d:"M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.106-3.105c.32-.322.863-.22.983.218a6 6 0 0 1-8.259 7.057l-7.91 7.91a1 1 0 0 1-2.999-3l7.91-7.91a6 6 0 0 1 7.057-8.259c.438.12.54.662.219.984z"}]];Mr(t,Rt({name:"wrench"},()=>r,{get iconNode(){return n}}))}var hSt=new Set(["$$slots","$$events","$$legacy"]);function Jc(t,e){let r=Tt(e,hSt);const n=[["path",{d:"M18 6 6 18"}],["path",{d:"m6 6 12 12"}]];Mr(t,Rt({name:"x"},()=>r,{get iconNode(){return n}}))}var fSt=new Set(["$$slots","$$events","$$legacy"]);function M8(t,e){let r=Tt(e,fSt);const n=[["path",{d:"M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z"}]];Mr(t,Rt({name:"zap"},()=>r,{get iconNode(){return n}}))}var pSt=new Set(["$$slots","$$events","$$legacy"]);function gSt(t,e){let r=Tt(e,pSt);const n=[["circle",{cx:"11",cy:"11",r:"8"}],["line",{x1:"21",x2:"16.65",y1:"21",y2:"16.65"}],["line",{x1:"11",x2:"11",y1:"8",y2:"14"}],["line",{x1:"8",x2:"14",y1:"11",y2:"11"}]];Mr(t,Rt({name:"zoom-in"},()=>r,{get iconNode(){return n}}))}var mSt=new Set(["$$slots","$$events","$$legacy"]);function _St(t,e){let r=Tt(e,mSt);const n=[["circle",{cx:"11",cy:"11",r:"8"}],["line",{x1:"21",x2:"16.65",y1:"21",y2:"16.65"}],["line",{x1:"8",x2:"14",y1:"11",y2:"11"}]];Mr(t,Rt({name:"zoom-out"},()=>r,{get iconNode(){return n}}))}const rIe="border border-border/30 focus-within:border-border dark:border-border/20 dark:focus-within:border-border",nIe=` + bg-muted/60 dark:bg-muted/75 + ${rIe} + shadow-sm + outline-none + text-foreground +`,vSt=` + bg-background + border border-border/30 dark:border-border/20 + shadow-sm backdrop-blur-lg! + rounded-t-lg! +`,ySt="max-h-80",bSt='[data-slot="input-area"] textarea, [data-slot="input-area"] [contenteditable="true"]',vr="h-4 w-4",iIe="h-4 w-4 animate-spin";function Y1e(t,e){return e?`....${t.slice(-e)}`:"[redacted]"}const SSt=/\[Attachment saved: ([^\]]+)\]/,ESt=/^[[{]/,TSt=/^(```|~~~)/m,CSt=/^#{1,6}\s+\S/,wSt=/^>\s+\S/,xSt=/^\s*[-*+]\s+\S/,ASt=/^\s*\d+[.)]\s+\S/,RSt=/\[[^\]\n]+\]\([^)\s]+\)/,NSt=/\*\*[^*\n]+\*\*|__[^_\n]+__/,OSt=/^\s*\|?[\s:|-]+\|?\s*$/,W1e=`--- +`,ISt=/Total matches:\s*(\d+)/,aIe=" - ",K1e={enabled:!0,maxTurns:100},UL={END:"",START:""},kSt={START:"<<>>"},Yb={AGENTIC_TOOL_CALL_OPEN:/\n*<<>>[\s\S]*$/,COMPLETED_TOOL_CALL:/<<>>\n<<>>\n<<>>([\s\S]*?)<<>>([\s\S]*?)<<>>/g,HAS_LEGACY_MARKERS:/<<<(?:AGENTIC_TOOL_CALL_START|reasoning_content_start)>>>/,REASONING_BLOCK:/<<>>[\s\S]*?<<>>/g,REASONING_EXTRACT:/<<>>([\s\S]*?)<<>>/,REASONING_OPEN:/<<>>[\s\S]*$/},k6={LIST:"/v1/models",LOAD:"/models/load",SSE:"/models/sse",UNLOAD:"/models/unload"},mH={COMPLETIONS:"./v1/chat/completions",CONTROL:"./v1/chat/completions/control"},j1e={LIST:"./slots"},BO={EXECUTE:"/tools",LIST:"/tools"},DSt=2e3,_H={BASE:"./v1/stream",LOOKUP:"./v1/streams/lookup"},FJ="/cors-proxy",MSt={},VU=MSt?.VITE_PUBLIC_APP_NAME||"llama-ui",LSt="PDF File",PSt="MCP Prompt",FSt="MCP Resource",Id="LlamaUi",b4="LlamaCppWebui",X1e="LlamacppWebui",D6=`${Id}.alwaysAllowedTools`,$u=`${Id}.config`,BSt=`${Id}.disabledTools`,Q1e=`${Id}.disabledToolKeys`,BJ=`${Id}.favoriteModels`,Z1e=`${Id}.reasoningEffortDefault`,UJ=`${Id}.userOverrides`,J1e=`${Id}.dismissedRecommendedMcpServers`,USt=`${Id}.streamResume.`,$St=`${b4}.alwaysAllowedTools`,GSt=`${b4}.config`,zSt=`${b4}.disabledTools`,qSt=`${b4}.favoriteModels`,HSt=`${b4}.userOverrides`,VSt={[D6]:$St,[$u]:GSt,[BSt]:zSt,[BJ]:qSt,[UJ]:HSt},gn={conversations:"conversations",messages:"messages"},e_e={conversations:"id, lastModified, currNode, name",messages:"id, convId, type, role, timestamp, parent, children"},$J={[gn.conversations]:e_e.conversations,[gn.messages]:e_e.messages};is.DEFAULT+"",is.HIGH+"",is.LOW+"",is.MAX+"",is.MEDIUM+"",is.OFF+"";const YSt=[{label:"Default",value:is.DEFAULT},{label:"Off",value:is.OFF},{label:"Low",value:is.LOW},{label:"Medium",value:is.MEDIUM},{label:"High",value:is.HIGH},{hasInfo:!0,label:"Max",value:is.MAX}],sIe={[is.HIGH]:8192,[is.LOW]:512,[is.MAX]:-1,[is.MEDIUM]:2048},UO=[{description:"Search the web and fetch full page content as clean markdown.",iconUrl:"/recommended-mcp/exa.ico",id:"exa",name:"Exa",url:"https://mcp.exa.ai/mcp"},{description:"Search and browse AI models, datasets, spaces, and docs on the Hugging Face Hub.",iconUrl:"/recommended-mcp/huggingface.ico",id:"huggingface",name:"Hugging Face",url:"https://huggingface.co/mcp"},{description:"Search repositories, issues, pull requests and interact with code on GitHub.",iconUrlDark:"/recommended-mcp/github-dark.png",iconUrlLight:"/recommended-mcp/github-light.png",id:"github",name:"GitHub",needsAuthorization:!0,url:"https://api.githubcopilot.com/mcp"},{description:"Browse up-to-date documentation and code examples for libraries and frameworks.",iconUrl:"/recommended-mcp/context7.png",id:"context7",name:"Context7",url:"https://mcp.context7.com/mcp"}],yA={[pi.AUDIO]:$le,[pi.IMAGE]:Ule,[pi.PDF]:v4,[pi.TEXT]:sp,[pi.VIDEO]:y4},WSt='',KSt='',jSt='',oIe=[{action:Hc.FILE_UPLOAD,class:"images-button",disabledTooltip:"Image processing requires a vision model",enabledWhen:d0.HAS_VISION_MODALITY,icon:yA.image,id:u0.IMAGES,label:"Images"},{action:Hc.FILE_UPLOAD,class:"audio-button",disabledTooltip:"Audio files processing requires an audio model",enabledWhen:d0.HAS_AUDIO_MODALITY,icon:yA.audio,id:u0.AUDIO,label:"Audio Files"},{action:Hc.FILE_UPLOAD,class:"video-button",disabledTooltip:"Video files processing requires a video model",enabledWhen:d0.HAS_VIDEO_MODALITY,icon:yA.video,id:u0.VIDEO,label:"Video Files"},{action:Hc.FILE_UPLOAD,enabledWhen:d0.ALWAYS,icon:yA.text,id:u0.TEXT,label:"Text Files"},{action:Hc.FILE_UPLOAD,disabledTooltip:"PDFs will be converted to text. Image-based PDFs may not work properly.",enabledWhen:d0.ALWAYS,hasEnabledTooltip:!0,icon:yA.pdf,id:u0.PDF,label:"PDF Files"}];Hc.SYSTEM_PROMPT_CLICK,d0.ALWAYS,u0.SYSTEM_MESSAGE,Hc.MCP_PROMPT_CLICK,d0.ALWAYS,u0.MCP_PROMPT,kle.HAS_MCP_PROMPTS_SUPPORT;Hc.MCP_RESOURCES_CLICK,d0.ALWAYS,u0.MCP_RESOURCES,kle.HAS_MCP_RESOURCES_SUPPORT;const $L="Add files, prompts, tools or MCP Servers",XSt=100,QSt=10,ZSt=1e3,JSt=10,eEt=64,tEt=32,rEt=64,t_e=128,r_e=8,nEt=8,iEt=150,aEt=[80,75],sEt={maxAbsoluteNullBytes:2,prefixLength:1024*10,suspiciousCharThresholdRatio:.15},oEt={[rn.EDIT_FILE]:{icon:Rbt,label:"Edit file",source:Jn.BUILTIN},[rn.EXEC_SHELL_COMMAND]:{icon:BL,label:"Run command",source:Jn.BUILTIN},[rn.FILE_GLOB_SEARCH]:{icon:kbt,label:"Search files",source:Jn.BUILTIN},[rn.GET_DATETIME]:{icon:oT,label:"Current time",source:Jn.BUILTIN},[rn.GET_INFO]:{icon:A0,label:"Runtime info",source:Jn.BUILTIN},[rn.GREP_SEARCH]:{icon:P2t,label:"Search in files",source:Jn.BUILTIN},[rn.READ_FILE]:{icon:sp,label:"Read file",source:Jn.BUILTIN},[rn.RUN_JAVASCRIPT]:{icon:Mle,label:"Run JavaScript",source:Jn.FRONTEND},[rn.WRITE_FILE]:{icon:Obt,label:"Write file",source:Jn.BUILTIN}};function YU(t){return t?oEt[t]??null:null}const lEt=[{function:{description:"Read file contents from the project directory",name:rn.READ_FILE,parameters:{properties:{end_line:{description:"1-indexed ending line (inclusive)",type:"integer"},path:{description:"Path to the file to read",type:"string"},start_line:{description:"1-indexed starting line (inclusive)",type:"integer"}},required:["path"],type:"object"}},type:ud.FUNCTION},{function:{description:"Write or create a file in the project directory",name:rn.WRITE_FILE,parameters:{properties:{content:{description:"File content to write",type:"string"},path:{description:"Path to the file to write",type:"string"}},required:["path","content"],type:"object"}},type:ud.FUNCTION},{function:{description:"Surgically edit an existing file by replacing a contiguous text block",name:rn.EDIT_FILE,parameters:{properties:{new_str:{description:"New replacement text",type:"string"},old_str:{description:"Exact text to replace",type:"string"},path:{description:"Path to the file to edit",type:"string"}},required:["path","old_str","new_str"],type:"object"}},type:ud.FUNCTION},{function:{description:"Search files and directories matching a glob pattern",name:rn.FILE_GLOB_SEARCH,parameters:{properties:{limit:{description:"Maximum number of results to return",type:"integer"},path:{description:"Directory to search in (default: .)",type:"string"},pattern:{description:"Glob pattern to match against (e.g. **/*.ts)",type:"string"},type:{description:"Entry type to match: file, dir, or all",type:"string"}},type:"object"}},type:ud.FUNCTION},{function:{description:"Search for text or regular expressions across files in the project",name:rn.GREP_SEARCH,parameters:{properties:{case_sensitive:{description:"Whether search should be case sensitive",type:"boolean"},path:{description:"Directory or file to search in",type:"string"},query:{description:"Text or regex search query",type:"string"}},required:["query"],type:"object"}},type:ud.FUNCTION},{function:{description:"Run a shell command on the server and capture its output",name:rn.EXEC_SHELL_COMMAND,parameters:{properties:{command:{description:"Shell command string to execute",type:"string"},timeout:{description:"Timeout in seconds (default: 10)",type:"integer"}},required:["command"],type:"object"}},type:ud.FUNCTION},{function:{description:"Get the current date, time, and timezone information",name:rn.GET_DATETIME,parameters:{properties:{},type:"object"}},type:ud.FUNCTION},{function:{description:"Get runtime, operating system, and hardware host environment information",name:rn.GET_INFO,parameters:{properties:{},type:"object"}},type:ud.FUNCTION}],lIe=300*1e3,cEt=100,uEt=600*1e3,dEt=50,hEt=50,fEt=300*1e3,pEt=10,gEt=1800*1e3,mEt=0,_Et=` + +`,vEt='"',yEt="/",vH="__new_chat__",GL="*",cIe="Set working directory",n_e="[",i_e="]",bEt="*?[]",GJ="\\",SEt=/^[A-Za-z]:/,EEt=/^[A-Za-z]:\/?/,TEt=/^\/\/[^/]+\/[^/]+\/?/,uIe=180,CEt=100,wEt=20,xEt=6,dIe=1,AEt=4,REt=20,NEt=32,zJ=10;function OEt(t){return[{action:Bg.PROMPT,description:"Insert an MCP prompt",disabled:!t.hasPrompts(),name:"prompt"},{action:Bg.CWD,description:cIe,disabled:!t.hasCwdTools(),keywords:["current working directory"],name:"cwd"},{action:Bg.MODEL,description:"Select model",disabled:!t.showModelSelector,name:"model"}]}const Sb={API_KEY:"--api-key",MCP_PROXY:"--ui-mcp-proxy",TOOLS:"--tools"},hIe="code-block-scroll-container",IEt="code-block-wrapper",fIe="code-block-header",kEt="code-block-actions",DEt="code-language",MEt="copy-code-btn",LEt="preview-code-btn",PEt="relative",Na=` +`,WU="text",FEt=/^(\w*)\n?/,BEt=/&/g,UEt=//g,a_e=/^```|\n```/g,pIe=/^(?:[ \t]*\n)+/,gIe=/(?:\n[ \t]*)+$/,KU=/[\\/]/,mIe=/^text:/,GEt="chat-message-edit",zEt="chat-actions",qEt="chat-settings-config",HEt={END_REASONING:"reasoning_end"},AD=1e3,s_e=60,o_e=3600,VEt=1,YEt=10,l_e="0s",_Ie=256,vIe=8192,WEt=/[\x00-\x1F\x7F]/g,KEt=/[\x00-\x08\x0A-\x0D\x0E-\x1F\x7F]/g,jEt=/(```[\s\S]*?```|`[^`\n]+`)/g,XEt=new RegExp("(```[\\S\\s]*?```|`.*?`)|(?\s*)/,nTt=/<>/g,iTt=/<>/g,aTt=/\$(?=\d)/g,sTt=new RegExp("(\\$\\$[\\s\\S]*?\\$\\$|(? ${Sb.API_KEY} option for the server.`,key:hr.API_KEY,label:"API Key",section:fn.GENERAL,type:En.INPUT},{defaultValue:"",help:"The starting message that defines how model should behave.",key:hr.SYSTEM_MESSAGE,label:"System Message",section:fn.GENERAL,type:En.TEXTAREA},{defaultValue:2500,help:"On pasting long text, it will be converted to a file. You can control the file length by setting the value of this parameter. Value 0 means disable.",key:hr.PASTE_LONG_TEXT_TO_FILE_LEN,label:"Paste long text to file length",section:fn.GENERAL,type:En.INPUT},{defaultValue:!0,help:"Use Enter to send messages and Shift + Enter for new lines. When disabled, use Ctrl/Cmd + Enter.",key:hr.SEND_ON_ENTER,label:"Send message on Enter",section:fn.GENERAL,type:En.CHECKBOX},{defaultValue:!1,help:"Automatically show microphone button instead of send button when textarea is empty for models with audio modality support.",isExperimental:!0,key:hr.AUTO_MIC_ON_EMPTY,label:"Show microphone on empty input",section:fn.GENERAL,type:En.CHECKBOX},{defaultValue:!1,help:'Enable "Continue" button for assistant messages, including reasoning models.',isExperimental:!0,key:hr.ENABLE_CONTINUE_GENERATION,label:'Enable "Continue" button',section:fn.GENERAL,type:En.CHECKBOX},{...NCt,defaultValue:!0,help:"Choose how conversation titles are generated. The first non-empty line uses a fast deterministic rule; the LLM option uses a model-generated title from the first message exchange.",key:hr.TITLE_GENERATION_USE_FIRST_LINE,label:"Conversation title"},{defaultValue:Iy.DEFAULT_PROMPT,dependsOn:hr.TITLE_GENERATION_USE_LLM,help:"Optional template for the title generation prompt. Use {{USER}} for the user message and {{ASSISTANT}} for the assistant message.",key:hr.TITLE_GENERATION_PROMPT,label:"LLM title generation prompt",section:fn.GENERAL,type:En.TEXTAREA},{defaultValue:!1,help:"When copying a message with text attachments, combine them into a single plain text string instead of a special format that can be pasted back as attachments.",key:hr.COPY_TEXT_ATTACHMENTS_AS_PLAIN_TEXT,label:"Copy text attachments as plain text",section:fn.GENERAL,type:En.CHECKBOX},{defaultValue:!1,help:"Parse PDF as image instead of text. Automatically falls back to text processing for non-vision models.",key:hr.PDF_AS_IMAGE,label:"Parse PDF as image",section:fn.GENERAL,type:En.CHECKBOX},{defaultValue:0,help:"Images larger than this will be resized before sending to server. Set to 0 to disable.",key:hr.MAX_IMAGE_RESOLUTION,label:"Maximum image resolution (megapixels)",section:fn.GENERAL,type:En.INPUT}],slug:fn.GENERAL,title:Yf.GENERAL},[fn.PENALTIES]:{icon:u1,settings:[{defaultValue:void 0,help:"Last n tokens to consider for penalizing repetition",key:hr.REPEAT_LAST_N,label:"Repeat last N",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.REPEAT_LAST_N},type:En.INPUT},{defaultValue:void 0,help:"Controls the repetition of token sequences in the generated text",key:hr.REPEAT_PENALTY,label:"Repeat penalty",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.REPEAT_PENALTY},type:En.INPUT},{defaultValue:void 0,help:"Limits tokens based on whether they appear in the output or not.",key:hr.PRESENCE_PENALTY,label:"Presence penalty",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.PRESENCE_PENALTY},type:En.INPUT},{defaultValue:void 0,help:"Limits tokens based on how often they appear in the output.",key:hr.FREQUENCY_PENALTY,label:"Frequency penalty",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.FREQUENCY_PENALTY},type:En.INPUT},{defaultValue:void 0,help:"DRY sampling reduces repetition in generated text even across long contexts. This parameter sets the DRY sampling multiplier.",key:hr.DRY_MULTIPLIER,label:"DRY multiplier",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.DRY_MULTIPLIER},type:En.INPUT},{defaultValue:void 0,help:"DRY sampling reduces repetition in generated text even across long contexts. This parameter sets the DRY sampling base value.",key:hr.DRY_BASE,label:"DRY base",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.DRY_BASE},type:En.INPUT},{defaultValue:void 0,help:"DRY sampling reduces repetition in generated text even across long contexts. This parameter sets the allowed length for DRY sampling.",key:hr.DRY_ALLOWED_LENGTH,label:"DRY allowed length",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.DRY_ALLOWED_LENGTH},type:En.INPUT},{defaultValue:void 0,help:"DRY sampling reduces repetition in generated text even across long contexts. This parameter sets DRY penalty for the last n tokens.",key:hr.DRY_PENALTY_LAST_N,label:"DRY penalty last N",section:fn.PENALTIES,sync:{paramType:eo.NUMBER,serverKey:hr.DRY_PENALTY_LAST_N},type:En.INPUT}],slug:fn.PENALTIES,title:Yf.PENALTIES},[fn.SAMPLING]:{icon:qbt,settings:[{defaultValue:void 0,help:"Controls the randomness of the generated text by affecting the probability distribution of the output tokens. Higher = more random, lower = more focused.",key:hr.TEMPERATURE,label:"Temperature",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.TEMPERATURE},type:En.INPUT},{defaultValue:void 0,help:"Addon for the temperature sampler. The added value to the range of dynamic temperature, which adjusts probabilities by entropy of tokens.",key:hr.DYNATEMP_RANGE,label:"Dynamic temperature range",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.DYNATEMP_RANGE},type:En.INPUT},{defaultValue:void 0,help:"Addon for the temperature sampler. Smoothes out the probability redistribution based on the most probable token.",key:hr.DYNATEMP_EXPONENT,label:"Dynamic temperature exponent",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.DYNATEMP_EXPONENT},type:En.INPUT},{defaultValue:void 0,help:"Keeps only k top tokens.",key:hr.TOP_K,label:"Top K",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.TOP_K},type:En.INPUT},{defaultValue:void 0,help:"Limits tokens to those that together have a cumulative probability of at least p",key:hr.TOP_P,label:"Top P",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.TOP_P},type:En.INPUT},{defaultValue:void 0,help:"Limits tokens based on the minimum probability for a token to be considered, relative to the probability of the most likely token.",key:hr.MIN_P,label:"Min P",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.MIN_P},type:En.INPUT},{defaultValue:void 0,help:"XTC sampler cuts out top tokens; this parameter controls the chance of cutting tokens at all. 0 disables XTC.",key:hr.XTC_PROBABILITY,label:"XTC probability",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.XTC_PROBABILITY},type:En.INPUT},{defaultValue:void 0,help:"XTC sampler cuts out top tokens; this parameter controls the token probability that is required to cut that token.",key:hr.XTC_THRESHOLD,label:"XTC threshold",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.XTC_THRESHOLD},type:En.INPUT},{defaultValue:void 0,help:"Sorts and limits tokens based on the difference between log-probability and entropy.",key:hr.TYP_P,label:"Typical P",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.TYP_P},type:En.INPUT},{defaultValue:void 0,help:"The maximum number of token per output. Use -1 for infinite (no limit).",key:hr.MAX_TOKENS,label:"Max tokens",section:fn.SAMPLING,sync:{paramType:eo.NUMBER,serverKey:hr.MAX_TOKENS},type:En.INPUT},{defaultValue:"",help:'The order at which samplers are applied, in simplified way. Default is "top_k;typ_p;top_p;min_p;temperature": top_k->typ_p->top_p->min_p->temperature',key:hr.SAMPLERS,label:"Samplers",section:fn.SAMPLING,sync:{paramType:eo.STRING,serverKey:hr.SAMPLERS},type:En.INPUT},{defaultValue:!1,help:"Enable backend-based samplers. When enabled, supported samplers run on the accelerator backend for faster sampling.",key:hr.BACKEND_SAMPLING,label:"Backend sampling",section:fn.SAMPLING,type:En.CHECKBOX}],slug:fn.SAMPLING,title:Yf.SAMPLING}},OCt=[{defaultValue:!0,help:"Display the system message at the top of each conversation.",key:hr.SHOW_SYSTEM_MESSAGE,label:"Show system message",type:En.CHECKBOX},{defaultValue:"[]",help:"Configure MCP servers as a JSON list. Use the form in the MCP Client settings section to edit.",key:hr.MCP_SERVERS,label:"MCP servers",type:En.INPUT},{defaultValue:!1,help:"Counterpart of the conversation title radio; stored and synced without a dedicated UI field.",key:hr.TITLE_GENERATION_USE_LLM,label:"Generate title with LLM",type:En.CHECKBOX}];function P8(){const t=[];for(const e of Object.values(kIe))t.push(...e.settings);return t.push(...OCt),t}const uu=Object.fromEntries(P8().map(t=>[t.key,t.defaultValue])),Vp=Object.fromEntries(P8().map(t=>[t.key,t.help])),SA=[...Object.values(kIe).map(t=>({fields:t.settings.map(e=>({dependsOn:e.dependsOn,help:e.help,isExperimental:e.isExperimental,isPositiveInteger:e.isPositiveInteger,key:e.key,label:e.label,max:e.max,min:e.min,options:e.options,placeholder:e.placeholder,radioOptions:e.radioOptions,type:e.type})),icon:t.icon,slug:t.slug,title:t.title})),...xCt],ICt=P8().filter(t=>t.type===En.INPUT&&typeof t.defaultValue!="string").map(t=>t.key),kCt=P8().filter(t=>t.isPositiveInteger).map(t=>t.key),GO=P8().filter(t=>t.sync!==void 0).map(t=>({canSync:!0,key:t.key,serverKey:t.sync.serverKey,type:t.sync.paramType})),DIe=Sa.START,DCt=3e3,MCt={[MR.MP3]:{extensions:[LR.MP3],mimeTypes:[Ua.MP3_MPEG,Ua.MP3]},[MR.WAV]:{extensions:[LR.WAV],mimeTypes:[Ua.WAV]}},LCt={[NJ.MP4]:{extensions:[OJ.MP4],mimeTypes:[PR.MP4]},[NJ.OGG]:{extensions:[OJ.OGG],mimeTypes:[PR.OGG]}},PCt={[Ry.GIF]:{extensions:[dc.GIF],mimeTypes:[Zi.GIF]},[Ry.HEIC]:{extensions:[dc.HEIC,dc.HEIF],mimeTypes:[Zi.HEIC,Zi.HEIF]},[Ry.JPEG]:{extensions:[dc.JPG,dc.JPEG],mimeTypes:[Zi.JPEG]},[Ry.PNG]:{extensions:[dc.PNG],mimeTypes:[Zi.PNG]},[Ry.SVG]:{extensions:[dc.SVG],mimeTypes:[Zi.SVG]},[Ry.WEBP]:{extensions:[dc.WEBP],mimeTypes:[Zi.WEBP]}},FCt={[VOe.PDF]:{extensions:[Dle.PDF],mimeTypes:[jg.PDF]}},BCt={[mi.ASCIIDOC]:{extensions:[Lr.ADOC],mimeTypes:[Or.ASCIIDOC]},[mi.BIBTEX]:{extensions:[Lr.BIB],mimeTypes:[Or.BIBTEX]},[mi.CPP]:{extensions:[Lr.CPP,Lr.C,Lr.H,Lr.HPP],mimeTypes:[Or.CPP_SRC,Or.CPP_HDR,Or.C_SRC,Or.C_HDR]},[mi.CSHARP]:{extensions:[Lr.CS],mimeTypes:[Or.CSHARP]},[mi.CSS]:{extensions:[Lr.CSS],mimeTypes:[Or.CSS]},[mi.CSV]:{extensions:[Lr.CSV],mimeTypes:[Or.CSV]},[mi.CUDA]:{extensions:[Lr.CU,Lr.CUH],mimeTypes:[Or.CUDA]},[mi.DART]:{extensions:[Lr.DART],mimeTypes:[Or.DART]},[mi.GO]:{extensions:[Lr.GO],mimeTypes:[Or.GO]},[mi.HASKELL]:{extensions:[Lr.HS],mimeTypes:[Or.HASKELL]},[mi.HTML]:{extensions:[Lr.HTML,Lr.HTM],mimeTypes:[Or.HTML]},[mi.JAVA]:{extensions:[Lr.JAVA],mimeTypes:[Or.JAVA]},[mi.JAVASCRIPT]:{extensions:[Lr.JS],mimeTypes:[Or.JAVASCRIPT,Or.JAVASCRIPT_APP]},[mi.JSON]:{extensions:[Lr.JSON],mimeTypes:[Or.JSON]},[mi.JSX]:{extensions:[Lr.JSX],mimeTypes:[Or.JSX]},[mi.KOTLIN]:{extensions:[Lr.KT],mimeTypes:[Or.KOTLIN]},[mi.LATEX]:{extensions:[Lr.TEX],mimeTypes:[Or.LATEX,Or.TEX,Or.TEX_APP]},[mi.LOG]:{extensions:[Lr.LOG],mimeTypes:[Or.PLAIN]},[mi.MARKDOWN]:{extensions:[Lr.MD],mimeTypes:[Or.MARKDOWN]},[mi.PHP]:{extensions:[Lr.PHP],mimeTypes:[Or.PHP]},[mi.PLAIN_TEXT]:{extensions:[Lr.TXT],mimeTypes:[Or.PLAIN]},[mi.PROPERTIES]:{extensions:[Lr.PROPERTIES],mimeTypes:[Or.PROPERTIES]},[mi.PYTHON]:{extensions:[Lr.PY],mimeTypes:[Or.PYTHON]},[mi.R]:{extensions:[Lr.R],mimeTypes:[Or.R]},[mi.RUBY]:{extensions:[Lr.RB],mimeTypes:[Or.RUBY]},[mi.RUST]:{extensions:[Lr.RS],mimeTypes:[Or.RUST]},[mi.SCALA]:{extensions:[Lr.SCALA],mimeTypes:[Or.SCALA]},[mi.SHELL]:{extensions:[Lr.SH,Lr.BAT],mimeTypes:[Or.SHELL,Or.BAT]},[mi.SQL]:{extensions:[Lr.SQL],mimeTypes:[Or.SQL]},[mi.SVELTE]:{extensions:[Lr.SVELTE],mimeTypes:[Or.SVELTE]},[mi.SWIFT]:{extensions:[Lr.SWIFT],mimeTypes:[Or.SWIFT]},[mi.TSX]:{extensions:[Lr.TSX],mimeTypes:[Or.TSX]},[mi.TYPESCRIPT]:{extensions:[Lr.TS],mimeTypes:[Or.TYPESCRIPT]},[mi.VUE]:{extensions:[Lr.VUE],mimeTypes:[Or.VUE]},[mi.VULKAN]:{extensions:[Lr.COMP],mimeTypes:[Or.PLAIN]},[mi.XML]:{extensions:[Lr.XML],mimeTypes:[Or.XML_TEXT,Or.XML_APP]},[mi.YAML]:{extensions:[Lr.YAML,Lr.YML],mimeTypes:[Or.YAML_TEXT,Or.YAML_APP]}},UCt=//gi,$Ct=/^
    ([\s\S]*)<\/ul>$/i,GCt=/
  • ([\s\S]*?)<\/li>/gi,bH="x-tool-cwd",SH={[Jn.BUILTIN]:"Built-in",[Jn.CUSTOM]:"JSON Schema",[Jn.FRONTEND]:"Browser"},L9={[Jn.BUILTIN]:"Built-in Tools",[Jn.CUSTOM]:"Custom Tools",[Jn.FRONTEND]:"Browser Tools"},jle=500;var zCt=im('');function F8(t,e){let r=ce(e,"class",3,""),n=ce(e,"style",3,"");var i=zCt();$e(()=>{Yt(i,0,dn(r())),zs(i,n())}),G(t,i)}const qCt=8,ND="System message",OD=PL,A_e=150,EH=50,R0="22rem",TH=[{icon:Hle,keys:["shift","cmd","o"],route:Sa.NEW_CHAT,tooltip:"New chat"},{icon:FL,keys:["cmd","k"],tooltip:"Search"},{activeRouteId:"/agents",activeUrlIncludes:"#/agents",icon:KOe,route:Sa.AGENTS,tooltip:"Agent Control Center"},{activeRouteId:"/mcp-servers",icon:F8,route:Sa.MCP_SERVERS,tooltip:"MCP Servers"},{activeUrlIncludes:"#/settings",icon:tx,route:`${Sa.SETTINGS}/general`,tooltip:"Settings"}],CH="://",jL=/\{([+#./;?&]?)([^}]+)\}/g,$1={FORM_CONTINUATION:"&",FORM_QUERY:"?",FRAGMENT:"#",LABEL:".",PATH_PARAM:";",PATH_SEGMENT:"/",RESERVED:"+"},Fh={COMMA:",",PERIOD:".",QUERY_CONTINUATION:"&",QUERY_PREFIX:"?",SEMICOLON:";",SLASH:"/"},MIe=/[*]$/,LIe=/:[\d]+$/,PIe=/^\/+/,HCt=/^data:(image\/[a-z0-9.\-+]+);base64/,bo=["com","net","org","gov","edu"],Am=[...bo,"mil"],VCt={ae:["co","net","org","gov","ac","sch"],ar:bo,au:[...Am,"id","asn","csiro"],bd:bo,bg:bo,br:[...Am,"art","eco","eng","inf","med","psi","tmp","etc","adm","adv","arq","bio","bmd","cim","cng","cnt","coop","ecn","esp","far","fm","fnd","fot","fst","g12","ggf","imb","ind","jor","jus","leg","lel","mat","mp","mus","not","ntr","odo","ppg","pro","psc","qsl","rec","slg","srv","trd","tur","tv","vet","vlog","wiki","zlg"],cn:Am,eg:bo,gr:bo,hk:bo,hr:bo,hu:["co","net","org","gov","edu"],id:[...Am,"co","go","or","web","sch"],il:["co","net","org","gov","ac","muni"],in:[...Am,"co","gen","ind","firm","ernet","nic"],jp:["ac","ad","co","ed","go","gr","lg","ne","or"],ke:["co","or","ne","go","ac","sc"],kr:[...Am,"co","go","or","ac","re"],lk:bo,mx:Am,my:Am,ng:bo,nz:[...Am,"co","gen","geek","kiwi","maori","school","govt","health","iwi","parliament"],ph:bo,pk:bo,pl:bo,ro:bo,rs:["co","net","org","gov","edu"],ru:bo,sa:bo,sg:[...bo,"per"],si:bo,th:["co","go","or","in","ac","mi","net"],tr:bo,tw:bo,ua:bo,uk:["co","org","net","ac","gov","mil","nhs","police","mod","ltd","plc","me","sch"],ve:bo,za:["co","org","net","web","law","mil"]},YCt={br:["nom","blog"],jp:["kobe","kyoto","nagoya","osaka","sapporo","sendai","tokyo","yokohama","aichi","akita","aomori","chiba","ehime","fukui","fukuoka","fukushima","gifu","gunma","hiroshima","hokkaido","hyogo","ibaraki","ishikawa","iwate","kagawa","kagoshima","kanagawa","kochi","kumamoto","mie","miyagi","miyazaki","nagano","nara","niigata","oita","okayama","okinawa","saga","saitama","shiga","shimane","shizuoka","tochigi","tokushima","tottori","toyama","wakayama","yamagata","yamaguchi","yamanashi"]};function FIe(t){const e=new Set;for(const[r,n]of Object.entries(t))for(const i of n)e.add(`${i}.${r}`);return e}const WCt=FIe(VCt),KCt=FIe(YCt),sx=/\/+$/,BIe=768;class Rm{static roundFloatingPoint(e){return e_(e)}static extractServerDefaults(e){const r={};if(e){for(const n of GO)if(n.canSync&&n.serverKey in e){const i=e[n.serverKey];i!==void 0&&(r[n.key]=this.roundFloatingPoint(i))}e.samplers&&Array.isArray(e.samplers)&&(r[hr.SAMPLERS]=e.samplers.join(";"))}return r}static mergeWithServerDefaults(e,r,n=new Set){const i={...e};for(const[a,s]of Object.entries(r))n.has(a)||(i[a]=this.roundFloatingPoint(s));return i}static getParameterInfo(e,r,n,i){const a=n[e]!==void 0,s=i.has(e),o=s?DJ.CUSTOM:DJ.DEFAULT;return{serverDefault:a?n[e]:void 0,source:o,userOverride:s?r:void 0,value:r}}static canSyncParameter(e){return GO.some(r=>r.key===e&&r.canSync)}static getSyncableParameterKeys(){return GO.filter(e=>e.canSync).map(e=>e.key)}static validateServerParameter(e,r){const n=GO.find(i=>i.key===e);if(!n)return!1;switch(n.type){case eo.NUMBER:return typeof r=="number"&&!isNaN(r);case eo.STRING:return typeof r=="string";case eo.BOOLEAN:return typeof r=="boolean";default:return!1}}static createParameterDiff(e,r){const n={};for(const i of this.getSyncableParameterKeys()){const a=e[i],s=r[i];s!==void 0&&(n[i]={current:a,differs:a!==s,server:s})}return n}}class UIe{static async fetch(e=!1){const r={};return e||(r.autoload="false"),R_e("./props",r,{authOnly:!0})}static async fetchForModel(e,r=!1){const n={model:e};return r||(n.autoload="false"),R_e("./props",n,{authOnly:!0})}}const Sg={HTTP:{ACCESS_DENIED:"Access denied",GENERIC:"Request failed",INTERNAL_ERROR:"Server error - check server logs",TEMPORARILY_UNAVAILABLE:"Server temporarily unavailable"},NETWORK:{GENERIC:"Failed to connect to server",NXDOMAIN:"Server not found - check server address",REFUSED:"Connection refused - server may be offline",TIMEOUT:"Request timed out",UNREACHABLE:"Server is not running or unreachable"}},jCt={401:Sg.HTTP.ACCESS_DENIED,403:Sg.HTTP.ACCESS_DENIED,500:Sg.HTTP.INTERNAL_ERROR,503:Sg.HTTP.TEMPORARILY_UNAVAILABLE};class Xle extends Error{status;constructor(e,r){super(e),this.name="ApiError",this.status=r}}async function $T(t,e={}){const{authOnly:r=!1,headers:n,...i}=e,s={...r?op():zT(),...n},o=t.startsWith(Uu.HTTP)||t.startsWith(Uu.HTTPS)?t:`${tl}${t}`;let l;try{l=await fetch(o,{...i,headers:s})}catch(u){throw new Error(GIe(u))}if(!l.ok){const u=await $Ie(l);throw new Xle(u,l.status)}return l.json()}async function R_e(t,e,r={}){const n=new URL(t,window.location.href);for(const[d,h]of Object.entries(e))h!=null&&n.searchParams.set(d,h);const{authOnly:i=!1,headers:a,...s}=r,l={...i?op():zT(),...a};let u;try{u=await fetch(n.toString(),{...s,headers:l})}catch(d){throw new Error(GIe(d))}if(!u.ok){const d=await $Ie(u);throw new Xle(d,u.status)}return u.json()}async function N_e(t,e,r={}){return $T(t,{body:JSON.stringify(e),method:"POST",...r})}async function $Ie(t){try{const r=await t.json();if(r?.error?.message)return r.error.message;if(r?.error&&typeof r.error=="string")return r.error;if(r?.message)return r.message}catch{}const e=jCt[t.status];return e||`${Sg.HTTP.GENERIC}: ${t.status} ${t.statusText}`}function GIe(t){let e;if(t instanceof Error){if(e=t.message,t.name==="TypeError"&&e.includes("fetch"))return Sg.NETWORK.UNREACHABLE}else e=String(t);return e.includes("ECONNREFUSED")?Sg.NETWORK.REFUSED:e.includes("ENOTFOUND")?Sg.NETWORK.NXDOMAIN:e.includes("ETIMEDOUT")?Sg.NETWORK.TIMEOUT:`${Sg.NETWORK.GENERIC} (${e})`}const XCt=1e3;class QCt{#e=Oe(null);get props(){return S(this.#e)}set props(e){X(this.#e,e,!0)}#t=Oe(!1);get loading(){return S(this.#t)}set loading(e){X(this.#t,e,!0)}#r=Oe(null);get error(){return S(this.#r)}set error(e){X(this.#r,e,!0)}#n=Oe(null);get status(){return S(this.#n)}set status(e){X(this.#n,e,!0)}#i=Oe(null);get role(){return S(this.#i)}set role(e){X(this.#i,e,!0)}fetchPromise=null;retryTimer=null;get defaultParams(){return this.props?.default_generation_settings?.params||null}get contextSize(){const e=this.props?.default_generation_settings?.n_ctx;return typeof e=="number"?e:null}get uiSettings(){return this.props?.ui_settings??this.props?.webui_settings}get isRouterMode(){return this.role===Ny.ROUTER}get isModelMode(){return this.role===Ny.MODEL}async fetch({background:e=!1}={}){if(this.fetchPromise)return this.fetchPromise;this.clearRetryTimer(),e||(this.loading=!0),this.status!==503&&(this.error=null);const r=(async()=>{try{const n=await UIe.fetch();this.props=n,this.error=null,this.status=null,this.detectRole(n)}catch(n){this.error=n instanceof Error?n.message:String(n),this.status=n instanceof Xle?n.status:null,console.error("Error fetching server properties:",n),this.status===503&&this.scheduleRetry()}finally{e||(this.loading=!1),this.fetchPromise=null}})();this.fetchPromise=r,await r}clear(){this.clearRetryTimer(),this.props=null,this.error=null,this.status=null,this.loading=!1,this.role=null,this.fetchPromise=null}scheduleRetry(){this.retryTimer||(this.retryTimer=setTimeout(()=>{this.retryTimer=null,this.fetch({background:!0})},XCt))}clearRetryTimer(){this.retryTimer&&(clearTimeout(this.retryTimer),this.retryTimer=null)}detectRole(e){const r=e?.role===Ny.ROUTER?Ny.ROUTER:Ny.MODEL;this.role!==r&&(this.role=r,console.info(`Server running in ${r===Ny.ROUTER?"ROUTER":"MODEL"} mode`))}}const $a=new QCt,ZCt=()=>$a.props,GT=()=>$a.loading,zR=()=>$a.error,JCt=()=>$a.status,ewt=()=>$a.contextSize,ls=()=>$a.isRouterMode;Zr({width:window.innerWidth});const Oa=new WNe(`max-width: ${BIe-1}px`),zIe=typeof window<"u"?window:void 0;function twt(t){let e=t.activeElement;for(;e?.shadowRoot;){const r=e.shadowRoot.activeElement;if(r===e)break;e=r}return e}let rwt=class{#e;#t;constructor(e={}){const{window:r=zIe,document:n=r?.document}=e;r!==void 0&&(this.#e=n,this.#t=Tv(i=>{const a=Bi(r,"focusin",i),s=Bi(r,"focusout",i);return()=>{a(),s()}}))}get current(){return this.#t?.(),this.#e?twt(this.#e):null}};new rwt;function nwt(t,e){switch(t){case"post":Kt(e);break;case"pre":uc(e);break}}function qIe(t,e,r,n={}){const{lazy:i=!1}=n;let a=!i,s=Array.isArray(t)?[]:void 0;nwt(e,()=>{const o=Array.isArray(t)?t.map(u=>u()):t();if(!a){a=!0,s=o;return}const l=zi(()=>r(o,s));return s=o,l})}function Qle(t,e,r){qIe(t,"post",e,r)}function iwt(t,e,r){qIe(t,"pre",e,r)}Qle.pre=iwt;function awt(t,e){switch(t){case"local":return e.localStorage;case"session":return e.sessionStorage}}class HIe{#e;#t;#r;#n;#i;#a=Oe(0);constructor(e,r,n={}){const{storage:i="local",serializer:a={serialize:JSON.stringify,deserialize:JSON.parse},syncTabs:s=!0,window:o=zIe}=n;if(this.#e=r,this.#t=e,this.#r=a,o===void 0)return;const l=awt(i,o);this.#n=l;const u=l.getItem(e);u!==null?this.#e=this.#o(u):this.#l(r),s&&i==="local"&&(this.#i=Tv(()=>Bi(o,"storage",this.#s)))}get current(){this.#i?.(),S(this.#a);const e=this.#o(this.#n?.getItem(this.#t))??this.#e,r=new WeakMap,n=i=>{if(i===null||i?.constructor.name==="Date"||typeof i!="object")return i;let a=r.get(i);return a||(a=new Proxy(i,{get:(s,o)=>(S(this.#a),n(Reflect.get(s,o))),set:(s,o,l)=>(X(this.#a,S(this.#a)+1),Reflect.set(s,o,l),this.#l(e),!0)}),r.set(i,a)),a};return n(e)}set current(e){this.#l(e),X(this.#a,S(this.#a)+1)}#s=e=>{e.key!==this.#t||e.newValue===null||(this.#e=this.#o(e.newValue),X(this.#a,S(this.#a)+1))};#o(e){try{return this.#r.deserialize(e)}catch(r){console.error(`Error when parsing "${e}" from persisted store "${this.#t}"`,r);return}}#l(e){try{e!=null&&this.#n?.setItem(this.#t,this.#r.serialize(e))}catch(r){console.error(`Error when writing value from persisted store "${this.#t}" to ${this.#n}`,r)}}}function O_e(t){return t.filter(e=>e.length>0)}const VIe={getItem:t=>null,setItem:(t,e)=>{}},B8=typeof document<"u";function swt(t){return typeof t=="function"}function owt(t){return t!==null&&typeof t=="object"}const qR=Symbol("box"),Zle=Symbol("is-writable");function lwt(t){return owt(t)&&qR in t}function cwt(t){return rl.isBox(t)&&Zle in t}function rl(t){let e=Oe(Zr(t));return{[qR]:!0,[Zle]:!0,get current(){return S(e)},set current(r){X(e,r,!0)}}}function uwt(t,e){const r=W(t);return e?{[qR]:!0,[Zle]:!0,get current(){return S(r)},set current(n){e(n)}}:{[qR]:!0,get current(){return t()}}}function dwt(t){return rl.isBox(t)?t:swt(t)?rl.with(t):rl(t)}function hwt(t){return Object.entries(t).reduce((e,[r,n])=>rl.isBox(n)?(rl.isWritableBox(n)?Object.defineProperty(e,r,{get(){return n.current},set(i){n.current=i}}):Object.defineProperty(e,r,{get(){return n.current}}),e):Object.assign(e,{[r]:n}),{})}function fwt(t){return rl.isWritableBox(t)?{[qR]:!0,get current(){return t.current}}:t}rl.from=dwt;rl.with=uwt;rl.flatten=hwt;rl.readonly=fwt;rl.isBox=lwt;rl.isWritableBox=cwt;function pwt(t,e){const r=RegExp(t,"g");return n=>{if(typeof n!="string")throw new TypeError(`expected an argument of type string, but got ${typeof n}`);return n.match(r)?n.replace(r,e):n}}const gwt=pwt(/[A-Z]/,t=>`-${t.toLowerCase()}`);function mwt(t){if(!t||typeof t!="object"||Array.isArray(t))throw new TypeError(`expected an argument of type object, but got ${typeof t}`);return Object.keys(t).map(e=>`${gwt(e)}: ${t[e]};`).join(` +`)}function _wt(t={}){return mwt(t).replace(` +`," ")}const vwt={position:"absolute",width:"1px",height:"1px",padding:"0",margin:"-1px",overflow:"hidden",clip:"rect(0, 0, 0, 0)",whiteSpace:"nowrap",borderWidth:"0",transform:"translateX(-100%)"};_wt(vwt);const ywt=typeof window<"u"?window:void 0;function bwt(t){let e=t.activeElement;for(;e?.shadowRoot;){const r=e.shadowRoot.activeElement;if(r===e)break;e=r}return e}let Swt=class{#e;#t;constructor(e={}){const{window:r=ywt,document:n=r?.document}=e;r!==void 0&&(this.#e=n,this.#t=Tv(i=>{const a=Bi(r,"focusin",i),s=Bi(r,"focusout",i);return()=>{a(),s()}}))}get current(){return this.#t?.(),this.#e?bwt(this.#e):null}};new Swt;const Eb=rl("mode-watcher-mode"),Tb=rl("mode-watcher-theme"),Ewt=["dark","light","system"];function VJ(t){return typeof t!="string"?!1:Ewt.includes(t)}class Twt{#e="system";#t=B8?localStorage:VIe;#r=this.#t.getItem(Eb.current);#n=VJ(this.#r)?this.#r:this.#e;#i=Oe(Zr(this.#a()));#a(e=this.#n){return new HIe(Eb.current,e,{serializer:{serialize:r=>r,deserialize:r=>VJ(r)?r:this.#e}})}constructor(){v8(()=>Qle.pre(()=>Eb.current,(e,r)=>{const n=S(this.#i).current;X(this.#i,this.#a(n),!0),r&&localStorage.removeItem(r)}))}get current(){return S(this.#i).current}set current(e){S(this.#i).current=e}}class Cwt{#e=void 0;#t=!0;#r=Oe(Zr(this.#e));#n=typeof window<"u"&&typeof window.matchMedia=="function"?new WNe("prefers-color-scheme: light"):{current:!1};query(){B8&&X(this.#r,this.#n.current?"light":"dark",!0)}tracking(e){this.#t=e}constructor(){v8(()=>{uc(()=>{this.#t&&this.query()})}),this.query=this.query.bind(this),this.tracking=this.tracking.bind(this)}get current(){return S(this.#r)}}const YJ=new Twt,WJ=new Cwt;class wwt{#e=B8?localStorage:VIe;#t=this.#e.getItem(Tb.current);#r=this.#t===null||this.#t===void 0?"":this.#t;#n=Oe(Zr(this.#i()));#i(e=this.#r){return new HIe(Tb.current,e,{serializer:{serialize:r=>typeof r!="string"?"":r,deserialize:r=>r}})}constructor(){v8(()=>Qle.pre(()=>Tb.current,(e,r)=>{const n=S(this.#n).current;X(this.#n,this.#i(n),!0),r&&localStorage.removeItem(r)}))}get current(){return S(this.#n).current}set current(e){S(this.#n).current=e}}const ID=new wwt;let I_e,k_e,D_e=!1,EA=null;function xwt(){return EA||(EA=document.createElement("style"),EA.appendChild(document.createTextNode(`* { + -webkit-transition: none !important; + -moz-transition: none !important; + -o-transition: none !important; + -ms-transition: none !important; + transition: none !important; + }`)),EA)}function YIe(t,e=!1){if(typeof document>"u")return;if(!D_e){D_e=!0,t();return}if(typeof window<"u"&&window.__vitest_worker__){t();return}clearTimeout(I_e),clearTimeout(k_e);const n=xwt(),i=()=>document.head.appendChild(n),a=()=>{n.parentNode&&document.head.removeChild(n)};function s(){t(),window.requestAnimationFrame(a)}if(typeof window.requestAnimationFrame<"u"){i(),e?s():window.requestAnimationFrame(()=>{s()});return}i(),I_e=window.setTimeout(()=>{t(),k_e=window.setTimeout(a,16)},16)}const b_=rl(void 0),XL=rl(!0),QL=rl(!1),KJ=rl([]),jJ=rl([]);function Awt(){const t=W(()=>{if(!B8)return;const e=YJ.current==="system"?WJ.current:YJ.current,r=O_e(KJ.current),n=O_e(jJ.current);function i(){const a=document.documentElement,s=document.querySelector('meta[name="theme-color"]');e==="light"?(r.length&&a.classList.remove(...r),n.length&&a.classList.add(...n),a.style.colorScheme="light",s&&b_.current&&s.setAttribute("content",b_.current.light)):(n.length&&a.classList.remove(...n),r.length&&a.classList.add(...r),a.style.colorScheme="dark",s&&b_.current&&s.setAttribute("content",b_.current.dark))}return XL.current?YIe(i,QL.current):i(),e});return{get current(){return S(t)}}}function Rwt(){const t=W(()=>{if(ID.current,!B8)return;function e(){document.documentElement.setAttribute("data-theme",ID.current)}return XL.current?YIe(e,zi(()=>QL.current)):e(),ID.current});return{get current(){return S(t)}}}const f2=Awt(),Nwt=Rwt();function cg(t){YJ.current=t}function Owt(t){ID.current=t}function Iwt({defaultMode:t="system",themeColors:e,darkClassNames:r=["dark"],lightClassNames:n=[],defaultTheme:i="",modeStorageKey:a="mode-watcher-mode",themeStorageKey:s="mode-watcher-theme"}){const o=document.documentElement,l=localStorage.getItem(a)??t,u=localStorage.getItem(s)??i,d=l==="light"||l==="system"&&window.matchMedia("(prefers-color-scheme: light)").matches;if(d?(r.length&&o.classList.remove(...r.filter(Boolean)),n.length&&o.classList.add(...n.filter(Boolean))):(n.length&&o.classList.remove(...n.filter(Boolean)),r.length&&o.classList.add(...r.filter(Boolean))),o.style.colorScheme=d?"light":"dark",e){const h=document.querySelector('meta[name="theme-color"]');h&&h.setAttribute("content",l==="light"?e.light:e.dark)}u&&(o.setAttribute("data-theme",u),localStorage.setItem(s,u)),localStorage.setItem(a,l)}var kwt=se('');function Dwt(t,e){at(e,!0);var r=Ae(),n=oe(r);{var i=a=>{var s=kwt();$e(()=>lr(s,"content",e.themeColors.dark)),G(a,s)};ve(n,a=>{e.themeColors&&a(i)})}G(t,r),st()}var Mwt=se(''),Lwt=se(" ",1);function Pwt(t,e){at(e,!0);let r=ce(e,"trueNonce",3,"");Y2("1funsus",n=>{var i=Lwt(),a=oe(i);{var s=l=>{var u=Mwt();$e(()=>lr(u,"content",e.themeColors.dark)),G(l,u)};ve(a,l=>{e.themeColors&&l(s)})}var o=ie(a,2);D_(o,()=>`(`+Iwt.toString()+")("+JSON.stringify(e.initConfig)+");<\/script>"),G(n,i)}),st()}function Fwt(t,e){at(e,!0);let r=ce(e,"track",3,!0),n=ce(e,"defaultMode",3,"system"),i=ce(e,"disableTransitions",3,!0),a=ce(e,"darkClassNames",19,()=>["dark"]),s=ce(e,"lightClassNames",19,()=>[]),o=ce(e,"defaultTheme",3,""),l=ce(e,"nonce",3,""),u=ce(e,"themeStorageKey",3,"mode-watcher-theme"),d=ce(e,"modeStorageKey",3,"mode-watcher-mode"),h=ce(e,"disableHeadScriptInjection",3,!1),f=ce(e,"synchronousModeChanges",3,!1);Eb.current=d(),Tb.current=u(),KJ.current=a(),jJ.current=s(),XL.current=i(),b_.current=e.themeColors,QL.current=f(),uc(()=>{QL.current=f()}),uc(()=>{XL.current=i()}),uc(()=>{b_.current=e.themeColors}),uc(()=>{KJ.current=a()}),uc(()=>{jJ.current=s()}),uc(()=>{Eb.current=d()}),uc(()=>{Tb.current=u()}),uc(()=>{f2.current,Eb.current,Tb.current,Nwt.current}),uo(()=>{WJ.tracking(r()),WJ.query();const y=localStorage.getItem(Eb.current);cg(VJ(y)?y:n());const E=localStorage.getItem(Tb.current);Owt(E||o())});const p={defaultMode:n(),themeColors:e.themeColors,darkClassNames:a(),lightClassNames:s(),defaultTheme:o(),modeStorageKey:d(),themeStorageKey:u()},g=W(()=>typeof window>"u"?l():"");var m=Ae(),_=oe(m);{var v=y=>{Dwt(y,{get themeColors(){return b_.current}})},b=y=>{Pwt(y,{get trueNonce(){return S(g)},get initConfig(){return p},get themeColors(){return b_.current}})};ve(_,y=>{h()?y(v):y(b,-1)})}G(t,m),st()}class Bwt{#e=Oe(Zr({...uu}));get config(){return S(this.#e)}set config(e){X(this.#e,e,!0)}#t=Oe(!1);get isInitialized(){return S(this.#t)}set isInitialized(e){X(this.#t,e,!0)}#r=Oe(Zr(new Set));get userOverrides(){return S(this.#r)}set userOverrides(e){X(this.#r,e,!0)}isFirstVisit=!1;getServerDefaults(){return Rm.extractServerDefaults($a.defaultParams)}constructor(){this.initialize()}initialize(){try{this.loadConfig(),this.migrateLegacyTheme(),cg(this.config[hr.THEME]),this.isInitialized=!0}catch(e){console.error("Failed to initialize settings store:",e)}}loadConfig(){try{const e=localStorage.getItem($u);this.isFirstVisit=e===null;const r=JSON.parse(e||"{}");this.config={...uu,...r},hr.SEND_ON_ENTER in r||Oa.current&&(this.config[hr.SEND_ON_ENTER]=!1);const n=JSON.parse(localStorage.getItem(UJ)||"[]");this.userOverrides=new Set(n)}catch(e){console.warn("Failed to parse config from localStorage, using defaults:",e),this.config={...uu},this.userOverrides=new Set}}migrateLegacyTheme(){const e=localStorage.getItem("theme");e&&(this.config[hr.THEME]=e,localStorage.removeItem("theme"),this.saveConfig(),cg(e))}updateConfig(e,r){if(this.config[e]=r,Rm.canSyncParameter(e)){const i=this.getServerDefaults()[e];if(i!==void 0){const a=e_(r),s=e_(i);a===s?this.userOverrides.delete(e):this.userOverrides.add(e)}}this.saveConfig()}updateMultipleConfig(e){Object.assign(this.config,e);const r=this.getServerDefaults();for(const[n,i]of Object.entries(e))if(Rm.canSyncParameter(n)){const a=r[n];if(a!==void 0){const s=e_(i),o=e_(a);s===o?this.userOverrides.delete(n):this.userOverrides.add(n)}}this.saveConfig()}saveConfig(){try{localStorage.setItem($u,JSON.stringify(this.config)),localStorage.setItem(UJ,JSON.stringify(Array.from(this.userOverrides)))}catch(e){console.error("Failed to save config to localStorage:",e)}}updateTheme(e){this.updateConfig(hr.THEME,e),cg(e)}resetConfig(){this.config={...uu},this.saveConfig()}resetTheme(){this.updateConfig(hr.THEME,uu[hr.THEME]),cg(uu[hr.THEME])}resetAll(){this.resetConfig(),this.resetTheme()}resetParameterToServerDefault(e){const r=this.getServerDefaults(),n=$a.uiSettings;n&&e in n?Nm(this.config,e,n[e]):r[e]!==void 0?Nm(this.config,e,""):e in uu&&Nm(this.config,e,ky(uu,e)),this.userOverrides.delete(e),this.saveConfig()}syncWithServerDefaults(){const e=this.getServerDefaults();if(Object.keys(e).length===0)return;const r=$a.uiSettings,n=new Set(r?Object.keys(r):[]);for(const[i,a]of Object.entries(e)){const s=ky(this.config,i),o=e_(s),l=e_(a);o===l&&(this.userOverrides.delete(i),!n.has(i)&&ky(uu,i)===void 0&&Nm(this.config,i,void 0))}if(r&&this.isFirstVisit){this.isFirstVisit=!1;for(const[i,a]of Object.entries(r))!this.userOverrides.has(i)&&a!==void 0&&(Nm(this.config,i,a),i===hr.THEME&&cg(a))}this.saveConfig(),console.log("User overrides after sync:",Array.from(this.userOverrides))}forceSyncWithServerDefaults(){const e=this.getServerDefaults(),r=$a.uiSettings;for(const n of Rm.getSyncableParameterKeys())r&&n in r?Nm(this.config,n,r[n]):e[n]!==void 0?Nm(this.config,n,""):n in uu&&Nm(this.config,n,ky(uu,n)),this.userOverrides.delete(n);for(const n of Object.keys(uu)){if(Rm.canSyncParameter(n))continue;const i=r&&n in r&&r[n]!==void 0?r[n]:ky(uu,n);Nm(this.config,n,i),n===hr.THEME&&cg(i),this.userOverrides.delete(n)}this.saveConfig()}getConfig(e){return this.config[e]}getAllConfig(){return{...this.config}}canSyncParameter(e){return Rm.canSyncParameter(e)}getParameterInfo(e){const r=this.getServerDefaults(),n=ky(this.config,e);return Rm.getParameterInfo(e,n??"",r,this.userOverrides)}getParameterDiff(){const e=this.getServerDefaults();if(Object.keys(e).length===0)return{};const r=A4t(this.config,Rm.getSyncableParameterKeys());return Rm.createParameterDiff(r,e)}clearAllUserOverrides(){this.userOverrides.clear(),this.saveConfig(),console.log("Cleared all user overrides")}exportSettings(e=!1){const r=e?{...this.config}:Object.fromEntries(Object.entries(this.config).filter(([n])=>n!=="apiKey"));if("mcpServers"in r&&!e)try{const i=JSON.parse(r.mcpServers).map(a=>(delete a.headers,a));r.mcpServers=JSON.stringify(i)}catch{delete r.mcpServers}return{config:r,timestamp:Date.now(),userOverrides:Array.from(this.userOverrides),version:1}}importSettings(e){if(!e||!e.config)throw new Error("Invalid settings data: missing config");this.config={...uu,...e.config},this.userOverrides=new Set(e.userOverrides??[]),this.saveConfig(),cg(this.config[hr.THEME]),console.log("Settings imported successfully")}}const nl=new Bwt,Vn=()=>nl.config,ZL=(t,e)=>nl.updateConfig(t,e);function op(){const e=Vn().apiKey?.toString().trim();return e?{[L8]:`${M_}${e}`}:{}}function zT(){return{[VL]:jg.JSON,...op()}}function wH(t,e,r){if(!t)return{};const n=new Headers(t),i={},a=new Set(Array.from(e??[],s=>s.toLowerCase()));for(const[s,o]of n.entries()){const l=s.toLowerCase(),u=l.startsWith(GR)?l.slice(GR.length):l,d=r?.get(l)??r?.get(u);d!==void 0?i[s]=Y1e(o,d):YL.has(l)||YL.has(u)||a.has(l)||a.has(u)?i[s]=Y1e(o):i[s]=o}return i}function Uwt(t,e){throw new lU(t,e)}async function WIe(t){const e=Vn().apiKey;try{const r={[VL]:jg.JSON};e&&(r[L8]=`${M_}${e}`);const n=await t(`${tl}/props`,{headers:r});if(!n.ok){if(n.status===401||n.status===403)throw Uwt(401,"Access denied");console.warn(`Server responded with status ${n.status} during API key validation`);return}}catch(r){if(r&&typeof r=="object"&&"status"in r)throw r;console.warn("Cannot connect to server for API key validation:",r)}}function Jle(t){return!!(t.attachment?.type===Ti.MCP_PROMPT||t.uploadedFile?.type===DR.MCP_PROMPT&&t.uploadedFile.mcpPrompt)}function ece(t){return t.attachment?.type===Ti.MCP_RESOURCE}function $wt(t){const e=nh(t.type);return e||rce(t.name)}function KIe(t){const{attachments:e=[],uploadedFiles:r=[]}=t,n=[];for(const i of r)n.push({id:i.id,isImage:$wt(i)===pi.IMAGE,isLoading:i.isLoading,loadError:i.loadError,name:i.name,preview:i.preview,size:i.size,textContent:i.textContent,uploadedFile:i});for(const[i,a]of e.entries()){const s=XJ(a);n.push({attachment:a,attachmentIndex:i,id:`attachment-${i}`,isImage:s,name:a.name,preview:s&&"base64Url"in a?a.base64Url:void 0,size:"size"in a?a.size:void 0,textContent:"content"in a?a.content:void 0})}return n.reverse()}function U8(t){const e=nh(t.type);return e||rce(t.name)}function jIe(t,e){return e?U8(e)===pi.TEXT:t?t.type===Ti.TEXT||t.type===Ti.LEGACY_CONTEXT:!1}function XJ(t,e){return e?U8(e)===pi.IMAGE:t?t.type===Ti.IMAGE:!1}function tce(t,e){return e?U8(e)===pi.PDF:t?t.type===Ti.PDF:!1}function QJ(t,e){return e?U8(e)===pi.AUDIO:t?t.type===Ti.AUDIO:!1}function ZJ(t,e){return e?U8(e)===pi.VIDEO:t?t.type===Ti.VIDEO:!1}function ox(t){t&&(t.style.height="1rem",t.style.height=t.scrollHeight+"px")}function ny(t,e){if(e)return t.find(r=>r.id===e)}function Cb(t,e,r=!1){const n=[],i=new Map;for(const o of t)i.set(o.id,o);let a=i.get(e);if(!a){let o=-1;for(const l of t)l.timestamp>o&&(a=l,o=l.timestamp)}let s=a;for(;s&&((s.type!=="root"||r)&&n.push(s),s.parent!==null);)s=i.get(s.parent);return n.sort((o,l)=>o.role===Sr.SYSTEM&&l.role!==Sr.SYSTEM?-1:o.role!==Sr.SYSTEM&&l.role===Sr.SYSTEM?1:o.timestamp-l.timestamp),n}function XIe(t,e){let r=t.get(e);for(;r&&r.children.length>0;){const n=r.children[r.children.length-1];r=t.get(n)}return r?.id??e}function JJ(t,e){const r=new Map(t.map(n=>[n.id,n]));return XIe(r,e)}function QIe(t,e){const r=new Map;for(const a of t)r.set(a.id,a);const n=[],i=[e];for(;i.length>0;){const a=i.shift(),s=r.get(a);if(s)for(const o of s.children)n.push(o),i.push(o)}return n}function Gwt(t,e){const r=t.get(e);if(!r)return null;if(r.parent===null)return{currentIndex:0,message:r,siblingIds:[e],totalSiblings:1};const n=t.get(r.parent);if(!n)return{currentIndex:0,message:r,siblingIds:[e],totalSiblings:1};const i=n.children,a=i.map(o=>XIe(t,o));return{currentIndex:i.indexOf(e),message:r,siblingIds:a,totalSiblings:i.length}}function zwt(t){const e=new Map(t.map(n=>[n.id,n])),r=new Map;for(const n of t){const i=Gwt(e,n.id);i&&r.set(n.id,i)}return r}var qwt=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function kd(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}var xH,M_e;function ZIe(){if(M_e)return xH;M_e=1;function t(Ge){return Ge instanceof Map?Ge.clear=Ge.delete=Ge.set=function(){throw new Error("map is read-only")}:Ge instanceof Set&&(Ge.add=Ge.clear=Ge.delete=function(){throw new Error("set is read-only")}),Object.freeze(Ge),Object.getOwnPropertyNames(Ge).forEach(xe=>{const mt=Ge[xe],Ye=typeof mt;(Ye==="object"||Ye==="function")&&!Object.isFrozen(mt)&&t(mt)}),Ge}class e{constructor(xe){xe.data===void 0&&(xe.data={}),this.data=xe.data,this.isMatchIgnored=!1}ignoreMatch(){this.isMatchIgnored=!0}}function r(Ge){return Ge.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function n(Ge,...xe){const mt=Object.create(null);for(const Ye in Ge)mt[Ye]=Ge[Ye];return xe.forEach(function(Ye){for(const kt in Ye)mt[kt]=Ye[kt]}),mt}const i="",a=Ge=>!!Ge.scope,s=(Ge,{prefix:xe})=>{if(Ge.startsWith("language:"))return Ge.replace("language:","language-");if(Ge.includes(".")){const mt=Ge.split(".");return[`${xe}${mt.shift()}`,...mt.map((Ye,kt)=>`${Ye}${"_".repeat(kt+1)}`)].join(" ")}return`${xe}${Ge}`};class o{constructor(xe,mt){this.buffer="",this.classPrefix=mt.classPrefix,xe.walk(this)}addText(xe){this.buffer+=r(xe)}openNode(xe){if(!a(xe))return;const mt=s(xe.scope,{prefix:this.classPrefix});this.span(mt)}closeNode(xe){a(xe)&&(this.buffer+=i)}value(){return this.buffer}span(xe){this.buffer+=``}}const l=(Ge={})=>{const xe={children:[]};return Object.assign(xe,Ge),xe};class u{constructor(){this.rootNode=l(),this.stack=[this.rootNode]}get top(){return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(xe){this.top.children.push(xe)}openNode(xe){const mt=l({scope:xe});this.add(mt),this.stack.push(mt)}closeNode(){if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}walk(xe){return this.constructor._walk(xe,this.rootNode)}static _walk(xe,mt){return typeof mt=="string"?xe.addText(mt):mt.children&&(xe.openNode(mt),mt.children.forEach(Ye=>this._walk(xe,Ye)),xe.closeNode(mt)),xe}static _collapse(xe){typeof xe!="string"&&xe.children&&(xe.children.every(mt=>typeof mt=="string")?xe.children=[xe.children.join("")]:xe.children.forEach(mt=>{u._collapse(mt)}))}}class d extends u{constructor(xe){super(),this.options=xe}addText(xe){xe!==""&&this.add(xe)}startScope(xe){this.openNode(xe)}endScope(){this.closeNode()}__addSublanguage(xe,mt){const Ye=xe.root;mt&&(Ye.scope=`language:${mt}`),this.add(Ye)}toHTML(){return new o(this,this.options).value()}finalize(){return this.closeAllNodes(),!0}}function h(Ge){return Ge?typeof Ge=="string"?Ge:Ge.source:null}function f(Ge){return m("(?=",Ge,")")}function p(Ge){return m("(?:",Ge,")*")}function g(Ge){return m("(?:",Ge,")?")}function m(...Ge){return Ge.map(mt=>h(mt)).join("")}function _(Ge){const xe=Ge[Ge.length-1];return typeof xe=="object"&&xe.constructor===Object?(Ge.splice(Ge.length-1,1),xe):{}}function v(...Ge){return"("+(_(Ge).capture?"":"?:")+Ge.map(Ye=>h(Ye)).join("|")+")"}function b(Ge){return new RegExp(Ge.toString()+"|").exec("").length-1}function y(Ge,xe){const mt=Ge&&Ge.exec(xe);return mt&&mt.index===0}const E=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;function T(Ge,{joinWith:xe}){let mt=0;return Ge.map(Ye=>{mt+=1;const kt=mt;let At=h(Ye),ft="";for(;At.length>0;){const wt=E.exec(At);if(!wt){ft+=At;break}ft+=At.substring(0,wt.index),At=At.substring(wt.index+wt[0].length),wt[0][0]==="\\"&&wt[1]?ft+="\\"+String(Number(wt[1])+kt):(ft+=wt[0],wt[0]==="("&&mt++)}return ft}).map(Ye=>`(${Ye})`).join(xe)}const C=/\b\B/,w="[a-zA-Z]\\w*",x="[a-zA-Z_]\\w*",A="\\b\\d+(\\.\\d+)?",R="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",O="\\b(0b[01]+)",F="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",P=(Ge={})=>{const xe=/^#![ ]*\//;return Ge.binary&&(Ge.begin=m(xe,/.*\b/,Ge.binary,/\b.*/)),n({scope:"meta",begin:xe,end:/$/,relevance:0,"on:begin":(mt,Ye)=>{mt.index!==0&&Ye.ignoreMatch()}},Ge)},N={begin:"\\\\[\\s\\S]",relevance:0},k={scope:"string",begin:"'",end:"'",illegal:"\\n",contains:[N]},M={scope:"string",begin:'"',end:'"',illegal:"\\n",contains:[N]},L={begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/},I=function(Ge,xe,mt={}){const Ye=n({scope:"comment",begin:Ge,end:xe,contains:[]},mt);Ye.contains.push({scope:"doctag",begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0});const kt=v("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/);return Ye.contains.push({begin:m(/[ ]+/,"(",kt,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),Ye},U=I("//","$"),B=I("/\\*","\\*/"),$=I("#","$"),H={scope:"number",begin:A,relevance:0},q={scope:"number",begin:R,relevance:0},V={scope:"number",begin:O,relevance:0},Y={scope:"regexp",begin:/\/(?=[^/\n]*\/)/,end:/\/[gimuy]*/,contains:[N,{begin:/\[/,end:/\]/,relevance:0,contains:[N]}]},j={scope:"title",begin:w,relevance:0},Q={scope:"title",begin:x,relevance:0},ae={begin:"\\.\\s*"+x,relevance:0};var ne=Object.freeze({__proto__:null,APOS_STRING_MODE:k,BACKSLASH_ESCAPE:N,BINARY_NUMBER_MODE:V,BINARY_NUMBER_RE:O,COMMENT:I,C_BLOCK_COMMENT_MODE:B,C_LINE_COMMENT_MODE:U,C_NUMBER_MODE:q,C_NUMBER_RE:R,END_SAME_AS_BEGIN:function(Ge){return Object.assign(Ge,{"on:begin":(xe,mt)=>{mt.data._beginMatch=xe[1]},"on:end":(xe,mt)=>{mt.data._beginMatch!==xe[1]&&mt.ignoreMatch()}})},HASH_COMMENT_MODE:$,IDENT_RE:w,MATCH_NOTHING_RE:C,METHOD_GUARD:ae,NUMBER_MODE:H,NUMBER_RE:A,PHRASAL_WORDS_MODE:L,QUOTE_STRING_MODE:M,REGEXP_MODE:Y,RE_STARTERS_RE:F,SHEBANG:P,TITLE_MODE:j,UNDERSCORE_IDENT_RE:x,UNDERSCORE_TITLE_MODE:Q});function ee(Ge,xe){Ge.input[Ge.index-1]==="."&&xe.ignoreMatch()}function J(Ge,xe){Ge.className!==void 0&&(Ge.scope=Ge.className,delete Ge.className)}function fe(Ge,xe){xe&&Ge.beginKeywords&&(Ge.begin="\\b("+Ge.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",Ge.__beforeBegin=ee,Ge.keywords=Ge.keywords||Ge.beginKeywords,delete Ge.beginKeywords,Ge.relevance===void 0&&(Ge.relevance=0))}function ue(Ge,xe){Array.isArray(Ge.illegal)&&(Ge.illegal=v(...Ge.illegal))}function ge(Ge,xe){if(Ge.match){if(Ge.begin||Ge.end)throw new Error("begin & end are not supported with match");Ge.begin=Ge.match,delete Ge.match}}function ye(Ge,xe){Ge.relevance===void 0&&(Ge.relevance=1)}const Ie=(Ge,xe)=>{if(!Ge.beforeMatch)return;if(Ge.starts)throw new Error("beforeMatch cannot be used with starts");const mt=Object.assign({},Ge);Object.keys(Ge).forEach(Ye=>{delete Ge[Ye]}),Ge.keywords=mt.keywords,Ge.begin=m(mt.beforeMatch,f(mt.begin)),Ge.starts={relevance:0,contains:[Object.assign(mt,{endsParent:!0})]},Ge.relevance=0,delete mt.beforeMatch},we=["of","and","for","in","not","or","if","then","parent","list","value"],Te="keyword";function Ve(Ge,xe,mt=Te){const Ye=Object.create(null);return typeof Ge=="string"?kt(mt,Ge.split(" ")):Array.isArray(Ge)?kt(mt,Ge):Object.keys(Ge).forEach(function(At){Object.assign(Ye,Ve(Ge[At],xe,At))}),Ye;function kt(At,ft){xe&&(ft=ft.map(wt=>wt.toLowerCase())),ft.forEach(function(wt){const bt=wt.split("|");Ye[bt[0]]=[At,Ce(bt[0],bt[1])]})}}function Ce(Ge,xe){return xe?Number(xe):rt(Ge)?0:1}function rt(Ge){return we.includes(Ge.toLowerCase())}const Ne={},et=Ge=>{console.error(Ge)},ut=(Ge,...xe)=>{console.log(`WARN: ${Ge}`,...xe)},Pe=(Ge,xe)=>{Ne[`${Ge}/${xe}`]||(console.log(`Deprecated as of ${Ge}. ${xe}`),Ne[`${Ge}/${xe}`]=!0)},qe=new Error;function Ze(Ge,xe,{key:mt}){let Ye=0;const kt=Ge[mt],At={},ft={};for(let wt=1;wt<=xe.length;wt++)ft[wt+Ye]=kt[wt],At[wt+Ye]=!0,Ye+=b(xe[wt-1]);Ge[mt]=ft,Ge[mt]._emit=At,Ge[mt]._multi=!0}function De(Ge){if(Array.isArray(Ge.begin)){if(Ge.skip||Ge.excludeBegin||Ge.returnBegin)throw et("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),qe;if(typeof Ge.beginScope!="object"||Ge.beginScope===null)throw et("beginScope must be object"),qe;Ze(Ge,Ge.begin,{key:"beginScope"}),Ge.begin=T(Ge.begin,{joinWith:""})}}function Fe(Ge){if(Array.isArray(Ge.end)){if(Ge.skip||Ge.excludeEnd||Ge.returnEnd)throw et("skip, excludeEnd, returnEnd not compatible with endScope: {}"),qe;if(typeof Ge.endScope!="object"||Ge.endScope===null)throw et("endScope must be object"),qe;Ze(Ge,Ge.end,{key:"endScope"}),Ge.end=T(Ge.end,{joinWith:""})}}function de(Ge){Ge.scope&&typeof Ge.scope=="object"&&Ge.scope!==null&&(Ge.beginScope=Ge.scope,delete Ge.scope)}function Ee(Ge){de(Ge),typeof Ge.beginScope=="string"&&(Ge.beginScope={_wrap:Ge.beginScope}),typeof Ge.endScope=="string"&&(Ge.endScope={_wrap:Ge.endScope}),De(Ge),Fe(Ge)}function he(Ge){function xe(ft,wt){return new RegExp(h(ft),"m"+(Ge.case_insensitive?"i":"")+(Ge.unicodeRegex?"u":"")+(wt?"g":""))}class mt{constructor(){this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}addRule(wt,bt){bt.position=this.position++,this.matchIndexes[this.matchAt]=bt,this.regexes.push([bt,wt]),this.matchAt+=b(wt)+1}compile(){this.regexes.length===0&&(this.exec=()=>null);const wt=this.regexes.map(bt=>bt[1]);this.matcherRe=xe(T(wt,{joinWith:"|"}),!0),this.lastIndex=0}exec(wt){this.matcherRe.lastIndex=this.lastIndex;const bt=this.matcherRe.exec(wt);if(!bt)return null;const Gt=bt.findIndex((yr,sr)=>sr>0&&yr!==void 0),Ue=this.matchIndexes[Gt];return bt.splice(0,Gt),Object.assign(bt,Ue)}}class Ye{constructor(){this.rules=[],this.multiRegexes=[],this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(wt){if(this.multiRegexes[wt])return this.multiRegexes[wt];const bt=new mt;return this.rules.slice(wt).forEach(([Gt,Ue])=>bt.addRule(Gt,Ue)),bt.compile(),this.multiRegexes[wt]=bt,bt}resumingScanAtSamePosition(){return this.regexIndex!==0}considerAll(){this.regexIndex=0}addRule(wt,bt){this.rules.push([wt,bt]),bt.type==="begin"&&this.count++}exec(wt){const bt=this.getMatcher(this.regexIndex);bt.lastIndex=this.lastIndex;let Gt=bt.exec(wt);if(this.resumingScanAtSamePosition()&&!(Gt&&Gt.index===this.lastIndex)){const Ue=this.getMatcher(0);Ue.lastIndex=this.lastIndex+1,Gt=Ue.exec(wt)}return Gt&&(this.regexIndex+=Gt.position+1,this.regexIndex===this.count&&this.considerAll()),Gt}}function kt(ft){const wt=new Ye;return ft.contains.forEach(bt=>wt.addRule(bt.begin,{rule:bt,type:"begin"})),ft.terminatorEnd&&wt.addRule(ft.terminatorEnd,{type:"end"}),ft.illegal&&wt.addRule(ft.illegal,{type:"illegal"}),wt}function At(ft,wt){const bt=ft;if(ft.isCompiled)return bt;[J,ge,Ee,Ie].forEach(Ue=>Ue(ft,wt)),Ge.compilerExtensions.forEach(Ue=>Ue(ft,wt)),ft.__beforeBegin=null,[fe,ue,ye].forEach(Ue=>Ue(ft,wt)),ft.isCompiled=!0;let Gt=null;return typeof ft.keywords=="object"&&ft.keywords.$pattern&&(ft.keywords=Object.assign({},ft.keywords),Gt=ft.keywords.$pattern,delete ft.keywords.$pattern),Gt=Gt||/\w+/,ft.keywords&&(ft.keywords=Ve(ft.keywords,Ge.case_insensitive)),bt.keywordPatternRe=xe(Gt,!0),wt&&(ft.begin||(ft.begin=/\B|\b/),bt.beginRe=xe(bt.begin),!ft.end&&!ft.endsWithParent&&(ft.end=/\B|\b/),ft.end&&(bt.endRe=xe(bt.end)),bt.terminatorEnd=h(bt.end)||"",ft.endsWithParent&&wt.terminatorEnd&&(bt.terminatorEnd+=(ft.end?"|":"")+wt.terminatorEnd)),ft.illegal&&(bt.illegalRe=xe(ft.illegal)),ft.contains||(ft.contains=[]),ft.contains=[].concat(...ft.contains.map(function(Ue){return _e(Ue==="self"?ft:Ue)})),ft.contains.forEach(function(Ue){At(Ue,bt)}),ft.starts&&At(ft.starts,wt),bt.matcher=kt(bt),bt}if(Ge.compilerExtensions||(Ge.compilerExtensions=[]),Ge.contains&&Ge.contains.includes("self"))throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");return Ge.classNameAliases=n(Ge.classNameAliases||{}),At(Ge)}function Le(Ge){return Ge?Ge.endsWithParent||Le(Ge.starts):!1}function _e(Ge){return Ge.variants&&!Ge.cachedVariants&&(Ge.cachedVariants=Ge.variants.map(function(xe){return n(Ge,{variants:null},xe)})),Ge.cachedVariants?Ge.cachedVariants:Le(Ge)?n(Ge,{starts:Ge.starts?n(Ge.starts):null}):Object.isFrozen(Ge)?n(Ge):Ge}var He="11.11.1";class Re extends Error{constructor(xe,mt){super(xe),this.name="HTMLInjectionError",this.html=mt}}const Xe=r,je=n,Be=Symbol("nomatch"),Je=7,ht=function(Ge){const xe=Object.create(null),mt=Object.create(null),Ye=[];let kt=!0;const At="Could not find the language '{}', did you forget to load/include a language module?",ft={disableAutodetect:!0,name:"Plain text",contains:[]};let wt={ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",cssSelector:"pre code",languages:null,__emitter:d};function bt(_r){return wt.noHighlightRe.test(_r)}function Gt(_r){let on=_r.className+" ";on+=_r.parentNode?_r.parentNode.className:"";const dr=wt.languageDetectRe.exec(on);if(dr){const nr=xr(dr[1]);return nr||(ut(At.replace("{}",dr[1])),ut("Falling back to no-highlight mode for this block.",_r)),nr?dr[1]:"no-highlight"}return on.split(/\s+/).find(nr=>bt(nr)||xr(nr))}function Ue(_r,on,dr){let nr="",rr="";typeof on=="object"?(nr=_r,dr=on.ignoreIllegals,rr=on.language):(Pe("10.7.0","highlight(lang, code, ...args) has been deprecated."),Pe("10.7.0",`Please use highlight(code, options) instead. +https://github.com/highlightjs/highlight.js/issues/2277`),rr=_r,nr=on),dr===void 0&&(dr=!0);const fr={code:nr,language:rr};La("before:highlight",fr);const In=fr.result?fr.result:yr(fr.language,fr.code,dr);return In.code=fr.code,La("after:highlight",In),In}function yr(_r,on,dr,nr){const rr=Object.create(null);function fr(pr,Gr){return pr.keywords[Gr]}function In(){if(!Zt.keywords){Nt.addText(ir);return}let pr=0;Zt.keywordPatternRe.lastIndex=0;let Gr=Zt.keywordPatternRe.exec(ir),an="";for(;Gr;){an+=ir.substring(pr,Gr.index);const zn=_o.case_insensitive?Gr[0].toLowerCase():Gr[0],oi=fr(Zt,zn);if(oi){const[ul,L1]=oi;if(Nt.addText(an),an="",rr[zn]=(rr[zn]||0)+1,rr[zn]<=Je&&(en+=L1),ul.startsWith("_"))an+=Gr[0];else{const qS=_o.classNameAliases[ul]||ul;gt(Gr[0],qS)}}else an+=Gr[0];pr=Zt.keywordPatternRe.lastIndex,Gr=Zt.keywordPatternRe.exec(ir)}an+=ir.substring(pr),Nt.addText(an)}function dt(){if(ir==="")return;let pr=null;if(typeof Zt.subLanguage=="string"){if(!xe[Zt.subLanguage]){Nt.addText(ir);return}pr=yr(Zt.subLanguage,ir,!0,ot[Zt.subLanguage]),ot[Zt.subLanguage]=pr._top}else pr=ar(ir,Zt.subLanguage.length?Zt.subLanguage:null);Zt.relevance>0&&(en+=pr.relevance),Nt.__addSublanguage(pr._emitter,pr.language)}function pa(){Zt.subLanguage!=null?dt():In(),ir=""}function gt(pr,Gr){pr!==""&&(Nt.startScope(Gr),Nt.addText(pr),Nt.endScope())}function xa(pr,Gr){let an=1;const zn=Gr.length-1;for(;an<=zn;){if(!pr._emit[an]){an++;continue}const oi=_o.classNameAliases[pr[an]]||pr[an],ul=Gr[an];oi?gt(ul,oi):(ir=ul,In(),ir=""),an++}}function Ph(pr,Gr){return pr.scope&&typeof pr.scope=="string"&&Nt.openNode(_o.classNameAliases[pr.scope]||pr.scope),pr.beginScope&&(pr.beginScope._wrap?(gt(ir,_o.classNameAliases[pr.beginScope._wrap]||pr.beginScope._wrap),ir=""):pr.beginScope._multi&&(xa(pr.beginScope,Gr),ir="")),Zt=Object.create(pr,{parent:{value:Zt}}),Zt}function ca(pr,Gr,an){let zn=y(pr.endRe,an);if(zn){if(pr["on:end"]){const oi=new e(pr);pr["on:end"](Gr,oi),oi.isMatchIgnored&&(zn=!1)}if(zn){for(;pr.endsParent&&pr.parent;)pr=pr.parent;return pr}}if(pr.endsWithParent)return ca(pr.parent,Gr,an)}function nu(pr){return Zt.matcher.regexIndex===0?(ir+=pr[0],1):(xi=!0,0)}function Qu(pr){const Gr=pr[0],an=pr.rule,zn=new e(an),oi=[an.__beforeBegin,an["on:begin"]];for(const ul of oi)if(ul&&(ul(pr,zn),zn.isMatchIgnored))return nu(Gr);return an.skip?ir+=Gr:(an.excludeBegin&&(ir+=Gr),pa(),!an.returnBegin&&!an.excludeBegin&&(ir=Gr)),Ph(an,pr),an.returnBegin?0:Gr.length}function Pa(pr){const Gr=pr[0],an=on.substring(pr.index),zn=ca(Zt,pr,an);if(!zn)return Be;const oi=Zt;Zt.endScope&&Zt.endScope._wrap?(pa(),gt(Gr,Zt.endScope._wrap)):Zt.endScope&&Zt.endScope._multi?(pa(),xa(Zt.endScope,pr)):oi.skip?ir+=Gr:(oi.returnEnd||oi.excludeEnd||(ir+=Gr),pa(),oi.excludeEnd&&(ir=Gr));do Zt.scope&&Nt.closeNode(),!Zt.skip&&!Zt.subLanguage&&(en+=Zt.relevance),Zt=Zt.parent;while(Zt!==zn.parent);return zn.starts&&Ph(zn.starts,pr),oi.returnEnd?0:Gr.length}function Ll(){const pr=[];for(let Gr=Zt;Gr!==_o;Gr=Gr.parent)Gr.scope&&pr.unshift(Gr.scope);pr.forEach(Gr=>Nt.openNode(Gr))}let Xl={};function Ql(pr,Gr){const an=Gr&&Gr[0];if(ir+=pr,an==null)return pa(),0;if(Xl.type==="begin"&&Gr.type==="end"&&Xl.index===Gr.index&&an===""){if(ir+=on.slice(Gr.index,Gr.index+1),!kt){const zn=new Error(`0 width match regex (${_r})`);throw zn.languageName=_r,zn.badRule=Xl.rule,zn}return 1}if(Xl=Gr,Gr.type==="begin")return Qu(Gr);if(Gr.type==="illegal"&&!dr){const zn=new Error('Illegal lexeme "'+an+'" for mode "'+(Zt.scope||"")+'"');throw zn.mode=Zt,zn}else if(Gr.type==="end"){const zn=Pa(Gr);if(zn!==Be)return zn}if(Gr.type==="illegal"&&an==="")return ir+=` +`,1;if(bn>1e5&&bn>Gr.index*3)throw new Error("potential infinite loop, way more iterations than matches");return ir+=an,an.length}const _o=xr(_r);if(!_o)throw et(At.replace("{}",_r)),new Error('Unknown language: "'+_r+'"');const Zl=he(_o);let Jl="",Zt=nr||Zl;const ot={},Nt=new wt.__emitter(wt);Ll();let ir="",en=0,Wr=0,bn=0,xi=!1;try{if(_o.__emitTokens)_o.__emitTokens(on,Nt);else{for(Zt.matcher.considerAll();;){bn++,xi?xi=!1:Zt.matcher.considerAll(),Zt.matcher.lastIndex=Wr;const pr=Zt.matcher.exec(on);if(!pr)break;const Gr=on.substring(Wr,pr.index),an=Ql(Gr,pr);Wr=pr.index+an}Ql(on.substring(Wr))}return Nt.finalize(),Jl=Nt.toHTML(),{language:_r,value:Jl,relevance:en,illegal:!1,_emitter:Nt,_top:Zt}}catch(pr){if(pr.message&&pr.message.includes("Illegal"))return{language:_r,value:Xe(on),illegal:!0,relevance:0,_illegalBy:{message:pr.message,index:Wr,context:on.slice(Wr-100,Wr+100),mode:pr.mode,resultSoFar:Jl},_emitter:Nt};if(kt)return{language:_r,value:Xe(on),illegal:!1,relevance:0,errorRaised:pr,_emitter:Nt,_top:Zt};throw pr}}function sr(_r){const on={value:Xe(_r),illegal:!1,relevance:0,_top:ft,_emitter:new wt.__emitter(wt)};return on._emitter.addText(_r),on}function ar(_r,on){on=on||wt.languages||Object.keys(xe);const dr=sr(_r),nr=on.filter(xr).filter(Hr).map(pa=>yr(pa,_r,!1));nr.unshift(dr);const rr=nr.sort((pa,gt)=>{if(pa.relevance!==gt.relevance)return gt.relevance-pa.relevance;if(pa.language&>.language){if(xr(pa.language).supersetOf===gt.language)return 1;if(xr(gt.language).supersetOf===pa.language)return-1}return 0}),[fr,In]=rr,dt=fr;return dt.secondBest=In,dt}function br(_r,on,dr){const nr=on&&mt[on]||dr;_r.classList.add("hljs"),_r.classList.add(`language-${nr}`)}function Un(_r){let on=null;const dr=Gt(_r);if(bt(dr))return;if(La("before:highlightElement",{el:_r,language:dr}),_r.dataset.highlighted){console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",_r);return}if(_r.children.length>0&&(wt.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),console.warn("The element with unescaped HTML:"),console.warn(_r)),wt.throwUnescapedHTML))throw new Re("One of your code blocks includes unescaped HTML.",_r.innerHTML);on=_r;const nr=on.textContent,rr=dr?Ue(nr,{language:dr,ignoreIllegals:!0}):ar(nr);_r.innerHTML=rr.value,_r.dataset.highlighted="yes",br(_r,dr,rr.language),_r.result={language:rr.language,re:rr.relevance,relevance:rr.relevance},rr.secondBest&&(_r.secondBest={language:rr.secondBest.language,relevance:rr.secondBest.relevance}),La("after:highlightElement",{el:_r,result:rr,text:nr})}function ct(_r){wt=je(wt,_r)}const Dt=()=>{Ir(),Pe("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")};function Jt(){Ir(),Pe("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")}let wr=!1;function Ir(){function _r(){Ir()}if(document.readyState==="loading"){wr||window.addEventListener("DOMContentLoaded",_r,!1),wr=!0;return}document.querySelectorAll(wt.cssSelector).forEach(Un)}function On(_r,on){let dr=null;try{dr=on(Ge)}catch(nr){if(et("Language definition for '{}' could not be registered.".replace("{}",_r)),kt)et(nr);else throw nr;dr=ft}dr.name||(dr.name=_r),xe[_r]=dr,dr.rawDefinition=on.bind(null,Ge),dr.aliases&&Qr(dr.aliases,{languageName:_r})}function _n(_r){delete xe[_r];for(const on of Object.keys(mt))mt[on]===_r&&delete mt[on]}function jn(){return Object.keys(xe)}function xr(_r){return _r=(_r||"").toLowerCase(),xe[_r]||xe[mt[_r]]}function Qr(_r,{languageName:on}){typeof _r=="string"&&(_r=[_r]),_r.forEach(dr=>{mt[dr.toLowerCase()]=on})}function Hr(_r){const on=xr(_r);return on&&!on.disableAutodetect}function ei(_r){_r["before:highlightBlock"]&&!_r["before:highlightElement"]&&(_r["before:highlightElement"]=on=>{_r["before:highlightBlock"](Object.assign({block:on.el},on))}),_r["after:highlightBlock"]&&!_r["after:highlightElement"]&&(_r["after:highlightElement"]=on=>{_r["after:highlightBlock"](Object.assign({block:on.el},on))})}function Gi(_r){ei(_r),Ye.push(_r)}function bi(_r){const on=Ye.indexOf(_r);on!==-1&&Ye.splice(on,1)}function La(_r,on){const dr=_r;Ye.forEach(function(nr){nr[dr]&&nr[dr](on)})}function cl(_r){return Pe("10.7.0","highlightBlock will be removed entirely in v12.0"),Pe("10.7.0","Please use highlightElement now."),Un(_r)}Object.assign(Ge,{highlight:Ue,highlightAuto:ar,highlightAll:Ir,highlightElement:Un,highlightBlock:cl,configure:ct,initHighlighting:Dt,initHighlightingOnLoad:Jt,registerLanguage:On,unregisterLanguage:_n,listLanguages:jn,getLanguage:xr,registerAliases:Qr,autoDetection:Hr,inherit:je,addPlugin:Gi,removePlugin:bi}),Ge.debugMode=function(){kt=!1},Ge.safeMode=function(){kt=!0},Ge.versionString=He,Ge.regex={concat:m,lookahead:f,either:v,optional:g,anyNumberOfTimes:p};for(const _r in ne)typeof ne[_r]=="object"&&t(ne[_r]);return Object.assign(Ge,ne),Ge},tt=ht({});return tt.newInstance=()=>ht({}),xH=tt,tt.HighlightJS=tt,tt.default=tt,xH}var AH,L_e;function Hwt(){if(L_e)return AH;L_e=1;function t(e){const r="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]+",a="далее "+"возврат вызватьисключение выполнить для если и из или иначе иначеесли исключение каждого конецесли конецпопытки конеццикла не новый перейти перем по пока попытка прервать продолжить тогда цикл экспорт ",l="загрузитьизфайла "+"вебклиент вместо внешнеесоединение клиент конецобласти мобильноеприложениеклиент мобильноеприложениесервер наклиенте наклиентенасервере наклиентенасерверебезконтекста насервере насерверебезконтекста область перед после сервер толстыйклиентобычноеприложение толстыйклиентуправляемоеприложение тонкийклиент ",p="разделительстраниц разделительстрок символтабуляции "+"ansitooem oemtoansi ввестивидсубконто ввестиперечисление ввестипериод ввестиплансчетов выбранныйплансчетов датагод датамесяц датачисло заголовоксистемы значениевстроку значениеизстроки каталогиб каталогпользователя кодсимв конгода конецпериодаби конецрассчитанногопериодаби конецстандартногоинтервала конквартала конмесяца коннедели лог лог10 максимальноеколичествосубконто названиеинтерфейса названиенабораправ назначитьвид назначитьсчет найтиссылки началопериодаби началостандартногоинтервала начгода начквартала начмесяца начнедели номерднягода номерднянедели номернеделигода обработкаожидания основнойжурналрасчетов основнойплансчетов основнойязык очиститьокносообщений периодстр получитьвремята получитьдатута получитьдокументта получитьзначенияотбора получитьпозициюта получитьпустоезначение получитьта префиксавтонумерации пропись пустоезначение разм разобратьпозициюдокумента рассчитатьрегистрына рассчитатьрегистрыпо симв создатьобъект статусвозврата стрколичествострок сформироватьпозициюдокумента счетпокоду текущеевремя типзначения типзначениястр установитьтана установитьтапо фиксшаблон шаблон "+"acos asin atan base64значение base64строка cos exp log log10 pow sin sqrt tan xmlзначение xmlстрока xmlтип xmlтипзнч активноеокно безопасныйрежим безопасныйрежимразделенияданных булево ввестидату ввестизначение ввестистроку ввестичисло возможностьчтенияxml вопрос восстановитьзначение врег выгрузитьжурналрегистрации выполнитьобработкуоповещения выполнитьпроверкуправдоступа вычислить год данныеформывзначение дата день деньгода деньнедели добавитьмесяц заблокироватьданныедляредактирования заблокироватьработупользователя завершитьработусистемы загрузитьвнешнююкомпоненту закрытьсправку записатьjson записатьxml записатьдатуjson записьжурналарегистрации заполнитьзначениясвойств запроситьразрешениепользователя запуститьприложение запуститьсистему зафиксироватьтранзакцию значениевданныеформы значениевстрокувнутр значениевфайл значениезаполнено значениеизстрокивнутр значениеизфайла изxmlтипа импортмоделиxdto имякомпьютера имяпользователя инициализироватьпредопределенныеданные информацияобошибке каталогбиблиотекимобильногоустройства каталогвременныхфайлов каталогдокументов каталогпрограммы кодироватьстроку кодлокализацииинформационнойбазы кодсимвола командасистемы конецгода конецдня конецквартала конецмесяца конецминуты конецнедели конецчаса конфигурациябазыданныхизмененадинамически конфигурацияизменена копироватьданныеформы копироватьфайл краткоепредставлениеошибки лев макс местноевремя месяц мин минута монопольныйрежим найти найтинедопустимыесимволыxml найтиокнопонавигационнойссылке найтипомеченныенаудаление найтипоссылкам найтифайлы началогода началодня началоквартала началомесяца началоминуты началонедели началочаса начатьзапросразрешенияпользователя начатьзапускприложения начатькопированиефайла начатьперемещениефайла начатьподключениевнешнейкомпоненты начатьподключениерасширенияработыскриптографией начатьподключениерасширенияработысфайлами начатьпоискфайлов начатьполучениекаталогавременныхфайлов начатьполучениекаталогадокументов начатьполучениерабочегокаталогаданныхпользователя начатьполучениефайлов начатьпомещениефайла начатьпомещениефайлов начатьсозданиедвоичныхданныхизфайла начатьсозданиекаталога начатьтранзакцию начатьудалениефайлов начатьустановкувнешнейкомпоненты начатьустановкурасширенияработыскриптографией начатьустановкурасширенияработысфайлами неделягода необходимостьзавершениясоединения номерсеансаинформационнойбазы номерсоединенияинформационнойбазы нрег нстр обновитьинтерфейс обновитьнумерациюобъектов обновитьповторноиспользуемыезначения обработкапрерыванияпользователя объединитьфайлы окр описаниеошибки оповестить оповеститьобизменении отключитьобработчикзапросанастроекклиенталицензирования отключитьобработчикожидания отключитьобработчикоповещения открытьзначение открытьиндекссправки открытьсодержаниесправки открытьсправку открытьформу открытьформумодально отменитьтранзакцию очиститьжурналрегистрации очиститьнастройкипользователя очиститьсообщения параметрыдоступа перейтипонавигационнойссылке переместитьфайл подключитьвнешнююкомпоненту подключитьобработчикзапросанастроекклиенталицензирования подключитьобработчикожидания подключитьобработчикоповещения подключитьрасширениеработыскриптографией подключитьрасширениеработысфайлами подробноепредставлениеошибки показатьвводдаты показатьвводзначения показатьвводстроки показатьвводчисла показатьвопрос показатьзначение показатьинформациюобошибке показатьнакарте показатьоповещениепользователя показатьпредупреждение полноеимяпользователя получитьcomобъект получитьxmlтип получитьадреспоместоположению получитьблокировкусеансов получитьвремязавершенияспящегосеанса получитьвремязасыпанияпассивногосеанса получитьвремяожиданияблокировкиданных получитьданныевыбора получитьдополнительныйпараметрклиенталицензирования получитьдопустимыекодылокализации получитьдопустимыечасовыепояса получитьзаголовокклиентскогоприложения получитьзаголовоксистемы получитьзначенияотборажурналарегистрации получитьидентификаторконфигурации получитьизвременногохранилища получитьимявременногофайла получитьимяклиенталицензирования получитьинформациюэкрановклиента получитьиспользованиежурналарегистрации получитьиспользованиесобытияжурналарегистрации получитькраткийзаголовокприложения получитьмакетоформления получитьмаскувсефайлы получитьмаскувсефайлыклиента получитьмаскувсефайлысервера получитьместоположениепоадресу получитьминимальнуюдлинупаролейпользователей получитьнавигационнуюссылку получитьнавигационнуюссылкуинформационнойбазы получитьобновлениеконфигурациибазыданных получитьобновлениепредопределенныхданныхинформационнойбазы получитьобщиймакет получитьобщуюформу получитьокна получитьоперативнуюотметкувремени получитьотключениебезопасногорежима получитьпараметрыфункциональныхопцийинтерфейса получитьполноеимяпредопределенногозначения получитьпредставлениянавигационныхссылок получитьпроверкусложностипаролейпользователей получитьразделительпути получитьразделительпутиклиента получитьразделительпутисервера получитьсеансыинформационнойбазы получитьскоростьклиентскогосоединения получитьсоединенияинформационнойбазы получитьсообщенияпользователю получитьсоответствиеобъектаиформы получитьсоставстандартногоинтерфейсаodata получитьструктурухранениябазыданных получитьтекущийсеансинформационнойбазы получитьфайл получитьфайлы получитьформу получитьфункциональнуюопцию получитьфункциональнуюопциюинтерфейса получитьчасовойпоясинформационнойбазы пользователиос поместитьвовременноехранилище поместитьфайл поместитьфайлы прав праводоступа предопределенноезначение представлениекодалокализации представлениепериода представлениеправа представлениеприложения представлениесобытияжурналарегистрации представлениечасовогопояса предупреждение прекратитьработусистемы привилегированныйрежим продолжитьвызов прочитатьjson прочитатьxml прочитатьдатуjson пустаястрока рабочийкаталогданныхпользователя разблокироватьданныедляредактирования разделитьфайл разорватьсоединениесвнешнимисточникомданных раскодироватьстроку рольдоступна секунда сигнал символ скопироватьжурналрегистрации смещениелетнеговремени смещениестандартноговремени соединитьбуферыдвоичныхданных создатькаталог создатьфабрикуxdto сокрл сокрлп сокрп сообщить состояние сохранитьзначение сохранитьнастройкипользователя сред стрдлина стрзаканчиваетсяна стрзаменить стрнайти стрначинаетсяс строка строкасоединенияинформационнойбазы стрполучитьстроку стрразделить стрсоединить стрсравнить стрчисловхождений стрчислострок стршаблон текущаядата текущаядатасеанса текущаяуниверсальнаядата текущаяуниверсальнаядатавмиллисекундах текущийвариантинтерфейсаклиентскогоприложения текущийвариантосновногошрифтаклиентскогоприложения текущийкодлокализации текущийрежимзапуска текущийязык текущийязыксистемы тип типзнч транзакцияактивна трег удалитьданныеинформационнойбазы удалитьизвременногохранилища удалитьобъекты удалитьфайлы универсальноевремя установитьбезопасныйрежим установитьбезопасныйрежимразделенияданных установитьблокировкусеансов установитьвнешнююкомпоненту установитьвремязавершенияспящегосеанса установитьвремязасыпанияпассивногосеанса установитьвремяожиданияблокировкиданных установитьзаголовокклиентскогоприложения установитьзаголовоксистемы установитьиспользованиежурналарегистрации установитьиспользованиесобытияжурналарегистрации установитькраткийзаголовокприложения установитьминимальнуюдлинупаролейпользователей установитьмонопольныйрежим установитьнастройкиклиенталицензирования установитьобновлениепредопределенныхданныхинформационнойбазы установитьотключениебезопасногорежима установитьпараметрыфункциональныхопцийинтерфейса установитьпривилегированныйрежим установитьпроверкусложностипаролейпользователей установитьрасширениеработыскриптографией установитьрасширениеработысфайлами установитьсоединениесвнешнимисточникомданных установитьсоответствиеобъектаиформы установитьсоставстандартногоинтерфейсаodata установитьчасовойпоясинформационнойбазы установитьчасовойпояссеанса формат цел час часовойпояс часовойпояссеанса число числопрописью этоадресвременногохранилища "+"wsссылки библиотекакартинок библиотекамакетовоформлениякомпоновкиданных библиотекастилей бизнеспроцессы внешниеисточникиданных внешниеобработки внешниеотчеты встроенныепокупки главныйинтерфейс главныйстиль документы доставляемыеуведомления журналыдокументов задачи информацияобинтернетсоединении использованиерабочейдаты историяработыпользователя константы критерииотбора метаданные обработки отображениерекламы отправкадоставляемыхуведомлений отчеты панельзадачос параметрзапуска параметрысеанса перечисления планывидоврасчета планывидовхарактеристик планыобмена планысчетов полнотекстовыйпоиск пользователиинформационнойбазы последовательности проверкавстроенныхпокупок рабочаядата расширенияконфигурации регистрыбухгалтерии регистрынакопления регистрырасчета регистрысведений регламентныезадания сериализаторxdto справочники средствагеопозиционирования средствакриптографии средствамультимедиа средстваотображениярекламы средствапочты средствателефонии фабрикаxdto файловыепотоки фоновыезадания хранилищанастроек хранилищевариантовотчетов хранилищенастроекданныхформ хранилищеобщихнастроек хранилищепользовательскихнастроекдинамическихсписков хранилищепользовательскихнастроекотчетов хранилищесистемныхнастроек ",B="webцвета windowsцвета windowsшрифты библиотекакартинок рамкистиля символы цветастиля шрифтыстиля "+"автоматическоесохранениеданныхформывнастройках автонумерациявформе автораздвижениесерий анимациядиаграммы вариантвыравниванияэлементовизаголовков вариантуправлениявысотойтаблицы вертикальнаяпрокруткаформы вертикальноеположение вертикальноеположениеэлемента видгруппыформы виддекорацииформы виддополненияэлементаформы видизмененияданных видкнопкиформы видпереключателя видподписейкдиаграмме видполяформы видфлажка влияниеразмеранапузырекдиаграммы горизонтальноеположение горизонтальноеположениеэлемента группировкаколонок группировкаподчиненныхэлементовформы группыиэлементы действиеперетаскивания дополнительныйрежимотображения допустимыедействияперетаскивания интервалмеждуэлементамиформы использованиевывода использованиеполосыпрокрутки используемоезначениеточкибиржевойдиаграммы историявыборапривводе источникзначенийоситочекдиаграммы источникзначенияразмерапузырькадиаграммы категориягруппыкоманд максимумсерий начальноеотображениедерева начальноеотображениесписка обновлениетекстаредактирования ориентациядендрограммы ориентациядиаграммы ориентацияметокдиаграммы ориентацияметоксводнойдиаграммы ориентацияэлементаформы отображениевдиаграмме отображениевлегендедиаграммы отображениегруппыкнопок отображениезаголовкашкалыдиаграммы отображениезначенийсводнойдиаграммы отображениезначенияизмерительнойдиаграммы отображениеинтерваладиаграммыганта отображениекнопки отображениекнопкивыбора отображениеобсужденийформы отображениеобычнойгруппы отображениеотрицательныхзначенийпузырьковойдиаграммы отображениепанелипоиска отображениеподсказки отображениепредупрежденияприредактировании отображениеразметкиполосырегулирования отображениестраницформы отображениетаблицы отображениетекстазначениядиаграммыганта отображениеуправленияобычнойгруппы отображениефигурыкнопки палитрацветовдиаграммы поведениеобычнойгруппы поддержкамасштабадендрограммы поддержкамасштабадиаграммыганта поддержкамасштабасводнойдиаграммы поисквтаблицепривводе положениезаголовкаэлементаформы положениекартинкикнопкиформы положениекартинкиэлементаграфическойсхемы положениекоманднойпанелиформы положениекоманднойпанелиэлементаформы положениеопорнойточкиотрисовки положениеподписейкдиаграмме положениеподписейшкалызначенийизмерительнойдиаграммы положениесостоянияпросмотра положениестрокипоиска положениетекстасоединительнойлинии положениеуправленияпоиском положениешкалывремени порядокотображенияточекгоризонтальнойгистограммы порядоксерийвлегендедиаграммы размеркартинки расположениезаголовкашкалыдиаграммы растягиваниеповертикалидиаграммыганта режимавтоотображениясостояния режимвводастроктаблицы режимвыборанезаполненного режимвыделениядаты режимвыделениястрокитаблицы режимвыделениятаблицы режимизмененияразмера режимизменениясвязанногозначения режимиспользованиядиалогапечати режимиспользованияпараметракоманды режиммасштабированияпросмотра режимосновногоокнаклиентскогоприложения режимоткрытияокнаформы режимотображениявыделения режимотображениягеографическойсхемы режимотображениязначенийсерии режимотрисовкисеткиграфическойсхемы режимполупрозрачностидиаграммы режимпробеловдиаграммы режимразмещениянастранице режимредактированияколонки режимсглаживаниядиаграммы режимсглаживанияиндикатора режимсписказадач сквозноевыравнивание сохранениеданныхформывнастройках способзаполнениятекстазаголовкашкалыдиаграммы способопределенияограничивающегозначениядиаграммы стандартнаягруппакоманд стандартноеоформление статусоповещенияпользователя стильстрелки типаппроксимациилиниитрендадиаграммы типдиаграммы типединицышкалывремени типимпортасерийслоягеографическойсхемы типлиниигеографическойсхемы типлиниидиаграммы типмаркерагеографическойсхемы типмаркерадиаграммы типобластиоформления типорганизацииисточникаданныхгеографическойсхемы типотображениясериислоягеографическойсхемы типотображенияточечногообъектагеографическойсхемы типотображенияшкалыэлементалегендыгеографическойсхемы типпоискаобъектовгеографическойсхемы типпроекциигеографическойсхемы типразмещенияизмерений типразмещенияреквизитовизмерений типрамкиэлементауправления типсводнойдиаграммы типсвязидиаграммыганта типсоединениязначенийпосериямдиаграммы типсоединенияточекдиаграммы типсоединительнойлинии типстороныэлементаграфическойсхемы типформыотчета типшкалырадарнойдиаграммы факторлиниитрендадиаграммы фигуракнопки фигурыграфическойсхемы фиксациявтаблице форматдняшкалывремени форматкартинки ширинаподчиненныхэлементовформы "+"виддвижениябухгалтерии виддвижениянакопления видпериодарегистрарасчета видсчета видточкимаршрутабизнеспроцесса использованиеагрегатарегистранакопления использованиегруппиэлементов использованиережимапроведения использованиесреза периодичностьагрегатарегистранакопления режимавтовремя режимзаписидокумента режимпроведениядокумента "+"авторегистрацияизменений допустимыйномерсообщения отправкаэлементаданных получениеэлементаданных "+"использованиерасшифровкитабличногодокумента ориентациястраницы положениеитоговколоноксводнойтаблицы положениеитоговстроксводнойтаблицы положениетекстаотносительнокартинки расположениезаголовкагруппировкитабличногодокумента способчтениязначенийтабличногодокумента типдвустороннейпечати типзаполненияобластитабличногодокумента типкурсоровтабличногодокумента типлиниирисункатабличногодокумента типлинииячейкитабличногодокумента типнаправленияпереходатабличногодокумента типотображениявыделениятабличногодокумента типотображениялинийсводнойтаблицы типразмещениятекстатабличногодокумента типрисункатабличногодокумента типсмещениятабличногодокумента типузоратабличногодокумента типфайлатабличногодокумента точностьпечати чередованиерасположениястраниц "+"отображениевремениэлементовпланировщика "+"типфайлаформатированногодокумента "+"обходрезультатазапроса типзаписизапроса "+"видзаполнениярасшифровкипостроителяотчета типдобавленияпредставлений типизмеренияпостроителяотчета типразмещенияитогов "+"доступкфайлу режимдиалогавыборафайла режимоткрытияфайла "+"типизмеренияпостроителязапроса "+"видданныханализа методкластеризации типединицыинтервалавременианализаданных типзаполнениятаблицырезультатаанализаданных типиспользованиячисловыхзначенийанализаданных типисточникаданныхпоискаассоциаций типколонкианализаданныхдереворешений типколонкианализаданныхкластеризация типколонкианализаданныхобщаястатистика типколонкианализаданныхпоискассоциаций типколонкианализаданныхпоискпоследовательностей типколонкимоделипрогноза типмерырасстоянияанализаданных типотсеченияправилассоциации типполяанализаданных типстандартизациианализаданных типупорядочиванияправилассоциациианализаданных типупорядочиванияшаблоновпоследовательностейанализаданных типупрощениядереварешений "+"wsнаправлениепараметра вариантxpathxs вариантзаписидатыjson вариантпростоготипаxs видгруппымоделиxs видфасетаxdto действиепостроителяdom завершенностьпростоготипаxs завершенностьсоставноготипаxs завершенностьсхемыxs запрещенныеподстановкиxs исключениягруппподстановкиxs категорияиспользованияатрибутаxs категорияограниченияидентичностиxs категорияограниченияпространствименxs методнаследованияxs модельсодержимогоxs назначениетипаxml недопустимыеподстановкиxs обработкапробельныхсимволовxs обработкасодержимогоxs ограничениезначенияxs параметрыотбораузловdom переносстрокjson позициявдокументеdom пробельныесимволыxml типатрибутаxml типзначенияjson типканоническогоxml типкомпонентыxs типпроверкиxml типрезультатаdomxpath типузлаdom типузлаxml формаxml формапредставленияxs форматдатыjson экранированиесимволовjson "+"видсравнениякомпоновкиданных действиеобработкирасшифровкикомпоновкиданных направлениесортировкикомпоновкиданных расположениевложенныхэлементоврезультатакомпоновкиданных расположениеитоговкомпоновкиданных расположениегруппировкикомпоновкиданных расположениеполейгруппировкикомпоновкиданных расположениеполякомпоновкиданных расположениереквизитовкомпоновкиданных расположениересурсовкомпоновкиданных типбухгалтерскогоостаткакомпоновкиданных типвыводатекстакомпоновкиданных типгруппировкикомпоновкиданных типгруппыэлементовотборакомпоновкиданных типдополненияпериодакомпоновкиданных типзаголовкаполейкомпоновкиданных типмакетагруппировкикомпоновкиданных типмакетаобластикомпоновкиданных типостаткакомпоновкиданных типпериодакомпоновкиданных типразмещениятекстакомпоновкиданных типсвязинаборовданныхкомпоновкиданных типэлементарезультатакомпоновкиданных расположениелегендыдиаграммыкомпоновкиданных типпримененияотборакомпоновкиданных режимотображенияэлементанастройкикомпоновкиданных режимотображениянастроеккомпоновкиданных состояниеэлементанастройкикомпоновкиданных способвосстановлениянастроеккомпоновкиданных режимкомпоновкирезультата использованиепараметракомпоновкиданных автопозицияресурсовкомпоновкиданных вариантиспользованиягруппировкикомпоновкиданных расположениересурсоввдиаграммекомпоновкиданных фиксациякомпоновкиданных использованиеусловногооформлениякомпоновкиданных "+"важностьинтернетпочтовогосообщения обработкатекстаинтернетпочтовогосообщения способкодированияинтернетпочтовоговложения способкодированиянеasciiсимволовинтернетпочтовогосообщения типтекстапочтовогосообщения протоколинтернетпочты статусразборапочтовогосообщения "+"режимтранзакциизаписижурналарегистрации статустранзакциизаписижурналарегистрации уровеньжурналарегистрации "+"расположениехранилищасертификатовкриптографии режимвключениясертификатовкриптографии режимпроверкисертификатакриптографии типхранилищасертификатовкриптографии "+"кодировкаименфайловвzipфайле методсжатияzip методшифрованияzip режимвосстановленияпутейфайловzip режимобработкиподкаталоговzip режимсохраненияпутейzip уровеньсжатияzip "+"звуковоеоповещение направлениепереходакстроке позициявпотоке порядокбайтов режимблокировкиданных режимуправленияблокировкойданных сервисвстроенныхпокупок состояниефоновогозадания типподписчикадоставляемыхуведомлений уровеньиспользованиязащищенногосоединенияftp "+"направлениепорядкасхемызапроса типдополненияпериодамисхемызапроса типконтрольнойточкисхемызапроса типобъединениясхемызапроса типпараметрадоступнойтаблицысхемызапроса типсоединениясхемызапроса "+"httpметод автоиспользованиеобщегореквизита автопрефиксномеразадачи вариантвстроенногоязыка видиерархии видрегистранакопления видтаблицывнешнегоисточникаданных записьдвиженийприпроведении заполнениепоследовательностей индексирование использованиебазыпланавидоврасчета использованиебыстроговыбора использованиеобщегореквизита использованиеподчинения использованиеполнотекстовогопоиска использованиеразделяемыхданныхобщегореквизита использованиереквизита назначениеиспользованияприложения назначениерасширенияконфигурации направлениепередачи обновлениепредопределенныхданных оперативноепроведение основноепредставлениевидарасчета основноепредставлениевидахарактеристики основноепредставлениезадачи основноепредставлениепланаобмена основноепредставлениесправочника основноепредставлениесчета перемещениеграницыприпроведении периодичностьномерабизнеспроцесса периодичностьномерадокумента периодичностьрегистрарасчета периодичностьрегистрасведений повторноеиспользованиевозвращаемыхзначений полнотекстовыйпоискпривводепостроке принадлежностьобъекта проведение разделениеаутентификацииобщегореквизита разделениеданныхобщегореквизита разделениерасширенийконфигурацииобщегореквизита режимавтонумерацииобъектов режимзаписирегистра режимиспользованиямодальности режимиспользованиясинхронныхвызововрасширенийплатформыивнешнихкомпонент режимповторногоиспользованиясеансов режимполученияданныхвыборапривводепостроке режимсовместимости режимсовместимостиинтерфейса режимуправленияблокировкойданныхпоумолчанию сериикодовпланавидовхарактеристик сериикодовпланасчетов сериикодовсправочника созданиепривводе способвыбора способпоискастрокипривводепостроке способредактирования типданныхтаблицывнешнегоисточникаданных типкодапланавидоврасчета типкодасправочника типмакета типномерабизнеспроцесса типномерадокумента типномеразадачи типформы удалениедвижений "+"важностьпроблемыприменениярасширенияконфигурации вариантинтерфейсаклиентскогоприложения вариантмасштабаформклиентскогоприложения вариантосновногошрифтаклиентскогоприложения вариантстандартногопериода вариантстандартнойдатыначала видграницы видкартинки видотображенияполнотекстовогопоиска видрамки видсравнения видцвета видчисловогозначения видшрифта допустимаядлина допустимыйзнак использованиеbyteordermark использованиеметаданныхполнотекстовогопоиска источникрасширенийконфигурации клавиша кодвозвратадиалога кодировкаxbase кодировкатекста направлениепоиска направлениесортировки обновлениепредопределенныхданных обновлениеприизмененииданных отображениепанелиразделов проверказаполнения режимдиалогавопрос режимзапускаклиентскогоприложения режимокругления режимоткрытияформприложения режимполнотекстовогопоиска скоростьклиентскогосоединения состояниевнешнегоисточникаданных состояниеобновленияконфигурациибазыданных способвыборасертификатаwindows способкодированиястроки статуссообщения типвнешнейкомпоненты типплатформы типповеденияклавишиenter типэлементаинформацииовыполненииобновленияконфигурациибазыданных уровеньизоляциитранзакций хешфункция частидаты",q="comобъект ftpсоединение httpзапрос httpсервисответ httpсоединение wsопределения wsпрокси xbase анализданных аннотацияxs блокировкаданных буфердвоичныхданных включениеxs выражениекомпоновкиданных генераторслучайныхчисел географическаясхема географическиекоординаты графическаясхема группамоделиxs данныерасшифровкикомпоновкиданных двоичныеданные дендрограмма диаграмма диаграммаганта диалогвыборафайла диалогвыборацвета диалогвыборашрифта диалограсписаниярегламентногозадания диалогредактированиястандартногопериода диапазон документdom документhtml документацияxs доставляемоеуведомление записьdom записьfastinfoset записьhtml записьjson записьxml записьzipфайла записьданных записьтекста записьузловdom запрос защищенноесоединениеopenssl значенияполейрасшифровкикомпоновкиданных извлечениетекста импортxs интернетпочта интернетпочтовоесообщение интернетпочтовыйпрофиль интернетпрокси интернетсоединение информациядляприложенияxs использованиеатрибутаxs использованиесобытияжурналарегистрации источникдоступныхнастроеккомпоновкиданных итераторузловdom картинка квалификаторыдаты квалификаторыдвоичныхданных квалификаторыстроки квалификаторычисла компоновщикмакетакомпоновкиданных компоновщикнастроеккомпоновкиданных конструктормакетаоформлениякомпоновкиданных конструкторнастроеккомпоновкиданных конструкторформатнойстроки линия макеткомпоновкиданных макетобластикомпоновкиданных макетоформлениякомпоновкиданных маскаxs менеджеркриптографии наборсхемxml настройкикомпоновкиданных настройкисериализацииjson обработкакартинок обработкарасшифровкикомпоновкиданных обходдереваdom объявлениеатрибутаxs объявлениенотацииxs объявлениеэлементаxs описаниеиспользованиясобытиядоступжурналарегистрации описаниеиспользованиясобытияотказвдоступежурналарегистрации описаниеобработкирасшифровкикомпоновкиданных описаниепередаваемогофайла описаниетипов определениегруппыатрибутовxs определениегруппымоделиxs определениеограниченияидентичностиxs определениепростоготипаxs определениесоставноготипаxs определениетипадокументаdom определенияxpathxs отборкомпоновкиданных пакетотображаемыхдокументов параметрвыбора параметркомпоновкиданных параметрызаписиjson параметрызаписиxml параметрычтенияxml переопределениеxs планировщик полеанализаданных полекомпоновкиданных построительdom построительзапроса построительотчета построительотчетаанализаданных построительсхемxml поток потоквпамяти почта почтовоесообщение преобразованиеxsl преобразованиекканоническомуxml процессорвыводарезультатакомпоновкиданныхвколлекциюзначений процессорвыводарезультатакомпоновкиданныхвтабличныйдокумент процессоркомпоновкиданных разыменовательпространствименdom рамка расписаниерегламентногозадания расширенноеимяxml результатчтенияданных своднаядиаграмма связьпараметравыбора связьпотипу связьпотипукомпоновкиданных сериализаторxdto сертификатклиентаwindows сертификатклиентафайл сертификаткриптографии сертификатыудостоверяющихцентровwindows сертификатыудостоверяющихцентровфайл сжатиеданных системнаяинформация сообщениепользователю сочетаниеклавиш сравнениезначений стандартнаядатаначала стандартныйпериод схемаxml схемакомпоновкиданных табличныйдокумент текстовыйдокумент тестируемоеприложение типданныхxml уникальныйидентификатор фабрикаxdto файл файловыйпоток фасетдлиныxs фасетколичестваразрядовдробнойчастиxs фасетмаксимальноговключающегозначенияxs фасетмаксимальногоисключающегозначенияxs фасетмаксимальнойдлиныxs фасетминимальноговключающегозначенияxs фасетминимальногоисключающегозначенияxs фасетминимальнойдлиныxs фасетобразцаxs фасетобщегоколичестваразрядовxs фасетперечисленияxs фасетпробельныхсимволовxs фильтрузловdom форматированнаястрока форматированныйдокумент фрагментxs хешированиеданных хранилищезначения цвет чтениеfastinfoset чтениеhtml чтениеjson чтениеxml чтениеzipфайла чтениеданных чтениетекста чтениеузловdom шрифт элементрезультатакомпоновкиданных "+"comsafearray деревозначений массив соответствие списокзначений структура таблицазначений фиксированнаяструктура фиксированноесоответствие фиксированныймассив ",V="null истина ложь неопределено",Y=e.inherit(e.NUMBER_MODE),j={className:"string",begin:'"|\\|',end:'"|$',contains:[{begin:'""'}]},Q={begin:"'",end:"'",excludeBegin:!0,excludeEnd:!0,contains:[{className:"number",begin:"\\d{4}([\\.\\\\/:-]?\\d{2}){0,5}"}]},ae={match:/[;()+\-:=,]/,className:"punctuation",relevance:0},re=e.inherit(e.C_LINE_COMMENT_MODE),ne={className:"meta",begin:"#|&",end:"$",keywords:{$pattern:r,keyword:a+l},contains:[re]},ee={className:"symbol",begin:"~",end:";|:",excludeEnd:!0},J={className:"function",variants:[{begin:"процедура|функция",end:"\\)",keywords:"процедура функция"},{begin:"конецпроцедуры|конецфункции",keywords:"конецпроцедуры конецфункции"}],contains:[{begin:"\\(",end:"\\)",endsParent:!0,contains:[{className:"params",begin:r,end:",",excludeEnd:!0,endsWithParent:!0,keywords:{$pattern:r,keyword:"знач",literal:V},contains:[Y,j,Q]},re]},e.inherit(e.TITLE_MODE,{begin:r})]};return{name:"1C:Enterprise",case_insensitive:!0,keywords:{$pattern:r,keyword:a,built_in:p,class:B,type:q,literal:V},contains:[ne,J,re,ee,Y,j,Q,ae]}}return AH=t,AH}var RH,P_e;function Vwt(){if(P_e)return RH;P_e=1;function t(e){const r=e.regex,n=/^[a-zA-Z][a-zA-Z0-9-]*/,i=["ALPHA","BIT","CHAR","CR","CRLF","CTL","DIGIT","DQUOTE","HEXDIG","HTAB","LF","LWSP","OCTET","SP","VCHAR","WSP"],a=e.COMMENT(/;/,/$/),s={scope:"symbol",match:/%b[0-1]+(-[0-1]+|(\.[0-1]+)+)?/},o={scope:"symbol",match:/%d[0-9]+(-[0-9]+|(\.[0-9]+)+)?/},l={scope:"symbol",match:/%x[0-9A-F]+(-[0-9A-F]+|(\.[0-9A-F]+)+)?/},u={scope:"symbol",match:/%[si](?=".*")/},d={scope:"attribute",match:r.concat(n,/(?=\s*=)/)};return{name:"Augmented Backus-Naur Form",illegal:/[!@#$^&',?+~`|:]/,keywords:i,contains:[{scope:"operator",match:/=\/?/},d,a,s,o,l,u,e.QUOTE_STRING_MODE,e.NUMBER_MODE]}}return RH=t,RH}var NH,F_e;function Ywt(){if(F_e)return NH;F_e=1;function t(e){const r=e.regex,n=["GET","POST","HEAD","PUT","DELETE","CONNECT","OPTIONS","PATCH","TRACE"];return{name:"Apache Access Log",contains:[{className:"number",begin:/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?\b/,relevance:5},{className:"number",begin:/\b\d+\b/,relevance:0},{className:"string",begin:r.concat(/"/,r.either(...n)),end:/"/,keywords:n,illegal:/\n/,relevance:5,contains:[{begin:/HTTP\/[12]\.\d'/,relevance:5}]},{className:"string",begin:/\[\d[^\]\n]{8,}\]/,illegal:/\n/,relevance:1},{className:"string",begin:/\[/,end:/\]/,illegal:/\n/,relevance:0},{className:"string",begin:/"Mozilla\/\d\.\d \(/,end:/"/,illegal:/\n/,relevance:3},{className:"string",begin:/"/,end:/"/,illegal:/\n/,relevance:0}]}}return NH=t,NH}var OH,B_e;function Wwt(){if(B_e)return OH;B_e=1;function t(e){const r=e.regex,n=/[a-zA-Z_$][a-zA-Z0-9_$]*/,i=r.concat(n,r.concat("(\\.",n,")*")),a=/([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/,s={className:"rest_arg",begin:/[.]{3}/,end:n,relevance:10};return{name:"ActionScript",aliases:["as"],keywords:{keyword:["as","break","case","catch","class","const","continue","default","delete","do","dynamic","each","else","extends","final","finally","for","function","get","if","implements","import","in","include","instanceof","interface","internal","is","namespace","native","new","override","package","private","protected","public","return","set","static","super","switch","this","throw","try","typeof","use","var","void","while","with"],literal:["true","false","null","undefined"]},contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.C_NUMBER_MODE,{match:[/\bpackage/,/\s+/,i],className:{1:"keyword",3:"title.class"}},{match:[/\b(?:class|interface|extends|implements)/,/\s+/,n],className:{1:"keyword",3:"title.class"}},{className:"meta",beginKeywords:"import include",end:/;/,keywords:{keyword:"import include"}},{beginKeywords:"function",end:/[{;]/,excludeEnd:!0,illegal:/\S/,contains:[e.inherit(e.TITLE_MODE,{className:"title.function"}),{className:"params",begin:/\(/,end:/\)/,contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,s]},{begin:r.concat(/:\s*/,a)}]},e.METHOD_GUARD],illegal:/#/}}return OH=t,OH}var IH,U_e;function Kwt(){if(U_e)return IH;U_e=1;function t(e){const r="\\d(_|\\d)*",n="[eE][-+]?"+r,i=r+"(\\."+r+")?("+n+")?",a="\\w+",o="\\b("+(r+"#"+a+"(\\."+a+")?#("+n+")?")+"|"+i+")",l="[A-Za-z](_?[A-Za-z0-9.])*",u=`[]\\{\\}%#'"`,d=e.COMMENT("--","$"),h={begin:"\\s+:\\s+",end:"\\s*(:=|;|\\)|=>|$)",illegal:u,contains:[{beginKeywords:"loop for declare others",endsParent:!0},{className:"keyword",beginKeywords:"not null constant access function procedure in out aliased exception"},{className:"type",begin:l,endsParent:!0,relevance:0}]};return{name:"Ada",case_insensitive:!0,keywords:{keyword:["abort","else","new","return","abs","elsif","not","reverse","abstract","end","accept","entry","select","access","exception","of","separate","aliased","exit","or","some","all","others","subtype","and","for","out","synchronized","array","function","overriding","at","tagged","generic","package","task","begin","goto","pragma","terminate","body","private","then","if","procedure","type","case","in","protected","constant","interface","is","raise","use","declare","range","delay","limited","record","when","delta","loop","rem","while","digits","renames","with","do","mod","requeue","xor"],literal:["True","False"]},contains:[d,{className:"string",begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{className:"string",begin:/'.'/},{className:"number",begin:o,relevance:0},{className:"symbol",begin:"'"+l},{className:"title",begin:"(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?",end:"(is|$)",keywords:"package body",excludeBegin:!0,excludeEnd:!0,illegal:u},{begin:"(\\b(with|overriding)\\s+)?\\b(function|procedure)\\s+",end:"(\\bis|\\bwith|\\brenames|\\)\\s*;)",keywords:"overriding function procedure with is renames return",returnBegin:!0,contains:[d,{className:"title",begin:"(\\bwith\\s+)?\\b(function|procedure)\\s+",end:"(\\(|\\s+|$)",excludeBegin:!0,excludeEnd:!0,illegal:u},h,{className:"type",begin:"\\breturn\\s+",end:"(\\s+|;|$)",keywords:"return",excludeBegin:!0,excludeEnd:!0,endsParent:!0,illegal:u}]},{className:"type",begin:"\\b(sub)?type\\s+",end:"\\s+",keywords:"type",excludeBegin:!0,illegal:u},h]}}return IH=t,IH}var kH,$_e;function jwt(){if($_e)return kH;$_e=1;function t(e){const r={className:"built_in",begin:"\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)"},n={className:"symbol",begin:"[a-zA-Z0-9_]+@"},i={className:"keyword",begin:"<",end:">",contains:[r,n]};return r.contains=[i],n.contains=[i],{name:"AngelScript",aliases:["asc"],keywords:["for","in|0","break","continue","while","do|0","return","if","else","case","switch","namespace","is","cast","or","and","xor","not","get|0","in","inout|10","out","override","set|0","private","public","const","default|0","final","shared","external","mixin|10","enum","typedef","funcdef","this","super","import","from","interface","abstract|0","try","catch","protected","explicit","property"],illegal:"(^using\\s+[A-Za-z0-9_\\.]+;$|\\bfunction\\s*[^\\(])",contains:[{className:"string",begin:"'",end:"'",illegal:"\\n",contains:[e.BACKSLASH_ESCAPE],relevance:0},{className:"string",begin:'"""',end:'"""'},{className:"string",begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE],relevance:0},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"string",begin:"^\\s*\\[",end:"\\]"},{beginKeywords:"interface namespace",end:/\{/,illegal:"[;.\\-]",contains:[{className:"symbol",begin:"[a-zA-Z0-9_]+"}]},{beginKeywords:"class",end:/\{/,illegal:"[;.\\-]",contains:[{className:"symbol",begin:"[a-zA-Z0-9_]+",contains:[{begin:"[:,]\\s*",contains:[{className:"symbol",begin:"[a-zA-Z0-9_]+"}]}]}]},r,n,{className:"literal",begin:"\\b(null|true|false)"},{className:"number",relevance:0,begin:"(-?)(\\b0[xXbBoOdD][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?f?|\\.\\d+f?)([eE][-+]?\\d+f?)?)"}]}}return kH=t,kH}var DH,G_e;function Xwt(){if(G_e)return DH;G_e=1;function t(e){const r={className:"number",begin:/[$%]\d+/},n={className:"number",begin:/\b\d+/},i={className:"number",begin:/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?/},a={className:"number",begin:/:\d{1,5}/};return{name:"Apache config",aliases:["apacheconf"],case_insensitive:!0,contains:[e.HASH_COMMENT_MODE,{className:"section",begin:/<\/?/,end:/>/,contains:[i,a,e.inherit(e.QUOTE_STRING_MODE,{relevance:0})]},{className:"attribute",begin:/\w+/,relevance:0,keywords:{_:["order","deny","allow","setenv","rewriterule","rewriteengine","rewritecond","documentroot","sethandler","errordocument","loadmodule","options","header","listen","serverroot","servername"]},starts:{end:/$/,relevance:0,keywords:{literal:"on off all deny allow"},contains:[{scope:"punctuation",match:/\\\n/},{className:"meta",begin:/\s\[/,end:/\]$/},{className:"variable",begin:/[\$%]\{/,end:/\}/,contains:["self",r]},i,n,e.QUOTE_STRING_MODE]}}],illegal:/\S/}}return DH=t,DH}var MH,z_e;function Qwt(){if(z_e)return MH;z_e=1;function t(e){const r=e.regex,n=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),i={className:"params",begin:/\(/,end:/\)/,contains:["self",e.C_NUMBER_MODE,n]},a=e.COMMENT(/--/,/$/),s=e.COMMENT(/\(\*/,/\*\)/,{contains:["self",a]}),o=[a,s,e.HASH_COMMENT_MODE],l=[/apart from/,/aside from/,/instead of/,/out of/,/greater than/,/isn't|(doesn't|does not) (equal|come before|come after|contain)/,/(greater|less) than( or equal)?/,/(starts?|ends|begins?) with/,/contained by/,/comes (before|after)/,/a (ref|reference)/,/POSIX (file|path)/,/(date|time) string/,/quoted form/],u=[/clipboard info/,/the clipboard/,/info for/,/list (disks|folder)/,/mount volume/,/path to/,/(close|open for) access/,/(get|set) eof/,/current date/,/do shell script/,/get volume settings/,/random number/,/set volume/,/system attribute/,/system info/,/time to GMT/,/(load|run|store) script/,/scripting components/,/ASCII (character|number)/,/localized string/,/choose (application|color|file|file name|folder|from list|remote application|URL)/,/display (alert|dialog)/];return{name:"AppleScript",aliases:["osascript"],keywords:{keyword:"about above after against and around as at back before beginning behind below beneath beside between but by considering contain contains continue copy div does eighth else end equal equals error every exit fifth first for fourth from front get given global if ignoring in into is it its last local me middle mod my ninth not of on onto or over prop property put ref reference repeat returning script second set seventh since sixth some tell tenth that the|0 then third through thru timeout times to transaction try until where while whose with without",literal:"AppleScript false linefeed return pi quote result space tab true",built_in:"alias application boolean class constant date file integer list number real record string text activate beep count delay launch log offset read round run say summarize write character characters contents day frontmost id item length month name|0 paragraph paragraphs rest reverse running time version weekday word words year"},contains:[n,e.C_NUMBER_MODE,{className:"built_in",begin:r.concat(/\b/,r.either(...u),/\b/)},{className:"built_in",begin:/^\s*return\b/},{className:"literal",begin:/\b(text item delimiters|current application|missing value)\b/},{className:"keyword",begin:r.concat(/\b/,r.either(...l),/\b/)},{beginKeywords:"on",illegal:/[${=;\n]/,contains:[e.UNDERSCORE_TITLE_MODE,i]},...o],illegal:/\/\/|->|=>|\[\[/}}return MH=t,MH}var LH,q_e;function Zwt(){if(q_e)return LH;q_e=1;function t(e){const r=e.regex,n="[A-Za-z_][0-9A-Za-z_]*",i={keyword:["break","case","catch","continue","debugger","do","else","export","for","function","if","import","in","new","of","return","switch","try","var","void","while"],literal:["BackSlash","DoubleQuote","ForwardSlash","Infinity","NaN","NewLine","PI","SingleQuote","Tab","TextFormatting","false","null","true","undefined"],built_in:["Abs","Acos","All","Angle","Any","Area","AreaGeodetic","Array","Asin","Atan","Atan2","Attachments","Average","Back","Bearing","Boolean","Buffer","BufferGeodetic","Ceil","Centroid","ChangeTimeZone","Clip","Concatenate","Console","Constrain","Contains","ConvertDirection","ConvexHull","Cos","Count","Crosses","Cut","Date|0","DateAdd","DateDiff","DateOnly","Day","Decode","DefaultValue","Densify","DensifyGeodetic","Dictionary","Difference","Disjoint","Distance","DistanceGeodetic","DistanceToCoordinate","Distinct","Domain","DomainCode","DomainName","EnvelopeIntersects","Equals","Erase","Exp","Expects","Extent","Feature","FeatureInFilter","FeatureSet","FeatureSetByAssociation","FeatureSetById","FeatureSetByName","FeatureSetByPortalItem","FeatureSetByRelationshipClass","FeatureSetByRelationshipName","Filter","FilterBySubtypeCode","Find","First|0","Floor","FromCharCode","FromCodePoint","FromJSON","Front","GdbVersion","Generalize","Geometry","GetEnvironment","GetFeatureSet","GetFeatureSetInfo","GetUser","GroupBy","Guid","HasKey","HasValue","Hash","Hour","IIf","ISOMonth","ISOWeek","ISOWeekday","ISOYear","Includes","IndexOf","Insert","Intersection","Intersects","IsEmpty","IsNan","IsSelfIntersecting","IsSimple","KnowledgeGraphByPortalItem","Left|0","Length","Length3D","LengthGeodetic","Log","Lower","Map","Max","Mean","MeasureToCoordinate","Mid","Millisecond","Min","Minute","Month","MultiPartToSinglePart","Multipoint","NearestCoordinate","NearestVertex","NextSequenceValue","None","Now","Number","Offset","OrderBy","Overlaps","Point","PointToCoordinate","Polygon","Polyline","Pop","Portal","Pow","Proper","Push","QueryGraph","Random","Reduce","Relate","Replace","Resize","Reverse","Right|0","RingIsClockwise","Rotate","Round","Schema","Second","SetGeometry","Simplify","Sin","Slice","Sort","Splice","Split","Sqrt","StandardizeFilename","StandardizeGuid","Stdev","SubtypeCode","SubtypeName","Subtypes","Sum","SymmetricDifference","Tan","Text","Time","TimeZone","TimeZoneOffset","Timestamp","ToCharCode","ToCodePoint","ToHex","ToLocal","ToUTC","Today","Top|0","Touches","TrackAccelerationAt","TrackAccelerationWindow","TrackCurrentAcceleration","TrackCurrentDistance","TrackCurrentSpeed","TrackCurrentTime","TrackDistanceAt","TrackDistanceWindow","TrackDuration","TrackFieldWindow","TrackGeometryWindow","TrackIndex","TrackSpeedAt","TrackSpeedWindow","TrackStartTime","TrackWindow","Trim","TypeOf","Union","Upper","UrlEncode","Variance","Week","Weekday","When|0","Within","Year|0"]},a=["aggregatedFeatures","analytic","config","datapoint","datastore","editcontext","feature","featureSet","feedfeature","fencefeature","fencenotificationtype","graph","join","layer","locationupdate","map","measure","measure","originalFeature","record","reference","rowindex","sourcedatastore","sourcefeature","sourcelayer","target","targetdatastore","targetfeature","targetlayer","userInput","value","variables","view"],s={className:"symbol",begin:"\\$"+r.either(...a)},o={className:"number",variants:[{begin:"\\b(0[bB][01]+)"},{begin:"\\b(0[oO][0-7]+)"},{begin:e.C_NUMBER_RE}],relevance:0},l={className:"subst",begin:"\\$\\{",end:"\\}",keywords:i,contains:[]},u={className:"string",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE,l]};l.contains=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,u,o,e.REGEXP_MODE];const d=l.contains.concat([e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE]);return{name:"ArcGIS Arcade",case_insensitive:!0,keywords:i,contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,u,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,s,o,{begin:/[{,]\s*/,relevance:0,contains:[{begin:n+"\\s*:",returnBegin:!0,relevance:0,contains:[{className:"attr",begin:n,relevance:0}]}]},{begin:"("+e.RE_STARTERS_RE+"|\\b(return)\\b)\\s*",keywords:"return",contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.REGEXP_MODE,{className:"function",begin:"(\\(.*?\\)|"+n+")\\s*=>",returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:n},{begin:/\(\s*\)/},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:i,contains:d}]}]}],relevance:0},{beginKeywords:"function",end:/\{/,excludeEnd:!0,contains:[e.inherit(e.TITLE_MODE,{className:"title.function",begin:n}),{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:d}],illegal:/\[|%/},{begin:/\$[(.]/}],illegal:/#(?!!)/}}return LH=t,LH}var PH,H_e;function Jwt(){if(H_e)return PH;H_e=1;function t(r){const n=r.regex,i=r.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),a="decltype\\(auto\\)",s="[a-zA-Z_]\\w*::",l="(?!struct)("+a+"|"+n.optional(s)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",u={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},h={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[r.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'("+"\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)"+"|.)",end:"'",illegal:"."},r.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},f={className:"number",variants:[{begin:"[+-]?(?:(?:[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|0[Xx](?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)[Pp][+-]?[0-9](?:'?[0-9])*)(?:[Ff](?:16|32|64|128)?|(BF|bf)16|[Ll]|)"},{begin:"[+-]?\\b(?:0[Bb][01](?:'?[01])*|0[Xx][0-9A-Fa-f](?:'?[0-9A-Fa-f])*|0(?:'?[0-7])*|[1-9](?:'?[0-9])*)(?:[Uu](?:LL?|ll?)|[Uu][Zz]?|(?:LL?|ll?)[Uu]?|[Zz][Uu]|)"}],relevance:0},p={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"},contains:[{begin:/\\\n/,relevance:0},r.inherit(h,{className:"string"}),{className:"string",begin:/<.*?>/},i,r.C_BLOCK_COMMENT_MODE]},g={className:"title",begin:n.optional(s)+r.IDENT_RE,relevance:0},m=n.optional(s)+r.IDENT_RE+"\\s*\\(",_=["alignas","alignof","and","and_eq","asm","atomic_cancel","atomic_commit","atomic_noexcept","auto","bitand","bitor","break","case","catch","class","co_await","co_return","co_yield","compl","concept","const_cast|10","consteval","constexpr","constinit","continue","decltype","default","delete","do","dynamic_cast|10","else","enum","explicit","export","extern","false","final","for","friend","goto","if","import","inline","module","mutable","namespace","new","noexcept","not","not_eq","nullptr","operator","or","or_eq","override","private","protected","public","reflexpr","register","reinterpret_cast|10","requires","return","sizeof","static_assert","static_cast|10","struct","switch","synchronized","template","this","thread_local","throw","transaction_safe","transaction_safe_dynamic","true","try","typedef","typeid","typename","union","using","virtual","volatile","while","xor","xor_eq"],v=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],b=["any","auto_ptr","barrier","binary_semaphore","bitset","complex","condition_variable","condition_variable_any","counting_semaphore","deque","false_type","flat_map","flat_set","future","imaginary","initializer_list","istringstream","jthread","latch","lock_guard","multimap","multiset","mutex","optional","ostringstream","packaged_task","pair","promise","priority_queue","queue","recursive_mutex","recursive_timed_mutex","scoped_lock","set","shared_future","shared_lock","shared_mutex","shared_timed_mutex","shared_ptr","stack","string_view","stringstream","timed_mutex","thread","true_type","tuple","unique_lock","unique_ptr","unordered_map","unordered_multimap","unordered_multiset","unordered_set","variant","vector","weak_ptr","wstring","wstring_view"],y=["abort","abs","acos","apply","as_const","asin","atan","atan2","calloc","ceil","cerr","cin","clog","cos","cosh","cout","declval","endl","exchange","exit","exp","fabs","floor","fmod","forward","fprintf","fputs","free","frexp","fscanf","future","invoke","isalnum","isalpha","iscntrl","isdigit","isgraph","islower","isprint","ispunct","isspace","isupper","isxdigit","labs","launder","ldexp","log","log10","make_pair","make_shared","make_shared_for_overwrite","make_tuple","make_unique","malloc","memchr","memcmp","memcpy","memset","modf","move","pow","printf","putchar","puts","realloc","scanf","sin","sinh","snprintf","sprintf","sqrt","sscanf","std","stderr","stdin","stdout","strcat","strchr","strcmp","strcpy","strcspn","strlen","strncat","strncmp","strncpy","strpbrk","strrchr","strspn","strstr","swap","tan","tanh","terminate","to_underlying","tolower","toupper","vfprintf","visit","vprintf","vsprintf"],C={type:v,keyword:_,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:b},w={className:"function.dispatch",relevance:0,keywords:{_hint:y},begin:n.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,r.IDENT_RE,n.lookahead(/(<[^<>]+>|)\s*\(/))},x=[w,p,u,i,r.C_BLOCK_COMMENT_MODE,f,h],A={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:C,contains:x.concat([{begin:/\(/,end:/\)/,keywords:C,contains:x.concat(["self"]),relevance:0}]),relevance:0},R={className:"function",begin:"("+l+"[\\*&\\s]+)+"+m,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:C,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:a,keywords:C,relevance:0},{begin:m,returnBegin:!0,contains:[g],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[h,f]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:C,relevance:0,contains:[i,r.C_BLOCK_COMMENT_MODE,h,f,u,{begin:/\(/,end:/\)/,keywords:C,relevance:0,contains:["self",i,r.C_BLOCK_COMMENT_MODE,h,f,u]}]},u,i,r.C_BLOCK_COMMENT_MODE,p]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:C,illegal:"",keywords:C,contains:["self",u]},{begin:r.IDENT_RE+"::",keywords:C},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}function e(r){const n={type:["boolean","byte","word","String"],built_in:["KeyboardController","MouseController","SoftwareSerial","EthernetServer","EthernetClient","LiquidCrystal","RobotControl","GSMVoiceCall","EthernetUDP","EsploraTFT","HttpClient","RobotMotor","WiFiClient","GSMScanner","FileSystem","Scheduler","GSMServer","YunClient","YunServer","IPAddress","GSMClient","GSMModem","Keyboard","Ethernet","Console","GSMBand","Esplora","Stepper","Process","WiFiUDP","GSM_SMS","Mailbox","USBHost","Firmata","PImage","Client","Server","GSMPIN","FileIO","Bridge","Serial","EEPROM","Stream","Mouse","Audio","Servo","File","Task","GPRS","WiFi","Wire","TFT","GSM","SPI","SD"],_hints:["setup","loop","runShellCommandAsynchronously","analogWriteResolution","retrieveCallingNumber","printFirmwareVersion","analogReadResolution","sendDigitalPortPair","noListenOnLocalhost","readJoystickButton","setFirmwareVersion","readJoystickSwitch","scrollDisplayRight","getVoiceCallStatus","scrollDisplayLeft","writeMicroseconds","delayMicroseconds","beginTransmission","getSignalStrength","runAsynchronously","getAsynchronously","listenOnLocalhost","getCurrentCarrier","readAccelerometer","messageAvailable","sendDigitalPorts","lineFollowConfig","countryNameWrite","runShellCommand","readStringUntil","rewindDirectory","readTemperature","setClockDivider","readLightSensor","endTransmission","analogReference","detachInterrupt","countryNameRead","attachInterrupt","encryptionType","readBytesUntil","robotNameWrite","readMicrophone","robotNameRead","cityNameWrite","userNameWrite","readJoystickY","readJoystickX","mouseReleased","openNextFile","scanNetworks","noInterrupts","digitalWrite","beginSpeaker","mousePressed","isActionDone","mouseDragged","displayLogos","noAutoscroll","addParameter","remoteNumber","getModifiers","keyboardRead","userNameRead","waitContinue","processInput","parseCommand","printVersion","readNetworks","writeMessage","blinkVersion","cityNameRead","readMessage","setDataMode","parsePacket","isListening","setBitOrder","beginPacket","isDirectory","motorsWrite","drawCompass","digitalRead","clearScreen","serialEvent","rightToLeft","setTextSize","leftToRight","requestFrom","keyReleased","compassRead","analogWrite","interrupts","WiFiServer","disconnect","playMelody","parseFloat","autoscroll","getPINUsed","setPINUsed","setTimeout","sendAnalog","readSlider","analogRead","beginWrite","createChar","motorsStop","keyPressed","tempoWrite","readButton","subnetMask","debugPrint","macAddress","writeGreen","randomSeed","attachGPRS","readString","sendString","remotePort","releaseAll","mouseMoved","background","getXChange","getYChange","answerCall","getResult","voiceCall","endPacket","constrain","getSocket","writeJSON","getButton","available","connected","findUntil","readBytes","exitValue","readGreen","writeBlue","startLoop","IPAddress","isPressed","sendSysex","pauseMode","gatewayIP","setCursor","getOemKey","tuneWrite","noDisplay","loadImage","switchPIN","onRequest","onReceive","changePIN","playFile","noBuffer","parseInt","overflow","checkPIN","knobRead","beginTFT","bitClear","updateIR","bitWrite","position","writeRGB","highByte","writeRed","setSpeed","readBlue","noStroke","remoteIP","transfer","shutdown","hangCall","beginSMS","endWrite","attached","maintain","noCursor","checkReg","checkPUK","shiftOut","isValid","shiftIn","pulseIn","connect","println","localIP","pinMode","getIMEI","display","noBlink","process","getBand","running","beginSD","drawBMP","lowByte","setBand","release","bitRead","prepare","pointTo","readRed","setMode","noFill","remove","listen","stroke","detach","attach","noTone","exists","buffer","height","bitSet","circle","config","cursor","random","IRread","setDNS","endSMS","getKey","micros","millis","begin","print","write","ready","flush","width","isPIN","blink","clear","press","mkdir","rmdir","close","point","yield","image","BSSID","click","delay","read","text","move","peek","beep","rect","line","open","seek","fill","size","turn","stop","home","find","step","tone","sqrt","RSSI","SSID","end","bit","tan","cos","sin","pow","map","abs","max","min","get","run","put"],literal:["DIGITAL_MESSAGE","FIRMATA_STRING","ANALOG_MESSAGE","REPORT_DIGITAL","REPORT_ANALOG","INPUT_PULLUP","SET_PIN_MODE","INTERNAL2V56","SYSTEM_RESET","LED_BUILTIN","INTERNAL1V1","SYSEX_START","INTERNAL","EXTERNAL","DEFAULT","OUTPUT","INPUT","HIGH","LOW"]},i=t(r),a=i.keywords;return a.type=[...a.type,...n.type],a.literal=[...a.literal,...n.literal],a.built_in=[...a.built_in,...n.built_in],a._hints=n._hints,i.name="Arduino",i.aliases=["ino"],i.supersetOf="cpp",i}return PH=e,PH}var FH,V_e;function e3t(){if(V_e)return FH;V_e=1;function t(e){const r={variants:[e.COMMENT("^[ \\t]*(?=#)","$",{relevance:0,excludeBegin:!0}),e.COMMENT("[;@]","$",{relevance:0}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]};return{name:"ARM Assembly",case_insensitive:!0,aliases:["arm"],keywords:{$pattern:"\\.?"+e.IDENT_RE,meta:".2byte .4byte .align .ascii .asciz .balign .byte .code .data .else .end .endif .endm .endr .equ .err .exitm .extern .global .hword .if .ifdef .ifndef .include .irp .long .macro .rept .req .section .set .skip .space .text .word .arm .thumb .code16 .code32 .force_thumb .thumb_func .ltorg ALIAS ALIGN ARM AREA ASSERT ATTR CN CODE CODE16 CODE32 COMMON CP DATA DCB DCD DCDU DCDO DCFD DCFDU DCI DCQ DCQU DCW DCWU DN ELIF ELSE END ENDFUNC ENDIF ENDP ENTRY EQU EXPORT EXPORTAS EXTERN FIELD FILL FUNCTION GBLA GBLL GBLS GET GLOBAL IF IMPORT INCBIN INCLUDE INFO KEEP LCLA LCLL LCLS LTORG MACRO MAP MEND MEXIT NOFP OPT PRESERVE8 PROC QN READONLY RELOC REQUIRE REQUIRE8 RLIST FN ROUT SETA SETL SETS SN SPACE SUBT THUMB THUMBX TTL WHILE WEND ",built_in:"r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 w0 w1 w2 w3 w4 w5 w6 w7 w8 w9 w10 w11 w12 w13 w14 w15 w16 w17 w18 w19 w20 w21 w22 w23 w24 w25 w26 w27 w28 w29 w30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 pc lr sp ip sl sb fp a1 a2 a3 a4 v1 v2 v3 v4 v5 v6 v7 v8 f0 f1 f2 f3 f4 f5 f6 f7 p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 q0 q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12 q13 q14 q15 cpsr_c cpsr_x cpsr_s cpsr_f cpsr_cx cpsr_cxs cpsr_xs cpsr_xsf cpsr_sf cpsr_cxsf spsr_c spsr_x spsr_s spsr_f spsr_cx spsr_cxs spsr_xs spsr_xsf spsr_sf spsr_cxsf s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 s12 s13 s14 s15 s16 s17 s18 s19 s20 s21 s22 s23 s24 s25 s26 s27 s28 s29 s30 s31 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d10 d11 d12 d13 d14 d15 d16 d17 d18 d19 d20 d21 d22 d23 d24 d25 d26 d27 d28 d29 d30 d31 {PC} {VAR} {TRUE} {FALSE} {OPT} {CONFIG} {ENDIAN} {CODESIZE} {CPU} {FPU} {ARCHITECTURE} {PCSTOREOFFSET} {ARMASM_VERSION} {INTER} {ROPI} {RWPI} {SWST} {NOSWST} . @"},contains:[{className:"keyword",begin:"\\b(adc|(qd?|sh?|u[qh]?)?add(8|16)?|usada?8|(q|sh?|u[qh]?)?(as|sa)x|and|adrl?|sbc|rs[bc]|asr|b[lx]?|blx|bxj|cbn?z|tb[bh]|bic|bfc|bfi|[su]bfx|bkpt|cdp2?|clz|clrex|cmp|cmn|cpsi[ed]|cps|setend|dbg|dmb|dsb|eor|isb|it[te]{0,3}|lsl|lsr|ror|rrx|ldm(([id][ab])|f[ds])?|ldr((s|ex)?[bhd])?|movt?|mvn|mra|mar|mul|[us]mull|smul[bwt][bt]|smu[as]d|smmul|smmla|mla|umlaal|smlal?([wbt][bt]|d)|mls|smlsl?[ds]|smc|svc|sev|mia([bt]{2}|ph)?|mrr?c2?|mcrr2?|mrs|msr|orr|orn|pkh(tb|bt)|rbit|rev(16|sh)?|sel|[su]sat(16)?|nop|pop|push|rfe([id][ab])?|stm([id][ab])?|str(ex)?[bhd]?|(qd?)?sub|(sh?|q|u[qh]?)?sub(8|16)|[su]xt(a?h|a?b(16)?)|srs([id][ab])?|swpb?|swi|smi|tst|teq|wfe|wfi|yield)(eq|ne|cs|cc|mi|pl|vs|vc|hi|ls|ge|lt|gt|le|al|hs|lo)?[sptrx]?(?=\\s)"},r,e.QUOTE_STRING_MODE,{className:"string",begin:"'",end:"[^\\\\]'",relevance:0},{className:"title",begin:"\\|",end:"\\|",illegal:"\\n",relevance:0},{className:"number",variants:[{begin:"[#$=]?0x[0-9a-f]+"},{begin:"[#$=]?0b[01]+"},{begin:"[#$=]\\d+"},{begin:"\\b\\d+"}],relevance:0},{className:"symbol",variants:[{begin:"^[ \\t]*[a-z_\\.\\$][a-z0-9_\\.\\$]+:"},{begin:"^[a-z_\\.\\$][a-z0-9_\\.\\$]+"},{begin:"[=#]\\w+"}],relevance:0}]}}return FH=t,FH}var BH,Y_e;function t3t(){if(Y_e)return BH;Y_e=1;function t(e){const r=e.regex,n=r.concat(/[\p{L}_]/u,r.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),i=/[\p{L}0-9._:-]+/u,a={className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},s={begin:/\s/,contains:[{className:"keyword",begin:/#?[a-z_][a-z1-9_-]+/,illegal:/\n/}]},o=e.inherit(s,{begin:/\(/,end:/\)/}),l=e.inherit(e.APOS_STRING_MODE,{className:"string"}),u=e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),d={endsWithParent:!0,illegal:/`]+/}]}]}]};return{name:"HTML, XML",aliases:["html","xhtml","rss","atom","xjb","xsd","xsl","plist","wsf","svg"],case_insensitive:!0,unicodeRegex:!0,contains:[{className:"meta",begin://,relevance:10,contains:[s,u,l,o,{begin:/\[/,end:/\]/,contains:[{className:"meta",begin://,contains:[s,o,u,l]}]}]},e.COMMENT(//,{relevance:10}),{begin://,relevance:10},a,{className:"meta",end:/\?>/,variants:[{begin:/<\?xml/,relevance:10,contains:[u]},{begin:/<\?[a-z][a-z0-9]+/}]},{className:"tag",begin:/)/,end:/>/,keywords:{name:"style"},contains:[d],starts:{end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",begin:/)/,end:/>/,keywords:{name:"script"},contains:[d],starts:{end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{className:"tag",begin:/<>|<\/>/},{className:"tag",begin:r.concat(//,/>/,/\s/)))),end:/\/?>/,contains:[{className:"name",begin:n,relevance:0,starts:d}]},{className:"tag",begin:r.concat(/<\//,r.lookahead(r.concat(n,/>/))),contains:[{className:"name",begin:n,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}}return BH=t,BH}var UH,W_e;function r3t(){if(W_e)return UH;W_e=1;function t(e){const r=e.regex,n={begin:"^'{3,}[ \\t]*$",relevance:10},i=[{begin:/\\[*_`]/},{begin:/\\\\\*{2}[^\n]*?\*{2}/},{begin:/\\\\_{2}[^\n]*_{2}/},{begin:/\\\\`{2}[^\n]*`{2}/},{begin:/[:;}][*_`](?![*_`])/}],a=[{className:"strong",begin:/\*{2}([^\n]+?)\*{2}/},{className:"strong",begin:r.concat(/\*\*/,/((\*(?!\*)|\\[^\n]|[^*\n\\])+\n)+/,/(\*(?!\*)|\\[^\n]|[^*\n\\])*/,/\*\*/),relevance:0},{className:"strong",begin:/\B\*(\S|\S[^\n]*?\S)\*(?!\w)/},{className:"strong",begin:/\*[^\s]([^\n]+\n)+([^\n]+)\*/}],s=[{className:"emphasis",begin:/_{2}([^\n]+?)_{2}/},{className:"emphasis",begin:r.concat(/__/,/((_(?!_)|\\[^\n]|[^_\n\\])+\n)+/,/(_(?!_)|\\[^\n]|[^_\n\\])*/,/__/),relevance:0},{className:"emphasis",begin:/\b_(\S|\S[^\n]*?\S)_(?!\w)/},{className:"emphasis",begin:/_[^\s]([^\n]+\n)+([^\n]+)_/},{className:"emphasis",begin:"\\B'(?!['\\s])",end:"(\\n{2}|')",contains:[{begin:"\\\\'\\w",relevance:0}],relevance:0}],o={className:"symbol",begin:"^(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\\s+",relevance:10},l={className:"bullet",begin:"^(\\*+|-+|\\.+|[^\\n]+?::)\\s+"};return{name:"AsciiDoc",aliases:["adoc"],contains:[e.COMMENT("^/{4,}\\n","\\n/{4,}$",{relevance:10}),e.COMMENT("^//","$",{relevance:0}),{className:"title",begin:"^\\.\\w.*$"},{begin:"^[=\\*]{4,}\\n",end:"\\n^[=\\*]{4,}$",relevance:10},{className:"section",relevance:10,variants:[{begin:"^(={1,6})[ ].+?([ ]\\1)?$"},{begin:"^[^\\[\\]\\n]+?\\n[=\\-~\\^\\+]{2,}$"}]},{className:"meta",begin:"^:.+?:",end:"\\s",excludeEnd:!0,relevance:10},{className:"meta",begin:"^\\[.+?\\]$",relevance:0},{className:"quote",begin:"^_{4,}\\n",end:"\\n_{4,}$",relevance:10},{className:"code",begin:"^[\\-\\.]{4,}\\n",end:"\\n[\\-\\.]{4,}$",relevance:10},{begin:"^\\+{4,}\\n",end:"\\n\\+{4,}$",contains:[{begin:"<",end:">",subLanguage:"xml",relevance:0}],relevance:10},l,o,...i,...a,...s,{className:"string",variants:[{begin:"``.+?''"},{begin:"`.+?'"}]},{className:"code",begin:/`{2}/,end:/(\n{2}|`{2})/},{className:"code",begin:"(`.+?`|\\+.+?\\+)",relevance:0},{className:"code",begin:"^[ \\t]",end:"$",relevance:0},n,{begin:"(link:)?(http|https|ftp|file|irc|image:?):\\S+?\\[[^[]*?\\]",returnBegin:!0,contains:[{begin:"(link|image:?):",relevance:0},{className:"link",begin:"\\w",end:"[^\\[]+",relevance:0},{className:"string",begin:"\\[",end:"\\]",excludeBegin:!0,excludeEnd:!0,relevance:0}],relevance:10}]}}return UH=t,UH}var $H,K_e;function n3t(){if(K_e)return $H;K_e=1;function t(e){const r=e.regex,n=["false","synchronized","int","abstract","float","private","char","boolean","static","null","if","const","for","true","while","long","throw","strictfp","finally","protected","import","native","final","return","void","enum","else","extends","implements","break","transient","new","catch","instanceof","byte","super","volatile","case","assert","short","package","default","double","public","try","this","switch","continue","throws","privileged","aspectOf","adviceexecution","proceed","cflowbelow","cflow","initialization","preinitialization","staticinitialization","withincode","target","within","execution","getWithinTypeName","handler","thisJoinPoint","thisJoinPointStaticPart","thisEnclosingJoinPointStaticPart","declare","parents","warning","error","soft","precedence","thisAspectInstance"],i=["get","set","args","call"];return{name:"AspectJ",keywords:n,illegal:/<\/|#/,contains:[e.COMMENT(/\/\*\*/,/\*\//,{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:/@[A-Za-z]+/}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"class",beginKeywords:"aspect",end:/[{;=]/,excludeEnd:!0,illegal:/[:;"\[\]]/,contains:[{beginKeywords:"extends implements pertypewithin perthis pertarget percflowbelow percflow issingleton"},e.UNDERSCORE_TITLE_MODE,{begin:/\([^\)]*/,end:/[)]+/,keywords:n.concat(i),excludeEnd:!1}]},{className:"class",beginKeywords:"class interface",end:/[{;=]/,excludeEnd:!0,relevance:0,keywords:"class interface",illegal:/[:"\[\]]/,contains:[{beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},{beginKeywords:"pointcut after before around throwing returning",end:/[)]/,excludeEnd:!1,illegal:/["\[\]]/,contains:[{begin:r.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,contains:[e.UNDERSCORE_TITLE_MODE]}]},{begin:/[:]/,returnBegin:!0,end:/[{;]/,relevance:0,excludeEnd:!1,keywords:n,illegal:/["\[\]]/,contains:[{begin:r.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),keywords:n.concat(i),relevance:0},e.QUOTE_STRING_MODE]},{beginKeywords:"new throw",relevance:0},{className:"function",begin:/\w+ +\w+(\.\w+)?\s*\([^\)]*\)\s*((throws)[\w\s,]+)?[\{;]/,returnBegin:!0,end:/[{;=]/,keywords:n,excludeEnd:!0,contains:[{begin:r.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,relevance:0,contains:[e.UNDERSCORE_TITLE_MODE]},{className:"params",begin:/\(/,end:/\)/,relevance:0,keywords:n,contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},e.C_NUMBER_MODE,{className:"meta",begin:/@[A-Za-z]+/}]}}return $H=t,$H}var GH,j_e;function i3t(){if(j_e)return GH;j_e=1;function t(e){const r={begin:"`[\\s\\S]"};return{name:"AutoHotkey",case_insensitive:!0,aliases:["ahk"],keywords:{keyword:"Break Continue Critical Exit ExitApp Gosub Goto New OnExit Pause return SetBatchLines SetTimer Suspend Thread Throw Until ahk_id ahk_class ahk_pid ahk_exe ahk_group",literal:"true false NOT AND OR",built_in:"ComSpec Clipboard ClipboardAll ErrorLevel"},contains:[r,e.inherit(e.QUOTE_STRING_MODE,{contains:[r]}),e.COMMENT(";","$",{relevance:0}),e.C_BLOCK_COMMENT_MODE,{className:"number",begin:e.NUMBER_RE,relevance:0},{className:"variable",begin:"%[a-zA-Z0-9#_$@]+%"},{className:"built_in",begin:"^\\s*\\w+\\s*(,|%)"},{className:"title",variants:[{begin:'^[^\\n";]+::(?!=)'},{begin:'^[^\\n";]+:(?!=)',relevance:0}]},{className:"meta",begin:"^\\s*#\\w+",end:"$",relevance:0},{className:"built_in",begin:"A_[a-zA-Z0-9]+"},{begin:",\\s*,"}]}}return GH=t,GH}var zH,X_e;function a3t(){if(X_e)return zH;X_e=1;function t(e){const r="ByRef Case Const ContinueCase ContinueLoop Dim Do Else ElseIf EndFunc EndIf EndSelect EndSwitch EndWith Enum Exit ExitLoop For Func Global If In Local Next ReDim Return Select Static Step Switch Then To Until Volatile WEnd While With",n=["EndRegion","forcedef","forceref","ignorefunc","include","include-once","NoTrayIcon","OnAutoItStartRegister","pragma","Region","RequireAdmin","Tidy_Off","Tidy_On","Tidy_Parameters"],i="True False And Null Not Or Default",a="Abs ACos AdlibRegister AdlibUnRegister Asc AscW ASin Assign ATan AutoItSetOption AutoItWinGetTitle AutoItWinSetTitle Beep Binary BinaryLen BinaryMid BinaryToString BitAND BitNOT BitOR BitRotate BitShift BitXOR BlockInput Break Call CDTray Ceiling Chr ChrW ClipGet ClipPut ConsoleRead ConsoleWrite ConsoleWriteError ControlClick ControlCommand ControlDisable ControlEnable ControlFocus ControlGetFocus ControlGetHandle ControlGetPos ControlGetText ControlHide ControlListView ControlMove ControlSend ControlSetText ControlShow ControlTreeView Cos Dec DirCopy DirCreate DirGetSize DirMove DirRemove DllCall DllCallAddress DllCallbackFree DllCallbackGetPtr DllCallbackRegister DllClose DllOpen DllStructCreate DllStructGetData DllStructGetPtr DllStructGetSize DllStructSetData DriveGetDrive DriveGetFileSystem DriveGetLabel DriveGetSerial DriveGetType DriveMapAdd DriveMapDel DriveMapGet DriveSetLabel DriveSpaceFree DriveSpaceTotal DriveStatus EnvGet EnvSet EnvUpdate Eval Execute Exp FileChangeDir FileClose FileCopy FileCreateNTFSLink FileCreateShortcut FileDelete FileExists FileFindFirstFile FileFindNextFile FileFlush FileGetAttrib FileGetEncoding FileGetLongName FileGetPos FileGetShortcut FileGetShortName FileGetSize FileGetTime FileGetVersion FileInstall FileMove FileOpen FileOpenDialog FileRead FileReadLine FileReadToArray FileRecycle FileRecycleEmpty FileSaveDialog FileSelectFolder FileSetAttrib FileSetEnd FileSetPos FileSetTime FileWrite FileWriteLine Floor FtpSetProxy FuncName GUICreate GUICtrlCreateAvi GUICtrlCreateButton GUICtrlCreateCheckbox GUICtrlCreateCombo GUICtrlCreateContextMenu GUICtrlCreateDate GUICtrlCreateDummy GUICtrlCreateEdit GUICtrlCreateGraphic GUICtrlCreateGroup GUICtrlCreateIcon GUICtrlCreateInput GUICtrlCreateLabel GUICtrlCreateList GUICtrlCreateListView GUICtrlCreateListViewItem GUICtrlCreateMenu GUICtrlCreateMenuItem GUICtrlCreateMonthCal GUICtrlCreateObj GUICtrlCreatePic GUICtrlCreateProgress GUICtrlCreateRadio GUICtrlCreateSlider GUICtrlCreateTab GUICtrlCreateTabItem GUICtrlCreateTreeView GUICtrlCreateTreeViewItem GUICtrlCreateUpdown GUICtrlDelete GUICtrlGetHandle GUICtrlGetState GUICtrlRead GUICtrlRecvMsg GUICtrlRegisterListViewSort GUICtrlSendMsg GUICtrlSendToDummy GUICtrlSetBkColor GUICtrlSetColor GUICtrlSetCursor GUICtrlSetData GUICtrlSetDefBkColor GUICtrlSetDefColor GUICtrlSetFont GUICtrlSetGraphic GUICtrlSetImage GUICtrlSetLimit GUICtrlSetOnEvent GUICtrlSetPos GUICtrlSetResizing GUICtrlSetState GUICtrlSetStyle GUICtrlSetTip GUIDelete GUIGetCursorInfo GUIGetMsg GUIGetStyle GUIRegisterMsg GUISetAccelerators GUISetBkColor GUISetCoord GUISetCursor GUISetFont GUISetHelp GUISetIcon GUISetOnEvent GUISetState GUISetStyle GUIStartGroup GUISwitch Hex HotKeySet HttpSetProxy HttpSetUserAgent HWnd InetClose InetGet InetGetInfo InetGetSize InetRead IniDelete IniRead IniReadSection IniReadSectionNames IniRenameSection IniWrite IniWriteSection InputBox Int IsAdmin IsArray IsBinary IsBool IsDeclared IsDllStruct IsFloat IsFunc IsHWnd IsInt IsKeyword IsNumber IsObj IsPtr IsString Log MemGetStats Mod MouseClick MouseClickDrag MouseDown MouseGetCursor MouseGetPos MouseMove MouseUp MouseWheel MsgBox Number ObjCreate ObjCreateInterface ObjEvent ObjGet ObjName OnAutoItExitRegister OnAutoItExitUnRegister Ping PixelChecksum PixelGetColor PixelSearch ProcessClose ProcessExists ProcessGetStats ProcessList ProcessSetPriority ProcessWait ProcessWaitClose ProgressOff ProgressOn ProgressSet Ptr Random RegDelete RegEnumKey RegEnumVal RegRead RegWrite Round Run RunAs RunAsWait RunWait Send SendKeepActive SetError SetExtended ShellExecute ShellExecuteWait Shutdown Sin Sleep SoundPlay SoundSetWaveVolume SplashImageOn SplashOff SplashTextOn Sqrt SRandom StatusbarGetText StderrRead StdinWrite StdioClose StdoutRead String StringAddCR StringCompare StringFormat StringFromASCIIArray StringInStr StringIsAlNum StringIsAlpha StringIsASCII StringIsDigit StringIsFloat StringIsInt StringIsLower StringIsSpace StringIsUpper StringIsXDigit StringLeft StringLen StringLower StringMid StringRegExp StringRegExpReplace StringReplace StringReverse StringRight StringSplit StringStripCR StringStripWS StringToASCIIArray StringToBinary StringTrimLeft StringTrimRight StringUpper Tan TCPAccept TCPCloseSocket TCPConnect TCPListen TCPNameToIP TCPRecv TCPSend TCPShutdown, UDPShutdown TCPStartup, UDPStartup TimerDiff TimerInit ToolTip TrayCreateItem TrayCreateMenu TrayGetMsg TrayItemDelete TrayItemGetHandle TrayItemGetState TrayItemGetText TrayItemSetOnEvent TrayItemSetState TrayItemSetText TraySetClick TraySetIcon TraySetOnEvent TraySetPauseIcon TraySetState TraySetToolTip TrayTip UBound UDPBind UDPCloseSocket UDPOpen UDPRecv UDPSend VarGetType WinActivate WinActive WinClose WinExists WinFlash WinGetCaretPos WinGetClassList WinGetClientSize WinGetHandle WinGetPos WinGetProcess WinGetState WinGetText WinGetTitle WinKill WinList WinMenuSelectItem WinMinimizeAll WinMinimizeAllUndo WinMove WinSetOnTop WinSetState WinSetTitle WinSetTrans WinWait WinWaitActive WinWaitClose WinWaitNotActive",s={variants:[e.COMMENT(";","$",{relevance:0}),e.COMMENT("#cs","#ce"),e.COMMENT("#comments-start","#comments-end")]},o={begin:"\\$[A-z0-9_]+"},l={className:"string",variants:[{begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]}]},u={variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]},d={className:"meta",begin:"#",end:"$",keywords:{keyword:n},contains:[{begin:/\\\n/,relevance:0},{beginKeywords:"include",keywords:{keyword:"include"},end:"$",contains:[l,{className:"string",variants:[{begin:"<",end:">"},{begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]}]}]},l,s]},h={className:"symbol",begin:"@[A-z0-9_]+"},f={beginKeywords:"Func",end:"$",illegal:"\\$|\\[|%",contains:[e.inherit(e.UNDERSCORE_TITLE_MODE,{className:"title.function"}),{className:"params",begin:"\\(",end:"\\)",contains:[o,l,u]}]};return{name:"AutoIt",case_insensitive:!0,illegal:/\/\*/,keywords:{keyword:r,built_in:a,literal:i},contains:[s,o,l,u,d,h,f]}}return zH=t,zH}var qH,Q_e;function s3t(){if(Q_e)return qH;Q_e=1;function t(e){return{name:"AVR Assembly",case_insensitive:!0,keywords:{$pattern:"\\.?"+e.IDENT_RE,keyword:"adc add adiw and andi asr bclr bld brbc brbs brcc brcs break breq brge brhc brhs brid brie brlo brlt brmi brne brpl brsh brtc brts brvc brvs bset bst call cbi cbr clc clh cli cln clr cls clt clv clz com cp cpc cpi cpse dec eicall eijmp elpm eor fmul fmuls fmulsu icall ijmp in inc jmp ld ldd ldi lds lpm lsl lsr mov movw mul muls mulsu neg nop or ori out pop push rcall ret reti rjmp rol ror sbc sbr sbrc sbrs sec seh sbi sbci sbic sbis sbiw sei sen ser ses set sev sez sleep spm st std sts sub subi swap tst wdr",built_in:"r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 r23 r24 r25 r26 r27 r28 r29 r30 r31 x|0 xh xl y|0 yh yl z|0 zh zl ucsr1c udr1 ucsr1a ucsr1b ubrr1l ubrr1h ucsr0c ubrr0h tccr3c tccr3a tccr3b tcnt3h tcnt3l ocr3ah ocr3al ocr3bh ocr3bl ocr3ch ocr3cl icr3h icr3l etimsk etifr tccr1c ocr1ch ocr1cl twcr twdr twar twsr twbr osccal xmcra xmcrb eicra spmcsr spmcr portg ddrg ping portf ddrf sreg sph spl xdiv rampz eicrb eimsk gimsk gicr eifr gifr timsk tifr mcucr mcucsr tccr0 tcnt0 ocr0 assr tccr1a tccr1b tcnt1h tcnt1l ocr1ah ocr1al ocr1bh ocr1bl icr1h icr1l tccr2 tcnt2 ocr2 ocdr wdtcr sfior eearh eearl eedr eecr porta ddra pina portb ddrb pinb portc ddrc pinc portd ddrd pind spdr spsr spcr udr0 ucsr0a ucsr0b ubrr0l acsr admux adcsr adch adcl porte ddre pine pinf",meta:".byte .cseg .db .def .device .dseg .dw .endmacro .equ .eseg .exit .include .list .listmac .macro .nolist .org .set"},contains:[e.C_BLOCK_COMMENT_MODE,e.COMMENT(";","$",{relevance:0}),e.C_NUMBER_MODE,e.BINARY_NUMBER_MODE,{className:"number",begin:"\\b(\\$[a-zA-Z0-9]+|0o[0-7]+)"},e.QUOTE_STRING_MODE,{className:"string",begin:"'",end:"[^\\\\]'",illegal:"[^\\\\][^']"},{className:"symbol",begin:"^[A-Za-z0-9_.$]+:"},{className:"meta",begin:"#",end:"$"},{className:"subst",begin:"@[0-9]+"}]}}return qH=t,qH}var HH,Z_e;function o3t(){if(Z_e)return HH;Z_e=1;function t(e){const r={className:"variable",variants:[{begin:/\$[\w\d#@][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},n="BEGIN END if else while do for in break continue delete next nextfile function func exit|10",i={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/(u|b)?r?'''/,end:/'''/,relevance:10},{begin:/(u|b)?r?"""/,end:/"""/,relevance:10},{begin:/(u|r|ur)'/,end:/'/,relevance:10},{begin:/(u|r|ur)"/,end:/"/,relevance:10},{begin:/(b|br)'/,end:/'/},{begin:/(b|br)"/,end:/"/},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]};return{name:"Awk",keywords:{keyword:n},contains:[r,i,e.REGEXP_MODE,e.HASH_COMMENT_MODE,e.NUMBER_MODE]}}return HH=t,HH}var VH,J_e;function l3t(){if(J_e)return VH;J_e=1;function t(e){const r=e.UNDERSCORE_IDENT_RE,s={keyword:["abstract","as","asc","avg","break","breakpoint","by","byref","case","catch","changecompany","class","client","client","common","const","continue","count","crosscompany","delegate","delete_from","desc","display","div","do","edit","else","eventhandler","exists","extends","final","finally","firstfast","firstonly","firstonly1","firstonly10","firstonly100","firstonly1000","flush","for","forceliterals","forcenestedloop","forceplaceholders","forceselectorder","forupdate","from","generateonly","group","hint","if","implements","in","index","insert_recordset","interface","internal","is","join","like","maxof","minof","mod","namespace","new","next","nofetch","notexists","optimisticlock","order","outer","pessimisticlock","print","private","protected","public","readonly","repeatableread","retry","return","reverse","select","server","setting","static","sum","super","switch","this","throw","try","ttsabort","ttsbegin","ttscommit","unchecked","update_recordset","using","validtimestate","void","where","while"],built_in:["anytype","boolean","byte","char","container","date","double","enum","guid","int","int64","long","real","short","str","utcdatetime","var"],literal:["default","false","null","true"]},o={variants:[{match:[/(class|interface)\s+/,r,/\s+(extends|implements)\s+/,r]},{match:[/class\s+/,r]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:s};return{name:"X++",aliases:["x++"],keywords:s,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,{className:"meta",begin:"#",end:"$"},o]}}return VH=t,VH}var YH,eve;function c3t(){if(eve)return YH;eve=1;function t(e){const r=e.regex,n={},i={begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[n]}]};Object.assign(n,{className:"variable",variants:[{begin:r.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},i]});const a={className:"subst",begin:/\$\(/,end:/\)/,contains:[e.BACKSLASH_ESCAPE]},s=e.inherit(e.COMMENT(),{match:[/(^|\s)/,/#.*$/],scope:{2:"comment"}}),o={begin:/<<-?\s*(?=\w+)/,starts:{contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,className:"string"})]}},l={className:"string",begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,n,a]};a.contains.push(l);const u={match:/\\"/},d={className:"string",begin:/'/,end:/'/},h={match:/\\'/},f={begin:/\$?\(\(/,end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},e.NUMBER_MODE,n]},p=["fish","bash","zsh","sh","csh","ksh","tcsh","dash","scsh"],g=e.SHEBANG({binary:`(${p.join("|")})`,relevance:10}),m={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,contains:[e.inherit(e.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0},_=["if","then","else","elif","fi","time","for","while","until","in","do","done","case","esac","coproc","function","select"],v=["true","false"],b={match:/(\/[a-z._-]+)+/},y=["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset"],E=["alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","sudo","type","typeset","ulimit","unalias"],T=["autoload","bg","bindkey","bye","cap","chdir","clone","comparguments","compcall","compctl","compdescribe","compfiles","compgroups","compquote","comptags","comptry","compvalues","dirs","disable","disown","echotc","echoti","emulate","fc","fg","float","functions","getcap","getln","history","integer","jobs","kill","limit","log","noglob","popd","print","pushd","pushln","rehash","sched","setcap","setopt","stat","suspend","ttyctl","unfunction","unhash","unlimit","unsetopt","vared","wait","whence","where","which","zcompile","zformat","zftp","zle","zmodload","zparseopts","zprof","zpty","zregexparse","zsocket","zstyle","ztcp"],C=["chcon","chgrp","chown","chmod","cp","dd","df","dir","dircolors","ln","ls","mkdir","mkfifo","mknod","mktemp","mv","realpath","rm","rmdir","shred","sync","touch","truncate","vdir","b2sum","base32","base64","cat","cksum","comm","csplit","cut","expand","fmt","fold","head","join","md5sum","nl","numfmt","od","paste","ptx","pr","sha1sum","sha224sum","sha256sum","sha384sum","sha512sum","shuf","sort","split","sum","tac","tail","tr","tsort","unexpand","uniq","wc","arch","basename","chroot","date","dirname","du","echo","env","expr","factor","groups","hostid","id","link","logname","nice","nohup","nproc","pathchk","pinky","printenv","printf","pwd","readlink","runcon","seq","sleep","stat","stdbuf","stty","tee","test","timeout","tty","uname","unlink","uptime","users","who","whoami","yes"];return{name:"Bash",aliases:["sh","zsh"],keywords:{$pattern:/\b[a-z][a-z0-9._-]+\b/,keyword:_,literal:v,built_in:[...y,...E,"set","shopt",...T,...C]},contains:[g,e.SHEBANG(),m,f,s,o,b,l,u,d,h,n]}}return YH=t,YH}var WH,tve;function u3t(){if(tve)return WH;tve=1;function t(e){return{name:"BASIC",case_insensitive:!0,illegal:"^.",keywords:{$pattern:"[a-zA-Z][a-zA-Z0-9_$%!#]*",keyword:["ABS","ASC","AND","ATN","AUTO|0","BEEP","BLOAD|10","BSAVE|10","CALL","CALLS","CDBL","CHAIN","CHDIR","CHR$|10","CINT","CIRCLE","CLEAR","CLOSE","CLS","COLOR","COM","COMMON","CONT","COS","CSNG","CSRLIN","CVD","CVI","CVS","DATA","DATE$","DEFDBL","DEFINT","DEFSNG","DEFSTR","DEF|0","SEG","USR","DELETE","DIM","DRAW","EDIT","END","ENVIRON","ENVIRON$","EOF","EQV","ERASE","ERDEV","ERDEV$","ERL","ERR","ERROR","EXP","FIELD","FILES","FIX","FOR|0","FRE","GET","GOSUB|10","GOTO","HEX$","IF","THEN","ELSE|0","INKEY$","INP","INPUT","INPUT#","INPUT$","INSTR","IMP","INT","IOCTL","IOCTL$","KEY","ON","OFF","LIST","KILL","LEFT$","LEN","LET","LINE","LLIST","LOAD","LOC","LOCATE","LOF","LOG","LPRINT","USING","LSET","MERGE","MID$","MKDIR","MKD$","MKI$","MKS$","MOD","NAME","NEW","NEXT","NOISE","NOT","OCT$","ON","OR","PEN","PLAY","STRIG","OPEN","OPTION","BASE","OUT","PAINT","PALETTE","PCOPY","PEEK","PMAP","POINT","POKE","POS","PRINT","PRINT]","PSET","PRESET","PUT","RANDOMIZE","READ","REM","RENUM","RESET|0","RESTORE","RESUME","RETURN|0","RIGHT$","RMDIR","RND","RSET","RUN","SAVE","SCREEN","SGN","SHELL","SIN","SOUND","SPACE$","SPC","SQR","STEP","STICK","STOP","STR$","STRING$","SWAP","SYSTEM","TAB","TAN","TIME$","TIMER","TROFF","TRON","TO","USR","VAL","VARPTR","VARPTR$","VIEW","WAIT","WHILE","WEND","WIDTH","WINDOW","WRITE","XOR"]},contains:[{scope:"string",begin:/"/,end:/"|$/,contains:[e.BACKSLASH_ESCAPE]},e.COMMENT("REM","$",{relevance:10}),e.COMMENT("'","$",{relevance:0}),{className:"symbol",begin:"^[0-9]+ ",relevance:10},{className:"number",begin:"\\b\\d+(\\.\\d+)?([edED]\\d+)?[#!]?",relevance:0},{className:"number",begin:"(&[hH][0-9a-fA-F]{1,4})"},{className:"number",begin:"(&[oO][0-7]{1,6})"}]}}return WH=t,WH}var KH,rve;function d3t(){if(rve)return KH;rve=1;function t(e){return{name:"Backus–Naur Form",contains:[{className:"attribute",begin://},{begin:/::=/,end:/$/,contains:[{begin://},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]}]}}return KH=t,KH}var jH,nve;function h3t(){if(nve)return jH;nve=1;function t(e){const r={className:"literal",begin:/[+-]+/,relevance:0};return{name:"Brainfuck",aliases:["bf"],contains:[e.COMMENT(/[^\[\]\.,\+\-<> \r\n]/,/[\[\]\.,\+\-<> \r\n]/,{contains:[{match:/[ ]+[^\[\]\.,\+\-<> \r\n]/,relevance:0}],returnEnd:!0,relevance:0}),{className:"title",begin:"[\\[\\]]",relevance:0},{className:"string",begin:"[\\.,]",relevance:0},{begin:/(?=\+\+|--)/,contains:[r]},r]}}return jH=t,jH}var XH,ive;function f3t(){if(ive)return XH;ive=1;function t(e){const r=e.regex,n=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",a="[a-zA-Z_]\\w*::",o="("+i+"|"+r.optional(a)+"[a-zA-Z_]\\w*"+r.optional("<[^<>]+>")+")",l={className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{match:/\batomic_[a-z]{3,6}\b/}]},d={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'("+"\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)"+"|.)",end:"'",illegal:"."},e.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},h={className:"number",variants:[{match:/\b(0b[01']+)/},{match:/(-?)\b([\d']+(\.[\d']*)?|\.[\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)/},{match:/(-?)\b(0[xX][a-fA-F0-9]+(?:'[a-fA-F0-9]+)*(?:\.[a-fA-F0-9]*(?:'[a-fA-F0-9]*)*)?(?:[pP][-+]?[0-9]+)?(l|L)?(u|U)?)/},{match:/(-?)\b\d+(?:'\d+)*(?:\.\d*(?:'\d*)*)?(?:[eE][-+]?\d+)?/}],relevance:0},f={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef elifdef elifndef include"},contains:[{begin:/\\\n/,relevance:0},e.inherit(d,{className:"string"}),{className:"string",begin:/<.*?>/},n,e.C_BLOCK_COMMENT_MODE]},p={className:"title",begin:r.optional(a)+e.IDENT_RE,relevance:0},g=r.optional(a)+e.IDENT_RE+"\\s*\\(",v={keyword:["asm","auto","break","case","continue","default","do","else","enum","extern","for","fortran","goto","if","inline","register","restrict","return","sizeof","typeof","typeof_unqual","struct","switch","typedef","union","volatile","while","_Alignas","_Alignof","_Atomic","_Generic","_Noreturn","_Static_assert","_Thread_local","alignas","alignof","noreturn","static_assert","thread_local","_Pragma"],type:["float","double","signed","unsigned","int","short","long","char","void","_Bool","_BitInt","_Complex","_Imaginary","_Decimal32","_Decimal64","_Decimal96","_Decimal128","_Decimal64x","_Decimal128x","_Float16","_Float32","_Float64","_Float128","_Float32x","_Float64x","_Float128x","const","static","constexpr","complex","bool","imaginary"],literal:"true false NULL",built_in:"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"},b=[f,l,n,e.C_BLOCK_COMMENT_MODE,h,d],y={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:v,contains:b.concat([{begin:/\(/,end:/\)/,keywords:v,contains:b.concat(["self"]),relevance:0}]),relevance:0},E={begin:"("+o+"[\\*&\\s]+)+"+g,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:v,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:i,keywords:v,relevance:0},{begin:g,returnBegin:!0,contains:[e.inherit(p,{className:"title.function"})],relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:v,relevance:0,contains:[n,e.C_BLOCK_COMMENT_MODE,d,h,l,{begin:/\(/,end:/\)/,keywords:v,relevance:0,contains:["self",n,e.C_BLOCK_COMMENT_MODE,d,h,l]}]},l,n,e.C_BLOCK_COMMENT_MODE,f]};return{name:"C",aliases:["h"],keywords:v,disableAutodetect:!0,illegal:"=]/,contains:[{beginKeywords:"final class struct"},e.TITLE_MODE]}]),exports:{preprocessor:f,strings:d,keywords:v}}}return XH=t,XH}var QH,ave;function p3t(){if(ave)return QH;ave=1;function t(e){const r=e.regex,n=["div","mod","in","and","or","not","xor","asserterror","begin","case","do","downto","else","end","exit","for","local","if","of","repeat","then","to","until","while","with","var"],i="false true",a=[e.C_LINE_COMMENT_MODE,e.COMMENT(/\{/,/\}/,{relevance:0}),e.COMMENT(/\(\*/,/\*\)/,{relevance:10})],s={className:"string",begin:/'/,end:/'/,contains:[{begin:/''/}]},o={className:"string",begin:/(#\d+)+/},l={className:"number",begin:"\\b\\d+(\\.\\d+)?(DT|D|T)",relevance:0},u={className:"string",begin:'"',end:'"'},d={match:[/procedure/,/\s+/,/[a-zA-Z_][\w@]*/,/\s*/],scope:{1:"keyword",3:"title.function"},contains:[{className:"params",begin:/\(/,end:/\)/,keywords:n,contains:[s,o,e.NUMBER_MODE]},...a]},h=["Table","Form","Report","Dataport","Codeunit","XMLport","MenuSuite","Page","Query"],f={match:[/OBJECT/,/\s+/,r.either(...h),/\s+/,/\d+/,/\s+(?=[^\s])/,/.*/,/$/],relevance:3,scope:{1:"keyword",3:"type",5:"number",7:"title"}};return{name:"C/AL",case_insensitive:!0,keywords:{keyword:n,literal:i},illegal:/\/\*/,contains:[{match:/[\w]+(?=\=)/,scope:"attribute",relevance:0},s,o,l,u,e.NUMBER_MODE,f,d]}}return QH=t,QH}var ZH,sve;function g3t(){if(sve)return ZH;sve=1;function t(e){const r=["struct","enum","interface","union","group","import","using","const","annotation","extends","in","of","on","as","with","from","fixed"],n=["Void","Bool","Int8","Int16","Int32","Int64","UInt8","UInt16","UInt32","UInt64","Float32","Float64","Text","Data","AnyPointer","AnyStruct","Capability","List"],i=["true","false"],a={variants:[{match:[/(struct|enum|interface)/,/\s+/,e.IDENT_RE]},{match:[/extends/,/\s*\(/,e.IDENT_RE,/\s*\)/]}],scope:{1:"keyword",3:"title.class"}};return{name:"Cap’n Proto",aliases:["capnp"],keywords:{keyword:r,type:n,literal:i},contains:[e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.HASH_COMMENT_MODE,{className:"meta",begin:/@0x[\w\d]{16};/,illegal:/\n/},{className:"symbol",begin:/@\d+\b/},a]}}return ZH=t,ZH}var JH,ove;function m3t(){if(ove)return JH;ove=1;function t(e){const r=["assembly","module","package","import","alias","class","interface","object","given","value","assign","void","function","new","of","extends","satisfies","abstracts","in","out","return","break","continue","throw","assert","dynamic","if","else","switch","case","for","while","try","catch","finally","then","let","this","outer","super","is","exists","nonempty"],n=["shared","abstract","formal","default","actual","variable","late","native","deprecated","final","sealed","annotation","suppressWarnings","small"],i=["doc","by","license","see","throws","tagged"],a={className:"subst",excludeBegin:!0,excludeEnd:!0,begin:/``/,end:/``/,keywords:r,relevance:10},s=[{className:"string",begin:'"""',end:'"""',relevance:10},{className:"string",begin:'"',end:'"',contains:[a]},{className:"string",begin:"'",end:"'"},{className:"number",begin:"#[0-9a-fA-F_]+|\\$[01_]+|[0-9_]+(?:\\.[0-9_](?:[eE][+-]?\\d+)?)?[kMGTPmunpf]?",relevance:0}];return a.contains=s,{name:"Ceylon",keywords:{keyword:r.concat(n),meta:i},illegal:"\\$[^01]|#[^0-9a-fA-F]",contains:[e.C_LINE_COMMENT_MODE,e.COMMENT("/\\*","\\*/",{contains:["self"]}),{className:"meta",begin:'@[a-z]\\w*(?::"[^"]*")?'}].concat(s)}}return JH=t,JH}var eV,lve;function _3t(){if(lve)return eV;lve=1;function t(e){return{name:"Clean",aliases:["icl","dcl"],keywords:{keyword:["if","let","in","with","where","case","of","class","instance","otherwise","implementation","definition","system","module","from","import","qualified","as","special","code","inline","foreign","export","ccall","stdcall","generic","derive","infix","infixl","infixr"],built_in:"Int Real Char Bool",literal:"True False"},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,{begin:"->|<-[|:]?|#!?|>>=|\\{\\||\\|\\}|:==|=:|<>"}]}}return eV=t,eV}var tV,cve;function v3t(){if(cve)return tV;cve=1;function t(e){const r="a-zA-Z_\\-!.?+*=<>&'",n="[#]?["+r+"]["+r+"0-9/;:$#]*",i="def defonce defprotocol defstruct defmulti defmethod defn- defn defmacro deftype defrecord",a={$pattern:n,built_in:i+" cond apply if-not if-let if not not= =|0 <|0 >|0 <=|0 >=|0 ==|0 +|0 /|0 *|0 -|0 rem quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last drop-while while intern condp case reduced cycle split-at split-with repeat replicate iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter monitor-exit macroexpand macroexpand-1 for dosync and or when when-not when-let comp juxt partial sequence memoize constantly complement identity assert peek pop doto proxy first rest cons cast coll last butlast sigs reify second ffirst fnext nfirst nnext meta with-meta ns in-ns create-ns import refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize"},s={begin:n,relevance:0},o={scope:"number",relevance:0,variants:[{match:/[-+]?0[xX][0-9a-fA-F]+N?/},{match:/[-+]?0[0-7]+N?/},{match:/[-+]?[1-9][0-9]?[rR][0-9a-zA-Z]+N?/},{match:/[-+]?[0-9]+\/[0-9]+N?/},{match:/[-+]?[0-9]+((\.[0-9]*([eE][+-]?[0-9]+)?M?)|([eE][+-]?[0-9]+M?|M))/},{match:/[-+]?([1-9][0-9]*|0)N?/}]},l={scope:"character",variants:[{match:/\\o[0-3]?[0-7]{1,2}/},{match:/\\u[0-9a-fA-F]{4}/},{match:/\\(newline|space|tab|formfeed|backspace|return)/},{match:/\\\S/,relevance:0}]},u={scope:"regex",begin:/#"/,end:/"/,contains:[e.BACKSLASH_ESCAPE]},d=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),h={scope:"punctuation",match:/,/,relevance:0},f=e.COMMENT(";","$",{relevance:0}),p={className:"literal",begin:/\b(true|false|nil)\b/},g={begin:"\\[|(#::?"+n+")?\\{",end:"[\\]\\}]",relevance:0},m={className:"symbol",begin:"[:]{1,2}"+n},_={begin:"\\(",end:"\\)"},v={endsWithParent:!0,relevance:0},b={keywords:a,className:"name",begin:n,relevance:0,starts:v},y=[h,_,l,u,d,f,m,g,o,p,s],E={beginKeywords:i,keywords:{$pattern:n,keyword:i},end:'(\\[|#|\\d|"|:|\\{|\\)|\\(|$)',contains:[{className:"title",begin:n,relevance:0,excludeEnd:!0,endsParent:!0}].concat(y)};return _.contains=[E,b,v],v.contains=y,g.contains=y,{name:"Clojure",aliases:["clj","edn"],illegal:/\S/,contains:[h,_,l,u,d,f,m,g,o,p]}}return tV=t,tV}var rV,uve;function y3t(){if(uve)return rV;uve=1;function t(e){return{name:"Clojure REPL",contains:[{className:"meta.prompt",begin:/^([\w.-]+|\s*#_)?=>/,starts:{end:/$/,subLanguage:"clojure"}}]}}return rV=t,rV}var nV,dve;function b3t(){if(dve)return nV;dve=1;function t(e){return{name:"CMake",aliases:["cmake.in"],case_insensitive:!0,keywords:{keyword:"break cmake_host_system_information cmake_minimum_required cmake_parse_arguments cmake_policy configure_file continue elseif else endforeach endfunction endif endmacro endwhile execute_process file find_file find_library find_package find_path find_program foreach function get_cmake_property get_directory_property get_filename_component get_property if include include_guard list macro mark_as_advanced math message option return separate_arguments set_directory_properties set_property set site_name string unset variable_watch while add_compile_definitions add_compile_options add_custom_command add_custom_target add_definitions add_dependencies add_executable add_library add_link_options add_subdirectory add_test aux_source_directory build_command create_test_sourcelist define_property enable_language enable_testing export fltk_wrap_ui get_source_file_property get_target_property get_test_property include_directories include_external_msproject include_regular_expression install link_directories link_libraries load_cache project qt_wrap_cpp qt_wrap_ui remove_definitions set_source_files_properties set_target_properties set_tests_properties source_group target_compile_definitions target_compile_features target_compile_options target_include_directories target_link_directories target_link_libraries target_link_options target_sources try_compile try_run ctest_build ctest_configure ctest_coverage ctest_empty_binary_directory ctest_memcheck ctest_read_custom_files ctest_run_script ctest_sleep ctest_start ctest_submit ctest_test ctest_update ctest_upload build_name exec_program export_library_dependencies install_files install_programs install_targets load_command make_directory output_required_files remove subdir_depends subdirs use_mangled_mesa utility_source variable_requires write_file qt5_use_modules qt5_use_package qt5_wrap_cpp on off true false and or not command policy target test exists is_newer_than is_directory is_symlink is_absolute matches less greater equal less_equal greater_equal strless strgreater strequal strless_equal strgreater_equal version_less version_greater version_equal version_less_equal version_greater_equal in_list defined"},contains:[{className:"variable",begin:/\$\{/,end:/\}/},e.COMMENT(/#\[\[/,/]]/),e.HASH_COMMENT_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE]}}return nV=t,nV}var iV,hve;function S3t(){if(hve)return iV;hve=1;const t=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends","using"],e=["true","false","null","undefined","NaN","Infinity"],r=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],n=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],i=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],a=[].concat(i,r,n);function s(o){const l=["npm","print"],u=["yes","no","on","off"],d=["then","unless","until","loop","by","when","and","or","is","isnt","not"],h=["var","const","let","function","static"],f=T=>C=>!T.includes(C),p={keyword:t.concat(d).filter(f(h)),literal:e.concat(u),built_in:a.concat(l)},g="[A-Za-z$_][0-9A-Za-z$_]*",m={className:"subst",begin:/#\{/,end:/\}/,keywords:p},_=[o.BINARY_NUMBER_MODE,o.inherit(o.C_NUMBER_MODE,{starts:{end:"(\\s*/)?",relevance:0}}),{className:"string",variants:[{begin:/'''/,end:/'''/,contains:[o.BACKSLASH_ESCAPE]},{begin:/'/,end:/'/,contains:[o.BACKSLASH_ESCAPE]},{begin:/"""/,end:/"""/,contains:[o.BACKSLASH_ESCAPE,m]},{begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE,m]}]},{className:"regexp",variants:[{begin:"///",end:"///",contains:[m,o.HASH_COMMENT_MODE]},{begin:"//[gim]{0,3}(?=\\W)",relevance:0},{begin:/\/(?![ *]).*?(?![\\]).\/[gim]{0,3}(?=\W)/}]},{begin:"@"+g},{subLanguage:"javascript",excludeBegin:!0,excludeEnd:!0,variants:[{begin:"```",end:"```"},{begin:"`",end:"`"}]}];m.contains=_;const v=o.inherit(o.TITLE_MODE,{begin:g}),b="(\\(.*\\)\\s*)?\\B[-=]>",y={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:p,contains:["self"].concat(_)}]},E={variants:[{match:[/class\s+/,g,/\s+extends\s+/,g]},{match:[/class\s+/,g]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:p};return{name:"CoffeeScript",aliases:["coffee","cson","iced"],keywords:p,illegal:/\/\*/,contains:[..._,o.COMMENT("###","###"),o.HASH_COMMENT_MODE,{className:"function",begin:"^\\s*"+g+"\\s*=\\s*"+b,end:"[-=]>",returnBegin:!0,contains:[v,y]},{begin:/[:\(,=]\s*/,relevance:0,contains:[{className:"function",begin:b,end:"[-=]>",returnBegin:!0,contains:[y]}]},E,{begin:g+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}]}}return iV=s,iV}var aV,fve;function E3t(){if(fve)return aV;fve=1;function t(e){return{name:"Coq",keywords:{keyword:["_|0","as","at","cofix","else","end","exists","exists2","fix","for","forall","fun","if","IF","in","let","match","mod","Prop","return","Set","then","Type","using","where","with","Abort","About","Add","Admit","Admitted","All","Arguments","Assumptions","Axiom","Back","BackTo","Backtrack","Bind","Blacklist","Canonical","Cd","Check","Class","Classes","Close","Coercion","Coercions","CoFixpoint","CoInductive","Collection","Combined","Compute","Conjecture","Conjectures","Constant","constr","Constraint","Constructors","Context","Corollary","CreateHintDb","Cut","Declare","Defined","Definition","Delimit","Dependencies","Dependent","Derive","Drop","eauto","End","Equality","Eval","Example","Existential","Existentials","Existing","Export","exporting","Extern","Extract","Extraction","Fact","Field","Fields","File","Fixpoint","Focus","for","From","Function","Functional","Generalizable","Global","Goal","Grab","Grammar","Graph","Guarded","Heap","Hint","HintDb","Hints","Hypotheses","Hypothesis","ident","Identity","If","Immediate","Implicit","Import","Include","Inductive","Infix","Info","Initial","Inline","Inspect","Instance","Instances","Intro","Intros","Inversion","Inversion_clear","Language","Left","Lemma","Let","Libraries","Library","Load","LoadPath","Local","Locate","Ltac","ML","Mode","Module","Modules","Monomorphic","Morphism","Next","NoInline","Notation","Obligation","Obligations","Opaque","Open","Optimize","Options","Parameter","Parameters","Parametric","Path","Paths","pattern","Polymorphic","Preterm","Print","Printing","Program","Projections","Proof","Proposition","Pwd","Qed","Quit","Rec","Record","Recursive","Redirect","Relation","Remark","Remove","Require","Reserved","Reset","Resolve","Restart","Rewrite","Right","Ring","Rings","Save","Scheme","Scope","Scopes","Script","Search","SearchAbout","SearchHead","SearchPattern","SearchRewrite","Section","Separate","Set","Setoid","Show","Solve","Sorted","Step","Strategies","Strategy","Structure","SubClass","Table","Tables","Tactic","Term","Test","Theorem","Time","Timeout","Transparent","Type","Typeclasses","Types","Undelimit","Undo","Unfocus","Unfocused","Unfold","Universe","Universes","Unset","Unshelve","using","Variable","Variables","Variant","Verbose","Visibility","where","with"],built_in:["abstract","absurd","admit","after","apply","as","assert","assumption","at","auto","autorewrite","autounfold","before","bottom","btauto","by","case","case_eq","cbn","cbv","change","classical_left","classical_right","clear","clearbody","cofix","compare","compute","congruence","constr_eq","constructor","contradict","contradiction","cut","cutrewrite","cycle","decide","decompose","dependent","destruct","destruction","dintuition","discriminate","discrR","do","double","dtauto","eapply","eassumption","eauto","ecase","econstructor","edestruct","ediscriminate","eelim","eexact","eexists","einduction","einjection","eleft","elim","elimtype","enough","equality","erewrite","eright","esimplify_eq","esplit","evar","exact","exactly_once","exfalso","exists","f_equal","fail","field","field_simplify","field_simplify_eq","first","firstorder","fix","fold","fourier","functional","generalize","generalizing","gfail","give_up","has_evar","hnf","idtac","in","induction","injection","instantiate","intro","intro_pattern","intros","intuition","inversion","inversion_clear","is_evar","is_var","lapply","lazy","left","lia","lra","move","native_compute","nia","nsatz","omega","once","pattern","pose","progress","proof","psatz","quote","record","red","refine","reflexivity","remember","rename","repeat","replace","revert","revgoals","rewrite","rewrite_strat","right","ring","ring_simplify","rtauto","set","setoid_reflexivity","setoid_replace","setoid_rewrite","setoid_symmetry","setoid_transitivity","shelve","shelve_unifiable","simpl","simple","simplify_eq","solve","specialize","split","split_Rabs","split_Rmult","stepl","stepr","subst","sum","swap","symmetry","tactic","tauto","time","timeout","top","transitivity","trivial","try","tryif","unfold","unify","until","using","vm_compute","with"]},contains:[e.QUOTE_STRING_MODE,e.COMMENT("\\(\\*","\\*\\)"),e.C_NUMBER_MODE,{className:"type",excludeBegin:!0,begin:"\\|\\s*",end:"\\w+"},{begin:/[-=]>/}]}}return aV=t,aV}var sV,pve;function T3t(){if(pve)return sV;pve=1;function t(e){return{name:"Caché Object Script",case_insensitive:!0,aliases:["cls"],keywords:"property parameter class classmethod clientmethod extends as break catch close continue do d|0 else elseif for goto halt hang h|0 if job j|0 kill k|0 lock l|0 merge new open quit q|0 read r|0 return set s|0 tcommit throw trollback try tstart use view while write w|0 xecute x|0 zkill znspace zn ztrap zwrite zw zzdump zzwrite print zbreak zinsert zload zprint zremove zsave zzprint mv mvcall mvcrt mvdim mvprint zquit zsync ascii",contains:[{className:"number",begin:"\\b(\\d+(\\.\\d*)?|\\.\\d+)",relevance:0},{className:"string",variants:[{begin:'"',end:'"',contains:[{begin:'""',relevance:0}]}]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"comment",begin:/;/,end:"$",relevance:0},{className:"built_in",begin:/(?:\$\$?|\.\.)\^?[a-zA-Z]+/},{className:"built_in",begin:/\$\$\$[a-zA-Z]+/},{className:"built_in",begin:/%[a-z]+(?:\.[a-z]+)*/},{className:"symbol",begin:/\^%?[a-zA-Z][\w]*/},{className:"keyword",begin:/##class|##super|#define|#dim/},{begin:/&sql\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,subLanguage:"sql"},{begin:/&(js|jscript|javascript)/,excludeBegin:!0,excludeEnd:!0,subLanguage:"javascript"},{begin:/&html<\s*\s*>/,subLanguage:"xml"}]}}return sV=t,sV}var oV,gve;function C3t(){if(gve)return oV;gve=1;function t(e){const r=e.regex,n=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",a="[a-zA-Z_]\\w*::",o="(?!struct)("+i+"|"+r.optional(a)+"[a-zA-Z_]\\w*"+r.optional("<[^<>]+>")+")",l={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},d={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'("+"\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)"+"|.)",end:"'",illegal:"."},e.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},h={className:"number",variants:[{begin:"[+-]?(?:(?:[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|0[Xx](?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)[Pp][+-]?[0-9](?:'?[0-9])*)(?:[Ff](?:16|32|64|128)?|(BF|bf)16|[Ll]|)"},{begin:"[+-]?\\b(?:0[Bb][01](?:'?[01])*|0[Xx][0-9A-Fa-f](?:'?[0-9A-Fa-f])*|0(?:'?[0-7])*|[1-9](?:'?[0-9])*)(?:[Uu](?:LL?|ll?)|[Uu][Zz]?|(?:LL?|ll?)[Uu]?|[Zz][Uu]|)"}],relevance:0},f={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"},contains:[{begin:/\\\n/,relevance:0},e.inherit(d,{className:"string"}),{className:"string",begin:/<.*?>/},n,e.C_BLOCK_COMMENT_MODE]},p={className:"title",begin:r.optional(a)+e.IDENT_RE,relevance:0},g=r.optional(a)+e.IDENT_RE+"\\s*\\(",m=["alignas","alignof","and","and_eq","asm","atomic_cancel","atomic_commit","atomic_noexcept","auto","bitand","bitor","break","case","catch","class","co_await","co_return","co_yield","compl","concept","const_cast|10","consteval","constexpr","constinit","continue","decltype","default","delete","do","dynamic_cast|10","else","enum","explicit","export","extern","false","final","for","friend","goto","if","import","inline","module","mutable","namespace","new","noexcept","not","not_eq","nullptr","operator","or","or_eq","override","private","protected","public","reflexpr","register","reinterpret_cast|10","requires","return","sizeof","static_assert","static_cast|10","struct","switch","synchronized","template","this","thread_local","throw","transaction_safe","transaction_safe_dynamic","true","try","typedef","typeid","typename","union","using","virtual","volatile","while","xor","xor_eq"],_=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],v=["any","auto_ptr","barrier","binary_semaphore","bitset","complex","condition_variable","condition_variable_any","counting_semaphore","deque","false_type","flat_map","flat_set","future","imaginary","initializer_list","istringstream","jthread","latch","lock_guard","multimap","multiset","mutex","optional","ostringstream","packaged_task","pair","promise","priority_queue","queue","recursive_mutex","recursive_timed_mutex","scoped_lock","set","shared_future","shared_lock","shared_mutex","shared_timed_mutex","shared_ptr","stack","string_view","stringstream","timed_mutex","thread","true_type","tuple","unique_lock","unique_ptr","unordered_map","unordered_multimap","unordered_multiset","unordered_set","variant","vector","weak_ptr","wstring","wstring_view"],b=["abort","abs","acos","apply","as_const","asin","atan","atan2","calloc","ceil","cerr","cin","clog","cos","cosh","cout","declval","endl","exchange","exit","exp","fabs","floor","fmod","forward","fprintf","fputs","free","frexp","fscanf","future","invoke","isalnum","isalpha","iscntrl","isdigit","isgraph","islower","isprint","ispunct","isspace","isupper","isxdigit","labs","launder","ldexp","log","log10","make_pair","make_shared","make_shared_for_overwrite","make_tuple","make_unique","malloc","memchr","memcmp","memcpy","memset","modf","move","pow","printf","putchar","puts","realloc","scanf","sin","sinh","snprintf","sprintf","sqrt","sscanf","std","stderr","stdin","stdout","strcat","strchr","strcmp","strcpy","strcspn","strlen","strncat","strncmp","strncpy","strpbrk","strrchr","strspn","strstr","swap","tan","tanh","terminate","to_underlying","tolower","toupper","vfprintf","visit","vprintf","vsprintf"],T={type:_,keyword:m,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:v},C={className:"function.dispatch",relevance:0,keywords:{_hint:b},begin:r.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,e.IDENT_RE,r.lookahead(/(<[^<>]+>|)\s*\(/))},w=[C,f,l,n,e.C_BLOCK_COMMENT_MODE,h,d],x={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:T,contains:w.concat([{begin:/\(/,end:/\)/,keywords:T,contains:w.concat(["self"]),relevance:0}]),relevance:0},A={className:"function",begin:"("+o+"[\\*&\\s]+)+"+g,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:T,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:i,keywords:T,relevance:0},{begin:g,returnBegin:!0,contains:[p],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[d,h]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:T,relevance:0,contains:[n,e.C_BLOCK_COMMENT_MODE,d,h,l,{begin:/\(/,end:/\)/,keywords:T,relevance:0,contains:["self",n,e.C_BLOCK_COMMENT_MODE,d,h,l]}]},l,n,e.C_BLOCK_COMMENT_MODE,f]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:T,illegal:"",keywords:T,contains:["self",l]},{begin:e.IDENT_RE+"::",keywords:T},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}return oV=t,oV}var lV,mve;function w3t(){if(mve)return lV;mve=1;function t(e){const r="primitive rsc_template",n="group clone ms master location colocation order fencing_topology rsc_ticket acl_target acl_group user role tag xml";return{name:"crmsh",aliases:["crm","pcmk"],case_insensitive:!0,keywords:{keyword:"params meta operations op rule attributes utilization"+" "+"read write deny defined not_defined in_range date spec in ref reference attribute type xpath version and or lt gt tag lte gte eq ne \\"+" "+"number string",literal:"Master Started Slave Stopped start promote demote stop monitor true false"},contains:[e.HASH_COMMENT_MODE,{beginKeywords:"node",starts:{end:"\\s*([\\w_-]+:)?",starts:{className:"title",end:"\\s*[\\$\\w_][\\w_-]*"}}},{beginKeywords:r,starts:{className:"title",end:"\\s*[\\$\\w_][\\w_-]*",starts:{end:"\\s*@?[\\w_][\\w_\\.:-]*"}}},{begin:"\\b("+n.split(" ").join("|")+")\\s+",keywords:n,starts:{className:"title",end:"[\\$\\w_][\\w_-]*"}},{beginKeywords:"property rsc_defaults op_defaults",starts:{className:"title",end:"\\s*([\\w_-]+:)?"}},e.QUOTE_STRING_MODE,{className:"meta",begin:"(ocf|systemd|service|lsb):[\\w_:-]+",relevance:0},{className:"number",begin:"\\b\\d+(\\.\\d+)?(ms|s|h|m)?",relevance:0},{className:"literal",begin:"[-]?(infinity|inf)",relevance:0},{className:"attr",begin:/([A-Za-z$_#][\w_-]+)=/,relevance:0},{className:"tag",begin:"",relevance:0}]}}return lV=t,lV}var cV,_ve;function x3t(){if(_ve)return cV;_ve=1;function t(e){const r="(_?[ui](8|16|32|64|128))?",n="(_?f(32|64))?",i="[a-zA-Z_]\\w*[!?=]?",a="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?",s="[A-Za-z_]\\w*(::\\w+)*(\\?|!)?",o={$pattern:i,keyword:"abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield __DIR__ __END_LINE__ __FILE__ __LINE__",literal:"false nil true"},l={className:"subst",begin:/#\{/,end:/\}/,keywords:o},u={className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},d={className:"template-variable",variants:[{begin:"\\{\\{",end:"\\}\\}"},{begin:"\\{%",end:"%\\}"}],keywords:o};function h(b,y){const E=[{begin:b,end:y}];return E[0].contains=E,E}const f={className:"string",contains:[e.BACKSLASH_ESCAPE,l],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:"%[Qwi]?\\(",end:"\\)",contains:h("\\(","\\)")},{begin:"%[Qwi]?\\[",end:"\\]",contains:h("\\[","\\]")},{begin:"%[Qwi]?\\{",end:/\}/,contains:h(/\{/,/\}/)},{begin:"%[Qwi]?<",end:">",contains:h("<",">")},{begin:"%[Qwi]?\\|",end:"\\|"},{begin:/<<-\w+$/,end:/^\s*\w+$/}],relevance:0},p={className:"string",variants:[{begin:"%q\\(",end:"\\)",contains:h("\\(","\\)")},{begin:"%q\\[",end:"\\]",contains:h("\\[","\\]")},{begin:"%q\\{",end:/\}/,contains:h(/\{/,/\}/)},{begin:"%q<",end:">",contains:h("<",">")},{begin:"%q\\|",end:"\\|"},{begin:/<<-'\w+'$/,end:/^\s*\w+$/}],relevance:0},g={begin:"(?!%\\})("+e.RE_STARTERS_RE+"|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*",keywords:"case if select unless until when while",contains:[{className:"regexp",contains:[e.BACKSLASH_ESCAPE,l],variants:[{begin:"//[a-z]*",relevance:0},{begin:"/(?!\\/)",end:"/[a-z]*"}]}],relevance:0},m={className:"regexp",contains:[e.BACKSLASH_ESCAPE,l],variants:[{begin:"%r\\(",end:"\\)",contains:h("\\(","\\)")},{begin:"%r\\[",end:"\\]",contains:h("\\[","\\]")},{begin:"%r\\{",end:/\}/,contains:h(/\{/,/\}/)},{begin:"%r<",end:">",contains:h("<",">")},{begin:"%r\\|",end:"\\|"}],relevance:0},_={className:"meta",begin:"@\\[",end:"\\]",contains:[e.inherit(e.QUOTE_STRING_MODE,{className:"string"})]},v=[d,f,p,m,g,_,u,e.HASH_COMMENT_MODE,{className:"class",beginKeywords:"class module struct",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:s}),{begin:"<"}]},{className:"class",beginKeywords:"lib enum union",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:s})]},{beginKeywords:"annotation",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:s})],relevance:2},{className:"function",beginKeywords:"def",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:a,endsParent:!0})]},{className:"function",beginKeywords:"fun macro",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:a,endsParent:!0})],relevance:2},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":",contains:[f,{begin:a}],relevance:0},{className:"number",variants:[{begin:"\\b0b([01_]+)"+r},{begin:"\\b0o([0-7_]+)"+r},{begin:"\\b0x([A-Fa-f0-9_]+)"+r},{begin:"\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?"+n+"(?!_)"},{begin:"\\b([1-9][0-9_]*|0)"+r}],relevance:0}];return l.contains=v,d.contains=v.slice(1),{name:"Crystal",aliases:["cr"],keywords:o,contains:v}}return cV=t,cV}var uV,vve;function A3t(){if(vve)return uV;vve=1;function t(e){const r=["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],n=["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"],i=["default","false","null","true"],a=["abstract","as","base","break","case","catch","class","const","continue","do","else","event","explicit","extern","finally","fixed","for","foreach","goto","if","implicit","in","interface","internal","is","lock","namespace","new","operator","out","override","params","private","protected","public","readonly","record","ref","return","scoped","sealed","sizeof","stackalloc","static","struct","switch","this","throw","try","typeof","unchecked","unsafe","using","virtual","void","volatile","while"],s=["add","alias","and","ascending","args","async","await","by","descending","dynamic","equals","file","from","get","global","group","init","into","join","let","nameof","not","notnull","on","or","orderby","partial","record","remove","required","scoped","select","set","unmanaged","value|0","var","when","where","with","yield"],o={keyword:a.concat(s),built_in:r,literal:i},l=e.inherit(e.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),u={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},d={className:"string",begin:/"""("*)(?!")(.|\n)*?"""\1/,relevance:1},h={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},f=e.inherit(h,{illegal:/\n/}),p={className:"subst",begin:/\{/,end:/\}/,keywords:o},g=e.inherit(p,{illegal:/\n/}),m={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},e.BACKSLASH_ESCAPE,g]},_={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},p]},v=e.inherit(_,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},g]});p.contains=[_,m,h,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,u,e.C_BLOCK_COMMENT_MODE],g.contains=[v,m,f,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,u,e.inherit(e.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const b={variants:[d,_,m,h,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},y={begin:"<",end:">",contains:[{beginKeywords:"in out"},l]},E=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",T={begin:"@"+e.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],keywords:o,illegal:/::/,contains:[e.COMMENT("///","$",{returnBegin:!0,contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{begin:""},{begin:""}]}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elif endif define undef warning error line region endregion pragma checksum"}},b,u,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},l,y,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[l,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[l,y,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"meta",begin:"^\\s*\\[(?=[\\w])",excludeBegin:!0,end:"\\]",excludeEnd:!0,contains:[{className:"string",begin:/"/,end:/"/}]},{beginKeywords:"new return throw await else",relevance:0},{className:"function",begin:"("+E+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:o,contains:[{beginKeywords:n.join(" "),relevance:0},{begin:e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,contains:[e.TITLE_MODE,y],relevance:0},{match:/\(\)/},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:o,relevance:0,contains:[b,u,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},T]}}return uV=t,uV}var dV,yve;function R3t(){if(yve)return dV;yve=1;function t(e){return{name:"CSP",case_insensitive:!1,keywords:{$pattern:"[a-zA-Z][a-zA-Z0-9_-]*",keyword:["base-uri","child-src","connect-src","default-src","font-src","form-action","frame-ancestors","frame-src","img-src","manifest-src","media-src","object-src","plugin-types","report-uri","sandbox","script-src","style-src","trusted-types","unsafe-hashes","worker-src"]},contains:[{className:"string",begin:"'",end:"'"},{className:"attribute",begin:"^Content",end:":",excludeEnd:!0}]}}return dV=t,dV}var hV,bve;function N3t(){if(bve)return hV;bve=1;const t=u=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:u.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:u.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z_][A-Za-z0-9_-]*/}}),e=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","optgroup","option","p","picture","q","quote","samp","section","select","source","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],r=["defs","g","marker","mask","pattern","svg","switch","symbol","feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feFlood","feGaussianBlur","feImage","feMerge","feMorphology","feOffset","feSpecularLighting","feTile","feTurbulence","linearGradient","radialGradient","stop","circle","ellipse","image","line","path","polygon","polyline","rect","text","use","textPath","tspan","foreignObject","clipPath"],n=[...e,...r],i=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"].sort().reverse(),a=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"].sort().reverse(),s=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),o=["accent-color","align-content","align-items","align-self","alignment-baseline","all","anchor-name","animation","animation-composition","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-range","animation-range-end","animation-range-start","animation-timeline","animation-timing-function","appearance","aspect-ratio","backdrop-filter","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-position-x","background-position-y","background-repeat","background-size","baseline-shift","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-end-end-radius","border-end-start-radius","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-start-end-radius","border-start-start-radius","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-align","box-decoration-break","box-direction","box-flex","box-flex-group","box-lines","box-ordinal-group","box-orient","box-pack","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","color-scheme","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","contain-intrinsic-block-size","contain-intrinsic-height","contain-intrinsic-inline-size","contain-intrinsic-size","contain-intrinsic-width","container","container-name","container-type","content","content-visibility","counter-increment","counter-reset","counter-set","cue","cue-after","cue-before","cursor","cx","cy","direction","display","dominant-baseline","empty-cells","enable-background","field-sizing","fill","fill-opacity","fill-rule","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flood-color","flood-opacity","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-optical-sizing","font-palette","font-size","font-size-adjust","font-smooth","font-smoothing","font-stretch","font-style","font-synthesis","font-synthesis-position","font-synthesis-small-caps","font-synthesis-style","font-synthesis-weight","font-variant","font-variant-alternates","font-variant-caps","font-variant-east-asian","font-variant-emoji","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","forced-color-adjust","gap","glyph-orientation-horizontal","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphenate-character","hyphenate-limit-chars","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","initial-letter","initial-letter-align","inline-size","inset","inset-area","inset-block","inset-block-end","inset-block-start","inset-inline","inset-inline-end","inset-inline-start","isolation","justify-content","justify-items","justify-self","kerning","left","letter-spacing","lighting-color","line-break","line-height","line-height-step","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","margin-trim","marker","marker-end","marker-mid","marker-start","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","masonry-auto-flow","math-depth","math-shift","math-style","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","offset","offset-anchor","offset-distance","offset-path","offset-position","offset-rotate","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-anchor","overflow-block","overflow-clip-margin","overflow-inline","overflow-wrap","overflow-x","overflow-y","overlay","overscroll-behavior","overscroll-behavior-block","overscroll-behavior-inline","overscroll-behavior-x","overscroll-behavior-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page","page-break-after","page-break-before","page-break-inside","paint-order","pause","pause-after","pause-before","perspective","perspective-origin","place-content","place-items","place-self","pointer-events","position","position-anchor","position-visibility","print-color-adjust","quotes","r","resize","rest","rest-after","rest-before","right","rotate","row-gap","ruby-align","ruby-position","scale","scroll-behavior","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scroll-timeline","scroll-timeline-axis","scroll-timeline-name","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","shape-rendering","speak","speak-as","src","stop-color","stop-opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","tab-size","table-layout","text-align","text-align-all","text-align-last","text-anchor","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-skip","text-decoration-skip-ink","text-decoration-style","text-decoration-thickness","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-size-adjust","text-transform","text-underline-offset","text-underline-position","text-wrap","text-wrap-mode","text-wrap-style","timeline-scope","top","touch-action","transform","transform-box","transform-origin","transform-style","transition","transition-behavior","transition-delay","transition-duration","transition-property","transition-timing-function","translate","unicode-bidi","user-modify","user-select","vector-effect","vertical-align","view-timeline","view-timeline-axis","view-timeline-inset","view-timeline-name","view-transition-name","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","white-space-collapse","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","x","y","z-index","zoom"].sort().reverse();function l(u){const d=u.regex,h=t(u),f={begin:/-(webkit|moz|ms|o)-(?=[a-z])/},p="and or not only",g=/@-?\w[\w]*(-\w+)*/,m="[a-zA-Z-][a-zA-Z0-9_-]*",_=[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE];return{name:"CSS",case_insensitive:!0,illegal:/[=|'\$]/,keywords:{keyframePosition:"from to"},classNameAliases:{keyframePosition:"selector-tag"},contains:[h.BLOCK_COMMENT,f,h.CSS_NUMBER_MODE,{className:"selector-id",begin:/#[A-Za-z0-9_-]+/,relevance:0},{className:"selector-class",begin:"\\."+m,relevance:0},h.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",variants:[{begin:":("+a.join("|")+")"},{begin:":(:)?("+s.join("|")+")"}]},h.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b"},{begin:/:/,end:/[;}{]/,contains:[h.BLOCK_COMMENT,h.HEXCOLOR,h.IMPORTANT,h.CSS_NUMBER_MODE,..._,{begin:/(url|data-uri)\(/,end:/\)/,relevance:0,keywords:{built_in:"url data-uri"},contains:[..._,{className:"string",begin:/[^)]/,endsWithParent:!0,excludeEnd:!0}]},h.FUNCTION_DISPATCH]},{begin:d.lookahead(/@/),end:"[{;]",relevance:0,illegal:/:/,contains:[{className:"keyword",begin:g},{begin:/\s/,endsWithParent:!0,excludeEnd:!0,relevance:0,keywords:{$pattern:/[a-z-]+/,keyword:p,attribute:i.join(" ")},contains:[{begin:/[a-z-]+(?=:)/,className:"attribute"},..._,h.CSS_NUMBER_MODE]}]},{className:"selector-tag",begin:"\\b("+n.join("|")+")\\b"}]}}return hV=l,hV}var fV,Sve;function O3t(){if(Sve)return fV;Sve=1;function t(e){const r={$pattern:e.UNDERSCORE_IDENT_RE,keyword:"abstract alias align asm assert auto body break byte case cast catch class const continue debug default delete deprecated do else enum export extern final finally for foreach foreach_reverse|10 goto if immutable import in inout int interface invariant is lazy macro mixin module new nothrow out override package pragma private protected public pure ref return scope shared static struct super switch synchronized template this throw try typedef typeid typeof union unittest version void volatile while with __FILE__ __LINE__ __gshared|10 __thread __traits __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__ __VERSION__",built_in:"bool cdouble cent cfloat char creal dchar delegate double dstring float function idouble ifloat ireal long real short string ubyte ucent uint ulong ushort wchar wstring",literal:"false null true"},n="(0|[1-9][\\d_]*)",i="(0|[1-9][\\d_]*|\\d[\\d_]*|[\\d_]+?\\d)",a="0[bB][01_]+",s="([\\da-fA-F][\\da-fA-F_]*|_[\\da-fA-F][\\da-fA-F_]*)",o="0[xX]"+s,l="([eE][+-]?"+i+")",u="("+i+"(\\.\\d*|"+l+")|\\d+\\."+i+"|\\."+n+l+"?)",d="(0[xX]("+s+"\\."+s+"|\\.?"+s+")[pP][+-]?"+i+")",h="("+n+"|"+a+"|"+o+")",f="("+d+"|"+u+")",p=`\\\\(['"\\?\\\\abfnrtv]|u[\\dA-Fa-f]{4}|[0-7]{1,3}|x[\\dA-Fa-f]{2}|U[\\dA-Fa-f]{8})|&[a-zA-Z\\d]{2,};`,g={className:"number",begin:"\\b"+h+"(L|u|U|Lu|LU|uL|UL)?",relevance:0},m={className:"number",begin:"\\b("+f+"([fF]|L|i|[fF]i|Li)?|"+h+"(i|[fF]i|Li))",relevance:0},_={className:"string",begin:"'("+p+"|.)",end:"'",illegal:"."},b={className:"string",begin:'"',contains:[{begin:p,relevance:0}],end:'"[cwd]?'},y={className:"string",begin:'[rq]"',end:'"[cwd]?',relevance:5},E={className:"string",begin:"`",end:"`[cwd]?"},T={className:"string",begin:'x"[\\da-fA-F\\s\\n\\r]*"[cwd]?',relevance:10},C={className:"string",begin:'q"\\{',end:'\\}"'},w={className:"meta",begin:"^#!",end:"$",relevance:5},x={className:"meta",begin:"#(line)",end:"$",relevance:5},A={className:"keyword",begin:"@[a-zA-Z_][a-zA-Z_\\d]*"},R=e.COMMENT("\\/\\+","\\+\\/",{contains:["self"],relevance:10});return{name:"D",keywords:r,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,R,T,b,y,E,C,m,g,_,w,x,A]}}return fV=t,fV}var pV,Eve;function I3t(){if(Eve)return pV;Eve=1;function t(e){const r=e.regex,n={begin:/<\/?[A-Za-z_]/,end:">",subLanguage:"xml",relevance:0},i={begin:"^[-\\*]{3,}",end:"$"},a={className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},s={className:"bullet",begin:"^[ ]*([*+-]|(\\d+\\.))(?=\\s+)",end:"\\s+",excludeEnd:!0},o={begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]},l=/[A-Za-z][A-Za-z0-9+.-]*/,u={variants:[{begin:/\[.+?\]\[.*?\]/,relevance:0},{begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,relevance:2},{begin:r.concat(/\[.+?\]\(/,l,/:\/\/.*?\)/),relevance:2},{begin:/\[.+?\]\([./?&#].*?\)/,relevance:1},{begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",end:"\\]",excludeBegin:!0,excludeEnd:!0}]},d={className:"strong",contains:[],variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]},h={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{begin:/_(?![_\s])/,end:/_/,relevance:0}]},f=e.inherit(d,{contains:[]}),p=e.inherit(h,{contains:[]});d.contains.push(p),h.contains.push(f);let g=[n,u];return[d,h,f,p].forEach(b=>{b.contains=b.contains.concat(g)}),g=g.concat(d,h),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:g},{begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",contains:g}]}]},n,s,d,h,{className:"quote",begin:"^>\\s+",contains:g,end:"$"},a,i,u,o,{scope:"literal",match:/&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/}]}}return pV=t,pV}var gV,Tve;function k3t(){if(Tve)return gV;Tve=1;function t(e){const r={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"}]},n={className:"subst",variants:[{begin:/\$\{/,end:/\}/}],keywords:"true false null this is new super"},i={className:"number",relevance:0,variants:[{match:/\b[0-9][0-9_]*(\.[0-9][0-9_]*)?([eE][+-]?[0-9][0-9_]*)?\b/},{match:/\b0[xX][0-9A-Fa-f][0-9A-Fa-f_]*\b/}]},a={className:"string",variants:[{begin:"r'''",end:"'''"},{begin:'r"""',end:'"""'},{begin:"r'",end:"'",illegal:"\\n"},{begin:'r"',end:'"',illegal:"\\n"},{begin:"'''",end:"'''",contains:[e.BACKSLASH_ESCAPE,r,n]},{begin:'"""',end:'"""',contains:[e.BACKSLASH_ESCAPE,r,n]},{begin:"'",end:"'",illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,r,n]},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,r,n]}]};n.contains=[i,a];const s=["Comparable","DateTime","Duration","Function","Iterable","Iterator","List","Map","Match","Object","Pattern","RegExp","Set","Stopwatch","String","StringBuffer","StringSink","Symbol","Type","Uri","bool","double","int","num","Element","ElementList"],o=s.map(d=>`${d}?`);return{name:"Dart",keywords:{keyword:["abstract","as","assert","async","await","base","break","case","catch","class","const","continue","covariant","default","deferred","do","dynamic","else","enum","export","extends","extension","external","factory","false","final","finally","for","Function","get","hide","if","implements","import","in","interface","is","late","library","mixin","new","null","on","operator","part","required","rethrow","return","sealed","set","show","static","super","switch","sync","this","throw","true","try","typedef","var","void","when","while","with","yield"],built_in:s.concat(o).concat(["Never","Null","dynamic","print","document","querySelector","querySelectorAll","window"]),$pattern:/[A-Za-z][A-Za-z0-9_]*\??/},contains:[a,e.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),e.COMMENT(/\/{3,} ?/,/$/,{contains:[{subLanguage:"markdown",begin:".",end:"$",relevance:0}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},i,{className:"meta",begin:"@[A-Za-z]+"},{begin:"=>"}]}}return gV=t,gV}var mV,Cve;function D3t(){if(Cve)return mV;Cve=1;function t(e){const r=["exports","register","file","shl","array","record","property","for","mod","while","set","ally","label","uses","raise","not","stored","class","safecall","var","interface","or","private","static","exit","index","inherited","to","else","stdcall","override","shr","asm","far","resourcestring","finalization","packed","virtual","out","and","protected","library","do","xorwrite","goto","near","function","end","div","overload","object","unit","begin","string","on","inline","repeat","until","destructor","write","message","program","with","read","initialization","except","default","nil","if","case","cdecl","in","downto","threadvar","of","try","pascal","const","external","constructor","type","public","then","implementation","finally","published","procedure","absolute","reintroduce","operator","as","is","abstract","alias","assembler","bitpacked","break","continue","cppdecl","cvar","enumerator","experimental","platform","deprecated","unimplemented","dynamic","export","far16","forward","generic","helper","implements","interrupt","iochecks","local","name","nodefault","noreturn","nostackframe","oldfpccall","otherwise","saveregisters","softfloat","specialize","strict","unaligned","varargs"],n=[e.C_LINE_COMMENT_MODE,e.COMMENT(/\{/,/\}/,{relevance:0}),e.COMMENT(/\(\*/,/\*\)/,{relevance:10})],i={className:"meta",variants:[{begin:/\{\$/,end:/\}/},{begin:/\(\*\$/,end:/\*\)/}]},a={className:"string",begin:/'/,end:/'/,contains:[{begin:/''/}]},s={className:"number",relevance:0,variants:[{match:/\b\d[\d_]*(\.\d[\d_]*)?/},{match:/\$[\dA-Fa-f_]+/},{match:/\$/,relevance:0},{match:/&[0-7][0-7_]*/},{match:/%[01_]+/},{match:/%/,relevance:0}]},o={className:"string",variants:[{match:/#\d[\d_]*/},{match:/#\$[\dA-Fa-f][\dA-Fa-f_]*/},{match:/#&[0-7][0-7_]*/},{match:/#%[01][01_]*/}]},l={begin:e.IDENT_RE+"\\s*=\\s*class\\s*\\(",returnBegin:!0,contains:[e.TITLE_MODE]},u={className:"function",beginKeywords:"function constructor destructor procedure",end:/[:;]/,keywords:"function constructor|10 destructor|10 procedure|10",contains:[e.TITLE_MODE,{className:"params",begin:/\(/,end:/\)/,keywords:r,contains:[a,o,i].concat(n)},i].concat(n)};return{name:"Delphi",aliases:["dpr","dfm","pas","pascal"],case_insensitive:!0,keywords:r,illegal:/"|\$[G-Zg-z]|\/\*|<\/|\|/,contains:[a,o,s,l,u,i].concat(n)}}return mV=t,mV}var _V,wve;function M3t(){if(wve)return _V;wve=1;function t(e){const r=e.regex;return{name:"Diff",aliases:["patch"],contains:[{className:"meta",relevance:10,match:r.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,/^\*\*\* +\d+,\d+ +\*\*\*\*$/,/^--- +\d+,\d+ +----$/)},{className:"comment",variants:[{begin:r.either(/Index: /,/^index/,/={3,}/,/^-{3}/,/^\*{3} /,/^\+{3}/,/^diff --git/),end:/$/},{match:/^\*{15}$/}]},{className:"addition",begin:/^\+/,end:/$/},{className:"deletion",begin:/^-/,end:/$/},{className:"addition",begin:/^!/,end:/$/}]}}return _V=t,_V}var vV,xve;function L3t(){if(xve)return vV;xve=1;function t(e){const r={begin:/\|[A-Za-z]+:?/,keywords:{name:"truncatewords removetags linebreaksbr yesno get_digit timesince random striptags filesizeformat escape linebreaks length_is ljust rjust cut urlize fix_ampersands title floatformat capfirst pprint divisibleby add make_list unordered_list urlencode timeuntil urlizetrunc wordcount stringformat linenumbers slice date dictsort dictsortreversed default_if_none pluralize lower join center default truncatewords_html upper length phone2numeric wordwrap time addslashes slugify first escapejs force_escape iriencode last safe safeseq truncatechars localize unlocalize localtime utc timezone"},contains:[e.QUOTE_STRING_MODE,e.APOS_STRING_MODE]};return{name:"Django",aliases:["jinja"],case_insensitive:!0,subLanguage:"xml",contains:[e.COMMENT(/\{%\s*comment\s*%\}/,/\{%\s*endcomment\s*%\}/),e.COMMENT(/\{#/,/#\}/),{className:"template-tag",begin:/\{%/,end:/%\}/,contains:[{className:"name",begin:/\w+/,keywords:{name:"comment endcomment load templatetag ifchanged endifchanged if endif firstof for endfor ifnotequal endifnotequal widthratio extends include spaceless endspaceless regroup ifequal endifequal ssi now with cycle url filter endfilter debug block endblock else autoescape endautoescape csrf_token empty elif endwith static trans blocktrans endblocktrans get_static_prefix get_media_prefix plural get_current_language language get_available_languages get_current_language_bidi get_language_info get_language_info_list localize endlocalize localtime endlocaltime timezone endtimezone get_current_timezone verbatim"},starts:{endsWithParent:!0,keywords:"in by as",contains:[r],relevance:0}}]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[r]}]}}return vV=t,vV}var yV,Ave;function P3t(){if(Ave)return yV;Ave=1;function t(e){return{name:"DNS Zone",aliases:["bind","zone"],keywords:["IN","A","AAAA","AFSDB","APL","CAA","CDNSKEY","CDS","CERT","CNAME","DHCID","DLV","DNAME","DNSKEY","DS","HIP","IPSECKEY","KEY","KX","LOC","MX","NAPTR","NS","NSEC","NSEC3","NSEC3PARAM","PTR","RRSIG","RP","SIG","SOA","SRV","SSHFP","TA","TKEY","TLSA","TSIG","TXT"],contains:[e.COMMENT(";","$",{relevance:0}),{className:"meta",begin:/^\$(TTL|GENERATE|INCLUDE|ORIGIN)\b/},{className:"number",begin:"((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))\\b"},{className:"number",begin:"((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]).){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\b"},e.inherit(e.NUMBER_MODE,{begin:/\b\d+[dhwm]?/})]}}return yV=t,yV}var bV,Rve;function F3t(){if(Rve)return bV;Rve=1;function t(e){return{name:"Dockerfile",aliases:["docker"],case_insensitive:!0,keywords:["from","maintainer","expose","env","arg","user","onbuild","stopsignal"],contains:[e.HASH_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE,{beginKeywords:"run cmd entrypoint volume add copy workdir label healthcheck shell",starts:{end:/[^\\]$/,subLanguage:"bash"}}],illegal:"",illegal:"\\n"}]},r,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},a={className:"variable",begin:/&[a-z\d_]*\b/},s={className:"keyword",begin:"/[a-z][a-z\\d-]*/"},o={className:"symbol",begin:"^\\s*[a-zA-Z_][a-zA-Z\\d_]*:"},l={className:"params",relevance:0,begin:"<",end:">",contains:[n,a]},u={className:"title.class",begin:/[a-zA-Z_][a-zA-Z\d_@-]*(?=\s\{)/,relevance:.2},d={className:"title.class",begin:/^\/(?=\s*\{)/,relevance:10},h={match:/[a-z][a-z-,]+(?=;)/,relevance:0,scope:"attr"},f={relevance:0,match:[/[a-z][a-z-,]+/,/\s*/,/=/],scope:{1:"attr",3:"operator"}},p={scope:"punctuation",relevance:0,match:/\};|[;{}]/};return{name:"Device Tree",contains:[d,a,s,o,u,f,h,l,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,n,r,i,p,{begin:e.IDENT_RE+"::",keywords:""}]}}return TV=t,TV}var CV,kve;function G3t(){if(kve)return CV;kve=1;function t(e){return{name:"Dust",aliases:["dst"],case_insensitive:!0,subLanguage:"xml",contains:[{className:"template-tag",begin:/\{[#\/]/,end:/\}/,illegal:/;/,contains:[{className:"name",begin:/[a-zA-Z\.-]+/,starts:{endsWithParent:!0,relevance:0,contains:[e.QUOTE_STRING_MODE]}}]},{className:"template-variable",begin:/\{/,end:/\}/,illegal:/;/,keywords:"if eq ne lt lte gt gte select default math sep"}]}}return CV=t,CV}var wV,Dve;function z3t(){if(Dve)return wV;Dve=1;function t(e){const r=e.COMMENT(/\(\*/,/\*\)/),n={className:"attribute",begin:/^[ ]*[a-zA-Z]+([\s_-]+[a-zA-Z]+)*/},a={begin:/=/,end:/[.;]/,contains:[r,{className:"meta",begin:/\?.*\?/},{className:"string",variants:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{begin:"`",end:"`"}]}]};return{name:"Extended Backus-Naur Form",illegal:/\S/,contains:[r,n,a]}}return wV=t,wV}var xV,Mve;function q3t(){if(Mve)return xV;Mve=1;function t(e){const r=e.regex,n="[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?",i="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?",o={$pattern:n,keyword:["after","alias","and","case","catch","cond","defstruct","defguard","do","else","end","fn","for","if","import","in","not","or","quote","raise","receive","require","reraise","rescue","try","unless","unquote","unquote_splicing","use","when","with|0"],literal:["false","nil","true"]},l={className:"subst",begin:/#\{/,end:/\}/,keywords:o},u={className:"number",begin:"(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[0-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)",relevance:0},h={match:/\\[\s\S]/,scope:"char.escape",relevance:0},f=`[/|([{<"']`,p=[{begin:/"/,end:/"/},{begin:/'/,end:/'/},{begin:/\//,end:/\//},{begin:/\|/,end:/\|/},{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/},{begin:/\{/,end:/\}/},{begin://}],g=C=>({scope:"char.escape",begin:r.concat(/\\/,C),relevance:0}),m={className:"string",begin:"~[a-z](?="+f+")",contains:p.map(C=>e.inherit(C,{contains:[g(C.end),h,l]}))},_={className:"string",begin:"~[A-Z](?="+f+")",contains:p.map(C=>e.inherit(C,{contains:[g(C.end)]}))},v={className:"regex",variants:[{begin:"~r(?="+f+")",contains:p.map(C=>e.inherit(C,{end:r.concat(C.end,/[uismxfU]{0,7}/),contains:[g(C.end),h,l]}))},{begin:"~R(?="+f+")",contains:p.map(C=>e.inherit(C,{end:r.concat(C.end,/[uismxfU]{0,7}/),contains:[g(C.end)]}))}]},b={className:"string",contains:[e.BACKSLASH_ESCAPE,l],variants:[{begin:/"""/,end:/"""/},{begin:/'''/,end:/'''/},{begin:/~S"""/,end:/"""/,contains:[]},{begin:/~S"/,end:/"/,contains:[]},{begin:/~S'''/,end:/'''/,contains:[]},{begin:/~S'/,end:/'/,contains:[]},{begin:/'/,end:/'/},{begin:/"/,end:/"/}]},y={className:"function",beginKeywords:"def defp defmacro defmacrop",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:n,endsParent:!0})]},E=e.inherit(y,{className:"class",beginKeywords:"defimpl defmodule defprotocol defrecord",end:/\bdo\b|$|;/}),T=[b,v,_,m,e.HASH_COMMENT_MODE,E,y,{begin:"::"},{className:"symbol",begin:":(?![\\s:])",contains:[b,{begin:i}],relevance:0},{className:"symbol",begin:n+":(?!:)",relevance:0},{className:"title.class",begin:/(\b[A-Z][a-zA-Z0-9_]+)/,relevance:0},u,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))"}];return l.contains=T,{name:"Elixir",aliases:["ex","exs"],keywords:o,contains:T}}return xV=t,xV}var AV,Lve;function H3t(){if(Lve)return AV;Lve=1;function t(e){const r={variants:[e.COMMENT("--","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},n={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},i={begin:"\\(",end:"\\)",illegal:'"',contains:[{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},r]},a={begin:/\{/,end:/\}/,contains:i.contains},s={className:"string",begin:"'\\\\?.",end:"'",illegal:"."};return{name:"Elm",keywords:["let","in","if","then","else","case","of","where","module","import","exposing","type","alias","as","infix","infixl","infixr","port","effect","command","subscription"],contains:[{beginKeywords:"port effect module",end:"exposing",keywords:"port effect module where command subscription exposing",contains:[i,r],illegal:"\\W\\.|;"},{begin:"import",end:"$",keywords:"import as exposing",contains:[i,r],illegal:"\\W\\.|;"},{begin:"type",end:"$",keywords:"type alias",contains:[n,i,a,r]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,r]},{begin:"port",end:"$",keywords:"port",contains:[r]},s,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,n,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),r,{begin:"->|<-"}],illegal:/;/}}return AV=t,AV}var RV,Pve;function V3t(){if(Pve)return RV;Pve=1;function t(e){const r=e.regex,n="([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",i=r.either(/\b([A-Z]+[a-z0-9]+)+/,/\b([A-Z]+[a-z0-9]+)+[A-Z]+/),a=r.concat(i,/(::\w+)*/),o={"variable.constant":["__FILE__","__LINE__","__ENCODING__"],"variable.language":["self","super"],keyword:["alias","and","begin","BEGIN","break","case","class","defined","do","else","elsif","end","END","ensure","for","if","in","module","next","not","or","redo","require","rescue","retry","return","then","undef","unless","until","when","while","yield",...["include","extend","prepend","public","private","protected","raise","throw"]],built_in:["proc","lambda","attr_accessor","attr_reader","attr_writer","define_method","private_constant","module_function"],literal:["true","false","nil"]},l={className:"doctag",begin:"@[A-Za-z]+"},u={begin:"#<",end:">"},d=[e.COMMENT("#","$",{contains:[l]}),e.COMMENT("^=begin","^=end",{contains:[l],relevance:10}),e.COMMENT("^__END__",e.MATCH_NOTHING_RE)],h={className:"subst",begin:/#\{/,end:/\}/,keywords:o},f={className:"string",contains:[e.BACKSLASH_ESCAPE,h],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:/%[qQwWx]?\(/,end:/\)/},{begin:/%[qQwWx]?\[/,end:/\]/},{begin:/%[qQwWx]?\{/,end:/\}/},{begin:/%[qQwWx]?/},{begin:/%[qQwWx]?\//,end:/\//},{begin:/%[qQwWx]?%/,end:/%/},{begin:/%[qQwWx]?-/,end:/-/},{begin:/%[qQwWx]?\|/,end:/\|/},{begin:/\B\?(\\\d{1,3})/},{begin:/\B\?(\\x[A-Fa-f0-9]{1,2})/},{begin:/\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/},{begin:/\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/},{begin:/\B\?\\(c|C-)[\x20-\x7e]/},{begin:/\B\?\\?\S/},{begin:r.concat(/<<[-~]?'?/,r.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,contains:[e.BACKSLASH_ESCAPE,h]})]}]},p="[1-9](_?[0-9])*|0",g="[0-9](_?[0-9])*",m={className:"number",relevance:0,variants:[{begin:`\\b(${p})(\\.(${g}))?([eE][+-]?(${g})|r)?i?\\b`},{begin:"\\b0[dD][0-9](_?[0-9])*r?i?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*r?i?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*r?i?\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"},{begin:"\\b0(_?[0-7])+r?i?\\b"}]},_={variants:[{match:/\(\)/},{className:"params",begin:/\(/,end:/(?=\))/,excludeBegin:!0,endsParent:!0,keywords:o}]},w=[f,{variants:[{match:[/class\s+/,a,/\s+<\s+/,a]},{match:[/\b(class|module)\s+/,a]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:o},{match:[/(include|extend)\s+/,a],scope:{2:"title.class"},keywords:o},{relevance:0,match:[a,/\.new[. (]/],scope:{1:"title.class"}},{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},{relevance:0,match:i,scope:"title.class"},{match:[/def/,/\s+/,n],scope:{1:"keyword",3:"title.function"},contains:[_]},{begin:e.IDENT_RE+"::"},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":(?!\\s)",contains:[f,{begin:n}],relevance:0},m,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},{className:"params",begin:/\|(?!=)/,end:/\|/,excludeBegin:!0,excludeEnd:!0,relevance:0,keywords:o},{begin:"("+e.RE_STARTERS_RE+"|unless)\\s*",keywords:"unless",contains:[{className:"regexp",contains:[e.BACKSLASH_ESCAPE,h],illegal:/\n/,variants:[{begin:"/",end:"/[a-z]*"},{begin:/%r\{/,end:/\}[a-z]*/},{begin:"%r\\(",end:"\\)[a-z]*"},{begin:"%r!",end:"![a-z]*"},{begin:"%r\\[",end:"\\][a-z]*"}]}].concat(u,d),relevance:0}].concat(u,d);h.contains=w,_.contains=w;const O=[{begin:/^\s*=>/,starts:{end:"$",contains:w}},{className:"meta.prompt",begin:"^("+"[>?]>"+"|"+"[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]"+"|"+"(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>"+")(?=[ ])",starts:{end:"$",keywords:o,contains:w}}];return d.unshift(u),{name:"Ruby",aliases:["rb","gemspec","podspec","thor","irb"],keywords:o,illegal:/\/\*/,contains:[e.SHEBANG({binary:"ruby"})].concat(O).concat(d).concat(w)}}return RV=t,RV}var NV,Fve;function Y3t(){if(Fve)return NV;Fve=1;function t(e){return{name:"ERB",subLanguage:"xml",contains:[e.COMMENT("<%#","%>"),{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0}]}}return NV=t,NV}var OV,Bve;function W3t(){if(Bve)return OV;Bve=1;function t(e){const r=e.regex;return{name:"Erlang REPL",keywords:{built_in:"spawn spawn_link self",keyword:"after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse|10 query receive rem try when xor"},contains:[{className:"meta.prompt",begin:"^[0-9]+> ",relevance:10},e.COMMENT("%","$"),{className:"number",begin:"\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",relevance:0},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{begin:r.concat(/\?(::)?/,/([A-Z]\w*)/,/((::)[A-Z]\w*)*/)},{begin:"->"},{begin:"ok"},{begin:"!"},{begin:"(\\b[a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*)|(\\b[a-z'][a-zA-Z0-9_']*)",relevance:0},{begin:"[A-Z][a-zA-Z0-9_']*",relevance:0}]}}return OV=t,OV}var IV,Uve;function K3t(){if(Uve)return IV;Uve=1;function t(e){const r="[a-z'][a-zA-Z0-9_']*",n="("+r+":"+r+"|"+r+")",i={keyword:"after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor maybe else",literal:"false true"},a=e.COMMENT("%","$"),s={className:"number",begin:"\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",relevance:0},o={begin:"fun\\s+"+r+"/\\d+"},l={begin:n+"\\(",end:"\\)",returnBegin:!0,relevance:0,contains:[{begin:n,relevance:0},{begin:"\\(",end:"\\)",endsWithParent:!0,returnEnd:!0,relevance:0}]},u={begin:/\{/,end:/\}/,relevance:0},d={begin:"\\b_([A-Z][A-Za-z0-9_]*)?",relevance:0},h={begin:"[A-Z][a-zA-Z0-9_]*",relevance:0},f={begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0,returnBegin:!0,contains:[{begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0},{begin:/\{/,end:/\}/,relevance:0}]},p={scope:"string",match:/\$(\\([^0-9]|[0-9]{1,3}|)|.)/},g={scope:"string",match:/"""("*)(?!")[\s\S]*?"""\1/},m={scope:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{match:/~\w?"""("*)(?!")[\s\S]*?"""\1/},{begin:/~\w?\(/,end:/\)/},{begin:/~\w?\[/,end:/\]/},{begin:/~\w?{/,end:/}/},{begin:/~\w?/},{begin:/~\w?\//,end:/\//},{begin:/~\w?\|/,end:/\|/},{begin:/~\w?'/,end:/'/},{begin:/~\w?"/,end:/"/},{begin:/~\w?`/,end:/`/},{begin:/~\w?#/,end:/#/}]},_={beginKeywords:"fun receive if try case maybe",end:"end",keywords:i};_.contains=[a,o,e.inherit(e.APOS_STRING_MODE,{className:""}),_,l,m,g,e.QUOTE_STRING_MODE,s,u,d,h,f,p];const v=[a,o,_,l,m,g,e.QUOTE_STRING_MODE,s,u,d,h,f,p];l.contains[1].contains=v,u.contains=v,f.contains[1].contains=v;const b=["-module","-record","-undef","-export","-ifdef","-ifndef","-author","-copyright","-doc","-moduledoc","-vsn","-import","-include","-include_lib","-compile","-define","-else","-endif","-file","-behaviour","-behavior","-spec","-on_load","-nifs"],y={className:"params",begin:"\\(",end:"\\)",contains:v};return{name:"Erlang",aliases:["erl"],keywords:i,illegal:"(",returnBegin:!0,illegal:"\\(|#|//|/\\*|\\\\|:|;",contains:[y,e.inherit(e.TITLE_MODE,{begin:r})],starts:{end:";|\\.",keywords:i,contains:v}},a,{begin:"^-",end:"\\.",relevance:0,excludeEnd:!0,returnBegin:!0,keywords:{$pattern:"-"+e.IDENT_RE,keyword:b.map(E=>`${E}|1.5`).join(" ")},contains:[y,m,g,e.QUOTE_STRING_MODE]},s,m,g,e.QUOTE_STRING_MODE,f,d,h,u,p,{begin:/\.$/}]}}return IV=t,IV}var kV,$ve;function j3t(){if($ve)return kV;$ve=1;function t(e){return{name:"Excel formulae",aliases:["xlsx","xls"],case_insensitive:!0,keywords:{$pattern:/[a-zA-Z][\w\.]*/,built_in:["ABS","ACCRINT","ACCRINTM","ACOS","ACOSH","ACOT","ACOTH","AGGREGATE","ADDRESS","AMORDEGRC","AMORLINC","AND","ARABIC","AREAS","ARRAYTOTEXT","ASC","ASIN","ASINH","ATAN","ATAN2","ATANH","AVEDEV","AVERAGE","AVERAGEA","AVERAGEIF","AVERAGEIFS","BAHTTEXT","BASE","BESSELI","BESSELJ","BESSELK","BESSELY","BETADIST","BETA.DIST","BETAINV","BETA.INV","BIN2DEC","BIN2HEX","BIN2OCT","BINOMDIST","BINOM.DIST","BINOM.DIST.RANGE","BINOM.INV","BITAND","BITLSHIFT","BITOR","BITRSHIFT","BITXOR","BYCOL","BYROW","CALL","CEILING","CEILING.MATH","CEILING.PRECISE","CELL","CHAR","CHIDIST","CHIINV","CHITEST","CHISQ.DIST","CHISQ.DIST.RT","CHISQ.INV","CHISQ.INV.RT","CHISQ.TEST","CHOOSE","CHOOSECOLS","CHOOSEROWS","CLEAN","CODE","COLUMN","COLUMNS","COMBIN","COMBINA","COMPLEX","CONCAT","CONCATENATE","CONFIDENCE","CONFIDENCE.NORM","CONFIDENCE.T","CONVERT","CORREL","COS","COSH","COT","COTH","COUNT","COUNTA","COUNTBLANK","COUNTIF","COUNTIFS","COUPDAYBS","COUPDAYS","COUPDAYSNC","COUPNCD","COUPNUM","COUPPCD","COVAR","COVARIANCE.P","COVARIANCE.S","CRITBINOM","CSC","CSCH","CUBEKPIMEMBER","CUBEMEMBER","CUBEMEMBERPROPERTY","CUBERANKEDMEMBER","CUBESET","CUBESETCOUNT","CUBEVALUE","CUMIPMT","CUMPRINC","DATE","DATEDIF","DATEVALUE","DAVERAGE","DAY","DAYS","DAYS360","DB","DBCS","DCOUNT","DCOUNTA","DDB","DEC2BIN","DEC2HEX","DEC2OCT","DECIMAL","DEGREES","DELTA","DEVSQ","DGET","DISC","DMAX","DMIN","DOLLAR","DOLLARDE","DOLLARFR","DPRODUCT","DROP","DSTDEV","DSTDEVP","DSUM","DURATION","DVAR","DVARP","EDATE","EFFECT","ENCODEURL","EOMONTH","ERF","ERF.PRECISE","ERFC","ERFC.PRECISE","ERROR.TYPE","EUROCONVERT","EVEN","EXACT","EXP","EXPAND","EXPON.DIST","EXPONDIST","FACT","FACTDOUBLE","FALSE","F.DIST","FDIST","F.DIST.RT","FILTER","FILTERXML","FIND","FINDB","F.INV","F.INV.RT","FINV","FISHER","FISHERINV","FIXED","FLOOR","FLOOR.MATH","FLOOR.PRECISE","FORECAST","FORECAST.ETS","FORECAST.ETS.CONFINT","FORECAST.ETS.SEASONALITY","FORECAST.ETS.STAT","FORECAST.LINEAR","FORMULATEXT","FREQUENCY","F.TEST","FTEST","FV","FVSCHEDULE","GAMMA","GAMMA.DIST","GAMMADIST","GAMMA.INV","GAMMAINV","GAMMALN","GAMMALN.PRECISE","GAUSS","GCD","GEOMEAN","GESTEP","GETPIVOTDATA","GROWTH","HARMEAN","HEX2BIN","HEX2DEC","HEX2OCT","HLOOKUP","HOUR","HSTACK","HYPERLINK","HYPGEOM.DIST","HYPGEOMDIST","IF","IFERROR","IFNA","IFS","IMABS","IMAGE","IMAGINARY","IMARGUMENT","IMCONJUGATE","IMCOS","IMCOSH","IMCOT","IMCSC","IMCSCH","IMDIV","IMEXP","IMLN","IMLOG10","IMLOG2","IMPOWER","IMPRODUCT","IMREAL","IMSEC","IMSECH","IMSIN","IMSINH","IMSQRT","IMSUB","IMSUM","IMTAN","INDEX","INDIRECT","INFO","INT","INTERCEPT","INTRATE","IPMT","IRR","ISBLANK","ISERR","ISERROR","ISEVEN","ISFORMULA","ISLOGICAL","ISNA","ISNONTEXT","ISNUMBER","ISODD","ISOMITTED","ISREF","ISTEXT","ISO.CEILING","ISOWEEKNUM","ISPMT","JIS","KURT","LAMBDA","LARGE","LCM","LEFT","LEFTB","LEN","LENB","LET","LINEST","LN","LOG","LOG10","LOGEST","LOGINV","LOGNORM.DIST","LOGNORMDIST","LOGNORM.INV","LOOKUP","LOWER","MAKEARRAY","MAP","MATCH","MAX","MAXA","MAXIFS","MDETERM","MDURATION","MEDIAN","MID","MIDB","MIN","MINIFS","MINA","MINUTE","MINVERSE","MIRR","MMULT","MOD","MODE","MODE.MULT","MODE.SNGL","MONTH","MROUND","MULTINOMIAL","MUNIT","N","NA","NEGBINOM.DIST","NEGBINOMDIST","NETWORKDAYS","NETWORKDAYS.INTL","NOMINAL","NORM.DIST","NORMDIST","NORMINV","NORM.INV","NORM.S.DIST","NORMSDIST","NORM.S.INV","NORMSINV","NOT","NOW","NPER","NPV","NUMBERVALUE","OCT2BIN","OCT2DEC","OCT2HEX","ODD","ODDFPRICE","ODDFYIELD","ODDLPRICE","ODDLYIELD","OFFSET","OR","PDURATION","PEARSON","PERCENTILE.EXC","PERCENTILE.INC","PERCENTILE","PERCENTRANK.EXC","PERCENTRANK.INC","PERCENTRANK","PERMUT","PERMUTATIONA","PHI","PHONETIC","PI","PMT","POISSON.DIST","POISSON","POWER","PPMT","PRICE","PRICEDISC","PRICEMAT","PROB","PRODUCT","PROPER","PV","QUARTILE","QUARTILE.EXC","QUARTILE.INC","QUOTIENT","RADIANS","RAND","RANDARRAY","RANDBETWEEN","RANK.AVG","RANK.EQ","RANK","RATE","RECEIVED","REDUCE","REGISTER.ID","REPLACE","REPLACEB","REPT","RIGHT","RIGHTB","ROMAN","ROUND","ROUNDDOWN","ROUNDUP","ROW","ROWS","RRI","RSQ","RTD","SCAN","SEARCH","SEARCHB","SEC","SECH","SECOND","SEQUENCE","SERIESSUM","SHEET","SHEETS","SIGN","SIN","SINH","SKEW","SKEW.P","SLN","SLOPE","SMALL","SORT","SORTBY","SQRT","SQRTPI","SQL.REQUEST","STANDARDIZE","STOCKHISTORY","STDEV","STDEV.P","STDEV.S","STDEVA","STDEVP","STDEVPA","STEYX","SUBSTITUTE","SUBTOTAL","SUM","SUMIF","SUMIFS","SUMPRODUCT","SUMSQ","SUMX2MY2","SUMX2PY2","SUMXMY2","SWITCH","SYD","T","TAN","TANH","TAKE","TBILLEQ","TBILLPRICE","TBILLYIELD","T.DIST","T.DIST.2T","T.DIST.RT","TDIST","TEXT","TEXTAFTER","TEXTBEFORE","TEXTJOIN","TEXTSPLIT","TIME","TIMEVALUE","T.INV","T.INV.2T","TINV","TOCOL","TOROW","TODAY","TRANSPOSE","TREND","TRIM","TRIMMEAN","TRUE","TRUNC","T.TEST","TTEST","TYPE","UNICHAR","UNICODE","UNIQUE","UPPER","VALUE","VALUETOTEXT","VAR","VAR.P","VAR.S","VARA","VARP","VARPA","VDB","VLOOKUP","VSTACK","WEBSERVICE","WEEKDAY","WEEKNUM","WEIBULL","WEIBULL.DIST","WORKDAY","WORKDAY.INTL","WRAPCOLS","WRAPROWS","XIRR","XLOOKUP","XMATCH","XNPV","XOR","YEAR","YEARFRAC","YIELD","YIELDDISC","YIELDMAT","Z.TEST","ZTEST"]},contains:[{begin:/^=/,end:/[^=]/,returnEnd:!0,illegal:/=/,relevance:10},{className:"symbol",begin:/\b[A-Z]{1,2}\d+\b/,end:/[^\d]/,excludeEnd:!0,relevance:0},{className:"symbol",begin:/[A-Z]{0,2}\d*:[A-Z]{0,2}\d*/,relevance:0},e.BACKSLASH_ESCAPE,e.QUOTE_STRING_MODE,{className:"number",begin:e.NUMBER_RE+"(%)?",relevance:0},e.COMMENT(/\bN\(/,/\)/,{excludeBegin:!0,excludeEnd:!0,illegal:/\n/})]}}return kV=t,kV}var DV,Gve;function X3t(){if(Gve)return DV;Gve=1;function t(e){return{name:"FIX",contains:[{begin:/[^\u2401\u0001]+/,end:/[\u2401\u0001]/,excludeEnd:!0,returnBegin:!0,returnEnd:!1,contains:[{begin:/([^\u2401\u0001=]+)/,end:/=([^\u2401\u0001=]+)/,returnEnd:!0,returnBegin:!1,className:"attr"},{begin:/=/,end:/([\u2401\u0001])/,excludeEnd:!0,excludeBegin:!0,className:"string"}]}],case_insensitive:!0}}return DV=t,DV}var MV,zve;function Q3t(){if(zve)return MV;zve=1;function t(e){const r={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},n={className:"string",variants:[{begin:'"',end:'"'}]},a={className:"function",beginKeywords:"def",end:/[:={\[(\n;]/,excludeEnd:!0,contains:[{className:"title",relevance:0,begin:/[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/}]};return{name:"Flix",keywords:{keyword:["case","class","def","else","enum","if","impl","import","in","lat","rel","index","let","match","namespace","switch","type","yield","with"],literal:["true","false"]},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,r,n,a,e.C_NUMBER_MODE]}}return MV=t,MV}var LV,qve;function Z3t(){if(qve)return LV;qve=1;function t(e){const r=e.regex,n={className:"params",begin:"\\(",end:"\\)"},i={variants:[e.COMMENT("!","$",{relevance:0}),e.COMMENT("^C[ ]","$",{relevance:0}),e.COMMENT("^C$","$",{relevance:0})]},a=/(_[a-z_\d]+)?/,s=/([de][+-]?\d+)?/,o={className:"number",variants:[{begin:r.concat(/\b\d+/,/\.(\d*)/,s,a)},{begin:r.concat(/\b\d+/,s,a)},{begin:r.concat(/\.\d+/,s,a)}],relevance:0},l={className:"function",beginKeywords:"subroutine function program",illegal:"[${=\\n]",contains:[e.UNDERSCORE_TITLE_MODE,n]},u={className:"string",relevance:0,variants:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]};return{name:"Fortran",case_insensitive:!0,aliases:["f90","f95"],keywords:{$pattern:/\b[a-z][a-z0-9_]+\b|\.[a-z][a-z0-9_]+\./,keyword:["kind","do","concurrent","local","shared","while","private","call","intrinsic","where","elsewhere","type","endtype","endmodule","endselect","endinterface","end","enddo","endif","if","forall","endforall","only","contains","default","return","stop","then","block","endblock","endassociate","public","subroutine|10","function","program",".and.",".or.",".not.",".le.",".eq.",".ge.",".gt.",".lt.","goto","save","else","use","module","select","case","access","blank","direct","exist","file","fmt","form","formatted","iostat","name","named","nextrec","number","opened","rec","recl","sequential","status","unformatted","unit","continue","format","pause","cycle","exit","c_null_char","c_alert","c_backspace","c_form_feed","flush","wait","decimal","round","iomsg","synchronous","nopass","non_overridable","pass","protected","volatile","abstract","extends","import","non_intrinsic","value","deferred","generic","final","enumerator","class","associate","bind","enum","c_int","c_short","c_long","c_long_long","c_signed_char","c_size_t","c_int8_t","c_int16_t","c_int32_t","c_int64_t","c_int_least8_t","c_int_least16_t","c_int_least32_t","c_int_least64_t","c_int_fast8_t","c_int_fast16_t","c_int_fast32_t","c_int_fast64_t","c_intmax_t","C_intptr_t","c_float","c_double","c_long_double","c_float_complex","c_double_complex","c_long_double_complex","c_bool","c_char","c_null_ptr","c_null_funptr","c_new_line","c_carriage_return","c_horizontal_tab","c_vertical_tab","iso_c_binding","c_loc","c_funloc","c_associated","c_f_pointer","c_ptr","c_funptr","iso_fortran_env","character_storage_size","error_unit","file_storage_size","input_unit","iostat_end","iostat_eor","numeric_storage_size","output_unit","c_f_procpointer","ieee_arithmetic","ieee_support_underflow_control","ieee_get_underflow_mode","ieee_set_underflow_mode","newunit","contiguous","recursive","pad","position","action","delim","readwrite","eor","advance","nml","interface","procedure","namelist","include","sequence","elemental","pure","impure","integer","real","character","complex","logical","codimension","dimension","allocatable|10","parameter","external","implicit|10","none","double","precision","assign","intent","optional","pointer","target","in","out","common","equivalence","data"],literal:[".False.",".True."],built_in:["alog","alog10","amax0","amax1","amin0","amin1","amod","cabs","ccos","cexp","clog","csin","csqrt","dabs","dacos","dasin","datan","datan2","dcos","dcosh","ddim","dexp","dint","dlog","dlog10","dmax1","dmin1","dmod","dnint","dsign","dsin","dsinh","dsqrt","dtan","dtanh","float","iabs","idim","idint","idnint","ifix","isign","max0","max1","min0","min1","sngl","algama","cdabs","cdcos","cdexp","cdlog","cdsin","cdsqrt","cqabs","cqcos","cqexp","cqlog","cqsin","cqsqrt","dcmplx","dconjg","derf","derfc","dfloat","dgamma","dimag","dlgama","iqint","qabs","qacos","qasin","qatan","qatan2","qcmplx","qconjg","qcos","qcosh","qdim","qerf","qerfc","qexp","qgamma","qimag","qlgama","qlog","qlog10","qmax1","qmin1","qmod","qnint","qsign","qsin","qsinh","qsqrt","qtan","qtanh","abs","acos","aimag","aint","anint","asin","atan","atan2","char","cmplx","conjg","cos","cosh","exp","ichar","index","int","log","log10","max","min","nint","sign","sin","sinh","sqrt","tan","tanh","print","write","dim","lge","lgt","lle","llt","mod","nullify","allocate","deallocate","adjustl","adjustr","all","allocated","any","associated","bit_size","btest","ceiling","count","cshift","date_and_time","digits","dot_product","eoshift","epsilon","exponent","floor","fraction","huge","iand","ibclr","ibits","ibset","ieor","ior","ishft","ishftc","lbound","len_trim","matmul","maxexponent","maxloc","maxval","merge","minexponent","minloc","minval","modulo","mvbits","nearest","pack","present","product","radix","random_number","random_seed","range","repeat","reshape","rrspacing","scale","scan","selected_int_kind","selected_real_kind","set_exponent","shape","size","spacing","spread","sum","system_clock","tiny","transpose","trim","ubound","unpack","verify","achar","iachar","transfer","dble","entry","dprod","cpu_time","command_argument_count","get_command","get_command_argument","get_environment_variable","is_iostat_end","ieee_arithmetic","ieee_support_underflow_control","ieee_get_underflow_mode","ieee_set_underflow_mode","is_iostat_eor","move_alloc","new_line","selected_char_kind","same_type_as","extends_type_of","acosh","asinh","atanh","bessel_j0","bessel_j1","bessel_jn","bessel_y0","bessel_y1","bessel_yn","erf","erfc","erfc_scaled","gamma","log_gamma","hypot","norm2","atomic_define","atomic_ref","execute_command_line","leadz","trailz","storage_size","merge_bits","bge","bgt","ble","blt","dshiftl","dshiftr","findloc","iall","iany","iparity","image_index","lcobound","ucobound","maskl","maskr","num_images","parity","popcnt","poppar","shifta","shiftl","shiftr","this_image","sync","change","team","co_broadcast","co_max","co_min","co_sum","co_reduce"]},illegal:/\/\*/,contains:[u,l,{begin:/^C\s*=(?!=)/,relevance:0},i,o]}}return LV=t,LV}var PV,Hve;function J3t(){if(Hve)return PV;Hve=1;function t(o){return new RegExp(o.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}function e(o){return o?typeof o=="string"?o:o.source:null}function r(o){return n("(?=",o,")")}function n(...o){return o.map(u=>e(u)).join("")}function i(o){const l=o[o.length-1];return typeof l=="object"&&l.constructor===Object?(o.splice(o.length-1,1),l):{}}function a(...o){return"("+(i(o).capture?"":"?:")+o.map(d=>e(d)).join("|")+")"}function s(o){const l=["abstract","and","as","assert","base","begin","class","default","delegate","do","done","downcast","downto","elif","else","end","exception","extern","finally","fixed","for","fun","function","global","if","in","inherit","inline","interface","internal","lazy","let","match","member","module","mutable","namespace","new","of","open","or","override","private","public","rec","return","static","struct","then","to","try","type","upcast","use","val","void","when","while","with","yield"],u={scope:"keyword",match:/\b(yield|return|let|do|match|use)!/},d=["if","else","endif","line","nowarn","light","r","i","I","load","time","help","quit"],h=["true","false","null","Some","None","Ok","Error","infinity","infinityf","nan","nanf"],f=["__LINE__","__SOURCE_DIRECTORY__","__SOURCE_FILE__"],p=["bool","byte","sbyte","int8","int16","int32","uint8","uint16","uint32","int","uint","int64","uint64","nativeint","unativeint","decimal","float","double","float32","single","char","string","unit","bigint","option","voption","list","array","seq","byref","exn","inref","nativeptr","obj","outref","voidptr","Result"],m={keyword:l,literal:h,built_in:["not","ref","raise","reraise","dict","readOnlyDict","set","get","enum","sizeof","typeof","typedefof","nameof","nullArg","invalidArg","invalidOp","id","fst","snd","ignore","lock","using","box","unbox","tryUnbox","printf","printfn","sprintf","eprintf","eprintfn","fprintf","fprintfn","failwith","failwithf"],"variable.constant":f},v={variants:[o.COMMENT(/\(\*(?!\))/,/\*\)/,{contains:["self"]}),o.C_LINE_COMMENT_MODE]},b=/[a-zA-Z_](\w|')*/,y={scope:"variable",begin:/``/,end:/``/},E=/\B('|\^)/,T={scope:"symbol",variants:[{match:n(E,/``.*?``/)},{match:n(E,o.UNDERSCORE_IDENT_RE)}],relevance:0},C=function({includeEqual:Y}){let j;Y?j="!%&*+-/<=>@^|~?":j="!%&*+-/<>@^|~?";const Q=Array.from(j),ae=n("[",...Q.map(t),"]"),re=a(ae,/\./),ne=n(re,r(re)),ee=a(n(ne,re,"*"),n(ae,"+"));return{scope:"operator",match:a(ee,/:\?>/,/:\?/,/:>/,/:=/,/::?/,/\$/),relevance:0}},w=C({includeEqual:!0}),x=C({includeEqual:!1}),A=function(Y,j){return{begin:n(Y,r(n(/\s*/,a(/\w/,/'/,/\^/,/#/,/``/,/\(/,/{\|/)))),beginScope:j,end:r(a(/\n/,/=/)),relevance:0,keywords:o.inherit(m,{type:p}),contains:[v,T,o.inherit(y,{scope:null}),x]}},R=A(/:/,"operator"),O=A(/\bof\b/,"keyword"),F={begin:[/(^|\s+)/,/type/,/\s+/,b],beginScope:{2:"keyword",4:"title.class"},end:r(/\(|=|$/),keywords:m,contains:[v,o.inherit(y,{scope:null}),T,{scope:"operator",match:/<|>/},R]},P={scope:"computation-expression",match:/\b[_a-z]\w*(?=\s*\{)/},N={begin:[/^\s*/,n(/#/,a(...d)),/\b/],beginScope:{2:"meta"},end:r(/\s|$/)},k={variants:[o.BINARY_NUMBER_MODE,o.C_NUMBER_MODE]},M={scope:"string",begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE]},L={scope:"string",begin:/@"/,end:/"/,contains:[{match:/""/},o.BACKSLASH_ESCAPE]},I={scope:"string",begin:/"""/,end:/"""/,relevance:2},U={scope:"subst",begin:/\{/,end:/\}/,keywords:m},B={scope:"string",begin:/\$"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},o.BACKSLASH_ESCAPE,U]},$={scope:"string",begin:/(\$@|@\$)"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},{match:/""/},o.BACKSLASH_ESCAPE,U]},H={scope:"string",begin:/\$"""/,end:/"""/,contains:[{match:/\{\{/},{match:/\}\}/},U],relevance:2},q={scope:"string",match:n(/'/,a(/[^\\']/,/\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/),/'/)};return U.contains=[$,B,L,M,q,u,v,y,R,P,N,k,T,w],{name:"F#",aliases:["fs","f#"],keywords:m,illegal:/\/\*/,classNameAliases:{"computation-expression":"keyword"},contains:[u,{variants:[H,$,B,I,L,M,q]},v,y,F,{scope:"meta",begin:/\[\]/,relevance:2,contains:[y,I,L,M,q,k]},O,R,P,N,k,T,w]}}return PV=s,PV}var FV,Vve;function e5t(){if(Vve)return FV;Vve=1;function t(e){const r=e.regex,n={keyword:"abort acronym acronyms alias all and assign binary card diag display else eq file files for free ge gt if integer le loop lt maximizing minimizing model models ne negative no not option options or ord positive prod put putpage puttl repeat sameas semicont semiint smax smin solve sos1 sos2 sum system table then until using while xor yes",literal:"eps inf na",built_in:"abs arccos arcsin arctan arctan2 Beta betaReg binomial ceil centropy cos cosh cvPower div div0 eDist entropy errorf execSeed exp fact floor frac gamma gammaReg log logBeta logGamma log10 log2 mapVal max min mod ncpCM ncpF ncpVUpow ncpVUsin normal pi poly power randBinomial randLinear randTriangle round rPower sigmoid sign signPower sin sinh slexp sllog10 slrec sqexp sqlog10 sqr sqrec sqrt tan tanh trunc uniform uniformInt vcPower bool_and bool_eqv bool_imp bool_not bool_or bool_xor ifThen rel_eq rel_ge rel_gt rel_le rel_lt rel_ne gday gdow ghour gleap gmillisec gminute gmonth gsecond gyear jdate jnow jstart jtime errorLevel execError gamsRelease gamsVersion handleCollect handleDelete handleStatus handleSubmit heapFree heapLimit heapSize jobHandle jobKill jobStatus jobTerminate licenseLevel licenseStatus maxExecError sleep timeClose timeComp timeElapsed timeExec timeStart"},i={className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0},a={className:"symbol",variants:[{begin:/=[lgenxc]=/},{begin:/\$/}]},s={className:"comment",variants:[{begin:"'",end:"'"},{begin:'"',end:'"'}],illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},o={begin:"/",end:"/",keywords:n,contains:[s,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,e.C_NUMBER_MODE]},l=/[a-z0-9&#*=?@\\><:,()$[\]_.{}!+%^-]+/,u={begin:/[a-z][a-z0-9_]*(\([a-z0-9_, ]*\))?[ \t]+/,excludeBegin:!0,end:"$",endsWithParent:!0,contains:[s,o,{className:"comment",begin:r.concat(l,r.anyNumberOfTimes(r.concat(/[ ]+/,l))),relevance:0}]};return{name:"GAMS",aliases:["gms"],case_insensitive:!0,keywords:n,contains:[e.COMMENT(/^\$ontext/,/^\$offtext/),{className:"meta",begin:"^\\$[a-z0-9]+",end:"$",returnBegin:!0,contains:[{className:"keyword",begin:"^\\$[a-z0-9]+"}]},e.COMMENT("^\\*","$"),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{beginKeywords:"set sets parameter parameters variable variables scalar scalars equation equations",end:";",contains:[e.COMMENT("^\\*","$"),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,o,u]},{beginKeywords:"table",end:";",returnBegin:!0,contains:[{beginKeywords:"table",end:"$",contains:[u]},e.COMMENT("^\\*","$"),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,e.C_NUMBER_MODE]},{className:"function",begin:/^[a-z][a-z0-9_,\-+' ()$]+\.{2}/,returnBegin:!0,contains:[{className:"title",begin:/^[a-z0-9_]+/},i,a]},e.C_NUMBER_MODE,a]}}return FV=t,FV}var BV,Yve;function t5t(){if(Yve)return BV;Yve=1;function t(e){const r={keyword:"bool break call callexe checkinterrupt clear clearg closeall cls comlog compile continue create debug declare delete disable dlibrary dllcall do dos ed edit else elseif enable end endfor endif endp endo errorlog errorlogat expr external fn for format goto gosub graph if keyword let lib library line load loadarray loadexe loadf loadk loadm loadp loads loadx local locate loopnextindex lprint lpwidth lshow matrix msym ndpclex new open output outwidth plot plotsym pop prcsn print printdos proc push retp return rndcon rndmod rndmult rndseed run save saveall screen scroll setarray show sparse stop string struct system trace trap threadfor threadendfor threadbegin threadjoin threadstat threadend until use while winprint ne ge le gt lt and xor or not eq eqv",built_in:"abs acf aconcat aeye amax amean AmericanBinomCall AmericanBinomCall_Greeks AmericanBinomCall_ImpVol AmericanBinomPut AmericanBinomPut_Greeks AmericanBinomPut_ImpVol AmericanBSCall AmericanBSCall_Greeks AmericanBSCall_ImpVol AmericanBSPut AmericanBSPut_Greeks AmericanBSPut_ImpVol amin amult annotationGetDefaults annotationSetBkd annotationSetFont annotationSetLineColor annotationSetLineStyle annotationSetLineThickness annualTradingDays arccos arcsin areshape arrayalloc arrayindex arrayinit arraytomat asciiload asclabel astd astds asum atan atan2 atranspose axmargin balance band bandchol bandcholsol bandltsol bandrv bandsolpd bar base10 begwind besselj bessely beta box boxcox cdfBeta cdfBetaInv cdfBinomial cdfBinomialInv cdfBvn cdfBvn2 cdfBvn2e cdfCauchy cdfCauchyInv cdfChic cdfChii cdfChinc cdfChincInv cdfExp cdfExpInv cdfFc cdfFnc cdfFncInv cdfGam cdfGenPareto cdfHyperGeo cdfLaplace cdfLaplaceInv cdfLogistic cdfLogisticInv cdfmControlCreate cdfMvn cdfMvn2e cdfMvnce cdfMvne cdfMvt2e cdfMvtce cdfMvte cdfN cdfN2 cdfNc cdfNegBinomial cdfNegBinomialInv cdfNi cdfPoisson cdfPoissonInv cdfRayleigh cdfRayleighInv cdfTc cdfTci cdfTnc cdfTvn cdfWeibull cdfWeibullInv cdir ceil ChangeDir chdir chiBarSquare chol choldn cholsol cholup chrs close code cols colsf combinate combinated complex con cond conj cons ConScore contour conv convertsatostr convertstrtosa corrm corrms corrvc corrx corrxs cos cosh counts countwts crossprd crout croutp csrcol csrlin csvReadM csvReadSA cumprodc cumsumc curve cvtos datacreate datacreatecomplex datalist dataload dataloop dataopen datasave date datestr datestring datestrymd dayinyr dayofweek dbAddDatabase dbClose dbCommit dbCreateQuery dbExecQuery dbGetConnectOptions dbGetDatabaseName dbGetDriverName dbGetDrivers dbGetHostName dbGetLastErrorNum dbGetLastErrorText dbGetNumericalPrecPolicy dbGetPassword dbGetPort dbGetTableHeaders dbGetTables dbGetUserName dbHasFeature dbIsDriverAvailable dbIsOpen dbIsOpenError dbOpen dbQueryBindValue dbQueryClear dbQueryCols dbQueryExecPrepared dbQueryFetchAllM dbQueryFetchAllSA dbQueryFetchOneM dbQueryFetchOneSA dbQueryFinish dbQueryGetBoundValue dbQueryGetBoundValues dbQueryGetField dbQueryGetLastErrorNum dbQueryGetLastErrorText dbQueryGetLastInsertID dbQueryGetLastQuery dbQueryGetPosition dbQueryIsActive dbQueryIsForwardOnly dbQueryIsNull dbQueryIsSelect dbQueryIsValid dbQueryPrepare dbQueryRows dbQuerySeek dbQuerySeekFirst dbQuerySeekLast dbQuerySeekNext dbQuerySeekPrevious dbQuerySetForwardOnly dbRemoveDatabase dbRollback dbSetConnectOptions dbSetDatabaseName dbSetHostName dbSetNumericalPrecPolicy dbSetPort dbSetUserName dbTransaction DeleteFile delif delrows denseToSp denseToSpRE denToZero design det detl dfft dffti diag diagrv digamma doswin DOSWinCloseall DOSWinOpen dotfeq dotfeqmt dotfge dotfgemt dotfgt dotfgtmt dotfle dotflemt dotflt dotfltmt dotfne dotfnemt draw drop dsCreate dstat dstatmt dstatmtControlCreate dtdate dtday dttime dttodtv dttostr dttoutc dtvnormal dtvtodt dtvtoutc dummy dummybr dummydn eig eigh eighv eigv elapsedTradingDays endwind envget eof eqSolve eqSolvemt eqSolvemtControlCreate eqSolvemtOutCreate eqSolveset erf erfc erfccplx erfcplx error etdays ethsec etstr EuropeanBinomCall EuropeanBinomCall_Greeks EuropeanBinomCall_ImpVol EuropeanBinomPut EuropeanBinomPut_Greeks EuropeanBinomPut_ImpVol EuropeanBSCall EuropeanBSCall_Greeks EuropeanBSCall_ImpVol EuropeanBSPut EuropeanBSPut_Greeks EuropeanBSPut_ImpVol exctsmpl exec execbg exp extern eye fcheckerr fclearerr feq feqmt fflush fft ffti fftm fftmi fftn fge fgemt fgets fgetsa fgetsat fgetst fgt fgtmt fileinfo filesa fle flemt floor flt fltmt fmod fne fnemt fonts fopen formatcv formatnv fputs fputst fseek fstrerror ftell ftocv ftos ftostrC gamma gammacplx gammaii gausset gdaAppend gdaCreate gdaDStat gdaDStatMat gdaGetIndex gdaGetName gdaGetNames gdaGetOrders gdaGetType gdaGetTypes gdaGetVarInfo gdaIsCplx gdaLoad gdaPack gdaRead gdaReadByIndex gdaReadSome gdaReadSparse gdaReadStruct gdaReportVarInfo gdaSave gdaUpdate gdaUpdateAndPack gdaVars gdaWrite gdaWrite32 gdaWriteSome getarray getdims getf getGAUSShome getmatrix getmatrix4D getname getnamef getNextTradingDay getNextWeekDay getnr getorders getpath getPreviousTradingDay getPreviousWeekDay getRow getscalar3D getscalar4D getTrRow getwind glm gradcplx gradMT gradMTm gradMTT gradMTTm gradp graphprt graphset hasimag header headermt hess hessMT hessMTg hessMTgw hessMTm hessMTmw hessMTT hessMTTg hessMTTgw hessMTTm hessMTw hessp hist histf histp hsec imag indcv indexcat indices indices2 indicesf indicesfn indnv indsav integrate1d integrateControlCreate intgrat2 intgrat3 inthp1 inthp2 inthp3 inthp4 inthpControlCreate intquad1 intquad2 intquad3 intrleav intrleavsa intrsect intsimp inv invpd invswp iscplx iscplxf isden isinfnanmiss ismiss key keyav keyw lag lag1 lagn lapEighb lapEighi lapEighvb lapEighvi lapgEig lapgEigh lapgEighv lapgEigv lapgSchur lapgSvdcst lapgSvds lapgSvdst lapSvdcusv lapSvds lapSvdusv ldlp ldlsol linSolve listwise ln lncdfbvn lncdfbvn2 lncdfmvn lncdfn lncdfn2 lncdfnc lnfact lngammacplx lnpdfmvn lnpdfmvt lnpdfn lnpdft loadd loadstruct loadwind loess loessmt loessmtControlCreate log loglog logx logy lower lowmat lowmat1 ltrisol lu lusol machEpsilon make makevars makewind margin matalloc matinit mattoarray maxbytes maxc maxindc maxv maxvec mbesselei mbesselei0 mbesselei1 mbesseli mbesseli0 mbesseli1 meanc median mergeby mergevar minc minindc minv miss missex missrv moment momentd movingave movingaveExpwgt movingaveWgt nextindex nextn nextnevn nextwind ntos null null1 numCombinations ols olsmt olsmtControlCreate olsqr olsqr2 olsqrmt ones optn optnevn orth outtyp pacf packedToSp packr parse pause pdfCauchy pdfChi pdfExp pdfGenPareto pdfHyperGeo pdfLaplace pdfLogistic pdfn pdfPoisson pdfRayleigh pdfWeibull pi pinv pinvmt plotAddArrow plotAddBar plotAddBox plotAddHist plotAddHistF plotAddHistP plotAddPolar plotAddScatter plotAddShape plotAddTextbox plotAddTS plotAddXY plotArea plotBar plotBox plotClearLayout plotContour plotCustomLayout plotGetDefaults plotHist plotHistF plotHistP plotLayout plotLogLog plotLogX plotLogY plotOpenWindow plotPolar plotSave plotScatter plotSetAxesPen plotSetBar plotSetBarFill plotSetBarStacked plotSetBkdColor plotSetFill plotSetGrid plotSetLegend plotSetLineColor plotSetLineStyle plotSetLineSymbol plotSetLineThickness plotSetNewWindow plotSetTitle plotSetWhichYAxis plotSetXAxisShow plotSetXLabel plotSetXRange plotSetXTicInterval plotSetXTicLabel plotSetYAxisShow plotSetYLabel plotSetYRange plotSetZAxisShow plotSetZLabel plotSurface plotTS plotXY polar polychar polyeval polygamma polyint polymake polymat polymroot polymult polyroot pqgwin previousindex princomp printfm printfmt prodc psi putarray putf putvals pvCreate pvGetIndex pvGetParNames pvGetParVector pvLength pvList pvPack pvPacki pvPackm pvPackmi pvPacks pvPacksi pvPacksm pvPacksmi pvPutParVector pvTest pvUnpack QNewton QNewtonmt QNewtonmtControlCreate QNewtonmtOutCreate QNewtonSet QProg QProgmt QProgmtInCreate qqr qqre qqrep qr qre qrep qrsol qrtsol qtyr qtyre qtyrep quantile quantiled qyr qyre qyrep qz rank rankindx readr real reclassify reclassifyCuts recode recserar recsercp recserrc rerun rescale reshape rets rev rfft rffti rfftip rfftn rfftnp rfftp rndBernoulli rndBeta rndBinomial rndCauchy rndChiSquare rndCon rndCreateState rndExp rndGamma rndGeo rndGumbel rndHyperGeo rndi rndKMbeta rndKMgam rndKMi rndKMn rndKMnb rndKMp rndKMu rndKMvm rndLaplace rndLCbeta rndLCgam rndLCi rndLCn rndLCnb rndLCp rndLCu rndLCvm rndLogNorm rndMTu rndMVn rndMVt rndn rndnb rndNegBinomial rndp rndPoisson rndRayleigh rndStateSkip rndu rndvm rndWeibull rndWishart rotater round rows rowsf rref sampleData satostrC saved saveStruct savewind scale scale3d scalerr scalinfnanmiss scalmiss schtoc schur searchsourcepath seekr select selif seqa seqm setdif setdifsa setvars setvwrmode setwind shell shiftr sin singleindex sinh sleep solpd sortc sortcc sortd sorthc sorthcc sortind sortindc sortmc sortr sortrc spBiconjGradSol spChol spConjGradSol spCreate spDenseSubmat spDiagRvMat spEigv spEye spLDL spline spLU spNumNZE spOnes spreadSheetReadM spreadSheetReadSA spreadSheetWrite spScale spSubmat spToDense spTrTDense spTScalar spZeros sqpSolve sqpSolveMT sqpSolveMTControlCreate sqpSolveMTlagrangeCreate sqpSolveMToutCreate sqpSolveSet sqrt statements stdc stdsc stocv stof strcombine strindx strlen strput strrindx strsect strsplit strsplitPad strtodt strtof strtofcplx strtriml strtrimr strtrunc strtruncl strtruncpad strtruncr submat subscat substute subvec sumc sumr surface svd svd1 svd2 svdcusv svds svdusv sysstate tab tan tanh tempname time timedt timestr timeutc title tkf2eps tkf2ps tocart todaydt toeplitz token topolar trapchk trigamma trimr trunc type typecv typef union unionsa uniqindx uniqindxsa unique uniquesa upmat upmat1 upper utctodt utctodtv utrisol vals varCovMS varCovXS varget vargetl varmall varmares varput varputl vartypef vcm vcms vcx vcxs vec vech vecr vector vget view viewxyz vlist vnamecv volume vput vread vtypecv wait waitc walkindex where window writer xlabel xlsGetSheetCount xlsGetSheetSize xlsGetSheetTypes xlsMakeRange xlsReadM xlsReadSA xlsWrite xlsWriteM xlsWriteSA xpnd xtics xy xyz ylabel ytics zeros zeta zlabel ztics cdfEmpirical dot h5create h5open h5read h5readAttribute h5write h5writeAttribute ldl plotAddErrorBar plotAddSurface plotCDFEmpirical plotSetColormap plotSetContourLabels plotSetLegendFont plotSetTextInterpreter plotSetXTicCount plotSetYTicCount plotSetZLevels powerm strjoin sylvester strtrim",literal:"DB_AFTER_LAST_ROW DB_ALL_TABLES DB_BATCH_OPERATIONS DB_BEFORE_FIRST_ROW DB_BLOB DB_EVENT_NOTIFICATIONS DB_FINISH_QUERY DB_HIGH_PRECISION DB_LAST_INSERT_ID DB_LOW_PRECISION_DOUBLE DB_LOW_PRECISION_INT32 DB_LOW_PRECISION_INT64 DB_LOW_PRECISION_NUMBERS DB_MULTIPLE_RESULT_SETS DB_NAMED_PLACEHOLDERS DB_POSITIONAL_PLACEHOLDERS DB_PREPARED_QUERIES DB_QUERY_SIZE DB_SIMPLE_LOCKING DB_SYSTEM_TABLES DB_TABLES DB_TRANSACTIONS DB_UNICODE DB_VIEWS __STDIN __STDOUT __STDERR __FILE_DIR"},n=e.COMMENT("@","@"),i={className:"meta",begin:"#",end:"$",keywords:{keyword:"define definecs|10 undef ifdef ifndef iflight ifdllcall ifmac ifos2win ifunix else endif lineson linesoff srcfile srcline"},contains:[{begin:/\\\n/,relevance:0},{beginKeywords:"include",end:"$",keywords:{keyword:"include"},contains:[{className:"string",begin:'"',end:'"',illegal:"\\n"}]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,n]},a={begin:/\bstruct\s+/,end:/\s/,keywords:"struct",contains:[{className:"type",begin:e.UNDERSCORE_IDENT_RE,relevance:0}]},s=[{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,endsWithParent:!0,relevance:0,contains:[{className:"literal",begin:/\.\.\./},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,n,a]}],o={className:"title",begin:e.UNDERSCORE_IDENT_RE,relevance:0},l=function(p,g,m){const _=e.inherit({className:"function",beginKeywords:p,end:g,excludeEnd:!0,contains:[].concat(s)},{});return _.contains.push(o),_.contains.push(e.C_NUMBER_MODE),_.contains.push(e.C_BLOCK_COMMENT_MODE),_.contains.push(n),_},u={className:"built_in",begin:"\\b("+r.built_in.split(" ").join("|")+")\\b"},d={className:"string",begin:'"',end:'"',contains:[e.BACKSLASH_ESCAPE],relevance:0},h={begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,keywords:r,relevance:0,contains:[{beginKeywords:r.keyword},u,{className:"built_in",begin:e.UNDERSCORE_IDENT_RE,relevance:0}]},f={begin:/\(/,end:/\)/,relevance:0,keywords:{built_in:r.built_in,literal:r.literal},contains:[e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,n,u,h,d,"self"]};return h.contains.push(f),{name:"GAUSS",aliases:["gss"],case_insensitive:!0,keywords:r,illegal:/(\{[%#]|[%#]\}| <- )/,contains:[e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,n,d,i,{className:"keyword",begin:/\bexternal (matrix|string|array|sparse matrix|struct|proc|keyword|fn)/},l("proc keyword",";"),l("fn","="),{beginKeywords:"for threadfor",end:/;/,relevance:0,contains:[e.C_BLOCK_COMMENT_MODE,n,f]},{variants:[{begin:e.UNDERSCORE_IDENT_RE+"\\."+e.UNDERSCORE_IDENT_RE},{begin:e.UNDERSCORE_IDENT_RE+"\\s*="}],relevance:0},h,a]}}return BV=t,BV}var UV,Wve;function r5t(){if(Wve)return UV;Wve=1;function t(e){const r=e.regex,n={$pattern:/[A-Z]+|%/,keyword:["THEN","ELSE","ENDIF","IF","GOTO","DO","WHILE","WH","END","CALL","SUB","ENDSUB","EQ","NE","LT","GT","LE","GE","AND","OR","XOR","%"],built_in:["ATAN","ABS","ACOS","ASIN","COS","EXP","FIX","FUP","ROUND","LN","SIN","SQRT","TAN","EXISTS"]},i=/\b/;function a(g,m){if(g.index===0)return;const _=g.input[g.index-1];_>="0"&&_<="9"||_!=="_"&&m.ignoreMatch()}const s=/[+-]?((\.\d+)|(\d+)(\.\d*)?)/,o=/[GM]\s*\d+(\.\d+)?/,l=/T\s*\d+/,u=/O\s*\d+/,d=/O<.+>/,h=/[ABCUVWXYZ]\s*/,f=/[FHIJKPQRS]\s*/,p=[e.COMMENT(/\(/,/\)/),e.COMMENT(/;/,/$/),e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,{scope:"title.function",variants:[{match:r.concat(i,o)},{begin:o,"on:begin":a},{match:r.concat(i,l)},{begin:l,"on:begin":a}]},{scope:"symbol",variants:[{match:r.concat(i,u)},{begin:u,"on:begin":a},{match:r.concat(i,d)},{begin:d,"on:begin":a},{match:/\*\s*\d+\s*$/}]},{scope:"operator",match:/^N\s*\d+/},{scope:"variable",match:/-?#\s*\d+/},{scope:"property",variants:[{match:r.concat(i,h,s)},{begin:r.concat(h,s),"on:begin":a}]},{scope:"params",variants:[{match:r.concat(i,f,s)},{begin:r.concat(f,s),"on:begin":a}]}];return{name:"G-code (ISO 6983)",aliases:["nc"],case_insensitive:!0,disableAutodetect:!0,keywords:n,contains:p}}return UV=t,UV}var $V,Kve;function n5t(){if(Kve)return $V;Kve=1;function t(e){return{name:"Gherkin",aliases:["feature"],keywords:"Feature Background Ability Business Need Scenario Scenarios Scenario Outline Scenario Template Examples Given And Then But When",contains:[{className:"symbol",begin:"\\*",relevance:0},{className:"meta",begin:"@[^@\\s]+"},{begin:"\\|",end:"\\|\\w*$",contains:[{className:"string",begin:"[^|]+"}]},{className:"variable",begin:"<",end:">"},e.HASH_COMMENT_MODE,{className:"string",begin:'"""',end:'"""'},e.QUOTE_STRING_MODE]}}return $V=t,$V}var GV,jve;function i5t(){if(jve)return GV;jve=1;function t(e){return{name:"GLSL",keywords:{keyword:"break continue discard do else for if return while switch case default attribute binding buffer ccw centroid centroid varying coherent column_major const cw depth_any depth_greater depth_less depth_unchanged early_fragment_tests equal_spacing flat fractional_even_spacing fractional_odd_spacing highp in index inout invariant invocations isolines layout line_strip lines lines_adjacency local_size_x local_size_y local_size_z location lowp max_vertices mediump noperspective offset origin_upper_left out packed patch pixel_center_integer point_mode points precise precision quads r11f_g11f_b10f r16 r16_snorm r16f r16i r16ui r32f r32i r32ui r8 r8_snorm r8i r8ui readonly restrict rg16 rg16_snorm rg16f rg16i rg16ui rg32f rg32i rg32ui rg8 rg8_snorm rg8i rg8ui rgb10_a2 rgb10_a2ui rgba16 rgba16_snorm rgba16f rgba16i rgba16ui rgba32f rgba32i rgba32ui rgba8 rgba8_snorm rgba8i rgba8ui row_major sample shared smooth std140 std430 stream triangle_strip triangles triangles_adjacency uniform varying vertices volatile writeonly",type:"atomic_uint bool bvec2 bvec3 bvec4 dmat2 dmat2x2 dmat2x3 dmat2x4 dmat3 dmat3x2 dmat3x3 dmat3x4 dmat4 dmat4x2 dmat4x3 dmat4x4 double dvec2 dvec3 dvec4 float iimage1D iimage1DArray iimage2D iimage2DArray iimage2DMS iimage2DMSArray iimage2DRect iimage3D iimageBuffer iimageCube iimageCubeArray image1D image1DArray image2D image2DArray image2DMS image2DMSArray image2DRect image3D imageBuffer imageCube imageCubeArray int isampler1D isampler1DArray isampler2D isampler2DArray isampler2DMS isampler2DMSArray isampler2DRect isampler3D isamplerBuffer isamplerCube isamplerCubeArray ivec2 ivec3 ivec4 mat2 mat2x2 mat2x3 mat2x4 mat3 mat3x2 mat3x3 mat3x4 mat4 mat4x2 mat4x3 mat4x4 sampler1D sampler1DArray sampler1DArrayShadow sampler1DShadow sampler2D sampler2DArray sampler2DArrayShadow sampler2DMS sampler2DMSArray sampler2DRect sampler2DRectShadow sampler2DShadow sampler3D samplerBuffer samplerCube samplerCubeArray samplerCubeArrayShadow samplerCubeShadow image1D uimage1DArray uimage2D uimage2DArray uimage2DMS uimage2DMSArray uimage2DRect uimage3D uimageBuffer uimageCube uimageCubeArray uint usampler1D usampler1DArray usampler2D usampler2DArray usampler2DMS usampler2DMSArray usampler2DRect usampler3D samplerBuffer usamplerCube usamplerCubeArray uvec2 uvec3 uvec4 vec2 vec3 vec4 void",built_in:"gl_MaxAtomicCounterBindings gl_MaxAtomicCounterBufferSize gl_MaxClipDistances gl_MaxClipPlanes gl_MaxCombinedAtomicCounterBuffers gl_MaxCombinedAtomicCounters gl_MaxCombinedImageUniforms gl_MaxCombinedImageUnitsAndFragmentOutputs gl_MaxCombinedTextureImageUnits gl_MaxComputeAtomicCounterBuffers gl_MaxComputeAtomicCounters gl_MaxComputeImageUniforms gl_MaxComputeTextureImageUnits gl_MaxComputeUniformComponents gl_MaxComputeWorkGroupCount gl_MaxComputeWorkGroupSize gl_MaxDrawBuffers gl_MaxFragmentAtomicCounterBuffers gl_MaxFragmentAtomicCounters gl_MaxFragmentImageUniforms gl_MaxFragmentInputComponents gl_MaxFragmentInputVectors gl_MaxFragmentUniformComponents gl_MaxFragmentUniformVectors gl_MaxGeometryAtomicCounterBuffers gl_MaxGeometryAtomicCounters gl_MaxGeometryImageUniforms gl_MaxGeometryInputComponents gl_MaxGeometryOutputComponents gl_MaxGeometryOutputVertices gl_MaxGeometryTextureImageUnits gl_MaxGeometryTotalOutputComponents gl_MaxGeometryUniformComponents gl_MaxGeometryVaryingComponents gl_MaxImageSamples gl_MaxImageUnits gl_MaxLights gl_MaxPatchVertices gl_MaxProgramTexelOffset gl_MaxTessControlAtomicCounterBuffers gl_MaxTessControlAtomicCounters gl_MaxTessControlImageUniforms gl_MaxTessControlInputComponents gl_MaxTessControlOutputComponents gl_MaxTessControlTextureImageUnits gl_MaxTessControlTotalOutputComponents gl_MaxTessControlUniformComponents gl_MaxTessEvaluationAtomicCounterBuffers gl_MaxTessEvaluationAtomicCounters gl_MaxTessEvaluationImageUniforms gl_MaxTessEvaluationInputComponents gl_MaxTessEvaluationOutputComponents gl_MaxTessEvaluationTextureImageUnits gl_MaxTessEvaluationUniformComponents gl_MaxTessGenLevel gl_MaxTessPatchComponents gl_MaxTextureCoords gl_MaxTextureImageUnits gl_MaxTextureUnits gl_MaxVaryingComponents gl_MaxVaryingFloats gl_MaxVaryingVectors gl_MaxVertexAtomicCounterBuffers gl_MaxVertexAtomicCounters gl_MaxVertexAttribs gl_MaxVertexImageUniforms gl_MaxVertexOutputComponents gl_MaxVertexOutputVectors gl_MaxVertexTextureImageUnits gl_MaxVertexUniformComponents gl_MaxVertexUniformVectors gl_MaxViewports gl_MinProgramTexelOffset gl_BackColor gl_BackLightModelProduct gl_BackLightProduct gl_BackMaterial gl_BackSecondaryColor gl_ClipDistance gl_ClipPlane gl_ClipVertex gl_Color gl_DepthRange gl_EyePlaneQ gl_EyePlaneR gl_EyePlaneS gl_EyePlaneT gl_Fog gl_FogCoord gl_FogFragCoord gl_FragColor gl_FragCoord gl_FragData gl_FragDepth gl_FrontColor gl_FrontFacing gl_FrontLightModelProduct gl_FrontLightProduct gl_FrontMaterial gl_FrontSecondaryColor gl_GlobalInvocationID gl_InstanceID gl_InvocationID gl_Layer gl_LightModel gl_LightSource gl_LocalInvocationID gl_LocalInvocationIndex gl_ModelViewMatrix gl_ModelViewMatrixInverse gl_ModelViewMatrixInverseTranspose gl_ModelViewMatrixTranspose gl_ModelViewProjectionMatrix gl_ModelViewProjectionMatrixInverse gl_ModelViewProjectionMatrixInverseTranspose gl_ModelViewProjectionMatrixTranspose gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 gl_Normal gl_NormalMatrix gl_NormalScale gl_NumSamples gl_NumWorkGroups gl_ObjectPlaneQ gl_ObjectPlaneR gl_ObjectPlaneS gl_ObjectPlaneT gl_PatchVerticesIn gl_Point gl_PointCoord gl_PointSize gl_Position gl_PrimitiveID gl_PrimitiveIDIn gl_ProjectionMatrix gl_ProjectionMatrixInverse gl_ProjectionMatrixInverseTranspose gl_ProjectionMatrixTranspose gl_SampleID gl_SampleMask gl_SampleMaskIn gl_SamplePosition gl_SecondaryColor gl_TessCoord gl_TessLevelInner gl_TessLevelOuter gl_TexCoord gl_TextureEnvColor gl_TextureMatrix gl_TextureMatrixInverse gl_TextureMatrixInverseTranspose gl_TextureMatrixTranspose gl_Vertex gl_VertexID gl_ViewportIndex gl_WorkGroupID gl_WorkGroupSize gl_in gl_out EmitStreamVertex EmitVertex EndPrimitive EndStreamPrimitive abs acos acosh all any asin asinh atan atanh atomicAdd atomicAnd atomicCompSwap atomicCounter atomicCounterDecrement atomicCounterIncrement atomicExchange atomicMax atomicMin atomicOr atomicXor barrier bitCount bitfieldExtract bitfieldInsert bitfieldReverse ceil clamp cos cosh cross dFdx dFdy degrees determinant distance dot equal exp exp2 faceforward findLSB findMSB floatBitsToInt floatBitsToUint floor fma fract frexp ftransform fwidth greaterThan greaterThanEqual groupMemoryBarrier imageAtomicAdd imageAtomicAnd imageAtomicCompSwap imageAtomicExchange imageAtomicMax imageAtomicMin imageAtomicOr imageAtomicXor imageLoad imageSize imageStore imulExtended intBitsToFloat interpolateAtCentroid interpolateAtOffset interpolateAtSample inverse inversesqrt isinf isnan ldexp length lessThan lessThanEqual log log2 matrixCompMult max memoryBarrier memoryBarrierAtomicCounter memoryBarrierBuffer memoryBarrierImage memoryBarrierShared min mix mod modf noise1 noise2 noise3 noise4 normalize not notEqual outerProduct packDouble2x32 packHalf2x16 packSnorm2x16 packSnorm4x8 packUnorm2x16 packUnorm4x8 pow radians reflect refract round roundEven shadow1D shadow1DLod shadow1DProj shadow1DProjLod shadow2D shadow2DLod shadow2DProj shadow2DProjLod sign sin sinh smoothstep sqrt step tan tanh texelFetch texelFetchOffset texture texture1D texture1DLod texture1DProj texture1DProjLod texture2D texture2DLod texture2DProj texture2DProjLod texture3D texture3DLod texture3DProj texture3DProjLod textureCube textureCubeLod textureGather textureGatherOffset textureGatherOffsets textureGrad textureGradOffset textureLod textureLodOffset textureOffset textureProj textureProjGrad textureProjGradOffset textureProjLod textureProjLodOffset textureProjOffset textureQueryLevels textureQueryLod textureSize transpose trunc uaddCarry uintBitsToFloat umulExtended unpackDouble2x32 unpackHalf2x16 unpackSnorm2x16 unpackSnorm4x8 unpackUnorm2x16 unpackUnorm4x8 usubBorrow",literal:"true false"},illegal:'"',contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.C_NUMBER_MODE,{className:"meta",begin:"#",end:"$"}]}}return GV=t,GV}var zV,Xve;function a5t(){if(Xve)return zV;Xve=1;function t(e){return{name:"GML",case_insensitive:!1,keywords:{keyword:["#endregion","#macro","#region","and","begin","break","case","constructor","continue","default","delete","div","do","else","end","enum","exit","for","function","globalvar","if","mod","new","not","or","repeat","return","static","switch","then","until","var","while","with","xor"],built_in:["abs","alarm_get","alarm_set","angle_difference","animcurve_channel_evaluate","animcurve_channel_new","animcurve_create","animcurve_destroy","animcurve_exists","animcurve_get","animcurve_get_channel","animcurve_get_channel_index","animcurve_point_new","ansi_char","application_get_position","application_surface_draw_enable","application_surface_enable","application_surface_is_enabled","arccos","arcsin","arctan","arctan2","array_all","array_any","array_concat","array_contains","array_contains_ext","array_copy","array_copy_while","array_create","array_create_ext","array_delete","array_equals","array_filter","array_filter_ext","array_find_index","array_first","array_foreach","array_get","array_get_index","array_insert","array_intersection","array_last","array_length","array_map","array_map_ext","array_pop","array_push","array_reduce","array_resize","array_reverse","array_reverse_ext","array_set","array_shuffle","array_shuffle_ext","array_sort","array_union","array_unique","array_unique_ext","asset_add_tags","asset_clear_tags","asset_get_ids","asset_get_index","asset_get_tags","asset_get_type","asset_has_any_tag","asset_has_tags","asset_remove_tags","audio_bus_clear_emitters","audio_bus_create","audio_bus_get_emitters","audio_channel_num","audio_create_buffer_sound","audio_create_play_queue","audio_create_stream","audio_create_sync_group","audio_debug","audio_destroy_stream","audio_destroy_sync_group","audio_effect_create","audio_emitter_bus","audio_emitter_create","audio_emitter_exists","audio_emitter_falloff","audio_emitter_free","audio_emitter_gain","audio_emitter_get_bus","audio_emitter_get_gain","audio_emitter_get_listener_mask","audio_emitter_get_pitch","audio_emitter_get_vx","audio_emitter_get_vy","audio_emitter_get_vz","audio_emitter_get_x","audio_emitter_get_y","audio_emitter_get_z","audio_emitter_pitch","audio_emitter_position","audio_emitter_set_listener_mask","audio_emitter_velocity","audio_exists","audio_falloff_set_model","audio_free_buffer_sound","audio_free_play_queue","audio_get_listener_count","audio_get_listener_info","audio_get_listener_mask","audio_get_master_gain","audio_get_name","audio_get_recorder_count","audio_get_recorder_info","audio_get_type","audio_group_get_assets","audio_group_get_gain","audio_group_is_loaded","audio_group_load","audio_group_load_progress","audio_group_name","audio_group_set_gain","audio_group_stop_all","audio_group_unload","audio_is_paused","audio_is_playing","audio_listener_get_data","audio_listener_orientation","audio_listener_position","audio_listener_set_orientation","audio_listener_set_position","audio_listener_set_velocity","audio_listener_velocity","audio_master_gain","audio_pause_all","audio_pause_sound","audio_pause_sync_group","audio_play_in_sync_group","audio_play_sound","audio_play_sound_at","audio_play_sound_ext","audio_play_sound_on","audio_queue_sound","audio_resume_all","audio_resume_sound","audio_resume_sync_group","audio_set_listener_mask","audio_set_master_gain","audio_sound_gain","audio_sound_get_audio_group","audio_sound_get_gain","audio_sound_get_listener_mask","audio_sound_get_loop","audio_sound_get_loop_end","audio_sound_get_loop_start","audio_sound_get_pitch","audio_sound_get_track_position","audio_sound_is_playable","audio_sound_length","audio_sound_loop","audio_sound_loop_end","audio_sound_loop_start","audio_sound_pitch","audio_sound_set_listener_mask","audio_sound_set_track_position","audio_start_recording","audio_start_sync_group","audio_stop_all","audio_stop_recording","audio_stop_sound","audio_stop_sync_group","audio_sync_group_debug","audio_sync_group_get_track_pos","audio_sync_group_is_paused","audio_sync_group_is_playing","audio_system_is_available","audio_system_is_initialised","base64_decode","base64_encode","bool","browser_input_capture","buffer_async_group_begin","buffer_async_group_end","buffer_async_group_option","buffer_base64_decode","buffer_base64_decode_ext","buffer_base64_encode","buffer_compress","buffer_copy","buffer_copy_from_vertex_buffer","buffer_copy_stride","buffer_crc32","buffer_create","buffer_create_from_vertex_buffer","buffer_create_from_vertex_buffer_ext","buffer_decompress","buffer_delete","buffer_exists","buffer_fill","buffer_get_address","buffer_get_alignment","buffer_get_size","buffer_get_surface","buffer_get_type","buffer_load","buffer_load_async","buffer_load_ext","buffer_load_partial","buffer_md5","buffer_peek","buffer_poke","buffer_read","buffer_resize","buffer_save","buffer_save_async","buffer_save_ext","buffer_seek","buffer_set_surface","buffer_set_used_size","buffer_sha1","buffer_sizeof","buffer_tell","buffer_write","call_cancel","call_later","camera_apply","camera_copy_transforms","camera_create","camera_create_view","camera_destroy","camera_get_active","camera_get_begin_script","camera_get_default","camera_get_end_script","camera_get_proj_mat","camera_get_update_script","camera_get_view_angle","camera_get_view_border_x","camera_get_view_border_y","camera_get_view_height","camera_get_view_mat","camera_get_view_speed_x","camera_get_view_speed_y","camera_get_view_target","camera_get_view_width","camera_get_view_x","camera_get_view_y","camera_set_begin_script","camera_set_default","camera_set_end_script","camera_set_proj_mat","camera_set_update_script","camera_set_view_angle","camera_set_view_border","camera_set_view_mat","camera_set_view_pos","camera_set_view_size","camera_set_view_speed","camera_set_view_target","ceil","choose","chr","clamp","clickable_add","clickable_add_ext","clickable_change","clickable_change_ext","clickable_delete","clickable_exists","clickable_set_style","clipboard_get_text","clipboard_has_text","clipboard_set_text","cloud_file_save","cloud_string_save","cloud_synchronise","code_is_compiled","collision_circle","collision_circle_list","collision_ellipse","collision_ellipse_list","collision_line","collision_line_list","collision_point","collision_point_list","collision_rectangle","collision_rectangle_list","color_get_blue","color_get_green","color_get_hue","color_get_red","color_get_saturation","color_get_value","colour_get_blue","colour_get_green","colour_get_hue","colour_get_red","colour_get_saturation","colour_get_value","cos","darccos","darcsin","darctan","darctan2","date_compare_date","date_compare_datetime","date_compare_time","date_create_datetime","date_current_datetime","date_date_of","date_date_string","date_datetime_string","date_day_span","date_days_in_month","date_days_in_year","date_get_day","date_get_day_of_year","date_get_hour","date_get_hour_of_year","date_get_minute","date_get_minute_of_year","date_get_month","date_get_second","date_get_second_of_year","date_get_timezone","date_get_week","date_get_weekday","date_get_year","date_hour_span","date_inc_day","date_inc_hour","date_inc_minute","date_inc_month","date_inc_second","date_inc_week","date_inc_year","date_is_today","date_leap_year","date_minute_span","date_month_span","date_second_span","date_set_timezone","date_time_of","date_time_string","date_valid_datetime","date_week_span","date_year_span","db_to_lin","dbg_add_font_glyphs","dbg_button","dbg_checkbox","dbg_color","dbg_colour","dbg_drop_down","dbg_same_line","dbg_section","dbg_section_delete","dbg_section_exists","dbg_slider","dbg_slider_int","dbg_sprite","dbg_text","dbg_text_input","dbg_view","dbg_view_delete","dbg_view_exists","dbg_watch","dcos","debug_event","debug_get_callstack","degtorad","device_get_tilt_x","device_get_tilt_y","device_get_tilt_z","device_is_keypad_open","device_mouse_check_button","device_mouse_check_button_pressed","device_mouse_check_button_released","device_mouse_dbclick_enable","device_mouse_raw_x","device_mouse_raw_y","device_mouse_x","device_mouse_x_to_gui","device_mouse_y","device_mouse_y_to_gui","directory_create","directory_destroy","directory_exists","display_get_dpi_x","display_get_dpi_y","display_get_frequency","display_get_gui_height","display_get_gui_width","display_get_height","display_get_orientation","display_get_sleep_margin","display_get_timing_method","display_get_width","display_mouse_get_x","display_mouse_get_y","display_mouse_set","display_reset","display_set_gui_maximise","display_set_gui_maximize","display_set_gui_size","display_set_sleep_margin","display_set_timing_method","display_set_ui_visibility","distance_to_object","distance_to_point","dot_product","dot_product_3d","dot_product_3d_normalised","dot_product_3d_normalized","dot_product_normalised","dot_product_normalized","draw_arrow","draw_button","draw_circle","draw_circle_color","draw_circle_colour","draw_clear","draw_clear_alpha","draw_ellipse","draw_ellipse_color","draw_ellipse_colour","draw_enable_drawevent","draw_enable_skeleton_blendmodes","draw_enable_swf_aa","draw_flush","draw_get_alpha","draw_get_color","draw_get_colour","draw_get_enable_skeleton_blendmodes","draw_get_font","draw_get_halign","draw_get_lighting","draw_get_swf_aa_level","draw_get_valign","draw_getpixel","draw_getpixel_ext","draw_healthbar","draw_highscore","draw_light_define_ambient","draw_light_define_direction","draw_light_define_point","draw_light_enable","draw_light_get","draw_light_get_ambient","draw_line","draw_line_color","draw_line_colour","draw_line_width","draw_line_width_color","draw_line_width_colour","draw_path","draw_point","draw_point_color","draw_point_colour","draw_primitive_begin","draw_primitive_begin_texture","draw_primitive_end","draw_rectangle","draw_rectangle_color","draw_rectangle_colour","draw_roundrect","draw_roundrect_color","draw_roundrect_color_ext","draw_roundrect_colour","draw_roundrect_colour_ext","draw_roundrect_ext","draw_self","draw_set_alpha","draw_set_circle_precision","draw_set_color","draw_set_colour","draw_set_font","draw_set_halign","draw_set_lighting","draw_set_swf_aa_level","draw_set_valign","draw_skeleton","draw_skeleton_collision","draw_skeleton_instance","draw_skeleton_time","draw_sprite","draw_sprite_ext","draw_sprite_general","draw_sprite_part","draw_sprite_part_ext","draw_sprite_pos","draw_sprite_stretched","draw_sprite_stretched_ext","draw_sprite_tiled","draw_sprite_tiled_ext","draw_surface","draw_surface_ext","draw_surface_general","draw_surface_part","draw_surface_part_ext","draw_surface_stretched","draw_surface_stretched_ext","draw_surface_tiled","draw_surface_tiled_ext","draw_text","draw_text_color","draw_text_colour","draw_text_ext","draw_text_ext_color","draw_text_ext_colour","draw_text_ext_transformed","draw_text_ext_transformed_color","draw_text_ext_transformed_colour","draw_text_transformed","draw_text_transformed_color","draw_text_transformed_colour","draw_texture_flush","draw_tile","draw_tilemap","draw_triangle","draw_triangle_color","draw_triangle_colour","draw_vertex","draw_vertex_color","draw_vertex_colour","draw_vertex_texture","draw_vertex_texture_color","draw_vertex_texture_colour","ds_exists","ds_grid_add","ds_grid_add_disk","ds_grid_add_grid_region","ds_grid_add_region","ds_grid_clear","ds_grid_copy","ds_grid_create","ds_grid_destroy","ds_grid_get","ds_grid_get_disk_max","ds_grid_get_disk_mean","ds_grid_get_disk_min","ds_grid_get_disk_sum","ds_grid_get_max","ds_grid_get_mean","ds_grid_get_min","ds_grid_get_sum","ds_grid_height","ds_grid_multiply","ds_grid_multiply_disk","ds_grid_multiply_grid_region","ds_grid_multiply_region","ds_grid_read","ds_grid_resize","ds_grid_set","ds_grid_set_disk","ds_grid_set_grid_region","ds_grid_set_region","ds_grid_shuffle","ds_grid_sort","ds_grid_to_mp_grid","ds_grid_value_disk_exists","ds_grid_value_disk_x","ds_grid_value_disk_y","ds_grid_value_exists","ds_grid_value_x","ds_grid_value_y","ds_grid_width","ds_grid_write","ds_list_add","ds_list_clear","ds_list_copy","ds_list_create","ds_list_delete","ds_list_destroy","ds_list_empty","ds_list_find_index","ds_list_find_value","ds_list_insert","ds_list_is_list","ds_list_is_map","ds_list_mark_as_list","ds_list_mark_as_map","ds_list_read","ds_list_replace","ds_list_set","ds_list_shuffle","ds_list_size","ds_list_sort","ds_list_write","ds_map_add","ds_map_add_list","ds_map_add_map","ds_map_clear","ds_map_copy","ds_map_create","ds_map_delete","ds_map_destroy","ds_map_empty","ds_map_exists","ds_map_find_first","ds_map_find_last","ds_map_find_next","ds_map_find_previous","ds_map_find_value","ds_map_is_list","ds_map_is_map","ds_map_keys_to_array","ds_map_read","ds_map_replace","ds_map_replace_list","ds_map_replace_map","ds_map_secure_load","ds_map_secure_load_buffer","ds_map_secure_save","ds_map_secure_save_buffer","ds_map_set","ds_map_size","ds_map_values_to_array","ds_map_write","ds_priority_add","ds_priority_change_priority","ds_priority_clear","ds_priority_copy","ds_priority_create","ds_priority_delete_max","ds_priority_delete_min","ds_priority_delete_value","ds_priority_destroy","ds_priority_empty","ds_priority_find_max","ds_priority_find_min","ds_priority_find_priority","ds_priority_read","ds_priority_size","ds_priority_write","ds_queue_clear","ds_queue_copy","ds_queue_create","ds_queue_dequeue","ds_queue_destroy","ds_queue_empty","ds_queue_enqueue","ds_queue_head","ds_queue_read","ds_queue_size","ds_queue_tail","ds_queue_write","ds_set_precision","ds_stack_clear","ds_stack_copy","ds_stack_create","ds_stack_destroy","ds_stack_empty","ds_stack_pop","ds_stack_push","ds_stack_read","ds_stack_size","ds_stack_top","ds_stack_write","dsin","dtan","effect_clear","effect_create_above","effect_create_below","effect_create_depth","effect_create_layer","environment_get_variable","event_inherited","event_perform","event_perform_async","event_perform_object","event_user","exception_unhandled_handler","exp","extension_exists","extension_get_option_count","extension_get_option_names","extension_get_option_value","extension_get_options","extension_get_version","external_call","external_define","external_free","file_attributes","file_bin_close","file_bin_open","file_bin_position","file_bin_read_byte","file_bin_rewrite","file_bin_seek","file_bin_size","file_bin_write_byte","file_copy","file_delete","file_exists","file_find_close","file_find_first","file_find_next","file_rename","file_text_close","file_text_eof","file_text_eoln","file_text_open_append","file_text_open_from_string","file_text_open_read","file_text_open_write","file_text_read_real","file_text_read_string","file_text_readln","file_text_write_real","file_text_write_string","file_text_writeln","filename_change_ext","filename_dir","filename_drive","filename_ext","filename_name","filename_path","floor","font_add","font_add_enable_aa","font_add_get_enable_aa","font_add_sprite","font_add_sprite_ext","font_cache_glyph","font_delete","font_enable_effects","font_enable_sdf","font_exists","font_get_bold","font_get_first","font_get_fontname","font_get_info","font_get_italic","font_get_last","font_get_name","font_get_sdf_enabled","font_get_sdf_spread","font_get_size","font_get_texture","font_get_uvs","font_replace_sprite","font_replace_sprite_ext","font_sdf_spread","font_set_cache_size","frac","fx_create","fx_get_name","fx_get_parameter","fx_get_parameter_names","fx_get_parameters","fx_get_single_layer","fx_set_parameter","fx_set_parameters","fx_set_single_layer","game_change","game_end","game_get_speed","game_load","game_load_buffer","game_restart","game_save","game_save_buffer","game_set_speed","gamepad_axis_count","gamepad_axis_value","gamepad_button_check","gamepad_button_check_pressed","gamepad_button_check_released","gamepad_button_count","gamepad_button_value","gamepad_get_axis_deadzone","gamepad_get_button_threshold","gamepad_get_description","gamepad_get_device_count","gamepad_get_guid","gamepad_get_mapping","gamepad_get_option","gamepad_hat_count","gamepad_hat_value","gamepad_is_connected","gamepad_is_supported","gamepad_remove_mapping","gamepad_set_axis_deadzone","gamepad_set_button_threshold","gamepad_set_color","gamepad_set_colour","gamepad_set_option","gamepad_set_vibration","gamepad_test_mapping","gc_collect","gc_enable","gc_get_stats","gc_get_target_frame_time","gc_is_enabled","gc_target_frame_time","gesture_double_tap_distance","gesture_double_tap_time","gesture_drag_distance","gesture_drag_time","gesture_flick_speed","gesture_get_double_tap_distance","gesture_get_double_tap_time","gesture_get_drag_distance","gesture_get_drag_time","gesture_get_flick_speed","gesture_get_pinch_angle_away","gesture_get_pinch_angle_towards","gesture_get_pinch_distance","gesture_get_rotate_angle","gesture_get_rotate_time","gesture_get_tap_count","gesture_pinch_angle_away","gesture_pinch_angle_towards","gesture_pinch_distance","gesture_rotate_angle","gesture_rotate_time","gesture_tap_count","get_integer","get_integer_async","get_login_async","get_open_filename","get_open_filename_ext","get_save_filename","get_save_filename_ext","get_string","get_string_async","get_timer","gif_add_surface","gif_open","gif_save","gif_save_buffer","gml_pragma","gml_release_mode","gpu_get_alphatestenable","gpu_get_alphatestref","gpu_get_blendenable","gpu_get_blendmode","gpu_get_blendmode_dest","gpu_get_blendmode_destalpha","gpu_get_blendmode_ext","gpu_get_blendmode_ext_sepalpha","gpu_get_blendmode_src","gpu_get_blendmode_srcalpha","gpu_get_colorwriteenable","gpu_get_colourwriteenable","gpu_get_cullmode","gpu_get_depth","gpu_get_fog","gpu_get_state","gpu_get_tex_filter","gpu_get_tex_filter_ext","gpu_get_tex_max_aniso","gpu_get_tex_max_aniso_ext","gpu_get_tex_max_mip","gpu_get_tex_max_mip_ext","gpu_get_tex_min_mip","gpu_get_tex_min_mip_ext","gpu_get_tex_mip_bias","gpu_get_tex_mip_bias_ext","gpu_get_tex_mip_enable","gpu_get_tex_mip_enable_ext","gpu_get_tex_mip_filter","gpu_get_tex_mip_filter_ext","gpu_get_tex_repeat","gpu_get_tex_repeat_ext","gpu_get_texfilter","gpu_get_texfilter_ext","gpu_get_texrepeat","gpu_get_texrepeat_ext","gpu_get_zfunc","gpu_get_ztestenable","gpu_get_zwriteenable","gpu_pop_state","gpu_push_state","gpu_set_alphatestenable","gpu_set_alphatestref","gpu_set_blendenable","gpu_set_blendmode","gpu_set_blendmode_ext","gpu_set_blendmode_ext_sepalpha","gpu_set_colorwriteenable","gpu_set_colourwriteenable","gpu_set_cullmode","gpu_set_depth","gpu_set_fog","gpu_set_state","gpu_set_tex_filter","gpu_set_tex_filter_ext","gpu_set_tex_max_aniso","gpu_set_tex_max_aniso_ext","gpu_set_tex_max_mip","gpu_set_tex_max_mip_ext","gpu_set_tex_min_mip","gpu_set_tex_min_mip_ext","gpu_set_tex_mip_bias","gpu_set_tex_mip_bias_ext","gpu_set_tex_mip_enable","gpu_set_tex_mip_enable_ext","gpu_set_tex_mip_filter","gpu_set_tex_mip_filter_ext","gpu_set_tex_repeat","gpu_set_tex_repeat_ext","gpu_set_texfilter","gpu_set_texfilter_ext","gpu_set_texrepeat","gpu_set_texrepeat_ext","gpu_set_zfunc","gpu_set_ztestenable","gpu_set_zwriteenable","handle_parse","highscore_add","highscore_clear","highscore_name","highscore_value","http_get","http_get_file","http_get_request_crossorigin","http_post_string","http_request","http_set_request_crossorigin","iap_acquire","iap_activate","iap_consume","iap_enumerate_products","iap_product_details","iap_purchase_details","iap_restore_all","iap_status","ini_close","ini_key_delete","ini_key_exists","ini_open","ini_open_from_string","ini_read_real","ini_read_string","ini_section_delete","ini_section_exists","ini_write_real","ini_write_string","instance_activate_all","instance_activate_layer","instance_activate_object","instance_activate_region","instance_change","instance_copy","instance_create_depth","instance_create_layer","instance_deactivate_all","instance_deactivate_layer","instance_deactivate_object","instance_deactivate_region","instance_destroy","instance_exists","instance_find","instance_furthest","instance_id_get","instance_nearest","instance_number","instance_place","instance_place_list","instance_position","instance_position_list","instanceof","int64","io_clear","irandom","irandom_range","is_array","is_bool","is_callable","is_debug_overlay_open","is_handle","is_infinity","is_instanceof","is_int32","is_int64","is_keyboard_used_debug_overlay","is_method","is_mouse_over_debug_overlay","is_nan","is_numeric","is_ptr","is_real","is_string","is_struct","is_undefined","json_decode","json_encode","json_parse","json_stringify","keyboard_check","keyboard_check_direct","keyboard_check_pressed","keyboard_check_released","keyboard_clear","keyboard_get_map","keyboard_get_numlock","keyboard_key_press","keyboard_key_release","keyboard_set_map","keyboard_set_numlock","keyboard_unset_map","keyboard_virtual_height","keyboard_virtual_hide","keyboard_virtual_show","keyboard_virtual_status","layer_add_instance","layer_background_alpha","layer_background_blend","layer_background_change","layer_background_create","layer_background_destroy","layer_background_exists","layer_background_get_alpha","layer_background_get_blend","layer_background_get_htiled","layer_background_get_id","layer_background_get_index","layer_background_get_speed","layer_background_get_sprite","layer_background_get_stretch","layer_background_get_visible","layer_background_get_vtiled","layer_background_get_xscale","layer_background_get_yscale","layer_background_htiled","layer_background_index","layer_background_speed","layer_background_sprite","layer_background_stretch","layer_background_visible","layer_background_vtiled","layer_background_xscale","layer_background_yscale","layer_clear_fx","layer_create","layer_depth","layer_destroy","layer_destroy_instances","layer_element_move","layer_enable_fx","layer_exists","layer_force_draw_depth","layer_fx_is_enabled","layer_get_all","layer_get_all_elements","layer_get_depth","layer_get_element_layer","layer_get_element_type","layer_get_forced_depth","layer_get_fx","layer_get_hspeed","layer_get_id","layer_get_id_at_depth","layer_get_name","layer_get_script_begin","layer_get_script_end","layer_get_shader","layer_get_target_room","layer_get_visible","layer_get_vspeed","layer_get_x","layer_get_y","layer_has_instance","layer_hspeed","layer_instance_get_instance","layer_is_draw_depth_forced","layer_reset_target_room","layer_script_begin","layer_script_end","layer_sequence_angle","layer_sequence_create","layer_sequence_destroy","layer_sequence_exists","layer_sequence_get_angle","layer_sequence_get_headdir","layer_sequence_get_headpos","layer_sequence_get_instance","layer_sequence_get_length","layer_sequence_get_sequence","layer_sequence_get_speedscale","layer_sequence_get_x","layer_sequence_get_xscale","layer_sequence_get_y","layer_sequence_get_yscale","layer_sequence_headdir","layer_sequence_headpos","layer_sequence_is_finished","layer_sequence_is_paused","layer_sequence_pause","layer_sequence_play","layer_sequence_speedscale","layer_sequence_x","layer_sequence_xscale","layer_sequence_y","layer_sequence_yscale","layer_set_fx","layer_set_target_room","layer_set_visible","layer_shader","layer_sprite_alpha","layer_sprite_angle","layer_sprite_blend","layer_sprite_change","layer_sprite_create","layer_sprite_destroy","layer_sprite_exists","layer_sprite_get_alpha","layer_sprite_get_angle","layer_sprite_get_blend","layer_sprite_get_id","layer_sprite_get_index","layer_sprite_get_speed","layer_sprite_get_sprite","layer_sprite_get_x","layer_sprite_get_xscale","layer_sprite_get_y","layer_sprite_get_yscale","layer_sprite_index","layer_sprite_speed","layer_sprite_x","layer_sprite_xscale","layer_sprite_y","layer_sprite_yscale","layer_tile_alpha","layer_tile_blend","layer_tile_change","layer_tile_create","layer_tile_destroy","layer_tile_exists","layer_tile_get_alpha","layer_tile_get_blend","layer_tile_get_region","layer_tile_get_sprite","layer_tile_get_visible","layer_tile_get_x","layer_tile_get_xscale","layer_tile_get_y","layer_tile_get_yscale","layer_tile_region","layer_tile_visible","layer_tile_x","layer_tile_xscale","layer_tile_y","layer_tile_yscale","layer_tilemap_create","layer_tilemap_destroy","layer_tilemap_exists","layer_tilemap_get_id","layer_vspeed","layer_x","layer_y","lengthdir_x","lengthdir_y","lerp","lin_to_db","ln","load_csv","log10","log2","logn","make_color_hsv","make_color_rgb","make_colour_hsv","make_colour_rgb","math_get_epsilon","math_set_epsilon","matrix_build","matrix_build_identity","matrix_build_lookat","matrix_build_projection_ortho","matrix_build_projection_perspective","matrix_build_projection_perspective_fov","matrix_get","matrix_multiply","matrix_set","matrix_stack_clear","matrix_stack_is_empty","matrix_stack_pop","matrix_stack_push","matrix_stack_set","matrix_stack_top","matrix_transform_vertex","max","md5_file","md5_string_unicode","md5_string_utf8","mean","median","merge_color","merge_colour","method","method_call","method_get_index","method_get_self","min","motion_add","motion_set","mouse_check_button","mouse_check_button_pressed","mouse_check_button_released","mouse_clear","mouse_wheel_down","mouse_wheel_up","move_and_collide","move_bounce_all","move_bounce_solid","move_contact_all","move_contact_solid","move_outside_all","move_outside_solid","move_random","move_snap","move_towards_point","move_wrap","mp_grid_add_cell","mp_grid_add_instances","mp_grid_add_rectangle","mp_grid_clear_all","mp_grid_clear_cell","mp_grid_clear_rectangle","mp_grid_create","mp_grid_destroy","mp_grid_draw","mp_grid_get_cell","mp_grid_path","mp_grid_to_ds_grid","mp_linear_path","mp_linear_path_object","mp_linear_step","mp_linear_step_object","mp_potential_path","mp_potential_path_object","mp_potential_settings","mp_potential_step","mp_potential_step_object","nameof","network_connect","network_connect_async","network_connect_raw","network_connect_raw_async","network_create_server","network_create_server_raw","network_create_socket","network_create_socket_ext","network_destroy","network_resolve","network_send_broadcast","network_send_packet","network_send_raw","network_send_udp","network_send_udp_raw","network_set_config","network_set_timeout","object_exists","object_get_mask","object_get_name","object_get_parent","object_get_persistent","object_get_physics","object_get_solid","object_get_sprite","object_get_visible","object_is_ancestor","object_set_mask","object_set_persistent","object_set_solid","object_set_sprite","object_set_visible","ord","os_check_permission","os_get_config","os_get_info","os_get_language","os_get_region","os_is_network_connected","os_is_paused","os_lock_orientation","os_powersave_enable","os_request_permission","os_set_orientation_lock","parameter_count","parameter_string","part_emitter_burst","part_emitter_clear","part_emitter_create","part_emitter_delay","part_emitter_destroy","part_emitter_destroy_all","part_emitter_enable","part_emitter_exists","part_emitter_interval","part_emitter_region","part_emitter_relative","part_emitter_stream","part_particles_burst","part_particles_clear","part_particles_count","part_particles_create","part_particles_create_color","part_particles_create_colour","part_system_angle","part_system_automatic_draw","part_system_automatic_update","part_system_clear","part_system_color","part_system_colour","part_system_create","part_system_create_layer","part_system_depth","part_system_destroy","part_system_draw_order","part_system_drawit","part_system_exists","part_system_get_info","part_system_get_layer","part_system_global_space","part_system_layer","part_system_position","part_system_update","part_type_alpha1","part_type_alpha2","part_type_alpha3","part_type_blend","part_type_clear","part_type_color1","part_type_color2","part_type_color3","part_type_color_hsv","part_type_color_mix","part_type_color_rgb","part_type_colour1","part_type_colour2","part_type_colour3","part_type_colour_hsv","part_type_colour_mix","part_type_colour_rgb","part_type_create","part_type_death","part_type_destroy","part_type_direction","part_type_exists","part_type_gravity","part_type_life","part_type_orientation","part_type_scale","part_type_shape","part_type_size","part_type_size_x","part_type_size_y","part_type_speed","part_type_sprite","part_type_step","part_type_subimage","particle_exists","particle_get_info","path_add","path_add_point","path_append","path_assign","path_change_point","path_clear_points","path_delete","path_delete_point","path_duplicate","path_end","path_exists","path_flip","path_get_closed","path_get_kind","path_get_length","path_get_name","path_get_number","path_get_point_speed","path_get_point_x","path_get_point_y","path_get_precision","path_get_speed","path_get_x","path_get_y","path_insert_point","path_mirror","path_rescale","path_reverse","path_rotate","path_set_closed","path_set_kind","path_set_precision","path_shift","path_start","physics_apply_angular_impulse","physics_apply_force","physics_apply_impulse","physics_apply_local_force","physics_apply_local_impulse","physics_apply_torque","physics_draw_debug","physics_fixture_add_point","physics_fixture_bind","physics_fixture_bind_ext","physics_fixture_create","physics_fixture_delete","physics_fixture_set_angular_damping","physics_fixture_set_awake","physics_fixture_set_box_shape","physics_fixture_set_chain_shape","physics_fixture_set_circle_shape","physics_fixture_set_collision_group","physics_fixture_set_density","physics_fixture_set_edge_shape","physics_fixture_set_friction","physics_fixture_set_kinematic","physics_fixture_set_linear_damping","physics_fixture_set_polygon_shape","physics_fixture_set_restitution","physics_fixture_set_sensor","physics_get_density","physics_get_friction","physics_get_restitution","physics_joint_delete","physics_joint_distance_create","physics_joint_enable_motor","physics_joint_friction_create","physics_joint_gear_create","physics_joint_get_value","physics_joint_prismatic_create","physics_joint_pulley_create","physics_joint_revolute_create","physics_joint_rope_create","physics_joint_set_value","physics_joint_weld_create","physics_joint_wheel_create","physics_mass_properties","physics_particle_count","physics_particle_create","physics_particle_delete","physics_particle_delete_region_box","physics_particle_delete_region_circle","physics_particle_delete_region_poly","physics_particle_draw","physics_particle_draw_ext","physics_particle_get_damping","physics_particle_get_data","physics_particle_get_data_particle","physics_particle_get_density","physics_particle_get_gravity_scale","physics_particle_get_group_flags","physics_particle_get_max_count","physics_particle_get_radius","physics_particle_group_add_point","physics_particle_group_begin","physics_particle_group_box","physics_particle_group_circle","physics_particle_group_count","physics_particle_group_delete","physics_particle_group_end","physics_particle_group_get_ang_vel","physics_particle_group_get_angle","physics_particle_group_get_centre_x","physics_particle_group_get_centre_y","physics_particle_group_get_data","physics_particle_group_get_inertia","physics_particle_group_get_mass","physics_particle_group_get_vel_x","physics_particle_group_get_vel_y","physics_particle_group_get_x","physics_particle_group_get_y","physics_particle_group_join","physics_particle_group_polygon","physics_particle_set_category_flags","physics_particle_set_damping","physics_particle_set_density","physics_particle_set_flags","physics_particle_set_gravity_scale","physics_particle_set_group_flags","physics_particle_set_max_count","physics_particle_set_radius","physics_pause_enable","physics_remove_fixture","physics_set_density","physics_set_friction","physics_set_restitution","physics_test_overlap","physics_world_create","physics_world_draw_debug","physics_world_gravity","physics_world_update_iterations","physics_world_update_speed","place_empty","place_free","place_meeting","place_snapped","point_direction","point_distance","point_distance_3d","point_in_circle","point_in_rectangle","point_in_triangle","position_change","position_destroy","position_empty","position_meeting","power","ptr","radtodeg","random","random_get_seed","random_range","random_set_seed","randomise","randomize","real","rectangle_in_circle","rectangle_in_rectangle","rectangle_in_triangle","ref_create","rollback_chat","rollback_create_game","rollback_define_extra_network_latency","rollback_define_input","rollback_define_input_frame_delay","rollback_define_mock_input","rollback_define_player","rollback_display_events","rollback_get_info","rollback_get_input","rollback_get_player_prefs","rollback_join_game","rollback_leave_game","rollback_set_player_prefs","rollback_start_game","rollback_sync_on_frame","rollback_use_late_join","rollback_use_manual_start","rollback_use_player_prefs","rollback_use_random_input","room_add","room_assign","room_duplicate","room_exists","room_get_camera","room_get_info","room_get_name","room_get_viewport","room_goto","room_goto_next","room_goto_previous","room_instance_add","room_instance_clear","room_next","room_previous","room_restart","room_set_camera","room_set_height","room_set_persistent","room_set_view_enabled","room_set_viewport","room_set_width","round","scheduler_resolution_get","scheduler_resolution_set","screen_save","screen_save_part","script_execute","script_execute_ext","script_exists","script_get_name","sequence_create","sequence_destroy","sequence_exists","sequence_get","sequence_get_objects","sequence_instance_override_object","sequence_keyframe_new","sequence_keyframedata_new","sequence_track_new","sha1_file","sha1_string_unicode","sha1_string_utf8","shader_current","shader_enable_corner_id","shader_get_name","shader_get_sampler_index","shader_get_uniform","shader_is_compiled","shader_reset","shader_set","shader_set_uniform_f","shader_set_uniform_f_array","shader_set_uniform_f_buffer","shader_set_uniform_i","shader_set_uniform_i_array","shader_set_uniform_matrix","shader_set_uniform_matrix_array","shaders_are_supported","shop_leave_rating","show_debug_message","show_debug_message_ext","show_debug_overlay","show_error","show_message","show_message_async","show_question","show_question_async","sign","sin","skeleton_animation_clear","skeleton_animation_get","skeleton_animation_get_duration","skeleton_animation_get_event_frames","skeleton_animation_get_ext","skeleton_animation_get_frame","skeleton_animation_get_frames","skeleton_animation_get_position","skeleton_animation_is_finished","skeleton_animation_is_looping","skeleton_animation_list","skeleton_animation_mix","skeleton_animation_set","skeleton_animation_set_ext","skeleton_animation_set_frame","skeleton_animation_set_position","skeleton_attachment_create","skeleton_attachment_create_color","skeleton_attachment_create_colour","skeleton_attachment_destroy","skeleton_attachment_exists","skeleton_attachment_get","skeleton_attachment_replace","skeleton_attachment_replace_color","skeleton_attachment_replace_colour","skeleton_attachment_set","skeleton_bone_data_get","skeleton_bone_data_set","skeleton_bone_list","skeleton_bone_state_get","skeleton_bone_state_set","skeleton_collision_draw_set","skeleton_find_slot","skeleton_get_bounds","skeleton_get_minmax","skeleton_get_num_bounds","skeleton_skin_create","skeleton_skin_get","skeleton_skin_list","skeleton_skin_set","skeleton_slot_alpha_get","skeleton_slot_color_get","skeleton_slot_color_set","skeleton_slot_colour_get","skeleton_slot_colour_set","skeleton_slot_data","skeleton_slot_data_instance","skeleton_slot_list","sprite_add","sprite_add_ext","sprite_add_from_surface","sprite_assign","sprite_collision_mask","sprite_create_from_surface","sprite_delete","sprite_duplicate","sprite_exists","sprite_flush","sprite_flush_multi","sprite_get_bbox_bottom","sprite_get_bbox_left","sprite_get_bbox_mode","sprite_get_bbox_right","sprite_get_bbox_top","sprite_get_height","sprite_get_info","sprite_get_name","sprite_get_nineslice","sprite_get_number","sprite_get_speed","sprite_get_speed_type","sprite_get_texture","sprite_get_tpe","sprite_get_uvs","sprite_get_width","sprite_get_xoffset","sprite_get_yoffset","sprite_merge","sprite_nineslice_create","sprite_prefetch","sprite_prefetch_multi","sprite_replace","sprite_save","sprite_save_strip","sprite_set_alpha_from_sprite","sprite_set_bbox","sprite_set_bbox_mode","sprite_set_cache_size","sprite_set_cache_size_ext","sprite_set_nineslice","sprite_set_offset","sprite_set_speed","sqr","sqrt","static_get","static_set","string","string_byte_at","string_byte_length","string_char_at","string_concat","string_concat_ext","string_copy","string_count","string_delete","string_digits","string_ends_with","string_ext","string_foreach","string_format","string_hash_to_newline","string_height","string_height_ext","string_insert","string_join","string_join_ext","string_last_pos","string_last_pos_ext","string_length","string_letters","string_lettersdigits","string_lower","string_ord_at","string_pos","string_pos_ext","string_repeat","string_replace","string_replace_all","string_set_byte_at","string_split","string_split_ext","string_starts_with","string_trim","string_trim_end","string_trim_start","string_upper","string_width","string_width_ext","struct_exists","struct_foreach","struct_get","struct_get_from_hash","struct_get_names","struct_names_count","struct_remove","struct_set","struct_set_from_hash","surface_copy","surface_copy_part","surface_create","surface_create_ext","surface_depth_disable","surface_exists","surface_format_is_supported","surface_free","surface_get_depth_disable","surface_get_format","surface_get_height","surface_get_target","surface_get_target_ext","surface_get_texture","surface_get_width","surface_getpixel","surface_getpixel_ext","surface_reset_target","surface_resize","surface_save","surface_save_part","surface_set_target","surface_set_target_ext","tag_get_asset_ids","tag_get_assets","tan","texture_debug_messages","texture_flush","texture_get_height","texture_get_texel_height","texture_get_texel_width","texture_get_uvs","texture_get_width","texture_global_scale","texture_is_ready","texture_prefetch","texture_set_stage","texturegroup_get_fonts","texturegroup_get_names","texturegroup_get_sprites","texturegroup_get_status","texturegroup_get_textures","texturegroup_get_tilesets","texturegroup_load","texturegroup_set_mode","texturegroup_unload","tile_get_empty","tile_get_flip","tile_get_index","tile_get_mirror","tile_get_rotate","tile_set_empty","tile_set_flip","tile_set_index","tile_set_mirror","tile_set_rotate","tilemap_clear","tilemap_get","tilemap_get_at_pixel","tilemap_get_cell_x_at_pixel","tilemap_get_cell_y_at_pixel","tilemap_get_frame","tilemap_get_global_mask","tilemap_get_height","tilemap_get_mask","tilemap_get_tile_height","tilemap_get_tile_width","tilemap_get_tileset","tilemap_get_width","tilemap_get_x","tilemap_get_y","tilemap_set","tilemap_set_at_pixel","tilemap_set_global_mask","tilemap_set_height","tilemap_set_mask","tilemap_set_width","tilemap_tileset","tilemap_x","tilemap_y","tileset_get_info","tileset_get_name","tileset_get_texture","tileset_get_uvs","time_bpm_to_seconds","time_seconds_to_bpm","time_source_create","time_source_destroy","time_source_exists","time_source_get_children","time_source_get_parent","time_source_get_period","time_source_get_reps_completed","time_source_get_reps_remaining","time_source_get_state","time_source_get_time_remaining","time_source_get_units","time_source_pause","time_source_reconfigure","time_source_reset","time_source_resume","time_source_start","time_source_stop","timeline_add","timeline_clear","timeline_delete","timeline_exists","timeline_get_name","timeline_max_moment","timeline_moment_add_script","timeline_moment_clear","timeline_size","typeof","url_get_domain","url_open","url_open_ext","url_open_full","uwp_device_touchscreen_available","uwp_livetile_badge_clear","uwp_livetile_badge_notification","uwp_livetile_notification_begin","uwp_livetile_notification_end","uwp_livetile_notification_expiry","uwp_livetile_notification_image_add","uwp_livetile_notification_secondary_begin","uwp_livetile_notification_tag","uwp_livetile_notification_template_add","uwp_livetile_notification_text_add","uwp_livetile_queue_enable","uwp_livetile_tile_clear","uwp_secondarytile_badge_clear","uwp_secondarytile_badge_notification","uwp_secondarytile_delete","uwp_secondarytile_pin","uwp_secondarytile_tile_clear","variable_clone","variable_get_hash","variable_global_exists","variable_global_get","variable_global_set","variable_instance_exists","variable_instance_get","variable_instance_get_names","variable_instance_names_count","variable_instance_set","variable_struct_exists","variable_struct_get","variable_struct_get_names","variable_struct_names_count","variable_struct_remove","variable_struct_set","vertex_argb","vertex_begin","vertex_color","vertex_colour","vertex_create_buffer","vertex_create_buffer_ext","vertex_create_buffer_from_buffer","vertex_create_buffer_from_buffer_ext","vertex_delete_buffer","vertex_end","vertex_float1","vertex_float2","vertex_float3","vertex_float4","vertex_format_add_color","vertex_format_add_colour","vertex_format_add_custom","vertex_format_add_normal","vertex_format_add_position","vertex_format_add_position_3d","vertex_format_add_texcoord","vertex_format_begin","vertex_format_delete","vertex_format_end","vertex_format_get_info","vertex_freeze","vertex_get_buffer_size","vertex_get_number","vertex_normal","vertex_position","vertex_position_3d","vertex_submit","vertex_submit_ext","vertex_texcoord","vertex_ubyte4","vertex_update_buffer_from_buffer","vertex_update_buffer_from_vertex","video_close","video_draw","video_enable_loop","video_get_duration","video_get_format","video_get_position","video_get_status","video_get_volume","video_is_looping","video_open","video_pause","video_resume","video_seek_to","video_set_volume","view_get_camera","view_get_hport","view_get_surface_id","view_get_visible","view_get_wport","view_get_xport","view_get_yport","view_set_camera","view_set_hport","view_set_surface_id","view_set_visible","view_set_wport","view_set_xport","view_set_yport","virtual_key_add","virtual_key_delete","virtual_key_hide","virtual_key_show","wallpaper_set_config","wallpaper_set_subscriptions","weak_ref_alive","weak_ref_any_alive","weak_ref_create","window_center","window_device","window_enable_borderless_fullscreen","window_get_borderless_fullscreen","window_get_caption","window_get_color","window_get_colour","window_get_cursor","window_get_fullscreen","window_get_height","window_get_showborder","window_get_visible_rects","window_get_width","window_get_x","window_get_y","window_handle","window_has_focus","window_mouse_get_delta_x","window_mouse_get_delta_y","window_mouse_get_locked","window_mouse_get_x","window_mouse_get_y","window_mouse_set","window_mouse_set_locked","window_set_caption","window_set_color","window_set_colour","window_set_cursor","window_set_fullscreen","window_set_max_height","window_set_max_width","window_set_min_height","window_set_min_width","window_set_position","window_set_rectangle","window_set_showborder","window_set_size","window_view_mouse_get_x","window_view_mouse_get_y","window_views_mouse_get_x","window_views_mouse_get_y","winphone_tile_background_color","winphone_tile_background_colour","zip_add_file","zip_create","zip_save","zip_unzip","zip_unzip_async"],symbol:["AudioEffect","AudioEffectType","AudioLFOType","GM_build_date","GM_build_type","GM_is_sandboxed","GM_project_filename","GM_runtime_version","GM_version","NaN","_GMFILE_","_GMFUNCTION_","_GMLINE_","alignmentH","alignmentV","all","animcurvetype_bezier","animcurvetype_catmullrom","animcurvetype_linear","asset_animationcurve","asset_font","asset_object","asset_path","asset_room","asset_script","asset_sequence","asset_shader","asset_sound","asset_sprite","asset_tiles","asset_timeline","asset_unknown","audio_3D","audio_bus_main","audio_falloff_exponent_distance","audio_falloff_exponent_distance_clamped","audio_falloff_exponent_distance_scaled","audio_falloff_inverse_distance","audio_falloff_inverse_distance_clamped","audio_falloff_inverse_distance_scaled","audio_falloff_linear_distance","audio_falloff_linear_distance_clamped","audio_falloff_none","audio_mono","audio_stereo","bboxkind_diamond","bboxkind_ellipse","bboxkind_precise","bboxkind_rectangular","bboxmode_automatic","bboxmode_fullimage","bboxmode_manual","bm_add","bm_dest_alpha","bm_dest_color","bm_dest_colour","bm_inv_dest_alpha","bm_inv_dest_color","bm_inv_dest_colour","bm_inv_src_alpha","bm_inv_src_color","bm_inv_src_colour","bm_max","bm_normal","bm_one","bm_src_alpha","bm_src_alpha_sat","bm_src_color","bm_src_colour","bm_subtract","bm_zero","browser_chrome","browser_edge","browser_firefox","browser_ie","browser_ie_mobile","browser_not_a_browser","browser_opera","browser_safari","browser_safari_mobile","browser_tizen","browser_unknown","browser_windows_store","buffer_bool","buffer_f16","buffer_f32","buffer_f64","buffer_fast","buffer_fixed","buffer_grow","buffer_s16","buffer_s32","buffer_s8","buffer_seek_end","buffer_seek_relative","buffer_seek_start","buffer_string","buffer_text","buffer_u16","buffer_u32","buffer_u64","buffer_u8","buffer_vbuffer","buffer_wrap","c_aqua","c_black","c_blue","c_dkgray","c_dkgrey","c_fuchsia","c_gray","c_green","c_grey","c_lime","c_ltgray","c_ltgrey","c_maroon","c_navy","c_olive","c_orange","c_purple","c_red","c_silver","c_teal","c_white","c_yellow","cache_directory","characterSpacing","cmpfunc_always","cmpfunc_equal","cmpfunc_greater","cmpfunc_greaterequal","cmpfunc_less","cmpfunc_lessequal","cmpfunc_never","cmpfunc_notequal","coreColor","coreColour","cr_appstart","cr_arrow","cr_beam","cr_cross","cr_default","cr_drag","cr_handpoint","cr_hourglass","cr_none","cr_size_all","cr_size_nesw","cr_size_ns","cr_size_nwse","cr_size_we","cr_uparrow","cull_clockwise","cull_counterclockwise","cull_noculling","device_emulator","device_ios_ipad","device_ios_ipad_retina","device_ios_iphone","device_ios_iphone5","device_ios_iphone6","device_ios_iphone6plus","device_ios_iphone_retina","device_ios_unknown","device_tablet","display_landscape","display_landscape_flipped","display_portrait","display_portrait_flipped","dll_cdecl","dll_stdcall","dropShadowEnabled","dropShadowEnabled","ds_type_grid","ds_type_list","ds_type_map","ds_type_priority","ds_type_queue","ds_type_stack","ef_cloud","ef_ellipse","ef_explosion","ef_firework","ef_flare","ef_rain","ef_ring","ef_smoke","ef_smokeup","ef_snow","ef_spark","ef_star","effectsEnabled","effectsEnabled","ev_alarm","ev_animation_end","ev_animation_event","ev_animation_update","ev_async_audio_playback","ev_async_audio_playback_ended","ev_async_audio_recording","ev_async_dialog","ev_async_push_notification","ev_async_save_load","ev_async_save_load","ev_async_social","ev_async_system_event","ev_async_web","ev_async_web_cloud","ev_async_web_iap","ev_async_web_image_load","ev_async_web_networking","ev_async_web_steam","ev_audio_playback","ev_audio_playback_ended","ev_audio_recording","ev_boundary","ev_boundary_view0","ev_boundary_view1","ev_boundary_view2","ev_boundary_view3","ev_boundary_view4","ev_boundary_view5","ev_boundary_view6","ev_boundary_view7","ev_broadcast_message","ev_cleanup","ev_collision","ev_create","ev_destroy","ev_dialog_async","ev_draw","ev_draw_begin","ev_draw_end","ev_draw_normal","ev_draw_post","ev_draw_pre","ev_end_of_path","ev_game_end","ev_game_start","ev_gesture","ev_gesture_double_tap","ev_gesture_drag_end","ev_gesture_drag_start","ev_gesture_dragging","ev_gesture_flick","ev_gesture_pinch_end","ev_gesture_pinch_in","ev_gesture_pinch_out","ev_gesture_pinch_start","ev_gesture_rotate_end","ev_gesture_rotate_start","ev_gesture_rotating","ev_gesture_tap","ev_global_gesture_double_tap","ev_global_gesture_drag_end","ev_global_gesture_drag_start","ev_global_gesture_dragging","ev_global_gesture_flick","ev_global_gesture_pinch_end","ev_global_gesture_pinch_in","ev_global_gesture_pinch_out","ev_global_gesture_pinch_start","ev_global_gesture_rotate_end","ev_global_gesture_rotate_start","ev_global_gesture_rotating","ev_global_gesture_tap","ev_global_left_button","ev_global_left_press","ev_global_left_release","ev_global_middle_button","ev_global_middle_press","ev_global_middle_release","ev_global_right_button","ev_global_right_press","ev_global_right_release","ev_gui","ev_gui_begin","ev_gui_end","ev_joystick1_button1","ev_joystick1_button2","ev_joystick1_button3","ev_joystick1_button4","ev_joystick1_button5","ev_joystick1_button6","ev_joystick1_button7","ev_joystick1_button8","ev_joystick1_down","ev_joystick1_left","ev_joystick1_right","ev_joystick1_up","ev_joystick2_button1","ev_joystick2_button2","ev_joystick2_button3","ev_joystick2_button4","ev_joystick2_button5","ev_joystick2_button6","ev_joystick2_button7","ev_joystick2_button8","ev_joystick2_down","ev_joystick2_left","ev_joystick2_right","ev_joystick2_up","ev_keyboard","ev_keypress","ev_keyrelease","ev_left_button","ev_left_press","ev_left_release","ev_middle_button","ev_middle_press","ev_middle_release","ev_mouse","ev_mouse_enter","ev_mouse_leave","ev_mouse_wheel_down","ev_mouse_wheel_up","ev_no_button","ev_no_more_health","ev_no_more_lives","ev_other","ev_outside","ev_outside_view0","ev_outside_view1","ev_outside_view2","ev_outside_view3","ev_outside_view4","ev_outside_view5","ev_outside_view6","ev_outside_view7","ev_pre_create","ev_push_notification","ev_right_button","ev_right_press","ev_right_release","ev_room_end","ev_room_start","ev_social","ev_step","ev_step_begin","ev_step_end","ev_step_normal","ev_system_event","ev_trigger","ev_user0","ev_user1","ev_user10","ev_user11","ev_user12","ev_user13","ev_user14","ev_user15","ev_user2","ev_user3","ev_user4","ev_user5","ev_user6","ev_user7","ev_user8","ev_user9","ev_web_async","ev_web_cloud","ev_web_iap","ev_web_image_load","ev_web_networking","ev_web_sound_load","ev_web_steam","fa_archive","fa_bottom","fa_center","fa_directory","fa_hidden","fa_left","fa_middle","fa_none","fa_readonly","fa_right","fa_sysfile","fa_top","fa_volumeid","false","frameSizeX","frameSizeY","gamespeed_fps","gamespeed_microseconds","global","glowColor","glowColour","glowEnabled","glowEnabled","glowEnd","glowStart","gp_axis_acceleration_x","gp_axis_acceleration_y","gp_axis_acceleration_z","gp_axis_angular_velocity_x","gp_axis_angular_velocity_y","gp_axis_angular_velocity_z","gp_axis_orientation_w","gp_axis_orientation_x","gp_axis_orientation_y","gp_axis_orientation_z","gp_axislh","gp_axislv","gp_axisrh","gp_axisrv","gp_face1","gp_face2","gp_face3","gp_face4","gp_padd","gp_padl","gp_padr","gp_padu","gp_select","gp_shoulderl","gp_shoulderlb","gp_shoulderr","gp_shoulderrb","gp_start","gp_stickl","gp_stickr","iap_available","iap_canceled","iap_ev_consume","iap_ev_product","iap_ev_purchase","iap_ev_restore","iap_ev_storeload","iap_failed","iap_purchased","iap_refunded","iap_status_available","iap_status_loading","iap_status_processing","iap_status_restoring","iap_status_unavailable","iap_status_uninitialised","iap_storeload_failed","iap_storeload_ok","iap_unavailable","infinity","kbv_autocapitalize_characters","kbv_autocapitalize_none","kbv_autocapitalize_sentences","kbv_autocapitalize_words","kbv_returnkey_continue","kbv_returnkey_default","kbv_returnkey_done","kbv_returnkey_emergency","kbv_returnkey_go","kbv_returnkey_google","kbv_returnkey_join","kbv_returnkey_next","kbv_returnkey_route","kbv_returnkey_search","kbv_returnkey_send","kbv_returnkey_yahoo","kbv_type_ascii","kbv_type_default","kbv_type_email","kbv_type_numbers","kbv_type_phone","kbv_type_phone_name","kbv_type_url","layerelementtype_background","layerelementtype_instance","layerelementtype_oldtilemap","layerelementtype_particlesystem","layerelementtype_sequence","layerelementtype_sprite","layerelementtype_tile","layerelementtype_tilemap","layerelementtype_undefined","leaderboard_type_number","leaderboard_type_time_mins_secs","lighttype_dir","lighttype_point","lineSpacing","m_axisx","m_axisx_gui","m_axisy","m_axisy_gui","m_scroll_down","m_scroll_up","matrix_projection","matrix_view","matrix_world","mb_any","mb_left","mb_middle","mb_none","mb_right","mb_side1","mb_side2","mip_markedonly","mip_off","mip_on","network_config_avoid_time_wait","network_config_connect_timeout","network_config_disable_multicast","network_config_disable_reliable_udp","network_config_enable_multicast","network_config_enable_reliable_udp","network_config_use_non_blocking_socket","network_config_websocket_protocol","network_connect_active","network_connect_blocking","network_connect_nonblocking","network_connect_none","network_connect_passive","network_send_binary","network_send_text","network_socket_bluetooth","network_socket_tcp","network_socket_udp","network_socket_ws","network_socket_wss","network_type_connect","network_type_data","network_type_disconnect","network_type_down","network_type_non_blocking_connect","network_type_up","network_type_up_failed","nineslice_blank","nineslice_bottom","nineslice_center","nineslice_centre","nineslice_hide","nineslice_left","nineslice_mirror","nineslice_repeat","nineslice_right","nineslice_stretch","nineslice_top","noone","of_challenge_lose","of_challenge_tie","of_challenge_win","os_android","os_gdk","os_gxgames","os_ios","os_linux","os_macosx","os_operagx","os_permission_denied","os_permission_denied_dont_request","os_permission_granted","os_ps3","os_ps4","os_ps5","os_psvita","os_switch","os_tvos","os_unknown","os_uwp","os_win8native","os_windows","os_winphone","os_xboxone","os_xboxseriesxs","other","outlineColor","outlineColour","outlineDist","outlineEnabled","outlineEnabled","paragraphSpacing","path_action_continue","path_action_restart","path_action_reverse","path_action_stop","phy_debug_render_aabb","phy_debug_render_collision_pairs","phy_debug_render_coms","phy_debug_render_core_shapes","phy_debug_render_joints","phy_debug_render_obb","phy_debug_render_shapes","phy_joint_anchor_1_x","phy_joint_anchor_1_y","phy_joint_anchor_2_x","phy_joint_anchor_2_y","phy_joint_angle","phy_joint_angle_limits","phy_joint_damping_ratio","phy_joint_frequency","phy_joint_length_1","phy_joint_length_2","phy_joint_lower_angle_limit","phy_joint_max_force","phy_joint_max_length","phy_joint_max_motor_force","phy_joint_max_motor_torque","phy_joint_max_torque","phy_joint_motor_force","phy_joint_motor_speed","phy_joint_motor_torque","phy_joint_reaction_force_x","phy_joint_reaction_force_y","phy_joint_reaction_torque","phy_joint_speed","phy_joint_translation","phy_joint_upper_angle_limit","phy_particle_data_flag_category","phy_particle_data_flag_color","phy_particle_data_flag_colour","phy_particle_data_flag_position","phy_particle_data_flag_typeflags","phy_particle_data_flag_velocity","phy_particle_flag_colormixing","phy_particle_flag_colourmixing","phy_particle_flag_elastic","phy_particle_flag_powder","phy_particle_flag_spring","phy_particle_flag_tensile","phy_particle_flag_viscous","phy_particle_flag_wall","phy_particle_flag_water","phy_particle_flag_zombie","phy_particle_group_flag_rigid","phy_particle_group_flag_solid","pi","pointer_invalid","pointer_null","pr_linelist","pr_linestrip","pr_pointlist","pr_trianglefan","pr_trianglelist","pr_trianglestrip","ps_distr_gaussian","ps_distr_invgaussian","ps_distr_linear","ps_mode_burst","ps_mode_stream","ps_shape_diamond","ps_shape_ellipse","ps_shape_line","ps_shape_rectangle","pt_shape_circle","pt_shape_cloud","pt_shape_disk","pt_shape_explosion","pt_shape_flare","pt_shape_line","pt_shape_pixel","pt_shape_ring","pt_shape_smoke","pt_shape_snow","pt_shape_spark","pt_shape_sphere","pt_shape_square","pt_shape_star","rollback_chat_message","rollback_connect_error","rollback_connect_info","rollback_connected_to_peer","rollback_connection_rejected","rollback_disconnected_from_peer","rollback_end_game","rollback_game_full","rollback_game_info","rollback_game_interrupted","rollback_game_resumed","rollback_high_latency","rollback_player_prefs","rollback_protocol_rejected","rollback_synchronized_with_peer","rollback_synchronizing_with_peer","self","seqaudiokey_loop","seqaudiokey_oneshot","seqdir_left","seqdir_right","seqinterpolation_assign","seqinterpolation_lerp","seqplay_loop","seqplay_oneshot","seqplay_pingpong","seqtextkey_bottom","seqtextkey_center","seqtextkey_justify","seqtextkey_left","seqtextkey_middle","seqtextkey_right","seqtextkey_top","seqtracktype_audio","seqtracktype_bool","seqtracktype_clipmask","seqtracktype_clipmask_mask","seqtracktype_clipmask_subject","seqtracktype_color","seqtracktype_colour","seqtracktype_empty","seqtracktype_graphic","seqtracktype_group","seqtracktype_instance","seqtracktype_message","seqtracktype_moment","seqtracktype_particlesystem","seqtracktype_real","seqtracktype_sequence","seqtracktype_spriteframes","seqtracktype_string","seqtracktype_text","shadowColor","shadowColour","shadowOffsetX","shadowOffsetY","shadowSoftness","sprite_add_ext_error_cancelled","sprite_add_ext_error_decompressfailed","sprite_add_ext_error_loadfailed","sprite_add_ext_error_setupfailed","sprite_add_ext_error_spritenotfound","sprite_add_ext_error_unknown","spritespeed_framespergameframe","spritespeed_framespersecond","surface_r16float","surface_r32float","surface_r8unorm","surface_rg8unorm","surface_rgba16float","surface_rgba32float","surface_rgba4unorm","surface_rgba8unorm","texturegroup_status_fetched","texturegroup_status_loaded","texturegroup_status_loading","texturegroup_status_unloaded","tf_anisotropic","tf_linear","tf_point","thickness","tile_flip","tile_index_mask","tile_mirror","tile_rotate","time_source_expire_after","time_source_expire_nearest","time_source_game","time_source_global","time_source_state_active","time_source_state_initial","time_source_state_paused","time_source_state_stopped","time_source_units_frames","time_source_units_seconds","timezone_local","timezone_utc","tm_countvsyncs","tm_sleep","tm_systemtiming","true","ty_real","ty_string","undefined","vertex_type_color","vertex_type_colour","vertex_type_float1","vertex_type_float2","vertex_type_float3","vertex_type_float4","vertex_type_ubyte4","vertex_usage_binormal","vertex_usage_blendindices","vertex_usage_blendweight","vertex_usage_color","vertex_usage_colour","vertex_usage_depth","vertex_usage_fog","vertex_usage_normal","vertex_usage_position","vertex_usage_psize","vertex_usage_sample","vertex_usage_tangent","vertex_usage_texcoord","video_format_rgba","video_format_yuv","video_status_closed","video_status_paused","video_status_playing","video_status_preparing","vk_add","vk_alt","vk_anykey","vk_backspace","vk_control","vk_decimal","vk_delete","vk_divide","vk_down","vk_end","vk_enter","vk_escape","vk_f1","vk_f10","vk_f11","vk_f12","vk_f2","vk_f3","vk_f4","vk_f5","vk_f6","vk_f7","vk_f8","vk_f9","vk_home","vk_insert","vk_lalt","vk_lcontrol","vk_left","vk_lshift","vk_multiply","vk_nokey","vk_numpad0","vk_numpad1","vk_numpad2","vk_numpad3","vk_numpad4","vk_numpad5","vk_numpad6","vk_numpad7","vk_numpad8","vk_numpad9","vk_pagedown","vk_pageup","vk_pause","vk_printscreen","vk_ralt","vk_rcontrol","vk_return","vk_right","vk_rshift","vk_shift","vk_space","vk_subtract","vk_tab","vk_up","wallpaper_config","wallpaper_subscription_data","wrap"],"variable.language":["alarm","application_surface","argument","argument0","argument1","argument2","argument3","argument4","argument5","argument6","argument7","argument8","argument9","argument10","argument11","argument12","argument13","argument14","argument15","argument_count","async_load","background_color","background_colour","background_showcolor","background_showcolour","bbox_bottom","bbox_left","bbox_right","bbox_top","browser_height","browser_width","colour?ColourTrack","current_day","current_hour","current_minute","current_month","current_second","current_time","current_weekday","current_year","cursor_sprite","debug_mode","delta_time","depth","direction","display_aa","drawn_by_sequence","event_action","event_data","event_number","event_object","event_type","font_texture_page_size","fps","fps_real","friction","game_display_name","game_id","game_project_name","game_save_id","gravity","gravity_direction","health","hspeed","iap_data","id","image_alpha","image_angle","image_blend","image_index","image_number","image_speed","image_xscale","image_yscale","in_collision_tree","in_sequence","instance_count","instance_id","keyboard_key","keyboard_lastchar","keyboard_lastkey","keyboard_string","layer","lives","longMessage","managed","mask_index","message","mouse_button","mouse_lastbutton","mouse_x","mouse_y","object_index","os_browser","os_device","os_type","os_version","path_endaction","path_index","path_orientation","path_position","path_positionprevious","path_scale","path_speed","persistent","phy_active","phy_angular_damping","phy_angular_velocity","phy_bullet","phy_col_normal_x","phy_col_normal_y","phy_collision_points","phy_collision_x","phy_collision_y","phy_com_x","phy_com_y","phy_dynamic","phy_fixed_rotation","phy_inertia","phy_kinematic","phy_linear_damping","phy_linear_velocity_x","phy_linear_velocity_y","phy_mass","phy_position_x","phy_position_xprevious","phy_position_y","phy_position_yprevious","phy_rotation","phy_sleeping","phy_speed","phy_speed_x","phy_speed_y","player_avatar_sprite","player_avatar_url","player_id","player_local","player_type","player_user_id","program_directory","rollback_api_server","rollback_confirmed_frame","rollback_current_frame","rollback_event_id","rollback_event_param","rollback_game_running","room","room_first","room_height","room_last","room_persistent","room_speed","room_width","score","script","sequence_instance","solid","speed","sprite_height","sprite_index","sprite_width","sprite_xoffset","sprite_yoffset","stacktrace","temp_directory","timeline_index","timeline_loop","timeline_position","timeline_running","timeline_speed","view_camera","view_current","view_enabled","view_hport","view_surface_id","view_visible","view_wport","view_xport","view_yport","visible","vspeed","webgl_enabled","working_directory","x","xprevious","xstart","y","yprevious","ystart"]},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE]}}return zV=t,zV}var qV,Qve;function s5t(){if(Qve)return qV;Qve=1;function t(e){const s={keyword:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var"],type:["bool","byte","complex64","complex128","error","float32","float64","int8","int16","int32","int64","string","uint8","uint16","uint32","uint64","int","uint","uintptr","rune"],literal:["true","false","iota","nil"],built_in:["append","cap","close","complex","copy","imag","len","make","new","panic","print","println","real","recover","delete"]};return{name:"Go",aliases:["golang"],keywords:s,illegal:"",end:",\\s+",returnBegin:!0,endsWithParent:!0,contains:[{className:"attr",begin:":\\w+"},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{begin:"\\w+",relevance:0}]}]},{begin:"\\(\\s*",end:"\\s*\\)",excludeEnd:!0,contains:[{begin:"\\w+\\s*=",end:"\\s+",returnBegin:!0,endsWithParent:!0,contains:[{className:"attr",begin:"\\w+",relevance:0},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{begin:"\\w+",relevance:0}]}]}]},{begin:"^\\s*[=~]\\s*"},{begin:/#\{/,end:/\}/,subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0}]}}return KV=t,KV}var jV,nye;function h5t(){if(nye)return jV;nye=1;function t(e){const r=e.regex,n={$pattern:/[\w.\/]+/,built_in:["action","bindattr","collection","component","concat","debugger","each","each-in","get","hash","if","in","input","link-to","loc","log","lookup","mut","outlet","partial","query-params","render","template","textarea","unbound","unless","view","with","yield"]},i={$pattern:/[\w.\/]+/,literal:["true","false","undefined","null"]},a=/""|"[^"]+"/,s=/''|'[^']+'/,o=/\[\]|\[[^\]]+\]/,l=/[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/,u=/(\.|\/)/,d=r.either(a,s,o,l),h=r.concat(r.optional(/\.|\.\/|\//),d,r.anyNumberOfTimes(r.concat(u,d))),f=r.concat("(",o,"|",l,")(?==)"),p={begin:h},g=e.inherit(p,{keywords:i}),m={begin:/\(/,end:/\)/},_={className:"attr",begin:f,relevance:0,starts:{begin:/=/,end:/=/,starts:{contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,g,m]}}},v={begin:/as\s+\|/,keywords:{keyword:"as"},end:/\|/,contains:[{begin:/\w+/}]},b={contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,v,_,g,m],returnEnd:!0},y=e.inherit(p,{className:"name",keywords:n,starts:e.inherit(b,{end:/\)/})});m.contains=[y];const E=e.inherit(p,{keywords:n,className:"name",starts:e.inherit(b,{end:/\}\}/})}),T=e.inherit(p,{keywords:n,className:"name"}),C=e.inherit(p,{className:"name",keywords:n,starts:e.inherit(b,{end:/\}\}/})});return{name:"Handlebars",aliases:["hbs","html.hbs","html.handlebars","htmlbars"],case_insensitive:!0,subLanguage:"xml",contains:[{begin:/\\\{\{/,skip:!0},{begin:/\\\\(?=\{\{)/,skip:!0},e.COMMENT(/\{\{!--/,/--\}\}/),e.COMMENT(/\{\{!/,/\}\}/),{className:"template-tag",begin:/\{\{\{\{(?!\/)/,end:/\}\}\}\}/,contains:[E],starts:{end:/\{\{\{\{\//,returnEnd:!0,subLanguage:"xml"}},{className:"template-tag",begin:/\{\{\{\{\//,end:/\}\}\}\}/,contains:[T]},{className:"template-tag",begin:/\{\{#/,end:/\}\}/,contains:[E]},{className:"template-tag",begin:/\{\{(?=else\}\})/,end:/\}\}/,keywords:"else"},{className:"template-tag",begin:/\{\{(?=else if)/,end:/\}\}/,keywords:"else if"},{className:"template-tag",begin:/\{\{\//,end:/\}\}/,contains:[T]},{className:"template-variable",begin:/\{\{\{/,end:/\}\}\}/,contains:[C]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[C]}]}}return jV=t,jV}var XV,iye;function f5t(){if(iye)return XV;iye=1;function t(e){const r="([0-9]_*)+",n="([0-9a-fA-F]_*)+",i="([01]_*)+",a="([0-7]_*)+",u="([!#$%&*+.\\/<=>?@\\\\^~-]|(?!([(),;\\[\\]`|{}]|[_:\"']))(\\p{S}|\\p{P}))",d={variants:[e.COMMENT("--+","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},h={className:"meta",begin:/\{-#/,end:/#-\}/},f={className:"meta",begin:"^#",end:"$"},p={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},g={begin:"\\(",end:"\\)",illegal:'"',contains:[h,f,{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},e.inherit(e.TITLE_MODE,{begin:"[_a-z][\\w']*"}),d]},m={begin:/\{/,end:/\}/,contains:g.contains},_={className:"number",relevance:0,variants:[{match:`\\b(${r})(\\.(${r}))?([eE][+-]?(${r}))?\\b`},{match:`\\b0[xX]_*(${n})(\\.(${n}))?([pP][+-]?(${r}))?\\b`},{match:`\\b0[oO](${a})\\b`},{match:`\\b0[bB](${i})\\b`}]};return{name:"Haskell",aliases:["hs"],keywords:"let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",unicodeRegex:!0,contains:[{beginKeywords:"module",end:"where",keywords:"module where",contains:[g,d],illegal:"\\W\\.|;"},{begin:"\\bimport\\b",end:"$",keywords:"import qualified as hiding",contains:[g,d],illegal:"\\W\\.|;"},{className:"class",begin:"^(\\s*)?(class|instance)\\b",end:"where",keywords:"class family instance where",contains:[p,g,d]},{className:"class",begin:"\\b(data|(new)?type)\\b",end:"$",keywords:"data family type newtype deriving",contains:[h,p,g,m,d]},{beginKeywords:"default",end:"$",contains:[p,g,d]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,d]},{begin:"\\bforeign\\b",end:"$",keywords:"foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",contains:[p,e.QUOTE_STRING_MODE,d]},{className:"meta",begin:"#!\\/usr\\/bin\\/env runhaskell",end:"$"},h,f,{scope:"string",begin:/'(?=\\?.')/,end:/'/,contains:[{scope:"char.escape",match:/\\./}]},e.QUOTE_STRING_MODE,_,p,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),{begin:`(?!-)${u}--+|--+(?!-)${u}`},d,{begin:"->|<-"}]}}return XV=t,XV}var QV,aye;function p5t(){if(aye)return QV;aye=1;function t(e){const r="[a-zA-Z_$][a-zA-Z0-9_$]*",n=/(-?)(\b0[xX][a-fA-F0-9_]+|(\b\d+(\.[\d_]*)?|\.[\d_]+)(([eE][-+]?\d+)|i32|u32|i64|f64)?)/;return{name:"Haxe",aliases:["hx"],keywords:{keyword:"abstract break case cast catch continue default do dynamic else enum extern final for function here if import in inline is macro never new override package private get set public return static super switch this throw trace try typedef untyped using var while "+"Int Float String Bool Dynamic Void Array ",built_in:"trace this",literal:"true false null _"},contains:[{className:"string",begin:"'",end:"'",contains:[e.BACKSLASH_ESCAPE,{className:"subst",begin:/\$\{/,end:/\}/},{className:"subst",begin:/\$/,end:/\W\}/}]},e.QUOTE_STRING_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"number",begin:n,relevance:0},{className:"variable",begin:"\\$"+r},{className:"meta",begin:/@:?/,end:/\(|$/,excludeEnd:!0},{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elseif end error"}},{className:"type",begin:/:[ \t]*/,end:/[^A-Za-z0-9_ \t\->]/,excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:/:[ \t]*/,end:/\W/,excludeBegin:!0,excludeEnd:!0},{className:"type",beginKeywords:"new",end:/\W/,excludeBegin:!0,excludeEnd:!0},{className:"title.class",beginKeywords:"enum",end:/\{/,contains:[e.TITLE_MODE]},{className:"title.class",begin:"\\babstract\\b(?=\\s*"+e.IDENT_RE+"\\s*\\()",end:/[\{$]/,contains:[{className:"type",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0},{className:"type",begin:/from +/,end:/\W/,excludeBegin:!0,excludeEnd:!0},{className:"type",begin:/to +/,end:/\W/,excludeBegin:!0,excludeEnd:!0},e.TITLE_MODE],keywords:{keyword:"abstract from to"}},{className:"title.class",begin:/\b(class|interface) +/,end:/[\{$]/,excludeEnd:!0,keywords:"class interface",contains:[{className:"keyword",begin:/\b(extends|implements) +/,keywords:"extends implements",contains:[{className:"type",begin:e.IDENT_RE,relevance:0}]},e.TITLE_MODE]},{className:"title.function",beginKeywords:"function",end:/\(/,excludeEnd:!0,illegal:/\S/,contains:[e.TITLE_MODE]}],illegal:/<\//}}return QV=t,QV}var ZV,sye;function g5t(){if(sye)return ZV;sye=1;function t(e){return{name:"HSP",case_insensitive:!0,keywords:{$pattern:/[\w._]+/,keyword:"goto gosub return break repeat loop continue wait await dim sdim foreach dimtype dup dupptr end stop newmod delmod mref run exgoto on mcall assert logmes newlab resume yield onexit onerror onkey onclick oncmd exist delete mkdir chdir dirlist bload bsave bcopy memfile if else poke wpoke lpoke getstr chdpm memexpand memcpy memset notesel noteadd notedel noteload notesave randomize noteunsel noteget split strrep setease button chgdisp exec dialog mmload mmplay mmstop mci pset pget syscolor mes print title pos circle cls font sysfont objsize picload color palcolor palette redraw width gsel gcopy gzoom gmode bmpsave hsvcolor getkey listbox chkbox combox input mesbox buffer screen bgscr mouse objsel groll line clrobj boxf objprm objmode stick grect grotate gsquare gradf objimage objskip objenable celload celdiv celput newcom querycom delcom cnvstow comres axobj winobj sendmsg comevent comevarg sarrayconv callfunc cnvwtos comevdisp libptr system hspstat hspver stat cnt err strsize looplev sublev iparam wparam lparam refstr refdval int rnd strlen length length2 length3 length4 vartype gettime peek wpeek lpeek varptr varuse noteinfo instr abs limit getease str strmid strf getpath strtrim sin cos tan atan sqrt double absf expf logf limitf powf geteasef mousex mousey mousew hwnd hinstance hdc ginfo objinfo dirinfo sysinfo thismod __hspver__ __hsp30__ __date__ __time__ __line__ __file__ _debug __hspdef__ and or xor not screen_normal screen_palette screen_hide screen_fixedsize screen_tool screen_frame gmode_gdi gmode_mem gmode_rgb0 gmode_alpha gmode_rgb0alpha gmode_add gmode_sub gmode_pixela ginfo_mx ginfo_my ginfo_act ginfo_sel ginfo_wx1 ginfo_wy1 ginfo_wx2 ginfo_wy2 ginfo_vx ginfo_vy ginfo_sizex ginfo_sizey ginfo_winx ginfo_winy ginfo_mesx ginfo_mesy ginfo_r ginfo_g ginfo_b ginfo_paluse ginfo_dispx ginfo_dispy ginfo_cx ginfo_cy ginfo_intid ginfo_newid ginfo_sx ginfo_sy objinfo_mode objinfo_bmscr objinfo_hwnd notemax notesize dir_cur dir_exe dir_win dir_sys dir_cmdline dir_desktop dir_mydoc dir_tv font_normal font_bold font_italic font_underline font_strikeout font_antialias objmode_normal objmode_guifont objmode_usefont gsquare_grad msgothic msmincho do until while wend for next _break _continue switch case default swbreak swend ddim ldim alloc m_pi rad2deg deg2rad ease_linear ease_quad_in ease_quad_out ease_quad_inout ease_cubic_in ease_cubic_out ease_cubic_inout ease_quartic_in ease_quartic_out ease_quartic_inout ease_bounce_in ease_bounce_out ease_bounce_inout ease_shake_in ease_shake_out ease_shake_inout ease_loop"},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{className:"string",begin:/\{"/,end:/"\}/,contains:[e.BACKSLASH_ESCAPE]},e.COMMENT(";","$",{relevance:0}),{className:"meta",begin:"#",end:"$",keywords:{keyword:"addion cfunc cmd cmpopt comfunc const defcfunc deffunc define else endif enum epack func global if ifdef ifndef include modcfunc modfunc modinit modterm module pack packopt regcmd runtime undef usecom uselib"},contains:[e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),e.NUMBER_MODE,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"symbol",begin:"^\\*(\\w+|@)"},e.NUMBER_MODE,e.C_NUMBER_MODE]}}return ZV=t,ZV}var JV,oye;function m5t(){if(oye)return JV;oye=1;function t(e){const r=e.regex,n="HTTP/([32]|1\\.[01])",i=/[A-Za-z][A-Za-z0-9-]*/,a={className:"attribute",begin:r.concat("^",i,"(?=\\:\\s)"),starts:{contains:[{className:"punctuation",begin:/: /,relevance:0,starts:{end:"$",relevance:0}}]}},s=[a,{begin:"\\n\\n",starts:{subLanguage:[],endsWithParent:!0}}];return{name:"HTTP",aliases:["https"],illegal:/\S/,contains:[{begin:"^(?="+n+" \\d{3})",end:/$/,contains:[{className:"meta",begin:n},{className:"number",begin:"\\b\\d{3}\\b"}],starts:{end:/\b\B/,illegal:/\S/,contains:s}},{begin:"(?=^[A-Z]+ (.*?) "+n+"$)",end:/$/,contains:[{className:"string",begin:" ",end:" ",excludeBegin:!0,excludeEnd:!0},{className:"meta",begin:n},{className:"keyword",begin:"[A-Z]+"}],starts:{end:/\b\B/,illegal:/\S/,contains:s}},e.inherit(a,{relevance:0})]}}return JV=t,JV}var eY,lye;function _5t(){if(lye)return eY;lye=1;function t(e){const r="a-zA-Z_\\-!.?+*=<>&#'",n="["+r+"]["+r+"0-9/;:]*",i={$pattern:n,built_in:"!= % %= & &= * ** **= *= *map + += , --build-class-- --import-- -= . / // //= /= < << <<= <= = > >= >> >>= @ @= ^ ^= abs accumulate all and any ap-compose ap-dotimes ap-each ap-each-while ap-filter ap-first ap-if ap-last ap-map ap-map-when ap-pipe ap-reduce ap-reject apply as-> ascii assert assoc bin break butlast callable calling-module-name car case cdr chain chr coll? combinations compile compress cond cons cons? continue count curry cut cycle dec def default-method defclass defmacro defmacro-alias defmacro/g! defmain defmethod defmulti defn defn-alias defnc defnr defreader defseq del delattr delete-route dict-comp dir disassemble dispatch-reader-macro distinct divmod do doto drop drop-last drop-while empty? end-sequence eval eval-and-compile eval-when-compile even? every? except exec filter first flatten float? fn fnc fnr for for* format fraction genexpr gensym get getattr global globals group-by hasattr hash hex id identity if if* if-not if-python2 import in inc input instance? integer integer-char? integer? interleave interpose is is-coll is-cons is-empty is-even is-every is-float is-instance is-integer is-integer-char is-iterable is-iterator is-keyword is-neg is-none is-not is-numeric is-odd is-pos is-string is-symbol is-zero isinstance islice issubclass iter iterable? iterate iterator? keyword keyword? lambda last len let lif lif-not list* list-comp locals loop macro-error macroexpand macroexpand-1 macroexpand-all map max merge-with method-decorator min multi-decorator multicombinations name neg? next none? nonlocal not not-in not? nth numeric? oct odd? open or ord partition permutations pos? post-route postwalk pow prewalk print product profile/calls profile/cpu put-route quasiquote quote raise range read read-str recursive-replace reduce remove repeat repeatedly repr require rest round route route-with-methods rwm second seq set-comp setattr setv some sorted string string? sum switch symbol? take take-nth take-while tee try unless unquote unquote-splicing vars walk when while with with* with-decorator with-gensyms xi xor yield yield-from zero? zip zip-longest | |= ~"},a="[-+]?\\d+(\\.\\d+)?",s={begin:n,relevance:0},o={className:"number",begin:a,relevance:0},l=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),u=e.COMMENT(";","$",{relevance:0}),d={className:"literal",begin:/\b([Tt]rue|[Ff]alse|nil|None)\b/},h={begin:"[\\[\\{]",end:"[\\]\\}]",relevance:0},f={className:"comment",begin:"\\^"+n},p=e.COMMENT("\\^\\{","\\}"),g={className:"symbol",begin:"[:]{1,2}"+n},m={begin:"\\(",end:"\\)"},_={endsWithParent:!0,relevance:0},v={className:"name",relevance:0,keywords:i,begin:n,starts:_},b=[m,l,f,p,u,g,h,o,d,s];return m.contains=[e.COMMENT("comment",""),v,_],_.contains=b,h.contains=b,{name:"Hy",aliases:["hylang"],illegal:/\S/,contains:[e.SHEBANG(),m,l,f,p,u,g,h,o,d]}}return eY=t,eY}var tY,cye;function v5t(){if(cye)return tY;cye=1;function t(e){return{name:"Inform 7",aliases:["i7"],case_insensitive:!0,keywords:{keyword:"thing room person man woman animal container supporter backdrop door scenery open closed locked inside gender is are say understand kind of rule"},contains:[{className:"string",begin:'"',end:'"',relevance:0,contains:[{className:"subst",begin:"\\[",end:"\\]"}]},{className:"section",begin:/^(Volume|Book|Part|Chapter|Section|Table)\b/,end:"$"},{begin:/^(Check|Carry out|Report|Instead of|To|Rule|When|Before|After)\b/,end:":",contains:[{begin:"\\(This",end:"\\)"}]},{className:"comment",begin:"\\[",end:"\\]",contains:["self"]}]}}return tY=t,tY}var rY,uye;function y5t(){if(uye)return rY;uye=1;function t(e){const r=e.regex,n={className:"number",relevance:0,variants:[{begin:/([+-]+)?[\d]+_[\d_]+/},{begin:e.NUMBER_RE}]},i=e.COMMENT();i.variants=[{begin:/;/,end:/$/},{begin:/#/,end:/$/}];const a={className:"variable",variants:[{begin:/\$[\w\d"][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},s={className:"literal",begin:/\bon|off|true|false|yes|no\b/},o={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:"'''",end:"'''",relevance:10},{begin:'"""',end:'"""',relevance:10},{begin:'"',end:'"'},{begin:"'",end:"'"}]},l={begin:/\[/,end:/\]/,contains:[i,s,a,o,n,"self"],relevance:0},u=/[A-Za-z0-9_-]+/,d=/"(\\"|[^"])*"/,h=/'[^']*'/,f=r.either(u,d,h),p=r.concat(f,"(\\s*\\.\\s*",f,")*",r.lookahead(/\s*=\s*[^#\s]/));return{name:"TOML, also INI",aliases:["toml"],case_insensitive:!0,illegal:/\S/,contains:[i,{className:"section",begin:/\[+/,end:/\]+/},{begin:p,className:"attr",starts:{end:/$/,contains:[i,l,s,a,o,n]}}]}}return rY=t,rY}var nY,dye;function b5t(){if(dye)return nY;dye=1;function t(e){const r=e.regex,n={className:"params",begin:"\\(",end:"\\)"},i=/(_[a-z_\d]+)?/,a=/([de][+-]?\d+)?/,s={className:"number",variants:[{begin:r.concat(/\b\d+/,/\.(\d*)/,a,i)},{begin:r.concat(/\b\d+/,a,i)},{begin:r.concat(/\.\d+/,a,i)}],relevance:0};return{name:"IRPF90",case_insensitive:!0,keywords:{literal:".False. .True.",keyword:"kind do while private call intrinsic where elsewhere type endtype endmodule endselect endinterface end enddo endif if forall endforall only contains default return stop then public subroutine|10 function program .and. .or. .not. .le. .eq. .ge. .gt. .lt. goto save else use module select case access blank direct exist file fmt form formatted iostat name named nextrec number opened rec recl sequential status unformatted unit continue format pause cycle exit c_null_char c_alert c_backspace c_form_feed flush wait decimal round iomsg synchronous nopass non_overridable pass protected volatile abstract extends import non_intrinsic value deferred generic final enumerator class associate bind enum c_int c_short c_long c_long_long c_signed_char c_size_t c_int8_t c_int16_t c_int32_t c_int64_t c_int_least8_t c_int_least16_t c_int_least32_t c_int_least64_t c_int_fast8_t c_int_fast16_t c_int_fast32_t c_int_fast64_t c_intmax_t C_intptr_t c_float c_double c_long_double c_float_complex c_double_complex c_long_double_complex c_bool c_char c_null_ptr c_null_funptr c_new_line c_carriage_return c_horizontal_tab c_vertical_tab iso_c_binding c_loc c_funloc c_associated c_f_pointer c_ptr c_funptr iso_fortran_env character_storage_size error_unit file_storage_size input_unit iostat_end iostat_eor numeric_storage_size output_unit c_f_procpointer ieee_arithmetic ieee_support_underflow_control ieee_get_underflow_mode ieee_set_underflow_mode newunit contiguous recursive pad position action delim readwrite eor advance nml interface procedure namelist include sequence elemental pure integer real character complex logical dimension allocatable|10 parameter external implicit|10 none double precision assign intent optional pointer target in out common equivalence data begin_provider &begin_provider end_provider begin_shell end_shell begin_template end_template subst assert touch soft_touch provide no_dep free irp_if irp_else irp_endif irp_write irp_read",built_in:"alog alog10 amax0 amax1 amin0 amin1 amod cabs ccos cexp clog csin csqrt dabs dacos dasin datan datan2 dcos dcosh ddim dexp dint dlog dlog10 dmax1 dmin1 dmod dnint dsign dsin dsinh dsqrt dtan dtanh float iabs idim idint idnint ifix isign max0 max1 min0 min1 sngl algama cdabs cdcos cdexp cdlog cdsin cdsqrt cqabs cqcos cqexp cqlog cqsin cqsqrt dcmplx dconjg derf derfc dfloat dgamma dimag dlgama iqint qabs qacos qasin qatan qatan2 qcmplx qconjg qcos qcosh qdim qerf qerfc qexp qgamma qimag qlgama qlog qlog10 qmax1 qmin1 qmod qnint qsign qsin qsinh qsqrt qtan qtanh abs acos aimag aint anint asin atan atan2 char cmplx conjg cos cosh exp ichar index int log log10 max min nint sign sin sinh sqrt tan tanh print write dim lge lgt lle llt mod nullify allocate deallocate adjustl adjustr all allocated any associated bit_size btest ceiling count cshift date_and_time digits dot_product eoshift epsilon exponent floor fraction huge iand ibclr ibits ibset ieor ior ishft ishftc lbound len_trim matmul maxexponent maxloc maxval merge minexponent minloc minval modulo mvbits nearest pack present product radix random_number random_seed range repeat reshape rrspacing scale scan selected_int_kind selected_real_kind set_exponent shape size spacing spread sum system_clock tiny transpose trim ubound unpack verify achar iachar transfer dble entry dprod cpu_time command_argument_count get_command get_command_argument get_environment_variable is_iostat_end ieee_arithmetic ieee_support_underflow_control ieee_get_underflow_mode ieee_set_underflow_mode is_iostat_eor move_alloc new_line selected_char_kind same_type_as extends_type_of acosh asinh atanh bessel_j0 bessel_j1 bessel_jn bessel_y0 bessel_y1 bessel_yn erf erfc erfc_scaled gamma log_gamma hypot norm2 atomic_define atomic_ref execute_command_line leadz trailz storage_size merge_bits bge bgt ble blt dshiftl dshiftr findloc iall iany iparity image_index lcobound ucobound maskl maskr num_images parity popcnt poppar shifta shiftl shiftr this_image IRP_ALIGN irp_here"},illegal:/\/\*/,contains:[e.inherit(e.APOS_STRING_MODE,{className:"string",relevance:0}),e.inherit(e.QUOTE_STRING_MODE,{className:"string",relevance:0}),{className:"function",beginKeywords:"subroutine function program",illegal:"[${=\\n]",contains:[e.UNDERSCORE_TITLE_MODE,n]},e.COMMENT("!","$",{relevance:0}),e.COMMENT("begin_doc","end_doc",{relevance:10}),s]}}return nY=t,nY}var iY,hye;function S5t(){if(hye)return iY;hye=1;function t(e){const r="[A-Za-zА-Яа-яёЁ_!][A-Za-zА-Яа-яёЁ_0-9]*",n="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]*",i="and и else иначе endexcept endfinally endforeach конецвсе endif конецесли endwhile конецпока except exitfor finally foreach все if если in в not не or или try while пока ",Y="SYSRES_CONST_ACCES_RIGHT_TYPE_EDIT SYSRES_CONST_ACCES_RIGHT_TYPE_FULL SYSRES_CONST_ACCES_RIGHT_TYPE_VIEW SYSRES_CONST_ACCESS_MODE_REQUISITE_CODE SYSRES_CONST_ACCESS_NO_ACCESS_VIEW SYSRES_CONST_ACCESS_NO_ACCESS_VIEW_CODE SYSRES_CONST_ACCESS_RIGHTS_ADD_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_ADD_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_CHANGE_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_CHANGE_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_DELETE_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_DELETE_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_EXECUTE_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_EXECUTE_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_NO_ACCESS_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_NO_ACCESS_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_RATIFY_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_RATIFY_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_RIGHTS_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_VIEW SYSRES_CONST_ACCESS_RIGHTS_VIEW_CODE SYSRES_CONST_ACCESS_RIGHTS_VIEW_REQUISITE_CODE SYSRES_CONST_ACCESS_RIGHTS_VIEW_REQUISITE_YES_CODE SYSRES_CONST_ACCESS_TYPE_CHANGE SYSRES_CONST_ACCESS_TYPE_CHANGE_CODE SYSRES_CONST_ACCESS_TYPE_EXISTS SYSRES_CONST_ACCESS_TYPE_EXISTS_CODE SYSRES_CONST_ACCESS_TYPE_FULL SYSRES_CONST_ACCESS_TYPE_FULL_CODE SYSRES_CONST_ACCESS_TYPE_VIEW SYSRES_CONST_ACCESS_TYPE_VIEW_CODE SYSRES_CONST_ACTION_TYPE_ABORT SYSRES_CONST_ACTION_TYPE_ACCEPT SYSRES_CONST_ACTION_TYPE_ACCESS_RIGHTS SYSRES_CONST_ACTION_TYPE_ADD_ATTACHMENT SYSRES_CONST_ACTION_TYPE_CHANGE_CARD SYSRES_CONST_ACTION_TYPE_CHANGE_KIND SYSRES_CONST_ACTION_TYPE_CHANGE_STORAGE SYSRES_CONST_ACTION_TYPE_CONTINUE SYSRES_CONST_ACTION_TYPE_COPY SYSRES_CONST_ACTION_TYPE_CREATE SYSRES_CONST_ACTION_TYPE_CREATE_VERSION SYSRES_CONST_ACTION_TYPE_DELETE SYSRES_CONST_ACTION_TYPE_DELETE_ATTACHMENT SYSRES_CONST_ACTION_TYPE_DELETE_VERSION SYSRES_CONST_ACTION_TYPE_DISABLE_DELEGATE_ACCESS_RIGHTS SYSRES_CONST_ACTION_TYPE_ENABLE_DELEGATE_ACCESS_RIGHTS SYSRES_CONST_ACTION_TYPE_ENCRYPTION_BY_CERTIFICATE SYSRES_CONST_ACTION_TYPE_ENCRYPTION_BY_CERTIFICATE_AND_PASSWORD SYSRES_CONST_ACTION_TYPE_ENCRYPTION_BY_PASSWORD SYSRES_CONST_ACTION_TYPE_EXPORT_WITH_LOCK SYSRES_CONST_ACTION_TYPE_EXPORT_WITHOUT_LOCK SYSRES_CONST_ACTION_TYPE_IMPORT_WITH_UNLOCK SYSRES_CONST_ACTION_TYPE_IMPORT_WITHOUT_UNLOCK SYSRES_CONST_ACTION_TYPE_LIFE_CYCLE_STAGE SYSRES_CONST_ACTION_TYPE_LOCK SYSRES_CONST_ACTION_TYPE_LOCK_FOR_SERVER SYSRES_CONST_ACTION_TYPE_LOCK_MODIFY SYSRES_CONST_ACTION_TYPE_MARK_AS_READED SYSRES_CONST_ACTION_TYPE_MARK_AS_UNREADED SYSRES_CONST_ACTION_TYPE_MODIFY SYSRES_CONST_ACTION_TYPE_MODIFY_CARD SYSRES_CONST_ACTION_TYPE_MOVE_TO_ARCHIVE SYSRES_CONST_ACTION_TYPE_OFF_ENCRYPTION SYSRES_CONST_ACTION_TYPE_PASSWORD_CHANGE SYSRES_CONST_ACTION_TYPE_PERFORM SYSRES_CONST_ACTION_TYPE_RECOVER_FROM_LOCAL_COPY SYSRES_CONST_ACTION_TYPE_RESTART SYSRES_CONST_ACTION_TYPE_RESTORE_FROM_ARCHIVE SYSRES_CONST_ACTION_TYPE_REVISION SYSRES_CONST_ACTION_TYPE_SEND_BY_MAIL SYSRES_CONST_ACTION_TYPE_SIGN SYSRES_CONST_ACTION_TYPE_START SYSRES_CONST_ACTION_TYPE_UNLOCK SYSRES_CONST_ACTION_TYPE_UNLOCK_FROM_SERVER SYSRES_CONST_ACTION_TYPE_VERSION_STATE SYSRES_CONST_ACTION_TYPE_VERSION_VISIBILITY SYSRES_CONST_ACTION_TYPE_VIEW SYSRES_CONST_ACTION_TYPE_VIEW_SHADOW_COPY SYSRES_CONST_ACTION_TYPE_WORKFLOW_DESCRIPTION_MODIFY SYSRES_CONST_ACTION_TYPE_WRITE_HISTORY SYSRES_CONST_ACTIVE_VERSION_STATE_PICK_VALUE SYSRES_CONST_ADD_REFERENCE_MODE_NAME SYSRES_CONST_ADDITION_REQUISITE_CODE SYSRES_CONST_ADDITIONAL_PARAMS_REQUISITE_CODE SYSRES_CONST_ADITIONAL_JOB_END_DATE_REQUISITE_NAME SYSRES_CONST_ADITIONAL_JOB_READ_REQUISITE_NAME SYSRES_CONST_ADITIONAL_JOB_START_DATE_REQUISITE_NAME SYSRES_CONST_ADITIONAL_JOB_STATE_REQUISITE_NAME SYSRES_CONST_ADMINISTRATION_HISTORY_ADDING_USER_TO_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_ADDING_USER_TO_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_COMP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_COMP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_USER_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_CREATION_USER_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_DATABASE_USER_CREATION SYSRES_CONST_ADMINISTRATION_HISTORY_DATABASE_USER_CREATION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DATABASE_USER_DELETION SYSRES_CONST_ADMINISTRATION_HISTORY_DATABASE_USER_DELETION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_COMP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_COMP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_USER_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_USER_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_USER_FROM_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_DELETION_USER_FROM_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_FILTERER_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_FILTERER_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_FILTERER_RESTRICTION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_FILTERER_RESTRICTION_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_PRIVILEGE_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_PRIVILEGE_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_RIGHTS_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_GRANTING_RIGHTS_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_IS_MAIN_SERVER_CHANGED_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_IS_MAIN_SERVER_CHANGED_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_IS_PUBLIC_CHANGED_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_IS_PUBLIC_CHANGED_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_FILTERER_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_FILTERER_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_FILTERER_RESTRICTION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_FILTERER_RESTRICTION_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_PRIVILEGE_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_PRIVILEGE_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_RIGHTS_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_REMOVING_RIGHTS_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_SERVER_LOGIN_CREATION SYSRES_CONST_ADMINISTRATION_HISTORY_SERVER_LOGIN_CREATION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_SERVER_LOGIN_DELETION SYSRES_CONST_ADMINISTRATION_HISTORY_SERVER_LOGIN_DELETION_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_CATEGORY_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_CATEGORY_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_COMP_TITLE_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_COMP_TITLE_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_FULL_NAME_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_FULL_NAME_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_PARENT_GROUP_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_PARENT_GROUP_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_AUTH_TYPE_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_AUTH_TYPE_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_LOGIN_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_LOGIN_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_STATUS_ACTION SYSRES_CONST_ADMINISTRATION_HISTORY_UPDATING_USER_STATUS_ACTION_CODE SYSRES_CONST_ADMINISTRATION_HISTORY_USER_PASSWORD_CHANGE SYSRES_CONST_ADMINISTRATION_HISTORY_USER_PASSWORD_CHANGE_ACTION SYSRES_CONST_ALL_ACCEPT_CONDITION_RUS SYSRES_CONST_ALL_USERS_GROUP SYSRES_CONST_ALL_USERS_GROUP_NAME SYSRES_CONST_ALL_USERS_SERVER_GROUP_NAME SYSRES_CONST_ALLOWED_ACCESS_TYPE_CODE SYSRES_CONST_ALLOWED_ACCESS_TYPE_NAME SYSRES_CONST_APP_VIEWER_TYPE_REQUISITE_CODE SYSRES_CONST_APPROVING_SIGNATURE_NAME SYSRES_CONST_APPROVING_SIGNATURE_REQUISITE_CODE SYSRES_CONST_ASSISTANT_SUBSTITUE_TYPE SYSRES_CONST_ASSISTANT_SUBSTITUE_TYPE_CODE SYSRES_CONST_ATTACH_TYPE_COMPONENT_TOKEN SYSRES_CONST_ATTACH_TYPE_DOC SYSRES_CONST_ATTACH_TYPE_EDOC SYSRES_CONST_ATTACH_TYPE_FOLDER SYSRES_CONST_ATTACH_TYPE_JOB SYSRES_CONST_ATTACH_TYPE_REFERENCE SYSRES_CONST_ATTACH_TYPE_TASK SYSRES_CONST_AUTH_ENCODED_PASSWORD SYSRES_CONST_AUTH_ENCODED_PASSWORD_CODE SYSRES_CONST_AUTH_NOVELL SYSRES_CONST_AUTH_PASSWORD SYSRES_CONST_AUTH_PASSWORD_CODE SYSRES_CONST_AUTH_WINDOWS SYSRES_CONST_AUTHENTICATING_SIGNATURE_NAME SYSRES_CONST_AUTHENTICATING_SIGNATURE_REQUISITE_CODE SYSRES_CONST_AUTO_ENUM_METHOD_FLAG SYSRES_CONST_AUTO_NUMERATION_CODE SYSRES_CONST_AUTO_STRONG_ENUM_METHOD_FLAG SYSRES_CONST_AUTOTEXT_NAME_REQUISITE_CODE SYSRES_CONST_AUTOTEXT_TEXT_REQUISITE_CODE SYSRES_CONST_AUTOTEXT_USAGE_ALL SYSRES_CONST_AUTOTEXT_USAGE_ALL_CODE SYSRES_CONST_AUTOTEXT_USAGE_SIGN SYSRES_CONST_AUTOTEXT_USAGE_SIGN_CODE SYSRES_CONST_AUTOTEXT_USAGE_WORK SYSRES_CONST_AUTOTEXT_USAGE_WORK_CODE SYSRES_CONST_AUTOTEXT_USE_ANYWHERE_CODE SYSRES_CONST_AUTOTEXT_USE_ON_SIGNING_CODE SYSRES_CONST_AUTOTEXT_USE_ON_WORK_CODE SYSRES_CONST_BEGIN_DATE_REQUISITE_CODE SYSRES_CONST_BLACK_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_BLUE_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_BTN_PART SYSRES_CONST_CALCULATED_ROLE_TYPE_CODE SYSRES_CONST_CALL_TYPE_VARIABLE_BUTTON_VALUE SYSRES_CONST_CALL_TYPE_VARIABLE_PROGRAM_VALUE SYSRES_CONST_CANCEL_MESSAGE_FUNCTION_RESULT SYSRES_CONST_CARD_PART SYSRES_CONST_CARD_REFERENCE_MODE_NAME SYSRES_CONST_CERTIFICATE_TYPE_REQUISITE_ENCRYPT_VALUE SYSRES_CONST_CERTIFICATE_TYPE_REQUISITE_SIGN_AND_ENCRYPT_VALUE SYSRES_CONST_CERTIFICATE_TYPE_REQUISITE_SIGN_VALUE SYSRES_CONST_CHECK_PARAM_VALUE_DATE_PARAM_TYPE SYSRES_CONST_CHECK_PARAM_VALUE_FLOAT_PARAM_TYPE SYSRES_CONST_CHECK_PARAM_VALUE_INTEGER_PARAM_TYPE SYSRES_CONST_CHECK_PARAM_VALUE_PICK_PARAM_TYPE SYSRES_CONST_CHECK_PARAM_VALUE_REEFRENCE_PARAM_TYPE SYSRES_CONST_CLOSED_RECORD_FLAG_VALUE_FEMININE SYSRES_CONST_CLOSED_RECORD_FLAG_VALUE_MASCULINE SYSRES_CONST_CODE_COMPONENT_TYPE_ADMIN SYSRES_CONST_CODE_COMPONENT_TYPE_DEVELOPER SYSRES_CONST_CODE_COMPONENT_TYPE_DOCS SYSRES_CONST_CODE_COMPONENT_TYPE_EDOC_CARDS SYSRES_CONST_CODE_COMPONENT_TYPE_EXTERNAL_EXECUTABLE SYSRES_CONST_CODE_COMPONENT_TYPE_OTHER SYSRES_CONST_CODE_COMPONENT_TYPE_REFERENCE SYSRES_CONST_CODE_COMPONENT_TYPE_REPORT SYSRES_CONST_CODE_COMPONENT_TYPE_SCRIPT SYSRES_CONST_CODE_COMPONENT_TYPE_URL SYSRES_CONST_CODE_REQUISITE_ACCESS SYSRES_CONST_CODE_REQUISITE_CODE SYSRES_CONST_CODE_REQUISITE_COMPONENT SYSRES_CONST_CODE_REQUISITE_DESCRIPTION SYSRES_CONST_CODE_REQUISITE_EXCLUDE_COMPONENT SYSRES_CONST_CODE_REQUISITE_RECORD SYSRES_CONST_COMMENT_REQ_CODE SYSRES_CONST_COMMON_SETTINGS_REQUISITE_CODE SYSRES_CONST_COMP_CODE_GRD SYSRES_CONST_COMPONENT_GROUP_TYPE_REQUISITE_CODE SYSRES_CONST_COMPONENT_TYPE_ADMIN_COMPONENTS SYSRES_CONST_COMPONENT_TYPE_DEVELOPER_COMPONENTS SYSRES_CONST_COMPONENT_TYPE_DOCS SYSRES_CONST_COMPONENT_TYPE_EDOC_CARDS SYSRES_CONST_COMPONENT_TYPE_EDOCS SYSRES_CONST_COMPONENT_TYPE_EXTERNAL_EXECUTABLE SYSRES_CONST_COMPONENT_TYPE_OTHER SYSRES_CONST_COMPONENT_TYPE_REFERENCE_TYPES SYSRES_CONST_COMPONENT_TYPE_REFERENCES SYSRES_CONST_COMPONENT_TYPE_REPORTS SYSRES_CONST_COMPONENT_TYPE_SCRIPTS SYSRES_CONST_COMPONENT_TYPE_URL SYSRES_CONST_COMPONENTS_REMOTE_SERVERS_VIEW_CODE SYSRES_CONST_CONDITION_BLOCK_DESCRIPTION SYSRES_CONST_CONST_FIRM_STATUS_COMMON SYSRES_CONST_CONST_FIRM_STATUS_INDIVIDUAL SYSRES_CONST_CONST_NEGATIVE_VALUE SYSRES_CONST_CONST_POSITIVE_VALUE SYSRES_CONST_CONST_SERVER_STATUS_DONT_REPLICATE SYSRES_CONST_CONST_SERVER_STATUS_REPLICATE SYSRES_CONST_CONTENTS_REQUISITE_CODE SYSRES_CONST_DATA_TYPE_BOOLEAN SYSRES_CONST_DATA_TYPE_DATE SYSRES_CONST_DATA_TYPE_FLOAT SYSRES_CONST_DATA_TYPE_INTEGER SYSRES_CONST_DATA_TYPE_PICK SYSRES_CONST_DATA_TYPE_REFERENCE SYSRES_CONST_DATA_TYPE_STRING SYSRES_CONST_DATA_TYPE_TEXT SYSRES_CONST_DATA_TYPE_VARIANT SYSRES_CONST_DATE_CLOSE_REQ_CODE SYSRES_CONST_DATE_FORMAT_DATE_ONLY_CHAR SYSRES_CONST_DATE_OPEN_REQ_CODE SYSRES_CONST_DATE_REQUISITE SYSRES_CONST_DATE_REQUISITE_CODE SYSRES_CONST_DATE_REQUISITE_NAME SYSRES_CONST_DATE_REQUISITE_TYPE SYSRES_CONST_DATE_TYPE_CHAR SYSRES_CONST_DATETIME_FORMAT_VALUE SYSRES_CONST_DEA_ACCESS_RIGHTS_ACTION_CODE SYSRES_CONST_DESCRIPTION_LOCALIZE_ID_REQUISITE_CODE SYSRES_CONST_DESCRIPTION_REQUISITE_CODE SYSRES_CONST_DET1_PART SYSRES_CONST_DET2_PART SYSRES_CONST_DET3_PART SYSRES_CONST_DET4_PART SYSRES_CONST_DET5_PART SYSRES_CONST_DET6_PART SYSRES_CONST_DETAIL_DATASET_KEY_REQUISITE_CODE SYSRES_CONST_DETAIL_PICK_REQUISITE_CODE SYSRES_CONST_DETAIL_REQ_CODE SYSRES_CONST_DO_NOT_USE_ACCESS_TYPE_CODE SYSRES_CONST_DO_NOT_USE_ACCESS_TYPE_NAME SYSRES_CONST_DO_NOT_USE_ON_VIEW_ACCESS_TYPE_CODE SYSRES_CONST_DO_NOT_USE_ON_VIEW_ACCESS_TYPE_NAME SYSRES_CONST_DOCUMENT_STORAGES_CODE SYSRES_CONST_DOCUMENT_TEMPLATES_TYPE_NAME SYSRES_CONST_DOUBLE_REQUISITE_CODE SYSRES_CONST_EDITOR_CLOSE_FILE_OBSERV_TYPE_CODE SYSRES_CONST_EDITOR_CLOSE_PROCESS_OBSERV_TYPE_CODE SYSRES_CONST_EDITOR_TYPE_REQUISITE_CODE SYSRES_CONST_EDITORS_APPLICATION_NAME_REQUISITE_CODE SYSRES_CONST_EDITORS_CREATE_SEVERAL_PROCESSES_REQUISITE_CODE SYSRES_CONST_EDITORS_EXTENSION_REQUISITE_CODE SYSRES_CONST_EDITORS_OBSERVER_BY_PROCESS_TYPE SYSRES_CONST_EDITORS_REFERENCE_CODE SYSRES_CONST_EDITORS_REPLACE_SPEC_CHARS_REQUISITE_CODE SYSRES_CONST_EDITORS_USE_PLUGINS_REQUISITE_CODE SYSRES_CONST_EDITORS_VIEW_DOCUMENT_OPENED_TO_EDIT_CODE SYSRES_CONST_EDOC_CARD_TYPE_REQUISITE_CODE SYSRES_CONST_EDOC_CARD_TYPES_LINK_REQUISITE_CODE SYSRES_CONST_EDOC_CERTIFICATE_AND_PASSWORD_ENCODE_CODE SYSRES_CONST_EDOC_CERTIFICATE_ENCODE_CODE SYSRES_CONST_EDOC_DATE_REQUISITE_CODE SYSRES_CONST_EDOC_KIND_REFERENCE_CODE SYSRES_CONST_EDOC_KINDS_BY_TEMPLATE_ACTION_CODE SYSRES_CONST_EDOC_MANAGE_ACCESS_CODE SYSRES_CONST_EDOC_NONE_ENCODE_CODE SYSRES_CONST_EDOC_NUMBER_REQUISITE_CODE SYSRES_CONST_EDOC_PASSWORD_ENCODE_CODE SYSRES_CONST_EDOC_READONLY_ACCESS_CODE SYSRES_CONST_EDOC_SHELL_LIFE_TYPE_VIEW_VALUE SYSRES_CONST_EDOC_SIZE_RESTRICTION_PRIORITY_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_CHECK_ACCESS_RIGHTS_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_COMPUTER_NAME_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_DATABASE_NAME_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_EDIT_IN_STORAGE_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_LOCAL_PATH_REQUISITE_CODE SYSRES_CONST_EDOC_STORAGE_SHARED_SOURCE_NAME_REQUISITE_CODE SYSRES_CONST_EDOC_TEMPLATE_REQUISITE_CODE SYSRES_CONST_EDOC_TYPES_REFERENCE_CODE SYSRES_CONST_EDOC_VERSION_ACTIVE_STAGE_CODE SYSRES_CONST_EDOC_VERSION_DESIGN_STAGE_CODE SYSRES_CONST_EDOC_VERSION_OBSOLETE_STAGE_CODE SYSRES_CONST_EDOC_WRITE_ACCES_CODE SYSRES_CONST_EDOCUMENT_CARD_REQUISITES_REFERENCE_CODE_SELECTED_REQUISITE SYSRES_CONST_ENCODE_CERTIFICATE_TYPE_CODE SYSRES_CONST_END_DATE_REQUISITE_CODE SYSRES_CONST_ENUMERATION_TYPE_REQUISITE_CODE SYSRES_CONST_EXECUTE_ACCESS_RIGHTS_TYPE_CODE SYSRES_CONST_EXECUTIVE_FILE_STORAGE_TYPE SYSRES_CONST_EXIST_CONST SYSRES_CONST_EXIST_VALUE SYSRES_CONST_EXPORT_LOCK_TYPE_ASK SYSRES_CONST_EXPORT_LOCK_TYPE_WITH_LOCK SYSRES_CONST_EXPORT_LOCK_TYPE_WITHOUT_LOCK SYSRES_CONST_EXPORT_VERSION_TYPE_ASK SYSRES_CONST_EXPORT_VERSION_TYPE_LAST SYSRES_CONST_EXPORT_VERSION_TYPE_LAST_ACTIVE SYSRES_CONST_EXTENSION_REQUISITE_CODE SYSRES_CONST_FILTER_NAME_REQUISITE_CODE SYSRES_CONST_FILTER_REQUISITE_CODE SYSRES_CONST_FILTER_TYPE_COMMON_CODE SYSRES_CONST_FILTER_TYPE_COMMON_NAME SYSRES_CONST_FILTER_TYPE_USER_CODE SYSRES_CONST_FILTER_TYPE_USER_NAME SYSRES_CONST_FILTER_VALUE_REQUISITE_NAME SYSRES_CONST_FLOAT_NUMBER_FORMAT_CHAR SYSRES_CONST_FLOAT_REQUISITE_TYPE SYSRES_CONST_FOLDER_AUTHOR_VALUE SYSRES_CONST_FOLDER_KIND_ANY_OBJECTS SYSRES_CONST_FOLDER_KIND_COMPONENTS SYSRES_CONST_FOLDER_KIND_EDOCS SYSRES_CONST_FOLDER_KIND_JOBS SYSRES_CONST_FOLDER_KIND_TASKS SYSRES_CONST_FOLDER_TYPE_COMMON SYSRES_CONST_FOLDER_TYPE_COMPONENT SYSRES_CONST_FOLDER_TYPE_FAVORITES SYSRES_CONST_FOLDER_TYPE_INBOX SYSRES_CONST_FOLDER_TYPE_OUTBOX SYSRES_CONST_FOLDER_TYPE_QUICK_LAUNCH SYSRES_CONST_FOLDER_TYPE_SEARCH SYSRES_CONST_FOLDER_TYPE_SHORTCUTS SYSRES_CONST_FOLDER_TYPE_USER SYSRES_CONST_FROM_DICTIONARY_ENUM_METHOD_FLAG SYSRES_CONST_FULL_SUBSTITUTE_TYPE SYSRES_CONST_FULL_SUBSTITUTE_TYPE_CODE SYSRES_CONST_FUNCTION_CANCEL_RESULT SYSRES_CONST_FUNCTION_CATEGORY_SYSTEM SYSRES_CONST_FUNCTION_CATEGORY_USER SYSRES_CONST_FUNCTION_FAILURE_RESULT SYSRES_CONST_FUNCTION_SAVE_RESULT SYSRES_CONST_GENERATED_REQUISITE SYSRES_CONST_GREEN_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_GROUP_ACCOUNT_TYPE_VALUE_CODE SYSRES_CONST_GROUP_CATEGORY_NORMAL_CODE SYSRES_CONST_GROUP_CATEGORY_NORMAL_NAME SYSRES_CONST_GROUP_CATEGORY_SERVICE_CODE SYSRES_CONST_GROUP_CATEGORY_SERVICE_NAME SYSRES_CONST_GROUP_COMMON_CATEGORY_FIELD_VALUE SYSRES_CONST_GROUP_FULL_NAME_REQUISITE_CODE SYSRES_CONST_GROUP_NAME_REQUISITE_CODE SYSRES_CONST_GROUP_RIGHTS_T_REQUISITE_CODE SYSRES_CONST_GROUP_SERVER_CODES_REQUISITE_CODE SYSRES_CONST_GROUP_SERVER_NAME_REQUISITE_CODE SYSRES_CONST_GROUP_SERVICE_CATEGORY_FIELD_VALUE SYSRES_CONST_GROUP_USER_REQUISITE_CODE SYSRES_CONST_GROUPS_REFERENCE_CODE SYSRES_CONST_GROUPS_REQUISITE_CODE SYSRES_CONST_HIDDEN_MODE_NAME SYSRES_CONST_HIGH_LVL_REQUISITE_CODE SYSRES_CONST_HISTORY_ACTION_CREATE_CODE SYSRES_CONST_HISTORY_ACTION_DELETE_CODE SYSRES_CONST_HISTORY_ACTION_EDIT_CODE SYSRES_CONST_HOUR_CHAR SYSRES_CONST_ID_REQUISITE_CODE SYSRES_CONST_IDSPS_REQUISITE_CODE SYSRES_CONST_IMAGE_MODE_COLOR SYSRES_CONST_IMAGE_MODE_GREYSCALE SYSRES_CONST_IMAGE_MODE_MONOCHROME SYSRES_CONST_IMPORTANCE_HIGH SYSRES_CONST_IMPORTANCE_LOW SYSRES_CONST_IMPORTANCE_NORMAL SYSRES_CONST_IN_DESIGN_VERSION_STATE_PICK_VALUE SYSRES_CONST_INCOMING_WORK_RULE_TYPE_CODE SYSRES_CONST_INT_REQUISITE SYSRES_CONST_INT_REQUISITE_TYPE SYSRES_CONST_INTEGER_NUMBER_FORMAT_CHAR SYSRES_CONST_INTEGER_TYPE_CHAR SYSRES_CONST_IS_GENERATED_REQUISITE_NEGATIVE_VALUE SYSRES_CONST_IS_PUBLIC_ROLE_REQUISITE_CODE SYSRES_CONST_IS_REMOTE_USER_NEGATIVE_VALUE SYSRES_CONST_IS_REMOTE_USER_POSITIVE_VALUE SYSRES_CONST_IS_STORED_REQUISITE_NEGATIVE_VALUE SYSRES_CONST_IS_STORED_REQUISITE_STORED_VALUE SYSRES_CONST_ITALIC_LIFE_CYCLE_STAGE_DRAW_STYLE SYSRES_CONST_JOB_BLOCK_DESCRIPTION SYSRES_CONST_JOB_KIND_CONTROL_JOB SYSRES_CONST_JOB_KIND_JOB SYSRES_CONST_JOB_KIND_NOTICE SYSRES_CONST_JOB_STATE_ABORTED SYSRES_CONST_JOB_STATE_COMPLETE SYSRES_CONST_JOB_STATE_WORKING SYSRES_CONST_KIND_REQUISITE_CODE SYSRES_CONST_KIND_REQUISITE_NAME SYSRES_CONST_KINDS_CREATE_SHADOW_COPIES_REQUISITE_CODE SYSRES_CONST_KINDS_DEFAULT_EDOC_LIFE_STAGE_REQUISITE_CODE SYSRES_CONST_KINDS_EDOC_ALL_TEPLATES_ALLOWED_REQUISITE_CODE SYSRES_CONST_KINDS_EDOC_ALLOW_LIFE_CYCLE_STAGE_CHANGING_REQUISITE_CODE SYSRES_CONST_KINDS_EDOC_ALLOW_MULTIPLE_ACTIVE_VERSIONS_REQUISITE_CODE SYSRES_CONST_KINDS_EDOC_SHARE_ACCES_RIGHTS_BY_DEFAULT_CODE SYSRES_CONST_KINDS_EDOC_TEMPLATE_REQUISITE_CODE SYSRES_CONST_KINDS_EDOC_TYPE_REQUISITE_CODE SYSRES_CONST_KINDS_SIGNERS_REQUISITES_CODE SYSRES_CONST_KOD_INPUT_TYPE SYSRES_CONST_LAST_UPDATE_DATE_REQUISITE_CODE SYSRES_CONST_LIFE_CYCLE_START_STAGE_REQUISITE_CODE SYSRES_CONST_LILAC_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_LINK_OBJECT_KIND_COMPONENT SYSRES_CONST_LINK_OBJECT_KIND_DOCUMENT SYSRES_CONST_LINK_OBJECT_KIND_EDOC SYSRES_CONST_LINK_OBJECT_KIND_FOLDER SYSRES_CONST_LINK_OBJECT_KIND_JOB SYSRES_CONST_LINK_OBJECT_KIND_REFERENCE SYSRES_CONST_LINK_OBJECT_KIND_TASK SYSRES_CONST_LINK_REF_TYPE_REQUISITE_CODE SYSRES_CONST_LIST_REFERENCE_MODE_NAME SYSRES_CONST_LOCALIZATION_DICTIONARY_MAIN_VIEW_CODE SYSRES_CONST_MAIN_VIEW_CODE SYSRES_CONST_MANUAL_ENUM_METHOD_FLAG SYSRES_CONST_MASTER_COMP_TYPE_REQUISITE_CODE SYSRES_CONST_MASTER_TABLE_REC_ID_REQUISITE_CODE SYSRES_CONST_MAXIMIZED_MODE_NAME SYSRES_CONST_ME_VALUE SYSRES_CONST_MESSAGE_ATTENTION_CAPTION SYSRES_CONST_MESSAGE_CONFIRMATION_CAPTION SYSRES_CONST_MESSAGE_ERROR_CAPTION SYSRES_CONST_MESSAGE_INFORMATION_CAPTION SYSRES_CONST_MINIMIZED_MODE_NAME SYSRES_CONST_MINUTE_CHAR SYSRES_CONST_MODULE_REQUISITE_CODE SYSRES_CONST_MONITORING_BLOCK_DESCRIPTION SYSRES_CONST_MONTH_FORMAT_VALUE SYSRES_CONST_NAME_LOCALIZE_ID_REQUISITE_CODE SYSRES_CONST_NAME_REQUISITE_CODE SYSRES_CONST_NAME_SINGULAR_REQUISITE_CODE SYSRES_CONST_NAMEAN_INPUT_TYPE SYSRES_CONST_NEGATIVE_PICK_VALUE SYSRES_CONST_NEGATIVE_VALUE SYSRES_CONST_NO SYSRES_CONST_NO_PICK_VALUE SYSRES_CONST_NO_SIGNATURE_REQUISITE_CODE SYSRES_CONST_NO_VALUE SYSRES_CONST_NONE_ACCESS_RIGHTS_TYPE_CODE SYSRES_CONST_NONOPERATING_RECORD_FLAG_VALUE SYSRES_CONST_NONOPERATING_RECORD_FLAG_VALUE_MASCULINE SYSRES_CONST_NORMAL_ACCESS_RIGHTS_TYPE_CODE SYSRES_CONST_NORMAL_LIFE_CYCLE_STAGE_DRAW_STYLE SYSRES_CONST_NORMAL_MODE_NAME SYSRES_CONST_NOT_ALLOWED_ACCESS_TYPE_CODE SYSRES_CONST_NOT_ALLOWED_ACCESS_TYPE_NAME SYSRES_CONST_NOTE_REQUISITE_CODE SYSRES_CONST_NOTICE_BLOCK_DESCRIPTION SYSRES_CONST_NUM_REQUISITE SYSRES_CONST_NUM_STR_REQUISITE_CODE SYSRES_CONST_NUMERATION_AUTO_NOT_STRONG SYSRES_CONST_NUMERATION_AUTO_STRONG SYSRES_CONST_NUMERATION_FROM_DICTONARY SYSRES_CONST_NUMERATION_MANUAL SYSRES_CONST_NUMERIC_TYPE_CHAR SYSRES_CONST_NUMREQ_REQUISITE_CODE SYSRES_CONST_OBSOLETE_VERSION_STATE_PICK_VALUE SYSRES_CONST_OPERATING_RECORD_FLAG_VALUE SYSRES_CONST_OPERATING_RECORD_FLAG_VALUE_CODE SYSRES_CONST_OPERATING_RECORD_FLAG_VALUE_FEMININE SYSRES_CONST_OPERATING_RECORD_FLAG_VALUE_MASCULINE SYSRES_CONST_OPTIONAL_FORM_COMP_REQCODE_PREFIX SYSRES_CONST_ORANGE_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_ORIGINALREF_REQUISITE_CODE SYSRES_CONST_OURFIRM_REF_CODE SYSRES_CONST_OURFIRM_REQUISITE_CODE SYSRES_CONST_OURFIRM_VAR SYSRES_CONST_OUTGOING_WORK_RULE_TYPE_CODE SYSRES_CONST_PICK_NEGATIVE_RESULT SYSRES_CONST_PICK_POSITIVE_RESULT SYSRES_CONST_PICK_REQUISITE SYSRES_CONST_PICK_REQUISITE_TYPE SYSRES_CONST_PICK_TYPE_CHAR SYSRES_CONST_PLAN_STATUS_REQUISITE_CODE SYSRES_CONST_PLATFORM_VERSION_COMMENT SYSRES_CONST_PLUGINS_SETTINGS_DESCRIPTION_REQUISITE_CODE SYSRES_CONST_POSITIVE_PICK_VALUE SYSRES_CONST_POWER_TO_CREATE_ACTION_CODE SYSRES_CONST_POWER_TO_SIGN_ACTION_CODE SYSRES_CONST_PRIORITY_REQUISITE_CODE SYSRES_CONST_QUALIFIED_TASK_TYPE SYSRES_CONST_QUALIFIED_TASK_TYPE_CODE SYSRES_CONST_RECSTAT_REQUISITE_CODE SYSRES_CONST_RED_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_REF_ID_T_REF_TYPE_REQUISITE_CODE SYSRES_CONST_REF_REQUISITE SYSRES_CONST_REF_REQUISITE_TYPE SYSRES_CONST_REF_REQUISITES_REFERENCE_CODE_SELECTED_REQUISITE SYSRES_CONST_REFERENCE_RECORD_HISTORY_CREATE_ACTION_CODE SYSRES_CONST_REFERENCE_RECORD_HISTORY_DELETE_ACTION_CODE SYSRES_CONST_REFERENCE_RECORD_HISTORY_MODIFY_ACTION_CODE SYSRES_CONST_REFERENCE_TYPE_CHAR SYSRES_CONST_REFERENCE_TYPE_REQUISITE_NAME SYSRES_CONST_REFERENCES_ADD_PARAMS_REQUISITE_CODE SYSRES_CONST_REFERENCES_DISPLAY_REQUISITE_REQUISITE_CODE SYSRES_CONST_REMOTE_SERVER_STATUS_WORKING SYSRES_CONST_REMOTE_SERVER_TYPE_MAIN SYSRES_CONST_REMOTE_SERVER_TYPE_SECONDARY SYSRES_CONST_REMOTE_USER_FLAG_VALUE_CODE SYSRES_CONST_REPORT_APP_EDITOR_INTERNAL SYSRES_CONST_REPORT_BASE_REPORT_ID_REQUISITE_CODE SYSRES_CONST_REPORT_BASE_REPORT_REQUISITE_CODE SYSRES_CONST_REPORT_SCRIPT_REQUISITE_CODE SYSRES_CONST_REPORT_TEMPLATE_REQUISITE_CODE SYSRES_CONST_REPORT_VIEWER_CODE_REQUISITE_CODE SYSRES_CONST_REQ_ALLOW_COMPONENT_DEFAULT_VALUE SYSRES_CONST_REQ_ALLOW_RECORD_DEFAULT_VALUE SYSRES_CONST_REQ_ALLOW_SERVER_COMPONENT_DEFAULT_VALUE SYSRES_CONST_REQ_MODE_AVAILABLE_CODE SYSRES_CONST_REQ_MODE_EDIT_CODE SYSRES_CONST_REQ_MODE_HIDDEN_CODE SYSRES_CONST_REQ_MODE_NOT_AVAILABLE_CODE SYSRES_CONST_REQ_MODE_VIEW_CODE SYSRES_CONST_REQ_NUMBER_REQUISITE_CODE SYSRES_CONST_REQ_SECTION_VALUE SYSRES_CONST_REQ_TYPE_VALUE SYSRES_CONST_REQUISITE_FORMAT_BY_UNIT SYSRES_CONST_REQUISITE_FORMAT_DATE_FULL SYSRES_CONST_REQUISITE_FORMAT_DATE_TIME SYSRES_CONST_REQUISITE_FORMAT_LEFT SYSRES_CONST_REQUISITE_FORMAT_RIGHT SYSRES_CONST_REQUISITE_FORMAT_WITHOUT_UNIT SYSRES_CONST_REQUISITE_NUMBER_REQUISITE_CODE SYSRES_CONST_REQUISITE_SECTION_ACTIONS SYSRES_CONST_REQUISITE_SECTION_BUTTON SYSRES_CONST_REQUISITE_SECTION_BUTTONS SYSRES_CONST_REQUISITE_SECTION_CARD SYSRES_CONST_REQUISITE_SECTION_TABLE SYSRES_CONST_REQUISITE_SECTION_TABLE10 SYSRES_CONST_REQUISITE_SECTION_TABLE11 SYSRES_CONST_REQUISITE_SECTION_TABLE12 SYSRES_CONST_REQUISITE_SECTION_TABLE13 SYSRES_CONST_REQUISITE_SECTION_TABLE14 SYSRES_CONST_REQUISITE_SECTION_TABLE15 SYSRES_CONST_REQUISITE_SECTION_TABLE16 SYSRES_CONST_REQUISITE_SECTION_TABLE17 SYSRES_CONST_REQUISITE_SECTION_TABLE18 SYSRES_CONST_REQUISITE_SECTION_TABLE19 SYSRES_CONST_REQUISITE_SECTION_TABLE2 SYSRES_CONST_REQUISITE_SECTION_TABLE20 SYSRES_CONST_REQUISITE_SECTION_TABLE21 SYSRES_CONST_REQUISITE_SECTION_TABLE22 SYSRES_CONST_REQUISITE_SECTION_TABLE23 SYSRES_CONST_REQUISITE_SECTION_TABLE24 SYSRES_CONST_REQUISITE_SECTION_TABLE3 SYSRES_CONST_REQUISITE_SECTION_TABLE4 SYSRES_CONST_REQUISITE_SECTION_TABLE5 SYSRES_CONST_REQUISITE_SECTION_TABLE6 SYSRES_CONST_REQUISITE_SECTION_TABLE7 SYSRES_CONST_REQUISITE_SECTION_TABLE8 SYSRES_CONST_REQUISITE_SECTION_TABLE9 SYSRES_CONST_REQUISITES_PSEUDOREFERENCE_REQUISITE_NUMBER_REQUISITE_CODE SYSRES_CONST_RIGHT_ALIGNMENT_CODE SYSRES_CONST_ROLES_REFERENCE_CODE SYSRES_CONST_ROUTE_STEP_AFTER_RUS SYSRES_CONST_ROUTE_STEP_AND_CONDITION_RUS SYSRES_CONST_ROUTE_STEP_OR_CONDITION_RUS SYSRES_CONST_ROUTE_TYPE_COMPLEX SYSRES_CONST_ROUTE_TYPE_PARALLEL SYSRES_CONST_ROUTE_TYPE_SERIAL SYSRES_CONST_SBDATASETDESC_NEGATIVE_VALUE SYSRES_CONST_SBDATASETDESC_POSITIVE_VALUE SYSRES_CONST_SBVIEWSDESC_POSITIVE_VALUE SYSRES_CONST_SCRIPT_BLOCK_DESCRIPTION SYSRES_CONST_SEARCH_BY_TEXT_REQUISITE_CODE SYSRES_CONST_SEARCHES_COMPONENT_CONTENT SYSRES_CONST_SEARCHES_CRITERIA_ACTION_NAME SYSRES_CONST_SEARCHES_EDOC_CONTENT SYSRES_CONST_SEARCHES_FOLDER_CONTENT SYSRES_CONST_SEARCHES_JOB_CONTENT SYSRES_CONST_SEARCHES_REFERENCE_CODE SYSRES_CONST_SEARCHES_TASK_CONTENT SYSRES_CONST_SECOND_CHAR SYSRES_CONST_SECTION_REQUISITE_ACTIONS_VALUE SYSRES_CONST_SECTION_REQUISITE_CARD_VALUE SYSRES_CONST_SECTION_REQUISITE_CODE SYSRES_CONST_SECTION_REQUISITE_DETAIL_1_VALUE SYSRES_CONST_SECTION_REQUISITE_DETAIL_2_VALUE SYSRES_CONST_SECTION_REQUISITE_DETAIL_3_VALUE SYSRES_CONST_SECTION_REQUISITE_DETAIL_4_VALUE SYSRES_CONST_SECTION_REQUISITE_DETAIL_5_VALUE SYSRES_CONST_SECTION_REQUISITE_DETAIL_6_VALUE SYSRES_CONST_SELECT_REFERENCE_MODE_NAME SYSRES_CONST_SELECT_TYPE_SELECTABLE SYSRES_CONST_SELECT_TYPE_SELECTABLE_ONLY_CHILD SYSRES_CONST_SELECT_TYPE_SELECTABLE_WITH_CHILD SYSRES_CONST_SELECT_TYPE_UNSLECTABLE SYSRES_CONST_SERVER_TYPE_MAIN SYSRES_CONST_SERVICE_USER_CATEGORY_FIELD_VALUE SYSRES_CONST_SETTINGS_USER_REQUISITE_CODE SYSRES_CONST_SIGNATURE_AND_ENCODE_CERTIFICATE_TYPE_CODE SYSRES_CONST_SIGNATURE_CERTIFICATE_TYPE_CODE SYSRES_CONST_SINGULAR_TITLE_REQUISITE_CODE SYSRES_CONST_SQL_SERVER_AUTHENTIFICATION_FLAG_VALUE_CODE SYSRES_CONST_SQL_SERVER_ENCODE_AUTHENTIFICATION_FLAG_VALUE_CODE SYSRES_CONST_STANDART_ROUTE_REFERENCE_CODE SYSRES_CONST_STANDART_ROUTE_REFERENCE_COMMENT_REQUISITE_CODE SYSRES_CONST_STANDART_ROUTES_GROUPS_REFERENCE_CODE SYSRES_CONST_STATE_REQ_NAME SYSRES_CONST_STATE_REQUISITE_ACTIVE_VALUE SYSRES_CONST_STATE_REQUISITE_CLOSED_VALUE SYSRES_CONST_STATE_REQUISITE_CODE SYSRES_CONST_STATIC_ROLE_TYPE_CODE SYSRES_CONST_STATUS_PLAN_DEFAULT_VALUE SYSRES_CONST_STATUS_VALUE_AUTOCLEANING SYSRES_CONST_STATUS_VALUE_BLUE_SQUARE SYSRES_CONST_STATUS_VALUE_COMPLETE SYSRES_CONST_STATUS_VALUE_GREEN_SQUARE SYSRES_CONST_STATUS_VALUE_ORANGE_SQUARE SYSRES_CONST_STATUS_VALUE_PURPLE_SQUARE SYSRES_CONST_STATUS_VALUE_RED_SQUARE SYSRES_CONST_STATUS_VALUE_SUSPEND SYSRES_CONST_STATUS_VALUE_YELLOW_SQUARE SYSRES_CONST_STDROUTE_SHOW_TO_USERS_REQUISITE_CODE SYSRES_CONST_STORAGE_TYPE_FILE SYSRES_CONST_STORAGE_TYPE_SQL_SERVER SYSRES_CONST_STR_REQUISITE SYSRES_CONST_STRIKEOUT_LIFE_CYCLE_STAGE_DRAW_STYLE SYSRES_CONST_STRING_FORMAT_LEFT_ALIGN_CHAR SYSRES_CONST_STRING_FORMAT_RIGHT_ALIGN_CHAR SYSRES_CONST_STRING_REQUISITE_CODE SYSRES_CONST_STRING_REQUISITE_TYPE SYSRES_CONST_STRING_TYPE_CHAR SYSRES_CONST_SUBSTITUTES_PSEUDOREFERENCE_CODE SYSRES_CONST_SUBTASK_BLOCK_DESCRIPTION SYSRES_CONST_SYSTEM_SETTING_CURRENT_USER_PARAM_VALUE SYSRES_CONST_SYSTEM_SETTING_EMPTY_VALUE_PARAM_VALUE SYSRES_CONST_SYSTEM_VERSION_COMMENT SYSRES_CONST_TASK_ACCESS_TYPE_ALL SYSRES_CONST_TASK_ACCESS_TYPE_ALL_MEMBERS SYSRES_CONST_TASK_ACCESS_TYPE_MANUAL SYSRES_CONST_TASK_ENCODE_TYPE_CERTIFICATION SYSRES_CONST_TASK_ENCODE_TYPE_CERTIFICATION_AND_PASSWORD SYSRES_CONST_TASK_ENCODE_TYPE_NONE SYSRES_CONST_TASK_ENCODE_TYPE_PASSWORD SYSRES_CONST_TASK_ROUTE_ALL_CONDITION SYSRES_CONST_TASK_ROUTE_AND_CONDITION SYSRES_CONST_TASK_ROUTE_OR_CONDITION SYSRES_CONST_TASK_STATE_ABORTED SYSRES_CONST_TASK_STATE_COMPLETE SYSRES_CONST_TASK_STATE_CONTINUED SYSRES_CONST_TASK_STATE_CONTROL SYSRES_CONST_TASK_STATE_INIT SYSRES_CONST_TASK_STATE_WORKING SYSRES_CONST_TASK_TITLE SYSRES_CONST_TASK_TYPES_GROUPS_REFERENCE_CODE SYSRES_CONST_TASK_TYPES_REFERENCE_CODE SYSRES_CONST_TEMPLATES_REFERENCE_CODE SYSRES_CONST_TEST_DATE_REQUISITE_NAME SYSRES_CONST_TEST_DEV_DATABASE_NAME SYSRES_CONST_TEST_DEV_SYSTEM_CODE SYSRES_CONST_TEST_EDMS_DATABASE_NAME SYSRES_CONST_TEST_EDMS_MAIN_CODE SYSRES_CONST_TEST_EDMS_MAIN_DB_NAME SYSRES_CONST_TEST_EDMS_SECOND_CODE SYSRES_CONST_TEST_EDMS_SECOND_DB_NAME SYSRES_CONST_TEST_EDMS_SYSTEM_CODE SYSRES_CONST_TEST_NUMERIC_REQUISITE_NAME SYSRES_CONST_TEXT_REQUISITE SYSRES_CONST_TEXT_REQUISITE_CODE SYSRES_CONST_TEXT_REQUISITE_TYPE SYSRES_CONST_TEXT_TYPE_CHAR SYSRES_CONST_TYPE_CODE_REQUISITE_CODE SYSRES_CONST_TYPE_REQUISITE_CODE SYSRES_CONST_UNDEFINED_LIFE_CYCLE_STAGE_FONT_COLOR SYSRES_CONST_UNITS_SECTION_ID_REQUISITE_CODE SYSRES_CONST_UNITS_SECTION_REQUISITE_CODE SYSRES_CONST_UNOPERATING_RECORD_FLAG_VALUE_CODE SYSRES_CONST_UNSTORED_DATA_REQUISITE_CODE SYSRES_CONST_UNSTORED_DATA_REQUISITE_NAME SYSRES_CONST_USE_ACCESS_TYPE_CODE SYSRES_CONST_USE_ACCESS_TYPE_NAME SYSRES_CONST_USER_ACCOUNT_TYPE_VALUE_CODE SYSRES_CONST_USER_ADDITIONAL_INFORMATION_REQUISITE_CODE SYSRES_CONST_USER_AND_GROUP_ID_FROM_PSEUDOREFERENCE_REQUISITE_CODE SYSRES_CONST_USER_CATEGORY_NORMAL SYSRES_CONST_USER_CERTIFICATE_REQUISITE_CODE SYSRES_CONST_USER_CERTIFICATE_STATE_REQUISITE_CODE SYSRES_CONST_USER_CERTIFICATE_SUBJECT_NAME_REQUISITE_CODE SYSRES_CONST_USER_CERTIFICATE_THUMBPRINT_REQUISITE_CODE SYSRES_CONST_USER_COMMON_CATEGORY SYSRES_CONST_USER_COMMON_CATEGORY_CODE SYSRES_CONST_USER_FULL_NAME_REQUISITE_CODE SYSRES_CONST_USER_GROUP_TYPE_REQUISITE_CODE SYSRES_CONST_USER_LOGIN_REQUISITE_CODE SYSRES_CONST_USER_REMOTE_CONTROLLER_REQUISITE_CODE SYSRES_CONST_USER_REMOTE_SYSTEM_REQUISITE_CODE SYSRES_CONST_USER_RIGHTS_T_REQUISITE_CODE SYSRES_CONST_USER_SERVER_NAME_REQUISITE_CODE SYSRES_CONST_USER_SERVICE_CATEGORY SYSRES_CONST_USER_SERVICE_CATEGORY_CODE SYSRES_CONST_USER_STATUS_ADMINISTRATOR_CODE SYSRES_CONST_USER_STATUS_ADMINISTRATOR_NAME SYSRES_CONST_USER_STATUS_DEVELOPER_CODE SYSRES_CONST_USER_STATUS_DEVELOPER_NAME SYSRES_CONST_USER_STATUS_DISABLED_CODE SYSRES_CONST_USER_STATUS_DISABLED_NAME SYSRES_CONST_USER_STATUS_SYSTEM_DEVELOPER_CODE SYSRES_CONST_USER_STATUS_USER_CODE SYSRES_CONST_USER_STATUS_USER_NAME SYSRES_CONST_USER_STATUS_USER_NAME_DEPRECATED SYSRES_CONST_USER_TYPE_FIELD_VALUE_USER SYSRES_CONST_USER_TYPE_REQUISITE_CODE SYSRES_CONST_USERS_CONTROLLER_REQUISITE_CODE SYSRES_CONST_USERS_IS_MAIN_SERVER_REQUISITE_CODE SYSRES_CONST_USERS_REFERENCE_CODE SYSRES_CONST_USERS_REGISTRATION_CERTIFICATES_ACTION_NAME SYSRES_CONST_USERS_REQUISITE_CODE SYSRES_CONST_USERS_SYSTEM_REQUISITE_CODE SYSRES_CONST_USERS_USER_ACCESS_RIGHTS_TYPR_REQUISITE_CODE SYSRES_CONST_USERS_USER_AUTHENTICATION_REQUISITE_CODE SYSRES_CONST_USERS_USER_COMPONENT_REQUISITE_CODE SYSRES_CONST_USERS_USER_GROUP_REQUISITE_CODE SYSRES_CONST_USERS_VIEW_CERTIFICATES_ACTION_NAME SYSRES_CONST_VIEW_DEFAULT_CODE SYSRES_CONST_VIEW_DEFAULT_NAME SYSRES_CONST_VIEWER_REQUISITE_CODE SYSRES_CONST_WAITING_BLOCK_DESCRIPTION SYSRES_CONST_WIZARD_FORM_LABEL_TEST_STRING SYSRES_CONST_WIZARD_QUERY_PARAM_HEIGHT_ETALON_STRING SYSRES_CONST_WIZARD_REFERENCE_COMMENT_REQUISITE_CODE SYSRES_CONST_WORK_RULES_DESCRIPTION_REQUISITE_CODE SYSRES_CONST_WORK_TIME_CALENDAR_REFERENCE_CODE SYSRES_CONST_WORK_WORKFLOW_HARD_ROUTE_TYPE_VALUE SYSRES_CONST_WORK_WORKFLOW_HARD_ROUTE_TYPE_VALUE_CODE SYSRES_CONST_WORK_WORKFLOW_HARD_ROUTE_TYPE_VALUE_CODE_RUS SYSRES_CONST_WORK_WORKFLOW_SOFT_ROUTE_TYPE_VALUE_CODE_RUS SYSRES_CONST_WORKFLOW_ROUTE_TYPR_HARD SYSRES_CONST_WORKFLOW_ROUTE_TYPR_SOFT SYSRES_CONST_XML_ENCODING SYSRES_CONST_XREC_STAT_REQUISITE_CODE SYSRES_CONST_XRECID_FIELD_NAME SYSRES_CONST_YES SYSRES_CONST_YES_NO_2_REQUISITE_CODE SYSRES_CONST_YES_NO_REQUISITE_CODE SYSRES_CONST_YES_NO_T_REF_TYPE_REQUISITE_CODE SYSRES_CONST_YES_PICK_VALUE SYSRES_CONST_YES_VALUE "+"CR FALSE nil NO_VALUE NULL TAB TRUE YES_VALUE "+"ADMINISTRATORS_GROUP_NAME CUSTOMIZERS_GROUP_NAME DEVELOPERS_GROUP_NAME SERVICE_USERS_GROUP_NAME "+"DECISION_BLOCK_FIRST_OPERAND_PROPERTY DECISION_BLOCK_NAME_PROPERTY DECISION_BLOCK_OPERATION_PROPERTY DECISION_BLOCK_RESULT_TYPE_PROPERTY DECISION_BLOCK_SECOND_OPERAND_PROPERTY "+"ANY_FILE_EXTENTION COMPRESSED_DOCUMENT_EXTENSION EXTENDED_DOCUMENT_EXTENSION SHORT_COMPRESSED_DOCUMENT_EXTENSION SHORT_EXTENDED_DOCUMENT_EXTENSION "+"JOB_BLOCK_ABORT_DEADLINE_PROPERTY JOB_BLOCK_AFTER_FINISH_EVENT JOB_BLOCK_AFTER_QUERY_PARAMETERS_EVENT JOB_BLOCK_ATTACHMENT_PROPERTY JOB_BLOCK_ATTACHMENTS_RIGHTS_GROUP_PROPERTY JOB_BLOCK_ATTACHMENTS_RIGHTS_TYPE_PROPERTY JOB_BLOCK_BEFORE_QUERY_PARAMETERS_EVENT JOB_BLOCK_BEFORE_START_EVENT JOB_BLOCK_CREATED_JOBS_PROPERTY JOB_BLOCK_DEADLINE_PROPERTY JOB_BLOCK_EXECUTION_RESULTS_PROPERTY JOB_BLOCK_IS_PARALLEL_PROPERTY JOB_BLOCK_IS_RELATIVE_ABORT_DEADLINE_PROPERTY JOB_BLOCK_IS_RELATIVE_DEADLINE_PROPERTY JOB_BLOCK_JOB_TEXT_PROPERTY JOB_BLOCK_NAME_PROPERTY JOB_BLOCK_NEED_SIGN_ON_PERFORM_PROPERTY JOB_BLOCK_PERFORMER_PROPERTY JOB_BLOCK_RELATIVE_ABORT_DEADLINE_TYPE_PROPERTY JOB_BLOCK_RELATIVE_DEADLINE_TYPE_PROPERTY JOB_BLOCK_SUBJECT_PROPERTY "+"ENGLISH_LANGUAGE_CODE RUSSIAN_LANGUAGE_CODE "+"smHidden smMaximized smMinimized smNormal wmNo wmYes "+"COMPONENT_TOKEN_LINK_KIND DOCUMENT_LINK_KIND EDOCUMENT_LINK_KIND FOLDER_LINK_KIND JOB_LINK_KIND REFERENCE_LINK_KIND TASK_LINK_KIND "+"COMPONENT_TOKEN_LOCK_TYPE EDOCUMENT_VERSION_LOCK_TYPE "+"MONITOR_BLOCK_AFTER_FINISH_EVENT MONITOR_BLOCK_BEFORE_START_EVENT MONITOR_BLOCK_DEADLINE_PROPERTY MONITOR_BLOCK_INTERVAL_PROPERTY MONITOR_BLOCK_INTERVAL_TYPE_PROPERTY MONITOR_BLOCK_IS_RELATIVE_DEADLINE_PROPERTY MONITOR_BLOCK_NAME_PROPERTY MONITOR_BLOCK_RELATIVE_DEADLINE_TYPE_PROPERTY MONITOR_BLOCK_SEARCH_SCRIPT_PROPERTY "+"NOTICE_BLOCK_AFTER_FINISH_EVENT NOTICE_BLOCK_ATTACHMENT_PROPERTY NOTICE_BLOCK_ATTACHMENTS_RIGHTS_GROUP_PROPERTY NOTICE_BLOCK_ATTACHMENTS_RIGHTS_TYPE_PROPERTY NOTICE_BLOCK_BEFORE_START_EVENT NOTICE_BLOCK_CREATED_NOTICES_PROPERTY NOTICE_BLOCK_DEADLINE_PROPERTY NOTICE_BLOCK_IS_RELATIVE_DEADLINE_PROPERTY NOTICE_BLOCK_NAME_PROPERTY NOTICE_BLOCK_NOTICE_TEXT_PROPERTY NOTICE_BLOCK_PERFORMER_PROPERTY NOTICE_BLOCK_RELATIVE_DEADLINE_TYPE_PROPERTY NOTICE_BLOCK_SUBJECT_PROPERTY "+"dseAfterCancel dseAfterClose dseAfterDelete dseAfterDeleteOutOfTransaction dseAfterInsert dseAfterOpen dseAfterScroll dseAfterUpdate dseAfterUpdateOutOfTransaction dseBeforeCancel dseBeforeClose dseBeforeDelete dseBeforeDetailUpdate dseBeforeInsert dseBeforeOpen dseBeforeUpdate dseOnAnyRequisiteChange dseOnCloseRecord dseOnDeleteError dseOnOpenRecord dseOnPrepareUpdate dseOnUpdateError dseOnUpdateRatifiedRecord dseOnValidDelete dseOnValidUpdate reOnChange reOnChangeValues SELECTION_BEGIN_ROUTE_EVENT SELECTION_END_ROUTE_EVENT "+"CURRENT_PERIOD_IS_REQUIRED PREVIOUS_CARD_TYPE_NAME SHOW_RECORD_PROPERTIES_FORM "+"ACCESS_RIGHTS_SETTING_DIALOG_CODE ADMINISTRATOR_USER_CODE ANALYTIC_REPORT_TYPE asrtHideLocal asrtHideRemote CALCULATED_ROLE_TYPE_CODE COMPONENTS_REFERENCE_DEVELOPER_VIEW_CODE DCTS_TEST_PROTOCOLS_FOLDER_PATH E_EDOC_VERSION_ALREADY_APPROVINGLY_SIGNED E_EDOC_VERSION_ALREADY_APPROVINGLY_SIGNED_BY_USER E_EDOC_VERSION_ALREDY_SIGNED E_EDOC_VERSION_ALREDY_SIGNED_BY_USER EDOC_TYPES_CODE_REQUISITE_FIELD_NAME EDOCUMENTS_ALIAS_NAME FILES_FOLDER_PATH FILTER_OPERANDS_DELIMITER FILTER_OPERATIONS_DELIMITER FORMCARD_NAME FORMLIST_NAME GET_EXTENDED_DOCUMENT_EXTENSION_CREATION_MODE GET_EXTENDED_DOCUMENT_EXTENSION_IMPORT_MODE INTEGRATED_REPORT_TYPE IS_BUILDER_APPLICATION_ROLE IS_BUILDER_APPLICATION_ROLE2 IS_BUILDER_USERS ISBSYSDEV LOG_FOLDER_PATH mbCancel mbNo mbNoToAll mbOK mbYes mbYesToAll MEMORY_DATASET_DESRIPTIONS_FILENAME mrNo mrNoToAll mrYes mrYesToAll MULTIPLE_SELECT_DIALOG_CODE NONOPERATING_RECORD_FLAG_FEMININE NONOPERATING_RECORD_FLAG_MASCULINE OPERATING_RECORD_FLAG_FEMININE OPERATING_RECORD_FLAG_MASCULINE PROFILING_SETTINGS_COMMON_SETTINGS_CODE_VALUE PROGRAM_INITIATED_LOOKUP_ACTION ratDelete ratEdit ratInsert REPORT_TYPE REQUIRED_PICK_VALUES_VARIABLE rmCard rmList SBRTE_PROGID_DEV SBRTE_PROGID_RELEASE STATIC_ROLE_TYPE_CODE SUPPRESS_EMPTY_TEMPLATE_CREATION SYSTEM_USER_CODE UPDATE_DIALOG_DATASET USED_IN_OBJECT_HINT_PARAM USER_INITIATED_LOOKUP_ACTION USER_NAME_FORMAT USER_SELECTION_RESTRICTIONS WORKFLOW_TEST_PROTOCOLS_FOLDER_PATH ELS_SUBTYPE_CONTROL_NAME ELS_FOLDER_KIND_CONTROL_NAME REPEAT_PROCESS_CURRENT_OBJECT_EXCEPTION_NAME "+"PRIVILEGE_COMPONENT_FULL_ACCESS PRIVILEGE_DEVELOPMENT_EXPORT PRIVILEGE_DEVELOPMENT_IMPORT PRIVILEGE_DOCUMENT_DELETE PRIVILEGE_ESD PRIVILEGE_FOLDER_DELETE PRIVILEGE_MANAGE_ACCESS_RIGHTS PRIVILEGE_MANAGE_REPLICATION PRIVILEGE_MANAGE_SESSION_SERVER PRIVILEGE_OBJECT_FULL_ACCESS PRIVILEGE_OBJECT_VIEW PRIVILEGE_RESERVE_LICENSE PRIVILEGE_SYSTEM_CUSTOMIZE PRIVILEGE_SYSTEM_DEVELOP PRIVILEGE_SYSTEM_INSTALL PRIVILEGE_TASK_DELETE PRIVILEGE_USER_PLUGIN_SETTINGS_CUSTOMIZE PRIVILEGES_PSEUDOREFERENCE_CODE "+"ACCESS_TYPES_PSEUDOREFERENCE_CODE ALL_AVAILABLE_COMPONENTS_PSEUDOREFERENCE_CODE ALL_AVAILABLE_PRIVILEGES_PSEUDOREFERENCE_CODE ALL_REPLICATE_COMPONENTS_PSEUDOREFERENCE_CODE AVAILABLE_DEVELOPERS_COMPONENTS_PSEUDOREFERENCE_CODE COMPONENTS_PSEUDOREFERENCE_CODE FILTRATER_SETTINGS_CONFLICTS_PSEUDOREFERENCE_CODE GROUPS_PSEUDOREFERENCE_CODE RECEIVE_PROTOCOL_PSEUDOREFERENCE_CODE REFERENCE_REQUISITE_PSEUDOREFERENCE_CODE REFERENCE_REQUISITES_PSEUDOREFERENCE_CODE REFTYPES_PSEUDOREFERENCE_CODE REPLICATION_SEANCES_DIARY_PSEUDOREFERENCE_CODE SEND_PROTOCOL_PSEUDOREFERENCE_CODE SUBSTITUTES_PSEUDOREFERENCE_CODE SYSTEM_SETTINGS_PSEUDOREFERENCE_CODE UNITS_PSEUDOREFERENCE_CODE USERS_PSEUDOREFERENCE_CODE VIEWERS_PSEUDOREFERENCE_CODE "+"CERTIFICATE_TYPE_ENCRYPT CERTIFICATE_TYPE_SIGN CERTIFICATE_TYPE_SIGN_AND_ENCRYPT "+"STORAGE_TYPE_FILE STORAGE_TYPE_NAS_CIFS STORAGE_TYPE_SAPERION STORAGE_TYPE_SQL_SERVER "+"COMPTYPE2_REQUISITE_DOCUMENTS_VALUE COMPTYPE2_REQUISITE_TASKS_VALUE COMPTYPE2_REQUISITE_FOLDERS_VALUE COMPTYPE2_REQUISITE_REFERENCES_VALUE "+"SYSREQ_CODE SYSREQ_COMPTYPE2 SYSREQ_CONST_AVAILABLE_FOR_WEB SYSREQ_CONST_COMMON_CODE SYSREQ_CONST_COMMON_VALUE SYSREQ_CONST_FIRM_CODE SYSREQ_CONST_FIRM_STATUS SYSREQ_CONST_FIRM_VALUE SYSREQ_CONST_SERVER_STATUS SYSREQ_CONTENTS SYSREQ_DATE_OPEN SYSREQ_DATE_CLOSE SYSREQ_DESCRIPTION SYSREQ_DESCRIPTION_LOCALIZE_ID SYSREQ_DOUBLE SYSREQ_EDOC_ACCESS_TYPE SYSREQ_EDOC_AUTHOR SYSREQ_EDOC_CREATED SYSREQ_EDOC_DELEGATE_RIGHTS_REQUISITE_CODE SYSREQ_EDOC_EDITOR SYSREQ_EDOC_ENCODE_TYPE SYSREQ_EDOC_ENCRYPTION_PLUGIN_NAME SYSREQ_EDOC_ENCRYPTION_PLUGIN_VERSION SYSREQ_EDOC_EXPORT_DATE SYSREQ_EDOC_EXPORTER SYSREQ_EDOC_KIND SYSREQ_EDOC_LIFE_STAGE_NAME SYSREQ_EDOC_LOCKED_FOR_SERVER_CODE SYSREQ_EDOC_MODIFIED SYSREQ_EDOC_NAME SYSREQ_EDOC_NOTE SYSREQ_EDOC_QUALIFIED_ID SYSREQ_EDOC_SESSION_KEY SYSREQ_EDOC_SESSION_KEY_ENCRYPTION_PLUGIN_NAME SYSREQ_EDOC_SESSION_KEY_ENCRYPTION_PLUGIN_VERSION SYSREQ_EDOC_SIGNATURE_TYPE SYSREQ_EDOC_SIGNED SYSREQ_EDOC_STORAGE SYSREQ_EDOC_STORAGES_ARCHIVE_STORAGE SYSREQ_EDOC_STORAGES_CHECK_RIGHTS SYSREQ_EDOC_STORAGES_COMPUTER_NAME SYSREQ_EDOC_STORAGES_EDIT_IN_STORAGE SYSREQ_EDOC_STORAGES_EXECUTIVE_STORAGE SYSREQ_EDOC_STORAGES_FUNCTION SYSREQ_EDOC_STORAGES_INITIALIZED SYSREQ_EDOC_STORAGES_LOCAL_PATH SYSREQ_EDOC_STORAGES_SAPERION_DATABASE_NAME SYSREQ_EDOC_STORAGES_SEARCH_BY_TEXT SYSREQ_EDOC_STORAGES_SERVER_NAME SYSREQ_EDOC_STORAGES_SHARED_SOURCE_NAME SYSREQ_EDOC_STORAGES_TYPE SYSREQ_EDOC_TEXT_MODIFIED SYSREQ_EDOC_TYPE_ACT_CODE SYSREQ_EDOC_TYPE_ACT_DESCRIPTION SYSREQ_EDOC_TYPE_ACT_DESCRIPTION_LOCALIZE_ID SYSREQ_EDOC_TYPE_ACT_ON_EXECUTE SYSREQ_EDOC_TYPE_ACT_ON_EXECUTE_EXISTS SYSREQ_EDOC_TYPE_ACT_SECTION SYSREQ_EDOC_TYPE_ADD_PARAMS SYSREQ_EDOC_TYPE_COMMENT SYSREQ_EDOC_TYPE_EVENT_TEXT SYSREQ_EDOC_TYPE_NAME_IN_SINGULAR SYSREQ_EDOC_TYPE_NAME_IN_SINGULAR_LOCALIZE_ID SYSREQ_EDOC_TYPE_NAME_LOCALIZE_ID SYSREQ_EDOC_TYPE_NUMERATION_METHOD SYSREQ_EDOC_TYPE_PSEUDO_REQUISITE_CODE SYSREQ_EDOC_TYPE_REQ_CODE SYSREQ_EDOC_TYPE_REQ_DESCRIPTION SYSREQ_EDOC_TYPE_REQ_DESCRIPTION_LOCALIZE_ID SYSREQ_EDOC_TYPE_REQ_IS_LEADING SYSREQ_EDOC_TYPE_REQ_IS_REQUIRED SYSREQ_EDOC_TYPE_REQ_NUMBER SYSREQ_EDOC_TYPE_REQ_ON_CHANGE SYSREQ_EDOC_TYPE_REQ_ON_CHANGE_EXISTS SYSREQ_EDOC_TYPE_REQ_ON_SELECT SYSREQ_EDOC_TYPE_REQ_ON_SELECT_KIND SYSREQ_EDOC_TYPE_REQ_SECTION SYSREQ_EDOC_TYPE_VIEW_CARD SYSREQ_EDOC_TYPE_VIEW_CODE SYSREQ_EDOC_TYPE_VIEW_COMMENT SYSREQ_EDOC_TYPE_VIEW_IS_MAIN SYSREQ_EDOC_TYPE_VIEW_NAME SYSREQ_EDOC_TYPE_VIEW_NAME_LOCALIZE_ID SYSREQ_EDOC_VERSION_AUTHOR SYSREQ_EDOC_VERSION_CRC SYSREQ_EDOC_VERSION_DATA SYSREQ_EDOC_VERSION_EDITOR SYSREQ_EDOC_VERSION_EXPORT_DATE SYSREQ_EDOC_VERSION_EXPORTER SYSREQ_EDOC_VERSION_HIDDEN SYSREQ_EDOC_VERSION_LIFE_STAGE SYSREQ_EDOC_VERSION_MODIFIED SYSREQ_EDOC_VERSION_NOTE SYSREQ_EDOC_VERSION_SIGNATURE_TYPE SYSREQ_EDOC_VERSION_SIGNED SYSREQ_EDOC_VERSION_SIZE SYSREQ_EDOC_VERSION_SOURCE SYSREQ_EDOC_VERSION_TEXT_MODIFIED SYSREQ_EDOCKIND_DEFAULT_VERSION_STATE_CODE SYSREQ_FOLDER_KIND SYSREQ_FUNC_CATEGORY SYSREQ_FUNC_COMMENT SYSREQ_FUNC_GROUP SYSREQ_FUNC_GROUP_COMMENT SYSREQ_FUNC_GROUP_NUMBER SYSREQ_FUNC_HELP SYSREQ_FUNC_PARAM_DEF_VALUE SYSREQ_FUNC_PARAM_IDENT SYSREQ_FUNC_PARAM_NUMBER SYSREQ_FUNC_PARAM_TYPE SYSREQ_FUNC_TEXT SYSREQ_GROUP_CATEGORY SYSREQ_ID SYSREQ_LAST_UPDATE SYSREQ_LEADER_REFERENCE SYSREQ_LINE_NUMBER SYSREQ_MAIN_RECORD_ID SYSREQ_NAME SYSREQ_NAME_LOCALIZE_ID SYSREQ_NOTE SYSREQ_ORIGINAL_RECORD SYSREQ_OUR_FIRM SYSREQ_PROFILING_SETTINGS_BATCH_LOGING SYSREQ_PROFILING_SETTINGS_BATCH_SIZE SYSREQ_PROFILING_SETTINGS_PROFILING_ENABLED SYSREQ_PROFILING_SETTINGS_SQL_PROFILING_ENABLED SYSREQ_PROFILING_SETTINGS_START_LOGGED SYSREQ_RECORD_STATUS SYSREQ_REF_REQ_FIELD_NAME SYSREQ_REF_REQ_FORMAT SYSREQ_REF_REQ_GENERATED SYSREQ_REF_REQ_LENGTH SYSREQ_REF_REQ_PRECISION SYSREQ_REF_REQ_REFERENCE SYSREQ_REF_REQ_SECTION SYSREQ_REF_REQ_STORED SYSREQ_REF_REQ_TOKENS SYSREQ_REF_REQ_TYPE SYSREQ_REF_REQ_VIEW SYSREQ_REF_TYPE_ACT_CODE SYSREQ_REF_TYPE_ACT_DESCRIPTION SYSREQ_REF_TYPE_ACT_DESCRIPTION_LOCALIZE_ID SYSREQ_REF_TYPE_ACT_ON_EXECUTE SYSREQ_REF_TYPE_ACT_ON_EXECUTE_EXISTS SYSREQ_REF_TYPE_ACT_SECTION SYSREQ_REF_TYPE_ADD_PARAMS SYSREQ_REF_TYPE_COMMENT SYSREQ_REF_TYPE_COMMON_SETTINGS SYSREQ_REF_TYPE_DISPLAY_REQUISITE_NAME SYSREQ_REF_TYPE_EVENT_TEXT SYSREQ_REF_TYPE_MAIN_LEADING_REF SYSREQ_REF_TYPE_NAME_IN_SINGULAR SYSREQ_REF_TYPE_NAME_IN_SINGULAR_LOCALIZE_ID SYSREQ_REF_TYPE_NAME_LOCALIZE_ID SYSREQ_REF_TYPE_NUMERATION_METHOD SYSREQ_REF_TYPE_REQ_CODE SYSREQ_REF_TYPE_REQ_DESCRIPTION SYSREQ_REF_TYPE_REQ_DESCRIPTION_LOCALIZE_ID SYSREQ_REF_TYPE_REQ_IS_CONTROL SYSREQ_REF_TYPE_REQ_IS_FILTER SYSREQ_REF_TYPE_REQ_IS_LEADING SYSREQ_REF_TYPE_REQ_IS_REQUIRED SYSREQ_REF_TYPE_REQ_NUMBER SYSREQ_REF_TYPE_REQ_ON_CHANGE SYSREQ_REF_TYPE_REQ_ON_CHANGE_EXISTS SYSREQ_REF_TYPE_REQ_ON_SELECT SYSREQ_REF_TYPE_REQ_ON_SELECT_KIND SYSREQ_REF_TYPE_REQ_SECTION SYSREQ_REF_TYPE_VIEW_CARD SYSREQ_REF_TYPE_VIEW_CODE SYSREQ_REF_TYPE_VIEW_COMMENT SYSREQ_REF_TYPE_VIEW_IS_MAIN SYSREQ_REF_TYPE_VIEW_NAME SYSREQ_REF_TYPE_VIEW_NAME_LOCALIZE_ID SYSREQ_REFERENCE_TYPE_ID SYSREQ_STATE SYSREQ_STATЕ SYSREQ_SYSTEM_SETTINGS_VALUE SYSREQ_TYPE SYSREQ_UNIT SYSREQ_UNIT_ID SYSREQ_USER_GROUPS_GROUP_FULL_NAME SYSREQ_USER_GROUPS_GROUP_NAME SYSREQ_USER_GROUPS_GROUP_SERVER_NAME SYSREQ_USERS_ACCESS_RIGHTS SYSREQ_USERS_AUTHENTICATION SYSREQ_USERS_CATEGORY SYSREQ_USERS_COMPONENT SYSREQ_USERS_COMPONENT_USER_IS_PUBLIC SYSREQ_USERS_DOMAIN SYSREQ_USERS_FULL_USER_NAME SYSREQ_USERS_GROUP SYSREQ_USERS_IS_MAIN_SERVER SYSREQ_USERS_LOGIN SYSREQ_USERS_REFERENCE_USER_IS_PUBLIC SYSREQ_USERS_STATUS SYSREQ_USERS_USER_CERTIFICATE SYSREQ_USERS_USER_CERTIFICATE_INFO SYSREQ_USERS_USER_CERTIFICATE_PLUGIN_NAME SYSREQ_USERS_USER_CERTIFICATE_PLUGIN_VERSION SYSREQ_USERS_USER_CERTIFICATE_STATE SYSREQ_USERS_USER_CERTIFICATE_SUBJECT_NAME SYSREQ_USERS_USER_CERTIFICATE_THUMBPRINT SYSREQ_USERS_USER_DEFAULT_CERTIFICATE SYSREQ_USERS_USER_DESCRIPTION SYSREQ_USERS_USER_GLOBAL_NAME SYSREQ_USERS_USER_LOGIN SYSREQ_USERS_USER_MAIN_SERVER SYSREQ_USERS_USER_TYPE SYSREQ_WORK_RULES_FOLDER_ID "+"RESULT_VAR_NAME RESULT_VAR_NAME_ENG "+"AUTO_NUMERATION_RULE_ID CANT_CHANGE_ID_REQUISITE_RULE_ID CANT_CHANGE_OURFIRM_REQUISITE_RULE_ID CHECK_CHANGING_REFERENCE_RECORD_USE_RULE_ID CHECK_CODE_REQUISITE_RULE_ID CHECK_DELETING_REFERENCE_RECORD_USE_RULE_ID CHECK_FILTRATER_CHANGES_RULE_ID CHECK_RECORD_INTERVAL_RULE_ID CHECK_REFERENCE_INTERVAL_RULE_ID CHECK_REQUIRED_DATA_FULLNESS_RULE_ID CHECK_REQUIRED_REQUISITES_FULLNESS_RULE_ID MAKE_RECORD_UNRATIFIED_RULE_ID RESTORE_AUTO_NUMERATION_RULE_ID SET_FIRM_CONTEXT_FROM_RECORD_RULE_ID SET_FIRST_RECORD_IN_LIST_FORM_RULE_ID SET_IDSPS_VALUE_RULE_ID SET_NEXT_CODE_VALUE_RULE_ID SET_OURFIRM_BOUNDS_RULE_ID SET_OURFIRM_REQUISITE_RULE_ID "+"SCRIPT_BLOCK_AFTER_FINISH_EVENT SCRIPT_BLOCK_BEFORE_START_EVENT SCRIPT_BLOCK_EXECUTION_RESULTS_PROPERTY SCRIPT_BLOCK_NAME_PROPERTY SCRIPT_BLOCK_SCRIPT_PROPERTY "+"SUBTASK_BLOCK_ABORT_DEADLINE_PROPERTY SUBTASK_BLOCK_AFTER_FINISH_EVENT SUBTASK_BLOCK_ASSIGN_PARAMS_EVENT SUBTASK_BLOCK_ATTACHMENTS_PROPERTY SUBTASK_BLOCK_ATTACHMENTS_RIGHTS_GROUP_PROPERTY SUBTASK_BLOCK_ATTACHMENTS_RIGHTS_TYPE_PROPERTY SUBTASK_BLOCK_BEFORE_START_EVENT SUBTASK_BLOCK_CREATED_TASK_PROPERTY SUBTASK_BLOCK_CREATION_EVENT SUBTASK_BLOCK_DEADLINE_PROPERTY SUBTASK_BLOCK_IMPORTANCE_PROPERTY SUBTASK_BLOCK_INITIATOR_PROPERTY SUBTASK_BLOCK_IS_RELATIVE_ABORT_DEADLINE_PROPERTY SUBTASK_BLOCK_IS_RELATIVE_DEADLINE_PROPERTY SUBTASK_BLOCK_JOBS_TYPE_PROPERTY SUBTASK_BLOCK_NAME_PROPERTY SUBTASK_BLOCK_PARALLEL_ROUTE_PROPERTY SUBTASK_BLOCK_PERFORMERS_PROPERTY SUBTASK_BLOCK_RELATIVE_ABORT_DEADLINE_TYPE_PROPERTY SUBTASK_BLOCK_RELATIVE_DEADLINE_TYPE_PROPERTY SUBTASK_BLOCK_REQUIRE_SIGN_PROPERTY SUBTASK_BLOCK_STANDARD_ROUTE_PROPERTY SUBTASK_BLOCK_START_EVENT SUBTASK_BLOCK_STEP_CONTROL_PROPERTY SUBTASK_BLOCK_SUBJECT_PROPERTY SUBTASK_BLOCK_TASK_CONTROL_PROPERTY SUBTASK_BLOCK_TEXT_PROPERTY SUBTASK_BLOCK_UNLOCK_ATTACHMENTS_ON_STOP_PROPERTY SUBTASK_BLOCK_USE_STANDARD_ROUTE_PROPERTY SUBTASK_BLOCK_WAIT_FOR_TASK_COMPLETE_PROPERTY "+"SYSCOMP_CONTROL_JOBS SYSCOMP_FOLDERS SYSCOMP_JOBS SYSCOMP_NOTICES SYSCOMP_TASKS "+"SYSDLG_CREATE_EDOCUMENT SYSDLG_CREATE_EDOCUMENT_VERSION SYSDLG_CURRENT_PERIOD SYSDLG_EDIT_FUNCTION_HELP SYSDLG_EDOCUMENT_KINDS_FOR_TEMPLATE SYSDLG_EXPORT_MULTIPLE_EDOCUMENTS SYSDLG_EXPORT_SINGLE_EDOCUMENT SYSDLG_IMPORT_EDOCUMENT SYSDLG_MULTIPLE_SELECT SYSDLG_SETUP_ACCESS_RIGHTS SYSDLG_SETUP_DEFAULT_RIGHTS SYSDLG_SETUP_FILTER_CONDITION SYSDLG_SETUP_SIGN_RIGHTS SYSDLG_SETUP_TASK_OBSERVERS SYSDLG_SETUP_TASK_ROUTE SYSDLG_SETUP_USERS_LIST SYSDLG_SIGN_EDOCUMENT SYSDLG_SIGN_MULTIPLE_EDOCUMENTS "+"SYSREF_ACCESS_RIGHTS_TYPES SYSREF_ADMINISTRATION_HISTORY SYSREF_ALL_AVAILABLE_COMPONENTS SYSREF_ALL_AVAILABLE_PRIVILEGES SYSREF_ALL_REPLICATING_COMPONENTS SYSREF_AVAILABLE_DEVELOPERS_COMPONENTS SYSREF_CALENDAR_EVENTS SYSREF_COMPONENT_TOKEN_HISTORY SYSREF_COMPONENT_TOKENS SYSREF_COMPONENTS SYSREF_CONSTANTS SYSREF_DATA_RECEIVE_PROTOCOL SYSREF_DATA_SEND_PROTOCOL SYSREF_DIALOGS SYSREF_DIALOGS_REQUISITES SYSREF_EDITORS SYSREF_EDOC_CARDS SYSREF_EDOC_TYPES SYSREF_EDOCUMENT_CARD_REQUISITES SYSREF_EDOCUMENT_CARD_TYPES SYSREF_EDOCUMENT_CARD_TYPES_REFERENCE SYSREF_EDOCUMENT_CARDS SYSREF_EDOCUMENT_HISTORY SYSREF_EDOCUMENT_KINDS SYSREF_EDOCUMENT_REQUISITES SYSREF_EDOCUMENT_SIGNATURES SYSREF_EDOCUMENT_TEMPLATES SYSREF_EDOCUMENT_TEXT_STORAGES SYSREF_EDOCUMENT_VIEWS SYSREF_FILTERER_SETUP_CONFLICTS SYSREF_FILTRATER_SETTING_CONFLICTS SYSREF_FOLDER_HISTORY SYSREF_FOLDERS SYSREF_FUNCTION_GROUPS SYSREF_FUNCTION_PARAMS SYSREF_FUNCTIONS SYSREF_JOB_HISTORY SYSREF_LINKS SYSREF_LOCALIZATION_DICTIONARY SYSREF_LOCALIZATION_LANGUAGES SYSREF_MODULES SYSREF_PRIVILEGES SYSREF_RECORD_HISTORY SYSREF_REFERENCE_REQUISITES SYSREF_REFERENCE_TYPE_VIEWS SYSREF_REFERENCE_TYPES SYSREF_REFERENCES SYSREF_REFERENCES_REQUISITES SYSREF_REMOTE_SERVERS SYSREF_REPLICATION_SESSIONS_LOG SYSREF_REPLICATION_SESSIONS_PROTOCOL SYSREF_REPORTS SYSREF_ROLES SYSREF_ROUTE_BLOCK_GROUPS SYSREF_ROUTE_BLOCKS SYSREF_SCRIPTS SYSREF_SEARCHES SYSREF_SERVER_EVENTS SYSREF_SERVER_EVENTS_HISTORY SYSREF_STANDARD_ROUTE_GROUPS SYSREF_STANDARD_ROUTES SYSREF_STATUSES SYSREF_SYSTEM_SETTINGS SYSREF_TASK_HISTORY SYSREF_TASK_KIND_GROUPS SYSREF_TASK_KINDS SYSREF_TASK_RIGHTS SYSREF_TASK_SIGNATURES SYSREF_TASKS SYSREF_UNITS SYSREF_USER_GROUPS SYSREF_USER_GROUPS_REFERENCE SYSREF_USER_SUBSTITUTION SYSREF_USERS SYSREF_USERS_REFERENCE SYSREF_VIEWERS SYSREF_WORKING_TIME_CALENDARS "+"ACCESS_RIGHTS_TABLE_NAME EDMS_ACCESS_TABLE_NAME EDOC_TYPES_TABLE_NAME "+"TEST_DEV_DB_NAME TEST_DEV_SYSTEM_CODE TEST_EDMS_DB_NAME TEST_EDMS_MAIN_CODE TEST_EDMS_MAIN_DB_NAME TEST_EDMS_SECOND_CODE TEST_EDMS_SECOND_DB_NAME TEST_EDMS_SYSTEM_CODE TEST_ISB5_MAIN_CODE TEST_ISB5_SECOND_CODE TEST_SQL_SERVER_2005_NAME TEST_SQL_SERVER_NAME "+"ATTENTION_CAPTION cbsCommandLinks cbsDefault CONFIRMATION_CAPTION ERROR_CAPTION INFORMATION_CAPTION mrCancel mrOk "+"EDOC_VERSION_ACTIVE_STAGE_CODE EDOC_VERSION_DESIGN_STAGE_CODE EDOC_VERSION_OBSOLETE_STAGE_CODE "+"cpDataEnciphermentEnabled cpDigitalSignatureEnabled cpID cpIssuer cpPluginVersion cpSerial cpSubjectName cpSubjSimpleName cpValidFromDate cpValidToDate "+"ISBL_SYNTAX NO_SYNTAX XML_SYNTAX "+"WAIT_BLOCK_AFTER_FINISH_EVENT WAIT_BLOCK_BEFORE_START_EVENT WAIT_BLOCK_DEADLINE_PROPERTY WAIT_BLOCK_IS_RELATIVE_DEADLINE_PROPERTY WAIT_BLOCK_NAME_PROPERTY WAIT_BLOCK_RELATIVE_DEADLINE_TYPE_PROPERTY "+"SYSRES_COMMON SYSRES_CONST SYSRES_MBFUNC SYSRES_SBDATA SYSRES_SBGUI SYSRES_SBINTF SYSRES_SBREFDSC SYSRES_SQLERRORS SYSRES_SYSCOMP ",Ql="atUser atGroup atRole "+"aemEnabledAlways aemDisabledAlways aemEnabledOnBrowse aemEnabledOnEdit aemDisabledOnBrowseEmpty "+"apBegin apEnd "+"alLeft alRight "+"asmNever asmNoButCustomize asmAsLastTime asmYesButCustomize asmAlways "+"cirCommon cirRevoked "+"ctSignature ctEncode ctSignatureEncode "+"clbUnchecked clbChecked clbGrayed "+"ceISB ceAlways ceNever "+"ctDocument ctReference ctScript ctUnknown ctReport ctDialog ctFunction ctFolder ctEDocument ctTask ctJob ctNotice ctControlJob "+"cfInternal cfDisplay "+"ciUnspecified ciWrite ciRead "+"ckFolder ckEDocument ckTask ckJob ckComponentToken ckAny ckReference ckScript ckReport ckDialog "+"ctISBLEditor ctBevel ctButton ctCheckListBox ctComboBox ctComboEdit ctGrid ctDBCheckBox ctDBComboBox ctDBEdit ctDBEllipsis ctDBMemo ctDBNavigator ctDBRadioGroup ctDBStatusLabel ctEdit ctGroupBox ctInplaceHint ctMemo ctPanel ctListBox ctRadioButton ctRichEdit ctTabSheet ctWebBrowser ctImage ctHyperLink ctLabel ctDBMultiEllipsis ctRibbon ctRichView ctInnerPanel ctPanelGroup ctBitButton "+"cctDate cctInteger cctNumeric cctPick cctReference cctString cctText "+"cltInternal cltPrimary cltGUI "+"dseBeforeOpen dseAfterOpen dseBeforeClose dseAfterClose dseOnValidDelete dseBeforeDelete dseAfterDelete dseAfterDeleteOutOfTransaction dseOnDeleteError dseBeforeInsert dseAfterInsert dseOnValidUpdate dseBeforeUpdate dseOnUpdateRatifiedRecord dseAfterUpdate dseAfterUpdateOutOfTransaction dseOnUpdateError dseAfterScroll dseOnOpenRecord dseOnCloseRecord dseBeforeCancel dseAfterCancel dseOnUpdateDeadlockError dseBeforeDetailUpdate dseOnPrepareUpdate dseOnAnyRequisiteChange "+"dssEdit dssInsert dssBrowse dssInActive "+"dftDate dftShortDate dftDateTime dftTimeStamp "+"dotDays dotHours dotMinutes dotSeconds "+"dtkndLocal dtkndUTC "+"arNone arView arEdit arFull "+"ddaView ddaEdit "+"emLock emEdit emSign emExportWithLock emImportWithUnlock emChangeVersionNote emOpenForModify emChangeLifeStage emDelete emCreateVersion emImport emUnlockExportedWithLock emStart emAbort emReInit emMarkAsReaded emMarkAsUnreaded emPerform emAccept emResume emChangeRights emEditRoute emEditObserver emRecoveryFromLocalCopy emChangeWorkAccessType emChangeEncodeTypeToCertificate emChangeEncodeTypeToPassword emChangeEncodeTypeToNone emChangeEncodeTypeToCertificatePassword emChangeStandardRoute emGetText emOpenForView emMoveToStorage emCreateObject emChangeVersionHidden emDeleteVersion emChangeLifeCycleStage emApprovingSign emExport emContinue emLockFromEdit emUnLockForEdit emLockForServer emUnlockFromServer emDelegateAccessRights emReEncode "+"ecotFile ecotProcess "+"eaGet eaCopy eaCreate eaCreateStandardRoute "+"edltAll edltNothing edltQuery "+"essmText essmCard "+"esvtLast esvtLastActive esvtSpecified "+"edsfExecutive edsfArchive "+"edstSQLServer edstFile "+"edvstNone edvstEDocumentVersionCopy edvstFile edvstTemplate edvstScannedFile "+"vsDefault vsDesign vsActive vsObsolete "+"etNone etCertificate etPassword etCertificatePassword "+"ecException ecWarning ecInformation "+"estAll estApprovingOnly "+"evtLast evtLastActive evtQuery "+"fdtString fdtNumeric fdtInteger fdtDate fdtText fdtUnknown fdtWideString fdtLargeInteger "+"ftInbox ftOutbox ftFavorites ftCommonFolder ftUserFolder ftComponents ftQuickLaunch ftShortcuts ftSearch "+"grhAuto grhX1 grhX2 grhX3 "+"hltText hltRTF hltHTML "+"iffBMP iffJPEG iffMultiPageTIFF iffSinglePageTIFF iffTIFF iffPNG "+"im8bGrayscale im24bRGB im1bMonochrome "+"itBMP itJPEG itWMF itPNG "+"ikhInformation ikhWarning ikhError ikhNoIcon "+"icUnknown icScript icFunction icIntegratedReport icAnalyticReport icDataSetEventHandler icActionHandler icFormEventHandler icLookUpEventHandler icRequisiteChangeEventHandler icBeforeSearchEventHandler icRoleCalculation icSelectRouteEventHandler icBlockPropertyCalculation icBlockQueryParamsEventHandler icChangeSearchResultEventHandler icBlockEventHandler icSubTaskInitEventHandler icEDocDataSetEventHandler icEDocLookUpEventHandler icEDocActionHandler icEDocFormEventHandler icEDocRequisiteChangeEventHandler icStructuredConversionRule icStructuredConversionEventBefore icStructuredConversionEventAfter icWizardEventHandler icWizardFinishEventHandler icWizardStepEventHandler icWizardStepFinishEventHandler icWizardActionEnableEventHandler icWizardActionExecuteEventHandler icCreateJobsHandler icCreateNoticesHandler icBeforeLookUpEventHandler icAfterLookUpEventHandler icTaskAbortEventHandler icWorkflowBlockActionHandler icDialogDataSetEventHandler icDialogActionHandler icDialogLookUpEventHandler icDialogRequisiteChangeEventHandler icDialogFormEventHandler icDialogValidCloseEventHandler icBlockFormEventHandler icTaskFormEventHandler icReferenceMethod icEDocMethod icDialogMethod icProcessMessageHandler "+"isShow isHide isByUserSettings "+"jkJob jkNotice jkControlJob "+"jtInner jtLeft jtRight jtFull jtCross "+"lbpAbove lbpBelow lbpLeft lbpRight "+"eltPerConnection eltPerUser "+"sfcUndefined sfcBlack sfcGreen sfcRed sfcBlue sfcOrange sfcLilac "+"sfsItalic sfsStrikeout sfsNormal "+"ldctStandardRoute ldctWizard ldctScript ldctFunction ldctRouteBlock ldctIntegratedReport ldctAnalyticReport ldctReferenceType ldctEDocumentType ldctDialog ldctServerEvents "+"mrcrtNone mrcrtUser mrcrtMaximal mrcrtCustom "+"vtEqual vtGreaterOrEqual vtLessOrEqual vtRange "+"rdYesterday rdToday rdTomorrow rdThisWeek rdThisMonth rdThisYear rdNextMonth rdNextWeek rdLastWeek rdLastMonth "+"rdWindow rdFile rdPrinter "+"rdtString rdtNumeric rdtInteger rdtDate rdtReference rdtAccount rdtText rdtPick rdtUnknown rdtLargeInteger rdtDocument "+"reOnChange reOnChangeValues "+"ttGlobal ttLocal ttUser ttSystem "+"ssmBrowse ssmSelect ssmMultiSelect ssmBrowseModal "+"smSelect smLike smCard "+"stNone stAuthenticating stApproving "+"sctString sctStream "+"sstAnsiSort sstNaturalSort "+"svtEqual svtContain "+"soatString soatNumeric soatInteger soatDatetime soatReferenceRecord soatText soatPick soatBoolean soatEDocument soatAccount soatIntegerCollection soatNumericCollection soatStringCollection soatPickCollection soatDatetimeCollection soatBooleanCollection soatReferenceRecordCollection soatEDocumentCollection soatAccountCollection soatContents soatUnknown "+"tarAbortByUser tarAbortByWorkflowException "+"tvtAllWords tvtExactPhrase tvtAnyWord "+"usNone usCompleted usRedSquare usBlueSquare usYellowSquare usGreenSquare usOrangeSquare usPurpleSquare usFollowUp "+"utUnknown utUser utDeveloper utAdministrator utSystemDeveloper utDisconnected "+"btAnd btDetailAnd btOr btNotOr btOnly "+"vmView vmSelect vmNavigation "+"vsmSingle vsmMultiple vsmMultipleCheck vsmNoSelection "+"wfatPrevious wfatNext wfatCancel wfatFinish "+"wfepUndefined wfepText3 wfepText6 wfepText9 wfepSpinEdit wfepDropDown wfepRadioGroup wfepFlag wfepText12 wfepText15 wfepText18 wfepText21 wfepText24 wfepText27 wfepText30 wfepRadioGroupColumn1 wfepRadioGroupColumn2 wfepRadioGroupColumn3 "+"wfetQueryParameter wfetText wfetDelimiter wfetLabel "+"wptString wptInteger wptNumeric wptBoolean wptDateTime wptPick wptText wptUser wptUserList wptEDocumentInfo wptEDocumentInfoList wptReferenceRecordInfo wptReferenceRecordInfoList wptFolderInfo wptTaskInfo wptContents wptFileName wptDate "+"wsrComplete wsrGoNext wsrGoPrevious wsrCustom wsrCancel wsrGoFinal "+"wstForm wstEDocument wstTaskCard wstReferenceRecordCard wstFinal "+"waAll waPerformers waManual "+"wsbStart wsbFinish wsbNotice wsbStep wsbDecision wsbWait wsbMonitor wsbScript wsbConnector wsbSubTask wsbLifeCycleStage wsbPause "+"wdtInteger wdtFloat wdtString wdtPick wdtDateTime wdtBoolean wdtTask wdtJob wdtFolder wdtEDocument wdtReferenceRecord wdtUser wdtGroup wdtRole wdtIntegerCollection wdtFloatCollection wdtStringCollection wdtPickCollection wdtDateTimeCollection wdtBooleanCollection wdtTaskCollection wdtJobCollection wdtFolderCollection wdtEDocumentCollection wdtReferenceRecordCollection wdtUserCollection wdtGroupCollection wdtRoleCollection wdtContents wdtUserList wdtSearchDescription wdtDeadLine wdtPickSet wdtAccountCollection "+"wiLow wiNormal wiHigh "+"wrtSoft wrtHard "+"wsInit wsRunning wsDone wsControlled wsAborted wsContinued "+"wtmFull wtmFromCurrent wtmOnlyCurrent ",_o="AddSubString AdjustLineBreaks AmountInWords Analysis ArrayDimCount ArrayHighBound ArrayLowBound ArrayOf ArrayReDim Assert Assigned BeginOfMonth BeginOfPeriod BuildProfilingOperationAnalysis CallProcedure CanReadFile CArrayElement CDataSetRequisite ChangeDate ChangeReferenceDataset Char CharPos CheckParam CheckParamValue CompareStrings ConstantExists ControlState ConvertDateStr Copy CopyFile CreateArray CreateCachedReference CreateConnection CreateDialog CreateDualListDialog CreateEditor CreateException CreateFile CreateFolderDialog CreateInputDialog CreateLinkFile CreateList CreateLock CreateMemoryDataSet CreateObject CreateOpenDialog CreateProgress CreateQuery CreateReference CreateReport CreateSaveDialog CreateScript CreateSQLPivotFunction CreateStringList CreateTreeListSelectDialog CSelectSQL CSQL CSubString CurrentUserID CurrentUserName CurrentVersion DataSetLocateEx DateDiff DateTimeDiff DateToStr DayOfWeek DeleteFile DirectoryExists DisableCheckAccessRights DisableCheckFullShowingRestriction DisableMassTaskSendingRestrictions DropTable DupeString EditText EnableCheckAccessRights EnableCheckFullShowingRestriction EnableMassTaskSendingRestrictions EndOfMonth EndOfPeriod ExceptionExists ExceptionsOff ExceptionsOn Execute ExecuteProcess Exit ExpandEnvironmentVariables ExtractFileDrive ExtractFileExt ExtractFileName ExtractFilePath ExtractParams FileExists FileSize FindFile FindSubString FirmContext ForceDirectories Format FormatDate FormatNumeric FormatSQLDate FormatString FreeException GetComponent GetComponentLaunchParam GetConstant GetLastException GetReferenceRecord GetRefTypeByRefID GetTableID GetTempFolder IfThen In IndexOf InputDialog InputDialogEx InteractiveMode IsFileLocked IsGraphicFile IsNumeric Length LoadString LoadStringFmt LocalTimeToUTC LowerCase Max MessageBox MessageBoxEx MimeDecodeBinary MimeDecodeString MimeEncodeBinary MimeEncodeString Min MoneyInWords MoveFile NewID Now OpenFile Ord Precision Raise ReadCertificateFromFile ReadFile ReferenceCodeByID ReferenceNumber ReferenceRequisiteMode ReferenceRequisiteValue RegionDateSettings RegionNumberSettings RegionTimeSettings RegRead RegWrite RenameFile Replace Round SelectServerCode SelectSQL ServerDateTime SetConstant SetManagedFolderFieldsState ShowConstantsInputDialog ShowMessage Sleep Split SQL SQL2XLSTAB SQLProfilingSendReport StrToDate SubString SubStringCount SystemSetting Time TimeDiff Today Transliterate Trim UpperCase UserStatus UTCToLocalTime ValidateXML VarIsClear VarIsEmpty VarIsNull WorkTimeDiff WriteFile WriteFileEx WriteObjectHistory Анализ БазаДанных БлокЕсть БлокЕстьРасш БлокИнфо БлокСнять БлокСнятьРасш БлокУстановить Ввод ВводМеню ВедС ВедСпр ВерхняяГраницаМассива ВнешПрогр Восст ВременнаяПапка Время ВыборSQL ВыбратьЗапись ВыделитьСтр Вызвать Выполнить ВыпПрогр ГрафическийФайл ГруппаДополнительно ДатаВремяСерв ДеньНедели ДиалогДаНет ДлинаСтр ДобПодстр ЕПусто ЕслиТо ЕЧисло ЗамПодстр ЗаписьСправочника ЗначПоляСпр ИДТипСпр ИзвлечьДиск ИзвлечьИмяФайла ИзвлечьПуть ИзвлечьРасширение ИзмДат ИзменитьРазмерМассива ИзмеренийМассива ИмяОрг ИмяПоляСпр Индекс ИндикаторЗакрыть ИндикаторОткрыть ИндикаторШаг ИнтерактивныйРежим ИтогТблСпр КодВидВедСпр КодВидСпрПоИД КодПоAnalit КодСимвола КодСпр КолПодстр КолПроп КонМес Конст КонстЕсть КонстЗнач КонТран КопироватьФайл КопияСтр КПериод КСтрТблСпр Макс МаксСтрТблСпр Массив Меню МенюРасш Мин НаборДанныхНайтиРасш НаимВидСпр НаимПоAnalit НаимСпр НастроитьПереводыСтрок НачМес НачТран НижняяГраницаМассива НомерСпр НПериод Окно Окр Окружение ОтлИнфДобавить ОтлИнфУдалить Отчет ОтчетАнал ОтчетИнт ПапкаСуществует Пауза ПВыборSQL ПереименоватьФайл Переменные ПереместитьФайл Подстр ПоискПодстр ПоискСтр ПолучитьИДТаблицы ПользовательДополнительно ПользовательИД ПользовательИмя ПользовательСтатус Прервать ПроверитьПараметр ПроверитьПараметрЗнач ПроверитьУсловие РазбСтр РазнВремя РазнДат РазнДатаВремя РазнРабВремя РегУстВрем РегУстДат РегУстЧсл РедТекст РеестрЗапись РеестрСписокИменПарам РеестрЧтение РеквСпр РеквСпрПр Сегодня Сейчас Сервер СерверПроцессИД СертификатФайлСчитать СжПроб Символ СистемаДиректумКод СистемаИнформация СистемаКод Содержит СоединениеЗакрыть СоединениеОткрыть СоздатьДиалог СоздатьДиалогВыбораИзДвухСписков СоздатьДиалогВыбораПапки СоздатьДиалогОткрытияФайла СоздатьДиалогСохраненияФайла СоздатьЗапрос СоздатьИндикатор СоздатьИсключение СоздатьКэшированныйСправочник СоздатьМассив СоздатьНаборДанных СоздатьОбъект СоздатьОтчет СоздатьПапку СоздатьРедактор СоздатьСоединение СоздатьСписок СоздатьСписокСтрок СоздатьСправочник СоздатьСценарий СоздСпр СостСпр Сохр СохрСпр СписокСистем Спр Справочник СпрБлокЕсть СпрБлокСнять СпрБлокСнятьРасш СпрБлокУстановить СпрИзмНабДан СпрКод СпрНомер СпрОбновить СпрОткрыть СпрОтменить СпрПарам СпрПолеЗнач СпрПолеИмя СпрРекв СпрРеквВведЗн СпрРеквНовые СпрРеквПр СпрРеквПредЗн СпрРеквРежим СпрРеквТипТекст СпрСоздать СпрСост СпрСохранить СпрТблИтог СпрТблСтр СпрТблСтрКол СпрТблСтрМакс СпрТблСтрМин СпрТблСтрПред СпрТблСтрСлед СпрТблСтрСозд СпрТблСтрУд СпрТекПредст СпрУдалить СравнитьСтр СтрВерхРегистр СтрНижнРегистр СтрТблСпр СумПроп Сценарий СценарийПарам ТекВерсия ТекОрг Точн Тран Транслитерация УдалитьТаблицу УдалитьФайл УдСпр УдСтрТблСпр Уст УстановкиКонстант ФайлАтрибутСчитать ФайлАтрибутУстановить ФайлВремя ФайлВремяУстановить ФайлВыбрать ФайлЗанят ФайлЗаписать ФайлИскать ФайлКопировать ФайлМожноЧитать ФайлОткрыть ФайлПереименовать ФайлПерекодировать ФайлПереместить ФайлПросмотреть ФайлРазмер ФайлСоздать ФайлСсылкаСоздать ФайлСуществует ФайлСчитать ФайлУдалить ФмтSQLДат ФмтДат ФмтСтр ФмтЧсл Формат ЦМассивЭлемент ЦНаборДанныхРеквизит ЦПодстр ",Zl="AltState Application CallType ComponentTokens CreatedJobs CreatedNotices ControlState DialogResult Dialogs EDocuments EDocumentVersionSource Folders GlobalIDs Job Jobs InputValue LookUpReference LookUpRequisiteNames LookUpSearch Object ParentComponent Processes References Requisite ReportName Reports Result Scripts Searches SelectedAttachments SelectedItems SelectMode Sender ServerEvents ServiceFactory ShiftState SubTask SystemDialogs Tasks Wizard Wizards Work ВызовСпособ ИмяОтчета РеквЗнач ",Jl="IApplication IAccessRights IAccountRepository IAccountSelectionRestrictions IAction IActionList IAdministrationHistoryDescription IAnchors IApplication IArchiveInfo IAttachment IAttachmentList ICheckListBox ICheckPointedList IColumn IComponent IComponentDescription IComponentToken IComponentTokenFactory IComponentTokenInfo ICompRecordInfo IConnection IContents IControl IControlJob IControlJobInfo IControlList ICrypto ICrypto2 ICustomJob ICustomJobInfo ICustomListBox ICustomObjectWizardStep ICustomWork ICustomWorkInfo IDataSet IDataSetAccessInfo IDataSigner IDateCriterion IDateRequisite IDateRequisiteDescription IDateValue IDeaAccessRights IDeaObjectInfo IDevelopmentComponentLock IDialog IDialogFactory IDialogPickRequisiteItems IDialogsFactory IDICSFactory IDocRequisite IDocumentInfo IDualListDialog IECertificate IECertificateInfo IECertificates IEditControl IEditorForm IEdmsExplorer IEdmsObject IEdmsObjectDescription IEdmsObjectFactory IEdmsObjectInfo IEDocument IEDocumentAccessRights IEDocumentDescription IEDocumentEditor IEDocumentFactory IEDocumentInfo IEDocumentStorage IEDocumentVersion IEDocumentVersionListDialog IEDocumentVersionSource IEDocumentWizardStep IEDocVerSignature IEDocVersionState IEnabledMode IEncodeProvider IEncrypter IEvent IEventList IException IExternalEvents IExternalHandler IFactory IField IFileDialog IFolder IFolderDescription IFolderDialog IFolderFactory IFolderInfo IForEach IForm IFormTitle IFormWizardStep IGlobalIDFactory IGlobalIDInfo IGrid IHasher IHistoryDescription IHyperLinkControl IImageButton IImageControl IInnerPanel IInplaceHint IIntegerCriterion IIntegerList IIntegerRequisite IIntegerValue IISBLEditorForm IJob IJobDescription IJobFactory IJobForm IJobInfo ILabelControl ILargeIntegerCriterion ILargeIntegerRequisite ILargeIntegerValue ILicenseInfo ILifeCycleStage IList IListBox ILocalIDInfo ILocalization ILock IMemoryDataSet IMessagingFactory IMetadataRepository INotice INoticeInfo INumericCriterion INumericRequisite INumericValue IObject IObjectDescription IObjectImporter IObjectInfo IObserver IPanelGroup IPickCriterion IPickProperty IPickRequisite IPickRequisiteDescription IPickRequisiteItem IPickRequisiteItems IPickValue IPrivilege IPrivilegeList IProcess IProcessFactory IProcessMessage IProgress IProperty IPropertyChangeEvent IQuery IReference IReferenceCriterion IReferenceEnabledMode IReferenceFactory IReferenceHistoryDescription IReferenceInfo IReferenceRecordCardWizardStep IReferenceRequisiteDescription IReferencesFactory IReferenceValue IRefRequisite IReport IReportFactory IRequisite IRequisiteDescription IRequisiteDescriptionList IRequisiteFactory IRichEdit IRouteStep IRule IRuleList ISchemeBlock IScript IScriptFactory ISearchCriteria ISearchCriterion ISearchDescription ISearchFactory ISearchFolderInfo ISearchForObjectDescription ISearchResultRestrictions ISecuredContext ISelectDialog IServerEvent IServerEventFactory IServiceDialog IServiceFactory ISignature ISignProvider ISignProvider2 ISignProvider3 ISimpleCriterion IStringCriterion IStringList IStringRequisite IStringRequisiteDescription IStringValue ISystemDialogsFactory ISystemInfo ITabSheet ITask ITaskAbortReasonInfo ITaskCardWizardStep ITaskDescription ITaskFactory ITaskInfo ITaskRoute ITextCriterion ITextRequisite ITextValue ITreeListSelectDialog IUser IUserList IValue IView IWebBrowserControl IWizard IWizardAction IWizardFactory IWizardFormElement IWizardParam IWizardPickParam IWizardReferenceParam IWizardStep IWorkAccessRights IWorkDescription IWorkflowAskableParam IWorkflowAskableParams IWorkflowBlock IWorkflowBlockResult IWorkflowEnabledMode IWorkflowParam IWorkflowPickParam IWorkflowReferenceParam IWorkState IWorkTreeCustomNode IWorkTreeJobNode IWorkTreeTaskNode IXMLEditorForm SBCrypto ",Zt=Y+Ql,ot=Zl,Nt="null true false nil ",ir={className:"number",begin:e.NUMBER_RE,relevance:0},en={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"}]},Wr={className:"doctag",begin:"\\b(?:TODO|DONE|BEGIN|END|STUB|CHG|FIXME|NOTE|BUG|XXX)\\b",relevance:0},bn={className:"comment",begin:"//",end:"$",relevance:0,contains:[e.PHRASAL_WORDS_MODE,Wr]},xi={className:"comment",begin:"/\\*",end:"\\*/",relevance:0,contains:[e.PHRASAL_WORDS_MODE,Wr]},pr={variants:[bn,xi]},Gr={$pattern:r,keyword:i,built_in:Zt,class:ot,literal:Nt},an={begin:"\\.\\s*"+e.UNDERSCORE_IDENT_RE,keywords:Gr,relevance:0},zn={className:"type",begin:":[ \\t]*("+Jl.trim().replace(/\s/g,"|")+")",end:"[ \\t]*=",excludeEnd:!0},oi={className:"variable",keywords:Gr,begin:r,relevance:0,contains:[zn,an]},ul=n+"\\(";return{name:"ISBL",case_insensitive:!0,keywords:Gr,illegal:"\\$|\\?|%|,|;$|~|#|@|i(s,o,l-1))}function a(s){const o=s.regex,l="[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*",u=l+i("(?:<"+l+"~~~(?:\\s*,\\s*"+l+"~~~)*>)?",/~~~/g,2),g={keyword:["synchronized","abstract","private","var","static","if","const ","for","while","strictfp","finally","protected","import","native","final","void","enum","else","break","transient","catch","instanceof","volatile","case","assert","package","default","public","try","switch","continue","throws","protected","public","private","module","requires","exports","do","sealed","yield","permits","goto","when"],literal:["false","true","null"],type:["char","boolean","long","float","int","byte","short","double"],built_in:["super","this"]},m={className:"meta",begin:"@"+l,contains:[{begin:/\(/,end:/\)/,contains:["self"]}]},_={className:"params",begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:[s.C_BLOCK_COMMENT_MODE],endsParent:!0};return{name:"Java",aliases:["jsp"],keywords:g,illegal:/<\/|#/,contains:[s.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]}),{begin:/import java\.[a-z]+\./,keywords:"import",relevance:2},s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE,{begin:/"""/,end:/"""/,className:"string",contains:[s.BACKSLASH_ESCAPE]},s.APOS_STRING_MODE,s.QUOTE_STRING_MODE,{match:[/\b(?:class|interface|enum|extends|implements|new)/,/\s+/,l],className:{1:"keyword",3:"title.class"}},{match:/non-sealed/,scope:"keyword"},{begin:[o.concat(/(?!else)/,l),/\s+/,l,/\s+/,/=(?!=)/],className:{1:"type",3:"variable",5:"operator"}},{begin:[/record/,/\s+/,l],className:{1:"keyword",3:"title.class"},contains:[_,s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE]},{beginKeywords:"new throw return else",relevance:0},{begin:["(?:"+u+"\\s+)",s.UNDERSCORE_IDENT_RE,/\s*(?=\()/],className:{2:"title.function"},keywords:g,contains:[{className:"params",begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:[m,s.APOS_STRING_MODE,s.QUOTE_STRING_MODE,n,s.C_BLOCK_COMMENT_MODE]},s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE]},n,m]}}return aY=a,aY}var sY,pye;function T5t(){if(pye)return sY;pye=1;const t="[A-Za-z$_][0-9A-Za-z$_]*",e=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends","using"],r=["true","false","null","undefined","NaN","Infinity"],n=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],i=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],a=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],s=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],o=[].concat(a,n,i);function l(u){const d=u.regex,h=(Q,{after:ae})=>{const re="",end:""},g=/<[A-Za-z0-9\\._:-]+\s*\/>/,m={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(Q,ae)=>{const re=Q[0].length+Q.index,ne=Q.input[re];if(ne==="<"||ne===","){ae.ignoreMatch();return}ne===">"&&(h(Q,{after:re})||ae.ignoreMatch());let ee;const J=Q.input.substring(re);if(ee=J.match(/^\s*=/)){ae.ignoreMatch();return}if((ee=J.match(/^\s+extends\s+/))&&ee.index===0){ae.ignoreMatch();return}}},_={$pattern:t,keyword:e,literal:r,built_in:o,"variable.language":s},v="[0-9](_?[0-9])*",b=`\\.(${v})`,y="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",E={className:"number",variants:[{begin:`(\\b(${y})((${b})|\\.)?|(${b}))[eE][+-]?(${v})\\b`},{begin:`\\b(${y})\\b((${b})\\b|\\.)?|(${b})\\b`},{begin:"\\b(0|[1-9](_?[0-9])*)n\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*n?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*n?\\b"},{begin:"\\b0[0-7]+n?\\b"}],relevance:0},T={className:"subst",begin:"\\$\\{",end:"\\}",keywords:_,contains:[]},C={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"xml"}},w={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"css"}},x={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"graphql"}},A={className:"string",begin:"`",end:"`",contains:[u.BACKSLASH_ESCAPE,T]},O={className:"comment",variants:[u.COMMENT(/\/\*\*(?!\/)/,"\\*/",{relevance:0,contains:[{begin:"(?=@[A-Za-z]+)",relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"},{className:"type",begin:"\\{",end:"\\}",excludeEnd:!0,excludeBegin:!0,relevance:0},{className:"variable",begin:f+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),u.C_BLOCK_COMMENT_MODE,u.C_LINE_COMMENT_MODE]},F=[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,C,w,x,A,{match:/\$\d+/},E];T.contains=F.concat({begin:/\{/,end:/\}/,keywords:_,contains:["self"].concat(F)});const P=[].concat(O,T.contains),N=P.concat([{begin:/(\s*)\(/,end:/\)/,keywords:_,contains:["self"].concat(P)}]),k={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:_,contains:N},M={variants:[{match:[/class/,/\s+/,f,/\s+/,/extends/,/\s+/,d.concat(f,"(",d.concat(/\./,f),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,f],scope:{1:"keyword",3:"title.class"}}]},L={relevance:0,match:d.either(/\bJSON/,/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),className:"title.class",keywords:{_:[...n,...i]}},I={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},U={variants:[{match:[/function/,/\s+/,f,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[k],illegal:/%/},B={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function $(Q){return d.concat("(?!",Q.join("|"),")")}const H={match:d.concat(/\b/,$([...a,"super","import"].map(Q=>`${Q}\\s*\\(`)),f,d.lookahead(/\s*\(/)),className:"title.function",relevance:0},q={begin:d.concat(/\./,d.lookahead(d.concat(f,/(?![0-9A-Za-z$_(])/))),end:f,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},V={match:[/get|set/,/\s+/,f,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},k]},Y="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+u.UNDERSCORE_IDENT_RE+")\\s*=>",j={match:[/const|var|let/,/\s+/,f,/\s*/,/=\s*/,/(async\s*)?/,d.lookahead(Y)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[k]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:_,exports:{PARAMS_CONTAINS:N,CLASS_REFERENCE:L},illegal:/#(?![$_A-z])/,contains:[u.SHEBANG({label:"shebang",binary:"node",relevance:5}),I,u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,C,w,x,A,O,{match:/\$\d+/},E,L,{scope:"attr",match:f+d.lookahead(":"),relevance:0},j,{begin:"("+u.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[O,u.REGEXP_MODE,{className:"function",begin:Y,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:u.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:_,contains:N}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:p.begin,end:p.end},{match:g},{begin:m.begin,"on:begin":m.isTrulyOpeningTag,end:m.end}],subLanguage:"xml",contains:[{begin:m.begin,end:m.end,skip:!0,contains:["self"]}]}]},U,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+u.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[k,u.inherit(u.TITLE_MODE,{begin:f,className:"title.function"})]},{match:/\.\.\./,relevance:0},q,{match:"\\$"+f,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[k]},H,B,M,V,{match:/\$[(.]/}]}}return sY=l,sY}var oY,gye;function C5t(){if(gye)return oY;gye=1;function t(e){const n={className:"params",begin:/\(/,end:/\)/,contains:[{begin:/[\w-]+ *=/,returnBegin:!0,relevance:0,contains:[{className:"attr",begin:/[\w-]+/}]}],relevance:0},i={className:"function",begin:/:[\w\-.]+/,relevance:0},a={className:"string",begin:/\B([\/.])[\w\-.\/=]+/},s={className:"params",begin:/--[\w\-=\/]+/};return{name:"JBoss CLI",aliases:["wildfly-cli"],keywords:{$pattern:"[a-z-]+",keyword:"alias batch cd clear command connect connection-factory connection-info data-source deploy deployment-info deployment-overlay echo echo-dmr help history if jdbc-driver-info jms-queue|20 jms-topic|20 ls patch pwd quit read-attribute read-operation reload rollout-plan run-batch set shutdown try unalias undeploy unset version xa-data-source",literal:"true false"},contains:[e.HASH_COMMENT_MODE,e.QUOTE_STRING_MODE,s,i,a,n]}}return oY=t,oY}var lY,mye;function w5t(){if(mye)return lY;mye=1;function t(e){const r={className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/,relevance:1.01},n={match:/[{}[\],:]/,className:"punctuation",relevance:0},i=["true","false","null"],a={scope:"literal",beginKeywords:i.join(" ")};return{name:"JSON",aliases:["jsonc"],keywords:{literal:i},contains:[r,n,e.QUOTE_STRING_MODE,a,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE],illegal:"\\S"}}return lY=t,lY}var cY,_ye;function x5t(){if(_ye)return cY;_ye=1;function t(e){const r="[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*",s={$pattern:r,keyword:["baremodule","begin","break","catch","ccall","const","continue","do","else","elseif","end","export","false","finally","for","function","global","if","import","in","isa","let","local","macro","module","quote","return","true","try","using","where","while"],literal:["ARGS","C_NULL","DEPOT_PATH","ENDIAN_BOM","ENV","Inf","Inf16","Inf32","Inf64","InsertionSort","LOAD_PATH","MergeSort","NaN","NaN16","NaN32","NaN64","PROGRAM_FILE","QuickSort","RoundDown","RoundFromZero","RoundNearest","RoundNearestTiesAway","RoundNearestTiesUp","RoundToZero","RoundUp","VERSION|0","devnull","false","im","missing","nothing","pi","stderr","stdin","stdout","true","undef","π","ℯ"],built_in:["AbstractArray","AbstractChannel","AbstractChar","AbstractDict","AbstractDisplay","AbstractFloat","AbstractIrrational","AbstractMatrix","AbstractRange","AbstractSet","AbstractString","AbstractUnitRange","AbstractVecOrMat","AbstractVector","Any","ArgumentError","Array","AssertionError","BigFloat","BigInt","BitArray","BitMatrix","BitSet","BitVector","Bool","BoundsError","CapturedException","CartesianIndex","CartesianIndices","Cchar","Cdouble","Cfloat","Channel","Char","Cint","Cintmax_t","Clong","Clonglong","Cmd","Colon","Complex","ComplexF16","ComplexF32","ComplexF64","CompositeException","Condition","Cptrdiff_t","Cshort","Csize_t","Cssize_t","Cstring","Cuchar","Cuint","Cuintmax_t","Culong","Culonglong","Cushort","Cvoid","Cwchar_t","Cwstring","DataType","DenseArray","DenseMatrix","DenseVecOrMat","DenseVector","Dict","DimensionMismatch","Dims","DivideError","DomainError","EOFError","Enum","ErrorException","Exception","ExponentialBackOff","Expr","Float16","Float32","Float64","Function","GlobalRef","HTML","IO","IOBuffer","IOContext","IOStream","IdDict","IndexCartesian","IndexLinear","IndexStyle","InexactError","InitError","Int","Int128","Int16","Int32","Int64","Int8","Integer","InterruptException","InvalidStateException","Irrational","KeyError","LinRange","LineNumberNode","LinearIndices","LoadError","MIME","Matrix","Method","MethodError","Missing","MissingException","Module","NTuple","NamedTuple","Nothing","Number","OrdinalRange","OutOfMemoryError","OverflowError","Pair","PartialQuickSort","PermutedDimsArray","Pipe","ProcessFailedException","Ptr","QuoteNode","Rational","RawFD","ReadOnlyMemoryError","Real","ReentrantLock","Ref","Regex","RegexMatch","RoundingMode","SegmentationFault","Set","Signed","Some","StackOverflowError","StepRange","StepRangeLen","StridedArray","StridedMatrix","StridedVecOrMat","StridedVector","String","StringIndexError","SubArray","SubString","SubstitutionString","Symbol","SystemError","Task","TaskFailedException","Text","TextDisplay","Timer","Tuple","Type","TypeError","TypeVar","UInt","UInt128","UInt16","UInt32","UInt64","UInt8","UndefInitializer","UndefKeywordError","UndefRefError","UndefVarError","Union","UnionAll","UnitRange","Unsigned","Val","Vararg","VecElement","VecOrMat","Vector","VersionNumber","WeakKeyDict","WeakRef"]},o={keywords:s,illegal:/<\//},l={className:"number",begin:/(\b0x[\d_]*(\.[\d_]*)?|0x\.\d[\d_]*)p[-+]?\d+|\b0[box][a-fA-F0-9][a-fA-F0-9_]*|(\b\d[\d_]*(\.[\d_]*)?|\.\d[\d_]*)([eEfF][-+]?\d+)?/,relevance:0},u={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},d={className:"subst",begin:/\$\(/,end:/\)/,keywords:s},h={className:"variable",begin:"\\$"+r},f={className:"string",contains:[e.BACKSLASH_ESCAPE,d,h],variants:[{begin:/\w*"""/,end:/"""\w*/,relevance:10},{begin:/\w*"/,end:/"\w*/}]},p={className:"string",contains:[e.BACKSLASH_ESCAPE,d,h],begin:"`",end:"`"},g={className:"meta",begin:"@"+r},m={className:"comment",variants:[{begin:"#=",end:"=#",relevance:10},{begin:"#",end:"$"}]};return o.name="Julia",o.contains=[l,u,f,p,g,m,e.HASH_COMMENT_MODE,{className:"keyword",begin:"\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b"},{begin:/<:/}],d.contains=o.contains,o}return cY=t,cY}var uY,vye;function A5t(){if(vye)return uY;vye=1;function t(e){return{name:"Julia REPL",contains:[{className:"meta.prompt",begin:/^julia>/,relevance:10,starts:{end:/^(?![ ]{6})/,subLanguage:"julia"}}],aliases:["jldoctest"]}}return uY=t,uY}var dY,yye;function R5t(){if(yye)return dY;yye=1;var t="[0-9](_*[0-9])*",e=`\\.(${t})`,r="[0-9a-fA-F](_*[0-9a-fA-F])*",n={className:"number",variants:[{begin:`(\\b(${t})((${e})|\\.)?|(${e}))[eE][+-]?(${t})[fFdD]?\\b`},{begin:`\\b(${t})((${e})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{begin:`(${e})[fFdD]?\\b`},{begin:`\\b(${t})[fFdD]\\b`},{begin:`\\b0[xX]((${r})\\.?|(${r})?\\.(${r}))[pP][+-]?(${t})[fFdD]?\\b`},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${r})[lL]?\\b`},{begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],relevance:0};function i(a){const s={keyword:"abstract as val var vararg get set class object open private protected public noinline crossinline dynamic final enum if else do while for when throw try catch finally import package is in fun override companion reified inline lateinit init interface annotation data sealed internal infix operator out by constructor super tailrec where const inner suspend typealias external expect actual",built_in:"Byte Short Char Int Long Boolean Float Double Void Unit Nothing",literal:"true false null"},o={className:"keyword",begin:/\b(break|continue|return|this)\b/,starts:{contains:[{className:"symbol",begin:/@\w+/}]}},l={className:"symbol",begin:a.UNDERSCORE_IDENT_RE+"@"},u={className:"subst",begin:/\$\{/,end:/\}/,contains:[a.C_NUMBER_MODE]},d={className:"variable",begin:"\\$"+a.UNDERSCORE_IDENT_RE},h={className:"string",variants:[{begin:'"""',end:'"""(?=[^"])',contains:[d,u]},{begin:"'",end:"'",illegal:/\n/,contains:[a.BACKSLASH_ESCAPE]},{begin:'"',end:'"',illegal:/\n/,contains:[a.BACKSLASH_ESCAPE,d,u]}]};u.contains.push(h);const f={className:"meta",begin:"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*"+a.UNDERSCORE_IDENT_RE+")?"},p={className:"meta",begin:"@"+a.UNDERSCORE_IDENT_RE,contains:[{begin:/\(/,end:/\)/,contains:[a.inherit(h,{className:"string"}),"self"]}]},g=n,m=a.COMMENT("/\\*","\\*/",{contains:[a.C_BLOCK_COMMENT_MODE]}),_={variants:[{className:"type",begin:a.UNDERSCORE_IDENT_RE},{begin:/\(/,end:/\)/,contains:[]}]},v=_;return v.variants[1].contains=[_],_.variants[1].contains=[v],{name:"Kotlin",aliases:["kt","kts"],keywords:s,contains:[a.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"}]}),a.C_LINE_COMMENT_MODE,m,o,l,f,p,{className:"function",beginKeywords:"fun",end:"[(]|$",returnBegin:!0,excludeEnd:!0,keywords:s,relevance:5,contains:[{begin:a.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,contains:[a.UNDERSCORE_TITLE_MODE]},{className:"type",begin://,keywords:"reified",relevance:0},{className:"params",begin:/\(/,end:/\)/,endsParent:!0,keywords:s,relevance:0,contains:[{begin:/:/,end:/[=,\/]/,endsWithParent:!0,contains:[_,a.C_LINE_COMMENT_MODE,m],relevance:0},a.C_LINE_COMMENT_MODE,m,f,p,h,a.C_NUMBER_MODE]},m]},{begin:[/class|interface|trait/,/\s+/,a.UNDERSCORE_IDENT_RE],beginScope:{3:"title.class"},keywords:"class interface trait",end:/[:\{(]|$/,excludeEnd:!0,illegal:"extends implements",contains:[{beginKeywords:"public protected internal private constructor"},a.UNDERSCORE_TITLE_MODE,{className:"type",begin://,excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:/[,:]\s*/,end:/[<\(,){\s]|$/,excludeBegin:!0,returnEnd:!0},f,p]},h,{className:"meta",begin:"^#!/usr/bin/env",end:"$",illegal:` +`},g]}}return dY=i,dY}var hY,bye;function N5t(){if(bye)return hY;bye=1;function t(e){const r="[a-zA-Z_][\\w.]*",n="<\\?(lasso(script)?|=)",i="\\]|\\?>",a={$pattern:r+"|&[lg]t;",literal:"true false none minimal full all void and or not bw nbw ew new cn ncn lt lte gt gte eq neq rx nrx ft",built_in:"array date decimal duration integer map pair string tag xml null boolean bytes keyword list locale queue set stack staticarray local var variable global data self inherited currentcapture givenblock",keyword:"cache database_names database_schemanames database_tablenames define_tag define_type email_batch encode_set html_comment handle handle_error header if inline iterate ljax_target link link_currentaction link_currentgroup link_currentrecord link_detail link_firstgroup link_firstrecord link_lastgroup link_lastrecord link_nextgroup link_nextrecord link_prevgroup link_prevrecord log loop namespace_using output_none portal private protect records referer referrer repeating resultset rows search_args search_arguments select sort_args sort_arguments thread_atomic value_list while abort case else fail_if fail_ifnot fail if_empty if_false if_null if_true loop_abort loop_continue loop_count params params_up return return_value run_children soap_definetag soap_lastrequest soap_lastresponse tag_name ascending average by define descending do equals frozen group handle_failure import in into join let match max min on order parent protected provide public require returnhome skip split_thread sum take thread to trait type where with yield yieldhome"},s=e.COMMENT("",{relevance:0}),o={className:"meta",begin:"\\[noprocess\\]",starts:{end:"\\[/noprocess\\]",returnEnd:!0,contains:[s]}},l={className:"meta",begin:"\\[/noprocess|"+n},u={className:"symbol",begin:"'"+r+"'"},d=[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.inherit(e.C_NUMBER_MODE,{begin:e.C_NUMBER_RE+"|(-?infinity|NaN)\\b"}),e.inherit(e.APOS_STRING_MODE,{illegal:null}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"string",begin:"`",end:"`"},{variants:[{begin:"[#$]"+r},{begin:"#",end:"\\d+",illegal:"\\W"}]},{className:"type",begin:"::\\s*",end:r,illegal:"\\W"},{className:"params",variants:[{begin:"-(?!infinity)"+r,relevance:0},{begin:"(\\.\\.\\.)"}]},{begin:/(->|\.)\s*/,relevance:0,contains:[u]},{className:"class",beginKeywords:"define",returnEnd:!0,end:"\\(|=>",contains:[e.inherit(e.TITLE_MODE,{begin:r+"(=(?!>))?|[-+*/%](?!>)"})]}];return{name:"Lasso",aliases:["ls","lassoscript"],case_insensitive:!0,keywords:a,contains:[{className:"meta",begin:i,relevance:0,starts:{end:"\\[|"+n,returnEnd:!0,relevance:0,contains:[s]}},o,l,{className:"meta",begin:"\\[no_square_brackets",starts:{end:"\\[/no_square_brackets\\]",keywords:a,contains:[{className:"meta",begin:i,relevance:0,starts:{end:"\\[noprocess\\]|"+n,returnEnd:!0,contains:[s]}},o,l].concat(d)}},{className:"meta",begin:"\\[",relevance:0},{className:"meta",begin:"^#!",end:"lasso9$",relevance:10}].concat(d)}}return hY=t,hY}var fY,Sye;function O5t(){if(Sye)return fY;Sye=1;function t(e){const n=e.regex.either(...["(?:NeedsTeXFormat|RequirePackage|GetIdInfo)","Provides(?:Expl)?(?:Package|Class|File)","(?:DeclareOption|ProcessOptions)","(?:documentclass|usepackage|input|include)","makeat(?:letter|other)","ExplSyntax(?:On|Off)","(?:new|renew|provide)?command","(?:re)newenvironment","(?:New|Renew|Provide|Declare)(?:Expandable)?DocumentCommand","(?:New|Renew|Provide|Declare)DocumentEnvironment","(?:(?:e|g|x)?def|let)","(?:begin|end)","(?:part|chapter|(?:sub){0,2}section|(?:sub)?paragraph)","caption","(?:label|(?:eq|page|name)?ref|(?:paren|foot|super)?cite)","(?:alpha|beta|[Gg]amma|[Dd]elta|(?:var)?epsilon|zeta|eta|[Tt]heta|vartheta)","(?:iota|(?:var)?kappa|[Ll]ambda|mu|nu|[Xx]i|[Pp]i|varpi|(?:var)rho)","(?:[Ss]igma|varsigma|tau|[Uu]psilon|[Pp]hi|varphi|chi|[Pp]si|[Oo]mega)","(?:frac|sum|prod|lim|infty|times|sqrt|leq|geq|left|right|middle|[bB]igg?)","(?:[lr]angle|q?quad|[lcvdi]?dots|d?dot|hat|tilde|bar)"].map(O=>O+"(?![a-zA-Z@:_])")),i=new RegExp(["(?:__)?[a-zA-Z]{2,}_[a-zA-Z](?:_?[a-zA-Z])+:[a-zA-Z]*","[lgc]__?[a-zA-Z](?:_?[a-zA-Z])*_[a-zA-Z]{2,}","[qs]__?[a-zA-Z](?:_?[a-zA-Z])+","use(?:_i)?:[a-zA-Z]*","(?:else|fi|or):","(?:if|cs|exp):w","(?:hbox|vbox):n","::[a-zA-Z]_unbraced","::[a-zA-Z:]"].map(O=>O+"(?![a-zA-Z:_])").join("|")),a=[{begin:/[a-zA-Z@]+/},{begin:/[^a-zA-Z@]?/}],s=[{begin:/\^{6}[0-9a-f]{6}/},{begin:/\^{5}[0-9a-f]{5}/},{begin:/\^{4}[0-9a-f]{4}/},{begin:/\^{3}[0-9a-f]{3}/},{begin:/\^{2}[0-9a-f]{2}/},{begin:/\^{2}[\u0000-\u007f]/}],o={className:"keyword",begin:/\\/,relevance:0,contains:[{endsParent:!0,begin:n},{endsParent:!0,begin:i},{endsParent:!0,variants:s},{endsParent:!0,relevance:0,variants:a}]},l={className:"params",relevance:0,begin:/#+\d?/},u={variants:s},d={className:"built_in",relevance:0,begin:/[$&^_]/},h={className:"meta",begin:/% ?!(T[eE]X|tex|BIB|bib)/,end:"$",relevance:10},f=e.COMMENT("%","$",{relevance:0}),p=[o,l,u,d,h,f],g={begin:/\{/,end:/\}/,relevance:0,contains:["self",...p]},m=e.inherit(g,{relevance:0,endsParent:!0,contains:[g,...p]}),_={begin:/\[/,end:/\]/,endsParent:!0,relevance:0,contains:[g,...p]},v={begin:/\s+/,relevance:0},b=[m],y=[_],E=function(O,F){return{contains:[v],starts:{relevance:0,contains:O,starts:F}}},T=function(O,F){return{begin:"\\\\"+O+"(?![a-zA-Z@:_])",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\"+O},relevance:0,contains:[v],starts:F}},C=function(O,F){return e.inherit({begin:"\\\\begin(?=[ ]*(\\r?\\n[ ]*)?\\{"+O+"\\})",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\begin"},relevance:0},E(b,F))},w=(O="string")=>e.END_SAME_AS_BEGIN({className:O,begin:/(.|\r?\n)/,end:/(.|\r?\n)/,excludeBegin:!0,excludeEnd:!0,endsParent:!0}),x=function(O){return{className:"string",end:"(?=\\\\end\\{"+O+"\\})"}},A=(O="string")=>({relevance:0,begin:/\{/,starts:{endsParent:!0,contains:[{className:O,end:/(?=\})/,endsParent:!0,contains:[{begin:/\{/,end:/\}/,relevance:0,contains:["self"]}]}]}}),R=[...["verb","lstinline"].map(O=>T(O,{contains:[w()]})),T("mint",E(b,{contains:[w()]})),T("mintinline",E(b,{contains:[A(),w()]})),T("url",{contains:[A("link"),A("link")]}),T("hyperref",{contains:[A("link")]}),T("href",E(y,{contains:[A("link")]})),...[].concat(...["","\\*"].map(O=>[C("verbatim"+O,x("verbatim"+O)),C("filecontents"+O,E(b,x("filecontents"+O))),...["","B","L"].map(F=>C(F+"Verbatim"+O,E(y,x(F+"Verbatim"+O))))])),C("minted",E(y,E(b,x("minted"))))];return{name:"LaTeX",aliases:["tex"],contains:[...R,...p]}}return fY=t,fY}var pY,Eye;function I5t(){if(Eye)return pY;Eye=1;function t(e){return{name:"LDIF",contains:[{className:"attribute",match:"^dn(?=:)",relevance:10},{className:"attribute",match:"^\\w+(?=:)"},{className:"literal",match:"^-"},e.HASH_COMMENT_MODE]}}return pY=t,pY}var gY,Tye;function k5t(){if(Tye)return gY;Tye=1;function t(e){const r=/([A-Za-z_][A-Za-z_0-9]*)?/,i={scope:"params",begin:/\(/,end:/\)(?=\:?)/,endsParent:!0,relevance:7,contains:[{scope:"string",begin:'"',end:'"'},{scope:"keyword",match:["true","false","in"].join("|")},{scope:"variable",match:/[A-Za-z_][A-Za-z_0-9]*/},{scope:"operator",match:/\+|\-|\*|\/|\%|\=\=|\=|\!|\>|\<|\&\&|\|\|/}]},a={match:[r,/(?=\()/],scope:{1:"keyword"},contains:[i]};return i.contains.unshift(a),{name:"Leaf",contains:[{match:[/#+/,r,/(?=\()/],scope:{1:"punctuation",2:"keyword"},starts:{contains:[{match:/\:/,scope:"punctuation"}]},contains:[i]},{match:[/#+/,r,/:?/],scope:{1:"punctuation",2:"keyword",3:"punctuation"}}]}}return gY=t,gY}var mY,Cye;function D5t(){if(Cye)return mY;Cye=1;const t=d=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:d.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[d.APOS_STRING_MODE,d.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:d.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z_][A-Za-z0-9_-]*/}}),e=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","optgroup","option","p","picture","q","quote","samp","section","select","source","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],r=["defs","g","marker","mask","pattern","svg","switch","symbol","feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feFlood","feGaussianBlur","feImage","feMerge","feMorphology","feOffset","feSpecularLighting","feTile","feTurbulence","linearGradient","radialGradient","stop","circle","ellipse","image","line","path","polygon","polyline","rect","text","use","textPath","tspan","foreignObject","clipPath"],n=[...e,...r],i=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"].sort().reverse(),a=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"].sort().reverse(),s=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),o=["accent-color","align-content","align-items","align-self","alignment-baseline","all","anchor-name","animation","animation-composition","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-range","animation-range-end","animation-range-start","animation-timeline","animation-timing-function","appearance","aspect-ratio","backdrop-filter","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-position-x","background-position-y","background-repeat","background-size","baseline-shift","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-end-end-radius","border-end-start-radius","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-start-end-radius","border-start-start-radius","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-align","box-decoration-break","box-direction","box-flex","box-flex-group","box-lines","box-ordinal-group","box-orient","box-pack","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","color-scheme","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","contain-intrinsic-block-size","contain-intrinsic-height","contain-intrinsic-inline-size","contain-intrinsic-size","contain-intrinsic-width","container","container-name","container-type","content","content-visibility","counter-increment","counter-reset","counter-set","cue","cue-after","cue-before","cursor","cx","cy","direction","display","dominant-baseline","empty-cells","enable-background","field-sizing","fill","fill-opacity","fill-rule","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flood-color","flood-opacity","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-optical-sizing","font-palette","font-size","font-size-adjust","font-smooth","font-smoothing","font-stretch","font-style","font-synthesis","font-synthesis-position","font-synthesis-small-caps","font-synthesis-style","font-synthesis-weight","font-variant","font-variant-alternates","font-variant-caps","font-variant-east-asian","font-variant-emoji","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","forced-color-adjust","gap","glyph-orientation-horizontal","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphenate-character","hyphenate-limit-chars","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","initial-letter","initial-letter-align","inline-size","inset","inset-area","inset-block","inset-block-end","inset-block-start","inset-inline","inset-inline-end","inset-inline-start","isolation","justify-content","justify-items","justify-self","kerning","left","letter-spacing","lighting-color","line-break","line-height","line-height-step","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","margin-trim","marker","marker-end","marker-mid","marker-start","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","masonry-auto-flow","math-depth","math-shift","math-style","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","offset","offset-anchor","offset-distance","offset-path","offset-position","offset-rotate","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-anchor","overflow-block","overflow-clip-margin","overflow-inline","overflow-wrap","overflow-x","overflow-y","overlay","overscroll-behavior","overscroll-behavior-block","overscroll-behavior-inline","overscroll-behavior-x","overscroll-behavior-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page","page-break-after","page-break-before","page-break-inside","paint-order","pause","pause-after","pause-before","perspective","perspective-origin","place-content","place-items","place-self","pointer-events","position","position-anchor","position-visibility","print-color-adjust","quotes","r","resize","rest","rest-after","rest-before","right","rotate","row-gap","ruby-align","ruby-position","scale","scroll-behavior","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scroll-timeline","scroll-timeline-axis","scroll-timeline-name","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","shape-rendering","speak","speak-as","src","stop-color","stop-opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","tab-size","table-layout","text-align","text-align-all","text-align-last","text-anchor","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-skip","text-decoration-skip-ink","text-decoration-style","text-decoration-thickness","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-size-adjust","text-transform","text-underline-offset","text-underline-position","text-wrap","text-wrap-mode","text-wrap-style","timeline-scope","top","touch-action","transform","transform-box","transform-origin","transform-style","transition","transition-behavior","transition-delay","transition-duration","transition-property","transition-timing-function","translate","unicode-bidi","user-modify","user-select","vector-effect","vertical-align","view-timeline","view-timeline-axis","view-timeline-inset","view-timeline-name","view-transition-name","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","white-space-collapse","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","x","y","z-index","zoom"].sort().reverse(),l=a.concat(s).sort().reverse();function u(d){const h=t(d),f=l,p="and or not only",g="[\\w-]+",m="("+g+"|@\\{"+g+"\\})",_=[],v=[],b=function(P){return{className:"string",begin:"~?"+P+".*?"+P}},y=function(P,N,k){return{className:P,begin:N,relevance:k}},E={$pattern:/[a-z-]+/,keyword:p,attribute:i.join(" ")},T={begin:"\\(",end:"\\)",contains:v,keywords:E,relevance:0};v.push(d.C_LINE_COMMENT_MODE,d.C_BLOCK_COMMENT_MODE,b("'"),b('"'),h.CSS_NUMBER_MODE,{begin:"(url|data-uri)\\(",starts:{className:"string",end:"[\\)\\n]",excludeEnd:!0}},h.HEXCOLOR,T,y("variable","@@?"+g,10),y("variable","@\\{"+g+"\\}"),y("built_in","~?`[^`]*?`"),{className:"attribute",begin:g+"\\s*:",end:":",returnBegin:!0,excludeEnd:!0},h.IMPORTANT,{beginKeywords:"and not"},h.FUNCTION_DISPATCH);const C=v.concat({begin:/\{/,end:/\}/,contains:_}),w={beginKeywords:"when",endsWithParent:!0,contains:[{beginKeywords:"and not"}].concat(v)},x={begin:m+"\\s*:",returnBegin:!0,end:/[;}]/,relevance:0,contains:[{begin:/-(webkit|moz|ms|o)-/},h.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b",end:/(?=:)/,starts:{endsWithParent:!0,illegal:"[<=$]",relevance:0,contains:v}}]},A={className:"keyword",begin:"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",starts:{end:"[;{}]",keywords:E,returnEnd:!0,contains:v,relevance:0}},R={className:"variable",variants:[{begin:"@"+g+"\\s*:",relevance:15},{begin:"@"+g}],starts:{end:"[;}]",returnEnd:!0,contains:C}},O={variants:[{begin:"[\\.#:&\\[>]",end:"[;{}]"},{begin:m,end:/\{/}],returnBegin:!0,returnEnd:!0,illegal:`[<='$"]`,relevance:0,contains:[d.C_LINE_COMMENT_MODE,d.C_BLOCK_COMMENT_MODE,w,y("keyword","all\\b"),y("variable","@\\{"+g+"\\}"),{begin:"\\b("+n.join("|")+")\\b",className:"selector-tag"},h.CSS_NUMBER_MODE,y("selector-tag",m,0),y("selector-id","#"+m),y("selector-class","\\."+m,0),y("selector-tag","&",0),h.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",begin:":("+a.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+s.join("|")+")"},{begin:/\(/,end:/\)/,relevance:0,contains:C},{begin:"!important"},h.FUNCTION_DISPATCH]},F={begin:g+`:(:)?(${f.join("|")})`,returnBegin:!0,contains:[O]};return _.push(d.C_LINE_COMMENT_MODE,d.C_BLOCK_COMMENT_MODE,A,R,F,x,O,w,h.FUNCTION_DISPATCH),{name:"Less",case_insensitive:!0,illegal:`[=>'/<($"]`,contains:_}}return mY=u,mY}var _Y,wye;function M5t(){if(wye)return _Y;wye=1;function t(e){const r="[a-zA-Z_\\-+\\*\\/<=>&#][a-zA-Z0-9_\\-+*\\/<=>&#!]*",n="\\|[^]*?\\|",i="(-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|-)?\\d+)?",a={className:"literal",begin:"\\b(t{1}|nil)\\b"},s={className:"number",variants:[{begin:i,relevance:0},{begin:"#(b|B)[0-1]+(/[0-1]+)?"},{begin:"#(o|O)[0-7]+(/[0-7]+)?"},{begin:"#(x|X)[0-9a-fA-F]+(/[0-9a-fA-F]+)?"},{begin:"#(c|C)\\("+i+" +"+i,end:"\\)"}]},o=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),l=e.COMMENT(";","$",{relevance:0}),u={begin:"\\*",end:"\\*"},d={className:"symbol",begin:"[:&]"+r},h={begin:r,relevance:0},f={begin:n},g={contains:[s,o,u,d,{begin:"\\(",end:"\\)",contains:["self",a,o,s,h]},h],variants:[{begin:"['`]\\(",end:"\\)"},{begin:"\\(quote ",end:"\\)",keywords:{name:"quote"}},{begin:"'"+n}]},m={variants:[{begin:"'"+r},{begin:"#'"+r+"(::"+r+")*"}]},_={begin:"\\(\\s*",end:"\\)"},v={endsWithParent:!0,relevance:0};return _.contains=[{className:"name",variants:[{begin:r,relevance:0},{begin:n}]},v],v.contains=[g,m,_,a,s,o,l,u,d,f,h],{name:"Lisp",illegal:/\S/,contains:[s,e.SHEBANG(),a,o,l,g,m,_,h]}}return _Y=t,_Y}var vY,xye;function L5t(){if(xye)return vY;xye=1;function t(e){const r={className:"variable",variants:[{begin:"\\b([gtps][A-Z]{1}[a-zA-Z0-9]*)(\\[.+\\])?(?:\\s*?)"},{begin:"\\$_[A-Z]+"}],relevance:0},n=[e.C_BLOCK_COMMENT_MODE,e.HASH_COMMENT_MODE,e.COMMENT("--","$"),e.COMMENT("[^:]//","$")],i=e.inherit(e.TITLE_MODE,{variants:[{begin:"\\b_*rig[A-Z][A-Za-z0-9_\\-]*"},{begin:"\\b_[a-z0-9\\-]+"}]}),a=e.inherit(e.TITLE_MODE,{begin:"\\b([A-Za-z0-9_\\-]+)\\b"});return{name:"LiveCode",case_insensitive:!1,keywords:{keyword:"$_COOKIE $_FILES $_GET $_GET_BINARY $_GET_RAW $_POST $_POST_BINARY $_POST_RAW $_SESSION $_SERVER codepoint codepoints segment segments codeunit codeunits sentence sentences trueWord trueWords paragraph after byte bytes english the until http forever descending using line real8 with seventh for stdout finally element word words fourth before black ninth sixth characters chars stderr uInt1 uInt1s uInt2 uInt2s stdin string lines relative rel any fifth items from middle mid at else of catch then third it file milliseconds seconds second secs sec int1 int1s int4 int4s internet int2 int2s normal text item last long detailed effective uInt4 uInt4s repeat end repeat URL in try into switch to words https token binfile each tenth as ticks tick system real4 by dateItems without char character ascending eighth whole dateTime numeric short first ftp integer abbreviated abbr abbrev private case while if div mod wrap and or bitAnd bitNot bitOr bitXor among not in a an within contains ends with begins the keys of keys",literal:"SIX TEN FORMFEED NINE ZERO NONE SPACE FOUR FALSE COLON CRLF PI COMMA ENDOFFILE EOF EIGHT FIVE QUOTE EMPTY ONE TRUE RETURN CR LINEFEED RIGHT BACKSLASH NULL SEVEN TAB THREE TWO six ten formfeed nine zero none space four false colon crlf pi comma endoffile eof eight five quote empty one true return cr linefeed right backslash null seven tab three two RIVERSION RISTATE FILE_READ_MODE FILE_WRITE_MODE FILE_WRITE_MODE DIR_WRITE_MODE FILE_READ_UMASK FILE_WRITE_UMASK DIR_READ_UMASK DIR_WRITE_UMASK",built_in:"put abs acos aliasReference annuity arrayDecode arrayEncode asin atan atan2 average avg avgDev base64Decode base64Encode baseConvert binaryDecode binaryEncode byteOffset byteToNum cachedURL cachedURLs charToNum cipherNames codepointOffset codepointProperty codepointToNum codeunitOffset commandNames compound compress constantNames cos date dateFormat decompress difference directories diskSpace DNSServers exp exp1 exp2 exp10 extents files flushEvents folders format functionNames geometricMean global globals hasMemory harmonicMean hostAddress hostAddressToName hostName hostNameToAddress isNumber ISOToMac itemOffset keys len length libURLErrorData libUrlFormData libURLftpCommand libURLLastHTTPHeaders libURLLastRHHeaders libUrlMultipartFormAddPart libUrlMultipartFormData libURLVersion lineOffset ln ln1 localNames log log2 log10 longFilePath lower macToISO matchChunk matchText matrixMultiply max md5Digest median merge messageAuthenticationCode messageDigest millisec millisecs millisecond milliseconds min monthNames nativeCharToNum normalizeText num number numToByte numToChar numToCodepoint numToNativeChar offset open openfiles openProcesses openProcessIDs openSockets paragraphOffset paramCount param params peerAddress pendingMessages platform popStdDev populationStandardDeviation populationVariance popVariance processID random randomBytes replaceText result revCreateXMLTree revCreateXMLTreeFromFile revCurrentRecord revCurrentRecordIsFirst revCurrentRecordIsLast revDatabaseColumnCount revDatabaseColumnIsNull revDatabaseColumnLengths revDatabaseColumnNames revDatabaseColumnNamed revDatabaseColumnNumbered revDatabaseColumnTypes revDatabaseConnectResult revDatabaseCursors revDatabaseID revDatabaseTableNames revDatabaseType revDataFromQuery revdb_closeCursor revdb_columnbynumber revdb_columncount revdb_columnisnull revdb_columnlengths revdb_columnnames revdb_columntypes revdb_commit revdb_connect revdb_connections revdb_connectionerr revdb_currentrecord revdb_cursorconnection revdb_cursorerr revdb_cursors revdb_dbtype revdb_disconnect revdb_execute revdb_iseof revdb_isbof revdb_movefirst revdb_movelast revdb_movenext revdb_moveprev revdb_query revdb_querylist revdb_recordcount revdb_rollback revdb_tablenames revGetDatabaseDriverPath revNumberOfRecords revOpenDatabase revOpenDatabases revQueryDatabase revQueryDatabaseBlob revQueryResult revQueryIsAtStart revQueryIsAtEnd revUnixFromMacPath revXMLAttribute revXMLAttributes revXMLAttributeValues revXMLChildContents revXMLChildNames revXMLCreateTreeFromFileWithNamespaces revXMLCreateTreeWithNamespaces revXMLDataFromXPathQuery revXMLEvaluateXPath revXMLFirstChild revXMLMatchingNode revXMLNextSibling revXMLNodeContents revXMLNumberOfChildren revXMLParent revXMLPreviousSibling revXMLRootNode revXMLRPC_CreateRequest revXMLRPC_Documents revXMLRPC_Error revXMLRPC_GetHost revXMLRPC_GetMethod revXMLRPC_GetParam revXMLText revXMLRPC_Execute revXMLRPC_GetParamCount revXMLRPC_GetParamNode revXMLRPC_GetParamType revXMLRPC_GetPath revXMLRPC_GetPort revXMLRPC_GetProtocol revXMLRPC_GetRequest revXMLRPC_GetResponse revXMLRPC_GetSocket revXMLTree revXMLTrees revXMLValidateDTD revZipDescribeItem revZipEnumerateItems revZipOpenArchives round sampVariance sec secs seconds sentenceOffset sha1Digest shell shortFilePath sin specialFolderPath sqrt standardDeviation statRound stdDev sum sysError systemVersion tan tempName textDecode textEncode tick ticks time to tokenOffset toLower toUpper transpose truewordOffset trunc uniDecode uniEncode upper URLDecode URLEncode URLStatus uuid value variableNames variance version waitDepth weekdayNames wordOffset xsltApplyStylesheet xsltApplyStylesheetFromFile xsltLoadStylesheet xsltLoadStylesheetFromFile add breakpoint cancel clear local variable file word line folder directory URL close socket process combine constant convert create new alias folder directory decrypt delete variable word line folder directory URL dispatch divide do encrypt filter get include intersect kill libURLDownloadToFile libURLFollowHttpRedirects libURLftpUpload libURLftpUploadFile libURLresetAll libUrlSetAuthCallback libURLSetDriver libURLSetCustomHTTPHeaders libUrlSetExpect100 libURLSetFTPListCommand libURLSetFTPMode libURLSetFTPStopTime libURLSetStatusCallback load extension loadedExtensions multiply socket prepare process post seek rel relative read from process rename replace require resetAll resolve revAddXMLNode revAppendXML revCloseCursor revCloseDatabase revCommitDatabase revCopyFile revCopyFolder revCopyXMLNode revDeleteFolder revDeleteXMLNode revDeleteAllXMLTrees revDeleteXMLTree revExecuteSQL revGoURL revInsertXMLNode revMoveFolder revMoveToFirstRecord revMoveToLastRecord revMoveToNextRecord revMoveToPreviousRecord revMoveToRecord revMoveXMLNode revPutIntoXMLNode revRollBackDatabase revSetDatabaseDriverPath revSetXMLAttribute revXMLRPC_AddParam revXMLRPC_DeleteAllDocuments revXMLAddDTD revXMLRPC_Free revXMLRPC_FreeAll revXMLRPC_DeleteDocument revXMLRPC_DeleteParam revXMLRPC_SetHost revXMLRPC_SetMethod revXMLRPC_SetPort revXMLRPC_SetProtocol revXMLRPC_SetSocket revZipAddItemWithData revZipAddItemWithFile revZipAddUncompressedItemWithData revZipAddUncompressedItemWithFile revZipCancel revZipCloseArchive revZipDeleteItem revZipExtractItemToFile revZipExtractItemToVariable revZipSetProgressCallback revZipRenameItem revZipReplaceItemWithData revZipReplaceItemWithFile revZipOpenArchive send set sort split start stop subtract symmetric union unload vectorDotProduct wait write"},contains:[r,{className:"keyword",begin:"\\bend\\sif\\b"},{className:"function",beginKeywords:"function",end:"$",contains:[r,a,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE,i]},{className:"function",begin:"\\bend\\s+",end:"$",keywords:"end",contains:[a,i],relevance:0},{beginKeywords:"command on",end:"$",contains:[r,a,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE,i]},{className:"meta",variants:[{begin:"<\\?(rev|lc|livecode)",relevance:10},{begin:"<\\?"},{begin:"\\?>"}]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE,i].concat(n),illegal:";$|^\\[|^=|&|\\{"}}return vY=t,vY}var yY,Aye;function P5t(){if(Aye)return yY;Aye=1;const t=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends","using"],e=["true","false","null","undefined","NaN","Infinity"],r=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],n=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],i=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],a=[].concat(i,r,n);function s(o){const l=["npm","print"],u=["yes","no","on","off","it","that","void"],d=["then","unless","until","loop","of","by","when","and","or","is","isnt","not","it","that","otherwise","from","to","til","fallthrough","case","enum","native","list","map","__hasProp","__extends","__slice","__bind","__indexOf"],h={keyword:t.concat(d),literal:e.concat(u),built_in:a.concat(l)},f="[A-Za-z$_](?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*",p=o.inherit(o.TITLE_MODE,{begin:f}),g={className:"subst",begin:/#\{/,end:/\}/,keywords:h},m={className:"subst",begin:/#[A-Za-z$_]/,end:/(?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*/,keywords:h},_=[o.BINARY_NUMBER_MODE,{className:"number",begin:"(\\b0[xX][a-fA-F0-9_]+)|(\\b\\d(\\d|_\\d)*(\\.(\\d(\\d|_\\d)*)?)?(_*[eE]([-+]\\d(_\\d|\\d)*)?)?[_a-z]*)",relevance:0,starts:{end:"(\\s*/)?",relevance:0}},{className:"string",variants:[{begin:/'''/,end:/'''/,contains:[o.BACKSLASH_ESCAPE]},{begin:/'/,end:/'/,contains:[o.BACKSLASH_ESCAPE]},{begin:/"""/,end:/"""/,contains:[o.BACKSLASH_ESCAPE,g,m]},{begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE,g,m]},{begin:/\\/,end:/(\s|$)/,excludeEnd:!0}]},{className:"regexp",variants:[{begin:"//",end:"//[gim]*",contains:[g,o.HASH_COMMENT_MODE]},{begin:/\/(?![ *])(\\.|[^\\\n])*?\/[gim]*(?=\W)/}]},{begin:"@"+f},{begin:"``",end:"``",excludeBegin:!0,excludeEnd:!0,subLanguage:"javascript"}];g.contains=_;const v={className:"params",begin:"\\(",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:h,contains:["self"].concat(_)}]},b={begin:"(#=>|=>|\\|>>|-?->|!->)"},y={variants:[{match:[/class\s+/,f,/\s+extends\s+/,f]},{match:[/class\s+/,f]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:h};return{name:"LiveScript",aliases:["ls"],keywords:h,illegal:/\/\*/,contains:_.concat([o.COMMENT("\\/\\*","\\*\\/"),o.HASH_COMMENT_MODE,b,{className:"function",contains:[p,v],returnBegin:!0,variants:[{begin:"("+f+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B->\\*?",end:"->\\*?"},{begin:"("+f+"\\s*(?:=|:=)\\s*)?!?(\\(.*\\)\\s*)?\\B[-~]{1,2}>\\*?",end:"[-~]{1,2}>\\*?"},{begin:"("+f+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B!?[-~]{1,2}>\\*?",end:"!?[-~]{1,2}>\\*?"}]},y,{begin:f+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return yY=s,yY}var bY,Rye;function F5t(){if(Rye)return bY;Rye=1;function t(e){const r=e.regex,n=/([-a-zA-Z$._][\w$.-]*)/,i={className:"type",begin:/\bi\d+(?=\s|\b)/},a={className:"operator",relevance:0,begin:/=/},s={className:"punctuation",relevance:0,begin:/,/},o={className:"number",variants:[{begin:/[su]?0[xX][KMLHR]?[a-fA-F0-9]+/},{begin:/[-+]?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/}],relevance:0},l={className:"symbol",variants:[{begin:/^\s*[a-z]+:/}],relevance:0},u={className:"variable",variants:[{begin:r.concat(/%/,n)},{begin:/%\d+/},{begin:/#\d+/}]},d={className:"title",variants:[{begin:r.concat(/@/,n)},{begin:/@\d+/},{begin:r.concat(/!/,n)},{begin:r.concat(/!\d+/,n)},{begin:/!\d+/}]};return{name:"LLVM IR",keywords:{keyword:"begin end true false declare define global constant private linker_private internal available_externally linkonce linkonce_odr weak weak_odr appending dllimport dllexport common default hidden protected extern_weak external thread_local zeroinitializer undef null to tail target triple datalayout volatile nuw nsw nnan ninf nsz arcp fast exact inbounds align addrspace section alias module asm sideeffect gc dbg linker_private_weak attributes blockaddress initialexec localdynamic localexec prefix unnamed_addr ccc fastcc coldcc x86_stdcallcc x86_fastcallcc arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel intel_ocl_bicc msp430_intrcc spir_func spir_kernel x86_64_sysvcc x86_64_win64cc x86_thiscallcc cc c signext zeroext inreg sret nounwind noreturn noalias nocapture byval nest readnone readonly inlinehint noinline alwaysinline optsize ssp sspreq noredzone noimplicitfloat naked builtin cold nobuiltin noduplicate nonlazybind optnone returns_twice sanitize_address sanitize_memory sanitize_thread sspstrong uwtable returned type opaque eq ne slt sgt sle sge ult ugt ule uge oeq one olt ogt ole oge ord uno ueq une x acq_rel acquire alignstack atomic catch cleanup filter inteldialect max min monotonic nand personality release seq_cst singlethread umax umin unordered xchg add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr and or xor icmp fcmp phi call trunc zext sext fptrunc fpext uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast addrspacecast select va_arg ret br switch invoke unwind unreachable indirectbr landingpad resume malloc alloca free load store getelementptr extractelement insertelement shufflevector getresult extractvalue insertvalue atomicrmw cmpxchg fence argmemonly",type:"void half bfloat float double fp128 x86_fp80 ppc_fp128 x86_amx x86_mmx ptr label token metadata opaque"},contains:[i,e.COMMENT(/;\s*$/,null,{relevance:0}),e.COMMENT(/;/,/$/),{className:"string",begin:/"/,end:/"/,contains:[{className:"char.escape",match:/\\\d\d/}]},d,s,a,u,l,o]}}return bY=t,bY}var SY,Nye;function B5t(){if(Nye)return SY;Nye=1;function t(e){const n={className:"string",begin:'"',end:'"',contains:[{className:"subst",begin:/\\[tn"\\]/}]},i={className:"number",relevance:0,begin:e.C_NUMBER_RE},a={className:"literal",variants:[{begin:"\\b(PI|TWO_PI|PI_BY_TWO|DEG_TO_RAD|RAD_TO_DEG|SQRT2)\\b"},{begin:"\\b(XP_ERROR_(EXPERIENCES_DISABLED|EXPERIENCE_(DISABLED|SUSPENDED)|INVALID_(EXPERIENCE|PARAMETERS)|KEY_NOT_FOUND|MATURITY_EXCEEDED|NONE|NOT_(FOUND|PERMITTED(_LAND)?)|NO_EXPERIENCE|QUOTA_EXCEEDED|RETRY_UPDATE|STORAGE_EXCEPTION|STORE_DISABLED|THROTTLED|UNKNOWN_ERROR)|JSON_APPEND|STATUS_(PHYSICS|ROTATE_[XYZ]|PHANTOM|SANDBOX|BLOCK_GRAB(_OBJECT)?|(DIE|RETURN)_AT_EDGE|CAST_SHADOWS|OK|MALFORMED_PARAMS|TYPE_MISMATCH|BOUNDS_ERROR|NOT_(FOUND|SUPPORTED)|INTERNAL_ERROR|WHITELIST_FAILED)|AGENT(_(BY_(LEGACY_|USER)NAME|FLYING|ATTACHMENTS|SCRIPTED|MOUSELOOK|SITTING|ON_OBJECT|AWAY|WALKING|IN_AIR|TYPING|CROUCHING|BUSY|ALWAYS_RUN|AUTOPILOT|LIST_(PARCEL(_OWNER)?|REGION)))?|CAMERA_(PITCH|DISTANCE|BEHINDNESS_(ANGLE|LAG)|(FOCUS|POSITION)(_(THRESHOLD|LOCKED|LAG))?|FOCUS_OFFSET|ACTIVE)|ANIM_ON|LOOP|REVERSE|PING_PONG|SMOOTH|ROTATE|SCALE|ALL_SIDES|LINK_(ROOT|SET|ALL_(OTHERS|CHILDREN)|THIS)|ACTIVE|PASS(IVE|_(ALWAYS|IF_NOT_HANDLED|NEVER))|SCRIPTED|CONTROL_(FWD|BACK|(ROT_)?(LEFT|RIGHT)|UP|DOWN|(ML_)?LBUTTON)|PERMISSION_(RETURN_OBJECTS|DEBIT|OVERRIDE_ANIMATIONS|SILENT_ESTATE_MANAGEMENT|TAKE_CONTROLS|TRIGGER_ANIMATION|ATTACH|CHANGE_LINKS|(CONTROL|TRACK)_CAMERA|TELEPORT)|INVENTORY_(TEXTURE|SOUND|OBJECT|SCRIPT|LANDMARK|CLOTHING|NOTECARD|BODYPART|ANIMATION|GESTURE|ALL|NONE)|CHANGED_(INVENTORY|COLOR|SHAPE|SCALE|TEXTURE|LINK|ALLOWED_DROP|OWNER|REGION(_START)?|TELEPORT|MEDIA)|OBJECT_(CLICK_ACTION|HOVER_HEIGHT|LAST_OWNER_ID|(PHYSICS|SERVER|STREAMING)_COST|UNKNOWN_DETAIL|CHARACTER_TIME|PHANTOM|PHYSICS|TEMP_(ATTACHED|ON_REZ)|NAME|DESC|POS|PRIM_(COUNT|EQUIVALENCE)|RETURN_(PARCEL(_OWNER)?|REGION)|REZZER_KEY|ROO?T|VELOCITY|OMEGA|OWNER|GROUP(_TAG)?|CREATOR|ATTACHED_(POINT|SLOTS_AVAILABLE)|RENDER_WEIGHT|(BODY_SHAPE|PATHFINDING)_TYPE|(RUNNING|TOTAL)_SCRIPT_COUNT|TOTAL_INVENTORY_COUNT|SCRIPT_(MEMORY|TIME))|TYPE_(INTEGER|FLOAT|STRING|KEY|VECTOR|ROTATION|INVALID)|(DEBUG|PUBLIC)_CHANNEL|ATTACH_(AVATAR_CENTER|CHEST|HEAD|BACK|PELVIS|MOUTH|CHIN|NECK|NOSE|BELLY|[LR](SHOULDER|HAND|FOOT|EAR|EYE|[UL](ARM|LEG)|HIP)|(LEFT|RIGHT)_PEC|HUD_(CENTER_[12]|TOP_(RIGHT|CENTER|LEFT)|BOTTOM(_(RIGHT|LEFT))?)|[LR]HAND_RING1|TAIL_(BASE|TIP)|[LR]WING|FACE_(JAW|[LR]EAR|[LR]EYE|TOUNGE)|GROIN|HIND_[LR]FOOT)|LAND_(LEVEL|RAISE|LOWER|SMOOTH|NOISE|REVERT)|DATA_(ONLINE|NAME|BORN|SIM_(POS|STATUS|RATING)|PAYINFO)|PAYMENT_INFO_(ON_FILE|USED)|REMOTE_DATA_(CHANNEL|REQUEST|REPLY)|PSYS_(PART_(BF_(ZERO|ONE(_MINUS_(DEST_COLOR|SOURCE_(ALPHA|COLOR)))?|DEST_COLOR|SOURCE_(ALPHA|COLOR))|BLEND_FUNC_(DEST|SOURCE)|FLAGS|(START|END)_(COLOR|ALPHA|SCALE|GLOW)|MAX_AGE|(RIBBON|WIND|INTERP_(COLOR|SCALE)|BOUNCE|FOLLOW_(SRC|VELOCITY)|TARGET_(POS|LINEAR)|EMISSIVE)_MASK)|SRC_(MAX_AGE|PATTERN|ANGLE_(BEGIN|END)|BURST_(RATE|PART_COUNT|RADIUS|SPEED_(MIN|MAX))|ACCEL|TEXTURE|TARGET_KEY|OMEGA|PATTERN_(DROP|EXPLODE|ANGLE(_CONE(_EMPTY)?)?)))|VEHICLE_(REFERENCE_FRAME|TYPE_(NONE|SLED|CAR|BOAT|AIRPLANE|BALLOON)|(LINEAR|ANGULAR)_(FRICTION_TIMESCALE|MOTOR_DIRECTION)|LINEAR_MOTOR_OFFSET|HOVER_(HEIGHT|EFFICIENCY|TIMESCALE)|BUOYANCY|(LINEAR|ANGULAR)_(DEFLECTION_(EFFICIENCY|TIMESCALE)|MOTOR_(DECAY_)?TIMESCALE)|VERTICAL_ATTRACTION_(EFFICIENCY|TIMESCALE)|BANKING_(EFFICIENCY|MIX|TIMESCALE)|FLAG_(NO_DEFLECTION_UP|LIMIT_(ROLL_ONLY|MOTOR_UP)|HOVER_((WATER|TERRAIN|UP)_ONLY|GLOBAL_HEIGHT)|MOUSELOOK_(STEER|BANK)|CAMERA_DECOUPLED))|PRIM_(ALLOW_UNSIT|ALPHA_MODE(_(BLEND|EMISSIVE|MASK|NONE))?|NORMAL|SPECULAR|TYPE(_(BOX|CYLINDER|PRISM|SPHERE|TORUS|TUBE|RING|SCULPT))?|HOLE_(DEFAULT|CIRCLE|SQUARE|TRIANGLE)|MATERIAL(_(STONE|METAL|GLASS|WOOD|FLESH|PLASTIC|RUBBER))?|SHINY_(NONE|LOW|MEDIUM|HIGH)|BUMP_(NONE|BRIGHT|DARK|WOOD|BARK|BRICKS|CHECKER|CONCRETE|TILE|STONE|DISKS|GRAVEL|BLOBS|SIDING|LARGETILE|STUCCO|SUCTION|WEAVE)|TEXGEN_(DEFAULT|PLANAR)|SCRIPTED_SIT_ONLY|SCULPT_(TYPE_(SPHERE|TORUS|PLANE|CYLINDER|MASK)|FLAG_(MIRROR|INVERT))|PHYSICS(_(SHAPE_(CONVEX|NONE|PRIM|TYPE)))?|(POS|ROT)_LOCAL|SLICE|TEXT|FLEXIBLE|POINT_LIGHT|TEMP_ON_REZ|PHANTOM|POSITION|SIT_TARGET|SIZE|ROTATION|TEXTURE|NAME|OMEGA|DESC|LINK_TARGET|COLOR|BUMP_SHINY|FULLBRIGHT|TEXGEN|GLOW|MEDIA_(ALT_IMAGE_ENABLE|CONTROLS|(CURRENT|HOME)_URL|AUTO_(LOOP|PLAY|SCALE|ZOOM)|FIRST_CLICK_INTERACT|(WIDTH|HEIGHT)_PIXELS|WHITELIST(_ENABLE)?|PERMS_(INTERACT|CONTROL)|PARAM_MAX|CONTROLS_(STANDARD|MINI)|PERM_(NONE|OWNER|GROUP|ANYONE)|MAX_(URL_LENGTH|WHITELIST_(SIZE|COUNT)|(WIDTH|HEIGHT)_PIXELS)))|MASK_(BASE|OWNER|GROUP|EVERYONE|NEXT)|PERM_(TRANSFER|MODIFY|COPY|MOVE|ALL)|PARCEL_(MEDIA_COMMAND_(STOP|PAUSE|PLAY|LOOP|TEXTURE|URL|TIME|AGENT|UNLOAD|AUTO_ALIGN|TYPE|SIZE|DESC|LOOP_SET)|FLAG_(ALLOW_(FLY|(GROUP_)?SCRIPTS|LANDMARK|TERRAFORM|DAMAGE|CREATE_(GROUP_)?OBJECTS)|USE_(ACCESS_(GROUP|LIST)|BAN_LIST|LAND_PASS_LIST)|LOCAL_SOUND_ONLY|RESTRICT_PUSHOBJECT|ALLOW_(GROUP|ALL)_OBJECT_ENTRY)|COUNT_(TOTAL|OWNER|GROUP|OTHER|SELECTED|TEMP)|DETAILS_(NAME|DESC|OWNER|GROUP|AREA|ID|SEE_AVATARS))|LIST_STAT_(MAX|MIN|MEAN|MEDIAN|STD_DEV|SUM(_SQUARES)?|NUM_COUNT|GEOMETRIC_MEAN|RANGE)|PAY_(HIDE|DEFAULT)|REGION_FLAG_(ALLOW_DAMAGE|FIXED_SUN|BLOCK_TERRAFORM|SANDBOX|DISABLE_(COLLISIONS|PHYSICS)|BLOCK_FLY|ALLOW_DIRECT_TELEPORT|RESTRICT_PUSHOBJECT)|HTTP_(METHOD|MIMETYPE|BODY_(MAXLENGTH|TRUNCATED)|CUSTOM_HEADER|PRAGMA_NO_CACHE|VERBOSE_THROTTLE|VERIFY_CERT)|SIT_(INVALID_(AGENT|LINK_OBJECT)|NO(T_EXPERIENCE|_(ACCESS|EXPERIENCE_PERMISSION|SIT_TARGET)))|STRING_(TRIM(_(HEAD|TAIL))?)|CLICK_ACTION_(NONE|TOUCH|SIT|BUY|PAY|OPEN(_MEDIA)?|PLAY|ZOOM)|TOUCH_INVALID_FACE|PROFILE_(NONE|SCRIPT_MEMORY)|RC_(DATA_FLAGS|DETECT_PHANTOM|GET_(LINK_NUM|NORMAL|ROOT_KEY)|MAX_HITS|REJECT_(TYPES|AGENTS|(NON)?PHYSICAL|LAND))|RCERR_(CAST_TIME_EXCEEDED|SIM_PERF_LOW|UNKNOWN)|ESTATE_ACCESS_(ALLOWED_(AGENT|GROUP)_(ADD|REMOVE)|BANNED_AGENT_(ADD|REMOVE))|DENSITY|FRICTION|RESTITUTION|GRAVITY_MULTIPLIER|KFM_(COMMAND|CMD_(PLAY|STOP|PAUSE)|MODE|FORWARD|LOOP|PING_PONG|REVERSE|DATA|ROTATION|TRANSLATION)|ERR_(GENERIC|PARCEL_PERMISSIONS|MALFORMED_PARAMS|RUNTIME_PERMISSIONS|THROTTLED)|CHARACTER_(CMD_((SMOOTH_)?STOP|JUMP)|DESIRED_(TURN_)?SPEED|RADIUS|STAY_WITHIN_PARCEL|LENGTH|ORIENTATION|ACCOUNT_FOR_SKIPPED_FRAMES|AVOIDANCE_MODE|TYPE(_([ABCD]|NONE))?|MAX_(DECEL|TURN_RADIUS|(ACCEL|SPEED)))|PURSUIT_(OFFSET|FUZZ_FACTOR|GOAL_TOLERANCE|INTERCEPT)|REQUIRE_LINE_OF_SIGHT|FORCE_DIRECT_PATH|VERTICAL|HORIZONTAL|AVOID_(CHARACTERS|DYNAMIC_OBSTACLES|NONE)|PU_(EVADE_(HIDDEN|SPOTTED)|FAILURE_(DYNAMIC_PATHFINDING_DISABLED|INVALID_(GOAL|START)|NO_(NAVMESH|VALID_DESTINATION)|OTHER|TARGET_GONE|(PARCEL_)?UNREACHABLE)|(GOAL|SLOWDOWN_DISTANCE)_REACHED)|TRAVERSAL_TYPE(_(FAST|NONE|SLOW))?|CONTENT_TYPE_(ATOM|FORM|HTML|JSON|LLSD|RSS|TEXT|XHTML|XML)|GCNP_(RADIUS|STATIC)|(PATROL|WANDER)_PAUSE_AT_WAYPOINTS|OPT_(AVATAR|CHARACTER|EXCLUSION_VOLUME|LEGACY_LINKSET|MATERIAL_VOLUME|OTHER|STATIC_OBSTACLE|WALKABLE)|SIM_STAT_PCT_CHARS_STEPPED)\\b"},{begin:"\\b(FALSE|TRUE)\\b"},{begin:"\\b(ZERO_ROTATION)\\b"},{begin:"\\b(EOF|JSON_(ARRAY|DELETE|FALSE|INVALID|NULL|NUMBER|OBJECT|STRING|TRUE)|NULL_KEY|TEXTURE_(BLANK|DEFAULT|MEDIA|PLYWOOD|TRANSPARENT)|URL_REQUEST_(GRANTED|DENIED))\\b"},{begin:"\\b(ZERO_VECTOR|TOUCH_INVALID_(TEXCOORD|VECTOR))\\b"}]},s={className:"built_in",begin:"\\b(ll(AgentInExperience|(Create|DataSize|Delete|KeyCount|Keys|Read|Update)KeyValue|GetExperience(Details|ErrorMessage)|ReturnObjectsBy(ID|Owner)|Json(2List|[GS]etValue|ValueType)|Sin|Cos|Tan|Atan2|Sqrt|Pow|Abs|Fabs|Frand|Floor|Ceil|Round|Vec(Mag|Norm|Dist)|Rot(Between|2(Euler|Fwd|Left|Up))|(Euler|Axes)2Rot|Whisper|(Region|Owner)?Say|Shout|Listen(Control|Remove)?|Sensor(Repeat|Remove)?|Detected(Name|Key|Owner|Type|Pos|Vel|Grab|Rot|Group|LinkNumber)|Die|Ground|Wind|([GS]et)(AnimationOverride|MemoryLimit|PrimMediaParams|ParcelMusicURL|Object(Desc|Name)|PhysicsMaterial|Status|Scale|Color|Alpha|Texture|Pos|Rot|Force|Torque)|ResetAnimationOverride|(Scale|Offset|Rotate)Texture|(Rot)?Target(Remove)?|(Stop)?MoveToTarget|Apply(Rotational)?Impulse|Set(KeyframedMotion|ContentType|RegionPos|(Angular)?Velocity|Buoyancy|HoverHeight|ForceAndTorque|TimerEvent|ScriptState|Damage|TextureAnim|Sound(Queueing|Radius)|Vehicle(Type|(Float|Vector|Rotation)Param)|(Touch|Sit)?Text|Camera(Eye|At)Offset|PrimitiveParams|ClickAction|Link(Alpha|Color|PrimitiveParams(Fast)?|Texture(Anim)?|Camera|Media)|RemoteScriptAccessPin|PayPrice|LocalRot)|ScaleByFactor|Get((Max|Min)ScaleFactor|ClosestNavPoint|StaticPath|SimStats|Env|PrimitiveParams|Link(PrimitiveParams|Number(OfSides)?|Key|Name|Media)|HTTPHeader|FreeURLs|Object(Details|PermMask|PrimCount)|Parcel(MaxPrims|Details|Prim(Count|Owners))|Attached(List)?|(SPMax|Free|Used)Memory|Region(Name|TimeDilation|FPS|Corner|AgentCount)|Root(Position|Rotation)|UnixTime|(Parcel|Region)Flags|(Wall|GMT)clock|SimulatorHostname|BoundingBox|GeometricCenter|Creator|NumberOf(Prims|NotecardLines|Sides)|Animation(List)?|(Camera|Local)(Pos|Rot)|Vel|Accel|Omega|Time(stamp|OfDay)|(Object|CenterOf)?Mass|MassMKS|Energy|Owner|(Owner)?Key|SunDirection|Texture(Offset|Scale|Rot)|Inventory(Number|Name|Key|Type|Creator|PermMask)|Permissions(Key)?|StartParameter|List(Length|EntryType)|Date|Agent(Size|Info|Language|List)|LandOwnerAt|NotecardLine|Script(Name|State))|(Get|Reset|GetAndReset)Time|PlaySound(Slave)?|LoopSound(Master|Slave)?|(Trigger|Stop|Preload)Sound|((Get|Delete)Sub|Insert)String|To(Upper|Lower)|Give(InventoryList|Money)|RezObject|(Stop)?LookAt|Sleep|CollisionFilter|(Take|Release)Controls|DetachFromAvatar|AttachToAvatar(Temp)?|InstantMessage|(GetNext)?Email|StopHover|MinEventDelay|RotLookAt|String(Length|Trim)|(Start|Stop)Animation|TargetOmega|Request(Experience)?Permissions|(Create|Break)Link|BreakAllLinks|(Give|Remove)Inventory|Water|PassTouches|Request(Agent|Inventory)Data|TeleportAgent(Home|GlobalCoords)?|ModifyLand|CollisionSound|ResetScript|MessageLinked|PushObject|PassCollisions|AxisAngle2Rot|Rot2(Axis|Angle)|A(cos|sin)|AngleBetween|AllowInventoryDrop|SubStringIndex|List2(CSV|Integer|Json|Float|String|Key|Vector|Rot|List(Strided)?)|DeleteSubList|List(Statistics|Sort|Randomize|(Insert|Find|Replace)List)|EdgeOfWorld|AdjustSoundVolume|Key2Name|TriggerSoundLimited|EjectFromLand|(CSV|ParseString)2List|OverMyLand|SameGroup|UnSit|Ground(Slope|Normal|Contour)|GroundRepel|(Set|Remove)VehicleFlags|SitOnLink|(AvatarOn)?(Link)?SitTarget|Script(Danger|Profiler)|Dialog|VolumeDetect|ResetOtherScript|RemoteLoadScriptPin|(Open|Close)RemoteDataChannel|SendRemoteData|RemoteDataReply|(Integer|String)ToBase64|XorBase64|Log(10)?|Base64To(String|Integer)|ParseStringKeepNulls|RezAtRoot|RequestSimulatorData|ForceMouselook|(Load|Release|(E|Une)scape)URL|ParcelMedia(CommandList|Query)|ModPow|MapDestination|(RemoveFrom|AddTo|Reset)Land(Pass|Ban)List|(Set|Clear)CameraParams|HTTP(Request|Response)|TextBox|DetectedTouch(UV|Face|Pos|(N|Bin)ormal|ST)|(MD5|SHA1|DumpList2)String|Request(Secure)?URL|Clear(Prim|Link)Media|(Link)?ParticleSystem|(Get|Request)(Username|DisplayName)|RegionSayTo|CastRay|GenerateKey|TransferLindenDollars|ManageEstateAccess|(Create|Delete)Character|ExecCharacterCmd|Evade|FleeFrom|NavigateTo|PatrolPoints|Pursue|UpdateCharacter|WanderWithin))\\b"};return{name:"LSL (Linden Scripting Language)",illegal:":",contains:[n,{className:"comment",variants:[e.COMMENT("//","$"),e.COMMENT("/\\*","\\*/")],relevance:0},i,{className:"section",variants:[{begin:"\\b(state|default)\\b"},{begin:"\\b(state_(entry|exit)|touch(_(start|end))?|(land_)?collision(_(start|end))?|timer|listen|(no_)?sensor|control|(not_)?at_(rot_)?target|money|email|experience_permissions(_denied)?|run_time_permissions|changed|attach|dataserver|moving_(start|end)|link_message|(on|object)_rez|remote_data|http_re(sponse|quest)|path_update|transaction_result)\\b"}]},s,a,{className:"type",begin:"\\b(integer|float|string|key|vector|quaternion|rotation|list)\\b"}]}}return SY=t,SY}var EY,Oye;function U5t(){if(Oye)return EY;Oye=1;function t(e){const r="\\[=*\\[",n="\\]=*\\]",i={begin:r,end:n,contains:["self"]},a=[e.COMMENT("--(?!"+r+")","$"),e.COMMENT("--"+r,n,{contains:[i],relevance:10})];return{name:"Lua",aliases:["pluto"],keywords:{$pattern:e.UNDERSCORE_IDENT_RE,literal:"true false nil",keyword:"and break do else elseif end for goto if in local not or repeat return then until while",built_in:"_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len __gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall arg self coroutine resume yield status wrap create running debug getupvalue debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv io lines write close flush open output type read stderr stdin input stdout popen tmpfile math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower table setn insert getn foreachi maxn foreach concat sort remove"},contains:a.concat([{className:"function",beginKeywords:"function",end:"\\)",contains:[e.inherit(e.TITLE_MODE,{begin:"([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"}),{className:"params",begin:"\\(",endsWithParent:!0,contains:a}].concat(a)},e.C_NUMBER_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:r,end:n,contains:[i],relevance:5}])}}return EY=t,EY}var TY,Iye;function $5t(){if(Iye)return TY;Iye=1;function t(e){const r={className:"variable",variants:[{begin:"\\$\\("+e.UNDERSCORE_IDENT_RE+"\\)",contains:[e.BACKSLASH_ESCAPE]},{begin:/\$[@%{m.has(w[0])||x.ignoreMatch()}},{className:"symbol",relevance:0,begin:g}]},v={className:"named-character",begin:/\\\[[$a-zA-Z][$a-zA-Z0-9]+\]/},b={className:"operator",relevance:0,begin:/[+\-*/,;.:@~=><&|_`'^?!%]+/},y={className:"pattern",relevance:0,begin:/([a-zA-Z$][a-zA-Z0-9$]*)?_+([a-zA-Z$][a-zA-Z0-9$]*)?/},E={className:"slot",relevance:0,begin:/#[a-zA-Z$][a-zA-Z0-9$]*|#+[0-9]?/},T={className:"brace",relevance:0,begin:/[[\](){}]/},C={className:"message-name",relevance:0,begin:n.concat("::",g)};return{name:"Mathematica",aliases:["mma","wl"],classNameAliases:{brace:"punctuation",pattern:"type",slot:"type",symbol:"variable","named-character":"variable","builtin-symbol":"built_in","message-name":"string"},contains:[r.COMMENT(/\(\*/,/\*\)/,{contains:["self"]}),y,E,C,_,v,r.QUOTE_STRING_MODE,p,b,T]}}return CY=e,CY}var wY,Dye;function z5t(){if(Dye)return wY;Dye=1;function t(e){const r="('|\\.')+",n={relevance:0,contains:[{begin:r}]};return{name:"Matlab",keywords:{keyword:"arguments break case catch classdef continue else elseif end enumeration events for function global if methods otherwise parfor persistent properties return spmd switch try while",built_in:"sin sind sinh asin asind asinh cos cosd cosh acos acosd acosh tan tand tanh atan atand atan2 atanh sec secd sech asec asecd asech csc cscd csch acsc acscd acsch cot cotd coth acot acotd acoth hypot exp expm1 log log1p log10 log2 pow2 realpow reallog realsqrt sqrt nthroot nextpow2 abs angle complex conj imag real unwrap isreal cplxpair fix floor ceil round mod rem sign airy besselj bessely besselh besseli besselk beta betainc betaln ellipj ellipke erf erfc erfcx erfinv expint gamma gammainc gammaln psi legendre cross dot factor isprime primes gcd lcm rat rats perms nchoosek factorial cart2sph cart2pol pol2cart sph2cart hsv2rgb rgb2hsv zeros ones eye repmat rand randn linspace logspace freqspace meshgrid accumarray size length ndims numel disp isempty isequal isequalwithequalnans cat reshape diag blkdiag tril triu fliplr flipud flipdim rot90 find sub2ind ind2sub bsxfun ndgrid permute ipermute shiftdim circshift squeeze isscalar isvector ans eps realmax realmin pi i|0 inf nan isnan isinf isfinite j|0 why compan gallery hadamard hankel hilb invhilb magic pascal rosser toeplitz vander wilkinson max min nanmax nanmin mean nanmean type table readtable writetable sortrows sort figure plot plot3 scatter scatter3 cellfun legend intersect ismember procrustes hold num2cell "},illegal:'(//|"|#|/\\*|\\s+/\\w+)',contains:[{className:"function",beginKeywords:"function",end:"$",contains:[e.UNDERSCORE_TITLE_MODE,{className:"params",variants:[{begin:"\\(",end:"\\)"},{begin:"\\[",end:"\\]"}]}]},{className:"built_in",begin:/true|false/,relevance:0,starts:n},{begin:"[a-zA-Z][a-zA-Z_0-9]*"+r,relevance:0},{className:"number",begin:e.C_NUMBER_RE,relevance:0,starts:n},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{begin:/\]|\}|\)/,relevance:0,starts:n},{className:"string",begin:'"',end:'"',contains:[{begin:'""'}],starts:n},e.COMMENT("^\\s*%\\{\\s*$","^\\s*%\\}\\s*$"),e.COMMENT("%","$")]}}return wY=t,wY}var xY,Mye;function q5t(){if(Mye)return xY;Mye=1;function t(e){return{name:"Maxima",keywords:{$pattern:"[A-Za-z_%][0-9A-Za-z_%]*",keyword:"if then else elseif for thru do while unless step in and or not",literal:"true false unknown inf minf ind und %e %i %pi %phi %gamma",built_in:" abasep abs absint absolute_real_time acos acosh acot acoth acsc acsch activate addcol add_edge add_edges addmatrices addrow add_vertex add_vertices adjacency_matrix adjoin adjoint af agd airy airy_ai airy_bi airy_dai airy_dbi algsys alg_type alias allroots alphacharp alphanumericp amortization %and annuity_fv annuity_pv antid antidiff AntiDifference append appendfile apply apply1 apply2 applyb1 apropos args arit_amortization arithmetic arithsum array arrayapply arrayinfo arraymake arraysetapply ascii asec asech asin asinh askinteger asksign assoc assoc_legendre_p assoc_legendre_q assume assume_external_byte_order asympa at atan atan2 atanh atensimp atom atvalue augcoefmatrix augmented_lagrangian_method av average_degree backtrace bars barsplot barsplot_description base64 base64_decode bashindices batch batchload bc2 bdvac belln benefit_cost bern bernpoly bernstein_approx bernstein_expand bernstein_poly bessel bessel_i bessel_j bessel_k bessel_simplify bessel_y beta beta_incomplete beta_incomplete_generalized beta_incomplete_regularized bezout bfallroots bffac bf_find_root bf_fmin_cobyla bfhzeta bfloat bfloatp bfpsi bfpsi0 bfzeta biconnected_components bimetric binomial bipartition block blockmatrixp bode_gain bode_phase bothcoef box boxplot boxplot_description break bug_report build_info|10 buildq build_sample burn cabs canform canten cardinality carg cartan cartesian_product catch cauchy_matrix cbffac cdf_bernoulli cdf_beta cdf_binomial cdf_cauchy cdf_chi2 cdf_continuous_uniform cdf_discrete_uniform cdf_exp cdf_f cdf_gamma cdf_general_finite_discrete cdf_geometric cdf_gumbel cdf_hypergeometric cdf_laplace cdf_logistic cdf_lognormal cdf_negative_binomial cdf_noncentral_chi2 cdf_noncentral_student_t cdf_normal cdf_pareto cdf_poisson cdf_rank_sum cdf_rayleigh cdf_signed_rank cdf_student_t cdf_weibull cdisplay ceiling central_moment cequal cequalignore cf cfdisrep cfexpand cgeodesic cgreaterp cgreaterpignore changename changevar chaosgame charat charfun charfun2 charlist charp charpoly chdir chebyshev_t chebyshev_u checkdiv check_overlaps chinese cholesky christof chromatic_index chromatic_number cint circulant_graph clear_edge_weight clear_rules clear_vertex_label clebsch_gordan clebsch_graph clessp clesspignore close closefile cmetric coeff coefmatrix cograd col collapse collectterms columnop columnspace columnswap columnvector combination combine comp2pui compare compfile compile compile_file complement_graph complete_bipartite_graph complete_graph complex_number_p components compose_functions concan concat conjugate conmetderiv connected_components connect_vertices cons constant constantp constituent constvalue cont2part content continuous_freq contortion contour_plot contract contract_edge contragrad contrib_ode convert coord copy copy_file copy_graph copylist copymatrix cor cos cosh cot coth cov cov1 covdiff covect covers crc24sum create_graph create_list csc csch csetup cspline ctaylor ct_coordsys ctransform ctranspose cube_graph cuboctahedron_graph cunlisp cv cycle_digraph cycle_graph cylindrical days360 dblint deactivate declare declare_constvalue declare_dimensions declare_fundamental_dimensions declare_fundamental_units declare_qty declare_translated declare_unit_conversion declare_units declare_weights decsym defcon define define_alt_display define_variable defint defmatch defrule defstruct deftaylor degree_sequence del delete deleten delta demo demoivre denom depends derivdegree derivlist describe desolve determinant dfloat dgauss_a dgauss_b dgeev dgemm dgeqrf dgesv dgesvd diag diagmatrix diag_matrix diagmatrixp diameter diff digitcharp dimacs_export dimacs_import dimension dimensionless dimensions dimensions_as_list direct directory discrete_freq disjoin disjointp disolate disp dispcon dispform dispfun dispJordan display disprule dispterms distrib divide divisors divsum dkummer_m dkummer_u dlange dodecahedron_graph dotproduct dotsimp dpart draw draw2d draw3d drawdf draw_file draw_graph dscalar echelon edge_coloring edge_connectivity edges eigens_by_jacobi eigenvalues eigenvectors eighth einstein eivals eivects elapsed_real_time elapsed_run_time ele2comp ele2polynome ele2pui elem elementp elevation_grid elim elim_allbut eliminate eliminate_using ellipse elliptic_e elliptic_ec elliptic_eu elliptic_f elliptic_kc elliptic_pi ematrix empty_graph emptyp endcons entermatrix entertensor entier equal equalp equiv_classes erf erfc erf_generalized erfi errcatch error errormsg errors euler ev eval_string evenp every evolution evolution2d evundiff example exp expand expandwrt expandwrt_factored expint expintegral_chi expintegral_ci expintegral_e expintegral_e1 expintegral_ei expintegral_e_simplify expintegral_li expintegral_shi expintegral_si explicit explose exponentialize express expt exsec extdiff extract_linear_equations extremal_subset ezgcd %f f90 facsum factcomb factor factorfacsum factorial factorout factorsum facts fast_central_elements fast_linsolve fasttimes featurep fernfale fft fib fibtophi fifth filename_merge file_search file_type fillarray findde find_root find_root_abs find_root_error find_root_rel first fix flatten flength float floatnump floor flower_snark flush flush1deriv flushd flushnd flush_output fmin_cobyla forget fortran fourcos fourexpand fourier fourier_elim fourint fourintcos fourintsin foursimp foursin fourth fposition frame_bracket freeof freshline fresnel_c fresnel_s from_adjacency_matrix frucht_graph full_listify fullmap fullmapl fullratsimp fullratsubst fullsetify funcsolve fundamental_dimensions fundamental_units fundef funmake funp fv g0 g1 gamma gamma_greek gamma_incomplete gamma_incomplete_generalized gamma_incomplete_regularized gauss gauss_a gauss_b gaussprob gcd gcdex gcdivide gcfac gcfactor gd generalized_lambert_w genfact gen_laguerre genmatrix gensym geo_amortization geo_annuity_fv geo_annuity_pv geomap geometric geometric_mean geosum get getcurrentdirectory get_edge_weight getenv get_lu_factors get_output_stream_string get_pixel get_plot_option get_tex_environment get_tex_environment_default get_vertex_label gfactor gfactorsum ggf girth global_variances gn gnuplot_close gnuplot_replot gnuplot_reset gnuplot_restart gnuplot_start go Gosper GosperSum gr2d gr3d gradef gramschmidt graph6_decode graph6_encode graph6_export graph6_import graph_center graph_charpoly graph_eigenvalues graph_flow graph_order graph_periphery graph_product graph_size graph_union great_rhombicosidodecahedron_graph great_rhombicuboctahedron_graph grid_graph grind grobner_basis grotzch_graph hamilton_cycle hamilton_path hankel hankel_1 hankel_2 harmonic harmonic_mean hav heawood_graph hermite hessian hgfred hilbertmap hilbert_matrix hipow histogram histogram_description hodge horner hypergeometric i0 i1 %ibes ic1 ic2 ic_convert ichr1 ichr2 icosahedron_graph icosidodecahedron_graph icurvature ident identfor identity idiff idim idummy ieqn %if ifactors iframes ifs igcdex igeodesic_coords ilt image imagpart imetric implicit implicit_derivative implicit_plot indexed_tensor indices induced_subgraph inferencep inference_result infix info_display init_atensor init_ctensor in_neighbors innerproduct inpart inprod inrt integerp integer_partitions integrate intersect intersection intervalp intopois intosum invariant1 invariant2 inverse_fft inverse_jacobi_cd inverse_jacobi_cn inverse_jacobi_cs inverse_jacobi_dc inverse_jacobi_dn inverse_jacobi_ds inverse_jacobi_nc inverse_jacobi_nd inverse_jacobi_ns inverse_jacobi_sc inverse_jacobi_sd inverse_jacobi_sn invert invert_by_adjoint invert_by_lu inv_mod irr is is_biconnected is_bipartite is_connected is_digraph is_edge_in_graph is_graph is_graph_or_digraph ishow is_isomorphic isolate isomorphism is_planar isqrt isreal_p is_sconnected is_tree is_vertex_in_graph items_inference %j j0 j1 jacobi jacobian jacobi_cd jacobi_cn jacobi_cs jacobi_dc jacobi_dn jacobi_ds jacobi_nc jacobi_nd jacobi_ns jacobi_p jacobi_sc jacobi_sd jacobi_sn JF jn join jordan julia julia_set julia_sin %k kdels kdelta kill killcontext kostka kron_delta kronecker_product kummer_m kummer_u kurtosis kurtosis_bernoulli kurtosis_beta kurtosis_binomial kurtosis_chi2 kurtosis_continuous_uniform kurtosis_discrete_uniform kurtosis_exp kurtosis_f kurtosis_gamma kurtosis_general_finite_discrete kurtosis_geometric kurtosis_gumbel kurtosis_hypergeometric kurtosis_laplace kurtosis_logistic kurtosis_lognormal kurtosis_negative_binomial kurtosis_noncentral_chi2 kurtosis_noncentral_student_t kurtosis_normal kurtosis_pareto kurtosis_poisson kurtosis_rayleigh kurtosis_student_t kurtosis_weibull label labels lagrange laguerre lambda lambert_w laplace laplacian_matrix last lbfgs lc2kdt lcharp lc_l lcm lc_u ldefint ldisp ldisplay legendre_p legendre_q leinstein length let letrules letsimp levi_civita lfreeof lgtreillis lhs li liediff limit Lindstedt linear linearinterpol linear_program linear_regression line_graph linsolve listarray list_correlations listify list_matrix_entries list_nc_monomials listoftens listofvars listp lmax lmin load loadfile local locate_matrix_entry log logcontract log_gamma lopow lorentz_gauge lowercasep lpart lratsubst lreduce lriemann lsquares_estimates lsquares_estimates_approximate lsquares_estimates_exact lsquares_mse lsquares_residual_mse lsquares_residuals lsum ltreillis lu_backsub lucas lu_factor %m macroexpand macroexpand1 make_array makebox makefact makegamma make_graph make_level_picture makelist makeOrders make_poly_continent make_poly_country make_polygon make_random_state make_rgb_picture makeset make_string_input_stream make_string_output_stream make_transform mandelbrot mandelbrot_set map mapatom maplist matchdeclare matchfix mat_cond mat_fullunblocker mat_function mathml_display mat_norm matrix matrixmap matrixp matrix_size mattrace mat_trace mat_unblocker max max_clique max_degree max_flow maximize_lp max_independent_set max_matching maybe md5sum mean mean_bernoulli mean_beta mean_binomial mean_chi2 mean_continuous_uniform mean_deviation mean_discrete_uniform mean_exp mean_f mean_gamma mean_general_finite_discrete mean_geometric mean_gumbel mean_hypergeometric mean_laplace mean_logistic mean_lognormal mean_negative_binomial mean_noncentral_chi2 mean_noncentral_student_t mean_normal mean_pareto mean_poisson mean_rayleigh mean_student_t mean_weibull median median_deviation member mesh metricexpandall mgf1_sha1 min min_degree min_edge_cut minfactorial minimalPoly minimize_lp minimum_spanning_tree minor minpack_lsquares minpack_solve min_vertex_cover min_vertex_cut mkdir mnewton mod mode_declare mode_identity ModeMatrix moebius mon2schur mono monomial_dimensions multibernstein_poly multi_display_for_texinfo multi_elem multinomial multinomial_coeff multi_orbit multiplot_mode multi_pui multsym multthru mycielski_graph nary natural_unit nc_degree ncexpt ncharpoly negative_picture neighbors new newcontext newdet new_graph newline newton new_variable next_prime nicedummies niceindices ninth nofix nonarray noncentral_moment nonmetricity nonnegintegerp nonscalarp nonzeroandfreeof notequal nounify nptetrad npv nroots nterms ntermst nthroot nullity nullspace num numbered_boundaries numberp number_to_octets num_distinct_partitions numerval numfactor num_partitions nusum nzeta nzetai nzetar octets_to_number octets_to_oid odd_girth oddp ode2 ode_check odelin oid_to_octets op opena opena_binary openr openr_binary openw openw_binary operatorp opsubst optimize %or orbit orbits ordergreat ordergreatp orderless orderlessp orthogonal_complement orthopoly_recur orthopoly_weight outermap out_neighbors outofpois pade parabolic_cylinder_d parametric parametric_surface parg parGosper parse_string parse_timedate part part2cont partfrac partition partition_set partpol path_digraph path_graph pathname_directory pathname_name pathname_type pdf_bernoulli pdf_beta pdf_binomial pdf_cauchy pdf_chi2 pdf_continuous_uniform pdf_discrete_uniform pdf_exp pdf_f pdf_gamma pdf_general_finite_discrete pdf_geometric pdf_gumbel pdf_hypergeometric pdf_laplace pdf_logistic pdf_lognormal pdf_negative_binomial pdf_noncentral_chi2 pdf_noncentral_student_t pdf_normal pdf_pareto pdf_poisson pdf_rank_sum pdf_rayleigh pdf_signed_rank pdf_student_t pdf_weibull pearson_skewness permanent permut permutation permutations petersen_graph petrov pickapart picture_equalp picturep piechart piechart_description planar_embedding playback plog plot2d plot3d plotdf ploteq plsquares pochhammer points poisdiff poisexpt poisint poismap poisplus poissimp poissubst poistimes poistrim polar polarform polartorect polar_to_xy poly_add poly_buchberger poly_buchberger_criterion poly_colon_ideal poly_content polydecomp poly_depends_p poly_elimination_ideal poly_exact_divide poly_expand poly_expt poly_gcd polygon poly_grobner poly_grobner_equal poly_grobner_member poly_grobner_subsetp poly_ideal_intersection poly_ideal_polysaturation poly_ideal_polysaturation1 poly_ideal_saturation poly_ideal_saturation1 poly_lcm poly_minimization polymod poly_multiply polynome2ele polynomialp poly_normal_form poly_normalize poly_normalize_list poly_polysaturation_extension poly_primitive_part poly_pseudo_divide poly_reduced_grobner poly_reduction poly_saturation_extension poly_s_polynomial poly_subtract polytocompanion pop postfix potential power_mod powerseries powerset prefix prev_prime primep primes principal_components print printf printfile print_graph printpois printprops prodrac product properties propvars psi psubst ptriangularize pui pui2comp pui2ele pui2polynome pui_direct puireduc push put pv qput qrange qty quad_control quad_qag quad_qagi quad_qagp quad_qags quad_qawc quad_qawf quad_qawo quad_qaws quadrilateral quantile quantile_bernoulli quantile_beta quantile_binomial quantile_cauchy quantile_chi2 quantile_continuous_uniform quantile_discrete_uniform quantile_exp quantile_f quantile_gamma quantile_general_finite_discrete quantile_geometric quantile_gumbel quantile_hypergeometric quantile_laplace quantile_logistic quantile_lognormal quantile_negative_binomial quantile_noncentral_chi2 quantile_noncentral_student_t quantile_normal quantile_pareto quantile_poisson quantile_rayleigh quantile_student_t quantile_weibull quartile_skewness quit qunit quotient racah_v racah_w radcan radius random random_bernoulli random_beta random_binomial random_bipartite_graph random_cauchy random_chi2 random_continuous_uniform random_digraph random_discrete_uniform random_exp random_f random_gamma random_general_finite_discrete random_geometric random_graph random_graph1 random_gumbel random_hypergeometric random_laplace random_logistic random_lognormal random_negative_binomial random_network random_noncentral_chi2 random_noncentral_student_t random_normal random_pareto random_permutation random_poisson random_rayleigh random_regular_graph random_student_t random_tournament random_tree random_weibull range rank rat ratcoef ratdenom ratdiff ratdisrep ratexpand ratinterpol rational rationalize ratnumer ratnump ratp ratsimp ratsubst ratvars ratweight read read_array read_binary_array read_binary_list read_binary_matrix readbyte readchar read_hashed_array readline read_list read_matrix read_nested_list readonly read_xpm real_imagpart_to_conjugate realpart realroots rearray rectangle rectform rectform_log_if_constant recttopolar rediff reduce_consts reduce_order region region_boundaries region_boundaries_plus rem remainder remarray rembox remcomps remcon remcoord remfun remfunction remlet remove remove_constvalue remove_dimensions remove_edge remove_fundamental_dimensions remove_fundamental_units remove_plot_option remove_vertex rempart remrule remsym remvalue rename rename_file reset reset_displays residue resolvante resolvante_alternee1 resolvante_bipartite resolvante_diedrale resolvante_klein resolvante_klein3 resolvante_produit_sym resolvante_unitaire resolvante_vierer rest resultant return reveal reverse revert revert2 rgb2level rhs ricci riemann rinvariant risch rk rmdir rncombine romberg room rootscontract round row rowop rowswap rreduce run_testsuite %s save saving scalarp scaled_bessel_i scaled_bessel_i0 scaled_bessel_i1 scalefactors scanmap scatterplot scatterplot_description scene schur2comp sconcat scopy scsimp scurvature sdowncase sec sech second sequal sequalignore set_alt_display setdifference set_draw_defaults set_edge_weight setelmx setequalp setify setp set_partitions set_plot_option set_prompt set_random_state set_tex_environment set_tex_environment_default setunits setup_autoload set_up_dot_simplifications set_vertex_label seventh sexplode sf sha1sum sha256sum shortest_path shortest_weighted_path show showcomps showratvars sierpinskiale sierpinskimap sign signum similaritytransform simp_inequality simplify_sum simplode simpmetderiv simtran sin sinh sinsert sinvertcase sixth skewness skewness_bernoulli skewness_beta skewness_binomial skewness_chi2 skewness_continuous_uniform skewness_discrete_uniform skewness_exp skewness_f skewness_gamma skewness_general_finite_discrete skewness_geometric skewness_gumbel skewness_hypergeometric skewness_laplace skewness_logistic skewness_lognormal skewness_negative_binomial skewness_noncentral_chi2 skewness_noncentral_student_t skewness_normal skewness_pareto skewness_poisson skewness_rayleigh skewness_student_t skewness_weibull slength smake small_rhombicosidodecahedron_graph small_rhombicuboctahedron_graph smax smin smismatch snowmap snub_cube_graph snub_dodecahedron_graph solve solve_rec solve_rec_rat some somrac sort sparse6_decode sparse6_encode sparse6_export sparse6_import specint spherical spherical_bessel_j spherical_bessel_y spherical_hankel1 spherical_hankel2 spherical_harmonic spherical_to_xyz splice split sposition sprint sqfr sqrt sqrtdenest sremove sremovefirst sreverse ssearch ssort sstatus ssubst ssubstfirst staircase standardize standardize_inverse_trig starplot starplot_description status std std1 std_bernoulli std_beta std_binomial std_chi2 std_continuous_uniform std_discrete_uniform std_exp std_f std_gamma std_general_finite_discrete std_geometric std_gumbel std_hypergeometric std_laplace std_logistic std_lognormal std_negative_binomial std_noncentral_chi2 std_noncentral_student_t std_normal std_pareto std_poisson std_rayleigh std_student_t std_weibull stemplot stirling stirling1 stirling2 strim striml strimr string stringout stringp strong_components struve_h struve_l sublis sublist sublist_indices submatrix subsample subset subsetp subst substinpart subst_parallel substpart substring subvar subvarp sum sumcontract summand_to_rec supcase supcontext symbolp symmdifference symmetricp system take_channel take_inference tan tanh taylor taylorinfo taylorp taylor_simplifier taytorat tcl_output tcontract tellrat tellsimp tellsimpafter tentex tenth test_mean test_means_difference test_normality test_proportion test_proportions_difference test_rank_sum test_sign test_signed_rank test_variance test_variance_ratio tex tex1 tex_display texput %th third throw time timedate timer timer_info tldefint tlimit todd_coxeter toeplitz tokens to_lisp topological_sort to_poly to_poly_solve totaldisrep totalfourier totient tpartpol trace tracematrix trace_options transform_sample translate translate_file transpose treefale tree_reduce treillis treinat triangle triangularize trigexpand trigrat trigreduce trigsimp trunc truncate truncated_cube_graph truncated_dodecahedron_graph truncated_icosahedron_graph truncated_tetrahedron_graph tr_warnings_get tube tutte_graph ueivects uforget ultraspherical underlying_graph undiff union unique uniteigenvectors unitp units unit_step unitvector unorder unsum untellrat untimer untrace uppercasep uricci uriemann uvect vandermonde_matrix var var1 var_bernoulli var_beta var_binomial var_chi2 var_continuous_uniform var_discrete_uniform var_exp var_f var_gamma var_general_finite_discrete var_geometric var_gumbel var_hypergeometric var_laplace var_logistic var_lognormal var_negative_binomial var_noncentral_chi2 var_noncentral_student_t var_normal var_pareto var_poisson var_rayleigh var_student_t var_weibull vector vectorpotential vectorsimp verbify vers vertex_coloring vertex_connectivity vertex_degree vertex_distance vertex_eccentricity vertex_in_degree vertex_out_degree vertices vertices_to_cycle vertices_to_path %w weyl wheel_graph wiener_index wigner_3j wigner_6j wigner_9j with_stdout write_binary_data writebyte write_data writefile wronskian xreduce xthru %y Zeilberger zeroequiv zerofor zeromatrix zeromatrixp zeta zgeev zheev zlange zn_add_table zn_carmichael_lambda zn_characteristic_factors zn_determinant zn_factor_generators zn_invert_by_lu zn_log zn_mult_table absboxchar activecontexts adapt_depth additive adim aform algebraic algepsilon algexact aliases allbut all_dotsimp_denoms allocation allsym alphabetic animation antisymmetric arrays askexp assume_pos assume_pos_pred assumescalar asymbol atomgrad atrig1 axes axis_3d axis_bottom axis_left axis_right axis_top azimuth background background_color backsubst berlefact bernstein_explicit besselexpand beta_args_sum_to_integer beta_expand bftorat bftrunc bindtest border boundaries_array box boxchar breakup %c capping cauchysum cbrange cbtics center cflength cframe_flag cnonmet_flag color color_bar color_bar_tics colorbox columns commutative complex cone context contexts contour contour_levels cosnpiflag ctaypov ctaypt ctayswitch ctayvar ct_coords ctorsion_flag ctrgsimp cube current_let_rule_package cylinder data_file_name debugmode decreasing default_let_rule_package delay dependencies derivabbrev derivsubst detout diagmetric diff dim dimensions dispflag display2d|10 display_format_internal distribute_over doallmxops domain domxexpt domxmxops domxnctimes dontfactor doscmxops doscmxplus dot0nscsimp dot0simp dot1simp dotassoc dotconstrules dotdistrib dotexptsimp dotident dotscrules draw_graph_program draw_realpart edge_color edge_coloring edge_partition edge_type edge_width %edispflag elevation %emode endphi endtheta engineering_format_floats enhanced3d %enumer epsilon_lp erfflag erf_representation errormsg error_size error_syms error_type %e_to_numlog eval even evenfun evflag evfun ev_point expandwrt_denom expintexpand expintrep expon expop exptdispflag exptisolate exptsubst facexpand facsum_combine factlim factorflag factorial_expand factors_only fb feature features file_name file_output_append file_search_demo file_search_lisp file_search_maxima|10 file_search_tests file_search_usage file_type_lisp file_type_maxima|10 fill_color fill_density filled_func fixed_vertices flipflag float2bf font font_size fortindent fortspaces fpprec fpprintprec functions gamma_expand gammalim gdet genindex gensumnum GGFCFMAX GGFINFINITY globalsolve gnuplot_command gnuplot_curve_styles gnuplot_curve_titles gnuplot_default_term_command gnuplot_dumb_term_command gnuplot_file_args gnuplot_file_name gnuplot_out_file gnuplot_pdf_term_command gnuplot_pm3d gnuplot_png_term_command gnuplot_postamble gnuplot_preamble gnuplot_ps_term_command gnuplot_svg_term_command gnuplot_term gnuplot_view_args Gosper_in_Zeilberger gradefs grid grid2d grind halfangles head_angle head_both head_length head_type height hypergeometric_representation %iargs ibase icc1 icc2 icounter idummyx ieqnprint ifb ifc1 ifc2 ifg ifgi ifr iframe_bracket_form ifri igeowedge_flag ikt1 ikt2 imaginary inchar increasing infeval infinity inflag infolists inm inmc1 inmc2 intanalysis integer integervalued integrate_use_rootsof integration_constant integration_constant_counter interpolate_color intfaclim ip_grid ip_grid_in irrational isolate_wrt_times iterations itr julia_parameter %k1 %k2 keepfloat key key_pos kinvariant kt label label_alignment label_orientation labels lassociative lbfgs_ncorrections lbfgs_nfeval_max leftjust legend letrat let_rule_packages lfg lg lhospitallim limsubst linear linear_solver linechar linel|10 linenum line_type linewidth line_width linsolve_params linsolvewarn lispdisp listarith listconstvars listdummyvars lmxchar load_pathname loadprint logabs logarc logcb logconcoeffp logexpand lognegint logsimp logx logx_secondary logy logy_secondary logz lriem m1pbranch macroexpansion macros mainvar manual_demo maperror mapprint matrix_element_add matrix_element_mult matrix_element_transpose maxapplydepth maxapplyheight maxima_tempdir|10 maxima_userdir|10 maxnegex MAX_ORD maxposex maxpsifracdenom maxpsifracnum maxpsinegint maxpsiposint maxtayorder mesh_lines_color method mod_big_prime mode_check_errorp mode_checkp mode_check_warnp mod_test mod_threshold modular_linear_solver modulus multiplicative multiplicities myoptions nary negdistrib negsumdispflag newline newtonepsilon newtonmaxiter nextlayerfactor niceindicespref nm nmc noeval nolabels nonegative_lp noninteger nonscalar noun noundisp nouns np npi nticks ntrig numer numer_pbranch obase odd oddfun opacity opproperties opsubst optimprefix optionset orientation origin orthopoly_returns_intervals outative outchar packagefile palette partswitch pdf_file pfeformat phiresolution %piargs piece pivot_count_sx pivot_max_sx plot_format plot_options plot_realpart png_file pochhammer_max_index points pointsize point_size points_joined point_type poislim poisson poly_coefficient_ring poly_elimination_order polyfactor poly_grobner_algorithm poly_grobner_debug poly_monomial_order poly_primary_elimination_order poly_return_term_list poly_secondary_elimination_order poly_top_reduction_only posfun position powerdisp pred prederror primep_number_of_tests product_use_gamma program programmode promote_float_to_bigfloat prompt proportional_axes props psexpand ps_file radexpand radius radsubstflag rassociative ratalgdenom ratchristof ratdenomdivide rateinstein ratepsilon ratfac rational ratmx ratprint ratriemann ratsimpexpons ratvarswitch ratweights ratweyl ratwtlvl real realonly redraw refcheck resolution restart resultant ric riem rmxchar %rnum_list rombergabs rombergit rombergmin rombergtol rootsconmode rootsepsilon run_viewer same_xy same_xyz savedef savefactors scalar scalarmatrixp scale scale_lp setcheck setcheckbreak setval show_edge_color show_edges show_edge_type show_edge_width show_id show_label showtime show_vertex_color show_vertex_size show_vertex_type show_vertices show_weight simp simplified_output simplify_products simpproduct simpsum sinnpiflag solvedecomposes solveexplicit solvefactors solvenullwarn solveradcan solvetrigwarn space sparse sphere spring_embedding_depth sqrtdispflag stardisp startphi starttheta stats_numer stringdisp structures style sublis_apply_lambda subnumsimp sumexpand sumsplitfact surface surface_hide svg_file symmetric tab taylordepth taylor_logexpand taylor_order_coefficients taylor_truncate_polynomials tensorkill terminal testsuite_files thetaresolution timer_devalue title tlimswitch tr track transcompile transform transform_xy translate_fast_arrays transparent transrun tr_array_as_ref tr_bound_function_applyp tr_file_tty_messagesp tr_float_can_branch_complex tr_function_call_default trigexpandplus trigexpandtimes triginverses trigsign trivial_solutions tr_numer tr_optimize_max_loop tr_semicompile tr_state_vars tr_warn_bad_function_calls tr_warn_fexpr tr_warn_meval tr_warn_mode tr_warn_undeclared tr_warn_undefined_variable tstep ttyoff tube_extremes ufg ug %unitexpand unit_vectors uric uriem use_fast_arrays user_preamble usersetunits values vect_cross verbose vertex_color vertex_coloring vertex_partition vertex_size vertex_type view warnings weyl width windowname windowtitle wired_surface wireframe xaxis xaxis_color xaxis_secondary xaxis_type xaxis_width xlabel xlabel_secondary xlength xrange xrange_secondary xtics xtics_axis xtics_rotate xtics_rotate_secondary xtics_secondary xtics_secondary_axis xu_grid x_voxel xy_file xyplane xy_scale yaxis yaxis_color yaxis_secondary yaxis_type yaxis_width ylabel ylabel_secondary ylength yrange yrange_secondary ytics ytics_axis ytics_rotate ytics_rotate_secondary ytics_secondary ytics_secondary_axis yv_grid y_voxel yx_ratio zaxis zaxis_color zaxis_type zaxis_width zeroa zerob zerobern zeta%pi zlabel zlabel_rotate zlength zmin zn_primroot_limit zn_primroot_pretest",symbol:"_ __ %|0 %%|0"},contains:[{className:"comment",begin:"/\\*",end:"\\*/",contains:["self"]},e.QUOTE_STRING_MODE,{className:"number",relevance:0,variants:[{begin:"\\b(\\d+|\\d+\\.|\\.\\d+|\\d+\\.\\d+)[Ee][-+]?\\d+\\b"},{begin:"\\b(\\d+|\\d+\\.|\\.\\d+|\\d+\\.\\d+)[Bb][-+]?\\d+\\b",relevance:10},{begin:"\\b(\\.\\d+|\\d+\\.\\d+)\\b"},{begin:"\\b(\\d+|0[0-9A-Za-z]+)\\.?\\b"}]}],illegal:/@/}}return xY=t,xY}var AY,Lye;function H5t(){if(Lye)return AY;Lye=1;function t(e){return{name:"MEL",keywords:"int float string vector matrix if else switch case default while do for in break continue global proc return about abs addAttr addAttributeEditorNodeHelp addDynamic addNewShelfTab addPP addPanelCategory addPrefixToName advanceToNextDrivenKey affectedNet affects aimConstraint air alias aliasAttr align alignCtx alignCurve alignSurface allViewFit ambientLight angle angleBetween animCone animCurveEditor animDisplay animView annotate appendStringArray applicationName applyAttrPreset applyTake arcLenDimContext arcLengthDimension arclen arrayMapper art3dPaintCtx artAttrCtx artAttrPaintVertexCtx artAttrSkinPaintCtx artAttrTool artBuildPaintMenu artFluidAttrCtx artPuttyCtx artSelectCtx artSetPaintCtx artUserPaintCtx assignCommand assignInputDevice assignViewportFactories attachCurve attachDeviceAttr attachSurface attrColorSliderGrp attrCompatibility attrControlGrp attrEnumOptionMenu attrEnumOptionMenuGrp attrFieldGrp attrFieldSliderGrp attrNavigationControlGrp attrPresetEditWin attributeExists attributeInfo attributeMenu attributeQuery autoKeyframe autoPlace bakeClip bakeFluidShading bakePartialHistory bakeResults bakeSimulation basename basenameEx batchRender bessel bevel bevelPlus binMembership bindSkin blend2 blendShape blendShapeEditor blendShapePanel blendTwoAttr blindDataType boneLattice boundary boxDollyCtx boxZoomCtx bufferCurve buildBookmarkMenu buildKeyframeMenu button buttonManip CBG cacheFile cacheFileCombine cacheFileMerge cacheFileTrack camera cameraView canCreateManip canvas capitalizeString catch catchQuiet ceil changeSubdivComponentDisplayLevel changeSubdivRegion channelBox character characterMap characterOutlineEditor characterize chdir checkBox checkBoxGrp checkDefaultRenderGlobals choice circle circularFillet clamp clear clearCache clip clipEditor clipEditorCurrentTimeCtx clipSchedule clipSchedulerOutliner clipTrimBefore closeCurve closeSurface cluster cmdFileOutput cmdScrollFieldExecuter cmdScrollFieldReporter cmdShell coarsenSubdivSelectionList collision color colorAtPoint colorEditor colorIndex colorIndexSliderGrp colorSliderButtonGrp colorSliderGrp columnLayout commandEcho commandLine commandPort compactHairSystem componentEditor compositingInterop computePolysetVolume condition cone confirmDialog connectAttr connectControl connectDynamic connectJoint connectionInfo constrain constrainValue constructionHistory container containsMultibyte contextInfo control convertFromOldLayers convertIffToPsd convertLightmap convertSolidTx convertTessellation convertUnit copyArray copyFlexor copyKey copySkinWeights cos cpButton cpCache cpClothSet cpCollision cpConstraint cpConvClothToMesh cpForces cpGetSolverAttr cpPanel cpProperty cpRigidCollisionFilter cpSeam cpSetEdit cpSetSolverAttr cpSolver cpSolverTypes cpTool cpUpdateClothUVs createDisplayLayer createDrawCtx createEditor createLayeredPsdFile createMotionField createNewShelf createNode createRenderLayer createSubdivRegion cross crossProduct ctxAbort ctxCompletion ctxEditMode ctxTraverse currentCtx currentTime currentTimeCtx currentUnit curve curveAddPtCtx curveCVCtx curveEPCtx curveEditorCtx curveIntersect curveMoveEPCtx curveOnSurface curveSketchCtx cutKey cycleCheck cylinder dagPose date defaultLightListCheckBox defaultNavigation defineDataServer defineVirtualDevice deformer deg_to_rad delete deleteAttr deleteShadingGroupsAndMaterials deleteShelfTab deleteUI deleteUnusedBrushes delrandstr detachCurve detachDeviceAttr detachSurface deviceEditor devicePanel dgInfo dgdirty dgeval dgtimer dimWhen directKeyCtx directionalLight dirmap dirname disable disconnectAttr disconnectJoint diskCache displacementToPoly displayAffected displayColor displayCull displayLevelOfDetail displayPref displayRGBColor displaySmoothness displayStats displayString displaySurface distanceDimContext distanceDimension doBlur dolly dollyCtx dopeSheetEditor dot dotProduct doubleProfileBirailSurface drag dragAttrContext draggerContext dropoffLocator duplicate duplicateCurve duplicateSurface dynCache dynControl dynExport dynExpression dynGlobals dynPaintEditor dynParticleCtx dynPref dynRelEdPanel dynRelEditor dynamicLoad editAttrLimits editDisplayLayerGlobals editDisplayLayerMembers editRenderLayerAdjustment editRenderLayerGlobals editRenderLayerMembers editor editorTemplate effector emit emitter enableDevice encodeString endString endsWith env equivalent equivalentTol erf error eval evalDeferred evalEcho event exactWorldBoundingBox exclusiveLightCheckBox exec executeForEachObject exists exp expression expressionEditorListen extendCurve extendSurface extrude fcheck fclose feof fflush fgetline fgetword file fileBrowserDialog fileDialog fileExtension fileInfo filetest filletCurve filter filterCurve filterExpand filterStudioImport findAllIntersections findAnimCurves findKeyframe findMenuItem findRelatedSkinCluster finder firstParentOf fitBspline flexor floatEq floatField floatFieldGrp floatScrollBar floatSlider floatSlider2 floatSliderButtonGrp floatSliderGrp floor flow fluidCacheInfo fluidEmitter fluidVoxelInfo flushUndo fmod fontDialog fopen formLayout format fprint frameLayout fread freeFormFillet frewind fromNativePath fwrite gamma gauss geometryConstraint getApplicationVersionAsFloat getAttr getClassification getDefaultBrush getFileList getFluidAttr getInputDeviceRange getMayaPanelTypes getModifiers getPanel getParticleAttr getPluginResource getenv getpid glRender glRenderEditor globalStitch gmatch goal gotoBindPose grabColor gradientControl gradientControlNoAttr graphDollyCtx graphSelectContext graphTrackCtx gravity grid gridLayout group groupObjectsByName HfAddAttractorToAS HfAssignAS HfBuildEqualMap HfBuildFurFiles HfBuildFurImages HfCancelAFR HfConnectASToHF HfCreateAttractor HfDeleteAS HfEditAS HfPerformCreateAS HfRemoveAttractorFromAS HfSelectAttached HfSelectAttractors HfUnAssignAS hardenPointCurve hardware hardwareRenderPanel headsUpDisplay headsUpMessage help helpLine hermite hide hilite hitTest hotBox hotkey hotkeyCheck hsv_to_rgb hudButton hudSlider hudSliderButton hwReflectionMap hwRender hwRenderLoad hyperGraph hyperPanel hyperShade hypot iconTextButton iconTextCheckBox iconTextRadioButton iconTextRadioCollection iconTextScrollList iconTextStaticLabel ikHandle ikHandleCtx ikHandleDisplayScale ikSolver ikSplineHandleCtx ikSystem ikSystemInfo ikfkDisplayMethod illustratorCurves image imfPlugins inheritTransform insertJoint insertJointCtx insertKeyCtx insertKnotCurve insertKnotSurface instance instanceable instancer intField intFieldGrp intScrollBar intSlider intSliderGrp interToUI internalVar intersect iprEngine isAnimCurve isConnected isDirty isParentOf isSameObject isTrue isValidObjectName isValidString isValidUiName isolateSelect itemFilter itemFilterAttr itemFilterRender itemFilterType joint jointCluster jointCtx jointDisplayScale jointLattice keyTangent keyframe keyframeOutliner keyframeRegionCurrentTimeCtx keyframeRegionDirectKeyCtx keyframeRegionDollyCtx keyframeRegionInsertKeyCtx keyframeRegionMoveKeyCtx keyframeRegionScaleKeyCtx keyframeRegionSelectKeyCtx keyframeRegionSetKeyCtx keyframeRegionTrackCtx keyframeStats lassoContext lattice latticeDeformKeyCtx launch launchImageEditor layerButton layeredShaderPort layeredTexturePort layout layoutDialog lightList lightListEditor lightListPanel lightlink lineIntersection linearPrecision linstep listAnimatable listAttr listCameras listConnections listDeviceAttachments listHistory listInputDeviceAxes listInputDeviceButtons listInputDevices listMenuAnnotation listNodeTypes listPanelCategories listRelatives listSets listTransforms listUnselected listerEditor loadFluid loadNewShelf loadPlugin loadPluginLanguageResources loadPrefObjects localizedPanelLabel lockNode loft log longNameOf lookThru ls lsThroughFilter lsType lsUI Mayatomr mag makeIdentity makeLive makePaintable makeRoll makeSingleSurface makeTubeOn makebot manipMoveContext manipMoveLimitsCtx manipOptions manipRotateContext manipRotateLimitsCtx manipScaleContext manipScaleLimitsCtx marker match max memory menu menuBarLayout menuEditor menuItem menuItemToShelf menuSet menuSetPref messageLine min minimizeApp mirrorJoint modelCurrentTimeCtx modelEditor modelPanel mouse movIn movOut move moveIKtoFK moveKeyCtx moveVertexAlongDirection multiProfileBirailSurface mute nParticle nameCommand nameField namespace namespaceInfo newPanelItems newton nodeCast nodeIconButton nodeOutliner nodePreset nodeType noise nonLinear normalConstraint normalize nurbsBoolean nurbsCopyUVSet nurbsCube nurbsEditUV nurbsPlane nurbsSelect nurbsSquare nurbsToPoly nurbsToPolygonsPref nurbsToSubdiv nurbsToSubdivPref nurbsUVSet nurbsViewDirectionVector objExists objectCenter objectLayer objectType objectTypeUI obsoleteProc oceanNurbsPreviewPlane offsetCurve offsetCurveOnSurface offsetSurface openGLExtension openMayaPref optionMenu optionMenuGrp optionVar orbit orbitCtx orientConstraint outlinerEditor outlinerPanel overrideModifier paintEffectsDisplay pairBlend palettePort paneLayout panel panelConfiguration panelHistory paramDimContext paramDimension paramLocator parent parentConstraint particle particleExists particleInstancer particleRenderInfo partition pasteKey pathAnimation pause pclose percent performanceOptions pfxstrokes pickWalk picture pixelMove planarSrf plane play playbackOptions playblast plugAttr plugNode pluginInfo pluginResourceUtil pointConstraint pointCurveConstraint pointLight pointMatrixMult pointOnCurve pointOnSurface pointPosition poleVectorConstraint polyAppend polyAppendFacetCtx polyAppendVertex polyAutoProjection polyAverageNormal polyAverageVertex polyBevel polyBlendColor polyBlindData polyBoolOp polyBridgeEdge polyCacheMonitor polyCheck polyChipOff polyClipboard polyCloseBorder polyCollapseEdge polyCollapseFacet polyColorBlindData polyColorDel polyColorPerVertex polyColorSet polyCompare polyCone polyCopyUV polyCrease polyCreaseCtx polyCreateFacet polyCreateFacetCtx polyCube polyCut polyCutCtx polyCylinder polyCylindricalProjection polyDelEdge polyDelFacet polyDelVertex polyDuplicateAndConnect polyDuplicateEdge polyEditUV polyEditUVShell polyEvaluate polyExtrudeEdge polyExtrudeFacet polyExtrudeVertex polyFlipEdge polyFlipUV polyForceUV polyGeoSampler polyHelix polyInfo polyInstallAction polyLayoutUV polyListComponentConversion polyMapCut polyMapDel polyMapSew polyMapSewMove polyMergeEdge polyMergeEdgeCtx polyMergeFacet polyMergeFacetCtx polyMergeUV polyMergeVertex polyMirrorFace polyMoveEdge polyMoveFacet polyMoveFacetUV polyMoveUV polyMoveVertex polyNormal polyNormalPerVertex polyNormalizeUV polyOptUvs polyOptions polyOutput polyPipe polyPlanarProjection polyPlane polyPlatonicSolid polyPoke polyPrimitive polyPrism polyProjection polyPyramid polyQuad polyQueryBlindData polyReduce polySelect polySelectConstraint polySelectConstraintMonitor polySelectCtx polySelectEditCtx polySeparate polySetToFaceNormal polySewEdge polyShortestPathCtx polySmooth polySoftEdge polySphere polySphericalProjection polySplit polySplitCtx polySplitEdge polySplitRing polySplitVertex polyStraightenUVBorder polySubdivideEdge polySubdivideFacet polyToSubdiv polyTorus polyTransfer polyTriangulate polyUVSet polyUnite polyWedgeFace popen popupMenu pose pow preloadRefEd print progressBar progressWindow projFileViewer projectCurve projectTangent projectionContext projectionManip promptDialog propModCtx propMove psdChannelOutliner psdEditTextureFile psdExport psdTextureFile putenv pwd python querySubdiv quit rad_to_deg radial radioButton radioButtonGrp radioCollection radioMenuItemCollection rampColorPort rand randomizeFollicles randstate rangeControl readTake rebuildCurve rebuildSurface recordAttr recordDevice redo reference referenceEdit referenceQuery refineSubdivSelectionList refresh refreshAE registerPluginResource rehash reloadImage removeJoint removeMultiInstance removePanelCategory rename renameAttr renameSelectionList renameUI render renderGlobalsNode renderInfo renderLayerButton renderLayerParent renderLayerPostProcess renderLayerUnparent renderManip renderPartition renderQualityNode renderSettings renderThumbnailUpdate renderWindowEditor renderWindowSelectContext renderer reorder reorderDeformers requires reroot resampleFluid resetAE resetPfxToPolyCamera resetTool resolutionNode retarget reverseCurve reverseSurface revolve rgb_to_hsv rigidBody rigidSolver roll rollCtx rootOf rot rotate rotationInterpolation roundConstantRadius rowColumnLayout rowLayout runTimeCommand runup sampleImage saveAllShelves saveAttrPreset saveFluid saveImage saveInitialState saveMenu savePrefObjects savePrefs saveShelf saveToolSettings scale scaleBrushBrightness scaleComponents scaleConstraint scaleKey scaleKeyCtx sceneEditor sceneUIReplacement scmh scriptCtx scriptEditorInfo scriptJob scriptNode scriptTable scriptToShelf scriptedPanel scriptedPanelType scrollField scrollLayout sculpt searchPathArray seed selLoadSettings select selectContext selectCurveCV selectKey selectKeyCtx selectKeyframeRegionCtx selectMode selectPref selectPriority selectType selectedNodes selectionConnection separator setAttr setAttrEnumResource setAttrMapping setAttrNiceNameResource setConstraintRestPosition setDefaultShadingGroup setDrivenKeyframe setDynamic setEditCtx setEditor setFluidAttr setFocus setInfinity setInputDeviceMapping setKeyCtx setKeyPath setKeyframe setKeyframeBlendshapeTargetWts setMenuMode setNodeNiceNameResource setNodeTypeFlag setParent setParticleAttr setPfxToPolyCamera setPluginResource setProject setStampDensity setStartupMessage setState setToolTo setUITemplate setXformManip sets shadingConnection shadingGeometryRelCtx shadingLightRelCtx shadingNetworkCompare shadingNode shapeCompare shelfButton shelfLayout shelfTabLayout shellField shortNameOf showHelp showHidden showManipCtx showSelectionInTitle showShadingGroupAttrEditor showWindow sign simplify sin singleProfileBirailSurface size sizeBytes skinCluster skinPercent smoothCurve smoothTangentSurface smoothstep snap2to2 snapKey snapMode snapTogetherCtx snapshot soft softMod softModCtx sort sound soundControl source spaceLocator sphere sphrand spotLight spotLightPreviewPort spreadSheetEditor spring sqrt squareSurface srtContext stackTrace startString startsWith stitchAndExplodeShell stitchSurface stitchSurfacePoints strcmp stringArrayCatenate stringArrayContains stringArrayCount stringArrayInsertAtIndex stringArrayIntersector stringArrayRemove stringArrayRemoveAtIndex stringArrayRemoveDuplicates stringArrayRemoveExact stringArrayToString stringToStringArray strip stripPrefixFromName stroke subdAutoProjection subdCleanTopology subdCollapse subdDuplicateAndConnect subdEditUV subdListComponentConversion subdMapCut subdMapSewMove subdMatchTopology subdMirror subdToBlind subdToPoly subdTransferUVsToCache subdiv subdivCrease subdivDisplaySmoothness substitute substituteAllString substituteGeometry substring surface surfaceSampler surfaceShaderList swatchDisplayPort switchTable symbolButton symbolCheckBox sysFile system tabLayout tan tangentConstraint texLatticeDeformContext texManipContext texMoveContext texMoveUVShellContext texRotateContext texScaleContext texSelectContext texSelectShortestPathCtx texSmudgeUVContext texWinToolCtx text textCurves textField textFieldButtonGrp textFieldGrp textManip textScrollList textToShelf textureDisplacePlane textureHairColor texturePlacementContext textureWindow threadCount threePointArcCtx timeControl timePort timerX toNativePath toggle toggleAxis toggleWindowVisibility tokenize tokenizeList tolerance tolower toolButton toolCollection toolDropped toolHasOptions toolPropertyWindow torus toupper trace track trackCtx transferAttributes transformCompare transformLimits translator trim trunc truncateFluidCache truncateHairCache tumble tumbleCtx turbulence twoPointArcCtx uiRes uiTemplate unassignInputDevice undo undoInfo ungroup uniform unit unloadPlugin untangleUV untitledFileName untrim upAxis updateAE userCtx uvLink uvSnapshot validateShelfName vectorize view2dToolCtx viewCamera viewClipPlane viewFit viewHeadOn viewLookAt viewManip viewPlace viewSet visor volumeAxis vortex waitCursor warning webBrowser webBrowserPrefs whatIs window windowPref wire wireContext workspace wrinkle wrinkleContext writeTake xbmLangPathList xform",illegal:""},{begin:"<=",relevance:0},{begin:"=>",relevance:0},{begin:"/\\\\"},{begin:"\\\\/"}]},{className:"built_in",variants:[{begin:":-\\|-->"},{begin:"=",relevance:0}]},n,e.C_BLOCK_COMMENT_MODE,i,e.NUMBER_MODE,a,s,{begin:/:-/},{begin:/\.$/}]}}return RY=t,RY}var NY,Fye;function Y5t(){if(Fye)return NY;Fye=1;function t(e){return{name:"MIPS Assembly",case_insensitive:!0,aliases:["mips"],keywords:{$pattern:"\\.?"+e.IDENT_RE,meta:".2byte .4byte .align .ascii .asciz .balign .byte .code .data .else .end .endif .endm .endr .equ .err .exitm .extern .global .hword .if .ifdef .ifndef .include .irp .long .macro .rept .req .section .set .skip .space .text .word .ltorg ",built_in:"$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $20 $21 $22 $23 $24 $25 $26 $27 $28 $29 $30 $31 zero at v0 v1 a0 a1 a2 a3 a4 a5 a6 a7 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 s0 s1 s2 s3 s4 s5 s6 s7 s8 k0 k1 gp sp fp ra $f0 $f1 $f2 $f2 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15 $f16 $f17 $f18 $f19 $f20 $f21 $f22 $f23 $f24 $f25 $f26 $f27 $f28 $f29 $f30 $f31 Context Random EntryLo0 EntryLo1 Context PageMask Wired EntryHi HWREna BadVAddr Count Compare SR IntCtl SRSCtl SRSMap Cause EPC PRId EBase Config Config1 Config2 Config3 LLAddr Debug DEPC DESAVE CacheErr ECC ErrorEPC TagLo DataLo TagHi DataHi WatchLo WatchHi PerfCtl PerfCnt "},contains:[{className:"keyword",begin:"\\b(addi?u?|andi?|b(al)?|beql?|bgez(al)?l?|bgtzl?|blezl?|bltz(al)?l?|bnel?|cl[oz]|divu?|ext|ins|j(al)?|jalr(\\.hb)?|jr(\\.hb)?|lbu?|lhu?|ll|lui|lw[lr]?|maddu?|mfhi|mflo|movn|movz|move|msubu?|mthi|mtlo|mul|multu?|nop|nor|ori?|rotrv?|sb|sc|se[bh]|sh|sllv?|slti?u?|srav?|srlv?|subu?|sw[lr]?|xori?|wsbh|abs\\.[sd]|add\\.[sd]|alnv.ps|bc1[ft]l?|c\\.(s?f|un|u?eq|[ou]lt|[ou]le|ngle?|seq|l[et]|ng[et])\\.[sd]|(ceil|floor|round|trunc)\\.[lw]\\.[sd]|cfc1|cvt\\.d\\.[lsw]|cvt\\.l\\.[dsw]|cvt\\.ps\\.s|cvt\\.s\\.[dlw]|cvt\\.s\\.p[lu]|cvt\\.w\\.[dls]|div\\.[ds]|ldx?c1|luxc1|lwx?c1|madd\\.[sd]|mfc1|mov[fntz]?\\.[ds]|msub\\.[sd]|mth?c1|mul\\.[ds]|neg\\.[ds]|nmadd\\.[ds]|nmsub\\.[ds]|p[lu][lu]\\.ps|recip\\.fmt|r?sqrt\\.[ds]|sdx?c1|sub\\.[ds]|suxc1|swx?c1|break|cache|d?eret|[de]i|ehb|mfc0|mtc0|pause|prefx?|rdhwr|rdpgpr|sdbbp|ssnop|synci?|syscall|teqi?|tgei?u?|tlb(p|r|w[ir])|tlti?u?|tnei?|wait|wrpgpr)",end:"\\s"},e.COMMENT("[;#](?!\\s*$)","$"),e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:"'",end:"[^\\\\]'",relevance:0},{className:"title",begin:"\\|",end:"\\|",illegal:"\\n",relevance:0},{className:"number",variants:[{begin:"0x[0-9a-f]+"},{begin:"\\b-?\\d+"}],relevance:0},{className:"symbol",variants:[{begin:"^\\s*[a-z_\\.\\$][a-z0-9_\\.\\$]+:"},{begin:"^\\s*[0-9]+:"},{begin:"[0-9]+[bf]"}],relevance:0}],illegal:/\//}}return NY=t,NY}var OY,Bye;function W5t(){if(Bye)return OY;Bye=1;function t(e){return{name:"Mizar",keywords:"environ vocabularies notations constructors definitions registrations theorems schemes requirements begin end definition registration cluster existence pred func defpred deffunc theorem proof let take assume then thus hence ex for st holds consider reconsider such that and in provided of as from be being by means equals implies iff redefine define now not or attr is mode suppose per cases set thesis contradiction scheme reserve struct correctness compatibility coherence symmetry assymetry reflexivity irreflexivity connectedness uniqueness commutativity idempotence involutiveness projectivity",contains:[e.COMMENT("::","$")]}}return OY=t,OY}var IY,Uye;function K5t(){if(Uye)return IY;Uye=1;function t(e){const r=e.regex,n=["abs","accept","alarm","and","atan2","bind","binmode","bless","break","caller","chdir","chmod","chomp","chop","chown","chr","chroot","class","close","closedir","connect","continue","cos","crypt","dbmclose","dbmopen","defined","delete","die","do","dump","each","else","elsif","endgrent","endhostent","endnetent","endprotoent","endpwent","endservent","eof","eval","exec","exists","exit","exp","fcntl","field","fileno","flock","for","foreach","fork","format","formline","getc","getgrent","getgrgid","getgrnam","gethostbyaddr","gethostbyname","gethostent","getlogin","getnetbyaddr","getnetbyname","getnetent","getpeername","getpgrp","getpriority","getprotobyname","getprotobynumber","getprotoent","getpwent","getpwnam","getpwuid","getservbyname","getservbyport","getservent","getsockname","getsockopt","given","glob","gmtime","goto","grep","gt","hex","if","index","int","ioctl","join","keys","kill","last","lc","lcfirst","length","link","listen","local","localtime","log","lstat","lt","ma","map","method","mkdir","msgctl","msgget","msgrcv","msgsnd","my","ne","next","no","not","oct","open","opendir","or","ord","our","pack","package","pipe","pop","pos","print","printf","prototype","push","q|0","qq","quotemeta","qw","qx","rand","read","readdir","readline","readlink","readpipe","recv","redo","ref","rename","require","reset","return","reverse","rewinddir","rindex","rmdir","say","scalar","seek","seekdir","select","semctl","semget","semop","send","setgrent","sethostent","setnetent","setpgrp","setpriority","setprotoent","setpwent","setservent","setsockopt","shift","shmctl","shmget","shmread","shmwrite","shutdown","sin","sleep","socket","socketpair","sort","splice","split","sprintf","sqrt","srand","stat","state","study","sub","substr","symlink","syscall","sysopen","sysread","sysseek","system","syswrite","tell","telldir","tie","tied","time","times","tr","truncate","uc","ucfirst","umask","undef","unless","unlink","unpack","unshift","untie","until","use","utime","values","vec","wait","waitpid","wantarray","warn","when","while","write","x|0","xor","y|0"],i=/[dualxmsipngr]{0,12}/,a={$pattern:/[\w.]+/,keyword:n.join(" ")},s={className:"subst",begin:"[$@]\\{",end:"\\}",keywords:a},o={begin:/->\{/,end:/\}/},l={scope:"attr",match:/\s+:\s*\w+(\s*\(.*?\))?/},u={scope:"variable",variants:[{begin:/\$\d/},{begin:r.concat(/[$%@](?!")(\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,"(?![A-Za-z])(?![@$%])")},{begin:/[$%@](?!")[^\s\w{=]|\$=/,relevance:0}],contains:[l]},d={className:"number",variants:[{match:/0?\.[0-9][0-9_]+\b/},{match:/\bv?(0|[1-9][0-9_]*(\.[0-9_]+)?|[1-9][0-9_]*)\b/},{match:/\b0[0-7][0-7_]*\b/},{match:/\b0x[0-9a-fA-F][0-9a-fA-F_]*\b/},{match:/\b0b[0-1][0-1_]*\b/}],relevance:0},h=[e.BACKSLASH_ESCAPE,s,u],f=[/!/,/\//,/\|/,/\?/,/'/,/"/,/#/],p=(_,v,b="\\1")=>{const y=b==="\\1"?b:r.concat(b,v);return r.concat(r.concat("(?:",_,")"),v,/(?:\\.|[^\\\/])*?/,y,/(?:\\.|[^\\\/])*?/,b,i)},g=(_,v,b)=>r.concat(r.concat("(?:",_,")"),v,/(?:\\.|[^\\\/])*?/,b,i),m=[u,e.HASH_COMMENT_MODE,e.COMMENT(/^=\w/,/=cut/,{endsWithParent:!0}),o,{className:"string",contains:h,variants:[{begin:"q[qwxr]?\\s*\\(",end:"\\)",relevance:5},{begin:"q[qwxr]?\\s*\\[",end:"\\]",relevance:5},{begin:"q[qwxr]?\\s*\\{",end:"\\}",relevance:5},{begin:"q[qwxr]?\\s*\\|",end:"\\|",relevance:5},{begin:"q[qwxr]?\\s*<",end:">",relevance:5},{begin:"qw\\s+q",end:"q",relevance:5},{begin:"'",end:"'",contains:[e.BACKSLASH_ESCAPE]},{begin:'"',end:'"'},{begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE]},{begin:/\{\w+\}/,relevance:0},{begin:"-?\\w+\\s*=>",relevance:0}]},d,{begin:"(\\/\\/|"+e.RE_STARTERS_RE+"|\\b(split|return|print|reverse|grep)\\b)\\s*",keywords:"split return print reverse grep",relevance:0,contains:[e.HASH_COMMENT_MODE,{className:"regexp",variants:[{begin:p("s|tr|y",r.either(...f,{capture:!0}))},{begin:p("s|tr|y","\\(","\\)")},{begin:p("s|tr|y","\\[","\\]")},{begin:p("s|tr|y","\\{","\\}")}],relevance:2},{className:"regexp",variants:[{begin:/(m|qr)\/\//,relevance:0},{begin:g("(?:m|qr)?",/\//,/\//)},{begin:g("m|qr",r.either(...f,{capture:!0}),/\1/)},{begin:g("m|qr",/\(/,/\)/)},{begin:g("m|qr",/\[/,/\]/)},{begin:g("m|qr",/\{/,/\}/)}]}]},{className:"function",beginKeywords:"sub method",end:"(\\s*\\(.*?\\))?[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE,l]},{className:"class",beginKeywords:"class",end:"[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE,l,d]},{begin:"-\\w\\b",relevance:0},{begin:"^__DATA__$",end:"^__END__$",subLanguage:"mojolicious",contains:[{begin:"^@@.*",end:"$",className:"comment"}]}];return s.contains=m,o.contains=m,{name:"Perl",aliases:["pl","pm"],keywords:a,contains:m}}return IY=t,IY}var kY,$ye;function j5t(){if($ye)return kY;$ye=1;function t(e){return{name:"Mojolicious",subLanguage:"xml",contains:[{className:"meta",begin:"^__(END|DATA)__$"},{begin:"^\\s*%{1,2}={0,2}",end:"$",subLanguage:"perl"},{begin:"<%{1,2}={0,2}",end:"={0,1}%>",subLanguage:"perl",excludeBegin:!0,excludeEnd:!0}]}}return kY=t,kY}var DY,Gye;function X5t(){if(Gye)return DY;Gye=1;function t(e){const r={className:"number",relevance:0,variants:[{begin:"[$][a-fA-F0-9]+"},e.NUMBER_MODE]},n={variants:[{match:[/(function|method)/,/\s+/,e.UNDERSCORE_IDENT_RE]}],scope:{1:"keyword",3:"title.function"}},i={variants:[{match:[/(class|interface|extends|implements)/,/\s+/,e.UNDERSCORE_IDENT_RE]}],scope:{1:"keyword",3:"title.class"}};return{name:"Monkey",case_insensitive:!0,keywords:{keyword:["public","private","property","continue","exit","extern","new","try","catch","eachin","not","abstract","final","select","case","default","const","local","global","field","end","if","then","else","elseif","endif","while","wend","repeat","until","forever","for","to","step","next","return","module","inline","throw","import","and","or","shl","shr","mod"],built_in:["DebugLog","DebugStop","Error","Print","ACos","ACosr","ASin","ASinr","ATan","ATan2","ATan2r","ATanr","Abs","Abs","Ceil","Clamp","Clamp","Cos","Cosr","Exp","Floor","Log","Max","Max","Min","Min","Pow","Sgn","Sgn","Sin","Sinr","Sqrt","Tan","Tanr","Seed","PI","HALFPI","TWOPI"],literal:["true","false","null"]},illegal:/\/\*/,contains:[e.COMMENT("#rem","#end"),e.COMMENT("'","$",{relevance:0}),n,i,{className:"variable.language",begin:/\b(self|super)\b/},{className:"meta",begin:/\s*#/,end:"$",keywords:{keyword:"if else elseif endif end then"}},{match:[/^\s*/,/strict\b/],scope:{2:"meta"}},{beginKeywords:"alias",end:"=",contains:[e.UNDERSCORE_TITLE_MODE]},e.QUOTE_STRING_MODE,r]}}return DY=t,DY}var MY,zye;function Q5t(){if(zye)return MY;zye=1;function t(e){const r={keyword:"if then not for in while do return else elseif break continue switch and or unless when class extends super local import export from using",literal:"true false nil",built_in:"_G _VERSION assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall coroutine debug io math os package string table"},n="[A-Za-z$_][0-9A-Za-z$_]*",i={className:"subst",begin:/#\{/,end:/\}/,keywords:r},a=[e.inherit(e.C_NUMBER_MODE,{starts:{end:"(\\s*/)?",relevance:0}}),{className:"string",variants:[{begin:/'/,end:/'/,contains:[e.BACKSLASH_ESCAPE]},{begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,i]}]},{className:"built_in",begin:"@__"+e.IDENT_RE},{begin:"@"+e.IDENT_RE},{begin:e.IDENT_RE+"\\\\"+e.IDENT_RE}];i.contains=a;const s=e.inherit(e.TITLE_MODE,{begin:n}),o="(\\(.*\\)\\s*)?\\B[-=]>",l={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:r,contains:["self"].concat(a)}]};return{name:"MoonScript",aliases:["moon"],keywords:r,illegal:/\/\*/,contains:a.concat([e.COMMENT("--","$"),{className:"function",begin:"^\\s*"+n+"\\s*=\\s*"+o,end:"[-=]>",returnBegin:!0,contains:[s,l]},{begin:/[\(,:=]\s*/,relevance:0,contains:[{className:"function",begin:o,end:"[-=]>",returnBegin:!0,contains:[l]}]},{className:"class",beginKeywords:"class",end:"$",illegal:/[:="\[\]]/,contains:[{beginKeywords:"extends",endsWithParent:!0,illegal:/[:="\[\]]/,contains:[s]},s]},{className:"name",begin:n+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return MY=t,MY}var LY,qye;function Z5t(){if(qye)return LY;qye=1;function t(e){return{name:"N1QL",case_insensitive:!0,contains:[{beginKeywords:"build create index delete drop explain infer|10 insert merge prepare select update upsert|10",end:/;/,keywords:{keyword:["all","alter","analyze","and","any","array","as","asc","begin","between","binary","boolean","break","bucket","build","by","call","case","cast","cluster","collate","collection","commit","connect","continue","correlate","cover","create","database","dataset","datastore","declare","decrement","delete","derived","desc","describe","distinct","do","drop","each","element","else","end","every","except","exclude","execute","exists","explain","fetch","first","flatten","for","force","from","function","grant","group","gsi","having","if","ignore","ilike","in","include","increment","index","infer","inline","inner","insert","intersect","into","is","join","key","keys","keyspace","known","last","left","let","letting","like","limit","lsm","map","mapping","matched","materialized","merge","minus","namespace","nest","not","number","object","offset","on","option","or","order","outer","over","parse","partition","password","path","pool","prepare","primary","private","privilege","procedure","public","raw","realm","reduce","rename","return","returning","revoke","right","role","rollback","satisfies","schema","select","self","semi","set","show","some","start","statistics","string","system","then","to","transaction","trigger","truncate","under","union","unique","unknown","unnest","unset","update","upsert","use","user","using","validate","value","valued","values","via","view","when","where","while","with","within","work","xor"],literal:["true","false","null","missing|5"],built_in:["array_agg","array_append","array_concat","array_contains","array_count","array_distinct","array_ifnull","array_length","array_max","array_min","array_position","array_prepend","array_put","array_range","array_remove","array_repeat","array_replace","array_reverse","array_sort","array_sum","avg","count","max","min","sum","greatest","least","ifmissing","ifmissingornull","ifnull","missingif","nullif","ifinf","ifnan","ifnanorinf","naninf","neginfif","posinfif","clock_millis","clock_str","date_add_millis","date_add_str","date_diff_millis","date_diff_str","date_part_millis","date_part_str","date_trunc_millis","date_trunc_str","duration_to_str","millis","str_to_millis","millis_to_str","millis_to_utc","millis_to_zone_name","now_millis","now_str","str_to_duration","str_to_utc","str_to_zone_name","decode_json","encode_json","encoded_size","poly_length","base64","base64_encode","base64_decode","meta","uuid","abs","acos","asin","atan","atan2","ceil","cos","degrees","e","exp","ln","log","floor","pi","power","radians","random","round","sign","sin","sqrt","tan","trunc","object_length","object_names","object_pairs","object_inner_pairs","object_values","object_inner_values","object_add","object_put","object_remove","object_unwrap","regexp_contains","regexp_like","regexp_position","regexp_replace","contains","initcap","length","lower","ltrim","position","repeat","replace","rtrim","split","substr","title","trim","upper","isarray","isatom","isboolean","isnumber","isobject","isstring","type","toarray","toatom","toboolean","tonumber","toobject","tostring"]},contains:[{className:"string",begin:"'",end:"'",contains:[e.BACKSLASH_ESCAPE]},{className:"string",begin:'"',end:'"',contains:[e.BACKSLASH_ESCAPE]},{className:"symbol",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE]},e.C_BLOCK_COMMENT_MODE]}}return LY=t,LY}var PY,Hye;function J5t(){if(Hye)return PY;Hye=1;function t(e){const r={match:[/^\s*(?=\S)/,/[^:]+/,/:\s*/,/$/],className:{2:"attribute",3:"punctuation"}},n={match:[/^\s*(?=\S)/,/[^:]*[^: ]/,/[ ]*:/,/[ ]/,/.*$/],className:{2:"attribute",3:"punctuation",5:"string"}},i={match:[/^\s*/,/>/,/[ ]/,/.*$/],className:{2:"punctuation",4:"string"}},a={variants:[{match:[/^\s*/,/-/,/[ ]/,/.*$/]},{match:[/^\s*/,/-$/]}],className:{2:"bullet",4:"string"}};return{name:"Nested Text",aliases:["nt"],contains:[e.inherit(e.HASH_COMMENT_MODE,{begin:/^\s*(?=#)/,excludeBegin:!0}),a,i,r,n]}}return PY=t,PY}var FY,Vye;function ext(){if(Vye)return FY;Vye=1;function t(e){const r=e.regex,n={className:"variable",variants:[{begin:/\$\d+/},{begin:/\$\{\w+\}/},{begin:r.concat(/[$@]/,e.UNDERSCORE_IDENT_RE)}]},a={endsWithParent:!0,keywords:{$pattern:/[a-z_]{2,}|\/dev\/poll/,literal:["on","off","yes","no","true","false","none","blocked","debug","info","notice","warn","error","crit","select","break","last","permanent","redirect","kqueue","rtsig","epoll","poll","/dev/poll"]},relevance:0,illegal:"=>",contains:[e.HASH_COMMENT_MODE,{className:"string",contains:[e.BACKSLASH_ESCAPE,n],variants:[{begin:/"/,end:/"/},{begin:/'/,end:/'/}]},{begin:"([a-z]+):/",end:"\\s",endsWithParent:!0,excludeEnd:!0,contains:[n]},{className:"regexp",contains:[e.BACKSLASH_ESCAPE,n],variants:[{begin:"\\s\\^",end:"\\s|\\{|;",returnEnd:!0},{begin:"~\\*?\\s+",end:"\\s|\\{|;",returnEnd:!0},{begin:"\\*(\\.[a-z\\-]+)+"},{begin:"([a-z\\-]+\\.)+\\*"}]},{className:"number",begin:"\\b\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}(:\\d{1,5})?\\b"},{className:"number",begin:"\\b\\d+[kKmMgGdshdwy]?\\b",relevance:0},n]};return{name:"Nginx config",aliases:["nginxconf"],contains:[e.HASH_COMMENT_MODE,{beginKeywords:"upstream location",end:/;|\{/,contains:a.contains,keywords:{section:"upstream location"}},{className:"section",begin:r.concat(e.UNDERSCORE_IDENT_RE+r.lookahead(/\s+\{/)),relevance:0},{begin:r.lookahead(e.UNDERSCORE_IDENT_RE+"\\s"),end:";|\\{",contains:[{className:"attribute",begin:e.UNDERSCORE_IDENT_RE,starts:a}],relevance:0}],illegal:"[^\\s\\}\\{]"}}return FY=t,FY}var BY,Yye;function txt(){if(Yye)return BY;Yye=1;function t(e){return{name:"Nim",keywords:{keyword:["addr","and","as","asm","bind","block","break","case","cast","concept","const","continue","converter","defer","discard","distinct","div","do","elif","else","end","enum","except","export","finally","for","from","func","generic","guarded","if","import","in","include","interface","is","isnot","iterator","let","macro","method","mixin","mod","nil","not","notin","object","of","or","out","proc","ptr","raise","ref","return","shared","shl","shr","static","template","try","tuple","type","using","var","when","while","with","without","xor","yield"],literal:["true","false"],type:["int","int8","int16","int32","int64","uint","uint8","uint16","uint32","uint64","float","float32","float64","bool","char","string","cstring","pointer","expr","stmt","void","auto","any","range","array","openarray","varargs","seq","set","clong","culong","cchar","cschar","cshort","cint","csize","clonglong","cfloat","cdouble","clongdouble","cuchar","cushort","cuint","culonglong","cstringarray","semistatic"],built_in:["stdin","stdout","stderr","result"]},contains:[{className:"meta",begin:/\{\./,end:/\.\}/,relevance:10},{className:"string",begin:/[a-zA-Z]\w*"/,end:/"/,contains:[{begin:/""/}]},{className:"string",begin:/([a-zA-Z]\w*)?"""/,end:/"""/},e.QUOTE_STRING_MODE,{className:"type",begin:/\b[A-Z]\w+\b/,relevance:0},{className:"number",relevance:0,variants:[{begin:/\b(0[xX][0-9a-fA-F][_0-9a-fA-F]*)('?[iIuU](8|16|32|64))?/},{begin:/\b(0o[0-7][_0-7]*)('?[iIuUfF](8|16|32|64))?/},{begin:/\b(0(b|B)[01][_01]*)('?[iIuUfF](8|16|32|64))?/},{begin:/\b(\d[_\d]*)('?[iIuUfF](8|16|32|64))?/}]},e.HASH_COMMENT_MODE]}}return BY=t,BY}var UY,Wye;function rxt(){if(Wye)return UY;Wye=1;function t(e){const r=e.regex,n={keyword:["assert","else","if","in","inherit","let","or","rec","then","with"],literal:["true","false","null"],built_in:["abort","baseNameOf","builtins","derivation","derivationStrict","dirOf","fetchGit","fetchMercurial","fetchTarball","fetchTree","fromTOML","import","isNull","map","placeholder","removeAttrs","scopedImport","throw","toString"]},i={scope:"built_in",match:r.either(...["abort","add","addDrvOutputDependencies","addErrorContext","all","any","appendContext","attrNames","attrValues","baseNameOf","bitAnd","bitOr","bitXor","break","builtins","catAttrs","ceil","compareVersions","concatLists","concatMap","concatStringsSep","convertHash","currentSystem","currentTime","deepSeq","derivation","derivationStrict","dirOf","div","elem","elemAt","false","fetchGit","fetchMercurial","fetchTarball","fetchTree","fetchurl","filter","filterSource","findFile","flakeRefToString","floor","foldl'","fromJSON","fromTOML","functionArgs","genList","genericClosure","getAttr","getContext","getEnv","getFlake","groupBy","hasAttr","hasContext","hashFile","hashString","head","import","intersectAttrs","isAttrs","isBool","isFloat","isFunction","isInt","isList","isNull","isPath","isString","langVersion","length","lessThan","listToAttrs","map","mapAttrs","match","mul","nixPath","nixVersion","null","parseDrvName","parseFlakeRef","partition","path","pathExists","placeholder","readDir","readFile","readFileType","removeAttrs","replaceStrings","scopedImport","seq","sort","split","splitVersion","storeDir","storePath","stringLength","sub","substring","tail","throw","toFile","toJSON","toPath","toString","toXML","trace","traceVerbose","true","tryEval","typeOf","unsafeDiscardOutputDependency","unsafeDiscardStringContext","unsafeGetAttrPos","warn","zipAttrsWith"].map(w=>`builtins\\.${w}`)),relevance:10},a="[A-Za-z_][A-Za-z0-9_'-]*",s={scope:"symbol",match:new RegExp(`<${a}(/${a})*>`)},o="[A-Za-z0-9_\\+\\.-]+",l={scope:"symbol",match:new RegExp(`(\\.\\.|\\.|~)?/(${o})?(/${o})*(?=[\\s;])`)},u=r.either("==","=","\\+\\+","\\+","<=","<\\|","<",">=",">","->","//","/","!=","!","\\|\\|","\\|>","\\?","\\*","&&"),d={scope:"operator",match:r.concat(u,/(?!-)/),relevance:0},h={scope:"number",match:new RegExp(`${e.NUMBER_RE}(?!-)`),relevance:0},f={variants:[{scope:"operator",beforeMatch:/\s/,begin:/-(?!>)/},{begin:[new RegExp(`${e.NUMBER_RE}`),/-/,/(?!>)/],beginScope:{1:"number",2:"operator"}},{begin:[u,/-/,/(?!>)/],beginScope:{1:"operator",2:"operator"}}],relevance:0},p={beforeMatch:/(^|\{|;)\s*/,begin:new RegExp(`${a}(\\.${a})*\\s*=(?!=)`),returnBegin:!0,relevance:0,contains:[{scope:"attr",match:new RegExp(`${a}(\\.${a})*(?=\\s*=)`),relevance:.2}]},g={scope:"char.escape",match:/\\\$/},m={scope:"char.escape",match:/''\$/},_={scope:"subst",begin:/\$\{/,end:/\}/,keywords:n},v={scope:"char.escape",match:/'''/},b={scope:"char.escape",match:/\\(?!\$)./},y={scope:"string",variants:[{begin:"''",end:"''",contains:[m,_,v,b]},{begin:'"',end:'"',contains:[g,_,b]}]},E={scope:"params",match:new RegExp(`${a}\\s*:(?=\\s)`)},T=[h,e.HASH_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),i,y,s,l,E,p,f,d];_.contains=T;const C=[{scope:"meta.prompt",match:/^nix-repl>(?=\s)/,relevance:10},{scope:"meta",beforeMatch:/\s+/,begin:/:([a-z]+|\?)/}];return{name:"Nix",aliases:["nixos"],keywords:n,contains:T.concat(C)}}return UY=t,UY}var $Y,Kye;function nxt(){if(Kye)return $Y;Kye=1;function t(e){return{name:"Node REPL",contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"javascript"}},variants:[{begin:/^>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return $Y=t,$Y}var GY,jye;function ixt(){if(jye)return GY;jye=1;function t(e){const r=e.regex,n=["ADMINTOOLS","APPDATA","CDBURN_AREA","CMDLINE","COMMONFILES32","COMMONFILES64","COMMONFILES","COOKIES","DESKTOP","DOCUMENTS","EXEDIR","EXEFILE","EXEPATH","FAVORITES","FONTS","HISTORY","HWNDPARENT","INSTDIR","INTERNET_CACHE","LANGUAGE","LOCALAPPDATA","MUSIC","NETHOOD","OUTDIR","PICTURES","PLUGINSDIR","PRINTHOOD","PROFILE","PROGRAMFILES32","PROGRAMFILES64","PROGRAMFILES","QUICKLAUNCH","RECENT","RESOURCES_LOCALIZED","RESOURCES","SENDTO","SMPROGRAMS","SMSTARTUP","STARTMENU","SYSDIR","TEMP","TEMPLATES","VIDEOS","WINDIR"],i=["ARCHIVE","FILE_ATTRIBUTE_ARCHIVE","FILE_ATTRIBUTE_NORMAL","FILE_ATTRIBUTE_OFFLINE","FILE_ATTRIBUTE_READONLY","FILE_ATTRIBUTE_SYSTEM","FILE_ATTRIBUTE_TEMPORARY","HKCR","HKCU","HKDD","HKEY_CLASSES_ROOT","HKEY_CURRENT_CONFIG","HKEY_CURRENT_USER","HKEY_DYN_DATA","HKEY_LOCAL_MACHINE","HKEY_PERFORMANCE_DATA","HKEY_USERS","HKLM","HKPD","HKU","IDABORT","IDCANCEL","IDIGNORE","IDNO","IDOK","IDRETRY","IDYES","MB_ABORTRETRYIGNORE","MB_DEFBUTTON1","MB_DEFBUTTON2","MB_DEFBUTTON3","MB_DEFBUTTON4","MB_ICONEXCLAMATION","MB_ICONINFORMATION","MB_ICONQUESTION","MB_ICONSTOP","MB_OK","MB_OKCANCEL","MB_RETRYCANCEL","MB_RIGHT","MB_RTLREADING","MB_SETFOREGROUND","MB_TOPMOST","MB_USERICON","MB_YESNO","NORMAL","OFFLINE","READONLY","SHCTX","SHELL_CONTEXT","SYSTEM|TEMPORARY"],a=["addincludedir","addplugindir","appendfile","assert","cd","define","delfile","echo","else","endif","error","execute","finalize","getdllversion","gettlbversion","if","ifdef","ifmacrodef","ifmacrondef","ifndef","include","insertmacro","macro","macroend","makensis","packhdr","searchparse","searchreplace","system","tempfile","undef","uninstfinalize","verbose","warning"],s={className:"variable.constant",begin:r.concat(/\$/,r.either(...n))},o={className:"variable",begin:/\$+\{[\!\w.:-]+\}/},l={className:"variable",begin:/\$+\w[\w\.]*/,illegal:/\(\)\{\}/},u={className:"variable",begin:/\$+\([\w^.:!-]+\)/},d={className:"params",begin:r.either(...i)},h={className:"keyword",begin:r.concat(/!/,r.either(...a))},f={className:"char.escape",begin:/\$(\\[nrt]|\$)/},p={className:"title.function",begin:/\w+::\w+/},g={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"},{begin:"`",end:"`"}],illegal:/\n/,contains:[f,s,o,l,u]},m=["Abort","AddBrandingImage","AddSize","AllowRootDirInstall","AllowSkipFiles","AutoCloseWindow","BGFont","BGGradient","BrandingText","BringToFront","Call","CallInstDLL","Caption","ChangeUI","CheckBitmap","ClearErrors","CompletedText","ComponentText","CopyFiles","CRCCheck","CreateDirectory","CreateFont","CreateShortCut","Delete","DeleteINISec","DeleteINIStr","DeleteRegKey","DeleteRegValue","DetailPrint","DetailsButtonText","DirText","DirVar","DirVerify","EnableWindow","EnumRegKey","EnumRegValue","Exch","Exec","ExecShell","ExecShellWait","ExecWait","ExpandEnvStrings","File","FileBufSize","FileClose","FileErrorText","FileOpen","FileRead","FileReadByte","FileReadUTF16LE","FileReadWord","FileWriteUTF16LE","FileSeek","FileWrite","FileWriteByte","FileWriteWord","FindClose","FindFirst","FindNext","FindWindow","FlushINI","GetCurInstType","GetCurrentAddress","GetDlgItem","GetDLLVersion","GetDLLVersionLocal","GetErrorLevel","GetFileTime","GetFileTimeLocal","GetFullPathName","GetFunctionAddress","GetInstDirError","GetKnownFolderPath","GetLabelAddress","GetTempFileName","GetWinVer","Goto","HideWindow","Icon","IfAbort","IfErrors","IfFileExists","IfRebootFlag","IfRtlLanguage","IfShellVarContextAll","IfSilent","InitPluginsDir","InstallButtonText","InstallColors","InstallDir","InstallDirRegKey","InstProgressFlags","InstType","InstTypeGetText","InstTypeSetText","Int64Cmp","Int64CmpU","Int64Fmt","IntCmp","IntCmpU","IntFmt","IntOp","IntPtrCmp","IntPtrCmpU","IntPtrOp","IsWindow","LangString","LicenseBkColor","LicenseData","LicenseForceSelection","LicenseLangString","LicenseText","LoadAndSetImage","LoadLanguageFile","LockWindow","LogSet","LogText","ManifestDPIAware","ManifestLongPathAware","ManifestMaxVersionTested","ManifestSupportedOS","MessageBox","MiscButtonText","Name|0","Nop","OutFile","Page","PageCallbacks","PEAddResource","PEDllCharacteristics","PERemoveResource","PESubsysVer","Pop","Push","Quit","ReadEnvStr","ReadINIStr","ReadRegDWORD","ReadRegStr","Reboot","RegDLL","Rename","RequestExecutionLevel","ReserveFile","Return","RMDir","SearchPath","SectionGetFlags","SectionGetInstTypes","SectionGetSize","SectionGetText","SectionIn","SectionSetFlags","SectionSetInstTypes","SectionSetSize","SectionSetText","SendMessage","SetAutoClose","SetBrandingImage","SetCompress","SetCompressor","SetCompressorDictSize","SetCtlColors","SetCurInstType","SetDatablockOptimize","SetDateSave","SetDetailsPrint","SetDetailsView","SetErrorLevel","SetErrors","SetFileAttributes","SetFont","SetOutPath","SetOverwrite","SetRebootFlag","SetRegView","SetShellVarContext","SetSilent","ShowInstDetails","ShowUninstDetails","ShowWindow","SilentInstall","SilentUnInstall","Sleep","SpaceTexts","StrCmp","StrCmpS","StrCpy","StrLen","SubCaption","Unicode","UninstallButtonText","UninstallCaption","UninstallIcon","UninstallSubCaption","UninstallText","UninstPage","UnRegDLL","Var","VIAddVersionKey","VIFileVersion","VIProductVersion","WindowIcon","WriteINIStr","WriteRegBin","WriteRegDWORD","WriteRegExpandStr","WriteRegMultiStr","WriteRegNone","WriteRegStr","WriteUninstaller","XPStyle"],_=["admin","all","auto","both","bottom","bzip2","colored","components","current","custom","directory","false","force","hide","highest","ifdiff","ifnewer","instfiles","lastused","leave","left","license","listonly","lzma","nevershow","none","normal","notset","off","on","open","print","right","show","silent","silentlog","smooth","textonly","top","true","try","un.components","un.custom","un.directory","un.instfiles","un.license","uninstConfirm","user","Win10","Win7","Win8","WinVista","zlib"],v={match:[/Function/,/\s+/,r.concat(/(\.)?/,e.IDENT_RE)],scope:{1:"keyword",3:"title.function"}},y={match:[/Var/,/\s+/,/(?:\/GLOBAL\s+)?/,/[A-Za-z][\w.]*/],scope:{1:"keyword",3:"params",4:"variable"}};return{name:"NSIS",case_insensitive:!0,keywords:{keyword:m,literal:_},contains:[e.HASH_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT(";","$",{relevance:0}),y,v,{beginKeywords:"Function PageEx Section SectionGroup FunctionEnd SectionEnd"},g,h,o,l,u,d,p,e.NUMBER_MODE]}}return GY=t,GY}var zY,Xye;function axt(){if(Xye)return zY;Xye=1;function t(e){const r={className:"built_in",begin:"\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+"},n=/[a-zA-Z@][a-zA-Z0-9_]*/,l={"variable.language":["this","super"],$pattern:n,keyword:["while","export","sizeof","typedef","const","struct","for","union","volatile","static","mutable","if","do","return","goto","enum","else","break","extern","asm","case","default","register","explicit","typename","switch","continue","inline","readonly","assign","readwrite","self","@synchronized","id","typeof","nonatomic","IBOutlet","IBAction","strong","weak","copy","in","out","inout","bycopy","byref","oneway","__strong","__weak","__block","__autoreleasing","@private","@protected","@public","@try","@property","@end","@throw","@catch","@finally","@autoreleasepool","@synthesize","@dynamic","@selector","@optional","@required","@encode","@package","@import","@defs","@compatibility_alias","__bridge","__bridge_transfer","__bridge_retained","__bridge_retain","__covariant","__contravariant","__kindof","_Nonnull","_Nullable","_Null_unspecified","__FUNCTION__","__PRETTY_FUNCTION__","__attribute__","getter","setter","retain","unsafe_unretained","nonnull","nullable","null_unspecified","null_resettable","class","instancetype","NS_DESIGNATED_INITIALIZER","NS_UNAVAILABLE","NS_REQUIRES_SUPER","NS_RETURNS_INNER_POINTER","NS_INLINE","NS_AVAILABLE","NS_DEPRECATED","NS_ENUM","NS_OPTIONS","NS_SWIFT_UNAVAILABLE","NS_ASSUME_NONNULL_BEGIN","NS_ASSUME_NONNULL_END","NS_REFINED_FOR_SWIFT","NS_SWIFT_NAME","NS_SWIFT_NOTHROW","NS_DURING","NS_HANDLER","NS_ENDHANDLER","NS_VALUERETURN","NS_VOIDRETURN"],literal:["false","true","FALSE","TRUE","nil","YES","NO","NULL"],built_in:["dispatch_once_t","dispatch_queue_t","dispatch_sync","dispatch_async","dispatch_once"],type:["int","float","char","unsigned","signed","short","long","double","wchar_t","unichar","void","bool","BOOL","id|0","_Bool"]},u={$pattern:n,keyword:["@interface","@class","@protocol","@implementation"]};return{name:"Objective-C",aliases:["mm","objc","obj-c","obj-c++","objective-c++"],keywords:l,illegal:"/,end:/$/,illegal:"\\n"},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"class",begin:"("+u.keyword.join("|")+")\\b",end:/(\{|$)/,excludeEnd:!0,keywords:u,contains:[e.UNDERSCORE_TITLE_MODE]},{begin:"\\."+e.UNDERSCORE_IDENT_RE,relevance:0}]}}return zY=t,zY}var qY,Qye;function sxt(){if(Qye)return qY;Qye=1;function t(e){return{name:"OCaml",aliases:["ml"],keywords:{$pattern:"[a-z_]\\w*!?",keyword:"and as assert asr begin class constraint do done downto else end exception external for fun function functor if in include inherit! inherit initializer land lazy let lor lsl lsr lxor match method!|10 method mod module mutable new object of open! open or private rec sig struct then to try type val! val virtual when while with parser value",built_in:"array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 string unit in_channel out_channel ref",literal:"true false"},illegal:/\/\/|>>/,contains:[{className:"literal",begin:"\\[(\\|\\|)?\\]|\\(\\)",relevance:0},e.COMMENT("\\(\\*","\\*\\)",{contains:["self"]}),{className:"symbol",begin:"'[A-Za-z_](?!')[\\w']*"},{className:"type",begin:"`[A-Z][\\w']*"},{className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},{begin:"[a-z_]\\w*'[\\w']*",relevance:0},e.inherit(e.APOS_STRING_MODE,{className:"string",relevance:0}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"number",begin:"\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",relevance:0},{begin:/->/}]}}return qY=t,qY}var HY,Zye;function oxt(){if(Zye)return HY;Zye=1;function t(e){const r={className:"keyword",begin:"\\$(f[asn]|t|vp[rtd]|children)"},n={className:"literal",begin:"false|true|PI|undef"},i={className:"number",begin:"\\b\\d+(\\.\\d+)?(e-?\\d+)?",relevance:0},a=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),s={className:"meta",keywords:{keyword:"include use"},begin:"include|use <",end:">"},o={className:"params",begin:"\\(",end:"\\)",contains:["self",i,a,r,n]},l={begin:"[*!#%]",relevance:0},u={className:"function",beginKeywords:"module function",end:/=|\{/,contains:[o,e.UNDERSCORE_TITLE_MODE]};return{name:"OpenSCAD",aliases:["scad"],keywords:{keyword:"function module include use for intersection_for if else \\%",literal:"false true PI undef",built_in:"circle square polygon text sphere cube cylinder polyhedron translate rotate scale resize mirror multmatrix color offset hull minkowski union difference intersection abs sign sin cos tan acos asin atan atan2 floor round ceil ln log pow sqrt exp rands min max concat lookup str chr search version version_num norm cross parent_module echo import import_dxf dxf_linear_extrude linear_extrude rotate_extrude surface projection render children dxf_cross dxf_dim let assign"},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,i,s,a,r,l,u]}}return HY=t,HY}var VY,Jye;function lxt(){if(Jye)return VY;Jye=1;function t(e){const r={$pattern:/\.?\w+/,keyword:"abstract add and array as asc aspect assembly async begin break block by case class concat const copy constructor continue create default delegate desc distinct div do downto dynamic each else empty end ensure enum equals event except exit extension external false final finalize finalizer finally flags for forward from function future global group has if implementation implements implies in index inherited inline interface into invariants is iterator join locked locking loop matching method mod module namespace nested new nil not notify nullable of old on operator or order out override parallel params partial pinned private procedure property protected public queryable raise read readonly record reintroduce remove repeat require result reverse sealed select self sequence set shl shr skip static step soft take then to true try tuple type union unit unsafe until uses using var virtual raises volatile where while with write xor yield await mapped deprecated stdcall cdecl pascal register safecall overload library platform reference packed strict published autoreleasepool selector strong weak unretained"},n=e.COMMENT(/\{/,/\}/,{relevance:0}),i=e.COMMENT("\\(\\*","\\*\\)",{relevance:10}),a={className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},s={className:"string",begin:"(#\\d+)+"},o={beginKeywords:"function constructor destructor procedure method",end:"[:;]",keywords:"function constructor|10 destructor|10 procedure|10 method|10",contains:[e.inherit(e.TITLE_MODE,{scope:"title.function"}),{className:"params",begin:"\\(",end:"\\)",keywords:r,contains:[a,s]},n,i]},l={scope:"punctuation",match:/;/,relevance:0};return{name:"Oxygene",case_insensitive:!0,keywords:r,illegal:'("|\\$[G-Zg-z]|\\/\\*||->)',contains:[n,i,e.C_LINE_COMMENT_MODE,a,s,e.NUMBER_MODE,o,l]}}return VY=t,VY}var YY,ebe;function cxt(){if(ebe)return YY;ebe=1;function t(e){const r=e.COMMENT(/\{/,/\}/,{contains:["self"]});return{name:"Parser3",subLanguage:"xml",relevance:0,contains:[e.COMMENT("^#","$"),e.COMMENT(/\^rem\{/,/\}/,{relevance:10,contains:[r]}),{className:"meta",begin:"^@(?:BASE|USE|CLASS|OPTIONS)$",relevance:10},{className:"title",begin:"@[\\w\\-]+\\[[\\w^;\\-]*\\](?:\\[[\\w^;\\-]*\\])?(?:.*)$"},{className:"variable",begin:/\$\{?[\w\-.:]+\}?/},{className:"keyword",begin:/\^[\w\-.:]+/},{className:"number",begin:"\\^#[0-9a-fA-F]+"},e.C_NUMBER_MODE]}}return YY=t,YY}var WY,tbe;function uxt(){if(tbe)return WY;tbe=1;function t(e){const r={className:"variable",begin:/\$[\w\d#@][\w\d_]*/,relevance:0},n={className:"variable",begin:/<(?!\/)/,end:/>/};return{name:"Packet Filter config",aliases:["pf.conf"],keywords:{$pattern:/[a-z0-9_<>-]+/,built_in:"block match pass load anchor|5 antispoof|10 set table",keyword:"in out log quick on rdomain inet inet6 proto from port os to route allow-opts divert-packet divert-reply divert-to flags group icmp-type icmp6-type label once probability recieved-on rtable prio queue tos tag tagged user keep fragment for os drop af-to|10 binat-to|10 nat-to|10 rdr-to|10 bitmask least-stats random round-robin source-hash static-port dup-to reply-to route-to parent bandwidth default min max qlimit block-policy debug fingerprints hostid limit loginterface optimization reassemble ruleset-optimization basic none profile skip state-defaults state-policy timeout const counters persist no modulate synproxy state|5 floating if-bound no-sync pflow|10 sloppy source-track global rule max-src-nodes max-src-states max-src-conn max-src-conn-rate overload flush scrub|5 max-mss min-ttl no-df|10 random-id",literal:"all any no-route self urpf-failed egress|5 unknown"},contains:[e.HASH_COMMENT_MODE,e.NUMBER_MODE,e.QUOTE_STRING_MODE,r,n]}}return WY=t,WY}var KY,rbe;function dxt(){if(rbe)return KY;rbe=1;function t(e){const r=e.COMMENT("--","$"),n="[a-zA-Z_][a-zA-Z_0-9$]*",i="\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",a="<<\\s*"+n+"\\s*>>",s="ABORT ALTER ANALYZE BEGIN CALL CHECKPOINT|10 CLOSE CLUSTER COMMENT COMMIT COPY CREATE DEALLOCATE DECLARE DELETE DISCARD DO DROP END EXECUTE EXPLAIN FETCH GRANT IMPORT INSERT LISTEN LOAD LOCK MOVE NOTIFY PREPARE REASSIGN|10 REFRESH REINDEX RELEASE RESET REVOKE ROLLBACK SAVEPOINT SECURITY SELECT SET SHOW START TRUNCATE UNLISTEN|10 UPDATE VACUUM|10 VALUES AGGREGATE COLLATION CONVERSION|10 DATABASE DEFAULT PRIVILEGES DOMAIN TRIGGER EXTENSION FOREIGN WRAPPER|10 TABLE FUNCTION GROUP LANGUAGE LARGE OBJECT MATERIALIZED VIEW OPERATOR CLASS FAMILY POLICY PUBLICATION|10 ROLE RULE SCHEMA SEQUENCE SERVER STATISTICS SUBSCRIPTION SYSTEM TABLESPACE CONFIGURATION DICTIONARY PARSER TEMPLATE TYPE USER MAPPING PREPARED ACCESS METHOD CAST AS TRANSFORM TRANSACTION OWNED TO INTO SESSION AUTHORIZATION INDEX PROCEDURE ASSERTION ALL ANALYSE AND ANY ARRAY ASC ASYMMETRIC|10 BOTH CASE CHECK COLLATE COLUMN CONCURRENTLY|10 CONSTRAINT CROSS DEFERRABLE RANGE DESC DISTINCT ELSE EXCEPT FOR FREEZE|10 FROM FULL HAVING ILIKE IN INITIALLY INNER INTERSECT IS ISNULL JOIN LATERAL LEADING LIKE LIMIT NATURAL NOT NOTNULL NULL OFFSET ON ONLY OR ORDER OUTER OVERLAPS PLACING PRIMARY REFERENCES RETURNING SIMILAR SOME SYMMETRIC TABLESAMPLE THEN TRAILING UNION UNIQUE USING VARIADIC|10 VERBOSE WHEN WHERE WINDOW WITH BY RETURNS INOUT OUT SETOF|10 IF STRICT CURRENT CONTINUE OWNER LOCATION OVER PARTITION WITHIN BETWEEN ESCAPE EXTERNAL INVOKER DEFINER WORK RENAME VERSION CONNECTION CONNECT TABLES TEMP TEMPORARY FUNCTIONS SEQUENCES TYPES SCHEMAS OPTION CASCADE RESTRICT ADD ADMIN EXISTS VALID VALIDATE ENABLE DISABLE REPLICA|10 ALWAYS PASSING COLUMNS PATH REF VALUE OVERRIDING IMMUTABLE STABLE VOLATILE BEFORE AFTER EACH ROW PROCEDURAL ROUTINE NO HANDLER VALIDATOR OPTIONS STORAGE OIDS|10 WITHOUT INHERIT DEPENDS CALLED INPUT LEAKPROOF|10 COST ROWS NOWAIT SEARCH UNTIL ENCRYPTED|10 PASSWORD CONFLICT|10 INSTEAD INHERITS CHARACTERISTICS WRITE CURSOR ALSO STATEMENT SHARE EXCLUSIVE INLINE ISOLATION REPEATABLE READ COMMITTED SERIALIZABLE UNCOMMITTED LOCAL GLOBAL SQL PROCEDURES RECURSIVE SNAPSHOT ROLLUP CUBE TRUSTED|10 INCLUDE FOLLOWING PRECEDING UNBOUNDED RANGE GROUPS UNENCRYPTED|10 SYSID FORMAT DELIMITER HEADER QUOTE ENCODING FILTER OFF FORCE_QUOTE FORCE_NOT_NULL FORCE_NULL COSTS BUFFERS TIMING SUMMARY DISABLE_PAGE_SKIPPING RESTART CYCLE GENERATED IDENTITY DEFERRED IMMEDIATE LEVEL LOGGED UNLOGGED OF NOTHING NONE EXCLUDE ATTRIBUTE USAGE ROUTINES TRUE FALSE NAN INFINITY ",o="SUPERUSER NOSUPERUSER CREATEDB NOCREATEDB CREATEROLE NOCREATEROLE INHERIT NOINHERIT LOGIN NOLOGIN REPLICATION NOREPLICATION BYPASSRLS NOBYPASSRLS ",l="ALIAS BEGIN CONSTANT DECLARE END EXCEPTION RETURN PERFORM|10 RAISE GET DIAGNOSTICS STACKED|10 FOREACH LOOP ELSIF EXIT WHILE REVERSE SLICE DEBUG LOG INFO NOTICE WARNING ASSERT OPEN ",u="BIGINT INT8 BIGSERIAL SERIAL8 BIT VARYING VARBIT BOOLEAN BOOL BOX BYTEA CHARACTER CHAR VARCHAR CIDR CIRCLE DATE DOUBLE PRECISION FLOAT8 FLOAT INET INTEGER INT INT4 INTERVAL JSON JSONB LINE LSEG|10 MACADDR MACADDR8 MONEY NUMERIC DEC DECIMAL PATH POINT POLYGON REAL FLOAT4 SMALLINT INT2 SMALLSERIAL|10 SERIAL2|10 SERIAL|10 SERIAL4|10 TEXT TIME ZONE TIMETZ|10 TIMESTAMP TIMESTAMPTZ|10 TSQUERY|10 TSVECTOR|10 TXID_SNAPSHOT|10 UUID XML NATIONAL NCHAR INT4RANGE|10 INT8RANGE|10 NUMRANGE|10 TSRANGE|10 TSTZRANGE|10 DATERANGE|10 ANYELEMENT ANYARRAY ANYNONARRAY ANYENUM ANYRANGE CSTRING INTERNAL RECORD PG_DDL_COMMAND VOID UNKNOWN OPAQUE REFCURSOR NAME OID REGPROC|10 REGPROCEDURE|10 REGOPER|10 REGOPERATOR|10 REGCLASS|10 REGTYPE|10 REGROLE|10 REGNAMESPACE|10 REGCONFIG|10 REGDICTIONARY|10 ",d=u.trim().split(" ").map(function(_){return _.split("|")[0]}).join("|"),h="CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURRENT_CATALOG|10 CURRENT_DATE LOCALTIME LOCALTIMESTAMP CURRENT_ROLE|10 CURRENT_SCHEMA|10 SESSION_USER PUBLIC ",f="FOUND NEW OLD TG_NAME|10 TG_WHEN|10 TG_LEVEL|10 TG_OP|10 TG_RELID|10 TG_RELNAME|10 TG_TABLE_NAME|10 TG_TABLE_SCHEMA|10 TG_NARGS|10 TG_ARGV|10 TG_EVENT|10 TG_TAG|10 ROW_COUNT RESULT_OID|10 PG_CONTEXT|10 RETURNED_SQLSTATE COLUMN_NAME CONSTRAINT_NAME PG_DATATYPE_NAME|10 MESSAGE_TEXT TABLE_NAME SCHEMA_NAME PG_EXCEPTION_DETAIL|10 PG_EXCEPTION_HINT|10 PG_EXCEPTION_CONTEXT|10 ",p="SQLSTATE SQLERRM|10 SUCCESSFUL_COMPLETION WARNING DYNAMIC_RESULT_SETS_RETURNED IMPLICIT_ZERO_BIT_PADDING NULL_VALUE_ELIMINATED_IN_SET_FUNCTION PRIVILEGE_NOT_GRANTED PRIVILEGE_NOT_REVOKED STRING_DATA_RIGHT_TRUNCATION DEPRECATED_FEATURE NO_DATA NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED SQL_STATEMENT_NOT_YET_COMPLETE CONNECTION_EXCEPTION CONNECTION_DOES_NOT_EXIST CONNECTION_FAILURE SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION TRANSACTION_RESOLUTION_UNKNOWN PROTOCOL_VIOLATION TRIGGERED_ACTION_EXCEPTION FEATURE_NOT_SUPPORTED INVALID_TRANSACTION_INITIATION LOCATOR_EXCEPTION INVALID_LOCATOR_SPECIFICATION INVALID_GRANTOR INVALID_GRANT_OPERATION INVALID_ROLE_SPECIFICATION DIAGNOSTICS_EXCEPTION STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER CASE_NOT_FOUND CARDINALITY_VIOLATION DATA_EXCEPTION ARRAY_SUBSCRIPT_ERROR CHARACTER_NOT_IN_REPERTOIRE DATETIME_FIELD_OVERFLOW DIVISION_BY_ZERO ERROR_IN_ASSIGNMENT ESCAPE_CHARACTER_CONFLICT INDICATOR_OVERFLOW INTERVAL_FIELD_OVERFLOW INVALID_ARGUMENT_FOR_LOGARITHM INVALID_ARGUMENT_FOR_NTILE_FUNCTION INVALID_ARGUMENT_FOR_NTH_VALUE_FUNCTION INVALID_ARGUMENT_FOR_POWER_FUNCTION INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION INVALID_CHARACTER_VALUE_FOR_CAST INVALID_DATETIME_FORMAT INVALID_ESCAPE_CHARACTER INVALID_ESCAPE_OCTET INVALID_ESCAPE_SEQUENCE NONSTANDARD_USE_OF_ESCAPE_CHARACTER INVALID_INDICATOR_PARAMETER_VALUE INVALID_PARAMETER_VALUE INVALID_REGULAR_EXPRESSION INVALID_ROW_COUNT_IN_LIMIT_CLAUSE INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE INVALID_TABLESAMPLE_ARGUMENT INVALID_TABLESAMPLE_REPEAT INVALID_TIME_ZONE_DISPLACEMENT_VALUE INVALID_USE_OF_ESCAPE_CHARACTER MOST_SPECIFIC_TYPE_MISMATCH NULL_VALUE_NOT_ALLOWED NULL_VALUE_NO_INDICATOR_PARAMETER NUMERIC_VALUE_OUT_OF_RANGE SEQUENCE_GENERATOR_LIMIT_EXCEEDED STRING_DATA_LENGTH_MISMATCH STRING_DATA_RIGHT_TRUNCATION SUBSTRING_ERROR TRIM_ERROR UNTERMINATED_C_STRING ZERO_LENGTH_CHARACTER_STRING FLOATING_POINT_EXCEPTION INVALID_TEXT_REPRESENTATION INVALID_BINARY_REPRESENTATION BAD_COPY_FILE_FORMAT UNTRANSLATABLE_CHARACTER NOT_AN_XML_DOCUMENT INVALID_XML_DOCUMENT INVALID_XML_CONTENT INVALID_XML_COMMENT INVALID_XML_PROCESSING_INSTRUCTION INTEGRITY_CONSTRAINT_VIOLATION RESTRICT_VIOLATION NOT_NULL_VIOLATION FOREIGN_KEY_VIOLATION UNIQUE_VIOLATION CHECK_VIOLATION EXCLUSION_VIOLATION INVALID_CURSOR_STATE INVALID_TRANSACTION_STATE ACTIVE_SQL_TRANSACTION BRANCH_TRANSACTION_ALREADY_ACTIVE HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION READ_ONLY_SQL_TRANSACTION SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED NO_ACTIVE_SQL_TRANSACTION IN_FAILED_SQL_TRANSACTION IDLE_IN_TRANSACTION_SESSION_TIMEOUT INVALID_SQL_STATEMENT_NAME TRIGGERED_DATA_CHANGE_VIOLATION INVALID_AUTHORIZATION_SPECIFICATION INVALID_PASSWORD DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST DEPENDENT_OBJECTS_STILL_EXIST INVALID_TRANSACTION_TERMINATION SQL_ROUTINE_EXCEPTION FUNCTION_EXECUTED_NO_RETURN_STATEMENT MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED INVALID_CURSOR_NAME EXTERNAL_ROUTINE_EXCEPTION CONTAINING_SQL_NOT_PERMITTED MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED EXTERNAL_ROUTINE_INVOCATION_EXCEPTION INVALID_SQLSTATE_RETURNED NULL_VALUE_NOT_ALLOWED TRIGGER_PROTOCOL_VIOLATED SRF_PROTOCOL_VIOLATED EVENT_TRIGGER_PROTOCOL_VIOLATED SAVEPOINT_EXCEPTION INVALID_SAVEPOINT_SPECIFICATION INVALID_CATALOG_NAME INVALID_SCHEMA_NAME TRANSACTION_ROLLBACK TRANSACTION_INTEGRITY_CONSTRAINT_VIOLATION SERIALIZATION_FAILURE STATEMENT_COMPLETION_UNKNOWN DEADLOCK_DETECTED SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION SYNTAX_ERROR INSUFFICIENT_PRIVILEGE CANNOT_COERCE GROUPING_ERROR WINDOWING_ERROR INVALID_RECURSION INVALID_FOREIGN_KEY INVALID_NAME NAME_TOO_LONG RESERVED_NAME DATATYPE_MISMATCH INDETERMINATE_DATATYPE COLLATION_MISMATCH INDETERMINATE_COLLATION WRONG_OBJECT_TYPE GENERATED_ALWAYS UNDEFINED_COLUMN UNDEFINED_FUNCTION UNDEFINED_TABLE UNDEFINED_PARAMETER UNDEFINED_OBJECT DUPLICATE_COLUMN DUPLICATE_CURSOR DUPLICATE_DATABASE DUPLICATE_FUNCTION DUPLICATE_PREPARED_STATEMENT DUPLICATE_SCHEMA DUPLICATE_TABLE DUPLICATE_ALIAS DUPLICATE_OBJECT AMBIGUOUS_COLUMN AMBIGUOUS_FUNCTION AMBIGUOUS_PARAMETER AMBIGUOUS_ALIAS INVALID_COLUMN_REFERENCE INVALID_COLUMN_DEFINITION INVALID_CURSOR_DEFINITION INVALID_DATABASE_DEFINITION INVALID_FUNCTION_DEFINITION INVALID_PREPARED_STATEMENT_DEFINITION INVALID_SCHEMA_DEFINITION INVALID_TABLE_DEFINITION INVALID_OBJECT_DEFINITION WITH_CHECK_OPTION_VIOLATION INSUFFICIENT_RESOURCES DISK_FULL OUT_OF_MEMORY TOO_MANY_CONNECTIONS CONFIGURATION_LIMIT_EXCEEDED PROGRAM_LIMIT_EXCEEDED STATEMENT_TOO_COMPLEX TOO_MANY_COLUMNS TOO_MANY_ARGUMENTS OBJECT_NOT_IN_PREREQUISITE_STATE OBJECT_IN_USE CANT_CHANGE_RUNTIME_PARAM LOCK_NOT_AVAILABLE OPERATOR_INTERVENTION QUERY_CANCELED ADMIN_SHUTDOWN CRASH_SHUTDOWN CANNOT_CONNECT_NOW DATABASE_DROPPED SYSTEM_ERROR IO_ERROR UNDEFINED_FILE DUPLICATE_FILE SNAPSHOT_TOO_OLD CONFIG_FILE_ERROR LOCK_FILE_EXISTS FDW_ERROR FDW_COLUMN_NAME_NOT_FOUND FDW_DYNAMIC_PARAMETER_VALUE_NEEDED FDW_FUNCTION_SEQUENCE_ERROR FDW_INCONSISTENT_DESCRIPTOR_INFORMATION FDW_INVALID_ATTRIBUTE_VALUE FDW_INVALID_COLUMN_NAME FDW_INVALID_COLUMN_NUMBER FDW_INVALID_DATA_TYPE FDW_INVALID_DATA_TYPE_DESCRIPTORS FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER FDW_INVALID_HANDLE FDW_INVALID_OPTION_INDEX FDW_INVALID_OPTION_NAME FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH FDW_INVALID_STRING_FORMAT FDW_INVALID_USE_OF_NULL_POINTER FDW_TOO_MANY_HANDLES FDW_OUT_OF_MEMORY FDW_NO_SCHEMAS FDW_OPTION_NAME_NOT_FOUND FDW_REPLY_HANDLE FDW_SCHEMA_NOT_FOUND FDW_TABLE_NOT_FOUND FDW_UNABLE_TO_CREATE_EXECUTION FDW_UNABLE_TO_CREATE_REPLY FDW_UNABLE_TO_ESTABLISH_CONNECTION PLPGSQL_ERROR RAISE_EXCEPTION NO_DATA_FOUND TOO_MANY_ROWS ASSERT_FAILURE INTERNAL_ERROR DATA_CORRUPTED INDEX_CORRUPTED ",m="ARRAY_AGG AVG BIT_AND BIT_OR BOOL_AND BOOL_OR COUNT EVERY JSON_AGG JSONB_AGG JSON_OBJECT_AGG JSONB_OBJECT_AGG MAX MIN MODE STRING_AGG SUM XMLAGG CORR COVAR_POP COVAR_SAMP REGR_AVGX REGR_AVGY REGR_COUNT REGR_INTERCEPT REGR_R2 REGR_SLOPE REGR_SXX REGR_SXY REGR_SYY STDDEV STDDEV_POP STDDEV_SAMP VARIANCE VAR_POP VAR_SAMP PERCENTILE_CONT PERCENTILE_DISC ROW_NUMBER RANK DENSE_RANK PERCENT_RANK CUME_DIST NTILE LAG LEAD FIRST_VALUE LAST_VALUE NTH_VALUE NUM_NONNULLS NUM_NULLS ABS CBRT CEIL CEILING DEGREES DIV EXP FLOOR LN LOG MOD PI POWER RADIANS ROUND SCALE SIGN SQRT TRUNC WIDTH_BUCKET RANDOM SETSEED ACOS ACOSD ASIN ASIND ATAN ATAND ATAN2 ATAN2D COS COSD COT COTD SIN SIND TAN TAND BIT_LENGTH CHAR_LENGTH CHARACTER_LENGTH LOWER OCTET_LENGTH OVERLAY POSITION SUBSTRING TREAT TRIM UPPER ASCII BTRIM CHR CONCAT CONCAT_WS CONVERT CONVERT_FROM CONVERT_TO DECODE ENCODE INITCAP LEFT LENGTH LPAD LTRIM MD5 PARSE_IDENT PG_CLIENT_ENCODING QUOTE_IDENT|10 QUOTE_LITERAL|10 QUOTE_NULLABLE|10 REGEXP_MATCH REGEXP_MATCHES REGEXP_REPLACE REGEXP_SPLIT_TO_ARRAY REGEXP_SPLIT_TO_TABLE REPEAT REPLACE REVERSE RIGHT RPAD RTRIM SPLIT_PART STRPOS SUBSTR TO_ASCII TO_HEX TRANSLATE OCTET_LENGTH GET_BIT GET_BYTE SET_BIT SET_BYTE TO_CHAR TO_DATE TO_NUMBER TO_TIMESTAMP AGE CLOCK_TIMESTAMP|10 DATE_PART DATE_TRUNC ISFINITE JUSTIFY_DAYS JUSTIFY_HOURS JUSTIFY_INTERVAL MAKE_DATE MAKE_INTERVAL|10 MAKE_TIME MAKE_TIMESTAMP|10 MAKE_TIMESTAMPTZ|10 NOW STATEMENT_TIMESTAMP|10 TIMEOFDAY TRANSACTION_TIMESTAMP|10 ENUM_FIRST ENUM_LAST ENUM_RANGE AREA CENTER DIAMETER HEIGHT ISCLOSED ISOPEN NPOINTS PCLOSE POPEN RADIUS WIDTH BOX BOUND_BOX CIRCLE LINE LSEG PATH POLYGON ABBREV BROADCAST HOST HOSTMASK MASKLEN NETMASK NETWORK SET_MASKLEN TEXT INET_SAME_FAMILY INET_MERGE MACADDR8_SET7BIT ARRAY_TO_TSVECTOR GET_CURRENT_TS_CONFIG NUMNODE PLAINTO_TSQUERY PHRASETO_TSQUERY WEBSEARCH_TO_TSQUERY QUERYTREE SETWEIGHT STRIP TO_TSQUERY TO_TSVECTOR JSON_TO_TSVECTOR JSONB_TO_TSVECTOR TS_DELETE TS_FILTER TS_HEADLINE TS_RANK TS_RANK_CD TS_REWRITE TSQUERY_PHRASE TSVECTOR_TO_ARRAY TSVECTOR_UPDATE_TRIGGER TSVECTOR_UPDATE_TRIGGER_COLUMN XMLCOMMENT XMLCONCAT XMLELEMENT XMLFOREST XMLPI XMLROOT XMLEXISTS XML_IS_WELL_FORMED XML_IS_WELL_FORMED_DOCUMENT XML_IS_WELL_FORMED_CONTENT XPATH XPATH_EXISTS XMLTABLE XMLNAMESPACES TABLE_TO_XML TABLE_TO_XMLSCHEMA TABLE_TO_XML_AND_XMLSCHEMA QUERY_TO_XML QUERY_TO_XMLSCHEMA QUERY_TO_XML_AND_XMLSCHEMA CURSOR_TO_XML CURSOR_TO_XMLSCHEMA SCHEMA_TO_XML SCHEMA_TO_XMLSCHEMA SCHEMA_TO_XML_AND_XMLSCHEMA DATABASE_TO_XML DATABASE_TO_XMLSCHEMA DATABASE_TO_XML_AND_XMLSCHEMA XMLATTRIBUTES TO_JSON TO_JSONB ARRAY_TO_JSON ROW_TO_JSON JSON_BUILD_ARRAY JSONB_BUILD_ARRAY JSON_BUILD_OBJECT JSONB_BUILD_OBJECT JSON_OBJECT JSONB_OBJECT JSON_ARRAY_LENGTH JSONB_ARRAY_LENGTH JSON_EACH JSONB_EACH JSON_EACH_TEXT JSONB_EACH_TEXT JSON_EXTRACT_PATH JSONB_EXTRACT_PATH JSON_OBJECT_KEYS JSONB_OBJECT_KEYS JSON_POPULATE_RECORD JSONB_POPULATE_RECORD JSON_POPULATE_RECORDSET JSONB_POPULATE_RECORDSET JSON_ARRAY_ELEMENTS JSONB_ARRAY_ELEMENTS JSON_ARRAY_ELEMENTS_TEXT JSONB_ARRAY_ELEMENTS_TEXT JSON_TYPEOF JSONB_TYPEOF JSON_TO_RECORD JSONB_TO_RECORD JSON_TO_RECORDSET JSONB_TO_RECORDSET JSON_STRIP_NULLS JSONB_STRIP_NULLS JSONB_SET JSONB_INSERT JSONB_PRETTY CURRVAL LASTVAL NEXTVAL SETVAL COALESCE NULLIF GREATEST LEAST ARRAY_APPEND ARRAY_CAT ARRAY_NDIMS ARRAY_DIMS ARRAY_FILL ARRAY_LENGTH ARRAY_LOWER ARRAY_POSITION ARRAY_POSITIONS ARRAY_PREPEND ARRAY_REMOVE ARRAY_REPLACE ARRAY_TO_STRING ARRAY_UPPER CARDINALITY STRING_TO_ARRAY UNNEST ISEMPTY LOWER_INC UPPER_INC LOWER_INF UPPER_INF RANGE_MERGE GENERATE_SERIES GENERATE_SUBSCRIPTS CURRENT_DATABASE CURRENT_QUERY CURRENT_SCHEMA|10 CURRENT_SCHEMAS|10 INET_CLIENT_ADDR INET_CLIENT_PORT INET_SERVER_ADDR INET_SERVER_PORT ROW_SECURITY_ACTIVE FORMAT_TYPE TO_REGCLASS TO_REGPROC TO_REGPROCEDURE TO_REGOPER TO_REGOPERATOR TO_REGTYPE TO_REGNAMESPACE TO_REGROLE COL_DESCRIPTION OBJ_DESCRIPTION SHOBJ_DESCRIPTION TXID_CURRENT TXID_CURRENT_IF_ASSIGNED TXID_CURRENT_SNAPSHOT TXID_SNAPSHOT_XIP TXID_SNAPSHOT_XMAX TXID_SNAPSHOT_XMIN TXID_VISIBLE_IN_SNAPSHOT TXID_STATUS CURRENT_SETTING SET_CONFIG BRIN_SUMMARIZE_NEW_VALUES BRIN_SUMMARIZE_RANGE BRIN_DESUMMARIZE_RANGE GIN_CLEAN_PENDING_LIST SUPPRESS_REDUNDANT_UPDATES_TRIGGER LO_FROM_BYTEA LO_PUT LO_GET LO_CREAT LO_CREATE LO_UNLINK LO_IMPORT LO_EXPORT LOREAD LOWRITE GROUPING CAST ".trim().split(" ").map(function(_){return _.split("|")[0]}).join("|");return{name:"PostgreSQL",aliases:["postgres","postgresql"],supersetOf:"sql",case_insensitive:!0,keywords:{keyword:s+l+o,built_in:h+f+p},illegal:/:==|\W\s*\(\*|(^|\s)\$[a-z]|\{\{|[a-z]:\s*$|\.\.\.|TO:|DO:/,contains:[{className:"keyword",variants:[{begin:/\bTEXT\s*SEARCH\b/},{begin:/\b(PRIMARY|FOREIGN|FOR(\s+NO)?)\s+KEY\b/},{begin:/\bPARALLEL\s+(UNSAFE|RESTRICTED|SAFE)\b/},{begin:/\bSTORAGE\s+(PLAIN|EXTERNAL|EXTENDED|MAIN)\b/},{begin:/\bMATCH\s+(FULL|PARTIAL|SIMPLE)\b/},{begin:/\bNULLS\s+(FIRST|LAST)\b/},{begin:/\bEVENT\s+TRIGGER\b/},{begin:/\b(MAPPING|OR)\s+REPLACE\b/},{begin:/\b(FROM|TO)\s+(PROGRAM|STDIN|STDOUT)\b/},{begin:/\b(SHARE|EXCLUSIVE)\s+MODE\b/},{begin:/\b(LEFT|RIGHT)\s+(OUTER\s+)?JOIN\b/},{begin:/\b(FETCH|MOVE)\s+(NEXT|PRIOR|FIRST|LAST|ABSOLUTE|RELATIVE|FORWARD|BACKWARD)\b/},{begin:/\bPRESERVE\s+ROWS\b/},{begin:/\bDISCARD\s+PLANS\b/},{begin:/\bREFERENCING\s+(OLD|NEW)\b/},{begin:/\bSKIP\s+LOCKED\b/},{begin:/\bGROUPING\s+SETS\b/},{begin:/\b(BINARY|INSENSITIVE|SCROLL|NO\s+SCROLL)\s+(CURSOR|FOR)\b/},{begin:/\b(WITH|WITHOUT)\s+HOLD\b/},{begin:/\bWITH\s+(CASCADED|LOCAL)\s+CHECK\s+OPTION\b/},{begin:/\bEXCLUDE\s+(TIES|NO\s+OTHERS)\b/},{begin:/\bFORMAT\s+(TEXT|XML|JSON|YAML)\b/},{begin:/\bSET\s+((SESSION|LOCAL)\s+)?NAMES\b/},{begin:/\bIS\s+(NOT\s+)?UNKNOWN\b/},{begin:/\bSECURITY\s+LABEL\b/},{begin:/\bSTANDALONE\s+(YES|NO|NO\s+VALUE)\b/},{begin:/\bWITH\s+(NO\s+)?DATA\b/},{begin:/\b(FOREIGN|SET)\s+DATA\b/},{begin:/\bSET\s+(CATALOG|CONSTRAINTS)\b/},{begin:/\b(WITH|FOR)\s+ORDINALITY\b/},{begin:/\bIS\s+(NOT\s+)?DOCUMENT\b/},{begin:/\bXML\s+OPTION\s+(DOCUMENT|CONTENT)\b/},{begin:/\b(STRIP|PRESERVE)\s+WHITESPACE\b/},{begin:/\bNO\s+(ACTION|MAXVALUE|MINVALUE)\b/},{begin:/\bPARTITION\s+BY\s+(RANGE|LIST|HASH)\b/},{begin:/\bAT\s+TIME\s+ZONE\b/},{begin:/\bGRANTED\s+BY\b/},{begin:/\bRETURN\s+(QUERY|NEXT)\b/},{begin:/\b(ATTACH|DETACH)\s+PARTITION\b/},{begin:/\bFORCE\s+ROW\s+LEVEL\s+SECURITY\b/},{begin:/\b(INCLUDING|EXCLUDING)\s+(COMMENTS|CONSTRAINTS|DEFAULTS|IDENTITY|INDEXES|STATISTICS|STORAGE|ALL)\b/},{begin:/\bAS\s+(ASSIGNMENT|IMPLICIT|PERMISSIVE|RESTRICTIVE|ENUM|RANGE)\b/}]},{begin:/\b(FORMAT|FAMILY|VERSION)\s*\(/},{begin:/\bINCLUDE\s*\(/,keywords:"INCLUDE"},{begin:/\bRANGE(?!\s*(BETWEEN|UNBOUNDED|CURRENT|[-0-9]+))/},{begin:/\b(VERSION|OWNER|TEMPLATE|TABLESPACE|CONNECTION\s+LIMIT|PROCEDURE|RESTRICT|JOIN|PARSER|COPY|START|END|COLLATION|INPUT|ANALYZE|STORAGE|LIKE|DEFAULT|DELIMITER|ENCODING|COLUMN|CONSTRAINT|TABLE|SCHEMA)\s*=/},{begin:/\b(PG_\w+?|HAS_[A-Z_]+_PRIVILEGE)\b/,relevance:10},{begin:/\bEXTRACT\s*\(/,end:/\bFROM\b/,returnEnd:!0,keywords:{type:"CENTURY DAY DECADE DOW DOY EPOCH HOUR ISODOW ISOYEAR MICROSECONDS MILLENNIUM MILLISECONDS MINUTE MONTH QUARTER SECOND TIMEZONE TIMEZONE_HOUR TIMEZONE_MINUTE WEEK YEAR"}},{begin:/\b(XMLELEMENT|XMLPI)\s*\(\s*NAME/,keywords:{keyword:"NAME"}},{begin:/\b(XMLPARSE|XMLSERIALIZE)\s*\(\s*(DOCUMENT|CONTENT)/,keywords:{keyword:"DOCUMENT CONTENT"}},{beginKeywords:"CACHE INCREMENT MAXVALUE MINVALUE",end:e.C_NUMBER_RE,returnEnd:!0,keywords:"BY CACHE INCREMENT MAXVALUE MINVALUE"},{className:"type",begin:/\b(WITH|WITHOUT)\s+TIME\s+ZONE\b/},{className:"type",begin:/\bINTERVAL\s+(YEAR|MONTH|DAY|HOUR|MINUTE|SECOND)(\s+TO\s+(MONTH|HOUR|MINUTE|SECOND))?\b/},{begin:/\bRETURNS\s+(LANGUAGE_HANDLER|TRIGGER|EVENT_TRIGGER|FDW_HANDLER|INDEX_AM_HANDLER|TSM_HANDLER)\b/,keywords:{keyword:"RETURNS",type:"LANGUAGE_HANDLER TRIGGER EVENT_TRIGGER FDW_HANDLER INDEX_AM_HANDLER TSM_HANDLER"}},{begin:"\\b("+m+")\\s*\\("},{begin:"\\.("+d+")\\b"},{begin:"\\b("+d+")\\s+PATH\\b",keywords:{keyword:"PATH",type:u.replace("PATH ","")}},{className:"type",begin:"\\b("+d+")\\b"},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{className:"string",begin:"(e|E|u&|U&)'",end:"'",contains:[{begin:"\\\\."}],relevance:10},e.END_SAME_AS_BEGIN({begin:i,end:i,contains:[{subLanguage:["pgsql","perl","python","tcl","r","lua","java","php","ruby","bash","scheme","xml","json"],endsWithParent:!0}]}),{begin:'"',end:'"',contains:[{begin:'""'}]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,r,{className:"meta",variants:[{begin:"%(ROW)?TYPE",relevance:10},{begin:"\\$\\d+"},{begin:"^#\\w",end:"$"}]},{className:"symbol",begin:a,relevance:10}]}}return KY=t,KY}var jY,nbe;function hxt(){if(nbe)return jY;nbe=1;function t(e){const r=e.regex,n=/(?![A-Za-z0-9])(?![$])/,i=r.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,n),a=r.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,n),s=r.concat(/[A-Z]+/,n),o={scope:"variable",match:"\\$+"+i},l={scope:"meta",variants:[{begin:/<\?php/,relevance:10},{begin:/<\?=/},{begin:/<\?/,relevance:.1},{begin:/\?>/}]},u={scope:"subst",variants:[{begin:/\$\w+/},{begin:/\{\$/,end:/\}/}]},d=e.inherit(e.APOS_STRING_MODE,{illegal:null}),h=e.inherit(e.QUOTE_STRING_MODE,{illegal:null,contains:e.QUOTE_STRING_MODE.contains.concat(u)}),f={begin:/<<<[ \t]*(?:(\w+)|"(\w+)")\n/,end:/[ \t]*(\w+)\b/,contains:e.QUOTE_STRING_MODE.contains.concat(u),"on:begin":(k,M)=>{M.data._beginMatch=k[1]||k[2]},"on:end":(k,M)=>{M.data._beginMatch!==k[1]&&M.ignoreMatch()}},p=e.END_SAME_AS_BEGIN({begin:/<<<[ \t]*'(\w+)'\n/,end:/[ \t]*(\w+)\b/}),g=`[ +]`,m={scope:"string",variants:[h,d,f,p]},_={scope:"number",variants:[{begin:"\\b0[bB][01]+(?:_[01]+)*\\b"},{begin:"\\b0[oO][0-7]+(?:_[0-7]+)*\\b"},{begin:"\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b"},{begin:"(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?"}],relevance:0},v=["false","null","true"],b=["__CLASS__","__DIR__","__FILE__","__FUNCTION__","__COMPILER_HALT_OFFSET__","__LINE__","__METHOD__","__NAMESPACE__","__TRAIT__","die","echo","exit","include","include_once","print","require","require_once","array","abstract","and","as","binary","bool","boolean","break","callable","case","catch","class","clone","const","continue","declare","default","do","double","else","elseif","empty","enddeclare","endfor","endforeach","endif","endswitch","endwhile","enum","eval","extends","final","finally","float","for","foreach","from","global","goto","if","implements","instanceof","insteadof","int","integer","interface","isset","iterable","list","match|0","mixed","new","never","object","or","private","protected","public","readonly","real","return","string","switch","throw","trait","try","unset","use","var","void","while","xor","yield"],y=["Error|0","AppendIterator","ArgumentCountError","ArithmeticError","ArrayIterator","ArrayObject","AssertionError","BadFunctionCallException","BadMethodCallException","CachingIterator","CallbackFilterIterator","CompileError","Countable","DirectoryIterator","DivisionByZeroError","DomainException","EmptyIterator","ErrorException","Exception","FilesystemIterator","FilterIterator","GlobIterator","InfiniteIterator","InvalidArgumentException","IteratorIterator","LengthException","LimitIterator","LogicException","MultipleIterator","NoRewindIterator","OutOfBoundsException","OutOfRangeException","OuterIterator","OverflowException","ParentIterator","ParseError","RangeException","RecursiveArrayIterator","RecursiveCachingIterator","RecursiveCallbackFilterIterator","RecursiveDirectoryIterator","RecursiveFilterIterator","RecursiveIterator","RecursiveIteratorIterator","RecursiveRegexIterator","RecursiveTreeIterator","RegexIterator","RuntimeException","SeekableIterator","SplDoublyLinkedList","SplFileInfo","SplFileObject","SplFixedArray","SplHeap","SplMaxHeap","SplMinHeap","SplObjectStorage","SplObserver","SplPriorityQueue","SplQueue","SplStack","SplSubject","SplTempFileObject","TypeError","UnderflowException","UnexpectedValueException","UnhandledMatchError","ArrayAccess","BackedEnum","Closure","Fiber","Generator","Iterator","IteratorAggregate","Serializable","Stringable","Throwable","Traversable","UnitEnum","WeakReference","WeakMap","Directory","__PHP_Incomplete_Class","parent","php_user_filter","self","static","stdClass"],T={keyword:b,literal:(k=>{const M=[];return k.forEach(L=>{M.push(L),L.toLowerCase()===L?M.push(L.toUpperCase()):M.push(L.toLowerCase())}),M})(v),built_in:y},C=k=>k.map(M=>M.replace(/\|\d+$/,"")),w={variants:[{match:[/new/,r.concat(g,"+"),r.concat("(?!",C(y).join("\\b|"),"\\b)"),a],scope:{1:"keyword",4:"title.class"}}]},x=r.concat(i,"\\b(?!\\()"),A={variants:[{match:[r.concat(/::/,r.lookahead(/(?!class\b)/)),x],scope:{2:"variable.constant"}},{match:[/::/,/class/],scope:{2:"variable.language"}},{match:[a,r.concat(/::/,r.lookahead(/(?!class\b)/)),x],scope:{1:"title.class",3:"variable.constant"}},{match:[a,r.concat("::",r.lookahead(/(?!class\b)/))],scope:{1:"title.class"}},{match:[a,/::/,/class/],scope:{1:"title.class",3:"variable.language"}}]},R={scope:"attr",match:r.concat(i,r.lookahead(":"),r.lookahead(/(?!::)/))},O={relevance:0,begin:/\(/,end:/\)/,keywords:T,contains:[R,o,A,e.C_BLOCK_COMMENT_MODE,m,_,w]},F={relevance:0,match:[/\b/,r.concat("(?!fn\\b|function\\b|",C(b).join("\\b|"),"|",C(y).join("\\b|"),"\\b)"),i,r.concat(g,"*"),r.lookahead(/(?=\()/)],scope:{3:"title.function.invoke"},contains:[O]};O.contains.push(F);const P=[R,A,e.C_BLOCK_COMMENT_MODE,m,_,w],N={begin:r.concat(/#\[\s*\\?/,r.either(a,s)),beginScope:"meta",end:/]/,endScope:"meta",keywords:{literal:v,keyword:["new","array"]},contains:[{begin:/\[/,end:/]/,keywords:{literal:v,keyword:["new","array"]},contains:["self",...P]},...P,{scope:"meta",variants:[{match:a},{match:s}]}]};return{case_insensitive:!1,keywords:T,contains:[N,e.HASH_COMMENT_MODE,e.COMMENT("//","$"),e.COMMENT("/\\*","\\*/",{contains:[{scope:"doctag",match:"@[A-Za-z]+"}]}),{match:/__halt_compiler\(\);/,keywords:"__halt_compiler",starts:{scope:"comment",end:e.MATCH_NOTHING_RE,contains:[{match:/\?>/,scope:"meta",endsParent:!0}]}},l,{scope:"variable.language",match:/\$this\b/},o,F,A,{match:[/const/,/\s/,i],scope:{1:"keyword",3:"variable.constant"}},w,{scope:"function",relevance:0,beginKeywords:"fn function",end:/[;{]/,excludeEnd:!0,illegal:"[$%\\[]",contains:[{beginKeywords:"use"},e.UNDERSCORE_TITLE_MODE,{begin:"=>",endsParent:!0},{scope:"params",begin:"\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0,keywords:T,contains:["self",N,o,A,e.C_BLOCK_COMMENT_MODE,m,_]}]},{scope:"class",variants:[{beginKeywords:"enum",illegal:/[($"]/},{beginKeywords:"class interface trait",illegal:/[:($"]/}],relevance:0,end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},{beginKeywords:"namespace",relevance:0,end:";",illegal:/[.']/,contains:[e.inherit(e.UNDERSCORE_TITLE_MODE,{scope:"title.class"})]},{beginKeywords:"use",relevance:0,end:";",contains:[{match:/\b(as|const|function)\b/,scope:"keyword"},e.UNDERSCORE_TITLE_MODE]},m,_]}}return jY=t,jY}var XY,ibe;function fxt(){if(ibe)return XY;ibe=1;function t(e){return{name:"PHP template",subLanguage:"xml",contains:[{begin:/<\?(php|=)?/,end:/\?>/,subLanguage:"php",contains:[{begin:"/\\*",end:"\\*/",skip:!0},{begin:'b"',end:'"',skip:!0},{begin:"b'",end:"'",skip:!0},e.inherit(e.APOS_STRING_MODE,{illegal:null,className:null,contains:null,skip:!0}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null,className:null,contains:null,skip:!0})]}]}}return XY=t,XY}var QY,abe;function pxt(){if(abe)return QY;abe=1;function t(e){return{name:"Plain text",aliases:["text","txt"],disableAutodetect:!0}}return QY=t,QY}var ZY,sbe;function gxt(){if(sbe)return ZY;sbe=1;function t(e){const r={keyword:"actor addressof and as be break class compile_error compile_intrinsic consume continue delegate digestof do else elseif embed end error for fun if ifdef in interface is isnt lambda let match new not object or primitive recover repeat return struct then trait try type until use var where while with xor",meta:"iso val tag trn box ref",literal:"this false true"},n={className:"string",begin:'"""',end:'"""',relevance:10},i={className:"string",begin:'"',end:'"',contains:[e.BACKSLASH_ESCAPE]},a={className:"string",begin:"'",end:"'",contains:[e.BACKSLASH_ESCAPE],relevance:0},s={className:"type",begin:"\\b_?[A-Z][\\w]*",relevance:0},o={begin:e.IDENT_RE+"'",relevance:0};return{name:"Pony",keywords:r,contains:[s,n,i,a,o,{className:"number",begin:"(-?)(\\b0[xX][a-fA-F0-9]+|\\b0[bB][01]+|(\\b\\d+(_\\d+)?(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",relevance:0},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]}}return ZY=t,ZY}var JY,obe;function mxt(){if(obe)return JY;obe=1;function t(e){const r=["string","char","byte","int","long","bool","decimal","single","double","DateTime","xml","array","hashtable","void"],n="Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|Unprotect|Use|ForEach|Sort|Tee|Where",i="-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|-split|-wildcard|-xor",a={$pattern:/-?[A-z\.\-]+\b/,keyword:"if else foreach return do while until elseif begin for trap data dynamicparam end break throw param continue finally in switch exit filter try process catch hidden static parameter",built_in:"ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write"},s=/\w[\w\d]*((-)[\w\d]+)*/,o={begin:"`[\\s\\S]",relevance:0},l={className:"variable",variants:[{begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]},u={className:"literal",begin:/\$(null|true|false)\b/},d={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],contains:[o,l,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},h={className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]},f={className:"doctag",variants:[{begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/},{begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/}]},p=e.inherit(e.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,end:/#>/}],contains:[f]}),g={className:"built_in",variants:[{begin:"(".concat(n,")+(-)[\\w\\d]+")}]},m={className:"class",beginKeywords:"class enum",end:/\s*[{]/,excludeEnd:!0,relevance:0,contains:[e.TITLE_MODE]},_={className:"function",begin:/function\s+/,end:/\s*\{|$/,excludeEnd:!0,returnBegin:!0,relevance:0,contains:[{begin:"function",relevance:0,className:"keyword"},{className:"title",begin:s,relevance:0},{begin:/\(/,end:/\)/,className:"params",relevance:0,contains:[l]}]},v={begin:/using\s/,end:/$/,returnBegin:!0,contains:[d,h,{className:"keyword",begin:/(using|assembly|command|module|namespace|type)/}]},b={variants:[{className:"operator",begin:"(".concat(i,")\\b")},{className:"literal",begin:/(-){1,2}[\w\d-]+/,relevance:0}]},y={className:"selector-tag",begin:/@\B/,relevance:0},E={className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,relevance:0,contains:[{className:"keyword",begin:"(".concat(a.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,relevance:0},e.inherit(e.TITLE_MODE,{endsParent:!0})]},T=[E,p,o,e.NUMBER_MODE,d,h,g,l,u,y],C={begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",T,{begin:"("+r.join("|")+")",className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,relevance:0})};return E.contains.unshift(C),{name:"PowerShell",aliases:["pwsh","ps","ps1"],case_insensitive:!0,keywords:a,contains:T.concat(m,_,v,b,C)}}return JY=t,JY}var eW,lbe;function _xt(){if(lbe)return eW;lbe=1;function t(e){const r=e.regex,n=["displayHeight","displayWidth","mouseY","mouseX","mousePressed","pmouseX","pmouseY","key","keyCode","pixels","focused","frameCount","frameRate","height","width","size","createGraphics","beginDraw","createShape","loadShape","PShape","arc","ellipse","line","point","quad","rect","triangle","bezier","bezierDetail","bezierPoint","bezierTangent","curve","curveDetail","curvePoint","curveTangent","curveTightness","shape","shapeMode","beginContour","beginShape","bezierVertex","curveVertex","endContour","endShape","quadraticVertex","vertex","ellipseMode","noSmooth","rectMode","smooth","strokeCap","strokeJoin","strokeWeight","mouseClicked","mouseDragged","mouseMoved","mousePressed","mouseReleased","mouseWheel","keyPressed","keyPressedkeyReleased","keyTyped","print","println","save","saveFrame","day","hour","millis","minute","month","second","year","background","clear","colorMode","fill","noFill","noStroke","stroke","alpha","blue","brightness","color","green","hue","lerpColor","red","saturation","modelX","modelY","modelZ","screenX","screenY","screenZ","ambient","emissive","shininess","specular","add","createImage","beginCamera","camera","endCamera","frustum","ortho","perspective","printCamera","printProjection","cursor","frameRate","noCursor","exit","loop","noLoop","popStyle","pushStyle","redraw","binary","boolean","byte","char","float","hex","int","str","unbinary","unhex","join","match","matchAll","nf","nfc","nfp","nfs","split","splitTokens","trim","append","arrayCopy","concat","expand","reverse","shorten","sort","splice","subset","box","sphere","sphereDetail","createInput","createReader","loadBytes","loadJSONArray","loadJSONObject","loadStrings","loadTable","loadXML","open","parseXML","saveTable","selectFolder","selectInput","beginRaw","beginRecord","createOutput","createWriter","endRaw","endRecord","PrintWritersaveBytes","saveJSONArray","saveJSONObject","saveStream","saveStrings","saveXML","selectOutput","popMatrix","printMatrix","pushMatrix","resetMatrix","rotate","rotateX","rotateY","rotateZ","scale","shearX","shearY","translate","ambientLight","directionalLight","lightFalloff","lights","lightSpecular","noLights","normal","pointLight","spotLight","image","imageMode","loadImage","noTint","requestImage","tint","texture","textureMode","textureWrap","blend","copy","filter","get","loadPixels","set","updatePixels","blendMode","loadShader","PShaderresetShader","shader","createFont","loadFont","text","textFont","textAlign","textLeading","textMode","textSize","textWidth","textAscent","textDescent","abs","ceil","constrain","dist","exp","floor","lerp","log","mag","map","max","min","norm","pow","round","sq","sqrt","acos","asin","atan","atan2","cos","degrees","radians","sin","tan","noise","noiseDetail","noiseSeed","random","randomGaussian","randomSeed"],i=e.IDENT_RE,a={variants:[{match:r.concat(r.either(...n),r.lookahead(/\s*\(/)),className:"built_in"},{relevance:0,match:r.concat(/\b(?!for|if|while)/,i,r.lookahead(/\s*\(/)),className:"title.function"}]},s={match:[/new\s+/,i],className:{1:"keyword",2:"class.title"}},o={relevance:0,match:[/\./,i],className:{2:"property"}},l={variants:[{match:[/class/,/\s+/,i,/\s+/,/extends/,/\s+/,i]},{match:[/class/,/\s+/,i]}],className:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},u=["boolean","byte","char","color","double","float","int","long","short"],d=["BufferedReader","PVector","PFont","PImage","PGraphics","HashMap","String","Array","FloatDict","ArrayList","FloatList","IntDict","IntList","JSONArray","JSONObject","Object","StringDict","StringList","Table","TableRow","XML"];return{name:"Processing",aliases:["pde"],keywords:{keyword:[...["abstract","assert","break","case","catch","const","continue","default","else","enum","final","finally","for","if","import","instanceof","long","native","new","package","private","private","protected","protected","public","public","return","static","strictfp","switch","synchronized","throw","throws","transient","try","void","volatile","while"]],literal:"P2D P3D HALF_PI PI QUARTER_PI TAU TWO_PI null true false",title:"setup draw",variable:"super this",built_in:[...n,...d],type:u},contains:[l,s,a,o,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE]}}return eW=t,eW}var tW,cbe;function vxt(){if(cbe)return tW;cbe=1;function t(e){return{name:"Python profiler",contains:[e.C_NUMBER_MODE,{begin:"[a-zA-Z_][\\da-zA-Z_]+\\.[\\da-zA-Z_]{1,3}",end:":",excludeEnd:!0},{begin:"(ncalls|tottime|cumtime)",end:"$",keywords:"ncalls tottime|10 cumtime|10 filename",relevance:10},{begin:"function calls",end:"$",contains:[e.C_NUMBER_MODE],relevance:10},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:"\\(",end:"\\)$",excludeBegin:!0,excludeEnd:!0,relevance:0}]}}return tW=t,tW}var rW,ube;function yxt(){if(ube)return rW;ube=1;function t(e){const r={begin:/[a-z][A-Za-z0-9_]*/,relevance:0},n={className:"symbol",variants:[{begin:/[A-Z][a-zA-Z0-9_]*/},{begin:/_[A-Za-z0-9_]*/}],relevance:0},i={begin:/\(/,end:/\)/,relevance:0},a={begin:/\[/,end:/\]/},s={className:"comment",begin:/%/,end:/$/,contains:[e.PHRASAL_WORDS_MODE]},o={className:"string",begin:/`/,end:/`/,contains:[e.BACKSLASH_ESCAPE]},l={className:"string",begin:/0'(\\'|.)/},u={className:"string",begin:/0'\\s/},h=[r,n,i,{begin:/:-/},a,s,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,o,l,u,e.C_NUMBER_MODE];return i.contains=h,a.contains=h,{name:"Prolog",contains:h.concat([{begin:/\.$/}])}}return rW=t,rW}var nW,dbe;function bxt(){if(dbe)return nW;dbe=1;function t(e){const r="[ \\t\\f]*",n="[ \\t\\f]+",i=r+"[:=]"+r,a=n,s="("+i+"|"+a+")",o="([^\\\\:= \\t\\f\\n]|\\\\.)+",l={end:s,relevance:0,starts:{className:"string",end:/$/,relevance:0,contains:[{begin:"\\\\\\\\"},{begin:"\\\\\\n"}]}};return{name:".properties",disableAutodetect:!0,case_insensitive:!0,illegal:/\S/,contains:[e.COMMENT("^\\s*[!#]","$"),{returnBegin:!0,variants:[{begin:o+i},{begin:o+a}],contains:[{className:"attr",begin:o,endsParent:!0}],starts:l},{className:"attr",begin:o+r+"$"}]}}return nW=t,nW}var iW,hbe;function Sxt(){if(hbe)return iW;hbe=1;function t(e){const r=["package","import","option","optional","required","repeated","group","oneof"],n=["double","float","int32","int64","uint32","uint64","sint32","sint64","fixed32","fixed64","sfixed32","sfixed64","bool","string","bytes"],i={match:[/(message|enum|service)\s+/,e.IDENT_RE],scope:{1:"keyword",2:"title.class"}};return{name:"Protocol Buffers",aliases:["proto"],keywords:{keyword:r,type:n,literal:["true","false"]},contains:[e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,i,{className:"function",beginKeywords:"rpc",end:/[{;]/,excludeEnd:!0,keywords:"rpc returns"},{begin:/^\s*[A-Z_]+(?=\s*=[^\n]+;$)/}]}}return iW=t,iW}var aW,fbe;function Ext(){if(fbe)return aW;fbe=1;function t(e){const r={keyword:"and case default else elsif false if in import enherits node or true undef unless main settings $string ",literal:"alias audit before loglevel noop require subscribe tag owner ensure group mode name|0 changes context force incl lens load_path onlyif provider returns root show_diff type_check en_address ip_address realname command environment hour monute month monthday special target weekday creates cwd ogoutput refresh refreshonly tries try_sleep umask backup checksum content ctime force ignore links mtime purge recurse recurselimit replace selinux_ignore_defaults selrange selrole seltype seluser source souirce_permissions sourceselect validate_cmd validate_replacement allowdupe attribute_membership auth_membership forcelocal gid ia_load_module members system host_aliases ip allowed_trunk_vlans description device_url duplex encapsulation etherchannel native_vlan speed principals allow_root auth_class auth_type authenticate_user k_of_n mechanisms rule session_owner shared options device fstype enable hasrestart directory present absent link atboot blockdevice device dump pass remounts poller_tag use message withpath adminfile allow_virtual allowcdrom category configfiles flavor install_options instance package_settings platform responsefile status uninstall_options vendor unless_system_user unless_uid binary control flags hasstatus manifest pattern restart running start stop allowdupe auths expiry gid groups home iterations key_membership keys managehome membership password password_max_age password_min_age profile_membership profiles project purge_ssh_keys role_membership roles salt shell uid baseurl cost descr enabled enablegroups exclude failovermethod gpgcheck gpgkey http_caching include includepkgs keepalive metadata_expire metalink mirrorlist priority protect proxy proxy_password proxy_username repo_gpgcheck s3_enabled skip_if_unavailable sslcacert sslclientcert sslclientkey sslverify mounted",built_in:"architecture augeasversion blockdevices boardmanufacturer boardproductname boardserialnumber cfkey dhcp_servers domain ec2_ ec2_userdata facterversion filesystems ldom fqdn gid hardwareisa hardwaremodel hostname id|0 interfaces ipaddress ipaddress_ ipaddress6 ipaddress6_ iphostnumber is_virtual kernel kernelmajversion kernelrelease kernelversion kernelrelease kernelversion lsbdistcodename lsbdistdescription lsbdistid lsbdistrelease lsbmajdistrelease lsbminordistrelease lsbrelease macaddress macaddress_ macosx_buildversion macosx_productname macosx_productversion macosx_productverson_major macosx_productversion_minor manufacturer memoryfree memorysize netmask metmask_ network_ operatingsystem operatingsystemmajrelease operatingsystemrelease osfamily partitions path physicalprocessorcount processor processorcount productname ps puppetversion rubysitedir rubyversion selinux selinux_config_mode selinux_config_policy selinux_current_mode selinux_current_mode selinux_enforced selinux_policyversion serialnumber sp_ sshdsakey sshecdsakey sshrsakey swapencrypted swapfree swapsize timezone type uniqueid uptime uptime_days uptime_hours uptime_seconds uuid virtual vlans xendomains zfs_version zonenae zones zpool_version"},n=e.COMMENT("#","$"),i="([A-Za-z_]|::)(\\w|::)*",a=e.inherit(e.TITLE_MODE,{begin:i}),s={className:"variable",begin:"\\$"+i},o={className:"string",contains:[e.BACKSLASH_ESCAPE,s],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]};return{name:"Puppet",aliases:["pp"],contains:[n,s,o,{beginKeywords:"class",end:"\\{|;",illegal:/=/,contains:[a,n]},{beginKeywords:"define",end:/\{/,contains:[{className:"section",begin:e.IDENT_RE,endsParent:!0}]},{begin:e.IDENT_RE+"\\s+\\{",returnBegin:!0,end:/\S/,contains:[{className:"keyword",begin:e.IDENT_RE,relevance:.2},{begin:/\{/,end:/\}/,keywords:r,relevance:0,contains:[o,n,{begin:"[a-zA-Z_]+\\s*=>",returnBegin:!0,end:"=>",contains:[{className:"attr",begin:e.IDENT_RE}]},{className:"number",begin:"(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",relevance:0},s]}],relevance:0}]}}return aW=t,aW}var sW,pbe;function Txt(){if(pbe)return sW;pbe=1;function t(e){const r={className:"string",begin:'(~)?"',end:'"',illegal:"\\n"},n={className:"symbol",begin:"#[a-zA-Z_]\\w*\\$?"};return{name:"PureBASIC",aliases:["pb","pbi"],keywords:"Align And Array As Break CallDebugger Case CompilerCase CompilerDefault CompilerElse CompilerElseIf CompilerEndIf CompilerEndSelect CompilerError CompilerIf CompilerSelect CompilerWarning Continue Data DataSection Debug DebugLevel Declare DeclareC DeclareCDLL DeclareDLL DeclareModule Default Define Dim DisableASM DisableDebugger DisableExplicit Else ElseIf EnableASM EnableDebugger EnableExplicit End EndDataSection EndDeclareModule EndEnumeration EndIf EndImport EndInterface EndMacro EndModule EndProcedure EndSelect EndStructure EndStructureUnion EndWith Enumeration EnumerationBinary Extends FakeReturn For ForEach ForEver Global Gosub Goto If Import ImportC IncludeBinary IncludeFile IncludePath Interface List Macro MacroExpandedCount Map Module NewList NewMap Next Not Or Procedure ProcedureC ProcedureCDLL ProcedureDLL ProcedureReturn Protected Prototype PrototypeC ReDim Read Repeat Restore Return Runtime Select Shared Static Step Structure StructureUnion Swap Threaded To UndefineMacro Until Until UnuseModule UseModule Wend While With XIncludeFile XOr",contains:[e.COMMENT(";","$",{relevance:0}),{className:"function",begin:"\\b(Procedure|Declare)(C|CDLL|DLL)?\\b",end:"\\(",excludeEnd:!0,returnBegin:!0,contains:[{className:"keyword",begin:"(Procedure|Declare)(C|CDLL|DLL)?",excludeEnd:!0},{className:"type",begin:"\\.\\w*"},e.UNDERSCORE_TITLE_MODE]},r,n]}}return sW=t,sW}var oW,gbe;function Cxt(){if(gbe)return oW;gbe=1;function t(e){const r=e.regex,n=new RegExp("[\\p{XID_Start}_]\\p{XID_Continue}*","u"),i=["and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","finally","for","from","global","if","import","in","is","lambda","match","nonlocal|10","not","or","pass","raise","return","try","while","with","yield"],l={$pattern:/[A-Za-z]\w+|__\w+__/,keyword:i,built_in:["__import__","abs","all","any","ascii","bin","bool","breakpoint","bytearray","bytes","callable","chr","classmethod","compile","complex","delattr","dict","dir","divmod","enumerate","eval","exec","filter","float","format","frozenset","getattr","globals","hasattr","hash","help","hex","id","input","int","isinstance","issubclass","iter","len","list","locals","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","range","repr","reversed","round","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","vars","zip"],literal:["__debug__","Ellipsis","False","None","NotImplemented","True"],type:["Any","Callable","Coroutine","Dict","List","Literal","Generic","Optional","Sequence","Set","Tuple","Type","Union"]},u={className:"meta",begin:/^(>>>|\.\.\.) /},d={className:"subst",begin:/\{/,end:/\}/,keywords:l,illegal:/#/},h={begin:/\{\{/,relevance:0},f={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,u],relevance:10},{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,u],relevance:10},{begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,u,h,d]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,u,h,d]},{begin:/([uU]|[rR])'/,end:/'/,relevance:10},{begin:/([uU]|[rR])"/,end:/"/,relevance:10},{begin:/([bB]|[bB][rR]|[rR][bB])'/,end:/'/},{begin:/([bB]|[bB][rR]|[rR][bB])"/,end:/"/},{begin:/([fF][rR]|[rR][fF]|[fF])'/,end:/'/,contains:[e.BACKSLASH_ESCAPE,h,d]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,h,d]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},p="[0-9](_?[0-9])*",g=`(\\b(${p}))?\\.(${p})|\\b(${p})\\.`,m=`\\b|${i.join("|")}`,_={className:"number",relevance:0,variants:[{begin:`(\\b(${p})|(${g}))[eE][+-]?(${p})[jJ]?(?=${m})`},{begin:`(${g})[jJ]?`},{begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${m})`},{begin:`\\b0[bB](_?[01])+[lL]?(?=${m})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${m})`},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${m})`},{begin:`\\b(${p})[jJ](?=${m})`}]},v={className:"comment",begin:r.lookahead(/# type:/),end:/$/,keywords:l,contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},b={className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:l,contains:["self",u,_,f,e.HASH_COMMENT_MODE]}]};return d.contains=[f,_,u],{name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:l,illegal:/(<\/|\?)|=>/,contains:[u,_,{scope:"variable.language",match:/\bself\b/},{beginKeywords:"if",relevance:0},{match:/\bor\b/,scope:"keyword"},f,v,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,n],scope:{1:"keyword",3:"title.function"},contains:[b]},{variants:[{match:[/\bclass/,/\s+/,n,/\s*/,/\(\s*/,n,/\s*\)/]},{match:[/\bclass/,/\s+/,n]}],scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[_,b,f]}]}}return oW=t,oW}var lW,mbe;function wxt(){if(mbe)return lW;mbe=1;function t(e){return{aliases:["pycon"],contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"python"}},variants:[{begin:/^>>>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return lW=t,lW}var cW,_be;function xxt(){if(_be)return cW;_be=1;function t(e){return{name:"Q",aliases:["k","kdb"],keywords:{$pattern:/(`?)[A-Za-z0-9_]+\b/,keyword:"do while select delete by update from",literal:"0b 1b",built_in:"neg not null string reciprocal floor ceiling signum mod xbar xlog and or each scan over prior mmu lsq inv md5 ltime gtime count first var dev med cov cor all any rand sums prds mins maxs fills deltas ratios avgs differ prev next rank reverse iasc idesc asc desc msum mcount mavg mdev xrank mmin mmax xprev rotate distinct group where flip type key til get value attr cut set upsert raze union inter except cross sv vs sublist enlist read0 read1 hopen hclose hdel hsym hcount peach system ltrim rtrim trim lower upper ssr view tables views cols xcols keys xkey xcol xasc xdesc fkeys meta lj aj aj0 ij pj asof uj ww wj wj1 fby xgroup ungroup ej save load rsave rload show csv parse eval min max avg wavg wsum sin cos tan sum",type:"`float `double int `timestamp `timespan `datetime `time `boolean `symbol `char `byte `short `long `real `month `date `minute `second `guid"},contains:[e.C_LINE_COMMENT_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE]}}return cW=t,cW}var uW,vbe;function Axt(){if(vbe)return uW;vbe=1;function t(e){const r=e.regex,n={keyword:"in of on if for while finally var new function do return void else break catch instanceof with throw case default try this switch continue typeof delete let yield const export super debugger as async await import",literal:"true false null undefined NaN Infinity",built_in:"eval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Error EvalError InternalError RangeError ReferenceError StopIteration SyntaxError TypeError URIError Number Math Date String RegExp Array Float32Array Float64Array Int16Array Int32Array Int8Array Uint16Array Uint32Array Uint8Array Uint8ClampedArray ArrayBuffer DataView JSON Intl arguments require module console window document Symbol Set Map WeakSet WeakMap Proxy Reflect Behavior bool color coordinate date double enumeration font geocircle georectangle geoshape int list matrix4x4 parent point quaternion real rect size string url variant vector2d vector3d vector4d Promise"},i="[a-zA-Z_][a-zA-Z0-9\\._]*",a={className:"keyword",begin:"\\bproperty\\b",starts:{className:"string",end:"(:|=|;|,|//|/\\*|$)",returnEnd:!0}},s={className:"keyword",begin:"\\bsignal\\b",starts:{className:"string",end:"(\\(|:|=|;|,|//|/\\*|$)",returnEnd:!0}},o={className:"attribute",begin:"\\bid\\s*:",starts:{className:"string",end:i,returnEnd:!1}},l={begin:i+"\\s*:",returnBegin:!0,contains:[{className:"attribute",begin:i,end:"\\s*:",excludeEnd:!0,relevance:0}],relevance:0},u={begin:r.concat(i,/\s*\{/),end:/\{/,returnBegin:!0,relevance:0,contains:[e.inherit(e.TITLE_MODE,{begin:i})]};return{name:"QML",aliases:["qt"],case_insensitive:!1,keywords:n,contains:[{className:"meta",begin:/^\s*['"]use (strict|asm)['"]/},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE,{className:"subst",begin:"\\$\\{",end:"\\}"}]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"number",variants:[{begin:"\\b(0[bB][01]+)"},{begin:"\\b(0[oO][0-7]+)"},{begin:e.C_NUMBER_RE}],relevance:0},{begin:"("+e.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.REGEXP_MODE,{begin:/\s*[);\]]/,relevance:0,subLanguage:"xml"}],relevance:0},s,a,{className:"function",beginKeywords:"function",end:/\{/,excludeEnd:!0,contains:[e.inherit(e.TITLE_MODE,{begin:/[A-Za-z$_][0-9A-Za-z$_]*/}),{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]}],illegal:/\[|%/},{begin:"\\."+e.IDENT_RE,relevance:0},o,l,u],illegal:/#/}}return uW=t,uW}var dW,ybe;function Rxt(){if(ybe)return dW;ybe=1;function t(e){const r=e.regex,n=/(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,i=r.either(/0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,/0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,/(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/),a=/[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/,s=r.either(/[()]/,/[{}]/,/\[\[/,/[[\]]/,/\\/,/,/);return{name:"R",keywords:{$pattern:n,keyword:"function if in break next repeat else for while",literal:"NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",built_in:"LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm"},contains:[e.COMMENT(/#'/,/$/,{contains:[{scope:"doctag",match:/@examples/,starts:{end:r.lookahead(r.either(/\n^#'\s*(?=@[a-zA-Z]+)/,/\n^(?!#')/)),endsParent:!0}},{scope:"doctag",begin:"@param",end:/$/,contains:[{scope:"variable",variants:[{match:n},{match:/`(?:\\.|[^`\\])+`/}],endsParent:!0}]},{scope:"doctag",match:/@[a-zA-Z]+/},{scope:"keyword",match:/\\[a-zA-Z]+/}]}),e.HASH_COMMENT_MODE,{scope:"string",contains:[e.BACKSLASH_ESCAPE],variants:[e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\(/,end:/\)(-*)"/}),e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\{/,end:/\}(-*)"/}),e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\[/,end:/\](-*)"/}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\(/,end:/\)(-*)'/}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\{/,end:/\}(-*)'/}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\[/,end:/\](-*)'/}),{begin:'"',end:'"',relevance:0},{begin:"'",end:"'",relevance:0}]},{relevance:0,variants:[{scope:{1:"operator",2:"number"},match:[a,i]},{scope:{1:"operator",2:"number"},match:[/%[^%]*%/,i]},{scope:{1:"punctuation",2:"number"},match:[s,i]},{scope:{2:"number"},match:[/[^a-zA-Z0-9._]|^/,i]}]},{scope:{3:"operator"},match:[n,/\s+/,/<-/,/\s+/]},{scope:"operator",relevance:0,variants:[{match:a},{match:/%[^%]*%/}]},{scope:"punctuation",relevance:0,match:s},{begin:"`",end:"`",contains:[{begin:/\\./}]}]}}return dW=t,dW}var hW,bbe;function Nxt(){if(bbe)return hW;bbe=1;function t(e){return{name:"ReasonML",aliases:["re"],keywords:{$pattern:/[a-z_]\w*!?/,keyword:["and","as","asr","assert","begin","class","constraint","do","done","downto","else","end","esfun","exception","external","for","fun","function","functor","if","in","include","inherit","initializer","land","lazy","let","lor","lsl","lsr","lxor","mod","module","mutable","new","nonrec","object","of","open","or","pri","pub","rec","sig","struct","switch","then","to","try","type","val","virtual","when","while","with"],built_in:["array","bool","bytes","char","exn|5","float","int","int32","int64","list","lazy_t|5","nativeint|5","ref","string","unit"],literal:["true","false"]},illegal:/(:-|:=|\$\{|\+=)/,contains:[{scope:"literal",match:/\[(\|\|)?\]|\(\)/,relevance:0},e.C_LINE_COMMENT_MODE,e.COMMENT(/\/\*/,/\*\//,{illegal:/^(#,\/\/)/}),{scope:"symbol",match:/\'[A-Za-z_](?!\')[\w\']*/},{scope:"type",match:/`[A-Z][\w\']*/},{scope:"type",match:/\b[A-Z][\w\']*/,relevance:0},{match:/[a-z_]\w*\'[\w\']*/,relevance:0},{scope:"operator",match:/\s+(\|\||\+[\+\.]?|\*[\*\/\.]?|\/[\.]?|\.\.\.|\|>|&&|===?)\s+/,relevance:0},e.inherit(e.APOS_STRING_MODE,{scope:"string",relevance:0}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{scope:"number",variants:[{match:/\b0[xX][a-fA-F0-9_]+[Lln]?/},{match:/\b0[oO][0-7_]+[Lln]?/},{match:/\b0[bB][01_]+[Lln]?/},{match:/\b[0-9][0-9_]*([Lln]|(\.[0-9_]*)?([eE][-+]?[0-9_]+)?)/}],relevance:0}]}}return hW=t,hW}var fW,Sbe;function Oxt(){if(Sbe)return fW;Sbe=1;function t(e){return{name:"RenderMan RIB",keywords:"ArchiveRecord AreaLightSource Atmosphere Attribute AttributeBegin AttributeEnd Basis Begin Blobby Bound Clipping ClippingPlane Color ColorSamples ConcatTransform Cone CoordinateSystem CoordSysTransform CropWindow Curves Cylinder DepthOfField Detail DetailRange Disk Displacement Display End ErrorHandler Exposure Exterior Format FrameAspectRatio FrameBegin FrameEnd GeneralPolygon GeometricApproximation Geometry Hider Hyperboloid Identity Illuminate Imager Interior LightSource MakeCubeFaceEnvironment MakeLatLongEnvironment MakeShadow MakeTexture Matte MotionBegin MotionEnd NuPatch ObjectBegin ObjectEnd ObjectInstance Opacity Option Orientation Paraboloid Patch PatchMesh Perspective PixelFilter PixelSamples PixelVariance Points PointsGeneralPolygons PointsPolygons Polygon Procedural Projection Quantize ReadArchive RelativeDetail ReverseOrientation Rotate Scale ScreenWindow ShadingInterpolation ShadingRate Shutter Sides Skew SolidBegin SolidEnd Sphere SubdivisionMesh Surface TextureCoordinates Torus Transform TransformBegin TransformEnd TransformPoints Translate TrimCurve WorldBegin WorldEnd",illegal:"/}],illegal:/./},e.COMMENT("^#","$"),l,u,o,{begin:/[\w-]+=([^\s{}[\]()>]+)/,relevance:0,returnBegin:!0,contains:[{className:"attribute",begin:/[^=]+/},{begin:/=/,endsWithParent:!0,relevance:0,contains:[l,u,o,{className:"literal",begin:"\\b("+a.split(" ").join("|")+")\\b"},{begin:/("[^"]*"|[^\s{}[\]]+)/}]}]},{className:"number",begin:/\*[0-9a-fA-F]+/},{begin:"\\b("+i.split(" ").join("|")+")([\\s[(\\]|])",returnBegin:!0,contains:[{className:"built_in",begin:/\w+/}]},{className:"built_in",variants:[{begin:"(\\.\\./|/|\\s)(("+s.split(" ").join("|")+");?\\s)+"},{begin:/\.\./,relevance:0}]}]}}return gW=t,gW}var mW,Cbe;function Dxt(){if(Cbe)return mW;Cbe=1;function t(e){const r=["abs","acos","ambient","area","asin","atan","atmosphere","attribute","calculatenormal","ceil","cellnoise","clamp","comp","concat","cos","degrees","depth","Deriv","diffuse","distance","Du","Dv","environment","exp","faceforward","filterstep","floor","format","fresnel","incident","length","lightsource","log","match","max","min","mod","noise","normalize","ntransform","opposite","option","phong","pnoise","pow","printf","ptlined","radians","random","reflect","refract","renderinfo","round","setcomp","setxcomp","setycomp","setzcomp","shadow","sign","sin","smoothstep","specular","specularbrdf","spline","sqrt","step","tan","texture","textureinfo","trace","transform","vtransform","xcomp","ycomp","zcomp"],n=["matrix","float","color","point","normal","vector"],i=["while","for","if","do","return","else","break","extern","continue"],a={match:[/(surface|displacement|light|volume|imager)/,/\s+/,e.IDENT_RE],scope:{1:"keyword",3:"title.class"}};return{name:"RenderMan RSL",keywords:{keyword:i,built_in:r,type:n},illegal:""},s]}}return vW=t,vW}var yW,Abe;function Pxt(){if(Abe)return yW;Abe=1;function t(e){const r=e.regex,n=["do","if","then","else","end","until","while","abort","array","attrib","by","call","cards","cards4","catname","continue","datalines","datalines4","delete","delim","delimiter","display","dm","drop","endsas","error","file","filename","footnote","format","goto","in","infile","informat","input","keep","label","leave","length","libname","link","list","lostcard","merge","missing","modify","options","output","out","page","put","redirect","remove","rename","replace","retain","return","select","set","skip","startsas","stop","title","update","waitsas","where","window","x|0","systask","add","and","alter","as","cascade","check","create","delete","describe","distinct","drop","foreign","from","group","having","index","insert","into","in","key","like","message","modify","msgtype","not","null","on","or","order","primary","references","reset","restrict","select","set","table","unique","update","validate","view","where"],i=["abs","addr","airy","arcos","arsin","atan","attrc","attrn","band","betainv","blshift","bnot","bor","brshift","bxor","byte","cdf","ceil","cexist","cinv","close","cnonct","collate","compbl","compound","compress","cos","cosh","css","curobs","cv","daccdb","daccdbsl","daccsl","daccsyd","dacctab","dairy","date","datejul","datepart","datetime","day","dclose","depdb","depdbsl","depdbsl","depsl","depsl","depsyd","depsyd","deptab","deptab","dequote","dhms","dif","digamma","dim","dinfo","dnum","dopen","doptname","doptnum","dread","dropnote","dsname","erf","erfc","exist","exp","fappend","fclose","fcol","fdelete","fetch","fetchobs","fexist","fget","fileexist","filename","fileref","finfo","finv","fipname","fipnamel","fipstate","floor","fnonct","fnote","fopen","foptname","foptnum","fpoint","fpos","fput","fread","frewind","frlen","fsep","fuzz","fwrite","gaminv","gamma","getoption","getvarc","getvarn","hbound","hms","hosthelp","hour","ibessel","index","indexc","indexw","input","inputc","inputn","int","intck","intnx","intrr","irr","jbessel","juldate","kurtosis","lag","lbound","left","length","lgamma","libname","libref","log","log10","log2","logpdf","logpmf","logsdf","lowcase","max","mdy","mean","min","minute","mod","month","mopen","mort","n","netpv","nmiss","normal","note","npv","open","ordinal","pathname","pdf","peek","peekc","pmf","point","poisson","poke","probbeta","probbnml","probchi","probf","probgam","probhypr","probit","probnegb","probnorm","probt","put","putc","putn","qtr","quote","ranbin","rancau","ranexp","rangam","range","rank","rannor","ranpoi","rantbl","rantri","ranuni","repeat","resolve","reverse","rewind","right","round","saving","scan","sdf","second","sign","sin","sinh","skewness","soundex","spedis","sqrt","std","stderr","stfips","stname","stnamel","substr","sum","symget","sysget","sysmsg","sysprod","sysrc","system","tan","tanh","time","timepart","tinv","tnonct","today","translate","tranwrd","trigamma","trim","trimn","trunc","uniform","upcase","uss","var","varfmt","varinfmt","varlabel","varlen","varname","varnum","varray","varrayx","vartype","verify","vformat","vformatd","vformatdx","vformatn","vformatnx","vformatw","vformatwx","vformatx","vinarray","vinarrayx","vinformat","vinformatd","vinformatdx","vinformatn","vinformatnx","vinformatw","vinformatwx","vinformatx","vlabel","vlabelx","vlength","vlengthx","vname","vnamex","vtype","vtypex","weekday","year","yyq","zipfips","zipname","zipnamel","zipstate"],a=["bquote","nrbquote","cmpres","qcmpres","compstor","datatyp","display","do","else","end","eval","global","goto","if","index","input","keydef","label","left","length","let","local","lowcase","macro","mend","nrbquote","nrquote","nrstr","put","qcmpres","qleft","qlowcase","qscan","qsubstr","qsysfunc","qtrim","quote","qupcase","scan","str","substr","superq","syscall","sysevalf","sysexec","sysfunc","sysget","syslput","sysprod","sysrc","sysrput","then","to","trim","unquote","until","upcase","verify","while","window"];return{name:"SAS",case_insensitive:!0,keywords:{literal:["null","missing","_all_","_automatic_","_character_","_infile_","_n_","_name_","_null_","_numeric_","_user_","_webout_"],keyword:n},contains:[{className:"keyword",begin:/^\s*(proc [\w\d_]+|data|run|quit)[\s;]/},{className:"variable",begin:/&[a-zA-Z_&][a-zA-Z0-9_]*\.?/},{begin:[/^\s*/,/datalines;|cards;/,/(?:.*\n)+/,/^\s*;\s*$/],className:{2:"keyword",3:"string"}},{begin:[/%mend|%macro/,/\s+/,/[a-zA-Z_&][a-zA-Z0-9_]*/],className:{1:"built_in",3:"title.function"}},{className:"built_in",begin:"%"+r.either(...a)},{className:"title.function",begin:/%[a-zA-Z_][a-zA-Z_0-9]*/},{className:"meta",begin:r.either(...i)+"(?=\\()"},{className:"string",variants:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},e.COMMENT("\\*",";"),e.C_BLOCK_COMMENT_MODE]}}return yW=t,yW}var bW,Rbe;function Fxt(){if(Rbe)return bW;Rbe=1;function t(e){const r=e.regex,n={className:"meta",begin:"@[A-Za-z]+"},i={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"},{begin:/\$\{/,end:/\}/}]},a={className:"string",variants:[{begin:'"""',end:'"""'},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:'[a-z]+"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,i]},{className:"string",begin:'[a-z]+"""',end:'"""',contains:[i],relevance:10}]},s={className:"type",begin:"\\b[A-Z][A-Za-z0-9_]*",relevance:0},o={className:"title",begin:/[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,relevance:0},l={className:"class",beginKeywords:"class object trait type",end:/[:={\[\n;]/,excludeEnd:!0,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{beginKeywords:"extends with",relevance:10},{begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[s,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[s,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},o]},u={className:"function",beginKeywords:"def",end:r.lookahead(/[:={\[(\n;]/),contains:[o]},d={begin:[/^\s*/,"extension",/\s+(?=[[(])/],beginScope:{2:"keyword"}},h={begin:[/^\s*/,/end/,/\s+/,/(extension\b)?/],beginScope:{2:"keyword",4:"keyword"}},f=[{match:/\.inline\b/},{begin:/\binline(?=\s)/,keywords:"inline"}],p={begin:[/\(\s*/,/using/,/\s+(?!\))/],beginScope:{2:"keyword"}};return{name:"Scala",keywords:{literal:"true false null",keyword:"type yield lazy override def with val var sealed abstract private trait object if then forSome for while do throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit export enum given transparent"},contains:[{begin:["//>",/\s+/,/using/,/\s+/,/\S+/],beginScope:{1:"comment",3:"keyword",5:"type"},end:/$/,contains:[{className:"string",begin:/\S+/}]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,a,s,u,l,e.C_NUMBER_MODE,d,h,...f,p,n]}}return bW=t,bW}var SW,Nbe;function Bxt(){if(Nbe)return SW;Nbe=1;function t(e){const r="[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",n="(-|\\+)?\\d+([./]\\d+)?",i=n+"[+\\-]"+n+"i",a={$pattern:r,built_in:"case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules ' * + , ,@ - ... / ; < <= = => > >= ` abs acos angle append apply asin assoc assq assv atan boolean? caar cadr call-with-input-file call-with-output-file call-with-values car cdddar cddddr cdr ceiling char->integer char-alphabetic? char-ci<=? char-ci=? char-ci>? char-downcase char-lower-case? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? char<=? char=? char>? char? close-input-port close-output-port complex? cons cos current-input-port current-output-port denominator display eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt floor force gcd imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lcm length list list->string list->vector list-ref list-tail list? load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number->string number? numerator odd? open-input-file open-output-file output-port? pair? peek-char port? positive? procedure? quasiquote quote quotient rational? rationalize read read-char real-part real? remainder reverse round scheme-report-environment set! set-car! set-cdr! sin sqrt string string->list string->number string->symbol string-append string-ci<=? string-ci=? string-ci>? string-copy string-fill! string-length string-ref string-set! string<=? string=? string>? string? substring symbol->string symbol? tan transcript-off transcript-on truncate values vector vector->list vector-fill! vector-length vector-ref vector-set! with-input-from-file with-output-to-file write write-char zero?"},s={className:"literal",begin:"(#t|#f|#\\\\"+r+"|#\\\\.)"},o={className:"number",variants:[{begin:n,relevance:0},{begin:i,relevance:0},{begin:"#b[0-1]+(/[0-1]+)?"},{begin:"#o[0-7]+(/[0-7]+)?"},{begin:"#x[0-9a-f]+(/[0-9a-f]+)?"}]},l=e.QUOTE_STRING_MODE,u=[e.COMMENT(";","$",{relevance:0}),e.COMMENT("#\\|","\\|#")],d={begin:r,relevance:0},h={className:"symbol",begin:"'"+r},f={endsWithParent:!0,relevance:0},p={variants:[{begin:/'/},{begin:"`"}],contains:[{begin:"\\(",end:"\\)",contains:["self",s,l,o,d,h]}]},g={className:"name",relevance:0,begin:r,keywords:a},_={variants:[{begin:"\\(",end:"\\)"},{begin:"\\[",end:"\\]"}],contains:[{begin:/lambda/,endsWithParent:!0,returnBegin:!0,contains:[g,{endsParent:!0,variants:[{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/}],contains:[d]}]},g,f]};return f.contains=[s,o,l,d,h,p,_].concat(u),{name:"Scheme",aliases:["scm"],illegal:/\S/,contains:[e.SHEBANG(),o,l,h,p,_].concat(u)}}return SW=t,SW}var EW,Obe;function Uxt(){if(Obe)return EW;Obe=1;function t(e){const r=[e.C_NUMBER_MODE,{className:"string",begin:`'|"`,end:`'|"`,contains:[e.BACKSLASH_ESCAPE,{begin:"''"}]}];return{name:"Scilab",aliases:["sci"],keywords:{$pattern:/%?\w+/,keyword:"abort break case clear catch continue do elseif else endfunction end for function global if pause return resume select try then while",literal:"%f %F %t %T %pi %eps %inf %nan %e %i %z %s",built_in:"abs and acos asin atan ceil cd chdir clearglobal cosh cos cumprod deff disp error exec execstr exists exp eye gettext floor fprintf fread fsolve imag isdef isempty isinfisnan isvector lasterror length load linspace list listfiles log10 log2 log max min msprintf mclose mopen ones or pathconvert poly printf prod pwd rand real round sinh sin size gsort sprintf sqrt strcat strcmps tring sum system tanh tan type typename warning zeros matrix"},illegal:'("|#|/\\*|\\s+/\\w+)',contains:[{className:"function",beginKeywords:"function",end:"$",contains:[e.UNDERSCORE_TITLE_MODE,{className:"params",begin:"\\(",end:"\\)"}]},{begin:"[a-zA-Z_][a-zA-Z_0-9]*[\\.']+",relevance:0},{begin:"\\[",end:"\\][\\.']*",relevance:0,contains:r},e.COMMENT("//","$")].concat(r)}}return EW=t,EW}var TW,Ibe;function $xt(){if(Ibe)return TW;Ibe=1;const t=u=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:u.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:u.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z_][A-Za-z0-9_-]*/}}),e=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","optgroup","option","p","picture","q","quote","samp","section","select","source","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],r=["defs","g","marker","mask","pattern","svg","switch","symbol","feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feFlood","feGaussianBlur","feImage","feMerge","feMorphology","feOffset","feSpecularLighting","feTile","feTurbulence","linearGradient","radialGradient","stop","circle","ellipse","image","line","path","polygon","polyline","rect","text","use","textPath","tspan","foreignObject","clipPath"],n=[...e,...r],i=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"].sort().reverse(),a=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"].sort().reverse(),s=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),o=["accent-color","align-content","align-items","align-self","alignment-baseline","all","anchor-name","animation","animation-composition","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-range","animation-range-end","animation-range-start","animation-timeline","animation-timing-function","appearance","aspect-ratio","backdrop-filter","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-position-x","background-position-y","background-repeat","background-size","baseline-shift","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-end-end-radius","border-end-start-radius","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-start-end-radius","border-start-start-radius","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-align","box-decoration-break","box-direction","box-flex","box-flex-group","box-lines","box-ordinal-group","box-orient","box-pack","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","color-scheme","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","contain-intrinsic-block-size","contain-intrinsic-height","contain-intrinsic-inline-size","contain-intrinsic-size","contain-intrinsic-width","container","container-name","container-type","content","content-visibility","counter-increment","counter-reset","counter-set","cue","cue-after","cue-before","cursor","cx","cy","direction","display","dominant-baseline","empty-cells","enable-background","field-sizing","fill","fill-opacity","fill-rule","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flood-color","flood-opacity","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-optical-sizing","font-palette","font-size","font-size-adjust","font-smooth","font-smoothing","font-stretch","font-style","font-synthesis","font-synthesis-position","font-synthesis-small-caps","font-synthesis-style","font-synthesis-weight","font-variant","font-variant-alternates","font-variant-caps","font-variant-east-asian","font-variant-emoji","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","forced-color-adjust","gap","glyph-orientation-horizontal","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphenate-character","hyphenate-limit-chars","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","initial-letter","initial-letter-align","inline-size","inset","inset-area","inset-block","inset-block-end","inset-block-start","inset-inline","inset-inline-end","inset-inline-start","isolation","justify-content","justify-items","justify-self","kerning","left","letter-spacing","lighting-color","line-break","line-height","line-height-step","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","margin-trim","marker","marker-end","marker-mid","marker-start","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","masonry-auto-flow","math-depth","math-shift","math-style","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","offset","offset-anchor","offset-distance","offset-path","offset-position","offset-rotate","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-anchor","overflow-block","overflow-clip-margin","overflow-inline","overflow-wrap","overflow-x","overflow-y","overlay","overscroll-behavior","overscroll-behavior-block","overscroll-behavior-inline","overscroll-behavior-x","overscroll-behavior-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page","page-break-after","page-break-before","page-break-inside","paint-order","pause","pause-after","pause-before","perspective","perspective-origin","place-content","place-items","place-self","pointer-events","position","position-anchor","position-visibility","print-color-adjust","quotes","r","resize","rest","rest-after","rest-before","right","rotate","row-gap","ruby-align","ruby-position","scale","scroll-behavior","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scroll-timeline","scroll-timeline-axis","scroll-timeline-name","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","shape-rendering","speak","speak-as","src","stop-color","stop-opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","tab-size","table-layout","text-align","text-align-all","text-align-last","text-anchor","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-skip","text-decoration-skip-ink","text-decoration-style","text-decoration-thickness","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-size-adjust","text-transform","text-underline-offset","text-underline-position","text-wrap","text-wrap-mode","text-wrap-style","timeline-scope","top","touch-action","transform","transform-box","transform-origin","transform-style","transition","transition-behavior","transition-delay","transition-duration","transition-property","transition-timing-function","translate","unicode-bidi","user-modify","user-select","vector-effect","vertical-align","view-timeline","view-timeline-axis","view-timeline-inset","view-timeline-name","view-transition-name","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","white-space-collapse","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","x","y","z-index","zoom"].sort().reverse();function l(u){const d=t(u),h=s,f=a,p="@[a-z-]+",g="and or not only",_={className:"variable",begin:"(\\$"+"[a-zA-Z-][a-zA-Z0-9_-]*"+")\\b",relevance:0};return{name:"SCSS",case_insensitive:!0,illegal:"[=/|']",contains:[u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,d.CSS_NUMBER_MODE,{className:"selector-id",begin:"#[A-Za-z0-9_-]+",relevance:0},{className:"selector-class",begin:"\\.[A-Za-z0-9_-]+",relevance:0},d.ATTRIBUTE_SELECTOR_MODE,{className:"selector-tag",begin:"\\b("+n.join("|")+")\\b",relevance:0},{className:"selector-pseudo",begin:":("+f.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+h.join("|")+")"},_,{begin:/\(/,end:/\)/,contains:[d.CSS_NUMBER_MODE]},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b"},{begin:"\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b"},{begin:/:/,end:/[;}{]/,relevance:0,contains:[d.BLOCK_COMMENT,_,d.HEXCOLOR,d.CSS_NUMBER_MODE,u.QUOTE_STRING_MODE,u.APOS_STRING_MODE,d.IMPORTANT,d.FUNCTION_DISPATCH]},{begin:"@(page|font-face)",keywords:{$pattern:p,keyword:"@page @font-face"}},{begin:"@",end:"[{;]",returnBegin:!0,keywords:{$pattern:/[a-z-]+/,keyword:g,attribute:i.join(" ")},contains:[{begin:p,className:"keyword"},{begin:/[a-z-]+(?=:)/,className:"attribute"},_,u.QUOTE_STRING_MODE,u.APOS_STRING_MODE,d.HEXCOLOR,d.CSS_NUMBER_MODE]},d.FUNCTION_DISPATCH]}}return TW=l,TW}var CW,kbe;function Gxt(){if(kbe)return CW;kbe=1;function t(e){return{name:"Shell Session",aliases:["console","shellsession"],contains:[{className:"meta.prompt",begin:/^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,starts:{end:/[^\\](?=\s*$)/,subLanguage:"bash"}}]}}return CW=t,CW}var wW,Dbe;function zxt(){if(Dbe)return wW;Dbe=1;function t(e){const r=["add","and","cmp","cmpg","cmpl","const","div","double","float","goto","if","int","long","move","mul","neg","new","nop","not","or","rem","return","shl","shr","sput","sub","throw","ushr","xor"],n=["aget","aput","array","check","execute","fill","filled","goto/16","goto/32","iget","instance","invoke","iput","monitor","packed","sget","sparse"],i=["transient","constructor","abstract","final","synthetic","public","private","protected","static","bridge","system"];return{name:"Smali",contains:[{className:"string",begin:'"',end:'"',relevance:0},e.COMMENT("#","$",{relevance:0}),{className:"keyword",variants:[{begin:"\\s*\\.end\\s[a-zA-Z0-9]*"},{begin:"^[ ]*\\.[a-zA-Z]*",relevance:0},{begin:"\\s:[a-zA-Z_0-9]*",relevance:0},{begin:"\\s("+i.join("|")+")"}]},{className:"built_in",variants:[{begin:"\\s("+r.join("|")+")\\s"},{begin:"\\s("+r.join("|")+")((-|/)[a-zA-Z0-9]+)+\\s",relevance:10},{begin:"\\s("+n.join("|")+")((-|/)[a-zA-Z0-9]+)*\\s",relevance:10}]},{className:"class",begin:`L[^(;: +]*;`,relevance:0},{begin:"[vp][0-9]+"}]}}return wW=t,wW}var xW,Mbe;function qxt(){if(Mbe)return xW;Mbe=1;function t(e){const r="[a-z][a-zA-Z0-9_]*",n={className:"string",begin:"\\$.{1}"},i={className:"symbol",begin:"#"+e.UNDERSCORE_IDENT_RE};return{name:"Smalltalk",aliases:["st"],keywords:["self","super","nil","true","false","thisContext"],contains:[e.COMMENT('"','"'),e.APOS_STRING_MODE,{className:"type",begin:"\\b[A-Z][A-Za-z0-9_]*",relevance:0},{begin:r+":",relevance:0},e.C_NUMBER_MODE,i,n,{begin:"\\|[ ]*"+r+"([ ]+"+r+")*[ ]*\\|",returnBegin:!0,end:/\|/,illegal:/\S/,contains:[{begin:"(\\|[ ]*)?"+r}]},{begin:"#\\(",end:"\\)",contains:[e.APOS_STRING_MODE,n,e.C_NUMBER_MODE,i]}]}}return xW=t,xW}var AW,Lbe;function Hxt(){if(Lbe)return AW;Lbe=1;function t(e){return{name:"SML (Standard ML)",aliases:["ml"],keywords:{$pattern:"[a-z_]\\w*!?",keyword:"abstype and andalso as case datatype do else end eqtype exception fn fun functor handle if in include infix infixr let local nonfix of op open orelse raise rec sharing sig signature struct structure then type val with withtype where while",built_in:"array bool char exn int list option order real ref string substring vector unit word",literal:"true false NONE SOME LESS EQUAL GREATER nil"},illegal:/\/\/|>>/,contains:[{className:"literal",begin:/\[(\|\|)?\]|\(\)/,relevance:0},e.COMMENT("\\(\\*","\\*\\)",{contains:["self"]}),{className:"symbol",begin:"'[A-Za-z_](?!')[\\w']*"},{className:"type",begin:"`[A-Z][\\w']*"},{className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},{begin:"[a-z_]\\w*'[\\w']*"},e.inherit(e.APOS_STRING_MODE,{className:"string",relevance:0}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"number",begin:"\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",relevance:0},{begin:/[-=]>/}]}}return AW=t,AW}var RW,Pbe;function Vxt(){if(Pbe)return RW;Pbe=1;function t(e){const r={className:"variable",begin:/\b_+[a-zA-Z]\w*/},n={className:"title",begin:/[a-zA-Z][a-zA-Z_0-9]*_fnc_[a-zA-Z_0-9]+/},i={className:"string",variants:[{begin:'"',end:'"',contains:[{begin:'""',relevance:0}]},{begin:"'",end:"'",contains:[{begin:"''",relevance:0}]}]},a=["break","breakWith","breakOut","breakTo","case","catch","continue","continueWith","default","do","else","exit","exitWith","for","forEach","from","if","local","private","switch","step","then","throw","to","try","waitUntil","while","with"],s=["blufor","civilian","configNull","controlNull","displayNull","diaryRecordNull","east","endl","false","grpNull","independent","lineBreak","locationNull","nil","objNull","opfor","pi","resistance","scriptNull","sideAmbientLife","sideEmpty","sideEnemy","sideFriendly","sideLogic","sideUnknown","taskNull","teamMemberNull","true","west"],o=["abs","accTime","acos","action","actionIDs","actionKeys","actionKeysEx","actionKeysImages","actionKeysNames","actionKeysNamesArray","actionName","actionParams","activateAddons","activatedAddons","activateKey","activeTitleEffectParams","add3DENConnection","add3DENEventHandler","add3DENLayer","addAction","addBackpack","addBackpackCargo","addBackpackCargoGlobal","addBackpackGlobal","addBinocularItem","addCamShake","addCuratorAddons","addCuratorCameraArea","addCuratorEditableObjects","addCuratorEditingArea","addCuratorPoints","addEditorObject","addEventHandler","addForce","addForceGeneratorRTD","addGoggles","addGroupIcon","addHandgunItem","addHeadgear","addItem","addItemCargo","addItemCargoGlobal","addItemPool","addItemToBackpack","addItemToUniform","addItemToVest","addLiveStats","addMagazine","addMagazineAmmoCargo","addMagazineCargo","addMagazineCargoGlobal","addMagazineGlobal","addMagazinePool","addMagazines","addMagazineTurret","addMenu","addMenuItem","addMissionEventHandler","addMPEventHandler","addMusicEventHandler","addonFiles","addOwnedMine","addPlayerScores","addPrimaryWeaponItem","addPublicVariableEventHandler","addRating","addResources","addScore","addScoreSide","addSecondaryWeaponItem","addSwitchableUnit","addTeamMember","addToRemainsCollector","addTorque","addUniform","addUserActionEventHandler","addVehicle","addVest","addWaypoint","addWeapon","addWeaponCargo","addWeaponCargoGlobal","addWeaponGlobal","addWeaponItem","addWeaponPool","addWeaponTurret","addWeaponWithAttachmentsCargo","addWeaponWithAttachmentsCargoGlobal","admin","agent","agents","AGLToASL","aimedAtTarget","aimPos","airDensityCurveRTD","airDensityRTD","airplaneThrottle","airportSide","AISFinishHeal","alive","all3DENEntities","allActiveTitleEffects","allAddonsInfo","allAirports","allControls","allCurators","allCutLayers","allDead","allDeadMen","allDiaryRecords","allDiarySubjects","allDisplays","allEnv3DSoundSources","allGroups","allLODs","allMapMarkers","allMines","allMissionObjects","allObjects","allow3DMode","allowCrewInImmobile","allowCuratorLogicIgnoreAreas","allowDamage","allowDammage","allowedService","allowFileOperations","allowFleeing","allowGetIn","allowService","allowSprint","allPlayers","allSimpleObjects","allSites","allTurrets","allUnits","allUnitsUAV","allUsers","allVariables","ambientTemperature","ammo","ammoOnPylon","and","animate","animateBay","animateDoor","animatePylon","animateSource","animationNames","animationPhase","animationSourcePhase","animationState","apertureParams","append","apply","armoryPoints","arrayIntersect","asin","ASLToAGL","ASLToATL","assert","assignAsCargo","assignAsCargoIndex","assignAsCommander","assignAsDriver","assignAsGunner","assignAsTurret","assignCurator","assignedCargo","assignedCommander","assignedDriver","assignedGroup","assignedGunner","assignedItems","assignedTarget","assignedTeam","assignedVehicle","assignedVehicleRole","assignedVehicles","assignItem","assignTeam","assignToAirport","atan","atan2","atg","ATLToASL","attachedObject","attachedObjects","attachedTo","attachObject","attachTo","attackEnabled","awake","backpack","backpackCargo","backpackContainer","backpackItems","backpackMagazines","backpackSpaceFor","behaviour","benchmark","bezierInterpolation","binocular","binocularItems","binocularMagazine","boundingBox","boundingBoxReal","boundingCenter","brakesDisabled","briefingName","buildingExit","buildingPos","buldozer_EnableRoadDiag","buldozer_IsEnabledRoadDiag","buldozer_LoadNewRoads","buldozer_reloadOperMap","buttonAction","buttonSetAction","cadetMode","calculatePath","calculatePlayerVisibilityByFriendly","call","callExtension","camCommand","camCommit","camCommitPrepared","camCommitted","camConstuctionSetParams","camCreate","camDestroy","cameraEffect","cameraEffectEnableHUD","cameraInterest","cameraOn","cameraView","campaignConfigFile","camPreload","camPreloaded","camPrepareBank","camPrepareDir","camPrepareDive","camPrepareFocus","camPrepareFov","camPrepareFovRange","camPreparePos","camPrepareRelPos","camPrepareTarget","camSetBank","camSetDir","camSetDive","camSetFocus","camSetFov","camSetFovRange","camSetPos","camSetRelPos","camSetTarget","camTarget","camUseNVG","canAdd","canAddItemToBackpack","canAddItemToUniform","canAddItemToVest","cancelSimpleTaskDestination","canDeployWeapon","canFire","canMove","canSlingLoad","canStand","canSuspend","canTriggerDynamicSimulation","canUnloadInCombat","canVehicleCargo","captive","captiveNum","cbChecked","cbSetChecked","ceil","channelEnabled","cheatsEnabled","checkAIFeature","checkVisibility","className","clear3DENAttribute","clear3DENInventory","clearAllItemsFromBackpack","clearBackpackCargo","clearBackpackCargoGlobal","clearForcesRTD","clearGroupIcons","clearItemCargo","clearItemCargoGlobal","clearItemPool","clearMagazineCargo","clearMagazineCargoGlobal","clearMagazinePool","clearOverlay","clearRadio","clearWeaponCargo","clearWeaponCargoGlobal","clearWeaponPool","clientOwner","closeDialog","closeDisplay","closeOverlay","collapseObjectTree","collect3DENHistory","collectiveRTD","collisionDisabledWith","combatBehaviour","combatMode","commandArtilleryFire","commandChat","commander","commandFire","commandFollow","commandFSM","commandGetOut","commandingMenu","commandMove","commandRadio","commandStop","commandSuppressiveFire","commandTarget","commandWatch","comment","commitOverlay","compatibleItems","compatibleMagazines","compile","compileFinal","compileScript","completedFSM","composeText","configClasses","configFile","configHierarchy","configName","configOf","configProperties","configSourceAddonList","configSourceMod","configSourceModList","confirmSensorTarget","connectTerminalToUAV","connectToServer","controlsGroupCtrl","conversationDisabled","copyFromClipboard","copyToClipboard","copyWaypoints","cos","count","countEnemy","countFriendly","countSide","countType","countUnknown","create3DENComposition","create3DENEntity","createAgent","createCenter","createDialog","createDiaryLink","createDiaryRecord","createDiarySubject","createDisplay","createGearDialog","createGroup","createGuardedPoint","createHashMap","createHashMapFromArray","createLocation","createMarker","createMarkerLocal","createMenu","createMine","createMissionDisplay","createMPCampaignDisplay","createSimpleObject","createSimpleTask","createSite","createSoundSource","createTask","createTeam","createTrigger","createUnit","createVehicle","createVehicleCrew","createVehicleLocal","crew","ctAddHeader","ctAddRow","ctClear","ctCurSel","ctData","ctFindHeaderRows","ctFindRowHeader","ctHeaderControls","ctHeaderCount","ctRemoveHeaders","ctRemoveRows","ctrlActivate","ctrlAddEventHandler","ctrlAngle","ctrlAnimateModel","ctrlAnimationPhaseModel","ctrlAt","ctrlAutoScrollDelay","ctrlAutoScrollRewind","ctrlAutoScrollSpeed","ctrlBackgroundColor","ctrlChecked","ctrlClassName","ctrlCommit","ctrlCommitted","ctrlCreate","ctrlDelete","ctrlEnable","ctrlEnabled","ctrlFade","ctrlFontHeight","ctrlForegroundColor","ctrlHTMLLoaded","ctrlIDC","ctrlIDD","ctrlMapAnimAdd","ctrlMapAnimClear","ctrlMapAnimCommit","ctrlMapAnimDone","ctrlMapCursor","ctrlMapMouseOver","ctrlMapPosition","ctrlMapScale","ctrlMapScreenToWorld","ctrlMapSetPosition","ctrlMapWorldToScreen","ctrlModel","ctrlModelDirAndUp","ctrlModelScale","ctrlMousePosition","ctrlParent","ctrlParentControlsGroup","ctrlPosition","ctrlRemoveAllEventHandlers","ctrlRemoveEventHandler","ctrlScale","ctrlScrollValues","ctrlSetActiveColor","ctrlSetAngle","ctrlSetAutoScrollDelay","ctrlSetAutoScrollRewind","ctrlSetAutoScrollSpeed","ctrlSetBackgroundColor","ctrlSetChecked","ctrlSetDisabledColor","ctrlSetEventHandler","ctrlSetFade","ctrlSetFocus","ctrlSetFont","ctrlSetFontH1","ctrlSetFontH1B","ctrlSetFontH2","ctrlSetFontH2B","ctrlSetFontH3","ctrlSetFontH3B","ctrlSetFontH4","ctrlSetFontH4B","ctrlSetFontH5","ctrlSetFontH5B","ctrlSetFontH6","ctrlSetFontH6B","ctrlSetFontHeight","ctrlSetFontHeightH1","ctrlSetFontHeightH2","ctrlSetFontHeightH3","ctrlSetFontHeightH4","ctrlSetFontHeightH5","ctrlSetFontHeightH6","ctrlSetFontHeightSecondary","ctrlSetFontP","ctrlSetFontPB","ctrlSetFontSecondary","ctrlSetForegroundColor","ctrlSetModel","ctrlSetModelDirAndUp","ctrlSetModelScale","ctrlSetMousePosition","ctrlSetPixelPrecision","ctrlSetPosition","ctrlSetPositionH","ctrlSetPositionW","ctrlSetPositionX","ctrlSetPositionY","ctrlSetScale","ctrlSetScrollValues","ctrlSetShadow","ctrlSetStructuredText","ctrlSetText","ctrlSetTextColor","ctrlSetTextColorSecondary","ctrlSetTextSecondary","ctrlSetTextSelection","ctrlSetTooltip","ctrlSetTooltipColorBox","ctrlSetTooltipColorShade","ctrlSetTooltipColorText","ctrlSetTooltipMaxWidth","ctrlSetURL","ctrlSetURLOverlayMode","ctrlShadow","ctrlShow","ctrlShown","ctrlStyle","ctrlText","ctrlTextColor","ctrlTextHeight","ctrlTextSecondary","ctrlTextSelection","ctrlTextWidth","ctrlTooltip","ctrlType","ctrlURL","ctrlURLOverlayMode","ctrlVisible","ctRowControls","ctRowCount","ctSetCurSel","ctSetData","ctSetHeaderTemplate","ctSetRowTemplate","ctSetValue","ctValue","curatorAddons","curatorCamera","curatorCameraArea","curatorCameraAreaCeiling","curatorCoef","curatorEditableObjects","curatorEditingArea","curatorEditingAreaType","curatorMouseOver","curatorPoints","curatorRegisteredObjects","curatorSelected","curatorWaypointCost","current3DENOperation","currentChannel","currentCommand","currentMagazine","currentMagazineDetail","currentMagazineDetailTurret","currentMagazineTurret","currentMuzzle","currentNamespace","currentPilot","currentTask","currentTasks","currentThrowable","currentVisionMode","currentWaypoint","currentWeapon","currentWeaponMode","currentWeaponTurret","currentZeroing","cursorObject","cursorTarget","customChat","customRadio","customWaypointPosition","cutFadeOut","cutObj","cutRsc","cutText","damage","date","dateToNumber","dayTime","deActivateKey","debriefingText","debugFSM","debugLog","decayGraphValues","deg","delete3DENEntities","deleteAt","deleteCenter","deleteCollection","deleteEditorObject","deleteGroup","deleteGroupWhenEmpty","deleteIdentity","deleteLocation","deleteMarker","deleteMarkerLocal","deleteRange","deleteResources","deleteSite","deleteStatus","deleteTeam","deleteVehicle","deleteVehicleCrew","deleteWaypoint","detach","detectedMines","diag_activeMissionFSMs","diag_activeScripts","diag_activeSQFScripts","diag_activeSQSScripts","diag_allMissionEventHandlers","diag_captureFrame","diag_captureFrameToFile","diag_captureSlowFrame","diag_codePerformance","diag_deltaTime","diag_drawmode","diag_dumpCalltraceToLog","diag_dumpScriptAssembly","diag_dumpTerrainSynth","diag_dynamicSimulationEnd","diag_enable","diag_enabled","diag_exportConfig","diag_exportTerrainSVG","diag_fps","diag_fpsmin","diag_frameno","diag_getTerrainSegmentOffset","diag_lightNewLoad","diag_list","diag_localized","diag_log","diag_logSlowFrame","diag_mergeConfigFile","diag_recordTurretLimits","diag_resetFSM","diag_resetshapes","diag_scope","diag_setLightNew","diag_stacktrace","diag_tickTime","diag_toggle","dialog","diarySubjectExists","didJIP","didJIPOwner","difficulty","difficultyEnabled","difficultyEnabledRTD","difficultyOption","direction","directionStabilizationEnabled","directSay","disableAI","disableBrakes","disableCollisionWith","disableConversation","disableDebriefingStats","disableMapIndicators","disableNVGEquipment","disableRemoteSensors","disableSerialization","disableTIEquipment","disableUAVConnectability","disableUserInput","displayAddEventHandler","displayChild","displayCtrl","displayParent","displayRemoveAllEventHandlers","displayRemoveEventHandler","displaySetEventHandler","displayUniqueName","displayUpdate","dissolveTeam","distance","distance2D","distanceSqr","distributionRegion","do3DENAction","doArtilleryFire","doFire","doFollow","doFSM","doGetOut","doMove","doorPhase","doStop","doSuppressiveFire","doTarget","doWatch","drawArrow","drawEllipse","drawIcon","drawIcon3D","drawLaser","drawLine","drawLine3D","drawLink","drawLocation","drawPolygon","drawRectangle","drawTriangle","driver","drop","dynamicSimulationDistance","dynamicSimulationDistanceCoef","dynamicSimulationEnabled","dynamicSimulationSystemEnabled","echo","edit3DENMissionAttributes","editObject","editorSetEventHandler","effectiveCommander","elevatePeriscope","emptyPositions","enableAI","enableAIFeature","enableAimPrecision","enableAttack","enableAudioFeature","enableAutoStartUpRTD","enableAutoTrimRTD","enableCamShake","enableCaustics","enableChannel","enableCollisionWith","enableCopilot","enableDebriefingStats","enableDiagLegend","enableDirectionStabilization","enableDynamicSimulation","enableDynamicSimulationSystem","enableEndDialog","enableEngineArtillery","enableEnvironment","enableFatigue","enableGunLights","enableInfoPanelComponent","enableIRLasers","enableMimics","enablePersonTurret","enableRadio","enableReload","enableRopeAttach","enableSatNormalOnDetail","enableSaving","enableSentences","enableSimulation","enableSimulationGlobal","enableStamina","enableStressDamage","enableTeamSwitch","enableTraffic","enableUAVConnectability","enableUAVWaypoints","enableVehicleCargo","enableVehicleSensor","enableWeaponDisassembly","endLoadingScreen","endMission","engineOn","enginesIsOnRTD","enginesPowerRTD","enginesRpmRTD","enginesTorqueRTD","entities","environmentEnabled","environmentVolume","equipmentDisabled","estimatedEndServerTime","estimatedTimeLeft","evalObjectArgument","everyBackpack","everyContainer","exec","execEditorScript","execFSM","execVM","exp","expectedDestination","exportJIPMessages","eyeDirection","eyePos","face","faction","fadeEnvironment","fadeMusic","fadeRadio","fadeSound","fadeSpeech","failMission","fileExists","fillWeaponsFromPool","find","findAny","findCover","findDisplay","findEditorObject","findEmptyPosition","findEmptyPositionReady","findIf","findNearestEnemy","finishMissionInit","finite","fire","fireAtTarget","firstBackpack","flag","flagAnimationPhase","flagOwner","flagSide","flagTexture","flatten","fleeing","floor","flyInHeight","flyInHeightASL","focusedCtrl","fog","fogForecast","fogParams","forceAddUniform","forceAtPositionRTD","forceCadetDifficulty","forcedMap","forceEnd","forceFlagTexture","forceFollowRoad","forceGeneratorRTD","forceMap","forceRespawn","forceSpeed","forceUnicode","forceWalk","forceWeaponFire","forceWeatherChange","forEachMember","forEachMemberAgent","forEachMemberTeam","forgetTarget","format","formation","formationDirection","formationLeader","formationMembers","formationPosition","formationTask","formatText","formLeader","freeExtension","freeLook","fromEditor","fuel","fullCrew","gearIDCAmmoCount","gearSlotAmmoCount","gearSlotData","gestureState","get","get3DENActionState","get3DENAttribute","get3DENCamera","get3DENConnections","get3DENEntity","get3DENEntityID","get3DENGrid","get3DENIconsVisible","get3DENLayerEntities","get3DENLinesVisible","get3DENMissionAttribute","get3DENMouseOver","get3DENSelected","getAimingCoef","getAllEnv3DSoundControllers","getAllEnvSoundControllers","getAllHitPointsDamage","getAllOwnedMines","getAllPylonsInfo","getAllSoundControllers","getAllUnitTraits","getAmmoCargo","getAnimAimPrecision","getAnimSpeedCoef","getArray","getArtilleryAmmo","getArtilleryComputerSettings","getArtilleryETA","getAssetDLCInfo","getAssignedCuratorLogic","getAssignedCuratorUnit","getAttackTarget","getAudioOptionVolumes","getBackpackCargo","getBleedingRemaining","getBurningValue","getCalculatePlayerVisibilityByFriendly","getCameraViewDirection","getCargoIndex","getCenterOfMass","getClientState","getClientStateNumber","getCompatiblePylonMagazines","getConnectedUAV","getConnectedUAVUnit","getContainerMaxLoad","getCorpse","getCruiseControl","getCursorObjectParams","getCustomAimCoef","getCustomSoundController","getCustomSoundControllerCount","getDammage","getDebriefingText","getDescription","getDir","getDirVisual","getDiverState","getDLCAssetsUsage","getDLCAssetsUsageByName","getDLCs","getDLCUsageTime","getEditorCamera","getEditorMode","getEditorObjectScope","getElevationOffset","getEngineTargetRPMRTD","getEnv3DSoundController","getEnvSoundController","getEventHandlerInfo","getFatigue","getFieldManualStartPage","getForcedFlagTexture","getForcedSpeed","getFriend","getFSMVariable","getFuelCargo","getGraphValues","getGroupIcon","getGroupIconParams","getGroupIcons","getHideFrom","getHit","getHitIndex","getHitPointDamage","getItemCargo","getLighting","getLightingAt","getLoadedModsInfo","getMagazineCargo","getMarkerColor","getMarkerPos","getMarkerSize","getMarkerType","getMass","getMissionConfig","getMissionConfigValue","getMissionDLCs","getMissionLayerEntities","getMissionLayers","getMissionPath","getModelInfo","getMousePosition","getMusicPlayedTime","getNumber","getObjectArgument","getObjectChildren","getObjectDLC","getObjectFOV","getObjectID","getObjectMaterials","getObjectProxy","getObjectScale","getObjectTextures","getObjectType","getObjectViewDistance","getOpticsMode","getOrDefault","getOrDefaultCall","getOxygenRemaining","getPersonUsedDLCs","getPilotCameraDirection","getPilotCameraPosition","getPilotCameraRotation","getPilotCameraTarget","getPiPViewDistance","getPlateNumber","getPlayerChannel","getPlayerID","getPlayerScores","getPlayerUID","getPlayerVoNVolume","getPos","getPosASL","getPosASLVisual","getPosASLW","getPosATL","getPosATLVisual","getPosVisual","getPosWorld","getPosWorldVisual","getPylonMagazines","getRelDir","getRelPos","getRemoteSensorsDisabled","getRepairCargo","getResolution","getRoadInfo","getRotorBrakeRTD","getSensorTargets","getSensorThreats","getShadowDistance","getShotParents","getSlingLoad","getSoundController","getSoundControllerResult","getSpeed","getStamina","getStatValue","getSteamFriendsServers","getSubtitleOptions","getSuppression","getTerrainGrid","getTerrainHeight","getTerrainHeightASL","getTerrainInfo","getText","getTextRaw","getTextureInfo","getTextWidth","getTiParameters","getTotalDLCUsageTime","getTrimOffsetRTD","getTurretLimits","getTurretOpticsMode","getUnitFreefallInfo","getUnitLoadout","getUnitTrait","getUnloadInCombat","getUserInfo","getUserMFDText","getUserMFDValue","getVariable","getVehicleCargo","getVehicleTiPars","getWeaponCargo","getWeaponSway","getWingsOrientationRTD","getWingsPositionRTD","getWPPos","glanceAt","globalChat","globalRadio","goggles","goto","group","groupChat","groupFromNetId","groupIconSelectable","groupIconsVisible","groupID","groupOwner","groupRadio","groups","groupSelectedUnits","groupSelectUnit","gunner","gusts","halt","handgunItems","handgunMagazine","handgunWeapon","handsHit","hashValue","hasInterface","hasPilotCamera","hasWeapon","hcAllGroups","hcGroupParams","hcLeader","hcRemoveAllGroups","hcRemoveGroup","hcSelected","hcSelectGroup","hcSetGroup","hcShowBar","hcShownBar","headgear","hideBody","hideObject","hideObjectGlobal","hideSelection","hint","hintC","hintCadet","hintSilent","hmd","hostMission","htmlLoad","HUDMovementLevels","humidity","image","importAllGroups","importance","in","inArea","inAreaArray","incapacitatedState","inflame","inflamed","infoPanel","infoPanelComponentEnabled","infoPanelComponents","infoPanels","inGameUISetEventHandler","inheritsFrom","initAmbientLife","inPolygon","inputAction","inputController","inputMouse","inRangeOfArtillery","insert","insertEditorObject","intersect","is3DEN","is3DENMultiplayer","is3DENPreview","isAbleToBreathe","isActionMenuVisible","isAgent","isAimPrecisionEnabled","isAllowedCrewInImmobile","isArray","isAutoHoverOn","isAutonomous","isAutoStartUpEnabledRTD","isAutotest","isAutoTrimOnRTD","isAwake","isBleeding","isBurning","isClass","isCollisionLightOn","isCopilotEnabled","isDamageAllowed","isDedicated","isDLCAvailable","isEngineOn","isEqualRef","isEqualTo","isEqualType","isEqualTypeAll","isEqualTypeAny","isEqualTypeArray","isEqualTypeParams","isFilePatchingEnabled","isFinal","isFlashlightOn","isFlatEmpty","isForcedWalk","isFormationLeader","isGameFocused","isGamePaused","isGroupDeletedWhenEmpty","isHidden","isInRemainsCollector","isInstructorFigureEnabled","isIRLaserOn","isKeyActive","isKindOf","isLaserOn","isLightOn","isLocalized","isManualFire","isMarkedForCollection","isMissionProfileNamespaceLoaded","isMultiplayer","isMultiplayerSolo","isNil","isNotEqualRef","isNotEqualTo","isNull","isNumber","isObjectHidden","isObjectRTD","isOnRoad","isPiPEnabled","isPlayer","isRealTime","isRemoteExecuted","isRemoteExecutedJIP","isSaving","isSensorTargetConfirmed","isServer","isShowing3DIcons","isSimpleObject","isSprintAllowed","isStaminaEnabled","isSteamMission","isSteamOverlayEnabled","isStreamFriendlyUIEnabled","isStressDamageEnabled","isText","isTouchingGround","isTurnedOut","isTutHintsEnabled","isUAVConnectable","isUAVConnected","isUIContext","isUniformAllowed","isVehicleCargo","isVehicleRadarOn","isVehicleSensorEnabled","isWalking","isWeaponDeployed","isWeaponRested","itemCargo","items","itemsWithMagazines","join","joinAs","joinAsSilent","joinSilent","joinString","kbAddDatabase","kbAddDatabaseTargets","kbAddTopic","kbHasTopic","kbReact","kbRemoveTopic","kbTell","kbWasSaid","keyImage","keyName","keys","knowsAbout","land","landAt","landResult","language","laserTarget","lbAdd","lbClear","lbColor","lbColorRight","lbCurSel","lbData","lbDelete","lbIsSelected","lbPicture","lbPictureRight","lbSelection","lbSetColor","lbSetColorRight","lbSetCurSel","lbSetData","lbSetPicture","lbSetPictureColor","lbSetPictureColorDisabled","lbSetPictureColorSelected","lbSetPictureRight","lbSetPictureRightColor","lbSetPictureRightColorDisabled","lbSetPictureRightColorSelected","lbSetSelectColor","lbSetSelectColorRight","lbSetSelected","lbSetText","lbSetTextRight","lbSetTooltip","lbSetValue","lbSize","lbSort","lbSortBy","lbSortByValue","lbText","lbTextRight","lbTooltip","lbValue","leader","leaderboardDeInit","leaderboardGetRows","leaderboardInit","leaderboardRequestRowsFriends","leaderboardRequestRowsGlobal","leaderboardRequestRowsGlobalAroundUser","leaderboardsRequestUploadScore","leaderboardsRequestUploadScoreKeepBest","leaderboardState","leaveVehicle","libraryCredits","libraryDisclaimers","lifeState","lightAttachObject","lightDetachObject","lightIsOn","lightnings","limitSpeed","linearConversion","lineIntersects","lineIntersectsObjs","lineIntersectsSurfaces","lineIntersectsWith","linkItem","list","listObjects","listRemoteTargets","listVehicleSensors","ln","lnbAddArray","lnbAddColumn","lnbAddRow","lnbClear","lnbColor","lnbColorRight","lnbCurSelRow","lnbData","lnbDeleteColumn","lnbDeleteRow","lnbGetColumnsPosition","lnbPicture","lnbPictureRight","lnbSetColor","lnbSetColorRight","lnbSetColumnsPos","lnbSetCurSelRow","lnbSetData","lnbSetPicture","lnbSetPictureColor","lnbSetPictureColorRight","lnbSetPictureColorSelected","lnbSetPictureColorSelectedRight","lnbSetPictureRight","lnbSetText","lnbSetTextRight","lnbSetTooltip","lnbSetValue","lnbSize","lnbSort","lnbSortBy","lnbSortByValue","lnbText","lnbTextRight","lnbValue","load","loadAbs","loadBackpack","loadConfig","loadFile","loadGame","loadIdentity","loadMagazine","loadOverlay","loadStatus","loadUniform","loadVest","localize","localNamespace","locationPosition","lock","lockCameraTo","lockCargo","lockDriver","locked","lockedCameraTo","lockedCargo","lockedDriver","lockedInventory","lockedTurret","lockIdentity","lockInventory","lockTurret","lockWp","log","logEntities","logNetwork","logNetworkTerminate","lookAt","lookAtPos","magazineCargo","magazines","magazinesAllTurrets","magazinesAmmo","magazinesAmmoCargo","magazinesAmmoFull","magazinesDetail","magazinesDetailBackpack","magazinesDetailUniform","magazinesDetailVest","magazinesTurret","magazineTurretAmmo","mapAnimAdd","mapAnimClear","mapAnimCommit","mapAnimDone","mapCenterOnCamera","mapGridPosition","markAsFinishedOnSteam","markerAlpha","markerBrush","markerChannel","markerColor","markerDir","markerPolyline","markerPos","markerShadow","markerShape","markerSize","markerText","markerType","matrixMultiply","matrixTranspose","max","maxLoad","members","menuAction","menuAdd","menuChecked","menuClear","menuCollapse","menuData","menuDelete","menuEnable","menuEnabled","menuExpand","menuHover","menuPicture","menuSetAction","menuSetCheck","menuSetData","menuSetPicture","menuSetShortcut","menuSetText","menuSetURL","menuSetValue","menuShortcut","menuShortcutText","menuSize","menuSort","menuText","menuURL","menuValue","merge","min","mineActive","mineDetectedBy","missileTarget","missileTargetPos","missionConfigFile","missionDifficulty","missionEnd","missionName","missionNameSource","missionNamespace","missionProfileNamespace","missionStart","missionVersion","mod","modelToWorld","modelToWorldVisual","modelToWorldVisualWorld","modelToWorldWorld","modParams","moonIntensity","moonPhase","morale","move","move3DENCamera","moveInAny","moveInCargo","moveInCommander","moveInDriver","moveInGunner","moveInTurret","moveObjectToEnd","moveOut","moveTime","moveTo","moveToCompleted","moveToFailed","musicVolume","name","namedProperties","nameSound","nearEntities","nearestBuilding","nearestLocation","nearestLocations","nearestLocationWithDubbing","nearestMines","nearestObject","nearestObjects","nearestTerrainObjects","nearObjects","nearObjectsReady","nearRoads","nearSupplies","nearTargets","needReload","needService","netId","netObjNull","newOverlay","nextMenuItemIndex","nextWeatherChange","nMenuItems","not","numberOfEnginesRTD","numberToDate","objectCurators","objectFromNetId","objectParent","objStatus","onBriefingGroup","onBriefingNotes","onBriefingPlan","onBriefingTeamSwitch","onCommandModeChanged","onDoubleClick","onEachFrame","onGroupIconClick","onGroupIconOverEnter","onGroupIconOverLeave","onHCGroupSelectionChanged","onMapSingleClick","onPlayerConnected","onPlayerDisconnected","onPreloadFinished","onPreloadStarted","onShowNewObject","onTeamSwitch","openCuratorInterface","openDLCPage","openGPS","openMap","openSteamApp","openYoutubeVideo","or","orderGetIn","overcast","overcastForecast","owner","param","params","parseNumber","parseSimpleArray","parseText","parsingNamespace","particlesQuality","periscopeElevation","pickWeaponPool","pitch","pixelGrid","pixelGridBase","pixelGridNoUIScale","pixelH","pixelW","playableSlotsNumber","playableUnits","playAction","playActionNow","player","playerRespawnTime","playerSide","playersNumber","playGesture","playMission","playMove","playMoveNow","playMusic","playScriptedMission","playSound","playSound3D","playSoundUI","pose","position","positionCameraToWorld","posScreenToWorld","posWorldToScreen","ppEffectAdjust","ppEffectCommit","ppEffectCommitted","ppEffectCreate","ppEffectDestroy","ppEffectEnable","ppEffectEnabled","ppEffectForceInNVG","precision","preloadCamera","preloadObject","preloadSound","preloadTitleObj","preloadTitleRsc","preprocessFile","preprocessFileLineNumbers","primaryWeapon","primaryWeaponItems","primaryWeaponMagazine","priority","processDiaryLink","productVersion","profileName","profileNamespace","profileNameSteam","progressLoadingScreen","progressPosition","progressSetPosition","publicVariable","publicVariableClient","publicVariableServer","pushBack","pushBackUnique","putWeaponPool","queryItemsPool","queryMagazinePool","queryWeaponPool","rad","radioChannelAdd","radioChannelCreate","radioChannelInfo","radioChannelRemove","radioChannelSetCallSign","radioChannelSetLabel","radioEnabled","radioVolume","rain","rainbow","rainParams","random","rank","rankId","rating","rectangular","regexFind","regexMatch","regexReplace","registeredTasks","registerTask","reload","reloadEnabled","remoteControl","remoteExec","remoteExecCall","remoteExecutedOwner","remove3DENConnection","remove3DENEventHandler","remove3DENLayer","removeAction","removeAll3DENEventHandlers","removeAllActions","removeAllAssignedItems","removeAllBinocularItems","removeAllContainers","removeAllCuratorAddons","removeAllCuratorCameraAreas","removeAllCuratorEditingAreas","removeAllEventHandlers","removeAllHandgunItems","removeAllItems","removeAllItemsWithMagazines","removeAllMissionEventHandlers","removeAllMPEventHandlers","removeAllMusicEventHandlers","removeAllOwnedMines","removeAllPrimaryWeaponItems","removeAllSecondaryWeaponItems","removeAllUserActionEventHandlers","removeAllWeapons","removeBackpack","removeBackpackGlobal","removeBinocularItem","removeCuratorAddons","removeCuratorCameraArea","removeCuratorEditableObjects","removeCuratorEditingArea","removeDiaryRecord","removeDiarySubject","removeDrawIcon","removeDrawLinks","removeEventHandler","removeFromRemainsCollector","removeGoggles","removeGroupIcon","removeHandgunItem","removeHeadgear","removeItem","removeItemFromBackpack","removeItemFromUniform","removeItemFromVest","removeItems","removeMagazine","removeMagazineGlobal","removeMagazines","removeMagazinesTurret","removeMagazineTurret","removeMenuItem","removeMissionEventHandler","removeMPEventHandler","removeMusicEventHandler","removeOwnedMine","removePrimaryWeaponItem","removeSecondaryWeaponItem","removeSimpleTask","removeSwitchableUnit","removeTeamMember","removeUniform","removeUserActionEventHandler","removeVest","removeWeapon","removeWeaponAttachmentCargo","removeWeaponCargo","removeWeaponGlobal","removeWeaponTurret","reportRemoteTarget","requiredVersion","resetCamShake","resetSubgroupDirection","resize","resources","respawnVehicle","restartEditorCamera","reveal","revealMine","reverse","reversedMouseY","roadAt","roadsConnectedTo","roleDescription","ropeAttachedObjects","ropeAttachedTo","ropeAttachEnabled","ropeAttachTo","ropeCreate","ropeCut","ropeDestroy","ropeDetach","ropeEndPosition","ropeLength","ropes","ropesAttachedTo","ropeSegments","ropeUnwind","ropeUnwound","rotorsForcesRTD","rotorsRpmRTD","round","runInitScript","safeZoneH","safeZoneW","safeZoneWAbs","safeZoneX","safeZoneXAbs","safeZoneY","save3DENInventory","saveGame","saveIdentity","saveJoysticks","saveMissionProfileNamespace","saveOverlay","saveProfileNamespace","saveStatus","saveVar","savingEnabled","say","say2D","say3D","scopeName","score","scoreSide","screenshot","screenToWorld","scriptDone","scriptName","scudState","secondaryWeapon","secondaryWeaponItems","secondaryWeaponMagazine","select","selectBestPlaces","selectDiarySubject","selectedEditorObjects","selectEditorObject","selectionNames","selectionPosition","selectionVectorDirAndUp","selectLeader","selectMax","selectMin","selectNoPlayer","selectPlayer","selectRandom","selectRandomWeighted","selectWeapon","selectWeaponTurret","sendAUMessage","sendSimpleCommand","sendTask","sendTaskResult","sendUDPMessage","sentencesEnabled","serverCommand","serverCommandAvailable","serverCommandExecutable","serverName","serverNamespace","serverTime","set","set3DENAttribute","set3DENAttributes","set3DENGrid","set3DENIconsVisible","set3DENLayer","set3DENLinesVisible","set3DENLogicType","set3DENMissionAttribute","set3DENMissionAttributes","set3DENModelsVisible","set3DENObjectType","set3DENSelected","setAccTime","setActualCollectiveRTD","setAirplaneThrottle","setAirportSide","setAmmo","setAmmoCargo","setAmmoOnPylon","setAnimSpeedCoef","setAperture","setApertureNew","setArmoryPoints","setAttributes","setAutonomous","setBehaviour","setBehaviourStrong","setBleedingRemaining","setBrakesRTD","setCameraInterest","setCamShakeDefParams","setCamShakeParams","setCamUseTi","setCaptive","setCenterOfMass","setCollisionLight","setCombatBehaviour","setCombatMode","setCompassOscillation","setConvoySeparation","setCruiseControl","setCuratorCameraAreaCeiling","setCuratorCoef","setCuratorEditingAreaType","setCuratorWaypointCost","setCurrentChannel","setCurrentTask","setCurrentWaypoint","setCustomAimCoef","SetCustomMissionData","setCustomSoundController","setCustomWeightRTD","setDamage","setDammage","setDate","setDebriefingText","setDefaultCamera","setDestination","setDetailMapBlendPars","setDiaryRecordText","setDiarySubjectPicture","setDir","setDirection","setDrawIcon","setDriveOnPath","setDropInterval","setDynamicSimulationDistance","setDynamicSimulationDistanceCoef","setEditorMode","setEditorObjectScope","setEffectCondition","setEffectiveCommander","setEngineRpmRTD","setFace","setFaceanimation","setFatigue","setFeatureType","setFlagAnimationPhase","setFlagOwner","setFlagSide","setFlagTexture","setFog","setForceGeneratorRTD","setFormation","setFormationTask","setFormDir","setFriend","setFromEditor","setFSMVariable","setFuel","setFuelCargo","setGroupIcon","setGroupIconParams","setGroupIconsSelectable","setGroupIconsVisible","setGroupid","setGroupIdGlobal","setGroupOwner","setGusts","setHideBehind","setHit","setHitIndex","setHitPointDamage","setHorizonParallaxCoef","setHUDMovementLevels","setHumidity","setIdentity","setImportance","setInfoPanel","setLeader","setLightAmbient","setLightAttenuation","setLightBrightness","setLightColor","setLightConePars","setLightDayLight","setLightFlareMaxDistance","setLightFlareSize","setLightIntensity","setLightIR","setLightnings","setLightUseFlare","setLightVolumeShape","setLocalWindParams","setMagazineTurretAmmo","setMarkerAlpha","setMarkerAlphaLocal","setMarkerBrush","setMarkerBrushLocal","setMarkerColor","setMarkerColorLocal","setMarkerDir","setMarkerDirLocal","setMarkerPolyline","setMarkerPolylineLocal","setMarkerPos","setMarkerPosLocal","setMarkerShadow","setMarkerShadowLocal","setMarkerShape","setMarkerShapeLocal","setMarkerSize","setMarkerSizeLocal","setMarkerText","setMarkerTextLocal","setMarkerType","setMarkerTypeLocal","setMass","setMaxLoad","setMimic","setMissileTarget","setMissileTargetPos","setMousePosition","setMusicEffect","setMusicEventHandler","setName","setNameSound","setObjectArguments","setObjectMaterial","setObjectMaterialGlobal","setObjectProxy","setObjectScale","setObjectTexture","setObjectTextureGlobal","setObjectViewDistance","setOpticsMode","setOvercast","setOwner","setOxygenRemaining","setParticleCircle","setParticleClass","setParticleFire","setParticleParams","setParticleRandom","setPilotCameraDirection","setPilotCameraRotation","setPilotCameraTarget","setPilotLight","setPiPEffect","setPiPViewDistance","setPitch","setPlateNumber","setPlayable","setPlayerRespawnTime","setPlayerVoNVolume","setPos","setPosASL","setPosASL2","setPosASLW","setPosATL","setPosition","setPosWorld","setPylonLoadout","setPylonsPriority","setRadioMsg","setRain","setRainbow","setRandomLip","setRank","setRectangular","setRepairCargo","setRotorBrakeRTD","setShadowDistance","setShotParents","setSide","setSimpleTaskAlwaysVisible","setSimpleTaskCustomData","setSimpleTaskDescription","setSimpleTaskDestination","setSimpleTaskTarget","setSimpleTaskType","setSimulWeatherLayers","setSize","setSkill","setSlingLoad","setSoundEffect","setSpeaker","setSpeech","setSpeedMode","setStamina","setStaminaScheme","setStatValue","setSuppression","setSystemOfUnits","setTargetAge","setTaskMarkerOffset","setTaskResult","setTaskState","setTerrainGrid","setTerrainHeight","setText","setTimeMultiplier","setTiParameter","setTitleEffect","setTowParent","setTrafficDensity","setTrafficDistance","setTrafficGap","setTrafficSpeed","setTriggerActivation","setTriggerArea","setTriggerInterval","setTriggerStatements","setTriggerText","setTriggerTimeout","setTriggerType","setTurretLimits","setTurretOpticsMode","setType","setUnconscious","setUnitAbility","setUnitCombatMode","setUnitFreefallHeight","setUnitLoadout","setUnitPos","setUnitPosWeak","setUnitRank","setUnitRecoilCoefficient","setUnitTrait","setUnloadInCombat","setUserActionText","setUserMFDText","setUserMFDValue","setVariable","setVectorDir","setVectorDirAndUp","setVectorUp","setVehicleAmmo","setVehicleAmmoDef","setVehicleArmor","setVehicleCargo","setVehicleId","setVehicleLock","setVehiclePosition","setVehicleRadar","setVehicleReceiveRemoteTargets","setVehicleReportOwnPosition","setVehicleReportRemoteTargets","setVehicleTiPars","setVehicleVarName","setVelocity","setVelocityModelSpace","setVelocityTransformation","setViewDistance","setVisibleIfTreeCollapsed","setWantedRPMRTD","setWaves","setWaypointBehaviour","setWaypointCombatMode","setWaypointCompletionRadius","setWaypointDescription","setWaypointForceBehaviour","setWaypointFormation","setWaypointHousePosition","setWaypointLoiterAltitude","setWaypointLoiterRadius","setWaypointLoiterType","setWaypointName","setWaypointPosition","setWaypointScript","setWaypointSpeed","setWaypointStatements","setWaypointTimeout","setWaypointType","setWaypointVisible","setWeaponReloadingTime","setWeaponZeroing","setWind","setWindDir","setWindForce","setWindStr","setWingForceScaleRTD","setWPPos","show3DIcons","showChat","showCinemaBorder","showCommandingMenu","showCompass","showCuratorCompass","showGps","showHUD","showLegend","showMap","shownArtilleryComputer","shownChat","shownCompass","shownCuratorCompass","showNewEditorObject","shownGps","shownHUD","shownMap","shownPad","shownRadio","shownScoretable","shownSubtitles","shownUAVFeed","shownWarrant","shownWatch","showPad","showRadio","showScoretable","showSubtitles","showUAVFeed","showWarrant","showWatch","showWaypoint","showWaypoints","side","sideChat","sideRadio","simpleTasks","simulationEnabled","simulCloudDensity","simulCloudOcclusion","simulInClouds","simulWeatherSync","sin","size","sizeOf","skill","skillFinal","skipTime","sleep","sliderPosition","sliderRange","sliderSetPosition","sliderSetRange","sliderSetSpeed","sliderSpeed","slingLoadAssistantShown","soldierMagazines","someAmmo","sort","soundVolume","spawn","speaker","speechVolume","speed","speedMode","splitString","sqrt","squadParams","stance","startLoadingScreen","stop","stopEngineRTD","stopped","str","sunOrMoon","supportInfo","suppressFor","surfaceIsWater","surfaceNormal","surfaceTexture","surfaceType","swimInDepth","switchableUnits","switchAction","switchCamera","switchGesture","switchLight","switchMove","synchronizedObjects","synchronizedTriggers","synchronizedWaypoints","synchronizeObjectsAdd","synchronizeObjectsRemove","synchronizeTrigger","synchronizeWaypoint","systemChat","systemOfUnits","systemTime","systemTimeUTC","tan","targetKnowledge","targets","targetsAggregate","targetsQuery","taskAlwaysVisible","taskChildren","taskCompleted","taskCustomData","taskDescription","taskDestination","taskHint","taskMarkerOffset","taskName","taskParent","taskResult","taskState","taskType","teamMember","teamName","teams","teamSwitch","teamSwitchEnabled","teamType","terminate","terrainIntersect","terrainIntersectASL","terrainIntersectAtASL","text","textLog","textLogFormat","tg","time","timeMultiplier","titleCut","titleFadeOut","titleObj","titleRsc","titleText","toArray","toFixed","toLower","toLowerANSI","toString","toUpper","toUpperANSI","triggerActivated","triggerActivation","triggerAmmo","triggerArea","triggerAttachedVehicle","triggerAttachObject","triggerAttachVehicle","triggerDynamicSimulation","triggerInterval","triggerStatements","triggerText","triggerTimeout","triggerTimeoutCurrent","triggerType","trim","turretLocal","turretOwner","turretUnit","tvAdd","tvClear","tvCollapse","tvCollapseAll","tvCount","tvCurSel","tvData","tvDelete","tvExpand","tvExpandAll","tvIsSelected","tvPicture","tvPictureRight","tvSelection","tvSetColor","tvSetCurSel","tvSetData","tvSetPicture","tvSetPictureColor","tvSetPictureColorDisabled","tvSetPictureColorSelected","tvSetPictureRight","tvSetPictureRightColor","tvSetPictureRightColorDisabled","tvSetPictureRightColorSelected","tvSetSelectColor","tvSetSelected","tvSetText","tvSetTooltip","tvSetValue","tvSort","tvSortAll","tvSortByValue","tvSortByValueAll","tvText","tvTooltip","tvValue","type","typeName","typeOf","UAVControl","uiNamespace","uiSleep","unassignCurator","unassignItem","unassignTeam","unassignVehicle","underwater","uniform","uniformContainer","uniformItems","uniformMagazines","uniqueUnitItems","unitAddons","unitAimPosition","unitAimPositionVisual","unitBackpack","unitCombatMode","unitIsUAV","unitPos","unitReady","unitRecoilCoefficient","units","unitsBelowHeight","unitTurret","unlinkItem","unlockAchievement","unregisterTask","updateDrawIcon","updateMenuItem","updateObjectTree","useAIOperMapObstructionTest","useAISteeringComponent","useAudioTimeForMoves","userInputDisabled","values","vectorAdd","vectorCos","vectorCrossProduct","vectorDiff","vectorDir","vectorDirVisual","vectorDistance","vectorDistanceSqr","vectorDotProduct","vectorFromTo","vectorLinearConversion","vectorMagnitude","vectorMagnitudeSqr","vectorModelToWorld","vectorModelToWorldVisual","vectorMultiply","vectorNormalized","vectorUp","vectorUpVisual","vectorWorldToModel","vectorWorldToModelVisual","vehicle","vehicleCargoEnabled","vehicleChat","vehicleMoveInfo","vehicleRadio","vehicleReceiveRemoteTargets","vehicleReportOwnPosition","vehicleReportRemoteTargets","vehicles","vehicleVarName","velocity","velocityModelSpace","verifySignature","vest","vestContainer","vestItems","vestMagazines","viewDistance","visibleCompass","visibleGps","visibleMap","visiblePosition","visiblePositionASL","visibleScoretable","visibleWatch","waves","waypointAttachedObject","waypointAttachedVehicle","waypointAttachObject","waypointAttachVehicle","waypointBehaviour","waypointCombatMode","waypointCompletionRadius","waypointDescription","waypointForceBehaviour","waypointFormation","waypointHousePosition","waypointLoiterAltitude","waypointLoiterRadius","waypointLoiterType","waypointName","waypointPosition","waypoints","waypointScript","waypointsEnabledUAV","waypointShow","waypointSpeed","waypointStatements","waypointTimeout","waypointTimeoutCurrent","waypointType","waypointVisible","weaponAccessories","weaponAccessoriesCargo","weaponCargo","weaponDirection","weaponInertia","weaponLowered","weaponReloadingTime","weapons","weaponsInfo","weaponsItems","weaponsItemsCargo","weaponState","weaponsTurret","weightRTD","WFSideText","wind","windDir","windRTD","windStr","wingsForcesRTD","worldName","worldSize","worldToModel","worldToModelVisual","worldToScreen"],l={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:"define undef ifdef ifndef else endif include if",contains:[{begin:/\\\n/,relevance:0},e.inherit(i,{className:"string"}),{begin:/<[^\n>]*>/,end:/$/,illegal:"\\n"},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]};return{name:"SQF",case_insensitive:!0,keywords:{keyword:a,built_in:o,literal:s},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.NUMBER_MODE,r,n,i,l],illegal:[/\$[^a-fA-F0-9]/,/\w\$/,/\?/,/@/,/ \| /,/[a-zA-Z_]\./,/\:\=/,/\[\:/]}}return RW=t,RW}var NW,Fbe;function Yxt(){if(Fbe)return NW;Fbe=1;function t(e){const r=e.regex,n=e.COMMENT("--","$"),i={scope:"string",variants:[{begin:/'/,end:/'/,contains:[{match:/''/}]}]},a={begin:/"/,end:/"/,contains:[{match:/""/}]},s=["true","false","unknown"],o=["double precision","large object","with timezone","without timezone"],l=["bigint","binary","blob","boolean","char","character","clob","date","dec","decfloat","decimal","float","int","integer","interval","nchar","nclob","national","numeric","real","row","smallint","time","timestamp","varchar","varying","varbinary"],u=["add","asc","collation","desc","final","first","last","view"],d=["abs","acos","all","allocate","alter","and","any","are","array","array_agg","array_max_cardinality","as","asensitive","asin","asymmetric","at","atan","atomic","authorization","avg","begin","begin_frame","begin_partition","between","bigint","binary","blob","boolean","both","by","call","called","cardinality","cascaded","case","cast","ceil","ceiling","char","char_length","character","character_length","check","classifier","clob","close","coalesce","collate","collect","column","commit","condition","connect","constraint","contains","convert","copy","corr","corresponding","cos","cosh","count","covar_pop","covar_samp","create","cross","cube","cume_dist","current","current_catalog","current_date","current_default_transform_group","current_path","current_role","current_row","current_schema","current_time","current_timestamp","current_path","current_role","current_transform_group_for_type","current_user","cursor","cycle","date","day","deallocate","dec","decimal","decfloat","declare","default","define","delete","dense_rank","deref","describe","deterministic","disconnect","distinct","double","drop","dynamic","each","element","else","empty","end","end_frame","end_partition","end-exec","equals","escape","every","except","exec","execute","exists","exp","external","extract","false","fetch","filter","first_value","float","floor","for","foreign","frame_row","free","from","full","function","fusion","get","global","grant","group","grouping","groups","having","hold","hour","identity","in","indicator","initial","inner","inout","insensitive","insert","int","integer","intersect","intersection","interval","into","is","join","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","language","large","last_value","lateral","lead","leading","left","like","like_regex","listagg","ln","local","localtime","localtimestamp","log","log10","lower","match","match_number","match_recognize","matches","max","member","merge","method","min","minute","mod","modifies","module","month","multiset","national","natural","nchar","nclob","new","no","none","normalize","not","nth_value","ntile","null","nullif","numeric","octet_length","occurrences_regex","of","offset","old","omit","on","one","only","open","or","order","out","outer","over","overlaps","overlay","parameter","partition","pattern","per","percent","percent_rank","percentile_cont","percentile_disc","period","portion","position","position_regex","power","precedes","precision","prepare","primary","procedure","ptf","range","rank","reads","real","recursive","ref","references","referencing","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","release","result","return","returns","revoke","right","rollback","rollup","row","row_number","rows","running","savepoint","scope","scroll","search","second","seek","select","sensitive","session_user","set","show","similar","sin","sinh","skip","smallint","some","specific","specifictype","sql","sqlexception","sqlstate","sqlwarning","sqrt","start","static","stddev_pop","stddev_samp","submultiset","subset","substring","substring_regex","succeeds","sum","symmetric","system","system_time","system_user","table","tablesample","tan","tanh","then","time","timestamp","timezone_hour","timezone_minute","to","trailing","translate","translate_regex","translation","treat","trigger","trim","trim_array","true","truncate","uescape","union","unique","unknown","unnest","update","upper","user","using","value","values","value_of","var_pop","var_samp","varbinary","varchar","varying","versioning","when","whenever","where","width_bucket","window","with","within","without","year"],h=["abs","acos","array_agg","asin","atan","avg","cast","ceil","ceiling","coalesce","corr","cos","cosh","count","covar_pop","covar_samp","cume_dist","dense_rank","deref","element","exp","extract","first_value","floor","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","last_value","lead","listagg","ln","log","log10","lower","max","min","mod","nth_value","ntile","nullif","percent_rank","percentile_cont","percentile_disc","position","position_regex","power","rank","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","row_number","sin","sinh","sqrt","stddev_pop","stddev_samp","substring","substring_regex","sum","tan","tanh","translate","translate_regex","treat","trim","trim_array","unnest","upper","value_of","var_pop","var_samp","width_bucket"],f=["current_catalog","current_date","current_default_transform_group","current_path","current_role","current_schema","current_transform_group_for_type","current_user","session_user","system_time","system_user","current_time","localtime","current_timestamp","localtimestamp"],p=["create table","insert into","primary key","foreign key","not null","alter table","add constraint","grouping sets","on overflow","character set","respect nulls","ignore nulls","nulls first","nulls last","depth first","breadth first"],g=h,m=[...d,...u].filter(C=>!h.includes(C)),_={scope:"variable",match:/@[a-z0-9][a-z0-9_]*/},v={scope:"operator",match:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,relevance:0},b={match:r.concat(/\b/,r.either(...g),/\s*\(/),relevance:0,keywords:{built_in:g}};function y(C){return r.concat(/\b/,r.either(...C.map(w=>w.replace(/\s+/,"\\s+"))),/\b/)}const E={scope:"keyword",match:y(p),relevance:0};function T(C,{exceptions:w,when:x}={}){const A=x;return w=w||[],C.map(R=>R.match(/\|\d+$/)||w.includes(R)?R:A(R)?`${R}|0`:R)}return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{$pattern:/\b[\w\.]+/,keyword:T(m,{when:C=>C.length<3}),literal:s,type:l,built_in:f},contains:[{scope:"type",match:y(o)},E,b,_,i,a,e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,n,v]}}return NW=t,NW}var OW,Bbe;function Wxt(){if(Bbe)return OW;Bbe=1;function t(e){const r=e.regex,n=["functions","model","data","parameters","quantities","transformed","generated"],i=["for","in","if","else","while","break","continue","return"],a=["array","tuple","complex","int","real","vector","complex_vector","ordered","positive_ordered","simplex","unit_vector","row_vector","complex_row_vector","matrix","complex_matrix","cholesky_factor_corr|10","cholesky_factor_cov|10","corr_matrix|10","cov_matrix|10","void"],s=["abs","acos","acosh","add_diag","algebra_solver","algebra_solver_newton","append_array","append_col","append_row","asin","asinh","atan","atan2","atanh","bessel_first_kind","bessel_second_kind","binary_log_loss","block","cbrt","ceil","chol2inv","cholesky_decompose","choose","col","cols","columns_dot_product","columns_dot_self","complex_schur_decompose","complex_schur_decompose_t","complex_schur_decompose_u","conj","cos","cosh","cov_exp_quad","crossprod","csr_extract","csr_extract_u","csr_extract_v","csr_extract_w","csr_matrix_times_vector","csr_to_dense_matrix","cumulative_sum","dae","dae_tol","determinant","diag_matrix","diagonal","diag_post_multiply","diag_pre_multiply","digamma","dims","distance","dot_product","dot_self","eigendecompose","eigendecompose_sym","eigenvalues","eigenvalues_sym","eigenvectors","eigenvectors_sym","erf","erfc","exp","exp2","expm1","falling_factorial","fdim","fft","fft2","floor","fma","fmax","fmin","fmod","gamma_p","gamma_q","generalized_inverse","get_imag","get_real","head","hmm_hidden_state_prob","hmm_marginal","hypot","identity_matrix","inc_beta","integrate_1d","integrate_ode","integrate_ode_adams","integrate_ode_bdf","integrate_ode_rk45","int_step","inv","inv_cloglog","inv_erfc","inverse","inverse_spd","inv_fft","inv_fft2","inv_inc_beta","inv_logit","inv_Phi","inv_sqrt","inv_square","is_inf","is_nan","lambert_w0","lambert_wm1","lbeta","lchoose","ldexp","lgamma","linspaced_array","linspaced_int_array","linspaced_row_vector","linspaced_vector","lmgamma","lmultiply","log","log1m","log1m_exp","log1m_inv_logit","log1p","log1p_exp","log_determinant","log_diff_exp","log_falling_factorial","log_inv_logit","log_inv_logit_diff","logit","log_mix","log_modified_bessel_first_kind","log_rising_factorial","log_softmax","log_sum_exp","machine_precision","map_rect","matrix_exp","matrix_exp_multiply","matrix_power","max","mdivide_left_spd","mdivide_left_tri_low","mdivide_right_spd","mdivide_right_tri_low","mean","min","modified_bessel_first_kind","modified_bessel_second_kind","multiply_lower_tri_self_transpose","negative_infinity","norm","norm1","norm2","not_a_number","num_elements","ode_adams","ode_adams_tol","ode_adjoint_tol_ctl","ode_bdf","ode_bdf_tol","ode_ckrk","ode_ckrk_tol","ode_rk45","ode_rk45_tol","one_hot_array","one_hot_int_array","one_hot_row_vector","one_hot_vector","ones_array","ones_int_array","ones_row_vector","ones_vector","owens_t","Phi","Phi_approx","polar","positive_infinity","pow","print","prod","proj","qr","qr_Q","qr_R","qr_thin","qr_thin_Q","qr_thin_R","quad_form","quad_form_diag","quad_form_sym","quantile","rank","reduce_sum","reject","rep_array","rep_matrix","rep_row_vector","rep_vector","reverse","rising_factorial","round","row","rows","rows_dot_product","rows_dot_self","scale_matrix_exp_multiply","sd","segment","sin","singular_values","sinh","size","softmax","sort_asc","sort_desc","sort_indices_asc","sort_indices_desc","sqrt","square","squared_distance","step","sub_col","sub_row","sum","svd","svd_U","svd_V","symmetrize_from_lower_tri","tail","tan","tanh","target","tcrossprod","tgamma","to_array_1d","to_array_2d","to_complex","to_int","to_matrix","to_row_vector","to_vector","trace","trace_gen_quad_form","trace_quad_form","trigamma","trunc","uniform_simplex","variance","zeros_array","zeros_int_array","zeros_row_vector"],o=["bernoulli","bernoulli_logit","bernoulli_logit_glm","beta","beta_binomial","beta_proportion","binomial","binomial_logit","categorical","categorical_logit","categorical_logit_glm","cauchy","chi_square","dirichlet","discrete_range","double_exponential","exp_mod_normal","exponential","frechet","gamma","gaussian_dlm_obs","gumbel","hmm_latent","hypergeometric","inv_chi_square","inv_gamma","inv_wishart","inv_wishart_cholesky","lkj_corr","lkj_corr_cholesky","logistic","loglogistic","lognormal","multi_gp","multi_gp_cholesky","multinomial","multinomial_logit","multi_normal","multi_normal_cholesky","multi_normal_prec","multi_student_cholesky_t","multi_student_t","multi_student_t_cholesky","neg_binomial","neg_binomial_2","neg_binomial_2_log","neg_binomial_2_log_glm","normal","normal_id_glm","ordered_logistic","ordered_logistic_glm","ordered_probit","pareto","pareto_type_2","poisson","poisson_log","poisson_log_glm","rayleigh","scaled_inv_chi_square","skew_double_exponential","skew_normal","std_normal","std_normal_log","student_t","uniform","von_mises","weibull","wiener","wishart","wishart_cholesky"],l=e.COMMENT(/\/\*/,/\*\//,{relevance:0,contains:[{scope:"doctag",match:/@(return|param)/}]}),u={scope:"meta",begin:/#include\b/,end:/$/,contains:[{match:/[a-z][a-z-._]+/,scope:"string"},e.C_LINE_COMMENT_MODE]},d=["lower","upper","offset","multiplier"];return{name:"Stan",aliases:["stanfuncs"],keywords:{$pattern:e.IDENT_RE,title:n,type:a,keyword:i,built_in:s},contains:[e.C_LINE_COMMENT_MODE,u,e.HASH_COMMENT_MODE,l,{scope:"built_in",match:/\s(pi|e|sqrt2|log2|log10)(?=\()/,relevance:0},{match:r.concat(/[<,]\s*/,r.either(...d),/\s*=/),keywords:d},{scope:"keyword",match:/\btarget(?=\s*\+=)/},{match:[/~\s*/,r.either(...o),/(?:\(\))/,/\s*T(?=\s*\[)/],scope:{2:"built_in",4:"keyword"}},{scope:"built_in",keywords:o,begin:r.concat(/\w*/,r.either(...o),/(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/)},{begin:[/~/,/\s*/,r.concat(r.either(...o),/(?=\s*[\(.*\)])/)],scope:{3:"built_in"}},{begin:[/~/,/\s*\w+(?=\s*[\(.*\)])/,"(?!.*/\b("+r.either(...o)+")\b)"],scope:{2:"title.function"}},{scope:"title.function",begin:/\w*(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/},{scope:"number",match:r.concat(/(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)/,/(?:[eE][+-]?\d+(?:_\d+)*)?i?(?!\w)/),relevance:0},{scope:"string",begin:/"/,end:/"/}]}}return OW=t,OW}var IW,Ube;function Kxt(){if(Ube)return IW;Ube=1;function t(e){return{name:"Stata",aliases:["do","ado"],case_insensitive:!0,keywords:"if else in foreach for forv forva forval forvalu forvalue forvalues by bys bysort xi quietly qui capture about ac ac_7 acprplot acprplot_7 adjust ado adopath adoupdate alpha ameans an ano anov anova anova_estat anova_terms anovadef aorder ap app appe appen append arch arch_dr arch_estat arch_p archlm areg areg_p args arima arima_dr arima_estat arima_p as asmprobit asmprobit_estat asmprobit_lf asmprobit_mfx__dlg asmprobit_p ass asse asser assert avplot avplot_7 avplots avplots_7 bcskew0 bgodfrey bias binreg bip0_lf biplot bipp_lf bipr_lf bipr_p biprobit bitest bitesti bitowt blogit bmemsize boot bootsamp bootstrap bootstrap_8 boxco_l boxco_p boxcox boxcox_6 boxcox_p bprobit br break brier bro brow brows browse brr brrstat bs bs_7 bsampl_w bsample bsample_7 bsqreg bstat bstat_7 bstat_8 bstrap bstrap_7 bubble bubbleplot ca ca_estat ca_p cabiplot camat canon canon_8 canon_8_p canon_estat canon_p cap caprojection capt captu captur capture cat cc cchart cchart_7 cci cd censobs_table centile cf char chdir checkdlgfiles checkestimationsample checkhlpfiles checksum chelp ci cii cl class classutil clear cli clis clist clo clog clog_lf clog_p clogi clogi_sw clogit clogit_lf clogit_p clogitp clogl_sw cloglog clonevar clslistarray cluster cluster_measures cluster_stop cluster_tree cluster_tree_8 clustermat cmdlog cnr cnre cnreg cnreg_p cnreg_sw cnsreg codebook collaps4 collapse colormult_nb colormult_nw compare compress conf confi confir confirm conren cons const constr constra constrai constrain constraint continue contract copy copyright copysource cor corc corr corr2data corr_anti corr_kmo corr_smc corre correl correla correlat correlate corrgram cou coun count cox cox_p cox_sw coxbase coxhaz coxvar cprplot cprplot_7 crc cret cretu cretur creturn cross cs cscript cscript_log csi ct ct_is ctset ctst_5 ctst_st cttost cumsp cumsp_7 cumul cusum cusum_7 cutil d|0 datasig datasign datasigna datasignat datasignatu datasignatur datasignature datetof db dbeta de dec deco decod decode deff des desc descr descri describ describe destring dfbeta dfgls dfuller di di_g dir dirstats dis discard disp disp_res disp_s displ displa display distinct do doe doed doedi doedit dotplot dotplot_7 dprobit drawnorm drop ds ds_util dstdize duplicates durbina dwstat dydx e|0 ed edi edit egen eivreg emdef en enc enco encod encode eq erase ereg ereg_lf ereg_p ereg_sw ereghet ereghet_glf ereghet_glf_sh ereghet_gp ereghet_ilf ereghet_ilf_sh ereghet_ip eret eretu eretur ereturn err erro error esize est est_cfexist est_cfname est_clickable est_expand est_hold est_table est_unhold est_unholdok estat estat_default estat_summ estat_vce_only esti estimates etodow etof etomdy ex exi exit expand expandcl fac fact facto factor factor_estat factor_p factor_pca_rotated factor_rotate factormat fcast fcast_compute fcast_graph fdades fdadesc fdadescr fdadescri fdadescrib fdadescribe fdasav fdasave fdause fh_st file open file read file close file filefilter fillin find_hlp_file findfile findit findit_7 fit fl fli flis flist for5_0 forest forestplot form forma format fpredict frac_154 frac_adj frac_chk frac_cox frac_ddp frac_dis frac_dv frac_in frac_mun frac_pp frac_pq frac_pv frac_wgt frac_xo fracgen fracplot fracplot_7 fracpoly fracpred fron_ex fron_hn fron_p fron_tn fron_tn2 frontier ftodate ftoe ftomdy ftowdate funnel funnelplot g|0 gamhet_glf gamhet_gp gamhet_ilf gamhet_ip gamma gamma_d2 gamma_p gamma_sw gammahet gdi_hexagon gdi_spokes ge gen gene gener genera generat generate genrank genstd genvmean gettoken gl gladder gladder_7 glim_l01 glim_l02 glim_l03 glim_l04 glim_l05 glim_l06 glim_l07 glim_l08 glim_l09 glim_l10 glim_l11 glim_l12 glim_lf glim_mu glim_nw1 glim_nw2 glim_nw3 glim_p glim_v1 glim_v2 glim_v3 glim_v4 glim_v5 glim_v6 glim_v7 glm glm_6 glm_p glm_sw glmpred glo glob globa global glogit glogit_8 glogit_p gmeans gnbre_lf gnbreg gnbreg_5 gnbreg_p gomp_lf gompe_sw gomper_p gompertz gompertzhet gomphet_glf gomphet_glf_sh gomphet_gp gomphet_ilf gomphet_ilf_sh gomphet_ip gphdot gphpen gphprint gprefs gprobi_p gprobit gprobit_8 gr gr7 gr_copy gr_current gr_db gr_describe gr_dir gr_draw gr_draw_replay gr_drop gr_edit gr_editviewopts gr_example gr_example2 gr_export gr_print gr_qscheme gr_query gr_read gr_rename gr_replay gr_save gr_set gr_setscheme gr_table gr_undo gr_use graph graph7 grebar greigen greigen_7 greigen_8 grmeanby grmeanby_7 gs_fileinfo gs_filetype gs_graphinfo gs_stat gsort gwood h|0 hadimvo hareg hausman haver he heck_d2 heckma_p heckman heckp_lf heckpr_p heckprob hel help hereg hetpr_lf hetpr_p hetprob hettest hexdump hilite hist hist_7 histogram hlogit hlu hmeans hotel hotelling hprobit hreg hsearch icd9 icd9_ff icd9p iis impute imtest inbase include inf infi infil infile infix inp inpu input ins insheet insp inspe inspec inspect integ inten intreg intreg_7 intreg_p intrg2_ll intrg_ll intrg_ll2 ipolate iqreg ir irf irf_create irfm iri is_svy is_svysum isid istdize ivprob_1_lf ivprob_lf ivprobit ivprobit_p ivreg ivreg_footnote ivtob_1_lf ivtob_lf ivtobit ivtobit_p jackknife jacknife jknife jknife_6 jknife_8 jkstat joinby kalarma1 kap kap_3 kapmeier kappa kapwgt kdensity kdensity_7 keep ksm ksmirnov ktau kwallis l|0 la lab labbe labbeplot labe label labelbook ladder levels levelsof leverage lfit lfit_p li lincom line linktest lis list lloghet_glf lloghet_glf_sh lloghet_gp lloghet_ilf lloghet_ilf_sh lloghet_ip llogi_sw llogis_p llogist llogistic llogistichet lnorm_lf lnorm_sw lnorma_p lnormal lnormalhet lnormhet_glf lnormhet_glf_sh lnormhet_gp lnormhet_ilf lnormhet_ilf_sh lnormhet_ip lnskew0 loadingplot loc loca local log logi logis_lf logistic logistic_p logit logit_estat logit_p loglogs logrank loneway lookfor lookup lowess lowess_7 lpredict lrecomp lroc lroc_7 lrtest ls lsens lsens_7 lsens_x lstat ltable ltable_7 ltriang lv lvr2plot lvr2plot_7 m|0 ma mac macr macro makecns man manova manova_estat manova_p manovatest mantel mark markin markout marksample mat mat_capp mat_order mat_put_rr mat_rapp mata mata_clear mata_describe mata_drop mata_matdescribe mata_matsave mata_matuse mata_memory mata_mlib mata_mosave mata_rename mata_which matalabel matcproc matlist matname matr matri matrix matrix_input__dlg matstrik mcc mcci md0_ md1_ md1debug_ md2_ md2debug_ mds mds_estat mds_p mdsconfig mdslong mdsmat mdsshepard mdytoe mdytof me_derd mean means median memory memsize menl meqparse mer merg merge meta mfp mfx mhelp mhodds minbound mixed_ll mixed_ll_reparm mkassert mkdir mkmat mkspline ml ml_5 ml_adjs ml_bhhhs ml_c_d ml_check ml_clear ml_cnt ml_debug ml_defd ml_e0 ml_e0_bfgs ml_e0_cycle ml_e0_dfp ml_e0i ml_e1 ml_e1_bfgs ml_e1_bhhh ml_e1_cycle ml_e1_dfp ml_e2 ml_e2_cycle ml_ebfg0 ml_ebfr0 ml_ebfr1 ml_ebh0q ml_ebhh0 ml_ebhr0 ml_ebr0i ml_ecr0i ml_edfp0 ml_edfr0 ml_edfr1 ml_edr0i ml_eds ml_eer0i ml_egr0i ml_elf ml_elf_bfgs ml_elf_bhhh ml_elf_cycle ml_elf_dfp ml_elfi ml_elfs ml_enr0i ml_enrr0 ml_erdu0 ml_erdu0_bfgs ml_erdu0_bhhh ml_erdu0_bhhhq ml_erdu0_cycle ml_erdu0_dfp ml_erdu0_nrbfgs ml_exde ml_footnote ml_geqnr ml_grad0 ml_graph ml_hbhhh ml_hd0 ml_hold ml_init ml_inv ml_log ml_max ml_mlout ml_mlout_8 ml_model ml_nb0 ml_opt ml_p ml_plot ml_query ml_rdgrd ml_repor ml_s_e ml_score ml_searc ml_technique ml_unhold mleval mlf_ mlmatbysum mlmatsum mlog mlogi mlogit mlogit_footnote mlogit_p mlopts mlsum mlvecsum mnl0_ mor more mov move mprobit mprobit_lf mprobit_p mrdu0_ mrdu1_ mvdecode mvencode mvreg mvreg_estat n|0 nbreg nbreg_al nbreg_lf nbreg_p nbreg_sw nestreg net newey newey_7 newey_p news nl nl_7 nl_9 nl_9_p nl_p nl_p_7 nlcom nlcom_p nlexp2 nlexp2_7 nlexp2a nlexp2a_7 nlexp3 nlexp3_7 nlgom3 nlgom3_7 nlgom4 nlgom4_7 nlinit nllog3 nllog3_7 nllog4 nllog4_7 nlog_rd nlogit nlogit_p nlogitgen nlogittree nlpred no nobreak noi nois noisi noisil noisily note notes notes_dlg nptrend numlabel numlist odbc old_ver olo olog ologi ologi_sw ologit ologit_p ologitp on one onew onewa oneway op_colnm op_comp op_diff op_inv op_str opr opro oprob oprob_sw oprobi oprobi_p oprobit oprobitp opts_exclusive order orthog orthpoly ou out outf outfi outfil outfile outs outsh outshe outshee outsheet ovtest pac pac_7 palette parse parse_dissim pause pca pca_8 pca_display pca_estat pca_p pca_rotate pcamat pchart pchart_7 pchi pchi_7 pcorr pctile pentium pergram pergram_7 permute permute_8 personal peto_st pkcollapse pkcross pkequiv pkexamine pkexamine_7 pkshape pksumm pksumm_7 pl plo plot plugin pnorm pnorm_7 poisgof poiss_lf poiss_sw poisso_p poisson poisson_estat post postclose postfile postutil pperron pr prais prais_e prais_e2 prais_p predict predictnl preserve print pro prob probi probit probit_estat probit_p proc_time procoverlay procrustes procrustes_estat procrustes_p profiler prog progr progra program prop proportion prtest prtesti pwcorr pwd q\\s qby qbys qchi qchi_7 qladder qladder_7 qnorm qnorm_7 qqplot qqplot_7 qreg qreg_c qreg_p qreg_sw qu quadchk quantile quantile_7 que quer query range ranksum ratio rchart rchart_7 rcof recast reclink recode reg reg3 reg3_p regdw regr regre regre_p2 regres regres_p regress regress_estat regriv_p remap ren rena renam rename renpfix repeat replace report reshape restore ret retu retur return rm rmdir robvar roccomp roccomp_7 roccomp_8 rocf_lf rocfit rocfit_8 rocgold rocplot rocplot_7 roctab roctab_7 rolling rologit rologit_p rot rota rotat rotate rotatemat rreg rreg_p ru run runtest rvfplot rvfplot_7 rvpplot rvpplot_7 sa safesum sample sampsi sav save savedresults saveold sc sca scal scala scalar scatter scm_mine sco scob_lf scob_p scobi_sw scobit scor score scoreplot scoreplot_help scree screeplot screeplot_help sdtest sdtesti se search separate seperate serrbar serrbar_7 serset set set_defaults sfrancia sh she shel shell shewhart shewhart_7 signestimationsample signrank signtest simul simul_7 simulate simulate_8 sktest sleep slogit slogit_d2 slogit_p smooth snapspan so sor sort spearman spikeplot spikeplot_7 spikeplt spline_x split sqreg sqreg_p sret sretu sretur sreturn ssc st st_ct st_hc st_hcd st_hcd_sh st_is st_issys st_note st_promo st_set st_show st_smpl st_subid stack statsby statsby_8 stbase stci stci_7 stcox stcox_estat stcox_fr stcox_fr_ll stcox_p stcox_sw stcoxkm stcoxkm_7 stcstat stcurv stcurve stcurve_7 stdes stem stepwise stereg stfill stgen stir stjoin stmc stmh stphplot stphplot_7 stphtest stphtest_7 stptime strate strate_7 streg streg_sw streset sts sts_7 stset stsplit stsum sttocc sttoct stvary stweib su suest suest_8 sum summ summa summar summari summariz summarize sunflower sureg survcurv survsum svar svar_p svmat svy svy_disp svy_dreg svy_est svy_est_7 svy_estat svy_get svy_gnbreg_p svy_head svy_header svy_heckman_p svy_heckprob_p svy_intreg_p svy_ivreg_p svy_logistic_p svy_logit_p svy_mlogit_p svy_nbreg_p svy_ologit_p svy_oprobit_p svy_poisson_p svy_probit_p svy_regress_p svy_sub svy_sub_7 svy_x svy_x_7 svy_x_p svydes svydes_8 svygen svygnbreg svyheckman svyheckprob svyintreg svyintreg_7 svyintrg svyivreg svylc svylog_p svylogit svymarkout svymarkout_8 svymean svymlog svymlogit svynbreg svyolog svyologit svyoprob svyoprobit svyopts svypois svypois_7 svypoisson svyprobit svyprobt svyprop svyprop_7 svyratio svyreg svyreg_p svyregress svyset svyset_7 svyset_8 svytab svytab_7 svytest svytotal sw sw_8 swcnreg swcox swereg swilk swlogis swlogit swologit swoprbt swpois swprobit swqreg swtobit swweib symmetry symmi symplot symplot_7 syntax sysdescribe sysdir sysuse szroeter ta tab tab1 tab2 tab_or tabd tabdi tabdis tabdisp tabi table tabodds tabodds_7 tabstat tabu tabul tabula tabulat tabulate te tempfile tempname tempvar tes test testnl testparm teststd tetrachoric time_it timer tis tob tobi tobit tobit_p tobit_sw token tokeni tokeniz tokenize tostring total translate translator transmap treat_ll treatr_p treatreg trim trimfill trnb_cons trnb_mean trpoiss_d2 trunc_ll truncr_p truncreg tsappend tset tsfill tsline tsline_ex tsreport tsrevar tsrline tsset tssmooth tsunab ttest ttesti tut_chk tut_wait tutorial tw tware_st two twoway twoway__fpfit_serset twoway__function_gen twoway__histogram_gen twoway__ipoint_serset twoway__ipoints_serset twoway__kdensity_gen twoway__lfit_serset twoway__normgen_gen twoway__pci_serset twoway__qfit_serset twoway__scatteri_serset twoway__sunflower_gen twoway_ksm_serset ty typ type typeof u|0 unab unabbrev unabcmd update us use uselabel var var_mkcompanion var_p varbasic varfcast vargranger varirf varirf_add varirf_cgraph varirf_create varirf_ctable varirf_describe varirf_dir varirf_drop varirf_erase varirf_graph varirf_ograph varirf_rename varirf_set varirf_table varlist varlmar varnorm varsoc varstable varstable_w varstable_w2 varwle vce vec vec_fevd vec_mkphi vec_p vec_p_w vecirf_create veclmar veclmar_w vecnorm vecnorm_w vecrank vecstable verinst vers versi versio version view viewsource vif vwls wdatetof webdescribe webseek webuse weib1_lf weib2_lf weib_lf weib_lf0 weibhet_glf weibhet_glf_sh weibhet_glfa weibhet_glfa_sh weibhet_gp weibhet_ilf weibhet_ilf_sh weibhet_ilfa weibhet_ilfa_sh weibhet_ip weibu_sw weibul_p weibull weibull_c weibull_s weibullhet wh whelp whi which whil while wilc_st wilcoxon win wind windo window winexec wntestb wntestb_7 wntestq xchart xchart_7 xcorr xcorr_7 xi xi_6 xmlsav xmlsave xmluse xpose xsh xshe xshel xshell xt_iis xt_tis xtab_p xtabond xtbin_p xtclog xtcloglog xtcloglog_8 xtcloglog_d2 xtcloglog_pa_p xtcloglog_re_p xtcnt_p xtcorr xtdata xtdes xtfront_p xtfrontier xtgee xtgee_elink xtgee_estat xtgee_makeivar xtgee_p xtgee_plink xtgls xtgls_p xthaus xthausman xtht_p xthtaylor xtile xtint_p xtintreg xtintreg_8 xtintreg_d2 xtintreg_p xtivp_1 xtivp_2 xtivreg xtline xtline_ex xtlogit xtlogit_8 xtlogit_d2 xtlogit_fe_p xtlogit_pa_p xtlogit_re_p xtmixed xtmixed_estat xtmixed_p xtnb_fe xtnb_lf xtnbreg xtnbreg_pa_p xtnbreg_refe_p xtpcse xtpcse_p xtpois xtpoisson xtpoisson_d2 xtpoisson_pa_p xtpoisson_refe_p xtpred xtprobit xtprobit_8 xtprobit_d2 xtprobit_re_p xtps_fe xtps_lf xtps_ren xtps_ren_8 xtrar_p xtrc xtrc_p xtrchh xtrefe_p xtreg xtreg_be xtreg_fe xtreg_ml xtreg_pa_p xtreg_re xtregar xtrere_p xtset xtsf_ll xtsf_llti xtsum xttab xttest0 xttobit xttobit_8 xttobit_p xttrans yx yxview__barlike_draw yxview_area_draw yxview_bar_draw yxview_dot_draw yxview_dropline_draw yxview_function_draw yxview_iarrow_draw yxview_ilabels_draw yxview_normal_draw yxview_pcarrow_draw yxview_pcbarrow_draw yxview_pccapsym_draw yxview_pcscatter_draw yxview_pcspike_draw yxview_rarea_draw yxview_rbar_draw yxview_rbarm_draw yxview_rcap_draw yxview_rcapsym_draw yxview_rconnected_draw yxview_rline_draw yxview_rscatter_draw yxview_rspike_draw yxview_spike_draw yxview_sunflower_draw zap_s zinb zinb_llf zinb_plf zip zip_llf zip_p zip_plf zt_ct_5 zt_hc_5 zt_hcd_5 zt_is_5 zt_iss_5 zt_sho_5 zt_smp_5 ztbase_5 ztcox_5 ztdes_5 ztereg_5 ztfill_5 ztgen_5 ztir_5 ztjoin_5 ztnb ztnb_p ztp ztp_p zts_5 ztset_5 ztspli_5 ztsum_5 zttoct_5 ztvary_5 ztweib_5",contains:[{className:"symbol",begin:/`[a-zA-Z0-9_]+'/},{className:"variable",begin:/\$\{?[a-zA-Z0-9_]+\}?/,relevance:0},{className:"string",variants:[{begin:`\`"[^\r +]*?"'`},{begin:`"[^\r +"]*"`}]},{className:"built_in",variants:[{begin:"\\b(abs|acos|asin|atan|atan2|atanh|ceil|cloglog|comb|cos|digamma|exp|floor|invcloglog|invlogit|ln|lnfact|lnfactorial|lngamma|log|log10|max|min|mod|reldif|round|sign|sin|sqrt|sum|tan|tanh|trigamma|trunc|betaden|Binomial|binorm|binormal|chi2|chi2tail|dgammapda|dgammapdada|dgammapdadx|dgammapdx|dgammapdxdx|F|Fden|Ftail|gammaden|gammap|ibeta|invbinomial|invchi2|invchi2tail|invF|invFtail|invgammap|invibeta|invnchi2|invnFtail|invnibeta|invnorm|invnormal|invttail|nbetaden|nchi2|nFden|nFtail|nibeta|norm|normal|normalden|normd|npnchi2|tden|ttail|uniform|abbrev|char|index|indexnot|length|lower|ltrim|match|plural|proper|real|regexm|regexr|regexs|reverse|rtrim|string|strlen|strlower|strltrim|strmatch|strofreal|strpos|strproper|strreverse|strrtrim|strtrim|strupper|subinstr|subinword|substr|trim|upper|word|wordcount|_caller|autocode|byteorder|chop|clip|cond|e|epsdouble|epsfloat|group|inlist|inrange|irecode|matrix|maxbyte|maxdouble|maxfloat|maxint|maxlong|mi|minbyte|mindouble|minfloat|minint|minlong|missing|r|recode|replay|return|s|scalar|d|date|day|dow|doy|halfyear|mdy|month|quarter|week|year|d|daily|dofd|dofh|dofm|dofq|dofw|dofy|h|halfyearly|hofd|m|mofd|monthly|q|qofd|quarterly|tin|twithin|w|weekly|wofd|y|yearly|yh|ym|yofd|yq|yw|cholesky|colnumb|colsof|corr|det|diag|diag0cnt|el|get|hadamard|I|inv|invsym|issym|issymmetric|J|matmissing|matuniform|mreldif|nullmat|rownumb|rowsof|sweep|syminv|trace|vec|vecdiag)(?=\\()"}]},e.COMMENT("^[ ]*\\*.*$",!1),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]}}return IW=t,IW}var kW,$be;function jxt(){if($be)return kW;$be=1;function t(e){return{name:"STEP Part 21",aliases:["p21","step","stp"],case_insensitive:!0,keywords:{$pattern:"[A-Z_][A-Z0-9_.]*",keyword:["HEADER","ENDSEC","DATA"]},contains:[{className:"meta",begin:"ISO-10303-21;",relevance:10},{className:"meta",begin:"END-ISO-10303-21;",relevance:10},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT("/\\*\\*!","\\*/"),e.C_NUMBER_MODE,e.inherit(e.APOS_STRING_MODE,{illegal:null}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),{className:"string",begin:"'",end:"'"},{className:"symbol",variants:[{begin:"#",end:"\\d+",illegal:"\\W"}]}]}}return kW=t,kW}var DW,Gbe;function Xxt(){if(Gbe)return DW;Gbe=1;const t=u=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:u.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:u.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z_][A-Za-z0-9_-]*/}}),e=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","optgroup","option","p","picture","q","quote","samp","section","select","source","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],r=["defs","g","marker","mask","pattern","svg","switch","symbol","feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feFlood","feGaussianBlur","feImage","feMerge","feMorphology","feOffset","feSpecularLighting","feTile","feTurbulence","linearGradient","radialGradient","stop","circle","ellipse","image","line","path","polygon","polyline","rect","text","use","textPath","tspan","foreignObject","clipPath"],n=[...e,...r],i=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"].sort().reverse(),a=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"].sort().reverse(),s=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),o=["accent-color","align-content","align-items","align-self","alignment-baseline","all","anchor-name","animation","animation-composition","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-range","animation-range-end","animation-range-start","animation-timeline","animation-timing-function","appearance","aspect-ratio","backdrop-filter","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-position-x","background-position-y","background-repeat","background-size","baseline-shift","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-end-end-radius","border-end-start-radius","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-start-end-radius","border-start-start-radius","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-align","box-decoration-break","box-direction","box-flex","box-flex-group","box-lines","box-ordinal-group","box-orient","box-pack","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","color-scheme","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","contain-intrinsic-block-size","contain-intrinsic-height","contain-intrinsic-inline-size","contain-intrinsic-size","contain-intrinsic-width","container","container-name","container-type","content","content-visibility","counter-increment","counter-reset","counter-set","cue","cue-after","cue-before","cursor","cx","cy","direction","display","dominant-baseline","empty-cells","enable-background","field-sizing","fill","fill-opacity","fill-rule","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flood-color","flood-opacity","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-optical-sizing","font-palette","font-size","font-size-adjust","font-smooth","font-smoothing","font-stretch","font-style","font-synthesis","font-synthesis-position","font-synthesis-small-caps","font-synthesis-style","font-synthesis-weight","font-variant","font-variant-alternates","font-variant-caps","font-variant-east-asian","font-variant-emoji","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","forced-color-adjust","gap","glyph-orientation-horizontal","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphenate-character","hyphenate-limit-chars","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","initial-letter","initial-letter-align","inline-size","inset","inset-area","inset-block","inset-block-end","inset-block-start","inset-inline","inset-inline-end","inset-inline-start","isolation","justify-content","justify-items","justify-self","kerning","left","letter-spacing","lighting-color","line-break","line-height","line-height-step","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","margin-trim","marker","marker-end","marker-mid","marker-start","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","masonry-auto-flow","math-depth","math-shift","math-style","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","offset","offset-anchor","offset-distance","offset-path","offset-position","offset-rotate","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-anchor","overflow-block","overflow-clip-margin","overflow-inline","overflow-wrap","overflow-x","overflow-y","overlay","overscroll-behavior","overscroll-behavior-block","overscroll-behavior-inline","overscroll-behavior-x","overscroll-behavior-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page","page-break-after","page-break-before","page-break-inside","paint-order","pause","pause-after","pause-before","perspective","perspective-origin","place-content","place-items","place-self","pointer-events","position","position-anchor","position-visibility","print-color-adjust","quotes","r","resize","rest","rest-after","rest-before","right","rotate","row-gap","ruby-align","ruby-position","scale","scroll-behavior","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scroll-timeline","scroll-timeline-axis","scroll-timeline-name","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","shape-rendering","speak","speak-as","src","stop-color","stop-opacity","stroke","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke-width","tab-size","table-layout","text-align","text-align-all","text-align-last","text-anchor","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-skip","text-decoration-skip-ink","text-decoration-style","text-decoration-thickness","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-size-adjust","text-transform","text-underline-offset","text-underline-position","text-wrap","text-wrap-mode","text-wrap-style","timeline-scope","top","touch-action","transform","transform-box","transform-origin","transform-style","transition","transition-behavior","transition-delay","transition-duration","transition-property","transition-timing-function","translate","unicode-bidi","user-modify","user-select","vector-effect","vertical-align","view-timeline","view-timeline-axis","view-timeline-inset","view-timeline-name","view-transition-name","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","white-space-collapse","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","x","y","z-index","zoom"].sort().reverse();function l(u){const d=t(u),h="and or not only",f={className:"variable",begin:"\\$"+u.IDENT_RE},p=["charset","css","debug","extend","font-face","for","import","include","keyframes","media","mixin","page","warn","while"],g="(?=[.\\s\\n[:,(])";return{name:"Stylus",aliases:["styl"],case_insensitive:!1,keywords:"if else for in",illegal:"("+["\\?","(\\bReturn\\b)","(\\bEnd\\b)","(\\bend\\b)","(\\bdef\\b)",";","#\\s","\\*\\s","===\\s","\\|","%"].join("|")+")",contains:[u.QUOTE_STRING_MODE,u.APOS_STRING_MODE,u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,d.HEXCOLOR,{begin:"\\.[a-zA-Z][a-zA-Z0-9_-]*"+g,className:"selector-class"},{begin:"#[a-zA-Z][a-zA-Z0-9_-]*"+g,className:"selector-id"},{begin:"\\b("+n.join("|")+")"+g,className:"selector-tag"},{className:"selector-pseudo",begin:"&?:("+a.join("|")+")"+g},{className:"selector-pseudo",begin:"&?:(:)?("+s.join("|")+")"+g},d.ATTRIBUTE_SELECTOR_MODE,{className:"keyword",begin:/@media/,starts:{end:/[{;}]/,keywords:{$pattern:/[a-z-]+/,keyword:h,attribute:i.join(" ")},contains:[d.CSS_NUMBER_MODE]}},{className:"keyword",begin:"@((-(o|moz|ms|webkit)-)?("+p.join("|")+"))\\b"},f,d.CSS_NUMBER_MODE,{className:"function",begin:"^[a-zA-Z][a-zA-Z0-9_-]*\\(.*\\)",illegal:"[\\n]",returnBegin:!0,contains:[{className:"title",begin:"\\b[a-zA-Z][a-zA-Z0-9_-]*"},{className:"params",begin:/\(/,end:/\)/,contains:[d.HEXCOLOR,f,u.APOS_STRING_MODE,d.CSS_NUMBER_MODE,u.QUOTE_STRING_MODE]}]},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b",starts:{end:/;|$/,contains:[d.HEXCOLOR,f,u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,d.CSS_NUMBER_MODE,u.C_BLOCK_COMMENT_MODE,d.IMPORTANT,d.FUNCTION_DISPATCH],illegal:/\./,relevance:0}},d.FUNCTION_DISPATCH]}}return DW=l,DW}var MW,zbe;function Qxt(){if(zbe)return MW;zbe=1;function t(e){return{name:"SubUnit",case_insensitive:!0,contains:[{className:"string",begin:`\\[ +(multipart)?`,end:`\\] +`},{className:"string",begin:"\\d{4}-\\d{2}-\\d{2}(\\s+)\\d{2}:\\d{2}:\\d{2}.\\d+Z"},{className:"string",begin:"(\\+|-)\\d+"},{className:"keyword",relevance:10,variants:[{begin:"^(test|testing|success|successful|failure|error|skip|xfail|uxsuccess)(:?)\\s+(test)?"},{begin:"^progress(:?)(\\s+)?(pop|push)?"},{begin:"^tags:"},{begin:"^time:"}]}]}}return MW=t,MW}var LW,qbe;function Zxt(){if(qbe)return LW;qbe=1;function t(x){return x?typeof x=="string"?x:x.source:null}function e(x){return r("(?=",x,")")}function r(...x){return x.map(R=>t(R)).join("")}function n(x){const A=x[x.length-1];return typeof A=="object"&&A.constructor===Object?(x.splice(x.length-1,1),A):{}}function i(...x){return"("+(n(x).capture?"":"?:")+x.map(O=>t(O)).join("|")+")"}const a=x=>r(/\b/,x,/\w$/.test(x)?/\b/:/\B/),s=["Protocol","Type"].map(a),o=["init","self"].map(a),l=["Any","Self"],u=["actor","any","associatedtype","async","await",/as\?/,/as!/,"as","borrowing","break","case","catch","class","consume","consuming","continue","convenience","copy","default","defer","deinit","didSet","distributed","do","dynamic","each","else","enum","extension","fallthrough",/fileprivate\(set\)/,"fileprivate","final","for","func","get","guard","if","import","indirect","infix",/init\?/,/init!/,"inout",/internal\(set\)/,"internal","in","is","isolated","nonisolated","lazy","let","macro","mutating","nonmutating",/open\(set\)/,"open","operator","optional","override","package","postfix","precedencegroup","prefix",/private\(set\)/,"private","protocol",/public\(set\)/,"public","repeat","required","rethrows","return","set","some","static","struct","subscript","super","switch","throws","throw",/try\?/,/try!/,"try","typealias",/unowned\(safe\)/,/unowned\(unsafe\)/,"unowned","var","weak","where","while","willSet"],d=["false","nil","true"],h=["assignment","associativity","higherThan","left","lowerThan","none","right"],f=["#colorLiteral","#column","#dsohandle","#else","#elseif","#endif","#error","#file","#fileID","#fileLiteral","#filePath","#function","#if","#imageLiteral","#keyPath","#line","#selector","#sourceLocation","#warning"],p=["abs","all","any","assert","assertionFailure","debugPrint","dump","fatalError","getVaList","isKnownUniquelyReferenced","max","min","numericCast","pointwiseMax","pointwiseMin","precondition","preconditionFailure","print","readLine","repeatElement","sequence","stride","swap","swift_unboxFromSwiftValueWithType","transcode","type","unsafeBitCast","unsafeDowncast","withExtendedLifetime","withUnsafeMutablePointer","withUnsafePointer","withVaList","withoutActuallyEscaping","zip"],g=i(/[/=\-+!*%<>&|^~?]/,/[\u00A1-\u00A7]/,/[\u00A9\u00AB]/,/[\u00AC\u00AE]/,/[\u00B0\u00B1]/,/[\u00B6\u00BB\u00BF\u00D7\u00F7]/,/[\u2016-\u2017]/,/[\u2020-\u2027]/,/[\u2030-\u203E]/,/[\u2041-\u2053]/,/[\u2055-\u205E]/,/[\u2190-\u23FF]/,/[\u2500-\u2775]/,/[\u2794-\u2BFF]/,/[\u2E00-\u2E7F]/,/[\u3001-\u3003]/,/[\u3008-\u3020]/,/[\u3030]/),m=i(g,/[\u0300-\u036F]/,/[\u1DC0-\u1DFF]/,/[\u20D0-\u20FF]/,/[\uFE00-\uFE0F]/,/[\uFE20-\uFE2F]/),_=r(g,m,"*"),v=i(/[a-zA-Z_]/,/[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,/[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,/[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,/[\u1E00-\u1FFF]/,/[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,/[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,/[\u2C00-\u2DFF\u2E80-\u2FFF]/,/[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,/[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,/[\uFE47-\uFEFE\uFF00-\uFFFD]/),b=i(v,/\d/,/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),y=r(v,b,"*"),E=r(/[A-Z]/,b,"*"),T=["attached","autoclosure",r(/convention\(/,i("swift","block","c"),/\)/),"discardableResult","dynamicCallable","dynamicMemberLookup","escaping","freestanding","frozen","GKInspectable","IBAction","IBDesignable","IBInspectable","IBOutlet","IBSegueAction","inlinable","main","nonobjc","NSApplicationMain","NSCopying","NSManaged",r(/objc\(/,y,/\)/),"objc","objcMembers","propertyWrapper","requires_stored_property_inits","resultBuilder","Sendable","testable","UIApplicationMain","unchecked","unknown","usableFromInline","warn_unqualified_access"],C=["iOS","iOSApplicationExtension","macOS","macOSApplicationExtension","macCatalyst","macCatalystApplicationExtension","watchOS","watchOSApplicationExtension","tvOS","tvOSApplicationExtension","swift"];function w(x){const A={match:/\s+/,relevance:0},R=x.COMMENT("/\\*","\\*/",{contains:["self"]}),O=[x.C_LINE_COMMENT_MODE,R],F={match:[/\./,i(...s,...o)],className:{2:"keyword"}},P={match:r(/\./,i(...u)),relevance:0},N=u.filter(Be=>typeof Be=="string").concat(["_|0"]),k=u.filter(Be=>typeof Be!="string").concat(l).map(a),M={variants:[{className:"keyword",match:i(...k,...o)}]},L={$pattern:i(/\b\w+/,/#\w+/),keyword:N.concat(f),literal:d},I=[F,P,M],U={match:r(/\./,i(...p)),relevance:0},B={className:"built_in",match:r(/\b/,i(...p),/(?=\()/)},$=[U,B],H={match:/->/,relevance:0},q={className:"operator",relevance:0,variants:[{match:_},{match:`\\.(\\.|${m})+`}]},V=[H,q],Y="([0-9]_*)+",j="([0-9a-fA-F]_*)+",Q={className:"number",relevance:0,variants:[{match:`\\b(${Y})(\\.(${Y}))?([eE][+-]?(${Y}))?\\b`},{match:`\\b0x(${j})(\\.(${j}))?([pP][+-]?(${Y}))?\\b`},{match:/\b0o([0-7]_*)+\b/},{match:/\b0b([01]_*)+\b/}]},ae=(Be="")=>({className:"subst",variants:[{match:r(/\\/,Be,/[0\\tnr"']/)},{match:r(/\\/,Be,/u\{[0-9a-fA-F]{1,8}\}/)}]}),re=(Be="")=>({className:"subst",match:r(/\\/,Be,/[\t ]*(?:[\r\n]|\r\n)/)}),ne=(Be="")=>({className:"subst",label:"interpol",begin:r(/\\/,Be,/\(/),end:/\)/}),ee=(Be="")=>({begin:r(Be,/"""/),end:r(/"""/,Be),contains:[ae(Be),re(Be),ne(Be)]}),J=(Be="")=>({begin:r(Be,/"/),end:r(/"/,Be),contains:[ae(Be),ne(Be)]}),fe={className:"string",variants:[ee(),ee("#"),ee("##"),ee("###"),J(),J("#"),J("##"),J("###")]},ue=[x.BACKSLASH_ESCAPE,{begin:/\[/,end:/\]/,relevance:0,contains:[x.BACKSLASH_ESCAPE]}],ge={begin:/\/[^\s](?=[^/\n]*\/)/,end:/\//,contains:ue},ye=Be=>{const Je=r(Be,/\//),ht=r(/\//,Be);return{begin:Je,end:ht,contains:[...ue,{scope:"comment",begin:`#(?!.*${ht})`,end:/$/}]}},Ie={scope:"regexp",variants:[ye("###"),ye("##"),ye("#"),ge]},we={match:r(/`/,y,/`/)},Te={className:"variable",match:/\$\d+/},Ve={className:"variable",match:`\\$${b}+`},Ce=[we,Te,Ve],rt={match:/(@|#(un)?)available/,scope:"keyword",starts:{contains:[{begin:/\(/,end:/\)/,keywords:C,contains:[...V,Q,fe]}]}},Ne={scope:"keyword",match:r(/@/,i(...T),e(i(/\(/,/\s+/)))},et={scope:"meta",match:r(/@/,y)},ut=[rt,Ne,et],Pe={match:e(/\b[A-Z]/),relevance:0,contains:[{className:"type",match:r(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,b,"+")},{className:"type",match:E,relevance:0},{match:/[?!]+/,relevance:0},{match:/\.\.\./,relevance:0},{match:r(/\s+&\s+/,e(E)),relevance:0}]},qe={begin://,keywords:L,contains:[...O,...I,...ut,H,Pe]};Pe.contains.push(qe);const Ze={match:r(y,/\s*:/),keywords:"_|0",relevance:0},De={begin:/\(/,end:/\)/,relevance:0,keywords:L,contains:["self",Ze,...O,Ie,...I,...$,...V,Q,fe,...Ce,...ut,Pe]},Fe={begin://,keywords:"repeat each",contains:[...O,Pe]},de={begin:i(e(r(y,/\s*:/)),e(r(y,/\s+/,y,/\s*:/))),end:/:/,relevance:0,contains:[{className:"keyword",match:/\b_\b/},{className:"params",match:y}]},Ee={begin:/\(/,end:/\)/,keywords:L,contains:[de,...O,...I,...V,Q,fe,...ut,Pe,De],endsParent:!0,illegal:/["']/},he={match:[/(func|macro)/,/\s+/,i(we.match,y,_)],className:{1:"keyword",3:"title.function"},contains:[Fe,Ee,A],illegal:[/\[/,/%/]},Le={match:[/\b(?:subscript|init[?!]?)/,/\s*(?=[<(])/],className:{1:"keyword"},contains:[Fe,Ee,A],illegal:/\[|%/},_e={match:[/operator/,/\s+/,_],className:{1:"keyword",3:"title"}},He={begin:[/precedencegroup/,/\s+/,E],className:{1:"keyword",3:"title"},contains:[Pe],keywords:[...h,...d],end:/}/},Re={match:[/class\b/,/\s+/,/func\b/,/\s+/,/\b[A-Za-z_][A-Za-z0-9_]*\b/],scope:{1:"keyword",3:"keyword",5:"title.function"}},Xe={match:[/class\b/,/\s+/,/var\b/],scope:{1:"keyword",3:"keyword"}},je={begin:[/(struct|protocol|class|extension|enum|actor)/,/\s+/,y,/\s*/],beginScope:{1:"keyword",3:"title.class"},keywords:L,contains:[Fe,...I,{begin:/:/,end:/\{/,keywords:L,contains:[{scope:"title.class.inherited",match:E},...I],relevance:0}]};for(const Be of fe.variants){const Je=Be.contains.find(tt=>tt.label==="interpol");Je.keywords=L;const ht=[...I,...$,...V,Q,fe,...Ce];Je.contains=[...ht,{begin:/\(/,end:/\)/,contains:["self",...ht]}]}return{name:"Swift",keywords:L,contains:[...O,he,Le,Re,Xe,je,_e,He,{beginKeywords:"import",end:/$/,contains:[...O],relevance:0},Ie,...I,...$,...V,Q,fe,...Ce,...ut,Pe,De]}}return LW=w,LW}var PW,Hbe;function Jxt(){if(Hbe)return PW;Hbe=1;function t(e){return{name:"Tagger Script",contains:[{className:"comment",begin:/\$noop\(/,end:/\)/,contains:[{begin:/\\[()]/},{begin:/\(/,end:/\)/,contains:[{begin:/\\[()]/},"self"]}],relevance:10},{className:"keyword",begin:/\$[_a-zA-Z0-9]+(?=\()/},{className:"variable",begin:/%[_a-zA-Z0-9:]+%/},{className:"symbol",begin:/\\[\\nt$%,()]/},{className:"symbol",begin:/\\u[a-fA-F0-9]{4}/}]}}return PW=t,PW}var FW,Vbe;function e4t(){if(Vbe)return FW;Vbe=1;function t(e){const r="true false yes no null",n="[\\w#;/?:@&=+$,.~*'()[\\]]+",i={className:"attr",variants:[{begin:/[\w*@][\w*@ :()\./-]*:(?=[ \t]|$)/},{begin:/"[\w*@][\w*@ :()\./-]*":(?=[ \t]|$)/},{begin:/'[\w*@][\w*@ :()\./-]*':(?=[ \t]|$)/}]},a={className:"template-variable",variants:[{begin:/\{\{/,end:/\}\}/},{begin:/%\{/,end:/\}/}]},s={className:"string",relevance:0,begin:/'/,end:/'/,contains:[{match:/''/,scope:"char.escape",relevance:0}]},o={className:"string",relevance:0,variants:[{begin:/"/,end:/"/},{begin:/\S+/}],contains:[e.BACKSLASH_ESCAPE,a]},l=e.inherit(o,{variants:[{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),p={className:"number",begin:"\\b"+"[0-9]{4}(-[0-9][0-9]){0,2}"+"([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?"+"(\\.[0-9]*)?"+"([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?"+"\\b"},g={end:",",endsWithParent:!0,excludeEnd:!0,keywords:r,relevance:0},m={begin:/\{/,end:/\}/,contains:[g],illegal:"\\n",relevance:0},_={begin:"\\[",end:"\\]",contains:[g],illegal:"\\n",relevance:0},v=[i,{className:"meta",begin:"^---\\s*$",relevance:10},{className:"string",begin:"[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"},{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:"!\\w+!"+n},{className:"type",begin:"!<"+n+">"},{className:"type",begin:"!"+n},{className:"type",begin:"!!"+n},{className:"meta",begin:"&"+e.UNDERSCORE_IDENT_RE+"$"},{className:"meta",begin:"\\*"+e.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",relevance:0},e.HASH_COMMENT_MODE,{beginKeywords:r,keywords:{literal:r}},p,{className:"number",begin:e.C_NUMBER_RE+"\\b",relevance:0},m,_,s,o],b=[...v];return b.pop(),b.push(l),g.contains=b,{name:"YAML",case_insensitive:!0,aliases:["yml"],contains:v}}return FW=t,FW}var BW,Ybe;function t4t(){if(Ybe)return BW;Ybe=1;function t(e){return{name:"Test Anything Protocol",case_insensitive:!0,contains:[e.HASH_COMMENT_MODE,{className:"meta",variants:[{begin:"^TAP version (\\d+)$"},{begin:"^1\\.\\.(\\d+)$"}]},{begin:/---$/,end:"\\.\\.\\.$",subLanguage:"yaml",relevance:0},{className:"number",begin:" (\\d+) "},{className:"symbol",variants:[{begin:"^ok"},{begin:"^not ok"}]}]}}return BW=t,BW}var UW,Wbe;function r4t(){if(Wbe)return UW;Wbe=1;function t(e){const r=e.regex,n=/[a-zA-Z_][a-zA-Z0-9_]*/,i={className:"number",variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]};return{name:"Tcl",aliases:["tk"],keywords:["after","append","apply","array","auto_execok","auto_import","auto_load","auto_mkindex","auto_mkindex_old","auto_qualify","auto_reset","bgerror","binary","break","catch","cd","chan","clock","close","concat","continue","dde","dict","encoding","eof","error","eval","exec","exit","expr","fblocked","fconfigure","fcopy","file","fileevent","filename","flush","for","foreach","format","gets","glob","global","history","http","if","incr","info","interp","join","lappend|10","lassign|10","lindex|10","linsert|10","list","llength|10","load","lrange|10","lrepeat|10","lreplace|10","lreverse|10","lsearch|10","lset|10","lsort|10","mathfunc","mathop","memory","msgcat","namespace","open","package","parray","pid","pkg::create","pkg_mkIndex","platform","platform::shell","proc","puts","pwd","read","refchan","regexp","registry","regsub|10","rename","return","safe","scan","seek","set","socket","source","split","string","subst","switch","tcl_endOfWord","tcl_findLibrary","tcl_startOfNextWord","tcl_startOfPreviousWord","tcl_wordBreakAfter","tcl_wordBreakBefore","tcltest","tclvars","tell","time","tm","trace","unknown","unload","unset","update","uplevel","upvar","variable","vwait","while"],contains:[e.COMMENT(";[ \\t]*#","$"),e.COMMENT("^[ \\t]*#","$"),{beginKeywords:"proc",end:"[\\{]",excludeEnd:!0,contains:[{className:"title",begin:"[ \\t\\n\\r]+(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",end:"[ \\t\\n\\r]",endsWithParent:!0,excludeEnd:!0}]},{className:"variable",variants:[{begin:r.concat(/\$/,r.optional(/::/),n,"(::",n,")*")},{begin:"\\$\\{(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",end:"\\}",contains:[i]}]},{className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[e.inherit(e.QUOTE_STRING_MODE,{illegal:null})]},i]}}return UW=t,UW}var $W,Kbe;function n4t(){if(Kbe)return $W;Kbe=1;function t(e){const r=["bool","byte","i16","i32","i64","double","string","binary"];return{name:"Thrift",keywords:{keyword:["namespace","const","typedef","struct","enum","service","exception","void","oneway","set","list","map","required","optional"],type:r,literal:"true false"},contains:[e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"class",beginKeywords:"struct enum service exception",end:/\{/,illegal:/\n/,contains:[e.inherit(e.TITLE_MODE,{starts:{endsWithParent:!0,excludeEnd:!0}})]},{begin:"\\b(set|list|map)\\s*<",keywords:{type:[...r,"set","list","map"]},end:">",contains:["self"]}]}}return $W=t,$W}var GW,jbe;function i4t(){if(jbe)return GW;jbe=1;function t(e){const r={className:"number",begin:"[1-9][0-9]*",relevance:0},n={className:"symbol",begin:":[^\\]]+"},i={className:"built_in",begin:"(AR|P|PAYLOAD|PR|R|SR|RSR|LBL|VR|UALM|MESSAGE|UTOOL|UFRAME|TIMER|TIMER_OVERFLOW|JOINT_MAX_SPEED|RESUME_PROG|DIAG_REC)\\[",end:"\\]",contains:["self",r,n]},a={className:"built_in",begin:"(AI|AO|DI|DO|F|RI|RO|UI|UO|GI|GO|SI|SO)\\[",end:"\\]",contains:["self",r,e.QUOTE_STRING_MODE,n]};return{name:"TP",keywords:{keyword:["ABORT","ACC","ADJUST","AND","AP_LD","BREAK","CALL","CNT","COL","CONDITION","CONFIG","DA","DB","DIV","DETECT","ELSE","END","ENDFOR","ERR_NUM","ERROR_PROG","FINE","FOR","GP","GUARD","INC","IF","JMP","LINEAR_MAX_SPEED","LOCK","MOD","MONITOR","OFFSET","Offset","OR","OVERRIDE","PAUSE","PREG","PTH","RT_LD","RUN","SELECT","SKIP","Skip","TA","TB","TO","TOOL_OFFSET","Tool_Offset","UF","UT","UFRAME_NUM","UTOOL_NUM","UNLOCK","WAIT","X","Y","Z","W","P","R","STRLEN","SUBSTR","FINDSTR","VOFFSET","PROG","ATTR","MN","POS"],literal:["ON","OFF","max_speed","LPOS","JPOS","ENABLE","DISABLE","START","STOP","RESET"]},contains:[i,a,{className:"keyword",begin:"/(PROG|ATTR|MN|POS|END)\\b"},{className:"keyword",begin:"(CALL|RUN|POINT_LOGIC|LBL)\\b"},{className:"keyword",begin:"\\b(ACC|CNT|Skip|Offset|PSPD|RT_LD|AP_LD|Tool_Offset)"},{className:"number",begin:"\\d+(sec|msec|mm/sec|cm/min|inch/min|deg/sec|mm|in|cm)?\\b",relevance:0},e.COMMENT("//","[;$]"),e.COMMENT("!","[;$]"),e.COMMENT("--eg:","$"),e.QUOTE_STRING_MODE,{className:"string",begin:"'",end:"'"},e.C_NUMBER_MODE,{className:"variable",begin:"\\$[A-Za-z0-9_]+"}]}}return GW=t,GW}var zW,Xbe;function a4t(){if(Xbe)return zW;Xbe=1;function t(e){const r=e.regex,n=["absolute_url","asset|0","asset_version","attribute","block","constant","controller|0","country_timezones","csrf_token","cycle","date","dump","expression","form|0","form_end","form_errors","form_help","form_label","form_rest","form_row","form_start","form_widget","html_classes","include","is_granted","logout_path","logout_url","max","min","parent","path|0","random","range","relative_path","render","render_esi","source","template_from_string","url|0"],i=["abs","abbr_class","abbr_method","batch","capitalize","column","convert_encoding","country_name","currency_name","currency_symbol","data_uri","date","date_modify","default","escape","file_excerpt","file_link","file_relative","filter","first","format","format_args","format_args_as_text","format_currency","format_date","format_datetime","format_file","format_file_from_text","format_number","format_time","html_to_markdown","humanize","inky_to_html","inline_css","join","json_encode","keys","language_name","last","length","locale_name","lower","map","markdown","markdown_to_html","merge","nl2br","number_format","raw","reduce","replace","reverse","round","slice","slug","sort","spaceless","split","striptags","timezone_name","title","trans","transchoice","trim","u|0","upper","url_encode","yaml_dump","yaml_encode"];let a=["apply","autoescape","block","cache","deprecated","do","embed","extends","filter","flush","for","form_theme","from","if","import","include","macro","sandbox","set","stopwatch","trans","trans_default_domain","transchoice","use","verbatim","with"];a=a.concat(a.map(m=>`end${m}`));const s={scope:"string",variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]},o={scope:"number",match:/\d+/},l={begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:[s,o]},u={beginKeywords:n.join(" "),keywords:{name:n},relevance:0,contains:[l]},d={match:/\|(?=[A-Za-z_]+:?)/,beginScope:"punctuation",relevance:0,contains:[{match:/[A-Za-z_]+:?/,keywords:i}]},h=(m,{relevance:_})=>({beginScope:{1:"template-tag",3:"name"},relevance:_||2,endScope:"template-tag",begin:[/\{%/,/\s*/,r.either(...m)],end:/%\}/,keywords:"in",contains:[d,u,s,o]}),f=/[a-z_]+/,p=h(a,{relevance:2}),g=h([f],{relevance:1});return{name:"Twig",aliases:["craftcms"],case_insensitive:!0,subLanguage:"xml",contains:[e.COMMENT(/\{#/,/#\}/),p,g,{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:["self",d,u,s,o]}]}}return zW=t,zW}var qW,Qbe;function s4t(){if(Qbe)return qW;Qbe=1;const t="[A-Za-z$_][0-9A-Za-z$_]*",e=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends","using"],r=["true","false","null","undefined","NaN","Infinity"],n=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],i=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],a=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],s=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],o=[].concat(a,n,i);function l(d){const h=d.regex,f=(ae,{after:re})=>{const ne="",end:""},m=/<[A-Za-z0-9\\._:-]+\s*\/>/,_={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(ae,re)=>{const ne=ae[0].length+ae.index,ee=ae.input[ne];if(ee==="<"||ee===","){re.ignoreMatch();return}ee===">"&&(f(ae,{after:ne})||re.ignoreMatch());let J;const fe=ae.input.substring(ne);if(J=fe.match(/^\s*=/)){re.ignoreMatch();return}if((J=fe.match(/^\s+extends\s+/))&&J.index===0){re.ignoreMatch();return}}},v={$pattern:t,keyword:e,literal:r,built_in:o,"variable.language":s},b="[0-9](_?[0-9])*",y=`\\.(${b})`,E="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",T={className:"number",variants:[{begin:`(\\b(${E})((${y})|\\.)?|(${y}))[eE][+-]?(${b})\\b`},{begin:`\\b(${E})\\b((${y})\\b|\\.)?|(${y})\\b`},{begin:"\\b(0|[1-9](_?[0-9])*)n\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*n?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*n?\\b"},{begin:"\\b0[0-7]+n?\\b"}],relevance:0},C={className:"subst",begin:"\\$\\{",end:"\\}",keywords:v,contains:[]},w={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[d.BACKSLASH_ESCAPE,C],subLanguage:"xml"}},x={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[d.BACKSLASH_ESCAPE,C],subLanguage:"css"}},A={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[d.BACKSLASH_ESCAPE,C],subLanguage:"graphql"}},R={className:"string",begin:"`",end:"`",contains:[d.BACKSLASH_ESCAPE,C]},F={className:"comment",variants:[d.COMMENT(/\/\*\*(?!\/)/,"\\*/",{relevance:0,contains:[{begin:"(?=@[A-Za-z]+)",relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"},{className:"type",begin:"\\{",end:"\\}",excludeEnd:!0,excludeBegin:!0,relevance:0},{className:"variable",begin:p+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),d.C_BLOCK_COMMENT_MODE,d.C_LINE_COMMENT_MODE]},P=[d.APOS_STRING_MODE,d.QUOTE_STRING_MODE,w,x,A,R,{match:/\$\d+/},T];C.contains=P.concat({begin:/\{/,end:/\}/,keywords:v,contains:["self"].concat(P)});const N=[].concat(F,C.contains),k=N.concat([{begin:/(\s*)\(/,end:/\)/,keywords:v,contains:["self"].concat(N)}]),M={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:v,contains:k},L={variants:[{match:[/class/,/\s+/,p,/\s+/,/extends/,/\s+/,h.concat(p,"(",h.concat(/\./,p),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,p],scope:{1:"keyword",3:"title.class"}}]},I={relevance:0,match:h.either(/\bJSON/,/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),className:"title.class",keywords:{_:[...n,...i]}},U={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},B={variants:[{match:[/function/,/\s+/,p,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[M],illegal:/%/},$={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function H(ae){return h.concat("(?!",ae.join("|"),")")}const q={match:h.concat(/\b/,H([...a,"super","import"].map(ae=>`${ae}\\s*\\(`)),p,h.lookahead(/\s*\(/)),className:"title.function",relevance:0},V={begin:h.concat(/\./,h.lookahead(h.concat(p,/(?![0-9A-Za-z$_(])/))),end:p,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},Y={match:[/get|set/,/\s+/,p,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},M]},j="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+d.UNDERSCORE_IDENT_RE+")\\s*=>",Q={match:[/const|var|let/,/\s+/,p,/\s*/,/=\s*/,/(async\s*)?/,h.lookahead(j)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[M]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:v,exports:{PARAMS_CONTAINS:k,CLASS_REFERENCE:I},illegal:/#(?![$_A-z])/,contains:[d.SHEBANG({label:"shebang",binary:"node",relevance:5}),U,d.APOS_STRING_MODE,d.QUOTE_STRING_MODE,w,x,A,R,F,{match:/\$\d+/},T,I,{scope:"attr",match:p+h.lookahead(":"),relevance:0},Q,{begin:"("+d.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[F,d.REGEXP_MODE,{className:"function",begin:j,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:d.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:v,contains:k}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:g.begin,end:g.end},{match:m},{begin:_.begin,"on:begin":_.isTrulyOpeningTag,end:_.end}],subLanguage:"xml",contains:[{begin:_.begin,end:_.end,skip:!0,contains:["self"]}]}]},B,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+d.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[M,d.inherit(d.TITLE_MODE,{begin:p,className:"title.function"})]},{match:/\.\.\./,relevance:0},V,{match:"\\$"+p,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[M]},q,$,L,Y,{match:/\$[(.]/}]}}function u(d){const h=d.regex,f=l(d),p=t,g=["any","void","number","boolean","string","object","never","symbol","bigint","unknown"],m={begin:[/namespace/,/\s+/,d.IDENT_RE],beginScope:{1:"keyword",3:"title.class"}},_={beginKeywords:"interface",end:/\{/,excludeEnd:!0,keywords:{keyword:"interface extends",built_in:g},contains:[f.exports.CLASS_REFERENCE]},v={className:"meta",relevance:10,begin:/^\s*['"]use strict['"]/},b=["type","interface","public","private","protected","implements","declare","abstract","readonly","enum","override","satisfies"],y={$pattern:t,keyword:e.concat(b),literal:r,built_in:o.concat(g),"variable.language":s},E={className:"meta",begin:"@"+p},T=(A,R,O)=>{const F=A.contains.findIndex(P=>P.label===R);if(F===-1)throw new Error("can not find mode to replace");A.contains.splice(F,1,O)};Object.assign(f.keywords,y),f.exports.PARAMS_CONTAINS.push(E);const C=f.contains.find(A=>A.scope==="attr"),w=Object.assign({},C,{match:h.concat(p,h.lookahead(/\s*\?:/))});f.exports.PARAMS_CONTAINS.push([f.exports.CLASS_REFERENCE,C,w]),f.contains=f.contains.concat([E,m,_,w]),T(f,"shebang",d.SHEBANG()),T(f,"use_strict",v);const x=f.contains.find(A=>A.label==="func.def");return x.relevance=0,Object.assign(f,{name:"TypeScript",aliases:["ts","tsx","mts","cts"]}),f}return qW=u,qW}var HW,Zbe;function o4t(){if(Zbe)return HW;Zbe=1;function t(e){return{name:"Vala",keywords:{keyword:"char uchar unichar int uint long ulong short ushort int8 int16 int32 int64 uint8 uint16 uint32 uint64 float double bool struct enum string void weak unowned owned async signal static abstract interface override virtual delegate if while do for foreach else switch case break default return try catch public private protected internal using new this get set const stdout stdin stderr var",built_in:"DBus GLib CCode Gee Object Gtk Posix",literal:"false true null"},contains:[{className:"class",beginKeywords:"class interface namespace",end:/\{/,excludeEnd:!0,illegal:"[^,:\\n\\s\\.]",contains:[e.UNDERSCORE_TITLE_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"string",begin:'"""',end:'"""',relevance:5},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,{className:"meta",begin:"^#",end:"$"}]}}return HW=t,HW}var VW,Jbe;function l4t(){if(Jbe)return VW;Jbe=1;function t(e){const r=e.regex,n={className:"string",begin:/"(""|[^/n])"C\b/},i={className:"string",begin:/"/,end:/"/,illegal:/\n/,contains:[{begin:/""/}]},a=/\d{1,2}\/\d{1,2}\/\d{4}/,s=/\d{4}-\d{1,2}-\d{1,2}/,o=/(\d|1[012])(:\d+){0,2} *(AM|PM)/,l=/\d{1,2}(:\d{1,2}){1,2}/,u={className:"literal",variants:[{begin:r.concat(/# */,r.either(s,a),/ *#/)},{begin:r.concat(/# */,l,/ *#/)},{begin:r.concat(/# */,o,/ *#/)},{begin:r.concat(/# */,r.either(s,a),/ +/,r.either(o,l),/ *#/)}]},d={className:"number",relevance:0,variants:[{begin:/\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/},{begin:/\b\d[\d_]*((U?[SIL])|[%&])?/},{begin:/&H[\dA-F_]+((U?[SIL])|[%&])?/},{begin:/&O[0-7_]+((U?[SIL])|[%&])?/},{begin:/&B[01_]+((U?[SIL])|[%&])?/}]},h={className:"label",begin:/^\w+:/},f=e.COMMENT(/'''/,/$/,{contains:[{className:"doctag",begin:/<\/?/,end:/>/}]}),p=e.COMMENT(null,/$/,{variants:[{begin:/'/},{begin:/([\t ]|^)REM(?=\s)/}]});return{name:"Visual Basic .NET",aliases:["vb"],case_insensitive:!0,classNameAliases:{label:"symbol"},keywords:{keyword:"addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",built_in:"addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",type:"boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",literal:"true false nothing"},illegal:"//|\\{|\\}|endif|gosub|variant|wend|^\\$ ",contains:[n,i,u,d,h,f,p,{className:"meta",begin:/[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,end:/$/,keywords:{keyword:"const disable else elseif enable end externalsource if region then"},contains:[p]}]}}return VW=t,VW}var YW,e2e;function c4t(){if(e2e)return YW;e2e=1;function t(e){const r=e.regex,n=["lcase","month","vartype","instrrev","ubound","setlocale","getobject","rgb","getref","string","weekdayname","rnd","dateadd","monthname","now","day","minute","isarray","cbool","round","formatcurrency","conversions","csng","timevalue","second","year","space","abs","clng","timeserial","fixs","len","asc","isempty","maths","dateserial","atn","timer","isobject","filter","weekday","datevalue","ccur","isdate","instr","datediff","formatdatetime","replace","isnull","right","sgn","array","snumeric","log","cdbl","hex","chr","lbound","msgbox","ucase","getlocale","cos","cdate","cbyte","rtrim","join","hour","oct","typename","trim","strcomp","int","createobject","loadpicture","tan","formatnumber","mid","split","cint","sin","datepart","ltrim","sqr","time","derived","eval","date","formatpercent","exp","inputbox","left","ascw","chrw","regexp","cstr","err"],i=["server","response","request","scriptengine","scriptenginebuildversion","scriptengineminorversion","scriptenginemajorversion"],a={begin:r.concat(r.either(...n),"\\s*\\("),relevance:0,keywords:{built_in:n}};return{name:"VBScript",aliases:["vbs"],case_insensitive:!0,keywords:{keyword:["call","class","const","dim","do","loop","erase","execute","executeglobal","exit","for","each","next","function","if","then","else","on","error","option","explicit","new","private","property","let","get","public","randomize","redim","rem","select","case","set","stop","sub","while","wend","with","end","to","elseif","is","or","xor","and","not","class_initialize","class_terminate","default","preserve","in","me","byval","byref","step","resume","goto"],built_in:i,literal:["true","false","null","nothing","empty"]},illegal:"//",contains:[a,e.inherit(e.QUOTE_STRING_MODE,{contains:[{begin:'""'}]}),e.COMMENT(/'/,/$/,{relevance:0}),e.C_NUMBER_MODE]}}return YW=t,YW}var WW,t2e;function u4t(){if(t2e)return WW;t2e=1;function t(e){return{name:"VBScript in HTML",subLanguage:"xml",contains:[{begin:"<%",end:"%>",subLanguage:"vbscript"}]}}return WW=t,WW}var KW,r2e;function d4t(){if(r2e)return KW;r2e=1;function t(e){const r=e.regex,n={$pattern:/\$?[\w]+(\$[\w]+)*/,keyword:["accept_on","alias","always","always_comb","always_ff","always_latch","and","assert","assign","assume","automatic","before","begin","bind","bins","binsof","bit","break","buf|0","bufif0","bufif1","byte","case","casex","casez","cell","chandle","checker","class","clocking","cmos","config","const","constraint","context","continue","cover","covergroup","coverpoint","cross","deassign","default","defparam","design","disable","dist","do","edge","else","end","endcase","endchecker","endclass","endclocking","endconfig","endfunction","endgenerate","endgroup","endinterface","endmodule","endpackage","endprimitive","endprogram","endproperty","endspecify","endsequence","endtable","endtask","enum","event","eventually","expect","export","extends","extern","final","first_match","for","force","foreach","forever","fork","forkjoin","function","generate|5","genvar","global","highz0","highz1","if","iff","ifnone","ignore_bins","illegal_bins","implements","implies","import","incdir","include","initial","inout","input","inside","instance","int","integer","interconnect","interface","intersect","join","join_any","join_none","large","let","liblist","library","local","localparam","logic","longint","macromodule","matches","medium","modport","module","nand","negedge","nettype","new","nexttime","nmos","nor","noshowcancelled","not","notif0","notif1","or","output","package","packed","parameter","pmos","posedge","primitive","priority","program","property","protected","pull0","pull1","pulldown","pullup","pulsestyle_ondetect","pulsestyle_onevent","pure","rand","randc","randcase","randsequence","rcmos","real","realtime","ref","reg","reject_on","release","repeat","restrict","return","rnmos","rpmos","rtran","rtranif0","rtranif1","s_always","s_eventually","s_nexttime","s_until","s_until_with","scalared","sequence","shortint","shortreal","showcancelled","signed","small","soft","solve","specify","specparam","static","string","strong","strong0","strong1","struct","super","supply0","supply1","sync_accept_on","sync_reject_on","table","tagged","task","this","throughout","time","timeprecision","timeunit","tran","tranif0","tranif1","tri","tri0","tri1","triand","trior","trireg","type","typedef","union","unique","unique0","unsigned","until","until_with","untyped","use","uwire","var","vectored","virtual","void","wait","wait_order","wand","weak","weak0","weak1","while","wildcard","wire","with","within","wor","xnor","xor"],literal:["null"],built_in:["$finish","$stop","$exit","$fatal","$error","$warning","$info","$realtime","$time","$printtimescale","$bitstoreal","$bitstoshortreal","$itor","$signed","$cast","$bits","$stime","$timeformat","$realtobits","$shortrealtobits","$rtoi","$unsigned","$asserton","$assertkill","$assertpasson","$assertfailon","$assertnonvacuouson","$assertoff","$assertcontrol","$assertpassoff","$assertfailoff","$assertvacuousoff","$isunbounded","$sampled","$fell","$changed","$past_gclk","$fell_gclk","$changed_gclk","$rising_gclk","$steady_gclk","$coverage_control","$coverage_get","$coverage_save","$set_coverage_db_name","$rose","$stable","$past","$rose_gclk","$stable_gclk","$future_gclk","$falling_gclk","$changing_gclk","$display","$coverage_get_max","$coverage_merge","$get_coverage","$load_coverage_db","$typename","$unpacked_dimensions","$left","$low","$increment","$clog2","$ln","$log10","$exp","$sqrt","$pow","$floor","$ceil","$sin","$cos","$tan","$countbits","$onehot","$isunknown","$fatal","$warning","$dimensions","$right","$high","$size","$asin","$acos","$atan","$atan2","$hypot","$sinh","$cosh","$tanh","$asinh","$acosh","$atanh","$countones","$onehot0","$error","$info","$random","$dist_chi_square","$dist_erlang","$dist_exponential","$dist_normal","$dist_poisson","$dist_t","$dist_uniform","$q_initialize","$q_remove","$q_exam","$async$and$array","$async$nand$array","$async$or$array","$async$nor$array","$sync$and$array","$sync$nand$array","$sync$or$array","$sync$nor$array","$q_add","$q_full","$psprintf","$async$and$plane","$async$nand$plane","$async$or$plane","$async$nor$plane","$sync$and$plane","$sync$nand$plane","$sync$or$plane","$sync$nor$plane","$system","$display","$displayb","$displayh","$displayo","$strobe","$strobeb","$strobeh","$strobeo","$write","$readmemb","$readmemh","$writememh","$value$plusargs","$dumpvars","$dumpon","$dumplimit","$dumpports","$dumpportson","$dumpportslimit","$writeb","$writeh","$writeo","$monitor","$monitorb","$monitorh","$monitoro","$writememb","$dumpfile","$dumpoff","$dumpall","$dumpflush","$dumpportsoff","$dumpportsall","$dumpportsflush","$fclose","$fdisplay","$fdisplayb","$fdisplayh","$fdisplayo","$fstrobe","$fstrobeb","$fstrobeh","$fstrobeo","$swrite","$swriteb","$swriteh","$swriteo","$fscanf","$fread","$fseek","$fflush","$feof","$fopen","$fwrite","$fwriteb","$fwriteh","$fwriteo","$fmonitor","$fmonitorb","$fmonitorh","$fmonitoro","$sformat","$sformatf","$fgetc","$ungetc","$fgets","$sscanf","$rewind","$ftell","$ferror"]},i=["__FILE__","__LINE__"],a=["begin_keywords","celldefine","default_nettype","default_decay_time","default_trireg_strength","define","delay_mode_distributed","delay_mode_path","delay_mode_unit","delay_mode_zero","else","elsif","end_keywords","endcelldefine","endif","ifdef","ifndef","include","line","nounconnected_drive","pragma","resetall","timescale","unconnected_drive","undef","undefineall"];return{name:"Verilog",aliases:["v","sv","svh"],case_insensitive:!1,keywords:n,contains:[e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE,e.QUOTE_STRING_MODE,{scope:"number",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/\b((\d+'([bhodBHOD]))[0-9xzXZa-fA-F_]+)/},{begin:/\B(('([bhodBHOD]))[0-9xzXZa-fA-F_]+)/},{begin:/\b[0-9][0-9_]*/,relevance:0}]},{scope:"variable",variants:[{begin:"#\\((?!parameter).+\\)"},{begin:"\\.\\w+",relevance:0}]},{scope:"variable.constant",match:r.concat(/`/,r.either(...i))},{scope:"meta",begin:r.concat(/`/,r.either(...a)),end:/$|\/\/|\/\*/,returnEnd:!0,keywords:a}]}}return KW=t,KW}var jW,n2e;function h4t(){if(n2e)return jW;n2e=1;function t(e){const r="\\d(_|\\d)*",n="[eE][-+]?"+r,i=r+"(\\."+r+")?("+n+")?",a="\\w+",o="\\b("+(r+"#"+a+"(\\."+a+")?#("+n+")?")+"|"+i+")";return{name:"VHDL",case_insensitive:!0,keywords:{keyword:["abs","access","after","alias","all","and","architecture","array","assert","assume","assume_guarantee","attribute","begin","block","body","buffer","bus","case","component","configuration","constant","context","cover","disconnect","downto","default","else","elsif","end","entity","exit","fairness","file","for","force","function","generate","generic","group","guarded","if","impure","in","inertial","inout","is","label","library","linkage","literal","loop","map","mod","nand","new","next","nor","not","null","of","on","open","or","others","out","package","parameter","port","postponed","procedure","process","property","protected","pure","range","record","register","reject","release","rem","report","restrict","restrict_guarantee","return","rol","ror","select","sequence","severity","shared","signal","sla","sll","sra","srl","strong","subtype","then","to","transport","type","unaffected","units","until","use","variable","view","vmode","vprop","vunit","wait","when","while","with","xnor","xor"],built_in:["boolean","bit","character","integer","time","delay_length","natural","positive","string","bit_vector","file_open_kind","file_open_status","std_logic","std_logic_vector","unsigned","signed","boolean_vector","integer_vector","std_ulogic","std_ulogic_vector","unresolved_unsigned","u_unsigned","unresolved_signed","u_signed","real_vector","time_vector"],literal:["false","true","note","warning","error","failure","line","text","side","width"]},illegal:/\{/,contains:[e.C_BLOCK_COMMENT_MODE,e.COMMENT("--","$"),e.QUOTE_STRING_MODE,{className:"number",begin:o,relevance:0},{className:"string",begin:"'(U|X|0|1|Z|W|L|H|-)'",contains:[e.BACKSLASH_ESCAPE]},{className:"symbol",begin:"'[A-Za-z](_?[A-Za-z0-9])*",contains:[e.BACKSLASH_ESCAPE]}]}}return jW=t,jW}var XW,i2e;function f4t(){if(i2e)return XW;i2e=1;function t(e){return{name:"Vim Script",keywords:{$pattern:/[!#@\w]+/,keyword:"N|0 P|0 X|0 a|0 ab abc abo al am an|0 ar arga argd arge argdo argg argl argu as au aug aun b|0 bN ba bad bd be bel bf bl bm bn bo bp br brea breaka breakd breakl bro bufdo buffers bun bw c|0 cN cNf ca cabc caddb cad caddf cal cat cb cc ccl cd ce cex cf cfir cgetb cgete cg changes chd che checkt cl cla clo cm cmapc cme cn cnew cnf cno cnorea cnoreme co col colo com comc comp con conf cope cp cpf cq cr cs cst cu cuna cunme cw delm deb debugg delc delf dif diffg diffo diffp diffpu diffs diffthis dig di dl dell dj dli do doautoa dp dr ds dsp e|0 ea ec echoe echoh echom echon el elsei em en endfo endf endt endw ene ex exe exi exu f|0 files filet fin fina fini fir fix fo foldc foldd folddoc foldo for fu go gr grepa gu gv ha helpf helpg helpt hi hid his ia iabc if ij il im imapc ime ino inorea inoreme int is isp iu iuna iunme j|0 ju k|0 keepa kee keepj lN lNf l|0 lad laddb laddf la lan lat lb lc lch lcl lcs le lefta let lex lf lfir lgetb lgete lg lgr lgrepa lh ll lla lli lmak lm lmapc lne lnew lnf ln loadk lo loc lockv lol lope lp lpf lr ls lt lu lua luad luaf lv lvimgrepa lw m|0 ma mak map mapc marks mat me menut mes mk mks mksp mkv mkvie mod mz mzf nbc nb nbs new nm nmapc nme nn nnoreme noa no noh norea noreme norm nu nun nunme ol o|0 om omapc ome on ono onoreme opt ou ounme ow p|0 profd prof pro promptr pc ped pe perld po popu pp pre prev ps pt ptN ptf ptj ptl ptn ptp ptr pts pu pw py3 python3 py3d py3f py pyd pyf quita qa rec red redi redr redraws reg res ret retu rew ri rightb rub rubyd rubyf rund ru rv sN san sa sal sav sb sbN sba sbf sbl sbm sbn sbp sbr scrip scripte scs se setf setg setl sf sfir sh sim sig sil sl sla sm smap smapc sme sn sni sno snor snoreme sor so spelld spe spelli spellr spellu spellw sp spr sre st sta startg startr star stopi stj sts sun sunm sunme sus sv sw sy synti sync tN tabN tabc tabdo tabe tabf tabfir tabl tabm tabnew tabn tabo tabp tabr tabs tab ta tags tc tcld tclf te tf th tj tl tm tn to tp tr try ts tu u|0 undoj undol una unh unl unlo unm unme uns up ve verb vert vim vimgrepa vi viu vie vm vmapc vme vne vn vnoreme vs vu vunme windo w|0 wN wa wh wi winc winp wn wp wq wqa ws wu wv x|0 xa xmapc xm xme xn xnoreme xu xunme y|0 z|0 ~ Next Print append abbreviate abclear aboveleft all amenu anoremenu args argadd argdelete argedit argglobal arglocal argument ascii autocmd augroup aunmenu buffer bNext ball badd bdelete behave belowright bfirst blast bmodified bnext botright bprevious brewind break breakadd breakdel breaklist browse bunload bwipeout change cNext cNfile cabbrev cabclear caddbuffer caddexpr caddfile call catch cbuffer cclose center cexpr cfile cfirst cgetbuffer cgetexpr cgetfile chdir checkpath checktime clist clast close cmap cmapclear cmenu cnext cnewer cnfile cnoremap cnoreabbrev cnoremenu copy colder colorscheme command comclear compiler continue confirm copen cprevious cpfile cquit crewind cscope cstag cunmap cunabbrev cunmenu cwindow delete delmarks debug debuggreedy delcommand delfunction diffupdate diffget diffoff diffpatch diffput diffsplit digraphs display deletel djump dlist doautocmd doautoall deletep drop dsearch dsplit edit earlier echo echoerr echohl echomsg else elseif emenu endif endfor endfunction endtry endwhile enew execute exit exusage file filetype find finally finish first fixdel fold foldclose folddoopen folddoclosed foldopen function global goto grep grepadd gui gvim hardcopy help helpfind helpgrep helptags highlight hide history insert iabbrev iabclear ijump ilist imap imapclear imenu inoremap inoreabbrev inoremenu intro isearch isplit iunmap iunabbrev iunmenu join jumps keepalt keepmarks keepjumps lNext lNfile list laddexpr laddbuffer laddfile last language later lbuffer lcd lchdir lclose lcscope left leftabove lexpr lfile lfirst lgetbuffer lgetexpr lgetfile lgrep lgrepadd lhelpgrep llast llist lmake lmap lmapclear lnext lnewer lnfile lnoremap loadkeymap loadview lockmarks lockvar lolder lopen lprevious lpfile lrewind ltag lunmap luado luafile lvimgrep lvimgrepadd lwindow move mark make mapclear match menu menutranslate messages mkexrc mksession mkspell mkvimrc mkview mode mzscheme mzfile nbclose nbkey nbsart next nmap nmapclear nmenu nnoremap nnoremenu noautocmd noremap nohlsearch noreabbrev noremenu normal number nunmap nunmenu oldfiles open omap omapclear omenu only onoremap onoremenu options ounmap ounmenu ownsyntax print profdel profile promptfind promptrepl pclose pedit perl perldo pop popup ppop preserve previous psearch ptag ptNext ptfirst ptjump ptlast ptnext ptprevious ptrewind ptselect put pwd py3do py3file python pydo pyfile quit quitall qall read recover redo redir redraw redrawstatus registers resize retab return rewind right rightbelow ruby rubydo rubyfile rundo runtime rviminfo substitute sNext sandbox sargument sall saveas sbuffer sbNext sball sbfirst sblast sbmodified sbnext sbprevious sbrewind scriptnames scriptencoding scscope set setfiletype setglobal setlocal sfind sfirst shell simalt sign silent sleep slast smagic smapclear smenu snext sniff snomagic snoremap snoremenu sort source spelldump spellgood spellinfo spellrepall spellundo spellwrong split sprevious srewind stop stag startgreplace startreplace startinsert stopinsert stjump stselect sunhide sunmap sunmenu suspend sview swapname syntax syntime syncbind tNext tabNext tabclose tabedit tabfind tabfirst tablast tabmove tabnext tabonly tabprevious tabrewind tag tcl tcldo tclfile tearoff tfirst throw tjump tlast tmenu tnext topleft tprevious trewind tselect tunmenu undo undojoin undolist unabbreviate unhide unlet unlockvar unmap unmenu unsilent update vglobal version verbose vertical vimgrep vimgrepadd visual viusage view vmap vmapclear vmenu vnew vnoremap vnoremenu vsplit vunmap vunmenu write wNext wall while winsize wincmd winpos wnext wprevious wqall wsverb wundo wviminfo xit xall xmapclear xmap xmenu xnoremap xnoremenu xunmap xunmenu yank",built_in:"synIDtrans atan2 range matcharg did_filetype asin feedkeys xor argv complete_check add getwinposx getqflist getwinposy screencol clearmatches empty extend getcmdpos mzeval garbagecollect setreg ceil sqrt diff_hlID inputsecret get getfperm getpid filewritable shiftwidth max sinh isdirectory synID system inputrestore winline atan visualmode inputlist tabpagewinnr round getregtype mapcheck hasmapto histdel argidx findfile sha256 exists toupper getcmdline taglist string getmatches bufnr strftime winwidth bufexists strtrans tabpagebuflist setcmdpos remote_read printf setloclist getpos getline bufwinnr float2nr len getcmdtype diff_filler luaeval resolve libcallnr foldclosedend reverse filter has_key bufname str2float strlen setline getcharmod setbufvar index searchpos shellescape undofile foldclosed setqflist buflisted strchars str2nr virtcol floor remove undotree remote_expr winheight gettabwinvar reltime cursor tabpagenr finddir localtime acos getloclist search tanh matchend rename gettabvar strdisplaywidth type abs py3eval setwinvar tolower wildmenumode log10 spellsuggest bufloaded synconcealed nextnonblank server2client complete settabwinvar executable input wincol setmatches getftype hlID inputsave searchpair or screenrow line settabvar histadd deepcopy strpart remote_peek and eval getftime submatch screenchar winsaveview matchadd mkdir screenattr getfontname libcall reltimestr getfsize winnr invert pow getbufline byte2line soundfold repeat fnameescape tagfiles sin strwidth spellbadword trunc maparg log lispindent hostname setpos globpath remote_foreground getchar synIDattr fnamemodify cscope_connection stridx winbufnr indent min complete_add nr2char searchpairpos inputdialog values matchlist items hlexists strridx browsedir expand fmod pathshorten line2byte argc count getwinvar glob foldtextresult getreg foreground cosh matchdelete has char2nr simplify histget searchdecl iconv winrestcmd pumvisible writefile foldlevel haslocaldir keys cos matchstr foldtext histnr tan tempname getcwd byteidx getbufvar islocked escape eventhandler remote_send serverlist winrestview synstack pyeval prevnonblank readfile cindent filereadable changenr exp"},illegal:/;/,contains:[e.NUMBER_MODE,{className:"string",begin:"'",end:"'",illegal:"\\n"},{className:"string",begin:/"(\\"|\n\\|[^"\n])*"/},e.COMMENT('"',"$"),{className:"variable",begin:/[bwtglsav]:[\w\d_]+/},{begin:[/\b(?:function|function!)/,/\s+/,e.IDENT_RE],className:{1:"keyword",3:"title"},end:"$",relevance:0,contains:[{className:"params",begin:"\\(",end:"\\)"}]},{className:"symbol",begin:/<[\w-]+>/}]}}return XW=t,XW}var QW,a2e;function p4t(){if(a2e)return QW;a2e=1;function t(e){e.regex;const r=e.COMMENT(/\(;/,/;\)/);r.contains.push("self");const n=e.COMMENT(/;;/,/$/),i=["anyfunc","block","br","br_if","br_table","call","call_indirect","data","drop","elem","else","end","export","func","global.get","global.set","local.get","local.set","local.tee","get_global","get_local","global","if","import","local","loop","memory","memory.grow","memory.size","module","mut","nop","offset","param","result","return","select","set_global","set_local","start","table","tee_local","then","type","unreachable"],a={begin:[/(?:func|call|call_indirect)/,/\s+/,/\$[^\s)]+/],className:{1:"keyword",3:"title.function"}},s={className:"variable",begin:/\$[\w_]+/},o={match:/(\((?!;)|\))+/,className:"punctuation",relevance:0},l={className:"number",relevance:0,match:/[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/},u={match:/(i32|i64|f32|f64)(?!\.)/,className:"type"},d={className:"keyword",match:/\b(f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|nearest|neg?|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|store(?:8|16|32)?|sqrt|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))\b/};return{name:"WebAssembly",keywords:{$pattern:/[\w.]+/,keyword:i},contains:[n,r,{match:[/(?:offset|align)/,/\s*/,/=/],className:{1:"keyword",3:"operator"}},s,o,a,e.QUOTE_STRING_MODE,u,d,l]}}return QW=t,QW}var ZW,s2e;function g4t(){if(s2e)return ZW;s2e=1;function t(e){const r=e.regex,n=/[a-zA-Z]\w*/,i=["as","break","class","construct","continue","else","for","foreign","if","import","in","is","return","static","var","while"],a=["true","false","null"],s=["this","super"],o=["Bool","Class","Fiber","Fn","List","Map","Null","Num","Object","Range","Sequence","String","System"],l=["-","~",/\*/,"%",/\.\.\./,/\.\./,/\+/,"<<",">>",">=","<=","<",">",/\^/,/!=/,/!/,/\bis\b/,"==","&&","&",/\|\|/,/\|/,/\?:/,"="],u={relevance:0,match:r.concat(/\b(?!(if|while|for|else|super)\b)/,n,/(?=\s*[({])/),className:"title.function"},d={match:r.concat(r.either(r.concat(/\b(?!(if|while|for|else|super)\b)/,n),r.either(...l)),/(?=\s*\([^)]+\)\s*\{)/),className:"title.function",starts:{contains:[{begin:/\(/,end:/\)/,contains:[{relevance:0,scope:"params",match:n}]}]}},h={variants:[{match:[/class\s+/,n,/\s+is\s+/,n]},{match:[/class\s+/,n]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:i},f={relevance:0,match:r.either(...l),className:"operator"},p={className:"string",begin:/"""/,end:/"""/},g={className:"property",begin:r.concat(/\./,r.lookahead(n)),end:n,excludeBegin:!0,relevance:0},m={relevance:0,match:r.concat(/\b_/,n),scope:"variable"},_={relevance:0,match:/\b[A-Z]+[a-z]+([A-Z]+[a-z]+)*/,scope:"title.class",keywords:{_:o}},v=e.C_NUMBER_MODE,b={match:[n,/\s*/,/=/,/\s*/,/\(/,n,/\)\s*\{/],scope:{1:"title.function",3:"operator",6:"params"}},y=e.COMMENT(/\/\*\*/,/\*\//,{contains:[{match:/@[a-z]+/,scope:"doctag"},"self"]}),E={scope:"subst",begin:/%\(/,end:/\)/,contains:[v,_,u,m,f]},T={scope:"string",begin:/"/,end:/"/,contains:[E,{scope:"char.escape",variants:[{match:/\\\\|\\["0%abefnrtv]/},{match:/\\x[0-9A-F]{2}/},{match:/\\u[0-9A-F]{4}/},{match:/\\U[0-9A-F]{8}/}]}]};E.contains.push(T);const C=[...i,...s,...a],w={relevance:0,match:r.concat("\\b(?!",C.join("|"),"\\b)",/[a-zA-Z_]\w*(?:[?!]|\b)/),className:"variable"};return{name:"Wren",keywords:{keyword:i,"variable.language":s,literal:a},contains:[{scope:"comment",variants:[{begin:[/#!?/,/[A-Za-z_]+(?=\()/],beginScope:{},keywords:{literal:a},contains:[],end:/\)/},{begin:[/#!?/,/[A-Za-z_]+/],beginScope:{},end:/$/}]},v,T,p,y,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,_,h,b,d,u,f,m,g,w]}}return ZW=t,ZW}var JW,o2e;function m4t(){if(o2e)return JW;o2e=1;function t(e){return{name:"Intel x86 Assembly",case_insensitive:!0,keywords:{$pattern:"[.%]?"+e.IDENT_RE,keyword:"lock rep repe repz repne repnz xaquire xrelease bnd nobnd aaa aad aam aas adc add and arpl bb0_reset bb1_reset bound bsf bsr bswap bt btc btr bts call cbw cdq cdqe clc cld cli clts cmc cmp cmpsb cmpsd cmpsq cmpsw cmpxchg cmpxchg486 cmpxchg8b cmpxchg16b cpuid cpu_read cpu_write cqo cwd cwde daa das dec div dmint emms enter equ f2xm1 fabs fadd faddp fbld fbstp fchs fclex fcmovb fcmovbe fcmove fcmovnb fcmovnbe fcmovne fcmovnu fcmovu fcom fcomi fcomip fcomp fcompp fcos fdecstp fdisi fdiv fdivp fdivr fdivrp femms feni ffree ffreep fiadd ficom ficomp fidiv fidivr fild fimul fincstp finit fist fistp fisttp fisub fisubr fld fld1 fldcw fldenv fldl2e fldl2t fldlg2 fldln2 fldpi fldz fmul fmulp fnclex fndisi fneni fninit fnop fnsave fnstcw fnstenv fnstsw fpatan fprem fprem1 fptan frndint frstor fsave fscale fsetpm fsin fsincos fsqrt fst fstcw fstenv fstp fstsw fsub fsubp fsubr fsubrp ftst fucom fucomi fucomip fucomp fucompp fxam fxch fxtract fyl2x fyl2xp1 hlt ibts icebp idiv imul in inc incbin insb insd insw int int01 int1 int03 int3 into invd invpcid invlpg invlpga iret iretd iretq iretw jcxz jecxz jrcxz jmp jmpe lahf lar lds lea leave les lfence lfs lgdt lgs lidt lldt lmsw loadall loadall286 lodsb lodsd lodsq lodsw loop loope loopne loopnz loopz lsl lss ltr mfence monitor mov movd movq movsb movsd movsq movsw movsx movsxd movzx mul mwait neg nop not or out outsb outsd outsw packssdw packsswb packuswb paddb paddd paddsb paddsiw paddsw paddusb paddusw paddw pand pandn pause paveb pavgusb pcmpeqb pcmpeqd pcmpeqw pcmpgtb pcmpgtd pcmpgtw pdistib pf2id pfacc pfadd pfcmpeq pfcmpge pfcmpgt pfmax pfmin pfmul pfrcp pfrcpit1 pfrcpit2 pfrsqit1 pfrsqrt pfsub pfsubr pi2fd pmachriw pmaddwd pmagw pmulhriw pmulhrwa pmulhrwc pmulhw pmullw pmvgezb pmvlzb pmvnzb pmvzb pop popa popad popaw popf popfd popfq popfw por prefetch prefetchw pslld psllq psllw psrad psraw psrld psrlq psrlw psubb psubd psubsb psubsiw psubsw psubusb psubusw psubw punpckhbw punpckhdq punpckhwd punpcklbw punpckldq punpcklwd push pusha pushad pushaw pushf pushfd pushfq pushfw pxor rcl rcr rdshr rdmsr rdpmc rdtsc rdtscp ret retf retn rol ror rdm rsdc rsldt rsm rsts sahf sal salc sar sbb scasb scasd scasq scasw sfence sgdt shl shld shr shrd sidt sldt skinit smi smint smintold smsw stc std sti stosb stosd stosq stosw str sub svdc svldt svts swapgs syscall sysenter sysexit sysret test ud0 ud1 ud2b ud2 ud2a umov verr verw fwait wbinvd wrshr wrmsr xadd xbts xchg xlatb xlat xor cmove cmovz cmovne cmovnz cmova cmovnbe cmovae cmovnb cmovb cmovnae cmovbe cmovna cmovg cmovnle cmovge cmovnl cmovl cmovnge cmovle cmovng cmovc cmovnc cmovo cmovno cmovs cmovns cmovp cmovpe cmovnp cmovpo je jz jne jnz ja jnbe jae jnb jb jnae jbe jna jg jnle jge jnl jl jnge jle jng jc jnc jo jno js jns jpo jnp jpe jp sete setz setne setnz seta setnbe setae setnb setnc setb setnae setcset setbe setna setg setnle setge setnl setl setnge setle setng sets setns seto setno setpe setp setpo setnp addps addss andnps andps cmpeqps cmpeqss cmpleps cmpless cmpltps cmpltss cmpneqps cmpneqss cmpnleps cmpnless cmpnltps cmpnltss cmpordps cmpordss cmpunordps cmpunordss cmpps cmpss comiss cvtpi2ps cvtps2pi cvtsi2ss cvtss2si cvttps2pi cvttss2si divps divss ldmxcsr maxps maxss minps minss movaps movhps movlhps movlps movhlps movmskps movntps movss movups mulps mulss orps rcpps rcpss rsqrtps rsqrtss shufps sqrtps sqrtss stmxcsr subps subss ucomiss unpckhps unpcklps xorps fxrstor fxrstor64 fxsave fxsave64 xgetbv xsetbv xsave xsave64 xsaveopt xsaveopt64 xrstor xrstor64 prefetchnta prefetcht0 prefetcht1 prefetcht2 maskmovq movntq pavgb pavgw pextrw pinsrw pmaxsw pmaxub pminsw pminub pmovmskb pmulhuw psadbw pshufw pf2iw pfnacc pfpnacc pi2fw pswapd maskmovdqu clflush movntdq movnti movntpd movdqa movdqu movdq2q movq2dq paddq pmuludq pshufd pshufhw pshuflw pslldq psrldq psubq punpckhqdq punpcklqdq addpd addsd andnpd andpd cmpeqpd cmpeqsd cmplepd cmplesd cmpltpd cmpltsd cmpneqpd cmpneqsd cmpnlepd cmpnlesd cmpnltpd cmpnltsd cmpordpd cmpordsd cmpunordpd cmpunordsd cmppd comisd cvtdq2pd cvtdq2ps cvtpd2dq cvtpd2pi cvtpd2ps cvtpi2pd cvtps2dq cvtps2pd cvtsd2si cvtsd2ss cvtsi2sd cvtss2sd cvttpd2pi cvttpd2dq cvttps2dq cvttsd2si divpd divsd maxpd maxsd minpd minsd movapd movhpd movlpd movmskpd movupd mulpd mulsd orpd shufpd sqrtpd sqrtsd subpd subsd ucomisd unpckhpd unpcklpd xorpd addsubpd addsubps haddpd haddps hsubpd hsubps lddqu movddup movshdup movsldup clgi stgi vmcall vmclear vmfunc vmlaunch vmload vmmcall vmptrld vmptrst vmread vmresume vmrun vmsave vmwrite vmxoff vmxon invept invvpid pabsb pabsw pabsd palignr phaddw phaddd phaddsw phsubw phsubd phsubsw pmaddubsw pmulhrsw pshufb psignb psignw psignd extrq insertq movntsd movntss lzcnt blendpd blendps blendvpd blendvps dppd dpps extractps insertps movntdqa mpsadbw packusdw pblendvb pblendw pcmpeqq pextrb pextrd pextrq phminposuw pinsrb pinsrd pinsrq pmaxsb pmaxsd pmaxud pmaxuw pminsb pminsd pminud pminuw pmovsxbw pmovsxbd pmovsxbq pmovsxwd pmovsxwq pmovsxdq pmovzxbw pmovzxbd pmovzxbq pmovzxwd pmovzxwq pmovzxdq pmuldq pmulld ptest roundpd roundps roundsd roundss crc32 pcmpestri pcmpestrm pcmpistri pcmpistrm pcmpgtq popcnt getsec pfrcpv pfrsqrtv movbe aesenc aesenclast aesdec aesdeclast aesimc aeskeygenassist vaesenc vaesenclast vaesdec vaesdeclast vaesimc vaeskeygenassist vaddpd vaddps vaddsd vaddss vaddsubpd vaddsubps vandpd vandps vandnpd vandnps vblendpd vblendps vblendvpd vblendvps vbroadcastss vbroadcastsd vbroadcastf128 vcmpeq_ospd vcmpeqpd vcmplt_ospd vcmpltpd vcmple_ospd vcmplepd vcmpunord_qpd vcmpunordpd vcmpneq_uqpd vcmpneqpd vcmpnlt_uspd vcmpnltpd vcmpnle_uspd vcmpnlepd vcmpord_qpd vcmpordpd vcmpeq_uqpd vcmpnge_uspd vcmpngepd vcmpngt_uspd vcmpngtpd vcmpfalse_oqpd vcmpfalsepd vcmpneq_oqpd vcmpge_ospd vcmpgepd vcmpgt_ospd vcmpgtpd vcmptrue_uqpd vcmptruepd vcmplt_oqpd vcmple_oqpd vcmpunord_spd vcmpneq_uspd vcmpnlt_uqpd vcmpnle_uqpd vcmpord_spd vcmpeq_uspd vcmpnge_uqpd vcmpngt_uqpd vcmpfalse_ospd vcmpneq_ospd vcmpge_oqpd vcmpgt_oqpd vcmptrue_uspd vcmppd vcmpeq_osps vcmpeqps vcmplt_osps vcmpltps vcmple_osps vcmpleps vcmpunord_qps vcmpunordps vcmpneq_uqps vcmpneqps vcmpnlt_usps vcmpnltps vcmpnle_usps vcmpnleps vcmpord_qps vcmpordps vcmpeq_uqps vcmpnge_usps vcmpngeps vcmpngt_usps vcmpngtps vcmpfalse_oqps vcmpfalseps vcmpneq_oqps vcmpge_osps vcmpgeps vcmpgt_osps vcmpgtps vcmptrue_uqps vcmptrueps vcmplt_oqps vcmple_oqps vcmpunord_sps vcmpneq_usps vcmpnlt_uqps vcmpnle_uqps vcmpord_sps vcmpeq_usps vcmpnge_uqps vcmpngt_uqps vcmpfalse_osps vcmpneq_osps vcmpge_oqps vcmpgt_oqps vcmptrue_usps vcmpps vcmpeq_ossd vcmpeqsd vcmplt_ossd vcmpltsd vcmple_ossd vcmplesd vcmpunord_qsd vcmpunordsd vcmpneq_uqsd vcmpneqsd vcmpnlt_ussd vcmpnltsd vcmpnle_ussd vcmpnlesd vcmpord_qsd vcmpordsd vcmpeq_uqsd vcmpnge_ussd vcmpngesd vcmpngt_ussd vcmpngtsd vcmpfalse_oqsd vcmpfalsesd vcmpneq_oqsd vcmpge_ossd vcmpgesd vcmpgt_ossd vcmpgtsd vcmptrue_uqsd vcmptruesd vcmplt_oqsd vcmple_oqsd vcmpunord_ssd vcmpneq_ussd vcmpnlt_uqsd vcmpnle_uqsd vcmpord_ssd vcmpeq_ussd vcmpnge_uqsd vcmpngt_uqsd vcmpfalse_ossd vcmpneq_ossd vcmpge_oqsd vcmpgt_oqsd vcmptrue_ussd vcmpsd vcmpeq_osss vcmpeqss vcmplt_osss vcmpltss vcmple_osss vcmpless vcmpunord_qss vcmpunordss vcmpneq_uqss vcmpneqss vcmpnlt_usss vcmpnltss vcmpnle_usss vcmpnless vcmpord_qss vcmpordss vcmpeq_uqss vcmpnge_usss vcmpngess vcmpngt_usss vcmpngtss vcmpfalse_oqss vcmpfalsess vcmpneq_oqss vcmpge_osss vcmpgess vcmpgt_osss vcmpgtss vcmptrue_uqss vcmptruess vcmplt_oqss vcmple_oqss vcmpunord_sss vcmpneq_usss vcmpnlt_uqss vcmpnle_uqss vcmpord_sss vcmpeq_usss vcmpnge_uqss vcmpngt_uqss vcmpfalse_osss vcmpneq_osss vcmpge_oqss vcmpgt_oqss vcmptrue_usss vcmpss vcomisd vcomiss vcvtdq2pd vcvtdq2ps vcvtpd2dq vcvtpd2ps vcvtps2dq vcvtps2pd vcvtsd2si vcvtsd2ss vcvtsi2sd vcvtsi2ss vcvtss2sd vcvtss2si vcvttpd2dq vcvttps2dq vcvttsd2si vcvttss2si vdivpd vdivps vdivsd vdivss vdppd vdpps vextractf128 vextractps vhaddpd vhaddps vhsubpd vhsubps vinsertf128 vinsertps vlddqu vldqqu vldmxcsr vmaskmovdqu vmaskmovps vmaskmovpd vmaxpd vmaxps vmaxsd vmaxss vminpd vminps vminsd vminss vmovapd vmovaps vmovd vmovq vmovddup vmovdqa vmovqqa vmovdqu vmovqqu vmovhlps vmovhpd vmovhps vmovlhps vmovlpd vmovlps vmovmskpd vmovmskps vmovntdq vmovntqq vmovntdqa vmovntpd vmovntps vmovsd vmovshdup vmovsldup vmovss vmovupd vmovups vmpsadbw vmulpd vmulps vmulsd vmulss vorpd vorps vpabsb vpabsw vpabsd vpacksswb vpackssdw vpackuswb vpackusdw vpaddb vpaddw vpaddd vpaddq vpaddsb vpaddsw vpaddusb vpaddusw vpalignr vpand vpandn vpavgb vpavgw vpblendvb vpblendw vpcmpestri vpcmpestrm vpcmpistri vpcmpistrm vpcmpeqb vpcmpeqw vpcmpeqd vpcmpeqq vpcmpgtb vpcmpgtw vpcmpgtd vpcmpgtq vpermilpd vpermilps vperm2f128 vpextrb vpextrw vpextrd vpextrq vphaddw vphaddd vphaddsw vphminposuw vphsubw vphsubd vphsubsw vpinsrb vpinsrw vpinsrd vpinsrq vpmaddwd vpmaddubsw vpmaxsb vpmaxsw vpmaxsd vpmaxub vpmaxuw vpmaxud vpminsb vpminsw vpminsd vpminub vpminuw vpminud vpmovmskb vpmovsxbw vpmovsxbd vpmovsxbq vpmovsxwd vpmovsxwq vpmovsxdq vpmovzxbw vpmovzxbd vpmovzxbq vpmovzxwd vpmovzxwq vpmovzxdq vpmulhuw vpmulhrsw vpmulhw vpmullw vpmulld vpmuludq vpmuldq vpor vpsadbw vpshufb vpshufd vpshufhw vpshuflw vpsignb vpsignw vpsignd vpslldq vpsrldq vpsllw vpslld vpsllq vpsraw vpsrad vpsrlw vpsrld vpsrlq vptest vpsubb vpsubw vpsubd vpsubq vpsubsb vpsubsw vpsubusb vpsubusw vpunpckhbw vpunpckhwd vpunpckhdq vpunpckhqdq vpunpcklbw vpunpcklwd vpunpckldq vpunpcklqdq vpxor vrcpps vrcpss vrsqrtps vrsqrtss vroundpd vroundps vroundsd vroundss vshufpd vshufps vsqrtpd vsqrtps vsqrtsd vsqrtss vstmxcsr vsubpd vsubps vsubsd vsubss vtestps vtestpd vucomisd vucomiss vunpckhpd vunpckhps vunpcklpd vunpcklps vxorpd vxorps vzeroall vzeroupper pclmullqlqdq pclmulhqlqdq pclmullqhqdq pclmulhqhqdq pclmulqdq vpclmullqlqdq vpclmulhqlqdq vpclmullqhqdq vpclmulhqhqdq vpclmulqdq vfmadd132ps vfmadd132pd vfmadd312ps vfmadd312pd vfmadd213ps vfmadd213pd vfmadd123ps vfmadd123pd vfmadd231ps vfmadd231pd vfmadd321ps vfmadd321pd vfmaddsub132ps vfmaddsub132pd vfmaddsub312ps vfmaddsub312pd vfmaddsub213ps vfmaddsub213pd vfmaddsub123ps vfmaddsub123pd vfmaddsub231ps vfmaddsub231pd vfmaddsub321ps vfmaddsub321pd vfmsub132ps vfmsub132pd vfmsub312ps vfmsub312pd vfmsub213ps vfmsub213pd vfmsub123ps vfmsub123pd vfmsub231ps vfmsub231pd vfmsub321ps vfmsub321pd vfmsubadd132ps vfmsubadd132pd vfmsubadd312ps vfmsubadd312pd vfmsubadd213ps vfmsubadd213pd vfmsubadd123ps vfmsubadd123pd vfmsubadd231ps vfmsubadd231pd vfmsubadd321ps vfmsubadd321pd vfnmadd132ps vfnmadd132pd vfnmadd312ps vfnmadd312pd vfnmadd213ps vfnmadd213pd vfnmadd123ps vfnmadd123pd vfnmadd231ps vfnmadd231pd vfnmadd321ps vfnmadd321pd vfnmsub132ps vfnmsub132pd vfnmsub312ps vfnmsub312pd vfnmsub213ps vfnmsub213pd vfnmsub123ps vfnmsub123pd vfnmsub231ps vfnmsub231pd vfnmsub321ps vfnmsub321pd vfmadd132ss vfmadd132sd vfmadd312ss vfmadd312sd vfmadd213ss vfmadd213sd vfmadd123ss vfmadd123sd vfmadd231ss vfmadd231sd vfmadd321ss vfmadd321sd vfmsub132ss vfmsub132sd vfmsub312ss vfmsub312sd vfmsub213ss vfmsub213sd vfmsub123ss vfmsub123sd vfmsub231ss vfmsub231sd vfmsub321ss vfmsub321sd vfnmadd132ss vfnmadd132sd vfnmadd312ss vfnmadd312sd vfnmadd213ss vfnmadd213sd vfnmadd123ss vfnmadd123sd vfnmadd231ss vfnmadd231sd vfnmadd321ss vfnmadd321sd vfnmsub132ss vfnmsub132sd vfnmsub312ss vfnmsub312sd vfnmsub213ss vfnmsub213sd vfnmsub123ss vfnmsub123sd vfnmsub231ss vfnmsub231sd vfnmsub321ss vfnmsub321sd rdfsbase rdgsbase rdrand wrfsbase wrgsbase vcvtph2ps vcvtps2ph adcx adox rdseed clac stac xstore xcryptecb xcryptcbc xcryptctr xcryptcfb xcryptofb montmul xsha1 xsha256 llwpcb slwpcb lwpval lwpins vfmaddpd vfmaddps vfmaddsd vfmaddss vfmaddsubpd vfmaddsubps vfmsubaddpd vfmsubaddps vfmsubpd vfmsubps vfmsubsd vfmsubss vfnmaddpd vfnmaddps vfnmaddsd vfnmaddss vfnmsubpd vfnmsubps vfnmsubsd vfnmsubss vfrczpd vfrczps vfrczsd vfrczss vpcmov vpcomb vpcomd vpcomq vpcomub vpcomud vpcomuq vpcomuw vpcomw vphaddbd vphaddbq vphaddbw vphadddq vphaddubd vphaddubq vphaddubw vphaddudq vphadduwd vphadduwq vphaddwd vphaddwq vphsubbw vphsubdq vphsubwd vpmacsdd vpmacsdqh vpmacsdql vpmacssdd vpmacssdqh vpmacssdql vpmacsswd vpmacssww vpmacswd vpmacsww vpmadcsswd vpmadcswd vpperm vprotb vprotd vprotq vprotw vpshab vpshad vpshaq vpshaw vpshlb vpshld vpshlq vpshlw vbroadcasti128 vpblendd vpbroadcastb vpbroadcastw vpbroadcastd vpbroadcastq vpermd vpermpd vpermps vpermq vperm2i128 vextracti128 vinserti128 vpmaskmovd vpmaskmovq vpsllvd vpsllvq vpsravd vpsrlvd vpsrlvq vgatherdpd vgatherqpd vgatherdps vgatherqps vpgatherdd vpgatherqd vpgatherdq vpgatherqq xabort xbegin xend xtest andn bextr blci blcic blsi blsic blcfill blsfill blcmsk blsmsk blsr blcs bzhi mulx pdep pext rorx sarx shlx shrx tzcnt tzmsk t1mskc valignd valignq vblendmpd vblendmps vbroadcastf32x4 vbroadcastf64x4 vbroadcasti32x4 vbroadcasti64x4 vcompresspd vcompressps vcvtpd2udq vcvtps2udq vcvtsd2usi vcvtss2usi vcvttpd2udq vcvttps2udq vcvttsd2usi vcvttss2usi vcvtudq2pd vcvtudq2ps vcvtusi2sd vcvtusi2ss vexpandpd vexpandps vextractf32x4 vextractf64x4 vextracti32x4 vextracti64x4 vfixupimmpd vfixupimmps vfixupimmsd vfixupimmss vgetexppd vgetexpps vgetexpsd vgetexpss vgetmantpd vgetmantps vgetmantsd vgetmantss vinsertf32x4 vinsertf64x4 vinserti32x4 vinserti64x4 vmovdqa32 vmovdqa64 vmovdqu32 vmovdqu64 vpabsq vpandd vpandnd vpandnq vpandq vpblendmd vpblendmq vpcmpltd vpcmpled vpcmpneqd vpcmpnltd vpcmpnled vpcmpd vpcmpltq vpcmpleq vpcmpneqq vpcmpnltq vpcmpnleq vpcmpq vpcmpequd vpcmpltud vpcmpleud vpcmpnequd vpcmpnltud vpcmpnleud vpcmpud vpcmpequq vpcmpltuq vpcmpleuq vpcmpnequq vpcmpnltuq vpcmpnleuq vpcmpuq vpcompressd vpcompressq vpermi2d vpermi2pd vpermi2ps vpermi2q vpermt2d vpermt2pd vpermt2ps vpermt2q vpexpandd vpexpandq vpmaxsq vpmaxuq vpminsq vpminuq vpmovdb vpmovdw vpmovqb vpmovqd vpmovqw vpmovsdb vpmovsdw vpmovsqb vpmovsqd vpmovsqw vpmovusdb vpmovusdw vpmovusqb vpmovusqd vpmovusqw vpord vporq vprold vprolq vprolvd vprolvq vprord vprorq vprorvd vprorvq vpscatterdd vpscatterdq vpscatterqd vpscatterqq vpsraq vpsravq vpternlogd vpternlogq vptestmd vptestmq vptestnmd vptestnmq vpxord vpxorq vrcp14pd vrcp14ps vrcp14sd vrcp14ss vrndscalepd vrndscaleps vrndscalesd vrndscaless vrsqrt14pd vrsqrt14ps vrsqrt14sd vrsqrt14ss vscalefpd vscalefps vscalefsd vscalefss vscatterdpd vscatterdps vscatterqpd vscatterqps vshuff32x4 vshuff64x2 vshufi32x4 vshufi64x2 kandnw kandw kmovw knotw kortestw korw kshiftlw kshiftrw kunpckbw kxnorw kxorw vpbroadcastmb2q vpbroadcastmw2d vpconflictd vpconflictq vplzcntd vplzcntq vexp2pd vexp2ps vrcp28pd vrcp28ps vrcp28sd vrcp28ss vrsqrt28pd vrsqrt28ps vrsqrt28sd vrsqrt28ss vgatherpf0dpd vgatherpf0dps vgatherpf0qpd vgatherpf0qps vgatherpf1dpd vgatherpf1dps vgatherpf1qpd vgatherpf1qps vscatterpf0dpd vscatterpf0dps vscatterpf0qpd vscatterpf0qps vscatterpf1dpd vscatterpf1dps vscatterpf1qpd vscatterpf1qps prefetchwt1 bndmk bndcl bndcu bndcn bndmov bndldx bndstx sha1rnds4 sha1nexte sha1msg1 sha1msg2 sha256rnds2 sha256msg1 sha256msg2 hint_nop0 hint_nop1 hint_nop2 hint_nop3 hint_nop4 hint_nop5 hint_nop6 hint_nop7 hint_nop8 hint_nop9 hint_nop10 hint_nop11 hint_nop12 hint_nop13 hint_nop14 hint_nop15 hint_nop16 hint_nop17 hint_nop18 hint_nop19 hint_nop20 hint_nop21 hint_nop22 hint_nop23 hint_nop24 hint_nop25 hint_nop26 hint_nop27 hint_nop28 hint_nop29 hint_nop30 hint_nop31 hint_nop32 hint_nop33 hint_nop34 hint_nop35 hint_nop36 hint_nop37 hint_nop38 hint_nop39 hint_nop40 hint_nop41 hint_nop42 hint_nop43 hint_nop44 hint_nop45 hint_nop46 hint_nop47 hint_nop48 hint_nop49 hint_nop50 hint_nop51 hint_nop52 hint_nop53 hint_nop54 hint_nop55 hint_nop56 hint_nop57 hint_nop58 hint_nop59 hint_nop60 hint_nop61 hint_nop62 hint_nop63",built_in:"ip eip rip al ah bl bh cl ch dl dh sil dil bpl spl r8b r9b r10b r11b r12b r13b r14b r15b ax bx cx dx si di bp sp r8w r9w r10w r11w r12w r13w r14w r15w eax ebx ecx edx esi edi ebp esp eip r8d r9d r10d r11d r12d r13d r14d r15d rax rbx rcx rdx rsi rdi rbp rsp r8 r9 r10 r11 r12 r13 r14 r15 cs ds es fs gs ss st st0 st1 st2 st3 st4 st5 st6 st7 mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 xmm8 xmm9 xmm10 xmm11 xmm12 xmm13 xmm14 xmm15 xmm16 xmm17 xmm18 xmm19 xmm20 xmm21 xmm22 xmm23 xmm24 xmm25 xmm26 xmm27 xmm28 xmm29 xmm30 xmm31 ymm0 ymm1 ymm2 ymm3 ymm4 ymm5 ymm6 ymm7 ymm8 ymm9 ymm10 ymm11 ymm12 ymm13 ymm14 ymm15 ymm16 ymm17 ymm18 ymm19 ymm20 ymm21 ymm22 ymm23 ymm24 ymm25 ymm26 ymm27 ymm28 ymm29 ymm30 ymm31 zmm0 zmm1 zmm2 zmm3 zmm4 zmm5 zmm6 zmm7 zmm8 zmm9 zmm10 zmm11 zmm12 zmm13 zmm14 zmm15 zmm16 zmm17 zmm18 zmm19 zmm20 zmm21 zmm22 zmm23 zmm24 zmm25 zmm26 zmm27 zmm28 zmm29 zmm30 zmm31 k0 k1 k2 k3 k4 k5 k6 k7 bnd0 bnd1 bnd2 bnd3 cr0 cr1 cr2 cr3 cr4 cr8 dr0 dr1 dr2 dr3 dr8 tr3 tr4 tr5 tr6 tr7 r0 r1 r2 r3 r4 r5 r6 r7 r0b r1b r2b r3b r4b r5b r6b r7b r0w r1w r2w r3w r4w r5w r6w r7w r0d r1d r2d r3d r4d r5d r6d r7d r0h r1h r2h r3h r0l r1l r2l r3l r4l r5l r6l r7l r8l r9l r10l r11l r12l r13l r14l r15l db dw dd dq dt ddq do dy dz resb resw resd resq rest resdq reso resy resz incbin equ times byte word dword qword nosplit rel abs seg wrt strict near far a32 ptr",meta:"%define %xdefine %+ %undef %defstr %deftok %assign %strcat %strlen %substr %rotate %elif %else %endif %if %ifmacro %ifctx %ifidn %ifidni %ifid %ifnum %ifstr %iftoken %ifempty %ifenv %error %warning %fatal %rep %endrep %include %push %pop %repl %pathsearch %depend %use %arg %stacksize %local %line %comment %endcomment .nolist __FILE__ __LINE__ __SECT__ __BITS__ __OUTPUT_FORMAT__ __DATE__ __TIME__ __DATE_NUM__ __TIME_NUM__ __UTC_DATE__ __UTC_TIME__ __UTC_DATE_NUM__ __UTC_TIME_NUM__ __PASS__ struc endstruc istruc at iend align alignb sectalign daz nodaz up down zero default option assume public bits use16 use32 use64 default section segment absolute extern global common cpu float __utf16__ __utf16le__ __utf16be__ __utf32__ __utf32le__ __utf32be__ __float8__ __float16__ __float32__ __float64__ __float80m__ __float80e__ __float128l__ __float128h__ __Infinity__ __QNaN__ __SNaN__ Inf NaN QNaN SNaN float8 float16 float32 float64 float80m float80e float128l float128h __FLOAT_DAZ__ __FLOAT_ROUND__ __FLOAT__"},contains:[e.COMMENT(";","$",{relevance:0}),{className:"number",variants:[{begin:"\\b(?:([0-9][0-9_]*)?\\.[0-9_]*(?:[eE][+-]?[0-9_]+)?|(0[Xx])?[0-9][0-9_]*(\\.[0-9_]*)?(?:[pP](?:[+-]?[0-9_]+)?)?)\\b",relevance:0},{begin:"\\$[0-9][0-9A-Fa-f]*",relevance:0},{begin:"\\b(?:[0-9A-Fa-f][0-9A-Fa-f_]*[Hh]|[0-9][0-9_]*[DdTt]?|[0-7][0-7_]*[QqOo]|[0-1][0-1_]*[BbYy])\\b"},{begin:"\\b(?:0[Xx][0-9A-Fa-f_]+|0[DdTt][0-9_]+|0[QqOo][0-7_]+|0[BbYy][0-1_]+)\\b"}]},e.QUOTE_STRING_MODE,{className:"string",variants:[{begin:"'",end:"[^\\\\]'"},{begin:"`",end:"[^\\\\]`"}],relevance:0},{className:"symbol",variants:[{begin:"^\\s*[A-Za-z._?][A-Za-z0-9_$#@~.?]*(:|\\s+label)"},{begin:"^\\s*%%[A-Za-z0-9_$#@~.?]*:"}],relevance:0},{className:"subst",begin:"%[0-9]+",relevance:0},{className:"subst",begin:"%!S+",relevance:0},{className:"meta",begin:/^\s*\.[\w_-]+/}]}}return JW=t,JW}var eK,l2e;function _4t(){if(l2e)return eK;l2e=1;function t(e){const r=["if","then","else","do","while","until","for","loop","import","with","is","as","where","when","by","data","constant","integer","real","text","name","boolean","symbol","infix","prefix","postfix","block","tree"],n=["in","mod","rem","and","or","xor","not","abs","sign","floor","ceil","sqrt","sin","cos","tan","asin","acos","atan","exp","expm1","log","log2","log10","log1p","pi","at","text_length","text_range","text_find","text_replace","contains","page","slide","basic_slide","title_slide","title","subtitle","fade_in","fade_out","fade_at","clear_color","color","line_color","line_width","texture_wrap","texture_transform","texture","scale_?x","scale_?y","scale_?z?","translate_?x","translate_?y","translate_?z?","rotate_?x","rotate_?y","rotate_?z?","rectangle","circle","ellipse","sphere","path","line_to","move_to","quad_to","curve_to","theme","background","contents","locally","time","mouse_?x","mouse_?y","mouse_buttons"],i=["ObjectLoader","Animate","MovieCredits","Slides","Filters","Shading","Materials","LensFlare","Mapping","VLCAudioVideo","StereoDecoder","PointCloud","NetworkAccess","RemoteControl","RegExp","ChromaKey","Snowfall","NodeJS","Speech","Charts"],s={$pattern:/[a-zA-Z][a-zA-Z0-9_?]*/,keyword:r,literal:["true","false","nil"],built_in:n.concat(i)},o={className:"string",begin:'"',end:'"',illegal:"\\n"},l={className:"string",begin:"'",end:"'",illegal:"\\n"},u={className:"string",begin:"<<",end:">>"},d={className:"number",begin:"[0-9]+#[0-9A-Z_]+(\\.[0-9-A-Z_]+)?#?([Ee][+-]?[0-9]+)?"},h={beginKeywords:"import",end:"$",keywords:s,contains:[o]},f={className:"function",begin:/[a-z][^\n]*->/,returnBegin:!0,end:/->/,contains:[e.inherit(e.TITLE_MODE,{starts:{endsWithParent:!0,keywords:s}})]};return{name:"XL",aliases:["tao"],keywords:s,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,o,l,u,f,h,d,e.NUMBER_MODE]}}return eK=t,eK}var tK,c2e;function v4t(){if(c2e)return tK;c2e=1;function t(e){return{name:"XQuery",aliases:["xpath","xq","xqm"],case_insensitive:!1,illegal:/(proc)|(abstract)|(extends)|(until)|(#)/,keywords:{$pattern:/[a-zA-Z$][a-zA-Z0-9_:-]*/,keyword:["module","schema","namespace","boundary-space","preserve","no-preserve","strip","default","collation","base-uri","ordering","context","decimal-format","decimal-separator","copy-namespaces","empty-sequence","except","exponent-separator","external","grouping-separator","inherit","no-inherit","lax","minus-sign","per-mille","percent","schema-attribute","schema-element","strict","unordered","zero-digit","declare","import","option","function","validate","variable","for","at","in","let","where","order","group","by","return","if","then","else","tumbling","sliding","window","start","when","only","end","previous","next","stable","ascending","descending","allowing","empty","greatest","least","some","every","satisfies","switch","case","typeswitch","try","catch","and","or","to","union","intersect","instance","of","treat","as","castable","cast","map","array","delete","insert","into","replace","value","rename","copy","modify","update"],type:["item","document-node","node","attribute","document","element","comment","namespace","namespace-node","processing-instruction","text","construction","xs:anyAtomicType","xs:untypedAtomic","xs:duration","xs:time","xs:decimal","xs:float","xs:double","xs:gYearMonth","xs:gYear","xs:gMonthDay","xs:gMonth","xs:gDay","xs:boolean","xs:base64Binary","xs:hexBinary","xs:anyURI","xs:QName","xs:NOTATION","xs:dateTime","xs:dateTimeStamp","xs:date","xs:string","xs:normalizedString","xs:token","xs:language","xs:NMTOKEN","xs:Name","xs:NCName","xs:ID","xs:IDREF","xs:ENTITY","xs:integer","xs:nonPositiveInteger","xs:negativeInteger","xs:long","xs:int","xs:short","xs:byte","xs:nonNegativeInteger","xs:unisignedLong","xs:unsignedInt","xs:unsignedShort","xs:unsignedByte","xs:positiveInteger","xs:yearMonthDuration","xs:dayTimeDuration"],literal:["eq","ne","lt","le","gt","ge","is","self::","child::","descendant::","descendant-or-self::","attribute::","following::","following-sibling::","parent::","ancestor::","ancestor-or-self::","preceding::","preceding-sibling::","NaN"]},contains:[{className:"variable",begin:/[$][\w\-:]+/},{className:"built_in",variants:[{begin:/\barray:/,end:/(?:append|filter|flatten|fold-(?:left|right)|for-each(?:-pair)?|get|head|insert-before|join|put|remove|reverse|size|sort|subarray|tail)\b/},{begin:/\bmap:/,end:/(?:contains|entry|find|for-each|get|keys|merge|put|remove|size)\b/},{begin:/\bmath:/,end:/(?:a(?:cos|sin|tan[2]?)|cos|exp(?:10)?|log(?:10)?|pi|pow|sin|sqrt|tan)\b/},{begin:/\bop:/,end:/\(/,excludeEnd:!0},{begin:/\bfn:/,end:/\(/,excludeEnd:!0},{begin:/[^/,end:/(\/[\w._:-]+>)/,subLanguage:"xml",contains:[{begin:/\{/,end:/\}/,subLanguage:"xquery"},"self"]}]}}return tK=t,tK}var rK,u2e;function y4t(){if(u2e)return rK;u2e=1;function t(e){const r={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[e.inherit(e.APOS_STRING_MODE,{illegal:null}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null})]},n=e.UNDERSCORE_TITLE_MODE,i={variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]},a="namespace class interface use extends function return abstract final public protected private static deprecated throw try catch Exception echo empty isset instanceof unset let var new const self require if else elseif switch case default do while loop for continue break likely unlikely __LINE__ __FILE__ __DIR__ __FUNCTION__ __CLASS__ __TRAIT__ __METHOD__ __NAMESPACE__ array boolean float double integer object resource string char long unsigned bool int uint ulong uchar true false null undefined";return{name:"Zephir",aliases:["zep"],keywords:a,contains:[e.C_LINE_COMMENT_MODE,e.COMMENT(/\/\*/,/\*\//,{contains:[{className:"doctag",begin:/@[A-Za-z]+/}]}),{className:"string",begin:/<<<['"]?\w+['"]?$/,end:/^\w+;/,contains:[e.BACKSLASH_ESCAPE]},{begin:/(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/},{className:"function",beginKeywords:"function fn",end:/[;{]/,excludeEnd:!0,illegal:/\$|\[|%/,contains:[n,{className:"params",begin:/\(/,end:/\)/,keywords:a,contains:["self",e.C_BLOCK_COMMENT_MODE,r,i]}]},{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,illegal:/[:($"]/,contains:[{beginKeywords:"extends implements"},n]},{beginKeywords:"namespace",end:/;/,illegal:/[.']/,contains:[n]},{beginKeywords:"use",end:/;/,contains:[n]},{begin:/=>/},r,i]}}return rK=t,rK}var nK,d2e;function b4t(){if(d2e)return nK;d2e=1;var t=ZIe();return t.registerLanguage("1c",Hwt()),t.registerLanguage("abnf",Vwt()),t.registerLanguage("accesslog",Ywt()),t.registerLanguage("actionscript",Wwt()),t.registerLanguage("ada",Kwt()),t.registerLanguage("angelscript",jwt()),t.registerLanguage("apache",Xwt()),t.registerLanguage("applescript",Qwt()),t.registerLanguage("arcade",Zwt()),t.registerLanguage("arduino",Jwt()),t.registerLanguage("armasm",e3t()),t.registerLanguage("xml",t3t()),t.registerLanguage("asciidoc",r3t()),t.registerLanguage("aspectj",n3t()),t.registerLanguage("autohotkey",i3t()),t.registerLanguage("autoit",a3t()),t.registerLanguage("avrasm",s3t()),t.registerLanguage("awk",o3t()),t.registerLanguage("axapta",l3t()),t.registerLanguage("bash",c3t()),t.registerLanguage("basic",u3t()),t.registerLanguage("bnf",d3t()),t.registerLanguage("brainfuck",h3t()),t.registerLanguage("c",f3t()),t.registerLanguage("cal",p3t()),t.registerLanguage("capnproto",g3t()),t.registerLanguage("ceylon",m3t()),t.registerLanguage("clean",_3t()),t.registerLanguage("clojure",v3t()),t.registerLanguage("clojure-repl",y3t()),t.registerLanguage("cmake",b3t()),t.registerLanguage("coffeescript",S3t()),t.registerLanguage("coq",E3t()),t.registerLanguage("cos",T3t()),t.registerLanguage("cpp",C3t()),t.registerLanguage("crmsh",w3t()),t.registerLanguage("crystal",x3t()),t.registerLanguage("csharp",A3t()),t.registerLanguage("csp",R3t()),t.registerLanguage("css",N3t()),t.registerLanguage("d",O3t()),t.registerLanguage("markdown",I3t()),t.registerLanguage("dart",k3t()),t.registerLanguage("delphi",D3t()),t.registerLanguage("diff",M3t()),t.registerLanguage("django",L3t()),t.registerLanguage("dns",P3t()),t.registerLanguage("dockerfile",F3t()),t.registerLanguage("dos",B3t()),t.registerLanguage("dsconfig",U3t()),t.registerLanguage("dts",$3t()),t.registerLanguage("dust",G3t()),t.registerLanguage("ebnf",z3t()),t.registerLanguage("elixir",q3t()),t.registerLanguage("elm",H3t()),t.registerLanguage("ruby",V3t()),t.registerLanguage("erb",Y3t()),t.registerLanguage("erlang-repl",W3t()),t.registerLanguage("erlang",K3t()),t.registerLanguage("excel",j3t()),t.registerLanguage("fix",X3t()),t.registerLanguage("flix",Q3t()),t.registerLanguage("fortran",Z3t()),t.registerLanguage("fsharp",J3t()),t.registerLanguage("gams",e5t()),t.registerLanguage("gauss",t5t()),t.registerLanguage("gcode",r5t()),t.registerLanguage("gherkin",n5t()),t.registerLanguage("glsl",i5t()),t.registerLanguage("gml",a5t()),t.registerLanguage("go",s5t()),t.registerLanguage("golo",o5t()),t.registerLanguage("gradle",l5t()),t.registerLanguage("graphql",c5t()),t.registerLanguage("groovy",u5t()),t.registerLanguage("haml",d5t()),t.registerLanguage("handlebars",h5t()),t.registerLanguage("haskell",f5t()),t.registerLanguage("haxe",p5t()),t.registerLanguage("hsp",g5t()),t.registerLanguage("http",m5t()),t.registerLanguage("hy",_5t()),t.registerLanguage("inform7",v5t()),t.registerLanguage("ini",y5t()),t.registerLanguage("irpf90",b5t()),t.registerLanguage("isbl",S5t()),t.registerLanguage("java",E5t()),t.registerLanguage("javascript",T5t()),t.registerLanguage("jboss-cli",C5t()),t.registerLanguage("json",w5t()),t.registerLanguage("julia",x5t()),t.registerLanguage("julia-repl",A5t()),t.registerLanguage("kotlin",R5t()),t.registerLanguage("lasso",N5t()),t.registerLanguage("latex",O5t()),t.registerLanguage("ldif",I5t()),t.registerLanguage("leaf",k5t()),t.registerLanguage("less",D5t()),t.registerLanguage("lisp",M5t()),t.registerLanguage("livecodeserver",L5t()),t.registerLanguage("livescript",P5t()),t.registerLanguage("llvm",F5t()),t.registerLanguage("lsl",B5t()),t.registerLanguage("lua",U5t()),t.registerLanguage("makefile",$5t()),t.registerLanguage("mathematica",G5t()),t.registerLanguage("matlab",z5t()),t.registerLanguage("maxima",q5t()),t.registerLanguage("mel",H5t()),t.registerLanguage("mercury",V5t()),t.registerLanguage("mipsasm",Y5t()),t.registerLanguage("mizar",W5t()),t.registerLanguage("perl",K5t()),t.registerLanguage("mojolicious",j5t()),t.registerLanguage("monkey",X5t()),t.registerLanguage("moonscript",Q5t()),t.registerLanguage("n1ql",Z5t()),t.registerLanguage("nestedtext",J5t()),t.registerLanguage("nginx",ext()),t.registerLanguage("nim",txt()),t.registerLanguage("nix",rxt()),t.registerLanguage("node-repl",nxt()),t.registerLanguage("nsis",ixt()),t.registerLanguage("objectivec",axt()),t.registerLanguage("ocaml",sxt()),t.registerLanguage("openscad",oxt()),t.registerLanguage("oxygene",lxt()),t.registerLanguage("parser3",cxt()),t.registerLanguage("pf",uxt()),t.registerLanguage("pgsql",dxt()),t.registerLanguage("php",hxt()),t.registerLanguage("php-template",fxt()),t.registerLanguage("plaintext",pxt()),t.registerLanguage("pony",gxt()),t.registerLanguage("powershell",mxt()),t.registerLanguage("processing",_xt()),t.registerLanguage("profile",vxt()),t.registerLanguage("prolog",yxt()),t.registerLanguage("properties",bxt()),t.registerLanguage("protobuf",Sxt()),t.registerLanguage("puppet",Ext()),t.registerLanguage("purebasic",Txt()),t.registerLanguage("python",Cxt()),t.registerLanguage("python-repl",wxt()),t.registerLanguage("q",xxt()),t.registerLanguage("qml",Axt()),t.registerLanguage("r",Rxt()),t.registerLanguage("reasonml",Nxt()),t.registerLanguage("rib",Oxt()),t.registerLanguage("roboconf",Ixt()),t.registerLanguage("routeros",kxt()),t.registerLanguage("rsl",Dxt()),t.registerLanguage("ruleslanguage",Mxt()),t.registerLanguage("rust",Lxt()),t.registerLanguage("sas",Pxt()),t.registerLanguage("scala",Fxt()),t.registerLanguage("scheme",Bxt()),t.registerLanguage("scilab",Uxt()),t.registerLanguage("scss",$xt()),t.registerLanguage("shell",Gxt()),t.registerLanguage("smali",zxt()),t.registerLanguage("smalltalk",qxt()),t.registerLanguage("sml",Hxt()),t.registerLanguage("sqf",Vxt()),t.registerLanguage("sql",Yxt()),t.registerLanguage("stan",Wxt()),t.registerLanguage("stata",Kxt()),t.registerLanguage("step21",jxt()),t.registerLanguage("stylus",Xxt()),t.registerLanguage("subunit",Qxt()),t.registerLanguage("swift",Zxt()),t.registerLanguage("taggerscript",Jxt()),t.registerLanguage("yaml",e4t()),t.registerLanguage("tap",t4t()),t.registerLanguage("tcl",r4t()),t.registerLanguage("thrift",n4t()),t.registerLanguage("tp",i4t()),t.registerLanguage("twig",a4t()),t.registerLanguage("typescript",s4t()),t.registerLanguage("vala",o4t()),t.registerLanguage("vbnet",l4t()),t.registerLanguage("vbscript",c4t()),t.registerLanguage("vbscript-html",u4t()),t.registerLanguage("verilog",d4t()),t.registerLanguage("vhdl",h4t()),t.registerLanguage("vim",f4t()),t.registerLanguage("wasm",p4t()),t.registerLanguage("wren",g4t()),t.registerLanguage("x86asm",m4t()),t.registerLanguage("xl",_4t()),t.registerLanguage("xquery",v4t()),t.registerLanguage("zephir",y4t()),t.HighlightJS=t,t.default=t,nK=t,nK}var S4t=b4t();const iK=kd(S4t),E4t=/^ {0,3}(`{3,})(.*)$/;function T4t(t){if(!t.includes("```"))return t;const e=t.split(Na);let r=!1,n=!1;for(let i=0;i=w4t&&TA.delete(TA.keys().next().value),TA.set(n,s),s}function x4t(t){const e=new RegExp(a_e.source,a_e.flags),r=[];let n;for(;(n=e.exec(t))!==null;){const d=n[0].startsWith(Na)?n.index+1:n.index;r.push(d)}if(r.length%2===0)return null;const i=r[r.length-1],s=t.slice(i+3).match(FEt),o=s?.[1]||WU,l=i+3+(s?.[0]?.length??0);return{code:t.slice(l),language:o,openingIndex:i}}function Nm(t,e,r){e in t&&(t[e]=r)}function ky(t,e){return t[e]}function A4t(t,e){const r={};for(const n of e){const i=ky(t,n);i!==void 0&&(r[n]=i)}return r}function zO(t){const e=`${tl}${FJ}`,r=new URL(e,window.location.origin);return r.searchParams.set(MTt,t),r}function R4t(t){const e={};for(const[r,n]of Object.entries(t))e[`${GR}${r}`]=n;return e}function N4t(t){return!!(t.includes(":")||/^\d{1,3}(\.\d{1,3}){3}$/.test(t))}function O4t(t){const e=t.hostname.toLowerCase();if(!e||N4t(e))return null;const r=e.split(".");if(r.length<2)return null;if(r.length>=3){const n=`${r[r.length-2]}.${r[r.length-1]}`;if(WCt.has(n))return r.slice(-3).join(".")}for(let n=2;n<=r.length;n++){const i=r.slice(-n).join(".");if(KCt.has(i))return r.length===n+1?e:r.slice(-(n+2)).join(".")}return r.slice(-2).join(".")}function JIe(t){try{const e=new URL(t);return e.protocol!==Uu.HTTP&&e.protocol!==Uu.HTTPS?null:e.href}catch{return null}}function qO(t){const e=t.trim();try{const r=new URL(e),n=r.pathname.replace(sx,""),i=r.hostname.toLowerCase();return`${r.protocol}//${i}${n}${r.search}`}catch{return e.toLowerCase().replace(sx,"")}}function I4t(t){return SCt[t]}function XU(t){if(!t)return 0;const{current:e,stages:r=[],value:n}=t,a=1-Math.max(r.length-1,0)*E_e,s=r.indexOf(e);return s<=0?n*a:a+(s-1+n)*E_e}function eke(t){if(!t)return null;const e=I4t(t.current);return e?`${e} ${Math.round(XU(t)*100)}%`:null}function f2e(t){const e=new Map;for(const r of t)e.set(r.conv.id,r.messages.length);return e}const k4t=Array(12).fill(0);var D4t=se('
    '),M4t=se('
    ');function L4t(t,e){at(e,!0);var r=M4t(),n=te(r);qr(n,23,()=>k4t,(i,a)=>`spinner-bar-${a}`,(i,a)=>{var s=D4t();G(i,s)}),Z(n),Z(r),$e(i=>{Yt(r,1,i),lr(r,"data-visible",e.visible)},[()=>dn(["sonner-loading-wrapper",e.class].filter(Boolean).join(" "))]),G(t,r),st()}function Yp(...t){return t.filter(Boolean).join(" ")}const P4t=typeof document<"u",F4t=typeof window<"u"?window:void 0;function B4t(t){let e=t.activeElement;for(;e?.shadowRoot;){const r=e.shadowRoot.activeElement;if(r===e)break;e=r}return e}class U4t{#e;#t;constructor(e={}){const{window:r=F4t,document:n=r?.document}=e;r!==void 0&&(this.#e=n,this.#t=Tv(i=>{const a=Bi(r,"focusin",i),s=Bi(r,"focusout",i);return()=>{a(),s()}}))}get current(){return this.#t?.(),this.#e?B4t(this.#e):null}}new U4t;class $4t{#e;#t;constructor(e){this.#e=e,this.#t=Symbol(e)}get key(){return this.#t}exists(){return mse(this.#t)}get(){const e=q_(this.#t);if(e===void 0)throw new Error(`Context "${this.#e}" not found`);return e}getOr(e){const r=q_(this.#t);return r===void 0?e:r}set(e){return s4(this.#t,e)}}const G4t=new $4t("");let p2e=0;class z4t{#e=Oe(Zr([]));get toasts(){return S(this.#e)}set toasts(e){X(this.#e,e,!0)}#t=Oe(Zr([]));get heights(){return S(this.#t)}set heights(e){X(this.#t,e,!0)}#r=e=>{const r=this.toasts.findIndex(n=>n.id===e);return r===-1?null:r};addToast=e=>{P4t&&this.toasts.unshift(e)};updateToast=({id:e,data:r,type:n,message:i})=>{const a=this.toasts.findIndex(o=>o.id===e),s=this.toasts[a];this.toasts[a]={...s,...r,id:e,title:i,type:n,updated:!0}};create=e=>{const{message:r,...n}=e,i=typeof e?.id=="number"||e.id&&e.id?.length>0?e.id:p2e++,a=e.dismissible!==void 0?e.dismissible:e.dismissable!==void 0?e.dismissable:!0,s=e.type===void 0?"default":e.type;return zi(()=>{this.toasts.find(l=>l.id===i)?this.updateToast({id:i,data:e,type:s,message:r,dismissible:a}):this.addToast({...n,id:i,title:r,dismissible:a,type:s})}),i};dismiss=e=>(zi(()=>{if(e===void 0){this.toasts=this.toasts.map(n=>({...n,dismiss:!0}));return}const r=this.toasts.findIndex(n=>n.id===e);this.toasts[r]&&(this.toasts[r]={...this.toasts[r],dismiss:!0})}),e);remove=e=>{if(e===void 0){this.toasts=[];return}const r=this.#r(e);if(r!==null)return this.toasts.splice(r,1),e};message=(e,r)=>this.create({...r,type:"default",message:e});error=(e,r)=>this.create({...r,type:"error",message:e});success=(e,r)=>this.create({...r,type:"success",message:e});info=(e,r)=>this.create({...r,type:"info",message:e});warning=(e,r)=>this.create({...r,type:"warning",message:e});loading=(e,r)=>this.create({...r,type:"loading",message:e});promise=(e,r)=>{if(!r)return;let n;r.loading!==void 0&&(n=this.create({...r,promise:e,type:"loading",message:typeof r.loading=="string"?r.loading:r.loading()}));const i=e instanceof Promise?e:e();let a=n!==void 0;return i.then(s=>{if(typeof s=="object"&&s&&"ok"in s&&typeof s.ok=="boolean"&&!s.ok){a=!1;const o=q4t(s);this.create({id:n,type:"error",message:o})}else if(r.success!==void 0){a=!1;const o=typeof r.success=="function"?r.success(s):r.success;this.create({id:n,type:"success",message:o})}}).catch(s=>{if(r.error!==void 0){a=!1;const o=typeof r.error=="function"?r.error(s):r.error;this.create({id:n,type:"error",message:o})}}).finally(()=>{a&&(this.dismiss(n),n=void 0),r.finally?.()}),n};custom=(e,r)=>{const n=r?.id||p2e++;return this.create({component:e,id:n,...r}),n};removeHeight=e=>{this.heights=this.heights.filter(r=>r.toastId!==e)};setHeight=e=>{const r=this.#r(e.toastId);if(r===null){this.heights.push(e);return}this.heights[r]=e};reset=()=>{this.toasts=[],this.heights=[]}}function q4t(t){return t&&typeof t=="object"&&"status"in t?`HTTP error! Status: ${t.status}`:`Error! ${t}`}const Za=new z4t;function H4t(t,e){return Za.create({message:t,...e})}class V4t{#e=W(()=>Za.toasts.filter(e=>!e.dismiss));get toasts(){return S(this.#e)}}const Y4t=H4t,Qi=Object.assign(Y4t,{success:Za.success,info:Za.info,warning:Za.warning,error:Za.error,custom:Za.custom,message:Za.message,promise:Za.promise,dismiss:Za.dismiss,loading:Za.loading,getActiveToasts:()=>Za.toasts.filter(t=>!t.dismiss)});function HO(t){return t.label!==void 0}function W4t(){let t=Oe(Zr(typeof document<"u"?document.hidden:!1));return Kt(()=>Bi(document,"visibilitychange",()=>{X(t,document.hidden,!0)})),{get current(){return S(t)}}}const g2e=4e3,K4t=14,j4t=45,X4t=200,Q4t=.05,Z4t={toast:"",title:"",description:"",loader:"",closeButton:"",cancelButton:"",actionButton:"",action:"",warning:"",error:"",success:"",default:"",info:"",loading:""};function J4t(t){const[e,r]=t.split("-"),n=[];return e&&n.push(e),r&&n.push(r),n}function m2e(t){return 1/(1.5+Math.abs(t)/20)}var eAt=se("
    "),tAt=se(''),rAt=se('
    '),nAt=se('
    '),iAt=se(''),aAt=se(''),sAt=se('
    ',1),oAt=se('
    • ');function lAt(t,e){at(e,!0);const r=rt=>{var Ne=Ae(),et=oe(Ne);{var ut=qe=>{var Ze=eAt(),De=te(Ze);Pt(De,()=>e.loadingIcon),Z(Ze),$e(Fe=>{Yt(Ze,1,Fe),lr(Ze,"data-visible",S(C)==="loading")},[()=>dn(Yp(S(U)?.loader,e.toast?.classes?.loader,"sonner-loader"))]),G(qe,Ze)},Pe=qe=>{{let Ze=W(()=>Yp(S(U)?.loader,e.toast.classes?.loader)),De=W(()=>S(C)==="loading");L4t(qe,{get class(){return S(Ze)},get visible(){return S(De)}})}};ve(et,qe=>{e.loadingIcon?qe(ut):qe(Pe,-1)})}G(rt,Ne)};let n=ce(e,"cancelButtonStyle",3,""),i=ce(e,"actionButtonStyle",3,""),a=ce(e,"descriptionClass",3,""),s=ce(e,"unstyled",3,!1),o=ce(e,"defaultRichColors",3,!1);const l={...Z4t};let u=Oe(!1),d=Oe(!1),h=Oe(!1),f=Oe(!1),p=Oe(!1),g=Oe(0),m=Oe(0),_=e.toast.duration||e.duration||g2e,v=Oe(void 0),b=Oe(null),y=Oe(null);const E=W(()=>e.index===0),T=W(()=>e.index+1<=e.visibleToasts),C=W(()=>e.toast.type),w=W(()=>e.toast.dismissible!==void 0?e.toast.dismissible!==!1:e.toast.dismissable!==!1),x=W(()=>e.toast.class||""),A=W(()=>e.toast.descriptionClass||""),R=W(()=>Za.heights.findIndex(rt=>rt.toastId===e.toast.id)||0),O=W(()=>e.toast.closeButton??e.closeButton),F=W(()=>e.toast.duration??e.duration??g2e);let P=null;const N=W(()=>e.position.split("-")),k=W(()=>Za.heights.reduce((rt,Ne,et)=>et>=S(R)?rt:rt+Ne.height,0)),M=W4t(),L=W(()=>e.toast.invert||e.invert),I=W(()=>S(C)==="loading"),U=W(()=>({...l,...e.classes})),B=W(()=>e.toast.title),$=W(()=>e.toast.description);let H=Oe(0),q=Oe(0);const V=W(()=>Math.round(S(R)*K4t+S(k)));Kt(()=>{S(B),S($);let rt;e.expanded||e.expandByDefault?rt=1:rt=1-e.index*Q4t;const Ne=zi(()=>S(v));if(Ne===void 0)return;Ne.style.setProperty("height","auto");const et=Ne.offsetHeight,ut=Ne.getBoundingClientRect().height,Pe=Math.round(ut/rt+Number.EPSILON&100)/100;Ne.style.removeProperty("height");let qe;Math.abs(Pe-et)<1?qe=Pe:qe=et,X(m,qe,!0),Za.setHeight({toastId:e.toast.id,height:qe})});function Y(){X(d,!0),X(g,S(V),!0),Za.removeHeight(e.toast.id),setTimeout(()=>{Za.remove(e.toast.id)},X4t)}let j;const Q=W(()=>e.toast.promise&&S(C)==="loading"||e.toast.duration===Number.POSITIVE_INFINITY);function ae(){X(H,new Date().getTime(),!0),j=setTimeout(()=>{e.toast.onAutoClose?.(e.toast),Y()},_)}function re(){if(S(q){e.toast.updated&&(clearTimeout(j),_=S(F),S(Q)||ae())}),Kt(()=>(S(Q)||(e.expanded||e.interacting||e.pauseWhenPageIsHidden&&M.current?re():ae()),()=>clearTimeout(j))),uo(()=>{X(u,!0);const rt=S(v)?.getBoundingClientRect().height;return X(m,rt,!0),Za.setHeight({toastId:e.toast.id,height:rt}),()=>{Za.removeHeight(e.toast.id)}}),Kt(()=>{e.toast.delete&&zi(()=>{Y(),e.toast.onDismiss?.(e.toast)})});const ne=rt=>{if(S(I))return;X(g,S(V),!0);const Ne=rt.target;Ne.setPointerCapture(rt.pointerId),Ne.tagName!=="BUTTON"&&(X(h,!0),P={x:rt.clientX,y:rt.clientY})},ee=()=>{if(S(f)||!S(w))return;P=null;const rt=Number(S(v)?.style.getPropertyValue("--swipe-amount-x").replace("px","")||0),Ne=Number(S(v)?.style.getPropertyValue("--swipe-amount-y").replace("px","")||0),et=new Date().getTime()-0,ut=S(b)==="x"?rt:Ne,Pe=Math.abs(ut)/et;if(Math.abs(ut)>=j4t||Pe>.11){X(g,S(V),!0),e.toast.onDismiss?.(e.toast),S(b)==="x"?X(y,rt>0?"right":"left",!0):X(y,Ne>0?"down":"up",!0),Y(),X(f,!0);return}else S(v)?.style.setProperty("--swipe-amount-x","0px"),S(v)?.style.setProperty("--swipe-amount-y","0px");X(p,!1),X(h,!1),X(b,null)},J=rt=>{if(!P||!S(w)||(window.getSelection()?.toString().length??-1)>0)return;const et=rt.clientY-P.y,ut=rt.clientX-P.x,Pe=e.swipeDirections??J4t(e.position);!S(b)&&(Math.abs(ut)>1||Math.abs(et)>1)&&X(b,Math.abs(ut)>Math.abs(et)?"x":"y",!0);let qe={x:0,y:0};if(S(b)==="y"){if(Pe.includes("top")||Pe.includes("bottom"))if(Pe.includes("top")&&et<0||Pe.includes("bottom")&&et>0)qe.y=et;else{const Ze=et*m2e(et);qe.y=Math.abs(Ze)0)qe.x=ut;else{const Ze=ut*m2e(ut);qe.x=Math.abs(Ze)0||Math.abs(qe.y)>0)&&X(p,!0),S(v)?.style.setProperty("--swipe-amount-x",`${qe.x}px`),S(v)?.style.setProperty("--swipe-amount-y",`${qe.y}px`)},fe=()=>{X(h,!1),X(b,null),P=null},ue=W(()=>e.toast.icon?e.toast.icon:S(C)==="success"?e.successIcon:S(C)==="error"?e.errorIcon:S(C)==="warning"?e.warningIcon:S(C)==="info"?e.infoIcon:S(C)==="loading"?e.loadingIcon:null);var ge=oAt();lr(ge,"tabindex",0);let ye;var Ie=te(ge);{var we=rt=>{var Ne=tAt(),et=te(Ne);Pt(et,()=>e.closeIcon??Vt),Z(Ne),$e(ut=>{lr(Ne,"aria-label",e.closeButtonAriaLabel),lr(Ne,"data-disabled",S(I)),Yt(Ne,1,ut)},[()=>dn(Yp(S(U)?.closeButton,e.toast?.classes?.closeButton))]),Kr("click",Ne,()=>{S(I)||!S(w)||(Y(),e.toast.onDismiss?.(e.toast))}),G(rt,Ne)};ve(Ie,rt=>{S(O)&&!e.toast.component&&S(C)!=="loading"&&e.closeIcon!==null&&rt(we)})}var Te=ie(Ie,2);{var Ve=rt=>{const Ne=W(()=>e.toast.component);var et=Ae(),ut=oe(et);Me(ut,()=>S(Ne),(Pe,qe)=>{qe(Pe,Rt(()=>e.toast.componentProps,{closeToast:Y}))}),G(rt,et)},Ce=rt=>{var Ne=sAt(),et=oe(Ne);{var ut=He=>{var Re=rAt(),Xe=te(Re);{var je=ht=>{var tt=Ae(),Ge=oe(tt);{var xe=Ye=>{var kt=Ae(),At=oe(kt);Me(At,()=>e.toast.icon,(ft,wt)=>{wt(ft,{})}),G(Ye,kt)},mt=Ye=>{r(Ye)};ve(Ge,Ye=>{e.toast.icon?Ye(xe):Ye(mt,-1)})}G(ht,tt)};ve(Xe,ht=>{(e.toast.promise||S(C)==="loading")&&ht(je)})}var Be=ie(Xe,2);{var Je=ht=>{var tt=Ae(),Ge=oe(tt);{var xe=ft=>{var wt=Ae(),bt=oe(wt);Me(bt,()=>e.toast.icon,(Gt,Ue)=>{Ue(Gt,{})}),G(ft,wt)},mt=ft=>{var wt=Ae(),bt=oe(wt);Pt(bt,()=>e.successIcon??Vt),G(ft,wt)},Ye=ft=>{var wt=Ae(),bt=oe(wt);Pt(bt,()=>e.errorIcon??Vt),G(ft,wt)},kt=ft=>{var wt=Ae(),bt=oe(wt);Pt(bt,()=>e.warningIcon??Vt),G(ft,wt)},At=ft=>{var wt=Ae(),bt=oe(wt);Pt(bt,()=>e.infoIcon??Vt),G(ft,wt)};ve(Ge,ft=>{e.toast.icon?ft(xe):S(C)==="success"?ft(mt,1):S(C)==="error"?ft(Ye,2):S(C)==="warning"?ft(kt,3):S(C)==="info"&&ft(At,4)})}G(ht,tt)};ve(Be,ht=>{e.toast.type!=="loading"&&ht(Je)})}Z(Re),$e(ht=>Yt(Re,1,ht),[()=>dn(Yp(S(U)?.icon,e.toast?.classes?.icon))]),G(He,Re)};ve(et,He=>{(S(C)||e.toast.icon||e.toast.promise)&&e.toast.icon!==null&&(S(ue)!==null||e.toast.icon)&&He(ut)})}var Pe=ie(et,2),qe=te(Pe),Ze=te(qe);{var De=He=>{var Re=Ae(),Xe=oe(Re);{var je=Je=>{const ht=W(()=>e.toast.title);var tt=Ae(),Ge=oe(tt);Me(Ge,()=>S(ht),(xe,mt)=>{mt(xe,Rt(()=>e.toast.componentProps))}),G(Je,tt)},Be=Je=>{var ht=or();$e(()=>it(ht,e.toast.title)),G(Je,ht)};ve(Xe,Je=>{typeof e.toast.title!="string"?Je(je):Je(Be,-1)})}G(He,Re)};ve(Ze,He=>{e.toast.title&&He(De)})}Z(qe);var Fe=ie(qe,2);{var de=He=>{var Re=nAt(),Xe=te(Re);{var je=Je=>{const ht=W(()=>e.toast.description);var tt=Ae(),Ge=oe(tt);Me(Ge,()=>S(ht),(xe,mt)=>{mt(xe,Rt(()=>e.toast.componentProps))}),G(Je,tt)},Be=Je=>{var ht=or();$e(()=>it(ht,e.toast.description)),G(Je,ht)};ve(Xe,Je=>{typeof e.toast.description!="string"?Je(je):Je(Be,-1)})}Z(Re),$e(Je=>Yt(Re,1,Je),[()=>dn(Yp(a(),S(A),S(U)?.description,e.toast.classes?.description))]),G(He,Re)};ve(Fe,He=>{e.toast.description&&He(de)})}Z(Pe);var Ee=ie(Pe,2);{var he=He=>{var Re=Ae(),Xe=oe(Re);{var je=ht=>{var tt=Ae(),Ge=oe(tt);Me(Ge,()=>e.toast.cancel,(xe,mt)=>{mt(xe,{})}),G(ht,tt)},Be=ht=>{var tt=iAt(),Ge=te(tt,!0);Z(tt),$e(xe=>{zs(tt,e.toast.cancelButtonStyle??n()),Yt(tt,1,xe),it(Ge,e.toast.cancel.label)},[()=>dn(Yp(S(U)?.cancelButton,e.toast?.classes?.cancelButton))]),Kr("click",tt,xe=>{HO(e.toast.cancel)&&S(w)&&(e.toast.cancel?.onClick?.(xe),Y())}),G(ht,tt)},Je=W(()=>HO(e.toast.cancel));ve(Xe,ht=>{typeof e.toast.cancel=="function"?ht(je):S(Je)&&ht(Be,1)})}G(He,Re)};ve(Ee,He=>{e.toast.cancel&&He(he)})}var Le=ie(Ee,2);{var _e=He=>{var Re=Ae(),Xe=oe(Re);{var je=ht=>{var tt=Ae(),Ge=oe(tt);Me(Ge,()=>e.toast.action,(xe,mt)=>{mt(xe,{})}),G(ht,tt)},Be=ht=>{var tt=aAt(),Ge=te(tt,!0);Z(tt),$e(xe=>{zs(tt,e.toast.actionButtonStyle??i()),Yt(tt,1,xe),it(Ge,e.toast.action.label)},[()=>dn(Yp(S(U)?.actionButton,e.toast?.classes?.actionButton))]),Kr("click",tt,xe=>{HO(e.toast.action)&&(e.toast.action?.onClick(xe),!xe.defaultPrevented&&Y())}),G(ht,tt)},Je=W(()=>HO(e.toast.action));ve(Xe,ht=>{typeof e.toast.action=="function"?ht(je):S(Je)&&ht(Be,1)})}G(He,Re)};ve(Le,He=>{e.toast.action&&He(_e)})}$e((He,Re)=>{Yt(Pe,1,He),Yt(qe,1,Re)},[()=>dn(Yp(S(U)?.content,e.toast?.classes?.content)),()=>dn(Yp(S(U)?.title,e.toast?.classes?.title))]),G(rt,Ne)};ve(Te,rt=>{e.toast.component?rt(Ve):rt(Ce,-1)})}Z(ge),Jr(ge,rt=>X(v,rt),()=>S(v)),$e((rt,Ne,et)=>{Yt(ge,1,rt),lr(ge,"aria-live",e.toast.important?"assertive":"polite"),lr(ge,"data-rich-colors",e.toast.richColors??o()),lr(ge,"data-styled",!(e.toast.component||e.toast.unstyled||s())),lr(ge,"data-mounted",S(u)),lr(ge,"data-promise",Ne),lr(ge,"data-swiped",S(p)),lr(ge,"data-removed",S(d)),lr(ge,"data-visible",S(T)),lr(ge,"data-y-position",S(N)[0]),lr(ge,"data-x-position",S(N)[1]),lr(ge,"data-index",e.index),lr(ge,"data-front",S(E)),lr(ge,"data-swiping",S(h)),lr(ge,"data-dismissible",S(w)),lr(ge,"data-type",S(C)),lr(ge,"data-invert",S(L)),lr(ge,"data-swipe-out",S(f)),lr(ge,"data-swipe-direction",S(y)),lr(ge,"data-expanded",et),ye=zs(ge,`${e.style} ${e.toast.style}`,ye,{"--index":e.index,"--toasts-before":e.index,"--z-index":Za.toasts.length-e.index,"--offset":`${S(d)?S(g):S(V)}px`,"--initial-height":e.expandByDefault?"auto":`${S(m)}px`})},[()=>dn(Yp(e.class,S(x),S(U)?.toast,e.toast?.classes?.toast,S(U)?.[S(C)],e.toast?.classes?.[S(C)])),()=>!!e.toast.promise,()=>!!(e.expanded||e.expandByDefault&&S(u))]),Kr("pointermove",ge,J),Kr("pointerup",ge,ee),Kr("pointerdown",ge,ne),Zn("dragend",ge,fe),G(t,ge),st()}Hi(["pointermove","pointerup","pointerdown","click"]);var cAt=im('');function uAt(t){var e=cAt();G(t,e)}var dAt=im('');function hAt(t){var e=dAt();G(t,e)}var fAt=im('');function pAt(t){var e=fAt();G(t,e)}var gAt=im('');function mAt(t){var e=gAt();G(t,e)}var _At=im('');function vAt(t){var e=_At();G(t,e)}const yAt=3,tke="24px",rke="16px",bAt=4e3,SAt=356,EAt=14,aK="dark",VO="light";function TAt(t,e){const r={};return[t,e].forEach((n,i)=>{const a=i===1,s=a?"--mobile-offset":"--offset",o=a?rke:tke;function l(u){["top","right","bottom","left"].forEach(d=>{r[`${s}-${d}`]=typeof u=="number"?`${u}px`:u})}typeof n=="number"||typeof n=="string"?l(n):typeof n=="object"?["top","right","bottom","left"].forEach(u=>{const d=n[u];d===void 0?r[`${s}-${u}`]=o:r[`${s}-${u}`]=typeof d=="number"?`${d}px`:d}):l(o)}),r}var CAt=new Set(["$$slots","$$events","$$legacy","invert","position","hotkey","expand","closeButton","offset","mobileOffset","theme","richColors","duration","visibleToasts","toastOptions","dir","gap","pauseWhenPageIsHidden","loadingIcon","successIcon","errorIcon","warningIcon","closeIcon","infoIcon","containerAriaLabel","class","closeButtonAriaLabel","onblur","onfocus","onmouseenter","onmousemove","onmouseleave","ondragend","onpointerdown","onpointerup"]),wAt=se("
      "),xAt=se('
      ');function AAt(t,e){at(e,!0);function r(Y){return Y!=="system"?Y:typeof window<"u"&&window.matchMedia&&window.matchMedia("(prefers-color-scheme: dark)").matches?aK:VO}let n=ce(e,"invert",3,!1),i=ce(e,"position",3,"bottom-right"),a=ce(e,"hotkey",19,()=>["altKey","KeyT"]),s=ce(e,"expand",3,!1),o=ce(e,"closeButton",3,!1),l=ce(e,"offset",3,tke),u=ce(e,"mobileOffset",3,rke),d=ce(e,"theme",3,"light"),h=ce(e,"richColors",3,!1),f=ce(e,"duration",3,bAt),p=ce(e,"visibleToasts",3,yAt),g=ce(e,"toastOptions",19,()=>({})),m=ce(e,"dir",7,"auto"),_=ce(e,"gap",3,EAt),v=ce(e,"pauseWhenPageIsHidden",3,!1),b=ce(e,"containerAriaLabel",3,"Notifications"),y=ce(e,"closeButtonAriaLabel",3,"Close toast"),E=Tt(e,CAt);function T(){if(m()!=="auto")return m();if(typeof window>"u"||typeof document>"u")return"ltr";const Y=document.documentElement.getAttribute("dir");return Y==="auto"||!Y?(zi(()=>m(window.getComputedStyle(document.documentElement).direction??"ltr")),m()):(zi(()=>m(Y)),Y)}const C=W(()=>Array.from(new Set([i(),...Za.toasts.filter(Y=>Y.position).map(Y=>Y.position)].filter(Boolean))));let w=Oe(!1),x=Oe(!1),A=Oe(Zr(r(d()))),R=Oe(void 0),O=Oe(null),F=Oe(!1);const P=W(()=>a().join("+").replace(/Key/g,"").replace(/Digit/g,""));Kt(()=>{Za.toasts.length<=1&&X(w,!1)}),Kt(()=>{const Y=Za.toasts.filter(j=>j.dismiss&&!j.delete);if(Y.length>0){const j=Za.toasts.map(Q=>Y.find(re=>re.id===Q.id)?{...Q,delete:!0}:Q);Za.toasts=j}}),Kt(()=>()=>{S(R)&&S(O)&&(S(O).focus({preventScroll:!0}),X(O,null),X(F,!1))}),uo(()=>(Za.reset(),Bi(document,"keydown",j=>{a().every(ae=>j[ae]||j.code===ae)&&(X(w,!0),S(R)?.focus()),j.code==="Escape"&&(document.activeElement===S(R)||S(R)?.contains(document.activeElement))&&X(w,!1)}))),Kt(()=>{if(d()!=="system"&&X(A,d()),typeof window<"u"){d()==="system"&&(window.matchMedia&&window.matchMedia("(prefers-color-scheme: dark)").matches?X(A,aK):X(A,VO));const Y=window.matchMedia("(prefers-color-scheme: dark)"),j=({matches:Q})=>{d()==="system"&&X(A,Q?aK:VO,!0)};"addEventListener"in Y?Y.addEventListener("change",j):Y.addListener(j)}});const N=Y=>{e.onblur?.(Y),S(F)&&!Y.currentTarget.contains(Y.relatedTarget)&&(X(F,!1),S(O)&&(S(O).focus({preventScroll:!0}),X(O,null)))},k=Y=>{e.onfocus?.(Y),!(Y.target instanceof HTMLElement&&Y.target.dataset.dismissible==="false")&&(S(F)||(X(F,!0),X(O,Y.relatedTarget,!0)))},M=Y=>{e.onpointerdown?.(Y),!(Y.target instanceof HTMLElement&&Y.target.dataset.dismissible==="false")&&X(x,!0)},L=Y=>{e.onmouseenter?.(Y),X(w,!0)},I=Y=>{e.onmouseleave?.(Y),S(x)||X(w,!1)},U=Y=>{e.onmousemove?.(Y),X(w,!0)},B=Y=>{e.ondragend?.(Y),X(w,!1)},$=Y=>{e.onpointerup?.(Y),X(x,!1)};G4t.set(new V4t);var H=xAt();lr(H,"tabindex",-1);var q=te(H);{var V=Y=>{var j=Ae(),Q=oe(j);qr(Q,18,()=>S(C),ae=>ae,(ae,re,ne,ee)=>{const J=W(()=>{const[ge,ye]=re.split("-");return{y:ge,x:ye}}),fe=W(()=>TAt(l(),u()));var ue=wAt();Er(ue,ge=>({tabindex:-1,dir:ge,class:e.class,"data-sonner-toaster":!0,"data-sonner-theme":S(A),"data-y-position":S(J).y,"data-x-position":S(J).x,style:e.style,onblur:N,onfocus:k,onmouseenter:L,onmousemove:U,onmouseleave:I,ondragend:B,onpointerdown:M,onpointerup:$,...E,[xE]:{"--front-toast-height":`${Za.heights[0]?.height}px`,"--width":`${SAt}px`,"--gap":`${_()}px`,"--offset-top":S(fe)["--offset-top"],"--offset-right":S(fe)["--offset-right"],"--offset-bottom":S(fe)["--offset-bottom"],"--offset-left":S(fe)["--offset-left"],"--mobile-offset-top":S(fe)["--mobile-offset-top"],"--mobile-offset-right":S(fe)["--mobile-offset-right"],"--mobile-offset-bottom":S(fe)["--mobile-offset-bottom"],"--mobile-offset-left":S(fe)["--mobile-offset-left"]}}),[()=>T()],void 0,void 0,"svelte-nbs0zk"),qr(ue,23,()=>Za.toasts.filter(ge=>!ge.position&&S(ne)===0||ge.position===re),ge=>ge.id,(ge,ye,Ie,we)=>{{const Te=he=>{var Le=Ae(),_e=oe(Le);{var He=Xe=>{var je=Ae(),Be=oe(je);Pt(Be,()=>e.successIcon??Vt),G(Xe,je)},Re=Xe=>{uAt(Xe)};ve(_e,Xe=>{e.successIcon?Xe(He):e.successIcon!==null&&Xe(Re,1)})}G(he,Le)},Ve=he=>{var Le=Ae(),_e=oe(Le);{var He=Xe=>{var je=Ae(),Be=oe(je);Pt(Be,()=>e.errorIcon??Vt),G(Xe,je)},Re=Xe=>{hAt(Xe)};ve(_e,Xe=>{e.errorIcon?Xe(He):e.errorIcon!==null&&Xe(Re,1)})}G(he,Le)},Ce=he=>{var Le=Ae(),_e=oe(Le);{var He=Xe=>{var je=Ae(),Be=oe(je);Pt(Be,()=>e.warningIcon??Vt),G(Xe,je)},Re=Xe=>{pAt(Xe)};ve(_e,Xe=>{e.warningIcon?Xe(He):e.warningIcon!==null&&Xe(Re,1)})}G(he,Le)},rt=he=>{var Le=Ae(),_e=oe(Le);{var He=Xe=>{var je=Ae(),Be=oe(je);Pt(Be,()=>e.infoIcon??Vt),G(Xe,je)},Re=Xe=>{mAt(Xe)};ve(_e,Xe=>{e.infoIcon?Xe(He):e.infoIcon!==null&&Xe(Re,1)})}G(he,Le)},Ne=he=>{var Le=Ae(),_e=oe(Le);{var He=Xe=>{var je=Ae(),Be=oe(je);Pt(Be,()=>e.closeIcon??Vt),G(Xe,je)},Re=Xe=>{vAt(Xe)};ve(_e,Xe=>{e.closeIcon?Xe(He):e.closeIcon!==null&&Xe(Re,1)})}G(he,Le)};let et=W(()=>g()?.duration??f()),ut=W(()=>g()?.class??""),Pe=W(()=>g()?.descriptionClass||""),qe=W(()=>g()?.style??""),Ze=W(()=>g().classes||{}),De=W(()=>g().unstyled??!1),Fe=W(()=>g()?.cancelButtonStyle??""),de=W(()=>g()?.actionButtonStyle??""),Ee=W(()=>g()?.closeButtonAriaLabel??y());lAt(ge,{get index(){return S(Ie)},get toast(){return S(ye)},get defaultRichColors(){return h()},get duration(){return S(et)},get class(){return S(ut)},get descriptionClass(){return S(Pe)},get invert(){return n()},get visibleToasts(){return p()},get closeButton(){return o()},get interacting(){return S(x)},get position(){return re},get style(){return S(qe)},get classes(){return S(Ze)},get unstyled(){return S(De)},get cancelButtonStyle(){return S(Fe)},get actionButtonStyle(){return S(de)},get closeButtonAriaLabel(){return S(Ee)},get expandByDefault(){return s()},get expanded(){return S(w)},get pauseWhenPageIsHidden(){return v()},get loadingIcon(){return e.loadingIcon},successIcon:Te,errorIcon:Ve,warningIcon:Ce,infoIcon:rt,closeIcon:Ne,$$slots:{successIcon:!0,errorIcon:!0,warningIcon:!0,infoIcon:!0,closeIcon:!0}})}}),Z(ue),Jr(ue,ge=>X(R,ge),()=>S(R)),$e(()=>ue.dir=ue.dir),G(ae,ue)}),G(Y,j)};ve(q,Y=>{Za.toasts.length>0&&Y(V)})}Z(H),$e(()=>lr(H,"aria-label",`${b()??""} ${S(P)??""}`)),G(t,H),st()}async function p2(t,e="Copied to clipboard",r="Failed to copy to clipboard"){try{if(navigator.clipboard&&navigator.clipboard.writeText)return await navigator.clipboard.writeText(t),Qi.success(e),!0;const n=document.createElement("textarea");n.value=t,n.style.position="fixed",n.style.left="-999999px",n.style.top="-999999px",document.body.appendChild(n),n.focus(),n.select();const i=document.execCommand("copy");if(document.body.removeChild(n),i)return Qi.success(e),!0;throw new Error("execCommand failed")}catch(n){return console.error("Failed to copy to clipboard:",n),Qi.error(r),!1}}async function RAt(t,e="Code copied to clipboard",r="Failed to copy code"){return p2(t,e,r)}function NAt(t,e,r=!1){const n=e?.filter(a=>a.type===Ti.TEXT||a.type===Ti.LEGACY_CONTEXT||a.type===Ti.MCP_PROMPT||a.type===Ti.MCP_RESOURCE)??[];if(n.length===0)return t;if(r){const a=[t];for(const s of n)a.push(s.content);return a.join(` + +`)}const i=n.map(a=>{if(a.type===Ti.MCP_PROMPT){const s=a;return{arguments:s.arguments,content:s.content,name:s.name,promptName:s.promptName,serverName:s.serverName,type:Ti.MCP_PROMPT}}return{content:a.content,name:a.name,type:Ti.TEXT}});return`${JSON.stringify(t)} +${JSON.stringify(i,null,2)}`}function OAt(t){const e={mcpPromptAttachments:[],message:t,textAttachments:[]};if(!t.startsWith('"'))return e;try{let r=-1,n=!1;for(let d=1;de?t.slice(0,e)+"...":t}function P6(t,e=!1){if(e){const r=t.split(Na).find(n=>n.trim().length>0);return r?r.trim():t.trim()}return t.trim()}function MAt(t){return t.trim().toLowerCase()}function nh(t){switch(MAt(t)){case Zi.JPEG:case Zi.PNG:case Zi.GIF:case Zi.WEBP:case Zi.SVG:case Zi.HEIC:case Zi.HEIF:return pi.IMAGE;case Ua.MP3_MPEG:case Ua.MP3:case Ua.MP4:case Ua.WAV:case Ua.WAVE:case Ua.X_WAV:case Ua.X_WAVE:case Ua.VND_WAVE:case Ua.X_PN_WAV:case Ua.WEBM:case Ua.WEBM_OPUS:return pi.AUDIO;case PR.MP4:case PR.OGG:return pi.VIDEO;case jg.PDF:return pi.PDF;case Or.PLAIN:case Or.MARKDOWN:case Or.ASCIIDOC:case Or.JAVASCRIPT:case Or.JAVASCRIPT_APP:case Or.TYPESCRIPT:case Or.JSX:case Or.TSX:case Or.CSS:case Or.HTML:case Or.JSON:case Or.XML_TEXT:case Or.XML_APP:case Or.YAML_TEXT:case Or.YAML_APP:case Or.CSV:case Or.PYTHON:case Or.JAVA:case Or.CPP_SRC:case Or.C_SRC:case Or.C_HDR:case Or.PHP:case Or.RUBY:case Or.GO:case Or.RUST:case Or.SHELL:case Or.BAT:case Or.SQL:case Or.R:case Or.SCALA:case Or.KOTLIN:case Or.SWIFT:case Or.DART:case Or.VUE:case Or.SVELTE:case Or.LATEX:case Or.BIBTEX:case Or.CUDA:case Or.CPP_HDR:case Or.CSHARP:case Or.HASKELL:case Or.PROPERTIES:case Or.TEX:case Or.TEX_APP:return pi.TEXT;default:return null}}function rce(t){switch(t.toLowerCase().substring(t.lastIndexOf("."))){case dc.JPG:case dc.JPEG:case dc.PNG:case dc.GIF:case dc.WEBP:case dc.SVG:case dc.HEIC:case dc.HEIF:return pi.IMAGE;case LR.MP3:case LR.WAV:return pi.AUDIO;case Dle.PDF:return pi.PDF;case Lr.TXT:case Lr.MD:case Lr.ADOC:case Lr.JS:case Lr.TS:case Lr.JSX:case Lr.TSX:case Lr.CSS:case Lr.HTML:case Lr.HTM:case Lr.JSON:case Lr.XML:case Lr.YAML:case Lr.YML:case Lr.CSV:case Lr.LOG:case Lr.PY:case Lr.JAVA:case Lr.CPP:case Lr.C:case Lr.H:case Lr.PHP:case Lr.RB:case Lr.GO:case Lr.RS:case Lr.SH:case Lr.BAT:case Lr.SQL:case Lr.R:case Lr.SCALA:case Lr.KT:case Lr.SWIFT:case Lr.DART:case Lr.VUE:case Lr.SVELTE:case Lr.TEX:case Lr.BIB:case Lr.COMP:case Lr.CU:case Lr.CUH:case Lr.HPP:case Lr.HS:case Lr.PROPERTIES:return pi.TEXT;default:return null}}function nke(t){const e=t.toLowerCase().substring(t.lastIndexOf("."));for(const[r,n]of Object.entries(PCt))if(n.extensions.includes(e))return`${pi.IMAGE}:${r}`;for(const[r,n]of Object.entries(MCt))if(n.extensions.includes(e))return`${pi.AUDIO}:${r}`;for(const[r,n]of Object.entries(LCt))if(n.extensions.includes(e))return`${pi.VIDEO}:${r}`;for(const[r,n]of Object.entries(FCt))if(n.extensions.includes(e))return`${pi.PDF}:${r}`;for(const[r,n]of Object.entries(BCt))if(n.extensions.includes(e))return`${pi.TEXT}:${r}`;return null}function LAt(t,e){if(e){const n=nh(e);if(n===pi.IMAGE||n===pi.AUDIO||n===pi.PDF)return!0}const r=rce(t);return r===pi.IMAGE||r===pi.AUDIO||r===pi.PDF,!0}function JL(t){if(typeof t!="number")return"Unknown";if(t===0)return"0 Bytes";const e=1024,r=["Bytes","KB","MB","GB"],n=Math.floor(Math.log(t)/Math.log(e));return parseFloat((t/Math.pow(e,n)).toFixed(2))+" "+r[n]}function kD(t){return typeof t!="number"?"Unknown":t>=1e9?`${(t/1e9).toFixed(2)}B`:t>=1e6?`${(t/1e6).toFixed(2)}M`:t>=1e3?`${(t/1e3).toFixed(2)}K`:t.toString()}function WO(t){return typeof t!="number"?"Unknown":t.toLocaleString()}function sK(t){try{const e=JSON.parse(t);return JSON.stringify(e,null,2)}catch{return t}}function PAt(t){return t.toLocaleTimeString("en-US",{hour:"2-digit",hour12:!1,minute:"2-digit",second:"2-digit"})}function KO(t){if(t<0)return"0s";const e=t/AD;if(e0&&a.push(`${r}h`),n>0&&a.push(`${n}min`),(i>0||a.length===0)&&a.push(`${i}s`),a.join(" ")}function CA(t,e,r,n){const i=n?`${e} (${n})`:e;return` + +--- ${t}: ${i} --- +${r}`}function eP(t){return t.isComposing||t.keyCode===229}function FAt(t,e){return t.includes(y_)?t.split(Na).map(r=>{if(r.indexOf(y_)==-1)return r;let n="",i=0;for(;i0?r[a-1]:"",l=r[a+1],u=a+1>`,i=s+1}return n}).join(Na):t}function BAt(t){return t.replace(XEt,(e,r,n,i)=>r??(n!=null?`${lT}${n}${lT}`:i!=null?`${y_}${i}${y_}`:e))}const _2e=64,Om=new Map;function v2e(t){const e=Om.get(t);if(e!==void 0)return e;const r=t;if(!JEt.test(t))return Om.size>=_2e&&Om.delete(Om.keys().next().value),Om.set(r,t),t;const n=new Map;t=t.split(Na).map((l,u)=>{const d=l.match(rTt);return d?(n.set(u,d[1]),l.slice(d[1].length)):l}).join(Na);const s=[];t=t.replace(jEt,l=>(s.push(l),`<>`));const o=[];return t.includes(u_e)&&(t=t.replace(ZEt,(l,u,d,h)=>{if(u.endsWith(hTt))return l;const f=eTt.test(h);let p;return f?(o.push(`${cTt}${d.trim()}${uTt}`),p=""):(o.push(`${u_e}${d}${dTt}`),p=Na),`${u}${p}<>${p}${h}`})),t=t.replace(sTt,l=>(o.push(l),`<>`)),t=FAt(t,o),t=t.replace(aTt,fTt),t=t.replace(nTt,(l,u)=>{let d=o[parseInt(u)];const h=d.match(QEt);if(h){const f=h[1],p=f.startsWith(Na)?"":Na,g=f.endsWith(Na)?"":Na;d=lT+p+f+g+lT}return d}),t=BAt(t),t=t.replace(oTt,(l,u)=>`${y_}${u}${y_}`).replace(lTt,(l,u)=>`${lT}${u}${lT}`),t=t.replace(iTt,(l,u)=>s[parseInt(u)]),n.size>0&&(t=t.split(Na).map((d,h)=>{const f=n.get(h);return f?f+d:d}).join(Na)),Om.size>=_2e&&Om.delete(Om.keys().next().value),Om.set(r,t),t}function UAt(t,e){const r=[],n=[],i={},{hasAudio:a,hasVideo:s,hasVision:o}=e;for(const l of t){const u=nh(l.type);let d=!0,h="";switch(u){case pi.IMAGE:o||(d=!1,h="Images require a vision-capable model");break;case pi.AUDIO:a||(d=!1,h="Audio files require an audio-capable model");break;case pi.VIDEO:s||(d=!1,h="Video files require a video-capable model");break;case pi.TEXT:case pi.PDF:break}d?r.push(l):(n.push(l),i[l.name]=h)}return{modalityReasons:i,supportedFiles:r,unsupportedFiles:n}}function ike(t){const e=t.trim();if(!e)return"";const r=e.split(KU);if(r.length===2){const[a,s]=r,o=a?.trim(),l=s?.trim();if(o&&l)return`${o}/${l}`}const i=r.pop()?.trim();return i&&i.length>0?i:e}function e_(t){return typeof t=="number"?Math.round(t*T_e)/T_e:t}function nce(t){switch(t.toLowerCase().substring(t.lastIndexOf("."))){case".js":case".mjs":case".cjs":return"javascript";case".ts":case".mts":case".cts":return"typescript";case".jsx":return"javascript";case".tsx":return"typescript";case".html":case".htm":return"html";case".css":return"css";case".scss":return"scss";case".less":return"less";case".vue":return"html";case".svelte":return"html";case".json":return"json";case".xml":return"xml";case".yaml":case".yml":return"yaml";case".toml":return"ini";case".csv":return"plaintext";case".py":return"python";case".java":return"java";case".kt":case".kts":return"kotlin";case".scala":return"scala";case".cpp":case".cc":case".cxx":case".c++":return"cpp";case".c":return"c";case".h":case".hpp":return"cpp";case".cs":return"csharp";case".go":return"go";case".rs":return"rust";case".rb":return"ruby";case".php":return"php";case".swift":return"swift";case".dart":return"dart";case".r":return"r";case".lua":return"lua";case".pl":case".pm":return"perl";case".sh":case".bash":case".zsh":return"bash";case".bat":case".cmd":return"dos";case".ps1":return"powershell";case".sql":return"sql";case".md":case".markdown":return"markdown";case".tex":case".latex":return"latex";case".adoc":case".asciidoc":return"asciidoc";case".ini":case".cfg":case".conf":return"ini";case".dockerfile":return"dockerfile";case".nginx":return"nginx";case".graphql":case".gql":return"graphql";case".proto":return"protobuf";case".diff":case".patch":return"diff";case".log":return"plaintext";case".txt":return"plaintext";default:return"plaintext"}}async function $At(t){return new Promise((e,r)=>{const n=new FileReader;n.onload=i=>{i.target?.result!==null&&i.target?.result!==void 0?e(i.target.result):r(new Error("Failed to read file"))},n.onerror=()=>r(new Error("File reading error")),n.readAsText(t)})}function GAt(t,e={}){if(!t)return!0;const r={...sEt,...e},n=t.substring(0,r.prefixLength);let i=0,a=0;for(let s=0;s13&&o<27)&&a++,o===65533&&a++}return!(i>r.maxAbsoluteNullBytes||a/n.length>r.suspiciousCharThresholdRatio)}function ice(t,e){let r=null;return(...n)=>{r&&clearTimeout(r),r=setTimeout(()=>{t(...n),r=null},e)}}function zAt(t){return t.replace(WEt,"").slice(0,_Ie)}function qAt(t){return t.replace(KEt,"").slice(0,vIe)}function HAt(t){return`
      + Image cannot be displayed + (open link) +
      `}async function*VAt(t,e){const r=t.body?.getReader();if(!r)return;const n=new TextDecoder;let i="";try{for(;;){if(e?.aborted)return;const{done:a,value:s}=await r.read();if(a)break;i+=n.decode(s,{stream:!0});const o=i.split(RD);i=o.pop()??"";for(const l of o)if(l)for(const u of l.split(WL)){if(!u.startsWith(ix))continue;const d=u.slice(ix.length).trim();if(d===RIe)return;if(d)try{yield{data:JSON.parse(d)}}catch{}}}}finally{try{r.releaseLock()}catch(a){console.error("[sse] failed to release reader lock:",a)}}}function y2e(t){const e=t.trim().toLowerCase();return e.startsWith(Uu.WEBSOCKET)||e.startsWith(Uu.WEBSOCKET_SECURE)?fc.WEBSOCKET:e.endsWith(BTt)||e.endsWith(UTt)||e.includes($Tt)?fc.SSE:fc.STREAMABLE_HTTP}function b2e(t){if(!t)return[];let e;if(typeof t=="string"){const r=t.trim();if(!r)return[];try{e=JSON.parse(r)}catch(n){return console.warn("[MCP] Failed to parse mcpServers JSON, ignoring value:",n),[]}}else e=t;return Array.isArray(e)?e.map((r,n)=>{const i=typeof r?.url=="string"?r.url.trim():"",a=typeof r?.headers=="string"?r.headers.trim():void 0,s=typeof r?.id=="string"&&r.id?.trim()?r.id.trim():`${HL}-${n+1}`;return{displayName:r?.displayName,enabled:!!r?.enabled,headers:a||void 0,id:s,name:r?.name,url:i,useProxy:!!r?.useProxy}}):[]}function YAt(t){switch(t){case _u.ERROR:return G0;case _u.WARN:return u1;default:return A0}}function WAt(t){switch(t){case _u.ERROR:return"text-destructive";case _u.WARN:return"text-yellow-600 dark:text-yellow-500";default:return"text-muted-foreground"}}function KAt(t){return t?.startsWith(J5.IMAGE)??!1}function tP(t){try{return t.replace(HTt,"").split(sh).filter(r=>r.length>0)}catch{return[t]}}function jAt(t){return t.replace(VTt,"").split(YTt).map(r=>r.charAt(0).toUpperCase()+r.slice(1)).join(" ")}function eee(t){try{const e=tP(t.uri);return e[e.length-1]||t.name||t.uri}catch{return t.name||t.uri}}function XAt(t,e){const r=t?.toLowerCase()||"",n=e?.toLowerCase()||"";return r.includes(Qd.JSON)||r.includes(Qd.JAVASCRIPT)||r.includes(Qd.TYPESCRIPT)||CIe.test(n)}function QAt(t,e){const r=t?.toLowerCase()||"",n=e?.toLowerCase()||"";return r.startsWith(J5.IMAGE)||TIe.test(n)}function ake(t,e){const r=t?.toLowerCase()||"",n=e?.toLowerCase()||"";return r.startsWith(J5.IMAGE)||TIe.test(n)?Ule:r.includes(Qd.JSON)||r.includes(Qd.JAVASCRIPT)||r.includes(Qd.TYPESCRIPT)||CIe.test(n)?N9:r.includes(J5.TEXT)||qTt.test(n)?sp:n.includes(IJ.DATABASE_KEYWORD)||n.includes(IJ.DATABASE_SCHEME)?Ple:v4}function wA(t){return t?t.filter(e=>"text"in e).map(e=>e.text).join(QTt):""}function ZAt(t){return t?t.filter(e=>"blob"in e):[]}function ske(t,e=Or.PLAIN,r=wIe){const n=new Blob([t],{type:e}),i=URL.createObjectURL(n),a=document.createElement("a");a.href=i,a.download=r,document.body.appendChild(a),a.click(),document.body.removeChild(a),URL.revokeObjectURL(i)}function jO(t){const e=t.indexOf(CH);if(e===-1)return t;const r=t.substring(0,e),n=t.substring(e+CH.length).replace(PIe,"");return`${r}${CH}${n}`}function oke(t){const e=[],r=new Set;let n;for(jL.lastIndex=0;(n=jL.exec(t))!==null;){const i=n[1]||"",a=n[2];for(const s of a.split(",")){const o=s.replace(MIe,"").replace(LIe,"").trim();o&&!r.has(o)&&(r.add(o),e.push({name:o,operator:i}))}}return e}function JAt(t,e){return jL.lastIndex=0,t.replace(jL,(r,n,i)=>{const a=i.split(",").map(o=>o.replace(MIe,"").replace(LIe,"").trim()),s=a.map(o=>e[o]??"").filter(o=>o!=="");if(s.length===0)return"";switch(n){case $1.RESERVED:return s.join(Fh.COMMA);case $1.FRAGMENT:return $1.FRAGMENT+s.join(Fh.COMMA);case $1.PATH_SEGMENT:return Fh.SLASH+s.join(Fh.SLASH);case $1.LABEL:return Fh.PERIOD+s.join(Fh.PERIOD);case $1.PATH_PARAM:return a.filter((o,l)=>s[l]).map((o,l)=>`${Fh.SEMICOLON}${o}=${s[l]}`).join("");case $1.FORM_QUERY:return Fh.QUERY_PREFIX+a.filter((o,l)=>s[l]).map((o,l)=>`${encodeURIComponent(o)}=${encodeURIComponent(s[l])}`).join(Fh.QUERY_CONTINUATION);case $1.FORM_CONTINUATION:return Fh.QUERY_CONTINUATION+a.filter((o,l)=>s[l]).map((o,l)=>`${encodeURIComponent(o)}=${encodeURIComponent(s[l])}`).join(Fh.COMMA);default:return s.map(o=>encodeURIComponent(o)).join(Fh.COMMA)}})}function e6t(t,e){return oke(t).every(n=>(e[n.name]??"").trim()!=="")}function HR(t,e){return`data:${t};base64,${e}`}function rP(t){if(!t?.trim())return[];try{const e=JSON.parse(t);if(typeof e=="object"&&e!==null&&!Array.isArray(e))return Object.entries(e).map(([r,n])=>({key:r,value:String(n)}))}catch{return[]}return[]}function t6t(t){const e=t.filter(n=>n.key.trim());if(e.length===0)return"";const r={};for(const n of e)r[n.key.trim()]=n.value;return JSON.stringify(r)}function g2(t){const e=t.replace(sx,""),r=e.lastIndexOf(sh);return r===-1?e:e.slice(r+1)}function lke(t,e){return t?e?t===e?th:t.startsWith(e+sh)?AIe+t.slice(e.length+1):g2(t):g2(t):""}function d1(t,e){return e?t===e?th:t.startsWith(e+sh)?AIe+t.slice(e.length+1):t:t}function S2e(t,e){const r=lke(t,e);return`${HJ}[${nx}${t}](${r}).`}function cke(t){const e=t.trim();if(e===xIe)return{display:"",path:null};if(e.startsWith(HJ)){const r=e.slice(HJ.length),n=r.match(fCt);return n?{display:n[2],path:n[1]}:{display:r,path:r}}return null}function r6t(t){return!SEt.test(t)&&!t.startsWith(GJ)?t:t.split(GJ).join(sh)}function n6t(t){const e=t.match(TEt);if(e)return e[0].length;const r=t.match(EEt);return r?r[0].length:t.startsWith(sh)?sh.length:0}function i6t(t){const e=r6t(t),r=n6t(e);if(r===0&&!e.startsWith(th))return null;const n=r>0?e.slice(0,r).replace(sx,"")+sh:th,i=e.slice(r>0?r:th.length).replace(PIe,"").replace(sx,""),a=o=>r>0?n+o:th+sh+o;if(!i)return{last:"",parent:n};const s=i.lastIndexOf(sh);return s===-1?{last:i,parent:n}:{last:i.slice(s+1),parent:a(i.slice(0,s))}}function tee(t){let e=GL;for(const r of t){const n=r.toLowerCase(),i=r.toUpperCase();n!==i?e+=n_e+n+i+i_e:bEt.includes(r)?e+=n_e+r+i_e:e+=r}return e+GL}function a6t(t,e,r){const n=i6t(t),i=n?n.parent:e,a=n?n.last?tee(n.last):GL:tee(t),s=n?dIe:r;return{include:a,last:n?.last,maxDepth:s,path:i,rankQuery:n?.last??t}}const s6t=0,o6t=1,l6t=2,c6t=3;function E2e(t,e){const r=g2(t).toLowerCase(),n=e.toLowerCase();return r===n?s6t:r.startsWith(n)?o6t:r.includes(n)?l6t:c6t}function u6t(t,e){return[...t].sort((r,n)=>E2e(r.path,e)-E2e(n.path,e)||r.path.length-n.path.length||r.path.localeCompare(n.path))}function ace(t,e){return t?t.replace(sx,"")+sh+e:e}function uke(t,e){if(!e)return[{match:!1,text:t}];const r=[],n=t.toLowerCase(),i=e.toLowerCase();let a=0;for(;aa&&r.push({match:!1,text:t.slice(a,s)}),r.push({match:!0,text:t.slice(s,s+e.length)}),a=s+e.length}return r}class lx{static async list(){return $T(BO.LIST)}static async executeTool(e,r,n,i){const a=await $T(BO.EXECUTE,{body:JSON.stringify({params:r,tool:e}),headers:i?{[bH]:i}:void 0,method:"POST",signal:n});return I6.ERROR in a?{content:String(a[I6.ERROR]),isError:!0}:I6.PLAIN_TEXT in a?{content:String(a[I6.PLAIN_TEXT]),isError:!1}:{content:JSON.stringify(a),isError:!1}}static async executeToolRaw(e,r,n,i){return $T(BO.EXECUTE,{body:JSON.stringify({params:r,tool:e}),headers:i?{[bH]:i}:void 0,method:"POST",signal:n})}static async*streamTool(e,r,n,i){const a=zT();i&&(a[bH]=i);const s=await fetch(`${tl}${BO.EXECUTE}`,{body:JSON.stringify({params:r,stream:!0,tool:e}),headers:a,method:"POST",signal:n});if(!s.ok||!s.body){const l=await d6t(s);throw new Error(l)}const o=VAt(s,n);for(;;){const l=await o.next();if(l.done)return;const u=l.value.data;if(u.chunk!==void 0&&(yield{chunk:u.chunk,done:!1}),u.done){yield{chunk:null,done:!0,error:u.error};return}}}}async function d6t(t){const e=`${t.status} ${t.statusText}`.trim();try{const r=await t.clone().json();if(r?.error)return`${e}: ${r.error}`;if(r?.message)return`${e}: ${r.message}`}catch(r){console.error("[tools] Non-JSON error response, falling back to raw text:",r);try{const n=await t.text();if(n.trim())return`${e}: ${n.trim()}`}catch(n){console.error("[tools] Failed to read error response as text:",n)}}return e||`HTTP ${t.status}`}const T2e=2e3,XO=new Map;async function C2e(t,e,r,n){const i=`${e}\0${t.path}\0${t.include}\0${t.maxDepth}\0${r}`,a=XO.get(i);if(a&&Date.now()-a.at=T2e&&XO.delete(d);return XO.set(i,{at:u,base:o,results:l}),{base:o,entries:l}}function w2e(t,e){return{name:g2(t.path),path:ace(e,t.path),type:t.type}}async function dke(t,e,r,n,i,a={}){const{childMaxDepth:s=dIe,descendOnTrailingSeparator:o=!1,type:l=ex.ALL}=a,u=a6t(t,e,r),d=await C2e(u,l,n,i);if(d.error)return{args:u,base:d.base,entries:[],error:d.error};const h=u6t(d.entries,u.rankQuery),f=h.map(g=>w2e(g,d.base)),p=u.last;if(p){const g=o?t.endsWith(sh)||t.endsWith(GJ):!0,m=h.find(_=>_.type==="dir"&&g2(_.path).toLowerCase()===p.toLowerCase());if(g&&m){const _=ace(d.base,m.path),v=await C2e({include:GL,maxDepth:s,path:_},l,n,i);if(!v.error){const b=v.entries.map(y=>w2e(y,v.base)).sort((y,E)=>y.path.localeCompare(E.path));return{args:u,base:d.base,entries:[...f,...b],exactDir:_}}}}return{args:u,base:d.base,entries:f}}const oK=new Set([" "," ",` +`,"\r","(",")","[","]",",",";",":",'"',"'"]);function sce(t,e){if(e<=0||e>t.length)return null;let r=-1;for(let i=e-1;i>=0;i--){const a=t[i];if(a==="@"){const s=i>0?t[i-1]:"";(i===0||oK.has(s))&&(r=i);break}if(oK.has(a))break}if(r===-1)return null;let n=r+1;for(;nencodeURIComponent(e)).join("/")}function VR(t){try{return t.split("/").map(e=>decodeURIComponent(e)).join("/")}catch{return t}}function _6t(t){const e=oce(JTt),r=[];let n=0,i;for(;(i=e.exec(t))!==null;)i.index>n&&r.push({mention:null,text:t.slice(n,i.index)}),r.push({mention:{name:i[1],path:VR(i[2])},text:i[0]}),n=i.index+i[0].length;return ne.length||r.start>r.end)return null;const n=t.path.replace(/\/+$/,""),i=t.type===sT.DIRECTORY?`${n}/`:n,s=`[${g2(n)||t.name}](${nx}${m6t(i)}) `,o=e.slice(0,r.start)+s+e.slice(r.end);return{caretOffset:r.start+s.length,newValue:o}}var x2e;const y6t=Object.freeze({status:"aborted"});function ur(t,e,r){function n(o,l){if(o._zod||Object.defineProperty(o,"_zod",{value:{def:l,constr:s,traits:new Set},enumerable:!1}),o._zod.traits.has(t))return;o._zod.traits.add(t),e(o,l);const u=s.prototype,d=Object.keys(u);for(let h=0;hr?.Parent&&o instanceof r.Parent?!0:o?._zod?.traits?.has(t)}),Object.defineProperty(s,"name",{value:t}),s}class qT extends Error{constructor(){super("Encountered Promise during synchronous parse. Use .parseAsync() instead.")}}class hke extends Error{constructor(e){super(`Encountered unidirectional transform during encode: ${e}`),this.name="ZodEncodeError"}}(x2e=globalThis).__zod_globalConfig??(x2e.__zod_globalConfig={});const uce=globalThis.__zod_globalConfig;function z0(t){return uce}function fke(t){const e=Object.values(t).filter(n=>typeof n=="number");return Object.entries(t).filter(([n,i])=>e.indexOf(+n)===-1).map(([n,i])=>i)}function ree(t,e){return typeof e=="bigint"?e.toString():e}function QU(t){return{get value(){{const e=t();return Object.defineProperty(this,"value",{value:e}),e}}}}function dce(t){return t==null}function hce(t){const e=t.startsWith("^")?1:0,r=t.endsWith("$")?t.length-1:t.length;return t.slice(e,r)}function b6t(t,e){const r=t/e,n=Math.round(r),i=Number.EPSILON*Math.max(Math.abs(r),1);return Math.abs(r-n){};function YR(t){return typeof t=="object"&&t!==null&&!Array.isArray(t)}const E6t=QU(()=>{if(uce.jitless||typeof navigator<"u"&&navigator?.userAgent?.includes("Cloudflare"))return!1;try{const t=Function;return new t(""),!0}catch{return!1}});function cx(t){if(YR(t)===!1)return!1;const e=t.constructor;if(e===void 0||typeof e!="function")return!0;const r=e.prototype;return!(YR(r)===!1||Object.prototype.hasOwnProperty.call(r,"isPrototypeOf")===!1)}function gke(t){return cx(t)?{...t}:Array.isArray(t)?[...t]:t instanceof Map?new Map(t):t instanceof Set?new Set(t):t}const T6t=new Set(["string","number","symbol"]);function ux(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function Rv(t,e,r){const n=new t._zod.constr(e??t._zod.def);return(!e||r?.parent)&&(n._zod.parent=t),n}function Dn(t){const e=t;if(!e)return{};if(typeof e=="string")return{error:()=>e};if(e?.message!==void 0){if(e?.error!==void 0)throw new Error("Cannot specify both `message` and `error` params");e.error=e.message}return delete e.message,typeof e.error=="string"?{...e,error:()=>e.error}:e}function C6t(t){return Object.keys(t).filter(e=>t[e]._zod.optin==="optional"&&t[e]._zod.optout==="optional")}const w6t={safeint:[Number.MIN_SAFE_INTEGER,Number.MAX_SAFE_INTEGER],int32:[-2147483648,2147483647],uint32:[0,4294967295],float32:[-34028234663852886e22,34028234663852886e22],float64:[-Number.MAX_VALUE,Number.MAX_VALUE]};function x6t(t,e){const r=t._zod.def,n=r.checks;if(n&&n.length>0)throw new Error(".pick() cannot be used on object schemas containing refinements");const a=Av(t._zod.def,{get shape(){const s={};for(const o in e){if(!(o in r.shape))throw new Error(`Unrecognized key: "${o}"`);e[o]&&(s[o]=r.shape[o])}return Z2(this,"shape",s),s},checks:[]});return Rv(t,a)}function A6t(t,e){const r=t._zod.def,n=r.checks;if(n&&n.length>0)throw new Error(".omit() cannot be used on object schemas containing refinements");const a=Av(t._zod.def,{get shape(){const s={...t._zod.def.shape};for(const o in e){if(!(o in r.shape))throw new Error(`Unrecognized key: "${o}"`);e[o]&&delete s[o]}return Z2(this,"shape",s),s},checks:[]});return Rv(t,a)}function R6t(t,e){if(!cx(e))throw new Error("Invalid input to extend: expected a plain object");const r=t._zod.def.checks;if(r&&r.length>0){const a=t._zod.def.shape;for(const s in e)if(Object.getOwnPropertyDescriptor(a,s)!==void 0)throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.")}const i=Av(t._zod.def,{get shape(){const a={...t._zod.def.shape,...e};return Z2(this,"shape",a),a}});return Rv(t,i)}function N6t(t,e){if(!cx(e))throw new Error("Invalid input to safeExtend: expected a plain object");const r=Av(t._zod.def,{get shape(){const n={...t._zod.def.shape,...e};return Z2(this,"shape",n),n}});return Rv(t,r)}function O6t(t,e){if(t._zod.def.checks?.length)throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");const r=Av(t._zod.def,{get shape(){const n={...t._zod.def.shape,...e._zod.def.shape};return Z2(this,"shape",n),n},get catchall(){return e._zod.def.catchall},checks:e._zod.def.checks??[]});return Rv(t,r)}function I6t(t,e,r){const i=e._zod.def.checks;if(i&&i.length>0)throw new Error(".partial() cannot be used on object schemas containing refinements");const s=Av(e._zod.def,{get shape(){const o=e._zod.def.shape,l={...o};if(r)for(const u in r){if(!(u in o))throw new Error(`Unrecognized key: "${u}"`);r[u]&&(l[u]=t?new t({type:"optional",innerType:o[u]}):o[u])}else for(const u in o)l[u]=t?new t({type:"optional",innerType:o[u]}):o[u];return Z2(this,"shape",l),l},checks:[]});return Rv(e,s)}function k6t(t,e,r){const n=Av(e._zod.def,{get shape(){const i=e._zod.def.shape,a={...i};if(r)for(const s in r){if(!(s in a))throw new Error(`Unrecognized key: "${s}"`);r[s]&&(a[s]=new t({type:"nonoptional",innerType:i[s]}))}else for(const s in i)a[s]=new t({type:"nonoptional",innerType:i[s]});return Z2(this,"shape",a),a}});return Rv(e,n)}function uT(t,e=0){if(t.aborted===!0)return!0;for(let r=e;r{var n;return(n=r).path??(n.path=[]),r.path.unshift(t),r})}function QO(t){return typeof t=="string"?t:t?.message}function q0(t,e,r){const n=t.message?t.message:QO(t.inst?._zod.def?.error?.(t))??QO(e?.error?.(t))??QO(r.customError?.(t))??QO(r.localeError?.(t))??"Invalid input",{inst:i,continue:a,input:s,...o}=t;return o.path??(o.path=[]),o.message=n,e?.reportInput&&(o.input=s),o}function fce(t){return Array.isArray(t)?"array":typeof t=="string"?"string":"unknown"}function WR(...t){const[e,r,n]=t;return typeof e=="string"?{message:e,code:"custom",input:r,inst:n}:{...e}}const mke=(t,e)=>{t.name="$ZodError",Object.defineProperty(t,"_zod",{value:t._zod,enumerable:!1}),Object.defineProperty(t,"issues",{value:e,enumerable:!1}),t.message=JSON.stringify(e,ree,2),Object.defineProperty(t,"toString",{value:()=>t.message,enumerable:!1})},_ke=ur("$ZodError",mke),vke=ur("$ZodError",mke,{Parent:Error});function M6t(t,e=r=>r.message){const r={},n=[];for(const i of t.issues)i.path.length>0?(r[i.path[0]]=r[i.path[0]]||[],r[i.path[0]].push(e(i))):n.push(e(i));return{formErrors:n,fieldErrors:r}}function L6t(t,e=r=>r.message){const r={_errors:[]},n=(i,a=[])=>{for(const s of i.issues)if(s.code==="invalid_union"&&s.errors.length)s.errors.map(o=>n({issues:o},[...a,...s.path]));else if(s.code==="invalid_key")n({issues:s.issues},[...a,...s.path]);else if(s.code==="invalid_element")n({issues:s.issues},[...a,...s.path]);else{const o=[...a,...s.path];if(o.length===0)r._errors.push(e(s));else{let l=r,u=0;for(;u(e,r,n,i)=>{const a=n?{...n,async:!1}:{async:!1},s=e._zod.run({value:r,issues:[]},a);if(s instanceof Promise)throw new qT;if(s.issues.length){const o=new(i?.Err??t)(s.issues.map(l=>q0(l,a,z0())));throw pke(o,i?.callee),o}return s.value},gce=t=>async(e,r,n,i)=>{const a=n?{...n,async:!0}:{async:!0};let s=e._zod.run({value:r,issues:[]},a);if(s instanceof Promise&&(s=await s),s.issues.length){const o=new(i?.Err??t)(s.issues.map(l=>q0(l,a,z0())));throw pke(o,i?.callee),o}return s.value},ZU=t=>(e,r,n)=>{const i=n?{...n,async:!1}:{async:!1},a=e._zod.run({value:r,issues:[]},i);if(a instanceof Promise)throw new qT;return a.issues.length?{success:!1,error:new(t??_ke)(a.issues.map(s=>q0(s,i,z0())))}:{success:!0,data:a.value}},yke=ZU(vke),JU=t=>async(e,r,n)=>{const i=n?{...n,async:!0}:{async:!0};let a=e._zod.run({value:r,issues:[]},i);return a instanceof Promise&&(a=await a),a.issues.length?{success:!1,error:new t(a.issues.map(s=>q0(s,i,z0())))}:{success:!0,data:a.value}},P6t=JU(vke),F6t=t=>(e,r,n)=>{const i=n?{...n,direction:"backward"}:{direction:"backward"};return pce(t)(e,r,i)},B6t=t=>(e,r,n)=>pce(t)(e,r,n),U6t=t=>async(e,r,n)=>{const i=n?{...n,direction:"backward"}:{direction:"backward"};return gce(t)(e,r,i)},$6t=t=>async(e,r,n)=>gce(t)(e,r,n),G6t=t=>(e,r,n)=>{const i=n?{...n,direction:"backward"}:{direction:"backward"};return ZU(t)(e,r,i)},z6t=t=>(e,r,n)=>ZU(t)(e,r,n),q6t=t=>async(e,r,n)=>{const i=n?{...n,direction:"backward"}:{direction:"backward"};return JU(t)(e,r,i)},H6t=t=>async(e,r,n)=>JU(t)(e,r,n),V6t=/^[cC][0-9a-z]{6,}$/,Y6t=/^[0-9a-z]+$/,W6t=/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/,K6t=/^[0-9a-vA-V]{20}$/,j6t=/^[A-Za-z0-9]{27}$/,X6t=/^[a-zA-Z0-9_-]{21}$/,Q6t=/^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/,Z6t=/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/,N2e=t=>t?new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${t}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`):/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/,J6t=/^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/,e9t="^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";function t9t(){return new RegExp(e9t,"u")}const r9t=/^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,n9t=/^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/,i9t=/^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/,a9t=/^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,s9t=/^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/,bke=/^[A-Za-z0-9_-]*$/,o9t=/^https?$/,l9t=/^\+[1-9]\d{6,14}$/,Ske="(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))",c9t=new RegExp(`^${Ske}$`);function Eke(t){const e="(?:[01]\\d|2[0-3]):[0-5]\\d";return typeof t.precision=="number"?t.precision===-1?`${e}`:t.precision===0?`${e}:[0-5]\\d`:`${e}:[0-5]\\d\\.\\d{${t.precision}}`:`${e}(?::[0-5]\\d(?:\\.\\d+)?)?`}function u9t(t){return new RegExp(`^${Eke(t)}$`)}function d9t(t){const e=Eke({precision:t.precision}),r=["Z"];t.local&&r.push(""),t.offset&&r.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");const n=`${e}(?:${r.join("|")})`;return new RegExp(`^${Ske}T(?:${n})$`)}const h9t=t=>{const e=t?`[\\s\\S]{${t?.minimum??0},${t?.maximum??""}}`:"[\\s\\S]*";return new RegExp(`^${e}$`)},f9t=/^-?\d+$/,Tke=/^-?\d+(?:\.\d+)?$/,p9t=/^(?:true|false)$/i,g9t=/^null$/i,m9t=/^[^A-Z]*$/,_9t=/^[^a-z]*$/,Dd=ur("$ZodCheck",(t,e)=>{var r;t._zod??(t._zod={}),t._zod.def=e,(r=t._zod).onattach??(r.onattach=[])}),Cke={number:"number",bigint:"bigint",object:"date"},wke=ur("$ZodCheckLessThan",(t,e)=>{Dd.init(t,e);const r=Cke[typeof e.value];t._zod.onattach.push(n=>{const i=n._zod.bag,a=(e.inclusive?i.maximum:i.exclusiveMaximum)??Number.POSITIVE_INFINITY;e.value{(e.inclusive?n.value<=e.value:n.value{Dd.init(t,e);const r=Cke[typeof e.value];t._zod.onattach.push(n=>{const i=n._zod.bag,a=(e.inclusive?i.minimum:i.exclusiveMinimum)??Number.NEGATIVE_INFINITY;e.value>a&&(e.inclusive?i.minimum=e.value:i.exclusiveMinimum=e.value)}),t._zod.check=n=>{(e.inclusive?n.value>=e.value:n.value>e.value)||n.issues.push({origin:r,code:"too_small",minimum:typeof e.value=="object"?e.value.getTime():e.value,input:n.value,inclusive:e.inclusive,inst:t,continue:!e.abort})}}),v9t=ur("$ZodCheckMultipleOf",(t,e)=>{Dd.init(t,e),t._zod.onattach.push(r=>{var n;(n=r._zod.bag).multipleOf??(n.multipleOf=e.value)}),t._zod.check=r=>{if(typeof r.value!=typeof e.value)throw new Error("Cannot mix number and bigint in multiple_of check.");(typeof r.value=="bigint"?r.value%e.value===BigInt(0):b6t(r.value,e.value)===0)||r.issues.push({origin:typeof r.value,code:"not_multiple_of",divisor:e.value,input:r.value,inst:t,continue:!e.abort})}}),y9t=ur("$ZodCheckNumberFormat",(t,e)=>{Dd.init(t,e),e.format=e.format||"float64";const r=e.format?.includes("int"),n=r?"int":"number",[i,a]=w6t[e.format];t._zod.onattach.push(s=>{const o=s._zod.bag;o.format=e.format,o.minimum=i,o.maximum=a,r&&(o.pattern=f9t)}),t._zod.check=s=>{const o=s.value;if(r){if(!Number.isInteger(o)){s.issues.push({expected:n,format:e.format,code:"invalid_type",continue:!1,input:o,inst:t});return}if(!Number.isSafeInteger(o)){o>0?s.issues.push({input:o,code:"too_big",maximum:Number.MAX_SAFE_INTEGER,note:"Integers must be within the safe integer range.",inst:t,origin:n,inclusive:!0,continue:!e.abort}):s.issues.push({input:o,code:"too_small",minimum:Number.MIN_SAFE_INTEGER,note:"Integers must be within the safe integer range.",inst:t,origin:n,inclusive:!0,continue:!e.abort});return}}oa&&s.issues.push({origin:"number",input:o,code:"too_big",maximum:a,inclusive:!0,inst:t,continue:!e.abort})}}),b9t=ur("$ZodCheckMaxLength",(t,e)=>{var r;Dd.init(t,e),(r=t._zod.def).when??(r.when=n=>{const i=n.value;return!dce(i)&&i.length!==void 0}),t._zod.onattach.push(n=>{const i=n._zod.bag.maximum??Number.POSITIVE_INFINITY;e.maximum{const i=n.value;if(i.length<=e.maximum)return;const s=fce(i);n.issues.push({origin:s,code:"too_big",maximum:e.maximum,inclusive:!0,input:i,inst:t,continue:!e.abort})}}),S9t=ur("$ZodCheckMinLength",(t,e)=>{var r;Dd.init(t,e),(r=t._zod.def).when??(r.when=n=>{const i=n.value;return!dce(i)&&i.length!==void 0}),t._zod.onattach.push(n=>{const i=n._zod.bag.minimum??Number.NEGATIVE_INFINITY;e.minimum>i&&(n._zod.bag.minimum=e.minimum)}),t._zod.check=n=>{const i=n.value;if(i.length>=e.minimum)return;const s=fce(i);n.issues.push({origin:s,code:"too_small",minimum:e.minimum,inclusive:!0,input:i,inst:t,continue:!e.abort})}}),E9t=ur("$ZodCheckLengthEquals",(t,e)=>{var r;Dd.init(t,e),(r=t._zod.def).when??(r.when=n=>{const i=n.value;return!dce(i)&&i.length!==void 0}),t._zod.onattach.push(n=>{const i=n._zod.bag;i.minimum=e.length,i.maximum=e.length,i.length=e.length}),t._zod.check=n=>{const i=n.value,a=i.length;if(a===e.length)return;const s=fce(i),o=a>e.length;n.issues.push({origin:s,...o?{code:"too_big",maximum:e.length}:{code:"too_small",minimum:e.length},inclusive:!0,exact:!0,input:n.value,inst:t,continue:!e.abort})}}),e$=ur("$ZodCheckStringFormat",(t,e)=>{var r,n;Dd.init(t,e),t._zod.onattach.push(i=>{const a=i._zod.bag;a.format=e.format,e.pattern&&(a.patterns??(a.patterns=new Set),a.patterns.add(e.pattern))}),e.pattern?(r=t._zod).check??(r.check=i=>{e.pattern.lastIndex=0,!e.pattern.test(i.value)&&i.issues.push({origin:"string",code:"invalid_format",format:e.format,input:i.value,...e.pattern?{pattern:e.pattern.toString()}:{},inst:t,continue:!e.abort})}):(n=t._zod).check??(n.check=()=>{})}),T9t=ur("$ZodCheckRegex",(t,e)=>{e$.init(t,e),t._zod.check=r=>{e.pattern.lastIndex=0,!e.pattern.test(r.value)&&r.issues.push({origin:"string",code:"invalid_format",format:"regex",input:r.value,pattern:e.pattern.toString(),inst:t,continue:!e.abort})}}),C9t=ur("$ZodCheckLowerCase",(t,e)=>{e.pattern??(e.pattern=m9t),e$.init(t,e)}),w9t=ur("$ZodCheckUpperCase",(t,e)=>{e.pattern??(e.pattern=_9t),e$.init(t,e)}),x9t=ur("$ZodCheckIncludes",(t,e)=>{Dd.init(t,e);const r=ux(e.includes),n=new RegExp(typeof e.position=="number"?`^.{${e.position}}${r}`:r);e.pattern=n,t._zod.onattach.push(i=>{const a=i._zod.bag;a.patterns??(a.patterns=new Set),a.patterns.add(n)}),t._zod.check=i=>{i.value.includes(e.includes,e.position)||i.issues.push({origin:"string",code:"invalid_format",format:"includes",includes:e.includes,input:i.value,inst:t,continue:!e.abort})}}),A9t=ur("$ZodCheckStartsWith",(t,e)=>{Dd.init(t,e);const r=new RegExp(`^${ux(e.prefix)}.*`);e.pattern??(e.pattern=r),t._zod.onattach.push(n=>{const i=n._zod.bag;i.patterns??(i.patterns=new Set),i.patterns.add(r)}),t._zod.check=n=>{n.value.startsWith(e.prefix)||n.issues.push({origin:"string",code:"invalid_format",format:"starts_with",prefix:e.prefix,input:n.value,inst:t,continue:!e.abort})}}),R9t=ur("$ZodCheckEndsWith",(t,e)=>{Dd.init(t,e);const r=new RegExp(`.*${ux(e.suffix)}$`);e.pattern??(e.pattern=r),t._zod.onattach.push(n=>{const i=n._zod.bag;i.patterns??(i.patterns=new Set),i.patterns.add(r)}),t._zod.check=n=>{n.value.endsWith(e.suffix)||n.issues.push({origin:"string",code:"invalid_format",format:"ends_with",suffix:e.suffix,input:n.value,inst:t,continue:!e.abort})}}),N9t=ur("$ZodCheckOverwrite",(t,e)=>{Dd.init(t,e),t._zod.check=r=>{r.value=e.tx(r.value)}});class O9t{constructor(e=[]){this.content=[],this.indent=0,this&&(this.args=e)}indented(e){this.indent+=1,e(this),this.indent-=1}write(e){if(typeof e=="function"){e(this,{execution:"sync"}),e(this,{execution:"async"});return}const n=e.split(` +`).filter(s=>s),i=Math.min(...n.map(s=>s.length-s.trimStart().length)),a=n.map(s=>s.slice(i)).map(s=>" ".repeat(this.indent*2)+s);for(const s of a)this.content.push(s)}compile(){const e=Function,r=this?.args,i=[...(this?.content??[""]).map(a=>` ${a}`)];return new e(...r,i.join(` +`))}}const I9t={major:4,minor:4,patch:3},ks=ur("$ZodType",(t,e)=>{var r;t??(t={}),t._zod.def=e,t._zod.bag=t._zod.bag||{},t._zod.version=I9t;const n=[...t._zod.def.checks??[]];t._zod.traits.has("$ZodCheck")&&n.unshift(t);for(const i of n)for(const a of i._zod.onattach)a(t);if(n.length===0)(r=t._zod).deferred??(r.deferred=[]),t._zod.deferred?.push(()=>{t._zod.run=t._zod.parse});else{const i=(s,o,l)=>{let u=uT(s),d;for(const h of o){if(h._zod.def.when){if(D6t(s)||!h._zod.def.when(s))continue}else if(u)continue;const f=s.issues.length,p=h._zod.check(s);if(p instanceof Promise&&l?.async===!1)throw new qT;if(d||p instanceof Promise)d=(d??Promise.resolve()).then(async()=>{await p,s.issues.length!==f&&(u||(u=uT(s,f)))});else{if(s.issues.length===f)continue;u||(u=uT(s,f))}}return d?d.then(()=>s):s},a=(s,o,l)=>{if(uT(s))return s.aborted=!0,s;const u=i(o,n,l);if(u instanceof Promise){if(l.async===!1)throw new qT;return u.then(d=>t._zod.parse(d,l))}return t._zod.parse(u,l)};t._zod.run=(s,o)=>{if(o.skipChecks)return t._zod.parse(s,o);if(o.direction==="backward"){const u=t._zod.parse({value:s.value,issues:[]},{...o,skipChecks:!0});return u instanceof Promise?u.then(d=>a(d,s,o)):a(u,s,o)}const l=t._zod.parse(s,o);if(l instanceof Promise){if(o.async===!1)throw new qT;return l.then(u=>i(u,n,o))}return i(l,n,o)}}es(t,"~standard",()=>({validate:i=>{try{const a=yke(t,i);return a.success?{value:a.data}:{issues:a.error?.issues}}catch{return P6t(t,i).then(s=>s.success?{value:s.data}:{issues:s.error?.issues})}},vendor:"zod",version:1}))}),mce=ur("$ZodString",(t,e)=>{ks.init(t,e),t._zod.pattern=[...t?._zod.bag?.patterns??[]].pop()??h9t(t._zod.bag),t._zod.parse=(r,n)=>{if(e.coerce)try{r.value=String(r.value)}catch{}return typeof r.value=="string"||r.issues.push({expected:"string",code:"invalid_type",input:r.value,inst:t}),r}}),Ws=ur("$ZodStringFormat",(t,e)=>{e$.init(t,e),mce.init(t,e)}),k9t=ur("$ZodGUID",(t,e)=>{e.pattern??(e.pattern=Z6t),Ws.init(t,e)}),D9t=ur("$ZodUUID",(t,e)=>{if(e.version){const n={v1:1,v2:2,v3:3,v4:4,v5:5,v6:6,v7:7,v8:8}[e.version];if(n===void 0)throw new Error(`Invalid UUID version: "${e.version}"`);e.pattern??(e.pattern=N2e(n))}else e.pattern??(e.pattern=N2e());Ws.init(t,e)}),M9t=ur("$ZodEmail",(t,e)=>{e.pattern??(e.pattern=J6t),Ws.init(t,e)}),L9t=ur("$ZodURL",(t,e)=>{Ws.init(t,e),t._zod.check=r=>{try{const n=r.value.trim();if(!e.normalize&&e.protocol?.source===o9t.source&&!/^https?:\/\//i.test(n)){r.issues.push({code:"invalid_format",format:"url",note:"Invalid URL format",input:r.value,inst:t,continue:!e.abort});return}const i=new URL(n);e.hostname&&(e.hostname.lastIndex=0,e.hostname.test(i.hostname)||r.issues.push({code:"invalid_format",format:"url",note:"Invalid hostname",pattern:e.hostname.source,input:r.value,inst:t,continue:!e.abort})),e.protocol&&(e.protocol.lastIndex=0,e.protocol.test(i.protocol.endsWith(":")?i.protocol.slice(0,-1):i.protocol)||r.issues.push({code:"invalid_format",format:"url",note:"Invalid protocol",pattern:e.protocol.source,input:r.value,inst:t,continue:!e.abort})),e.normalize?r.value=i.href:r.value=n;return}catch{r.issues.push({code:"invalid_format",format:"url",input:r.value,inst:t,continue:!e.abort})}}}),P9t=ur("$ZodEmoji",(t,e)=>{e.pattern??(e.pattern=t9t()),Ws.init(t,e)}),F9t=ur("$ZodNanoID",(t,e)=>{e.pattern??(e.pattern=X6t),Ws.init(t,e)}),B9t=ur("$ZodCUID",(t,e)=>{e.pattern??(e.pattern=V6t),Ws.init(t,e)}),U9t=ur("$ZodCUID2",(t,e)=>{e.pattern??(e.pattern=Y6t),Ws.init(t,e)}),$9t=ur("$ZodULID",(t,e)=>{e.pattern??(e.pattern=W6t),Ws.init(t,e)}),G9t=ur("$ZodXID",(t,e)=>{e.pattern??(e.pattern=K6t),Ws.init(t,e)}),z9t=ur("$ZodKSUID",(t,e)=>{e.pattern??(e.pattern=j6t),Ws.init(t,e)}),q9t=ur("$ZodISODateTime",(t,e)=>{e.pattern??(e.pattern=d9t(e)),Ws.init(t,e)}),H9t=ur("$ZodISODate",(t,e)=>{e.pattern??(e.pattern=c9t),Ws.init(t,e)}),V9t=ur("$ZodISOTime",(t,e)=>{e.pattern??(e.pattern=u9t(e)),Ws.init(t,e)}),Y9t=ur("$ZodISODuration",(t,e)=>{e.pattern??(e.pattern=Q6t),Ws.init(t,e)}),W9t=ur("$ZodIPv4",(t,e)=>{e.pattern??(e.pattern=r9t),Ws.init(t,e),t._zod.bag.format="ipv4"}),K9t=ur("$ZodIPv6",(t,e)=>{e.pattern??(e.pattern=n9t),Ws.init(t,e),t._zod.bag.format="ipv6",t._zod.check=r=>{try{new URL(`http://[${r.value}]`)}catch{r.issues.push({code:"invalid_format",format:"ipv6",input:r.value,inst:t,continue:!e.abort})}}}),j9t=ur("$ZodCIDRv4",(t,e)=>{e.pattern??(e.pattern=i9t),Ws.init(t,e)}),X9t=ur("$ZodCIDRv6",(t,e)=>{e.pattern??(e.pattern=a9t),Ws.init(t,e),t._zod.check=r=>{const n=r.value.split("/");try{if(n.length!==2)throw new Error;const[i,a]=n;if(!a)throw new Error;const s=Number(a);if(`${s}`!==a)throw new Error;if(s<0||s>128)throw new Error;new URL(`http://[${i}]`)}catch{r.issues.push({code:"invalid_format",format:"cidrv6",input:r.value,inst:t,continue:!e.abort})}}});function Ake(t){if(t==="")return!0;if(/\s/.test(t)||t.length%4!==0)return!1;try{return atob(t),!0}catch{return!1}}const Q9t=ur("$ZodBase64",(t,e)=>{e.pattern??(e.pattern=s9t),Ws.init(t,e),t._zod.bag.contentEncoding="base64",t._zod.check=r=>{Ake(r.value)||r.issues.push({code:"invalid_format",format:"base64",input:r.value,inst:t,continue:!e.abort})}});function Z9t(t){if(!bke.test(t))return!1;const e=t.replace(/[-_]/g,n=>n==="-"?"+":"/"),r=e.padEnd(Math.ceil(e.length/4)*4,"=");return Ake(r)}const J9t=ur("$ZodBase64URL",(t,e)=>{e.pattern??(e.pattern=bke),Ws.init(t,e),t._zod.bag.contentEncoding="base64url",t._zod.check=r=>{Z9t(r.value)||r.issues.push({code:"invalid_format",format:"base64url",input:r.value,inst:t,continue:!e.abort})}}),eRt=ur("$ZodE164",(t,e)=>{e.pattern??(e.pattern=l9t),Ws.init(t,e)});function tRt(t,e=null){try{const r=t.split(".");if(r.length!==3)return!1;const[n]=r;if(!n)return!1;const i=JSON.parse(atob(n));return!("typ"in i&&i?.typ!=="JWT"||!i.alg||e&&(!("alg"in i)||i.alg!==e))}catch{return!1}}const rRt=ur("$ZodJWT",(t,e)=>{Ws.init(t,e),t._zod.check=r=>{tRt(r.value,e.alg)||r.issues.push({code:"invalid_format",format:"jwt",input:r.value,inst:t,continue:!e.abort})}}),Rke=ur("$ZodNumber",(t,e)=>{ks.init(t,e),t._zod.pattern=t._zod.bag.pattern??Tke,t._zod.parse=(r,n)=>{if(e.coerce)try{r.value=Number(r.value)}catch{}const i=r.value;if(typeof i=="number"&&!Number.isNaN(i)&&Number.isFinite(i))return r;const a=typeof i=="number"?Number.isNaN(i)?"NaN":Number.isFinite(i)?void 0:"Infinity":void 0;return r.issues.push({expected:"number",code:"invalid_type",input:i,inst:t,...a?{received:a}:{}}),r}}),nRt=ur("$ZodNumberFormat",(t,e)=>{y9t.init(t,e),Rke.init(t,e)}),iRt=ur("$ZodBoolean",(t,e)=>{ks.init(t,e),t._zod.pattern=p9t,t._zod.parse=(r,n)=>{if(e.coerce)try{r.value=!!r.value}catch{}const i=r.value;return typeof i=="boolean"||r.issues.push({expected:"boolean",code:"invalid_type",input:i,inst:t}),r}}),aRt=ur("$ZodNull",(t,e)=>{ks.init(t,e),t._zod.pattern=g9t,t._zod.values=new Set([null]),t._zod.parse=(r,n)=>{const i=r.value;return i===null||r.issues.push({expected:"null",code:"invalid_type",input:i,inst:t}),r}}),sRt=ur("$ZodAny",(t,e)=>{ks.init(t,e),t._zod.parse=r=>r}),oRt=ur("$ZodUnknown",(t,e)=>{ks.init(t,e),t._zod.parse=r=>r}),lRt=ur("$ZodNever",(t,e)=>{ks.init(t,e),t._zod.parse=(r,n)=>(r.issues.push({expected:"never",code:"invalid_type",input:r.value,inst:t}),r)});function O2e(t,e,r){t.issues.length&&e.issues.push(...dT(r,t.issues)),e.value[r]=t.value}const cRt=ur("$ZodArray",(t,e)=>{ks.init(t,e),t._zod.parse=(r,n)=>{const i=r.value;if(!Array.isArray(i))return r.issues.push({expected:"array",code:"invalid_type",input:i,inst:t}),r;r.value=Array(i.length);const a=[];for(let s=0;sO2e(u,r,s))):O2e(l,r,s)}return a.length?Promise.all(a).then(()=>r):r}});function nP(t,e,r,n,i,a){const s=r in n;if(t.issues.length){if(i&&a&&!s)return;e.issues.push(...dT(r,t.issues))}if(!s&&!i){t.issues.length||e.issues.push({code:"invalid_type",expected:"nonoptional",input:void 0,path:[r]});return}t.value===void 0?s&&(e.value[r]=void 0):e.value[r]=t.value}function Nke(t){const e=Object.keys(t.shape);for(const n of e)if(!t.shape?.[n]?._zod?.traits?.has("$ZodType"))throw new Error(`Invalid element at key "${n}": expected a Zod schema`);const r=C6t(t.shape);return{...t,keys:e,keySet:new Set(e),numKeys:e.length,optionalKeys:new Set(r)}}function Oke(t,e,r,n,i,a){const s=[],o=i.keySet,l=i.catchall._zod,u=l.def.type,d=l.optin==="optional",h=l.optout==="optional";for(const f in e){if(f==="__proto__"||o.has(f))continue;if(u==="never"){s.push(f);continue}const p=l.run({value:e[f],issues:[]},n);p instanceof Promise?t.push(p.then(g=>nP(g,r,f,e,d,h))):nP(p,r,f,e,d,h)}return s.length&&r.issues.push({code:"unrecognized_keys",keys:s,input:e,inst:a}),t.length?Promise.all(t).then(()=>r):r}const uRt=ur("$ZodObject",(t,e)=>{if(ks.init(t,e),!Object.getOwnPropertyDescriptor(e,"shape")?.get){const o=e.shape;Object.defineProperty(e,"shape",{get:()=>{const l={...o};return Object.defineProperty(e,"shape",{value:l}),l}})}const n=QU(()=>Nke(e));es(t._zod,"propValues",()=>{const o=e.shape,l={};for(const u in o){const d=o[u]._zod;if(d.values){l[u]??(l[u]=new Set);for(const h of d.values)l[u].add(h)}}return l});const i=YR,a=e.catchall;let s;t._zod.parse=(o,l)=>{s??(s=n.value);const u=o.value;if(!i(u))return o.issues.push({expected:"object",code:"invalid_type",input:u,inst:t}),o;o.value={};const d=[],h=s.shape;for(const f of s.keys){const p=h[f],g=p._zod.optin==="optional",m=p._zod.optout==="optional",_=p._zod.run({value:u[f],issues:[]},l);_ instanceof Promise?d.push(_.then(v=>nP(v,o,f,u,g,m))):nP(_,o,f,u,g,m)}return a?Oke(d,u,o,l,n.value,t):d.length?Promise.all(d).then(()=>o):o}}),dRt=ur("$ZodObjectJIT",(t,e)=>{uRt.init(t,e);const r=t._zod.parse,n=QU(()=>Nke(e)),i=f=>{const p=new O9t(["shape","payload","ctx"]),g=n.value,m=y=>{const E=R2e(y);return`shape[${E}]._zod.run({ value: input[${E}], issues: [] }, ctx)`};p.write("const input = payload.value;");const _=Object.create(null);let v=0;for(const y of g.keys)_[y]=`key_${v++}`;p.write("const newResult = {};");for(const y of g.keys){const E=_[y],T=R2e(y),C=f[y],w=C?._zod?.optin==="optional",x=C?._zod?.optout==="optional";p.write(`const ${E} = ${m(y)};`),w&&x?p.write(` + if (${E}.issues.length) { + if (${T} in input) { + payload.issues = payload.issues.concat(${E}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${T}, ...iss.path] : [${T}] + }))); + } + } + + if (${E}.value === undefined) { + if (${T} in input) { + newResult[${T}] = undefined; + } + } else { + newResult[${T}] = ${E}.value; + } + + `):w?p.write(` + if (${E}.issues.length) { + payload.issues = payload.issues.concat(${E}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${T}, ...iss.path] : [${T}] + }))); + } + + if (${E}.value === undefined) { + if (${T} in input) { + newResult[${T}] = undefined; + } + } else { + newResult[${T}] = ${E}.value; + } + + `):p.write(` + const ${E}_present = ${T} in input; + if (${E}.issues.length) { + payload.issues = payload.issues.concat(${E}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${T}, ...iss.path] : [${T}] + }))); + } + if (!${E}_present && !${E}.issues.length) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: undefined, + path: [${T}] + }); + } + + if (${E}_present) { + if (${E}.value === undefined) { + newResult[${T}] = undefined; + } else { + newResult[${T}] = ${E}.value; + } + } + + `)}p.write("payload.value = newResult;"),p.write("return payload;");const b=p.compile();return(y,E)=>b(f,y,E)};let a;const s=YR,o=!uce.jitless,u=o&&E6t.value,d=e.catchall;let h;t._zod.parse=(f,p)=>{h??(h=n.value);const g=f.value;return s(g)?o&&u&&p?.async===!1&&p.jitless!==!0?(a||(a=i(e.shape)),f=a(f,p),d?Oke([],g,f,p,h,t):f):r(f,p):(f.issues.push({expected:"object",code:"invalid_type",input:g,inst:t}),f)}});function I2e(t,e,r,n){for(const a of t)if(a.issues.length===0)return e.value=a.value,e;const i=t.filter(a=>!uT(a));return i.length===1?(e.value=i[0].value,i[0]):(e.issues.push({code:"invalid_union",input:e.value,inst:r,errors:t.map(a=>a.issues.map(s=>q0(s,n,z0())))}),e)}const Ike=ur("$ZodUnion",(t,e)=>{ks.init(t,e),es(t._zod,"optin",()=>e.options.some(n=>n._zod.optin==="optional")?"optional":void 0),es(t._zod,"optout",()=>e.options.some(n=>n._zod.optout==="optional")?"optional":void 0),es(t._zod,"values",()=>{if(e.options.every(n=>n._zod.values))return new Set(e.options.flatMap(n=>Array.from(n._zod.values)))}),es(t._zod,"pattern",()=>{if(e.options.every(n=>n._zod.pattern)){const n=e.options.map(i=>i._zod.pattern);return new RegExp(`^(${n.map(i=>hce(i.source)).join("|")})$`)}});const r=e.options.length===1?e.options[0]._zod.run:null;t._zod.parse=(n,i)=>{if(r)return r(n,i);let a=!1;const s=[];for(const o of e.options){const l=o._zod.run({value:n.value,issues:[]},i);if(l instanceof Promise)s.push(l),a=!0;else{if(l.issues.length===0)return l;s.push(l)}}return a?Promise.all(s).then(o=>I2e(o,n,t,i)):I2e(s,n,t,i)}}),hRt=ur("$ZodDiscriminatedUnion",(t,e)=>{e.inclusive=!1,Ike.init(t,e);const r=t._zod.parse;es(t._zod,"propValues",()=>{const i={};for(const a of e.options){const s=a._zod.propValues;if(!s||Object.keys(s).length===0)throw new Error(`Invalid discriminated union option at index "${e.options.indexOf(a)}"`);for(const[o,l]of Object.entries(s)){i[o]||(i[o]=new Set);for(const u of l)i[o].add(u)}}return i});const n=QU(()=>{const i=e.options,a=new Map;for(const s of i){const o=s._zod.propValues?.[e.discriminator];if(!o||o.size===0)throw new Error(`Invalid discriminated union option at index "${e.options.indexOf(s)}"`);for(const l of o){if(a.has(l))throw new Error(`Duplicate discriminator value "${String(l)}"`);a.set(l,s)}}return a});t._zod.parse=(i,a)=>{const s=i.value;if(!YR(s))return i.issues.push({code:"invalid_type",expected:"object",input:s,inst:t}),i;const o=n.value.get(s?.[e.discriminator]);return o?o._zod.run(i,a):e.unionFallback||a.direction==="backward"?r(i,a):(i.issues.push({code:"invalid_union",errors:[],note:"No matching discriminator",discriminator:e.discriminator,options:Array.from(n.value.keys()),input:s,path:[e.discriminator],inst:t}),i)}}),fRt=ur("$ZodIntersection",(t,e)=>{ks.init(t,e),t._zod.parse=(r,n)=>{const i=r.value,a=e.left._zod.run({value:i,issues:[]},n),s=e.right._zod.run({value:i,issues:[]},n);return a instanceof Promise||s instanceof Promise?Promise.all([a,s]).then(([l,u])=>k2e(r,l,u)):k2e(r,a,s)}});function nee(t,e){if(t===e)return{valid:!0,data:t};if(t instanceof Date&&e instanceof Date&&+t==+e)return{valid:!0,data:t};if(cx(t)&&cx(e)){const r=Object.keys(e),n=Object.keys(t).filter(a=>r.indexOf(a)!==-1),i={...t,...e};for(const a of n){const s=nee(t[a],e[a]);if(!s.valid)return{valid:!1,mergeErrorPath:[a,...s.mergeErrorPath]};i[a]=s.data}return{valid:!0,data:i}}if(Array.isArray(t)&&Array.isArray(e)){if(t.length!==e.length)return{valid:!1,mergeErrorPath:[]};const r=[];for(let n=0;no.l&&o.r).map(([o])=>o);if(a.length&&i&&t.issues.push({...i,keys:a}),uT(t))return t;const s=nee(e.value,r.value);if(!s.valid)throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(s.mergeErrorPath)}`);return t.value=s.data,t}const pRt=ur("$ZodRecord",(t,e)=>{ks.init(t,e),t._zod.parse=(r,n)=>{const i=r.value;if(!cx(i))return r.issues.push({expected:"record",code:"invalid_type",input:i,inst:t}),r;const a=[],s=e.keyType._zod.values;if(s){r.value={};const o=new Set;for(const u of s)if(typeof u=="string"||typeof u=="number"||typeof u=="symbol"){o.add(typeof u=="number"?u.toString():u);const d=e.keyType._zod.run({value:u,issues:[]},n);if(d instanceof Promise)throw new Error("Async schemas not supported in object keys currently");if(d.issues.length){r.issues.push({code:"invalid_key",origin:"record",issues:d.issues.map(p=>q0(p,n,z0())),input:u,path:[u],inst:t});continue}const h=d.value,f=e.valueType._zod.run({value:i[u],issues:[]},n);f instanceof Promise?a.push(f.then(p=>{p.issues.length&&r.issues.push(...dT(u,p.issues)),r.value[h]=p.value})):(f.issues.length&&r.issues.push(...dT(u,f.issues)),r.value[h]=f.value)}let l;for(const u in i)o.has(u)||(l=l??[],l.push(u));l&&l.length>0&&r.issues.push({code:"unrecognized_keys",input:i,inst:t,keys:l})}else{r.value={};for(const o of Reflect.ownKeys(i)){if(o==="__proto__"||!Object.prototype.propertyIsEnumerable.call(i,o))continue;let l=e.keyType._zod.run({value:o,issues:[]},n);if(l instanceof Promise)throw new Error("Async schemas not supported in object keys currently");if(typeof o=="string"&&Tke.test(o)&&l.issues.length){const h=e.keyType._zod.run({value:Number(o),issues:[]},n);if(h instanceof Promise)throw new Error("Async schemas not supported in object keys currently");h.issues.length===0&&(l=h)}if(l.issues.length){e.mode==="loose"?r.value[o]=i[o]:r.issues.push({code:"invalid_key",origin:"record",issues:l.issues.map(h=>q0(h,n,z0())),input:o,path:[o],inst:t});continue}const d=e.valueType._zod.run({value:i[o],issues:[]},n);d instanceof Promise?a.push(d.then(h=>{h.issues.length&&r.issues.push(...dT(o,h.issues)),r.value[l.value]=h.value})):(d.issues.length&&r.issues.push(...dT(o,d.issues)),r.value[l.value]=d.value)}}return a.length?Promise.all(a).then(()=>r):r}}),gRt=ur("$ZodEnum",(t,e)=>{ks.init(t,e);const r=fke(e.entries),n=new Set(r);t._zod.values=n,t._zod.pattern=new RegExp(`^(${r.filter(i=>T6t.has(typeof i)).map(i=>typeof i=="string"?ux(i):i.toString()).join("|")})$`),t._zod.parse=(i,a)=>{const s=i.value;return n.has(s)||i.issues.push({code:"invalid_value",values:r,input:s,inst:t}),i}}),mRt=ur("$ZodLiteral",(t,e)=>{if(ks.init(t,e),e.values.length===0)throw new Error("Cannot create literal schema with no valid values");const r=new Set(e.values);t._zod.values=r,t._zod.pattern=new RegExp(`^(${e.values.map(n=>typeof n=="string"?ux(n):n?ux(n.toString()):String(n)).join("|")})$`),t._zod.parse=(n,i)=>{const a=n.value;return r.has(a)||n.issues.push({code:"invalid_value",values:e.values,input:a,inst:t}),n}}),_Rt=ur("$ZodTransform",(t,e)=>{ks.init(t,e),t._zod.optin="optional",t._zod.parse=(r,n)=>{if(n.direction==="backward")throw new hke(t.constructor.name);const i=e.transform(r.value,r);if(n.async)return(i instanceof Promise?i:Promise.resolve(i)).then(s=>(r.value=s,r.fallback=!0,r));if(i instanceof Promise)throw new qT;return r.value=i,r.fallback=!0,r}});function D2e(t,e){return e===void 0&&(t.issues.length||t.fallback)?{issues:[],value:void 0}:t}const kke=ur("$ZodOptional",(t,e)=>{ks.init(t,e),t._zod.optin="optional",t._zod.optout="optional",es(t._zod,"values",()=>e.innerType._zod.values?new Set([...e.innerType._zod.values,void 0]):void 0),es(t._zod,"pattern",()=>{const r=e.innerType._zod.pattern;return r?new RegExp(`^(${hce(r.source)})?$`):void 0}),t._zod.parse=(r,n)=>{if(e.innerType._zod.optin==="optional"){const i=r.value,a=e.innerType._zod.run(r,n);return a instanceof Promise?a.then(s=>D2e(s,i)):D2e(a,i)}return r.value===void 0?r:e.innerType._zod.run(r,n)}}),vRt=ur("$ZodExactOptional",(t,e)=>{kke.init(t,e),es(t._zod,"values",()=>e.innerType._zod.values),es(t._zod,"pattern",()=>e.innerType._zod.pattern),t._zod.parse=(r,n)=>e.innerType._zod.run(r,n)}),yRt=ur("$ZodNullable",(t,e)=>{ks.init(t,e),es(t._zod,"optin",()=>e.innerType._zod.optin),es(t._zod,"optout",()=>e.innerType._zod.optout),es(t._zod,"pattern",()=>{const r=e.innerType._zod.pattern;return r?new RegExp(`^(${hce(r.source)}|null)$`):void 0}),es(t._zod,"values",()=>e.innerType._zod.values?new Set([...e.innerType._zod.values,null]):void 0),t._zod.parse=(r,n)=>r.value===null?r:e.innerType._zod.run(r,n)}),bRt=ur("$ZodDefault",(t,e)=>{ks.init(t,e),t._zod.optin="optional",es(t._zod,"values",()=>e.innerType._zod.values),t._zod.parse=(r,n)=>{if(n.direction==="backward")return e.innerType._zod.run(r,n);if(r.value===void 0)return r.value=e.defaultValue,r;const i=e.innerType._zod.run(r,n);return i instanceof Promise?i.then(a=>M2e(a,e)):M2e(i,e)}});function M2e(t,e){return t.value===void 0&&(t.value=e.defaultValue),t}const SRt=ur("$ZodPrefault",(t,e)=>{ks.init(t,e),t._zod.optin="optional",es(t._zod,"values",()=>e.innerType._zod.values),t._zod.parse=(r,n)=>(n.direction==="backward"||r.value===void 0&&(r.value=e.defaultValue),e.innerType._zod.run(r,n))}),ERt=ur("$ZodNonOptional",(t,e)=>{ks.init(t,e),es(t._zod,"values",()=>{const r=e.innerType._zod.values;return r?new Set([...r].filter(n=>n!==void 0)):void 0}),t._zod.parse=(r,n)=>{const i=e.innerType._zod.run(r,n);return i instanceof Promise?i.then(a=>L2e(a,t)):L2e(i,t)}});function L2e(t,e){return!t.issues.length&&t.value===void 0&&t.issues.push({code:"invalid_type",expected:"nonoptional",input:t.value,inst:e}),t}const TRt=ur("$ZodCatch",(t,e)=>{ks.init(t,e),t._zod.optin="optional",es(t._zod,"optout",()=>e.innerType._zod.optout),es(t._zod,"values",()=>e.innerType._zod.values),t._zod.parse=(r,n)=>{if(n.direction==="backward")return e.innerType._zod.run(r,n);const i=e.innerType._zod.run(r,n);return i instanceof Promise?i.then(a=>(r.value=a.value,a.issues.length&&(r.value=e.catchValue({...r,error:{issues:a.issues.map(s=>q0(s,n,z0()))},input:r.value}),r.issues=[],r.fallback=!0),r)):(r.value=i.value,i.issues.length&&(r.value=e.catchValue({...r,error:{issues:i.issues.map(a=>q0(a,n,z0()))},input:r.value}),r.issues=[],r.fallback=!0),r)}}),Dke=ur("$ZodPipe",(t,e)=>{ks.init(t,e),es(t._zod,"values",()=>e.in._zod.values),es(t._zod,"optin",()=>e.in._zod.optin),es(t._zod,"optout",()=>e.out._zod.optout),es(t._zod,"propValues",()=>e.in._zod.propValues),t._zod.parse=(r,n)=>{if(n.direction==="backward"){const a=e.out._zod.run(r,n);return a instanceof Promise?a.then(s=>ZO(s,e.in,n)):ZO(a,e.in,n)}const i=e.in._zod.run(r,n);return i instanceof Promise?i.then(a=>ZO(a,e.out,n)):ZO(i,e.out,n)}});function ZO(t,e,r){return t.issues.length?(t.aborted=!0,t):e._zod.run({value:t.value,issues:t.issues,fallback:t.fallback},r)}const CRt=ur("$ZodPreprocess",(t,e)=>{Dke.init(t,e)}),wRt=ur("$ZodReadonly",(t,e)=>{ks.init(t,e),es(t._zod,"propValues",()=>e.innerType._zod.propValues),es(t._zod,"values",()=>e.innerType._zod.values),es(t._zod,"optin",()=>e.innerType?._zod?.optin),es(t._zod,"optout",()=>e.innerType?._zod?.optout),t._zod.parse=(r,n)=>{if(n.direction==="backward")return e.innerType._zod.run(r,n);const i=e.innerType._zod.run(r,n);return i instanceof Promise?i.then(P2e):P2e(i)}});function P2e(t){return t.value=Object.freeze(t.value),t}const xRt=ur("$ZodCustom",(t,e)=>{Dd.init(t,e),ks.init(t,e),t._zod.parse=(r,n)=>r,t._zod.check=r=>{const n=r.value,i=e.fn(n);if(i instanceof Promise)return i.then(a=>F2e(a,r,n,t));F2e(i,r,n,t)}});function F2e(t,e,r,n){if(!t){const i={code:"custom",input:r,inst:n,path:[...n._zod.def.path??[]],continue:!n._zod.def.abort};n._zod.def.params&&(i.params=n._zod.def.params),e.issues.push(WR(i))}}var B2e;class ARt{constructor(){this._map=new WeakMap,this._idmap=new Map}add(e,...r){const n=r[0];return this._map.set(e,n),n&&typeof n=="object"&&"id"in n&&this._idmap.set(n.id,e),this}clear(){return this._map=new WeakMap,this._idmap=new Map,this}remove(e){const r=this._map.get(e);return r&&typeof r=="object"&&"id"in r&&this._idmap.delete(r.id),this._map.delete(e),this}get(e){const r=e._zod.parent;if(r){const n={...this.get(r)??{}};delete n.id;const i={...n,...this._map.get(e)};return Object.keys(i).length?i:void 0}return this._map.get(e)}has(e){return this._map.has(e)}}function RRt(){return new ARt}(B2e=globalThis).__zod_globalRegistry??(B2e.__zod_globalRegistry=RRt());const F6=globalThis.__zod_globalRegistry;function NRt(t,e){return new t({type:"string",...Dn(e)})}function ORt(t,e){return new t({type:"string",format:"email",check:"string_format",abort:!1,...Dn(e)})}function U2e(t,e){return new t({type:"string",format:"guid",check:"string_format",abort:!1,...Dn(e)})}function IRt(t,e){return new t({type:"string",format:"uuid",check:"string_format",abort:!1,...Dn(e)})}function kRt(t,e){return new t({type:"string",format:"uuid",check:"string_format",abort:!1,version:"v4",...Dn(e)})}function DRt(t,e){return new t({type:"string",format:"uuid",check:"string_format",abort:!1,version:"v6",...Dn(e)})}function MRt(t,e){return new t({type:"string",format:"uuid",check:"string_format",abort:!1,version:"v7",...Dn(e)})}function Mke(t,e){return new t({type:"string",format:"url",check:"string_format",abort:!1,...Dn(e)})}function LRt(t,e){return new t({type:"string",format:"emoji",check:"string_format",abort:!1,...Dn(e)})}function PRt(t,e){return new t({type:"string",format:"nanoid",check:"string_format",abort:!1,...Dn(e)})}function FRt(t,e){return new t({type:"string",format:"cuid",check:"string_format",abort:!1,...Dn(e)})}function BRt(t,e){return new t({type:"string",format:"cuid2",check:"string_format",abort:!1,...Dn(e)})}function URt(t,e){return new t({type:"string",format:"ulid",check:"string_format",abort:!1,...Dn(e)})}function $Rt(t,e){return new t({type:"string",format:"xid",check:"string_format",abort:!1,...Dn(e)})}function GRt(t,e){return new t({type:"string",format:"ksuid",check:"string_format",abort:!1,...Dn(e)})}function zRt(t,e){return new t({type:"string",format:"ipv4",check:"string_format",abort:!1,...Dn(e)})}function qRt(t,e){return new t({type:"string",format:"ipv6",check:"string_format",abort:!1,...Dn(e)})}function HRt(t,e){return new t({type:"string",format:"cidrv4",check:"string_format",abort:!1,...Dn(e)})}function VRt(t,e){return new t({type:"string",format:"cidrv6",check:"string_format",abort:!1,...Dn(e)})}function YRt(t,e){return new t({type:"string",format:"base64",check:"string_format",abort:!1,...Dn(e)})}function WRt(t,e){return new t({type:"string",format:"base64url",check:"string_format",abort:!1,...Dn(e)})}function KRt(t,e){return new t({type:"string",format:"e164",check:"string_format",abort:!1,...Dn(e)})}function jRt(t,e){return new t({type:"string",format:"jwt",check:"string_format",abort:!1,...Dn(e)})}function XRt(t,e){return new t({type:"string",format:"datetime",check:"string_format",offset:!1,local:!1,precision:null,...Dn(e)})}function QRt(t,e){return new t({type:"string",format:"date",check:"string_format",...Dn(e)})}function ZRt(t,e){return new t({type:"string",format:"time",check:"string_format",precision:null,...Dn(e)})}function JRt(t,e){return new t({type:"string",format:"duration",check:"string_format",...Dn(e)})}function e7t(t,e){return new t({type:"number",checks:[],...Dn(e)})}function t7t(t,e){return new t({type:"number",coerce:!0,checks:[],...Dn(e)})}function r7t(t,e){return new t({type:"number",check:"number_format",abort:!1,format:"safeint",...Dn(e)})}function n7t(t,e){return new t({type:"boolean",...Dn(e)})}function i7t(t,e){return new t({type:"null",...Dn(e)})}function a7t(t){return new t({type:"any"})}function s7t(t){return new t({type:"unknown"})}function o7t(t,e){return new t({type:"never",...Dn(e)})}function $2e(t,e){return new wke({check:"less_than",...Dn(e),value:t,inclusive:!1})}function lK(t,e){return new wke({check:"less_than",...Dn(e),value:t,inclusive:!0})}function G2e(t,e){return new xke({check:"greater_than",...Dn(e),value:t,inclusive:!1})}function cK(t,e){return new xke({check:"greater_than",...Dn(e),value:t,inclusive:!0})}function z2e(t,e){return new v9t({check:"multiple_of",...Dn(e),value:t})}function Lke(t,e){return new b9t({check:"max_length",...Dn(e),maximum:t})}function iP(t,e){return new S9t({check:"min_length",...Dn(e),minimum:t})}function Pke(t,e){return new E9t({check:"length_equals",...Dn(e),length:t})}function l7t(t,e){return new T9t({check:"string_format",format:"regex",...Dn(e),pattern:t})}function c7t(t){return new C9t({check:"string_format",format:"lowercase",...Dn(t)})}function u7t(t){return new w9t({check:"string_format",format:"uppercase",...Dn(t)})}function d7t(t,e){return new x9t({check:"string_format",format:"includes",...Dn(e),includes:t})}function h7t(t,e){return new A9t({check:"string_format",format:"starts_with",...Dn(e),prefix:t})}function f7t(t,e){return new R9t({check:"string_format",format:"ends_with",...Dn(e),suffix:t})}function S4(t){return new N9t({check:"overwrite",tx:t})}function p7t(t){return S4(e=>e.normalize(t))}function g7t(){return S4(t=>t.trim())}function m7t(){return S4(t=>t.toLowerCase())}function _7t(){return S4(t=>t.toUpperCase())}function v7t(){return S4(t=>S6t(t))}function y7t(t,e,r){return new t({type:"array",element:e,...Dn(r)})}function b7t(t,e,r){const n=Dn(r);return n.abort??(n.abort=!0),new t({type:"custom",check:"custom",fn:e,...n})}function S7t(t,e,r){return new t({type:"custom",check:"custom",fn:e,...Dn(r)})}function E7t(t,e){const r=T7t(n=>(n.addIssue=i=>{if(typeof i=="string")n.issues.push(WR(i,n.value,r._zod.def));else{const a=i;a.fatal&&(a.continue=!1),a.code??(a.code="custom"),a.input??(a.input=n.value),a.inst??(a.inst=r),a.continue??(a.continue=!r._zod.def.abort),n.issues.push(WR(a))}},t(n.value,n)),e);return r}function T7t(t,e){const r=new Dd({check:"custom",...Dn(e)});return r._zod.check=t,r}function Fke(t){let e=t?.target??"draft-2020-12";return e==="draft-4"&&(e="draft-04"),e==="draft-7"&&(e="draft-07"),{processors:t.processors??{},metadataRegistry:t?.metadata??F6,target:e,unrepresentable:t?.unrepresentable??"throw",override:t?.override??(()=>{}),io:t?.io??"output",counter:0,seen:new Map,cycles:t?.cycles??"ref",reused:t?.reused??"inline",external:t?.external??void 0}}function il(t,e,r={path:[],schemaPath:[]}){var n;const i=t._zod.def,a=e.seen.get(t);if(a)return a.count++,r.schemaPath.includes(t)&&(a.cycle=r.path),a.schema;const s={schema:{},count:1,cycle:void 0,path:r.path};e.seen.set(t,s);const o=t._zod.toJSONSchema?.();if(o)s.schema=o;else{const d={...r,schemaPath:[...r.schemaPath,t],path:r.path};if(t._zod.processJSONSchema)t._zod.processJSONSchema(e,s.schema,d);else{const f=s.schema,p=e.processors[i.type];if(!p)throw new Error(`[toJSONSchema]: Non-representable type encountered: ${i.type}`);p(t,e,f,d)}const h=t._zod.parent;h&&(s.ref||(s.ref=h),il(h,e,d),e.seen.get(h).isParent=!0)}const l=e.metadataRegistry.get(t);return l&&Object.assign(s.schema,l),e.io==="input"&&du(t)&&(delete s.schema.examples,delete s.schema.default),e.io==="input"&&"_prefault"in s.schema&&((n=s.schema).default??(n.default=s.schema._prefault)),delete s.schema._prefault,e.seen.get(t).schema}function Bke(t,e){const r=t.seen.get(e);if(!r)throw new Error("Unprocessed schema. This is a bug in Zod.");const n=new Map;for(const s of t.seen.entries()){const o=t.metadataRegistry.get(s[0])?.id;if(o){const l=n.get(o);if(l&&l!==s[0])throw new Error(`Duplicate schema id "${o}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);n.set(o,s[0])}}const i=s=>{const o=t.target==="draft-2020-12"?"$defs":"definitions";if(t.external){const h=t.external.registry.get(s[0])?.id,f=t.external.uri??(g=>g);if(h)return{ref:f(h)};const p=s[1].defId??s[1].schema.id??`schema${t.counter++}`;return s[1].defId=p,{defId:p,ref:`${f("__shared")}#/${o}/${p}`}}if(s[1]===r)return{ref:"#"};const u=`#/${o}/`,d=s[1].schema.id??`__schema${t.counter++}`;return{defId:d,ref:u+d}},a=s=>{if(s[1].schema.$ref)return;const o=s[1],{ref:l,defId:u}=i(s);o.def={...o.schema},u&&(o.defId=u);const d=o.schema;for(const h in d)delete d[h];d.$ref=l};if(t.cycles==="throw")for(const s of t.seen.entries()){const o=s[1];if(o.cycle)throw new Error(`Cycle detected: #/${o.cycle?.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`)}for(const s of t.seen.entries()){const o=s[1];if(e===s[0]){a(s);continue}if(t.external){const u=t.external.registry.get(s[0])?.id;if(e!==s[0]&&u){a(s);continue}}if(t.metadataRegistry.get(s[0])?.id){a(s);continue}if(o.cycle){a(s);continue}if(o.count>1&&t.reused==="ref"){a(s);continue}}}function Uke(t,e){const r=t.seen.get(e);if(!r)throw new Error("Unprocessed schema. This is a bug in Zod.");const n=o=>{const l=t.seen.get(o);if(l.ref===null)return;const u=l.def??l.schema,d={...u},h=l.ref;if(l.ref=null,h){n(h);const p=t.seen.get(h),g=p.schema;if(g.$ref&&(t.target==="draft-07"||t.target==="draft-04"||t.target==="openapi-3.0")?(u.allOf=u.allOf??[],u.allOf.push(g)):Object.assign(u,g),Object.assign(u,d),o._zod.parent===h)for(const _ in u)_==="$ref"||_==="allOf"||_ in d||delete u[_];if(g.$ref&&p.def)for(const _ in u)_==="$ref"||_==="allOf"||_ in p.def&&JSON.stringify(u[_])===JSON.stringify(p.def[_])&&delete u[_]}const f=o._zod.parent;if(f&&f!==h){n(f);const p=t.seen.get(f);if(p?.schema.$ref&&(u.$ref=p.schema.$ref,p.def))for(const g in u)g==="$ref"||g==="allOf"||g in p.def&&JSON.stringify(u[g])===JSON.stringify(p.def[g])&&delete u[g]}t.override({zodSchema:o,jsonSchema:u,path:l.path??[]})};for(const o of[...t.seen.entries()].reverse())n(o[0]);const i={};if(t.target==="draft-2020-12"?i.$schema="https://json-schema.org/draft/2020-12/schema":t.target==="draft-07"?i.$schema="http://json-schema.org/draft-07/schema#":t.target==="draft-04"?i.$schema="http://json-schema.org/draft-04/schema#":t.target,t.external?.uri){const o=t.external.registry.get(e)?.id;if(!o)throw new Error("Schema is missing an `id` property");i.$id=t.external.uri(o)}Object.assign(i,r.def??r.schema);const a=t.metadataRegistry.get(e)?.id;a!==void 0&&i.id===a&&delete i.id;const s=t.external?.defs??{};for(const o of t.seen.entries()){const l=o[1];l.def&&l.defId&&(l.def.id===l.defId&&delete l.def.id,s[l.defId]=l.def)}t.external||Object.keys(s).length>0&&(t.target==="draft-2020-12"?i.$defs=s:i.definitions=s);try{const o=JSON.parse(JSON.stringify(i));return Object.defineProperty(o,"~standard",{value:{...e["~standard"],jsonSchema:{input:aP(e,"input",t.processors),output:aP(e,"output",t.processors)}},enumerable:!1,writable:!1}),o}catch{throw new Error("Error converting schema to JSON.")}}function du(t,e){const r=e??{seen:new Set};if(r.seen.has(t))return!1;r.seen.add(t);const n=t._zod.def;if(n.type==="transform")return!0;if(n.type==="array")return du(n.element,r);if(n.type==="set")return du(n.valueType,r);if(n.type==="lazy")return du(n.getter(),r);if(n.type==="promise"||n.type==="optional"||n.type==="nonoptional"||n.type==="nullable"||n.type==="readonly"||n.type==="default"||n.type==="prefault")return du(n.innerType,r);if(n.type==="intersection")return du(n.left,r)||du(n.right,r);if(n.type==="record"||n.type==="map")return du(n.keyType,r)||du(n.valueType,r);if(n.type==="pipe")return t._zod.traits.has("$ZodCodec")?!0:du(n.in,r)||du(n.out,r);if(n.type==="object"){for(const i in n.shape)if(du(n.shape[i],r))return!0;return!1}if(n.type==="union"){for(const i of n.options)if(du(i,r))return!0;return!1}if(n.type==="tuple"){for(const i of n.items)if(du(i,r))return!0;return!!(n.rest&&du(n.rest,r))}return!1}const C7t=(t,e={})=>r=>{const n=Fke({...r,processors:e});return il(t,n),Bke(n,t),Uke(n,t)},aP=(t,e,r={})=>n=>{const{libraryOptions:i,target:a}=n??{},s=Fke({...i??{},target:a,io:e,processors:r});return il(t,s),Bke(s,t),Uke(s,t)},w7t={guid:"uuid",url:"uri",datetime:"date-time",json_string:"json-string",regex:""},x7t=(t,e,r,n)=>{const i=r;i.type="string";const{minimum:a,maximum:s,format:o,patterns:l,contentEncoding:u}=t._zod.bag;if(typeof a=="number"&&(i.minLength=a),typeof s=="number"&&(i.maxLength=s),o&&(i.format=w7t[o]??o,i.format===""&&delete i.format,o==="time"&&delete i.format),u&&(i.contentEncoding=u),l&&l.size>0){const d=[...l];d.length===1?i.pattern=d[0].source:d.length>1&&(i.allOf=[...d.map(h=>({...e.target==="draft-07"||e.target==="draft-04"||e.target==="openapi-3.0"?{type:"string"}:{},pattern:h.source}))])}},A7t=(t,e,r,n)=>{const i=r,{minimum:a,maximum:s,format:o,multipleOf:l,exclusiveMaximum:u,exclusiveMinimum:d}=t._zod.bag;typeof o=="string"&&o.includes("int")?i.type="integer":i.type="number";const h=typeof d=="number"&&d>=(a??Number.NEGATIVE_INFINITY),f=typeof u=="number"&&u<=(s??Number.POSITIVE_INFINITY),p=e.target==="draft-04"||e.target==="openapi-3.0";h?p?(i.minimum=d,i.exclusiveMinimum=!0):i.exclusiveMinimum=d:typeof a=="number"&&(i.minimum=a),f?p?(i.maximum=u,i.exclusiveMaximum=!0):i.exclusiveMaximum=u:typeof s=="number"&&(i.maximum=s),typeof l=="number"&&(i.multipleOf=l)},R7t=(t,e,r,n)=>{r.type="boolean"},N7t=(t,e,r,n)=>{e.target==="openapi-3.0"?(r.type="string",r.nullable=!0,r.enum=[null]):r.type="null"},O7t=(t,e,r,n)=>{r.not={}},I7t=(t,e,r,n)=>{},k7t=(t,e,r,n)=>{},D7t=(t,e,r,n)=>{const i=t._zod.def,a=fke(i.entries);a.every(s=>typeof s=="number")&&(r.type="number"),a.every(s=>typeof s=="string")&&(r.type="string"),r.enum=a},M7t=(t,e,r,n)=>{const i=t._zod.def,a=[];for(const s of i.values)if(s===void 0){if(e.unrepresentable==="throw")throw new Error("Literal `undefined` cannot be represented in JSON Schema")}else if(typeof s=="bigint"){if(e.unrepresentable==="throw")throw new Error("BigInt literals cannot be represented in JSON Schema");a.push(Number(s))}else a.push(s);if(a.length!==0)if(a.length===1){const s=a[0];r.type=s===null?"null":typeof s,e.target==="draft-04"||e.target==="openapi-3.0"?r.enum=[s]:r.const=s}else a.every(s=>typeof s=="number")&&(r.type="number"),a.every(s=>typeof s=="string")&&(r.type="string"),a.every(s=>typeof s=="boolean")&&(r.type="boolean"),a.every(s=>s===null)&&(r.type="null"),r.enum=a},L7t=(t,e,r,n)=>{if(e.unrepresentable==="throw")throw new Error("Custom types cannot be represented in JSON Schema")},P7t=(t,e,r,n)=>{if(e.unrepresentable==="throw")throw new Error("Transforms cannot be represented in JSON Schema")},F7t=(t,e,r,n)=>{const i=r,a=t._zod.def,{minimum:s,maximum:o}=t._zod.bag;typeof s=="number"&&(i.minItems=s),typeof o=="number"&&(i.maxItems=o),i.type="array",i.items=il(a.element,e,{...n,path:[...n.path,"items"]})},B7t=(t,e,r,n)=>{const i=r,a=t._zod.def;i.type="object",i.properties={};const s=a.shape;for(const u in s)i.properties[u]=il(s[u],e,{...n,path:[...n.path,"properties",u]});const o=new Set(Object.keys(s)),l=new Set([...o].filter(u=>{const d=a.shape[u]._zod;return e.io==="input"?d.optin===void 0:d.optout===void 0}));l.size>0&&(i.required=Array.from(l)),a.catchall?._zod.def.type==="never"?i.additionalProperties=!1:a.catchall?a.catchall&&(i.additionalProperties=il(a.catchall,e,{...n,path:[...n.path,"additionalProperties"]})):e.io==="output"&&(i.additionalProperties=!1)},U7t=(t,e,r,n)=>{const i=t._zod.def,a=i.inclusive===!1,s=i.options.map((o,l)=>il(o,e,{...n,path:[...n.path,a?"oneOf":"anyOf",l]}));a?r.oneOf=s:r.anyOf=s},$7t=(t,e,r,n)=>{const i=t._zod.def,a=il(i.left,e,{...n,path:[...n.path,"allOf",0]}),s=il(i.right,e,{...n,path:[...n.path,"allOf",1]}),o=u=>"allOf"in u&&Object.keys(u).length===1,l=[...o(a)?a.allOf:[a],...o(s)?s.allOf:[s]];r.allOf=l},G7t=(t,e,r,n)=>{const i=r,a=t._zod.def;i.type="object";const s=a.keyType,l=s._zod.bag?.patterns;if(a.mode==="loose"&&l&&l.size>0){const d=il(a.valueType,e,{...n,path:[...n.path,"patternProperties","*"]});i.patternProperties={};for(const h of l)i.patternProperties[h.source]=d}else(e.target==="draft-07"||e.target==="draft-2020-12")&&(i.propertyNames=il(a.keyType,e,{...n,path:[...n.path,"propertyNames"]})),i.additionalProperties=il(a.valueType,e,{...n,path:[...n.path,"additionalProperties"]});const u=s._zod.values;if(u){const d=[...u].filter(h=>typeof h=="string"||typeof h=="number");d.length>0&&(i.required=d)}},z7t=(t,e,r,n)=>{const i=t._zod.def,a=il(i.innerType,e,n),s=e.seen.get(t);e.target==="openapi-3.0"?(s.ref=i.innerType,r.nullable=!0):r.anyOf=[a,{type:"null"}]},q7t=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType},H7t=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType,r.default=JSON.parse(JSON.stringify(i.defaultValue))},V7t=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType,e.io==="input"&&(r._prefault=JSON.parse(JSON.stringify(i.defaultValue)))},Y7t=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType;let s;try{s=i.catchValue(void 0)}catch{throw new Error("Dynamic catch values are not supported in JSON Schema")}r.default=s},W7t=(t,e,r,n)=>{const i=t._zod.def,a=i.in._zod.traits.has("$ZodTransform"),s=e.io==="input"?a?i.out:i.in:i.out;il(s,e,n);const o=e.seen.get(t);o.ref=s},K7t=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType,r.readOnly=!0},$ke=(t,e,r,n)=>{const i=t._zod.def;il(i.innerType,e,n);const a=e.seen.get(t);a.ref=i.innerType};function _ce(t){return!!t._zod}function t_(t,e){return _ce(t)?yke(t,e):t.safeParse(e)}function Gke(t){if(!t)return;let e;if(_ce(t)?e=t._zod?.def?.shape:e=t.shape,!!e){if(typeof e=="function")try{return e()}catch{return}return e}}function zke(t){if(_ce(t)){const a=t._zod?.def;if(a){if(a.value!==void 0)return a.value;if(Array.isArray(a.values)&&a.values.length>0)return a.values[0]}}const r=t._def;if(r){if(r.value!==void 0)return r.value;if(Array.isArray(r.values)&&r.values.length>0)return r.values[0]}const n=t.value;if(n!==void 0)return n}const j7t=ur("ZodISODateTime",(t,e)=>{q9t.init(t,e),go.init(t,e)});function qke(t){return XRt(j7t,t)}const X7t=ur("ZodISODate",(t,e)=>{H9t.init(t,e),go.init(t,e)});function Q7t(t){return QRt(X7t,t)}const Z7t=ur("ZodISOTime",(t,e)=>{V9t.init(t,e),go.init(t,e)});function J7t(t){return ZRt(Z7t,t)}const e8t=ur("ZodISODuration",(t,e)=>{Y9t.init(t,e),go.init(t,e)});function t8t(t){return JRt(e8t,t)}const r8t=(t,e)=>{_ke.init(t,e),t.name="ZodError",Object.defineProperties(t,{format:{value:r=>L6t(t,r)},flatten:{value:r=>M6t(t,r)},addIssue:{value:r=>{t.issues.push(r),t.message=JSON.stringify(t.issues,ree,2)}},addIssues:{value:r=>{t.issues.push(...r),t.message=JSON.stringify(t.issues,ree,2)}},isEmpty:{get(){return t.issues.length===0}}})},Af=ur("ZodError",r8t,{Parent:Error}),n8t=pce(Af),i8t=gce(Af),a8t=ZU(Af),s8t=JU(Af),o8t=F6t(Af),l8t=B6t(Af),c8t=U6t(Af),u8t=$6t(Af),d8t=G6t(Af),h8t=z6t(Af),f8t=q6t(Af),p8t=H6t(Af),q2e=new WeakMap;function $8(t,e,r){const n=Object.getPrototypeOf(t);let i=q2e.get(n);if(i||(i=new Set,q2e.set(n,i)),!i.has(e)){i.add(e);for(const a in r){const s=r[a];Object.defineProperty(n,a,{configurable:!0,enumerable:!1,get(){const o=s.bind(this);return Object.defineProperty(this,a,{configurable:!0,writable:!0,enumerable:!0,value:o}),o},set(o){Object.defineProperty(this,a,{configurable:!0,writable:!0,enumerable:!0,value:o})}})}}}const Ds=ur("ZodType",(t,e)=>(ks.init(t,e),Object.assign(t["~standard"],{jsonSchema:{input:aP(t,"input"),output:aP(t,"output")}}),t.toJSONSchema=C7t(t,{}),t.def=e,t.type=e.type,Object.defineProperty(t,"_def",{value:e}),t.parse=(r,n)=>n8t(t,r,n,{callee:t.parse}),t.safeParse=(r,n)=>a8t(t,r,n),t.parseAsync=async(r,n)=>i8t(t,r,n,{callee:t.parseAsync}),t.safeParseAsync=async(r,n)=>s8t(t,r,n),t.spa=t.safeParseAsync,t.encode=(r,n)=>o8t(t,r,n),t.decode=(r,n)=>l8t(t,r,n),t.encodeAsync=async(r,n)=>c8t(t,r,n),t.decodeAsync=async(r,n)=>u8t(t,r,n),t.safeEncode=(r,n)=>d8t(t,r,n),t.safeDecode=(r,n)=>h8t(t,r,n),t.safeEncodeAsync=async(r,n)=>f8t(t,r,n),t.safeDecodeAsync=async(r,n)=>p8t(t,r,n),$8(t,"ZodType",{check(...r){const n=this.def;return this.clone(Av(n,{checks:[...n.checks??[],...r.map(i=>typeof i=="function"?{_zod:{check:i,def:{check:"custom"},onattach:[]}}:i)]}),{parent:!0})},with(...r){return this.check(...r)},clone(r,n){return Rv(this,r,n)},brand(){return this},register(r,n){return r.add(this,n),this},refine(r,n){return this.check(oNt(r,n))},superRefine(r,n){return this.check(lNt(r,n))},overwrite(r){return this.check(S4(r))},optional(){return so(this)},exactOptional(){return K8t(this)},nullable(){return W2e(this)},nullish(){return so(W2e(this))},nonoptional(r){return eNt(this,r)},array(){return sn(this)},or(r){return Ks([this,r])},and(r){return yce(this,r)},transform(r){return K2e(this,jke(r))},default(r){return Q8t(this,r)},prefault(r){return J8t(this,r)},catch(r){return rNt(this,r)},pipe(r){return K2e(this,r)},readonly(){return aNt(this)},describe(r){const n=this.clone();return F6.add(n,{description:r}),n},meta(...r){if(r.length===0)return F6.get(this);const n=this.clone();return F6.add(n,r[0]),n},isOptional(){return this.safeParse(void 0).success},isNullable(){return this.safeParse(null).success},apply(r){return r(this)}}),Object.defineProperty(t,"description",{get(){return F6.get(t)?.description},configurable:!0}),t)),Hke=ur("_ZodString",(t,e)=>{mce.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(n,i,a)=>x7t(t,n,i);const r=t._zod.bag;t.format=r.format??null,t.minLength=r.minimum??null,t.maxLength=r.maximum??null,$8(t,"_ZodString",{regex(...n){return this.check(l7t(...n))},includes(...n){return this.check(d7t(...n))},startsWith(...n){return this.check(h7t(...n))},endsWith(...n){return this.check(f7t(...n))},min(...n){return this.check(iP(...n))},max(...n){return this.check(Lke(...n))},length(...n){return this.check(Pke(...n))},nonempty(...n){return this.check(iP(1,...n))},lowercase(n){return this.check(c7t(n))},uppercase(n){return this.check(u7t(n))},trim(){return this.check(g7t())},normalize(...n){return this.check(p7t(...n))},toLowerCase(){return this.check(m7t())},toUpperCase(){return this.check(_7t())},slugify(){return this.check(v7t())}})}),g8t=ur("ZodString",(t,e)=>{mce.init(t,e),Hke.init(t,e),t.email=r=>t.check(ORt(m8t,r)),t.url=r=>t.check(Mke(Vke,r)),t.jwt=r=>t.check(jRt(k8t,r)),t.emoji=r=>t.check(LRt(v8t,r)),t.guid=r=>t.check(U2e(H2e,r)),t.uuid=r=>t.check(IRt(JO,r)),t.uuidv4=r=>t.check(kRt(JO,r)),t.uuidv6=r=>t.check(DRt(JO,r)),t.uuidv7=r=>t.check(MRt(JO,r)),t.nanoid=r=>t.check(PRt(y8t,r)),t.guid=r=>t.check(U2e(H2e,r)),t.cuid=r=>t.check(FRt(b8t,r)),t.cuid2=r=>t.check(BRt(S8t,r)),t.ulid=r=>t.check(URt(E8t,r)),t.base64=r=>t.check(YRt(N8t,r)),t.base64url=r=>t.check(WRt(O8t,r)),t.xid=r=>t.check($Rt(T8t,r)),t.ksuid=r=>t.check(GRt(C8t,r)),t.ipv4=r=>t.check(zRt(w8t,r)),t.ipv6=r=>t.check(qRt(x8t,r)),t.cidrv4=r=>t.check(HRt(A8t,r)),t.cidrv6=r=>t.check(VRt(R8t,r)),t.e164=r=>t.check(KRt(I8t,r)),t.datetime=r=>t.check(qke(r)),t.date=r=>t.check(Q7t(r)),t.time=r=>t.check(J7t(r)),t.duration=r=>t.check(t8t(r))});function xt(t){return NRt(g8t,t)}const go=ur("ZodStringFormat",(t,e)=>{Ws.init(t,e),Hke.init(t,e)}),m8t=ur("ZodEmail",(t,e)=>{M9t.init(t,e),go.init(t,e)}),H2e=ur("ZodGUID",(t,e)=>{k9t.init(t,e),go.init(t,e)}),JO=ur("ZodUUID",(t,e)=>{D9t.init(t,e),go.init(t,e)}),Vke=ur("ZodURL",(t,e)=>{L9t.init(t,e),go.init(t,e)});function _8t(t){return Mke(Vke,t)}const v8t=ur("ZodEmoji",(t,e)=>{P9t.init(t,e),go.init(t,e)}),y8t=ur("ZodNanoID",(t,e)=>{F9t.init(t,e),go.init(t,e)}),b8t=ur("ZodCUID",(t,e)=>{B9t.init(t,e),go.init(t,e)}),S8t=ur("ZodCUID2",(t,e)=>{U9t.init(t,e),go.init(t,e)}),E8t=ur("ZodULID",(t,e)=>{$9t.init(t,e),go.init(t,e)}),T8t=ur("ZodXID",(t,e)=>{G9t.init(t,e),go.init(t,e)}),C8t=ur("ZodKSUID",(t,e)=>{z9t.init(t,e),go.init(t,e)}),w8t=ur("ZodIPv4",(t,e)=>{W9t.init(t,e),go.init(t,e)}),x8t=ur("ZodIPv6",(t,e)=>{K9t.init(t,e),go.init(t,e)}),A8t=ur("ZodCIDRv4",(t,e)=>{j9t.init(t,e),go.init(t,e)}),R8t=ur("ZodCIDRv6",(t,e)=>{X9t.init(t,e),go.init(t,e)}),N8t=ur("ZodBase64",(t,e)=>{Q9t.init(t,e),go.init(t,e)}),O8t=ur("ZodBase64URL",(t,e)=>{J9t.init(t,e),go.init(t,e)}),I8t=ur("ZodE164",(t,e)=>{eRt.init(t,e),go.init(t,e)}),k8t=ur("ZodJWT",(t,e)=>{rRt.init(t,e),go.init(t,e)}),vce=ur("ZodNumber",(t,e)=>{Rke.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(n,i,a)=>A7t(t,n,i),$8(t,"ZodNumber",{gt(n,i){return this.check(G2e(n,i))},gte(n,i){return this.check(cK(n,i))},min(n,i){return this.check(cK(n,i))},lt(n,i){return this.check($2e(n,i))},lte(n,i){return this.check(lK(n,i))},max(n,i){return this.check(lK(n,i))},int(n){return this.check(V2e(n))},safe(n){return this.check(V2e(n))},positive(n){return this.check(G2e(0,n))},nonnegative(n){return this.check(cK(0,n))},negative(n){return this.check($2e(0,n))},nonpositive(n){return this.check(lK(0,n))},multipleOf(n,i){return this.check(z2e(n,i))},step(n,i){return this.check(z2e(n,i))},finite(){return this}});const r=t._zod.bag;t.minValue=Math.max(r.minimum??Number.NEGATIVE_INFINITY,r.exclusiveMinimum??Number.NEGATIVE_INFINITY)??null,t.maxValue=Math.min(r.maximum??Number.POSITIVE_INFINITY,r.exclusiveMaximum??Number.POSITIVE_INFINITY)??null,t.isInt=(r.format??"").includes("int")||Number.isSafeInteger(r.multipleOf??.5),t.isFinite=!0,t.format=r.format??null});function qa(t){return e7t(vce,t)}const D8t=ur("ZodNumberFormat",(t,e)=>{nRt.init(t,e),vce.init(t,e)});function V2e(t){return r7t(D8t,t)}const M8t=ur("ZodBoolean",(t,e)=>{iRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>R7t(t,r,n)});function xs(t){return n7t(M8t,t)}const L8t=ur("ZodNull",(t,e)=>{aRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>N7t(t,r,n)});function P8t(t){return i7t(L8t,t)}const F8t=ur("ZodAny",(t,e)=>{sRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>I7t()});function B8t(){return a7t(F8t)}const U8t=ur("ZodUnknown",(t,e)=>{oRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>k7t()});function lo(){return s7t(U8t)}const $8t=ur("ZodNever",(t,e)=>{lRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>O7t(t,r,n)});function G8t(t){return o7t($8t,t)}const z8t=ur("ZodArray",(t,e)=>{cRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>F7t(t,r,n,i),t.element=e.element,$8(t,"ZodArray",{min(r,n){return this.check(iP(r,n))},nonempty(r){return this.check(iP(1,r))},max(r,n){return this.check(Lke(r,n))},length(r,n){return this.check(Pke(r,n))},unwrap(){return this.element}})});function sn(t,e){return y7t(z8t,t,e)}const Yke=ur("ZodObject",(t,e)=>{dRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>B7t(t,r,n,i),es(t,"shape",()=>e.shape),$8(t,"ZodObject",{keyof(){return Th(Object.keys(this._zod.def.shape))},catchall(r){return this.clone({...this._zod.def,catchall:r})},passthrough(){return this.clone({...this._zod.def,catchall:lo()})},loose(){return this.clone({...this._zod.def,catchall:lo()})},strict(){return this.clone({...this._zod.def,catchall:G8t()})},strip(){return this.clone({...this._zod.def,catchall:void 0})},extend(r){return R6t(this,r)},safeExtend(r){return N6t(this,r)},merge(r){return O6t(this,r)},pick(r){return x6t(this,r)},omit(r){return A6t(this,r)},partial(...r){return I6t(Xke,this,r[0])},required(...r){return k6t(Qke,this,r[0])}})});function ln(t,e){const r={type:"object",shape:t??{},...Dn(e)};return new Yke(r)}function vc(t,e){return new Yke({type:"object",shape:t,catchall:lo(),...Dn(e)})}const Wke=ur("ZodUnion",(t,e)=>{Ike.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>U7t(t,r,n,i),t.options=e.options});function Ks(t,e){return new Wke({type:"union",options:t,...Dn(e)})}const q8t=ur("ZodDiscriminatedUnion",(t,e)=>{Wke.init(t,e),hRt.init(t,e)});function Kke(t,e,r){return new q8t({type:"union",options:e,discriminator:t,...Dn(r)})}const H8t=ur("ZodIntersection",(t,e)=>{fRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>$7t(t,r,n,i)});function yce(t,e){return new H8t({type:"intersection",left:t,right:e})}const Y2e=ur("ZodRecord",(t,e)=>{pRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>G7t(t,r,n,i),t.keyType=e.keyType,t.valueType=e.valueType});function Ns(t,e,r){return!e||!e._zod?new Y2e({type:"record",keyType:xt(),valueType:t,...Dn(e)}):new Y2e({type:"record",keyType:t,valueType:e,...Dn(r)})}const iee=ur("ZodEnum",(t,e)=>{gRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(n,i,a)=>D7t(t,n,i),t.enum=e.entries,t.options=Object.values(e.entries);const r=new Set(Object.keys(e.entries));t.extract=(n,i)=>{const a={};for(const s of n)if(r.has(s))a[s]=e.entries[s];else throw new Error(`Key ${s} not found in enum`);return new iee({...e,checks:[],...Dn(i),entries:a})},t.exclude=(n,i)=>{const a={...e.entries};for(const s of n)if(r.has(s))delete a[s];else throw new Error(`Key ${s} not found in enum`);return new iee({...e,checks:[],...Dn(i),entries:a})}});function Th(t,e){const r=Array.isArray(t)?Object.fromEntries(t.map(n=>[n,n])):t;return new iee({type:"enum",entries:r,...Dn(e)})}const V8t=ur("ZodLiteral",(t,e)=>{mRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>M7t(t,r,n),t.values=new Set(e.values),Object.defineProperty(t,"value",{get(){if(e.values.length>1)throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");return e.values[0]}})});function qn(t,e){return new V8t({type:"literal",values:Array.isArray(t)?t:[t],...Dn(e)})}const Y8t=ur("ZodTransform",(t,e)=>{_Rt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>P7t(t,r),t._zod.parse=(r,n)=>{if(n.direction==="backward")throw new hke(t.constructor.name);r.addIssue=a=>{if(typeof a=="string")r.issues.push(WR(a,r.value,e));else{const s=a;s.fatal&&(s.continue=!1),s.code??(s.code="custom"),s.input??(s.input=r.value),s.inst??(s.inst=t),r.issues.push(WR(s))}};const i=e.transform(r.value,r);return i instanceof Promise?i.then(a=>(r.value=a,r.fallback=!0,r)):(r.value=i,r.fallback=!0,r)}});function jke(t){return new Y8t({type:"transform",transform:t})}const Xke=ur("ZodOptional",(t,e)=>{kke.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>$ke(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function so(t){return new Xke({type:"optional",innerType:t})}const W8t=ur("ZodExactOptional",(t,e)=>{vRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>$ke(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function K8t(t){return new W8t({type:"optional",innerType:t})}const j8t=ur("ZodNullable",(t,e)=>{yRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>z7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function W2e(t){return new j8t({type:"nullable",innerType:t})}const X8t=ur("ZodDefault",(t,e)=>{bRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>H7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType,t.removeDefault=t.unwrap});function Q8t(t,e){return new X8t({type:"default",innerType:t,get defaultValue(){return typeof e=="function"?e():gke(e)}})}const Z8t=ur("ZodPrefault",(t,e)=>{SRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>V7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function J8t(t,e){return new Z8t({type:"prefault",innerType:t,get defaultValue(){return typeof e=="function"?e():gke(e)}})}const Qke=ur("ZodNonOptional",(t,e)=>{ERt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>q7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function eNt(t,e){return new Qke({type:"nonoptional",innerType:t,...Dn(e)})}const tNt=ur("ZodCatch",(t,e)=>{TRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>Y7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType,t.removeCatch=t.unwrap});function rNt(t,e){return new tNt({type:"catch",innerType:t,catchValue:typeof e=="function"?e:()=>e})}const Zke=ur("ZodPipe",(t,e)=>{Dke.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>W7t(t,r,n,i),t.in=e.in,t.out=e.out});function K2e(t,e){return new Zke({type:"pipe",in:t,out:e})}const nNt=ur("ZodPreprocess",(t,e)=>{Zke.init(t,e),CRt.init(t,e)}),iNt=ur("ZodReadonly",(t,e)=>{wRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>K7t(t,r,n,i),t.unwrap=()=>t._zod.def.innerType});function aNt(t){return new iNt({type:"readonly",innerType:t})}const Jke=ur("ZodCustom",(t,e)=>{xRt.init(t,e),Ds.init(t,e),t._zod.processJSONSchema=(r,n,i)=>L7t(t,r)});function sNt(t,e){return b7t(Jke,t??(()=>!0),e)}function oNt(t,e={}){return S7t(Jke,t,e)}function lNt(t,e){return E7t(t,e)}function eDe(t,e){return new nNt({type:"pipe",in:jke(t),out:e})}const cNt={custom:"custom"};function uNt(t){return t7t(vce,t)}const t$="2025-11-25",dNt=[t$,"2025-06-18","2025-03-26","2024-11-05","2024-10-07"],Dy="io.modelcontextprotocol/related-task",r$="2.0",xl=sNt(t=>t!==null&&(typeof t=="object"||typeof t=="function")),tDe=Ks([xt(),qa().int()]),rDe=xt();vc({ttl:qa().optional(),pollInterval:qa().optional()});const hNt=ln({ttl:qa().optional()}),fNt=ln({taskId:xt()}),bce=vc({progressToken:tDe.optional(),[Dy]:fNt.optional()}),Ch=ln({_meta:bce.optional()}),G8=Ch.extend({task:hNt.optional()}),pNt=t=>G8.safeParse(t).success,Rc=ln({method:xt(),params:Ch.loose().optional()}),Rf=ln({_meta:bce.optional()}),Nf=ln({method:xt(),params:Rf.loose().optional()}),Nc=vc({_meta:bce.optional()}),n$=Ks([xt(),qa().int()]),nDe=ln({jsonrpc:qn(r$),id:n$,...Rc.shape}).strict(),aee=t=>nDe.safeParse(t).success,iDe=ln({jsonrpc:qn(r$),...Nf.shape}).strict(),gNt=t=>iDe.safeParse(t).success,Sce=ln({jsonrpc:qn(r$),id:n$,result:Nc}).strict(),B6=t=>Sce.safeParse(t).success;var Oi;(function(t){t[t.ConnectionClosed=-32e3]="ConnectionClosed",t[t.RequestTimeout=-32001]="RequestTimeout",t[t.ParseError=-32700]="ParseError",t[t.InvalidRequest=-32600]="InvalidRequest",t[t.MethodNotFound=-32601]="MethodNotFound",t[t.InvalidParams=-32602]="InvalidParams",t[t.InternalError=-32603]="InternalError",t[t.UrlElicitationRequired=-32042]="UrlElicitationRequired"})(Oi||(Oi={}));const Ece=ln({jsonrpc:qn(r$),id:n$.optional(),error:ln({code:qa().int(),message:xt(),data:lo().optional()})}).strict(),mNt=t=>Ece.safeParse(t).success,F9=Ks([nDe,iDe,Sce,Ece]);Ks([Sce,Ece]);const hT=Nc.strict(),_Nt=Rf.extend({requestId:n$.optional(),reason:xt().optional()}),Tce=Nf.extend({method:qn("notifications/cancelled"),params:_Nt}),vNt=ln({src:xt(),mimeType:xt().optional(),sizes:sn(xt()).optional(),theme:Th(["light","dark"]).optional()}),z8=ln({icons:sn(vNt).optional()}),dx=ln({name:xt(),title:xt().optional()}),aDe=dx.extend({...dx.shape,...z8.shape,version:xt(),websiteUrl:xt().optional(),description:xt().optional()}),yNt=yce(ln({applyDefaults:xs().optional()}),Ns(xt(),lo())),bNt=eDe(t=>t&&typeof t=="object"&&!Array.isArray(t)&&Object.keys(t).length===0?{form:{}}:t,yce(ln({form:yNt.optional(),url:xl.optional()}),Ns(xt(),lo()).optional())),SNt=vc({list:xl.optional(),cancel:xl.optional(),requests:vc({sampling:vc({createMessage:xl.optional()}).optional(),elicitation:vc({create:xl.optional()}).optional()}).optional()}),ENt=vc({list:xl.optional(),cancel:xl.optional(),requests:vc({tools:vc({call:xl.optional()}).optional()}).optional()}),TNt=ln({experimental:Ns(xt(),xl).optional(),sampling:ln({context:xl.optional(),tools:xl.optional()}).optional(),elicitation:bNt.optional(),roots:ln({listChanged:xs().optional()}).optional(),tasks:SNt.optional(),extensions:Ns(xt(),xl).optional()}),CNt=Ch.extend({protocolVersion:xt(),capabilities:TNt,clientInfo:aDe}),wNt=Rc.extend({method:qn("initialize"),params:CNt}),xNt=ln({experimental:Ns(xt(),xl).optional(),logging:xl.optional(),completions:xl.optional(),prompts:ln({listChanged:xs().optional()}).optional(),resources:ln({subscribe:xs().optional(),listChanged:xs().optional()}).optional(),tools:ln({listChanged:xs().optional()}).optional(),tasks:ENt.optional(),extensions:Ns(xt(),xl).optional()}),sDe=Nc.extend({protocolVersion:xt(),capabilities:xNt,serverInfo:aDe,instructions:xt().optional()}),oDe=Nf.extend({method:qn("notifications/initialized"),params:Rf.optional()}),ANt=t=>oDe.safeParse(t).success,Cce=Rc.extend({method:qn("ping"),params:Ch.optional()}),RNt=ln({progress:qa(),total:so(qa()),message:so(xt())}),NNt=ln({...Rf.shape,...RNt.shape,progressToken:tDe}),wce=Nf.extend({method:qn("notifications/progress"),params:NNt}),ONt=Ch.extend({cursor:rDe.optional()}),q8=Rc.extend({params:ONt.optional()}),H8=Nc.extend({nextCursor:rDe.optional()}),INt=Th(["working","input_required","completed","failed","cancelled"]),V8=ln({taskId:xt(),status:INt,ttl:Ks([qa(),P8t()]),createdAt:xt(),lastUpdatedAt:xt(),pollInterval:so(qa()),statusMessage:so(xt())}),KR=Nc.extend({task:V8}),kNt=Rf.merge(V8),sP=Nf.extend({method:qn("notifications/tasks/status"),params:kNt}),xce=Rc.extend({method:qn("tasks/get"),params:Ch.extend({taskId:xt()})}),Ace=Nc.merge(V8),Rce=Rc.extend({method:qn("tasks/result"),params:Ch.extend({taskId:xt()})});Nc.loose();const Nce=q8.extend({method:qn("tasks/list")}),Oce=H8.extend({tasks:sn(V8)}),Ice=Rc.extend({method:qn("tasks/cancel"),params:Ch.extend({taskId:xt()})}),DNt=Nc.merge(V8),lDe=ln({uri:xt(),mimeType:so(xt()),_meta:Ns(xt(),lo()).optional()}),cDe=lDe.extend({text:xt()}),kce=xt().refine(t=>{try{return atob(t),!0}catch{return!1}},{message:"Invalid Base64 string"}),uDe=lDe.extend({blob:kce}),Y8=Th(["user","assistant"]),E4=ln({audience:sn(Y8).optional(),priority:qa().min(0).max(1).optional(),lastModified:qke({offset:!0}).optional()}),dDe=ln({...dx.shape,...z8.shape,uri:xt(),description:so(xt()),mimeType:so(xt()),size:so(qa()),annotations:E4.optional(),_meta:so(vc({}))}),MNt=ln({...dx.shape,...z8.shape,uriTemplate:xt(),description:so(xt()),mimeType:so(xt()),annotations:E4.optional(),_meta:so(vc({}))}),LNt=q8.extend({method:qn("resources/list")}),hDe=H8.extend({resources:sn(dDe)}),PNt=q8.extend({method:qn("resources/templates/list")}),fDe=H8.extend({resourceTemplates:sn(MNt)}),Dce=Ch.extend({uri:xt()}),FNt=Dce,BNt=Rc.extend({method:qn("resources/read"),params:FNt}),pDe=Nc.extend({contents:sn(Ks([cDe,uDe]))}),gDe=Nf.extend({method:qn("notifications/resources/list_changed"),params:Rf.optional()}),UNt=Dce,$Nt=Rc.extend({method:qn("resources/subscribe"),params:UNt}),GNt=Dce,zNt=Rc.extend({method:qn("resources/unsubscribe"),params:GNt}),qNt=Rf.extend({uri:xt()}),HNt=Nf.extend({method:qn("notifications/resources/updated"),params:qNt}),VNt=ln({name:xt(),description:so(xt()),required:so(xs())}),YNt=ln({...dx.shape,...z8.shape,description:so(xt()),arguments:so(sn(VNt)),_meta:so(vc({}))}),WNt=q8.extend({method:qn("prompts/list")}),mDe=H8.extend({prompts:sn(YNt)}),KNt=Ch.extend({name:xt(),arguments:Ns(xt(),xt()).optional()}),jNt=Rc.extend({method:qn("prompts/get"),params:KNt}),Mce=ln({type:qn("text"),text:xt(),annotations:E4.optional(),_meta:Ns(xt(),lo()).optional()}),Lce=ln({type:qn("image"),data:kce,mimeType:xt(),annotations:E4.optional(),_meta:Ns(xt(),lo()).optional()}),Pce=ln({type:qn("audio"),data:kce,mimeType:xt(),annotations:E4.optional(),_meta:Ns(xt(),lo()).optional()}),XNt=ln({type:qn("tool_use"),name:xt(),id:xt(),input:Ns(xt(),lo()),_meta:Ns(xt(),lo()).optional()}),QNt=ln({type:qn("resource"),resource:Ks([cDe,uDe]),annotations:E4.optional(),_meta:Ns(xt(),lo()).optional()}),ZNt=dDe.extend({type:qn("resource_link")}),Fce=Ks([Mce,Lce,Pce,ZNt,QNt]),JNt=ln({role:Y8,content:Fce}),_De=Nc.extend({description:xt().optional(),messages:sn(JNt)}),vDe=Nf.extend({method:qn("notifications/prompts/list_changed"),params:Rf.optional()}),eOt=ln({title:xt().optional(),readOnlyHint:xs().optional(),destructiveHint:xs().optional(),idempotentHint:xs().optional(),openWorldHint:xs().optional()}),tOt=ln({taskSupport:Th(["required","optional","forbidden"]).optional()}),yDe=ln({...dx.shape,...z8.shape,description:xt().optional(),inputSchema:ln({type:qn("object"),properties:Ns(xt(),xl).optional(),required:sn(xt()).optional()}).catchall(lo()),outputSchema:ln({type:qn("object"),properties:Ns(xt(),xl).optional(),required:sn(xt()).optional()}).catchall(lo()).optional(),annotations:eOt.optional(),execution:tOt.optional(),_meta:Ns(xt(),lo()).optional()}),rOt=q8.extend({method:qn("tools/list")}),bDe=H8.extend({tools:sn(yDe)}),i$=Nc.extend({content:sn(Fce).default([]),structuredContent:Ns(xt(),lo()).optional(),isError:xs().optional()});i$.or(Nc.extend({toolResult:lo()}));const nOt=G8.extend({name:xt(),arguments:Ns(xt(),lo()).optional()}),iOt=Rc.extend({method:qn("tools/call"),params:nOt}),SDe=Nf.extend({method:qn("notifications/tools/list_changed"),params:Rf.optional()}),aOt=ln({autoRefresh:xs().default(!0),debounceMs:qa().int().nonnegative().default(300)}),EDe=Th(["debug","info","notice","warning","error","critical","alert","emergency"]),sOt=Ch.extend({level:EDe}),oOt=Rc.extend({method:qn("logging/setLevel"),params:sOt}),lOt=Rf.extend({level:EDe,logger:xt().optional(),data:lo()}),cOt=Nf.extend({method:qn("notifications/message"),params:lOt}),uOt=ln({name:xt().optional()}),dOt=ln({hints:sn(uOt).optional(),costPriority:qa().min(0).max(1).optional(),speedPriority:qa().min(0).max(1).optional(),intelligencePriority:qa().min(0).max(1).optional()}),hOt=ln({mode:Th(["auto","required","none"]).optional()}),fOt=ln({type:qn("tool_result"),toolUseId:xt().describe("The unique identifier for the corresponding tool call."),content:sn(Fce).default([]),structuredContent:ln({}).loose().optional(),isError:xs().optional(),_meta:Ns(xt(),lo()).optional()}),pOt=Kke("type",[Mce,Lce,Pce]),oP=Kke("type",[Mce,Lce,Pce,XNt,fOt]),gOt=ln({role:Y8,content:Ks([oP,sn(oP)]),_meta:Ns(xt(),lo()).optional()}),mOt=G8.extend({messages:sn(gOt),modelPreferences:dOt.optional(),systemPrompt:xt().optional(),includeContext:Th(["none","thisServer","allServers"]).optional(),temperature:qa().optional(),maxTokens:qa().int(),stopSequences:sn(xt()).optional(),metadata:xl.optional(),tools:sn(yDe).optional(),toolChoice:hOt.optional()}),TDe=Rc.extend({method:qn("sampling/createMessage"),params:mOt}),CDe=Nc.extend({model:xt(),stopReason:so(Th(["endTurn","stopSequence","maxTokens"]).or(xt())),role:Y8,content:pOt}),wDe=Nc.extend({model:xt(),stopReason:so(Th(["endTurn","stopSequence","maxTokens","toolUse"]).or(xt())),role:Y8,content:Ks([oP,sn(oP)])}),_Ot=ln({type:qn("boolean"),title:xt().optional(),description:xt().optional(),default:xs().optional()}),vOt=ln({type:qn("string"),title:xt().optional(),description:xt().optional(),minLength:qa().optional(),maxLength:qa().optional(),format:Th(["email","uri","date","date-time"]).optional(),default:xt().optional()}),yOt=ln({type:Th(["number","integer"]),title:xt().optional(),description:xt().optional(),minimum:qa().optional(),maximum:qa().optional(),default:qa().optional()}),bOt=ln({type:qn("string"),title:xt().optional(),description:xt().optional(),enum:sn(xt()),default:xt().optional()}),SOt=ln({type:qn("string"),title:xt().optional(),description:xt().optional(),oneOf:sn(ln({const:xt(),title:xt()})),default:xt().optional()}),EOt=ln({type:qn("string"),title:xt().optional(),description:xt().optional(),enum:sn(xt()),enumNames:sn(xt()).optional(),default:xt().optional()}),TOt=Ks([bOt,SOt]),COt=ln({type:qn("array"),title:xt().optional(),description:xt().optional(),minItems:qa().optional(),maxItems:qa().optional(),items:ln({type:qn("string"),enum:sn(xt())}),default:sn(xt()).optional()}),wOt=ln({type:qn("array"),title:xt().optional(),description:xt().optional(),minItems:qa().optional(),maxItems:qa().optional(),items:ln({anyOf:sn(ln({const:xt(),title:xt()}))}),default:sn(xt()).optional()}),xOt=Ks([COt,wOt]),AOt=Ks([EOt,TOt,xOt]),ROt=Ks([AOt,_Ot,vOt,yOt]),NOt=G8.extend({mode:qn("form").optional(),message:xt(),requestedSchema:ln({type:qn("object"),properties:Ns(xt(),ROt),required:sn(xt()).optional()})}),OOt=G8.extend({mode:qn("url"),message:xt(),elicitationId:xt(),url:xt().url()}),IOt=Ks([NOt,OOt]),xDe=Rc.extend({method:qn("elicitation/create"),params:IOt}),kOt=Rf.extend({elicitationId:xt()}),DOt=Nf.extend({method:qn("notifications/elicitation/complete"),params:kOt}),ADe=Nc.extend({action:Th(["accept","decline","cancel"]),content:eDe(t=>t===null?void 0:t,Ns(xt(),Ks([xt(),qa(),xs(),sn(xt())])).optional())}),MOt=ln({type:qn("ref/resource"),uri:xt()}),LOt=ln({type:qn("ref/prompt"),name:xt()}),POt=Ch.extend({ref:Ks([LOt,MOt]),argument:ln({name:xt(),value:xt()}),context:ln({arguments:Ns(xt(),xt()).optional()}).optional()}),FOt=Rc.extend({method:qn("completion/complete"),params:POt}),RDe=Nc.extend({completion:vc({values:sn(xt()).max(100),total:so(qa().int()),hasMore:so(xs())})}),BOt=ln({uri:xt().startsWith("file://"),name:xt().optional(),_meta:Ns(xt(),lo()).optional()}),UOt=Rc.extend({method:qn("roots/list"),params:Ch.optional()}),$Ot=Nc.extend({roots:sn(BOt)}),GOt=Nf.extend({method:qn("notifications/roots/list_changed"),params:Rf.optional()});Ks([Cce,wNt,FOt,oOt,jNt,WNt,LNt,PNt,BNt,$Nt,zNt,iOt,rOt,xce,Rce,Nce,Ice]);Ks([Tce,wce,oDe,GOt,sP]);Ks([hT,CDe,wDe,ADe,$Ot,Ace,Oce,KR]);Ks([Cce,TDe,xDe,UOt,xce,Rce,Nce,Ice]);Ks([Tce,wce,cOt,HNt,gDe,SDe,vDe,sP,DOt]);Ks([hT,sDe,RDe,_De,mDe,hDe,fDe,pDe,i$,bDe,Ace,Oce,KR]);class ci extends Error{constructor(e,r,n){super(`MCP error ${e}: ${r}`),this.code=e,this.data=n,this.name="McpError"}static fromError(e,r,n){if(e===Oi.UrlElicitationRequired&&n){const i=n;if(i.elicitations)return new zOt(i.elicitations,r)}return new ci(e,r,n)}}class zOt extends ci{constructor(e,r=`URL elicitation${e.length>1?"s":""} required`){super(Oi.UrlElicitationRequired,r,{elicitations:e})}get elicitations(){return this.data?.elicitations??[]}}function iy(t){return t==="completed"||t==="failed"||t==="cancelled"}new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");function j2e(t){const r=Gke(t)?.method;if(!r)throw new Error("Schema is missing a method literal");const n=zke(r);if(typeof n!="string")throw new Error("Schema method literal must be a string");return n}function X2e(t,e){const r=t_(t,e);if(!r.success)throw r.error;return r.data}const qOt=6e4;class HOt{constructor(e){this._options=e,this._requestMessageId=0,this._requestHandlers=new Map,this._requestHandlerAbortControllers=new Map,this._notificationHandlers=new Map,this._responseHandlers=new Map,this._progressHandlers=new Map,this._timeoutInfo=new Map,this._pendingDebouncedNotifications=new Set,this._taskProgressTokens=new Map,this._requestResolvers=new Map,this.setNotificationHandler(Tce,r=>{this._oncancel(r)}),this.setNotificationHandler(wce,r=>{this._onprogress(r)}),this.setRequestHandler(Cce,r=>({})),this._taskStore=e?.taskStore,this._taskMessageQueue=e?.taskMessageQueue,this._taskStore&&(this.setRequestHandler(xce,async(r,n)=>{const i=await this._taskStore.getTask(r.params.taskId,n.sessionId);if(!i)throw new ci(Oi.InvalidParams,"Failed to retrieve task: Task not found");return{...i}}),this.setRequestHandler(Rce,async(r,n)=>{const i=async()=>{const a=r.params.taskId;if(this._taskMessageQueue){let o;for(;o=await this._taskMessageQueue.dequeue(a,n.sessionId);){if(o.type==="response"||o.type==="error"){const l=o.message,u=l.id,d=this._requestResolvers.get(u);if(d)if(this._requestResolvers.delete(u),o.type==="response")d(l);else{const h=l,f=new ci(h.error.code,h.error.message,h.error.data);d(f)}else{const h=o.type==="response"?"Response":"Error";this._onerror(new Error(`${h} handler missing for request ${u}`))}continue}await this._transport?.send(o.message,{relatedRequestId:n.requestId})}}const s=await this._taskStore.getTask(a,n.sessionId);if(!s)throw new ci(Oi.InvalidParams,`Task not found: ${a}`);if(!iy(s.status))return await this._waitForTaskUpdate(a,n.signal),await i();if(iy(s.status)){const o=await this._taskStore.getTaskResult(a,n.sessionId);return this._clearTaskQueue(a),{...o,_meta:{...o._meta,[Dy]:{taskId:a}}}}return await i()};return await i()}),this.setRequestHandler(Nce,async(r,n)=>{try{const{tasks:i,nextCursor:a}=await this._taskStore.listTasks(r.params?.cursor,n.sessionId);return{tasks:i,nextCursor:a,_meta:{}}}catch(i){throw new ci(Oi.InvalidParams,`Failed to list tasks: ${i instanceof Error?i.message:String(i)}`)}}),this.setRequestHandler(Ice,async(r,n)=>{try{const i=await this._taskStore.getTask(r.params.taskId,n.sessionId);if(!i)throw new ci(Oi.InvalidParams,`Task not found: ${r.params.taskId}`);if(iy(i.status))throw new ci(Oi.InvalidParams,`Cannot cancel task in terminal status: ${i.status}`);await this._taskStore.updateTaskStatus(r.params.taskId,"cancelled","Client cancelled task execution.",n.sessionId),this._clearTaskQueue(r.params.taskId);const a=await this._taskStore.getTask(r.params.taskId,n.sessionId);if(!a)throw new ci(Oi.InvalidParams,`Task not found after cancellation: ${r.params.taskId}`);return{_meta:{},...a}}catch(i){throw i instanceof ci?i:new ci(Oi.InvalidRequest,`Failed to cancel task: ${i instanceof Error?i.message:String(i)}`)}}))}async _oncancel(e){if(!e.params.requestId)return;this._requestHandlerAbortControllers.get(e.params.requestId)?.abort(e.params.reason)}_setupTimeout(e,r,n,i,a=!1){this._timeoutInfo.set(e,{timeoutId:setTimeout(i,r),startTime:Date.now(),timeout:r,maxTotalTimeout:n,resetTimeoutOnProgress:a,onTimeout:i})}_resetTimeout(e){const r=this._timeoutInfo.get(e);if(!r)return!1;const n=Date.now()-r.startTime;if(r.maxTotalTimeout&&n>=r.maxTotalTimeout)throw this._timeoutInfo.delete(e),ci.fromError(Oi.RequestTimeout,"Maximum total timeout exceeded",{maxTotalTimeout:r.maxTotalTimeout,totalElapsed:n});return clearTimeout(r.timeoutId),r.timeoutId=setTimeout(r.onTimeout,r.timeout),!0}_cleanupTimeout(e){const r=this._timeoutInfo.get(e);r&&(clearTimeout(r.timeoutId),this._timeoutInfo.delete(e))}async connect(e){if(this._transport)throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");this._transport=e;const r=this.transport?.onclose;this._transport.onclose=()=>{r?.(),this._onclose()};const n=this.transport?.onerror;this._transport.onerror=a=>{n?.(a),this._onerror(a)};const i=this._transport?.onmessage;this._transport.onmessage=(a,s)=>{i?.(a,s),B6(a)||mNt(a)?this._onresponse(a):aee(a)?this._onrequest(a,s):gNt(a)?this._onnotification(a):this._onerror(new Error(`Unknown message type: ${JSON.stringify(a)}`))},await this._transport.start()}_onclose(){const e=this._responseHandlers;this._responseHandlers=new Map,this._progressHandlers.clear(),this._taskProgressTokens.clear(),this._pendingDebouncedNotifications.clear();for(const n of this._timeoutInfo.values())clearTimeout(n.timeoutId);this._timeoutInfo.clear();for(const n of this._requestHandlerAbortControllers.values())n.abort();this._requestHandlerAbortControllers.clear();const r=ci.fromError(Oi.ConnectionClosed,"Connection closed");this._transport=void 0,this.onclose?.();for(const n of e.values())n(r)}_onerror(e){this.onerror?.(e)}_onnotification(e){const r=this._notificationHandlers.get(e.method)??this.fallbackNotificationHandler;r!==void 0&&Promise.resolve().then(()=>r(e)).catch(n=>this._onerror(new Error(`Uncaught error in notification handler: ${n}`)))}_onrequest(e,r){const n=this._requestHandlers.get(e.method)??this.fallbackRequestHandler,i=this._transport,a=e.params?._meta?.[Dy]?.taskId;if(n===void 0){const d={jsonrpc:"2.0",id:e.id,error:{code:Oi.MethodNotFound,message:"Method not found"}};a&&this._taskMessageQueue?this._enqueueTaskMessage(a,{type:"error",message:d,timestamp:Date.now()},i?.sessionId).catch(h=>this._onerror(new Error(`Failed to enqueue error response: ${h}`))):i?.send(d).catch(h=>this._onerror(new Error(`Failed to send an error response: ${h}`)));return}const s=new AbortController;this._requestHandlerAbortControllers.set(e.id,s);const o=pNt(e.params)?e.params.task:void 0,l=this._taskStore?this.requestTaskStore(e,i?.sessionId):void 0,u={signal:s.signal,sessionId:i?.sessionId,_meta:e.params?._meta,sendNotification:async d=>{if(s.signal.aborted)return;const h={relatedRequestId:e.id};a&&(h.relatedTask={taskId:a}),await this.notification(d,h)},sendRequest:async(d,h,f)=>{if(s.signal.aborted)throw new ci(Oi.ConnectionClosed,"Request was cancelled");const p={...f,relatedRequestId:e.id};a&&!p.relatedTask&&(p.relatedTask={taskId:a});const g=p.relatedTask?.taskId??a;return g&&l&&await l.updateTaskStatus(g,"input_required"),await this.request(d,h,p)},authInfo:r?.authInfo,requestId:e.id,requestInfo:r?.requestInfo,taskId:a,taskStore:l,taskRequestedTtl:o?.ttl,closeSSEStream:r?.closeSSEStream,closeStandaloneSSEStream:r?.closeStandaloneSSEStream};Promise.resolve().then(()=>{o&&this.assertTaskHandlerCapability(e.method)}).then(()=>n(e,u)).then(async d=>{if(s.signal.aborted)return;const h={result:d,jsonrpc:"2.0",id:e.id};a&&this._taskMessageQueue?await this._enqueueTaskMessage(a,{type:"response",message:h,timestamp:Date.now()},i?.sessionId):await i?.send(h)},async d=>{if(s.signal.aborted)return;const h={jsonrpc:"2.0",id:e.id,error:{code:Number.isSafeInteger(d.code)?d.code:Oi.InternalError,message:d.message??"Internal error",...d.data!==void 0&&{data:d.data}}};a&&this._taskMessageQueue?await this._enqueueTaskMessage(a,{type:"error",message:h,timestamp:Date.now()},i?.sessionId):await i?.send(h)}).catch(d=>this._onerror(new Error(`Failed to send response: ${d}`))).finally(()=>{this._requestHandlerAbortControllers.get(e.id)===s&&this._requestHandlerAbortControllers.delete(e.id)})}_onprogress(e){const{progressToken:r,...n}=e.params,i=Number(r),a=this._progressHandlers.get(i);if(!a){this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(e)}`));return}const s=this._responseHandlers.get(i),o=this._timeoutInfo.get(i);if(o&&s&&o.resetTimeoutOnProgress)try{this._resetTimeout(i)}catch(l){this._responseHandlers.delete(i),this._progressHandlers.delete(i),this._cleanupTimeout(i),s(l);return}a(n)}_onresponse(e){const r=Number(e.id),n=this._requestResolvers.get(r);if(n){if(this._requestResolvers.delete(r),B6(e))n(e);else{const s=new ci(e.error.code,e.error.message,e.error.data);n(s)}return}const i=this._responseHandlers.get(r);if(i===void 0){this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(e)}`));return}this._responseHandlers.delete(r),this._cleanupTimeout(r);let a=!1;if(B6(e)&&e.result&&typeof e.result=="object"){const s=e.result;if(s.task&&typeof s.task=="object"){const o=s.task;typeof o.taskId=="string"&&(a=!0,this._taskProgressTokens.set(o.taskId,r))}}if(a||this._progressHandlers.delete(r),B6(e))i(e);else{const s=ci.fromError(e.error.code,e.error.message,e.error.data);i(s)}}get transport(){return this._transport}async close(){await this._transport?.close()}async*requestStream(e,r,n){const{task:i}=n??{};if(!i){try{yield{type:"result",result:await this.request(e,r,n)}}catch(s){yield{type:"error",error:s instanceof ci?s:new ci(Oi.InternalError,String(s))}}return}let a;try{const s=await this.request(e,KR,n);if(s.task)a=s.task.taskId,yield{type:"taskCreated",task:s.task};else throw new ci(Oi.InternalError,"Task creation did not return a task");for(;;){const o=await this.getTask({taskId:a},n);if(yield{type:"taskStatus",task:o},iy(o.status)){o.status==="completed"?yield{type:"result",result:await this.getTaskResult({taskId:a},r,n)}:o.status==="failed"?yield{type:"error",error:new ci(Oi.InternalError,`Task ${a} failed`)}:o.status==="cancelled"&&(yield{type:"error",error:new ci(Oi.InternalError,`Task ${a} was cancelled`)});return}if(o.status==="input_required"){yield{type:"result",result:await this.getTaskResult({taskId:a},r,n)};return}const l=o.pollInterval??this._options?.defaultTaskPollInterval??1e3;await new Promise(u=>setTimeout(u,l)),n?.signal?.throwIfAborted()}}catch(s){yield{type:"error",error:s instanceof ci?s:new ci(Oi.InternalError,String(s))}}}request(e,r,n){const{relatedRequestId:i,resumptionToken:a,onresumptiontoken:s,task:o,relatedTask:l}=n??{};return new Promise((u,d)=>{const h=b=>{d(b)};if(!this._transport){h(new Error("Not connected"));return}if(this._options?.enforceStrictCapabilities===!0)try{this.assertCapabilityForMethod(e.method),o&&this.assertTaskCapability(e.method)}catch(b){h(b);return}n?.signal?.throwIfAborted();const f=this._requestMessageId++,p={...e,jsonrpc:"2.0",id:f};n?.onprogress&&(this._progressHandlers.set(f,n.onprogress),p.params={...e.params,_meta:{...e.params?._meta||{},progressToken:f}}),o&&(p.params={...p.params,task:o}),l&&(p.params={...p.params,_meta:{...p.params?._meta||{},[Dy]:l}});const g=b=>{this._responseHandlers.delete(f),this._progressHandlers.delete(f),this._cleanupTimeout(f),this._transport?.send({jsonrpc:"2.0",method:"notifications/cancelled",params:{requestId:f,reason:String(b)}},{relatedRequestId:i,resumptionToken:a,onresumptiontoken:s}).catch(E=>this._onerror(new Error(`Failed to send cancellation: ${E}`)));const y=b instanceof ci?b:new ci(Oi.RequestTimeout,String(b));d(y)};this._responseHandlers.set(f,b=>{if(!n?.signal?.aborted){if(b instanceof Error)return d(b);try{const y=t_(r,b.result);y.success?u(y.data):d(y.error)}catch(y){d(y)}}}),n?.signal?.addEventListener("abort",()=>{g(n?.signal?.reason)});const m=n?.timeout??qOt,_=()=>g(ci.fromError(Oi.RequestTimeout,"Request timed out",{timeout:m}));this._setupTimeout(f,m,n?.maxTotalTimeout,_,n?.resetTimeoutOnProgress??!1);const v=l?.taskId;if(v){const b=y=>{const E=this._responseHandlers.get(f);E?E(y):this._onerror(new Error(`Response handler missing for side-channeled request ${f}`))};this._requestResolvers.set(f,b),this._enqueueTaskMessage(v,{type:"request",message:p,timestamp:Date.now()}).catch(y=>{this._cleanupTimeout(f),d(y)})}else this._transport.send(p,{relatedRequestId:i,resumptionToken:a,onresumptiontoken:s}).catch(b=>{this._cleanupTimeout(f),d(b)})})}async getTask(e,r){return this.request({method:"tasks/get",params:e},Ace,r)}async getTaskResult(e,r,n){return this.request({method:"tasks/result",params:e},r,n)}async listTasks(e,r){return this.request({method:"tasks/list",params:e},Oce,r)}async cancelTask(e,r){return this.request({method:"tasks/cancel",params:e},DNt,r)}async notification(e,r){if(!this._transport)throw new Error("Not connected");this.assertNotificationCapability(e.method);const n=r?.relatedTask?.taskId;if(n){const o={...e,jsonrpc:"2.0",params:{...e.params,_meta:{...e.params?._meta||{},[Dy]:r.relatedTask}}};await this._enqueueTaskMessage(n,{type:"notification",message:o,timestamp:Date.now()});return}if((this._options?.debouncedNotificationMethods??[]).includes(e.method)&&!e.params&&!r?.relatedRequestId&&!r?.relatedTask){if(this._pendingDebouncedNotifications.has(e.method))return;this._pendingDebouncedNotifications.add(e.method),Promise.resolve().then(()=>{if(this._pendingDebouncedNotifications.delete(e.method),!this._transport)return;let o={...e,jsonrpc:"2.0"};r?.relatedTask&&(o={...o,params:{...o.params,_meta:{...o.params?._meta||{},[Dy]:r.relatedTask}}}),this._transport?.send(o,r).catch(l=>this._onerror(l))});return}let s={...e,jsonrpc:"2.0"};r?.relatedTask&&(s={...s,params:{...s.params,_meta:{...s.params?._meta||{},[Dy]:r.relatedTask}}}),await this._transport.send(s,r)}setRequestHandler(e,r){const n=j2e(e);this.assertRequestHandlerCapability(n),this._requestHandlers.set(n,(i,a)=>{const s=X2e(e,i);return Promise.resolve(r(s,a))})}removeRequestHandler(e){this._requestHandlers.delete(e)}assertCanSetRequestHandler(e){if(this._requestHandlers.has(e))throw new Error(`A request handler for ${e} already exists, which would be overridden`)}setNotificationHandler(e,r){const n=j2e(e);this._notificationHandlers.set(n,i=>{const a=X2e(e,i);return Promise.resolve(r(a))})}removeNotificationHandler(e){this._notificationHandlers.delete(e)}_cleanupTaskProgressHandler(e){const r=this._taskProgressTokens.get(e);r!==void 0&&(this._progressHandlers.delete(r),this._taskProgressTokens.delete(e))}async _enqueueTaskMessage(e,r,n){if(!this._taskStore||!this._taskMessageQueue)throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");const i=this._options?.maxTaskQueueSize;await this._taskMessageQueue.enqueue(e,r,n,i)}async _clearTaskQueue(e,r){if(this._taskMessageQueue){const n=await this._taskMessageQueue.dequeueAll(e,r);for(const i of n)if(i.type==="request"&&aee(i.message)){const a=i.message.id,s=this._requestResolvers.get(a);s?(s(new ci(Oi.InternalError,"Task cancelled or completed")),this._requestResolvers.delete(a)):this._onerror(new Error(`Resolver missing for request ${a} during task ${e} cleanup`))}}}async _waitForTaskUpdate(e,r){let n=this._options?.defaultTaskPollInterval??1e3;try{const i=await this._taskStore?.getTask(e);i?.pollInterval&&(n=i.pollInterval)}catch{}return new Promise((i,a)=>{if(r.aborted){a(new ci(Oi.InvalidRequest,"Request cancelled"));return}const s=setTimeout(i,n);r.addEventListener("abort",()=>{clearTimeout(s),a(new ci(Oi.InvalidRequest,"Request cancelled"))},{once:!0})})}requestTaskStore(e,r){const n=this._taskStore;if(!n)throw new Error("No task store configured");return{createTask:async i=>{if(!e)throw new Error("No request provided");return await n.createTask(i,e.id,{method:e.method,params:e.params},r)},getTask:async i=>{const a=await n.getTask(i,r);if(!a)throw new ci(Oi.InvalidParams,"Failed to retrieve task: Task not found");return a},storeTaskResult:async(i,a,s)=>{await n.storeTaskResult(i,a,s,r);const o=await n.getTask(i,r);if(o){const l=sP.parse({method:"notifications/tasks/status",params:o});await this.notification(l),iy(o.status)&&this._cleanupTaskProgressHandler(i)}},getTaskResult:i=>n.getTaskResult(i,r),updateTaskStatus:async(i,a,s)=>{const o=await n.getTask(i,r);if(!o)throw new ci(Oi.InvalidParams,`Task "${i}" not found - it may have been cleaned up`);if(iy(o.status))throw new ci(Oi.InvalidParams,`Cannot update task "${i}" from terminal status "${o.status}" to "${a}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);await n.updateTaskStatus(i,a,s,r);const l=await n.getTask(i,r);if(l){const u=sP.parse({method:"notifications/tasks/status",params:l});await this.notification(u),iy(l.status)&&this._cleanupTaskProgressHandler(i)}},listTasks:i=>n.listTasks(i,r)}}}function Q2e(t){return t!==null&&typeof t=="object"&&!Array.isArray(t)}function VOt(t,e){const r={...t};for(const n in e){const i=n,a=e[i];if(a===void 0)continue;const s=r[i];Q2e(s)&&Q2e(a)?r[i]={...s,...a}:r[i]=a}return r}var eI={exports:{}},uK={},Im={},ay={},dK={},hK={},fK={},Z2e;function lP(){return Z2e||(Z2e=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.regexpCode=t.getEsmExportName=t.getProperty=t.safeStringify=t.stringify=t.strConcat=t.addCodeArg=t.str=t._=t.nil=t._Code=t.Name=t.IDENTIFIER=t._CodeOrName=void 0;class e{}t._CodeOrName=e,t.IDENTIFIER=/^[a-z$_][a-z$_0-9]*$/i;class r extends e{constructor(b){if(super(),!t.IDENTIFIER.test(b))throw new Error("CodeGen: name must be a valid identifier");this.str=b}toString(){return this.str}emptyStr(){return!1}get names(){return{[this.str]:1}}}t.Name=r;class n extends e{constructor(b){super(),this._items=typeof b=="string"?[b]:b}toString(){return this.str}emptyStr(){if(this._items.length>1)return!1;const b=this._items[0];return b===""||b==='""'}get str(){var b;return(b=this._str)!==null&&b!==void 0?b:this._str=this._items.reduce((y,E)=>`${y}${E}`,"")}get names(){var b;return(b=this._names)!==null&&b!==void 0?b:this._names=this._items.reduce((y,E)=>(E instanceof r&&(y[E.str]=(y[E.str]||0)+1),y),{})}}t._Code=n,t.nil=new n("");function i(v,...b){const y=[v[0]];let E=0;for(;E{if(h.scopePath===void 0)throw new Error(`CodeGen: name "${h}" has no value`);return(0,e._)`${u}${h.scopePath}`})}scopeCode(u=this._values,d,h){return this._reduceValues(u,f=>{if(f.value===void 0)throw new Error(`CodeGen: name "${f}" has no value`);return f.value.code},d,h)}_reduceValues(u,d,h={},f){let p=e.nil;for(const g in u){const m=u[g];if(!m)continue;const _=h[g]=h[g]||new Map;m.forEach(v=>{if(_.has(v))return;_.set(v,n.Started);let b=d(v);if(b){const y=this.opts.es5?t.varKinds.var:t.varKinds.const;p=(0,e._)`${p}${y} ${v} = ${b};${this.opts._n}`}else if(b=f?.(v))p=(0,e._)`${p}${b}${this.opts._n}`;else throw new r(v);_.set(v,n.Completed)})}return p}}t.ValueScope=o})(pK)),pK}var tSe;function Ji(){return tSe||(tSe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.or=t.and=t.not=t.CodeGen=t.operators=t.varKinds=t.ValueScopeName=t.ValueScope=t.Scope=t.Name=t.regexpCode=t.stringify=t.getProperty=t.nil=t.strConcat=t.str=t._=void 0;const e=lP(),r=eSe();var n=lP();Object.defineProperty(t,"_",{enumerable:!0,get:function(){return n._}}),Object.defineProperty(t,"str",{enumerable:!0,get:function(){return n.str}}),Object.defineProperty(t,"strConcat",{enumerable:!0,get:function(){return n.strConcat}}),Object.defineProperty(t,"nil",{enumerable:!0,get:function(){return n.nil}}),Object.defineProperty(t,"getProperty",{enumerable:!0,get:function(){return n.getProperty}}),Object.defineProperty(t,"stringify",{enumerable:!0,get:function(){return n.stringify}}),Object.defineProperty(t,"regexpCode",{enumerable:!0,get:function(){return n.regexpCode}}),Object.defineProperty(t,"Name",{enumerable:!0,get:function(){return n.Name}});var i=eSe();Object.defineProperty(t,"Scope",{enumerable:!0,get:function(){return i.Scope}}),Object.defineProperty(t,"ValueScope",{enumerable:!0,get:function(){return i.ValueScope}}),Object.defineProperty(t,"ValueScopeName",{enumerable:!0,get:function(){return i.ValueScopeName}}),Object.defineProperty(t,"varKinds",{enumerable:!0,get:function(){return i.varKinds}}),t.operators={GT:new e._Code(">"),GTE:new e._Code(">="),LT:new e._Code("<"),LTE:new e._Code("<="),EQ:new e._Code("==="),NEQ:new e._Code("!=="),NOT:new e._Code("!"),OR:new e._Code("||"),AND:new e._Code("&&"),ADD:new e._Code("+")};class a{optimizeNodes(){return this}optimizeNames(V,Y){return this}}class s extends a{constructor(V,Y,j){super(),this.varKind=V,this.name=Y,this.rhs=j}render({es5:V,_n:Y}){const j=V?r.varKinds.var:this.varKind,Q=this.rhs===void 0?"":` = ${this.rhs}`;return`${j} ${this.name}${Q};`+Y}optimizeNames(V,Y){if(V[this.name.str])return this.rhs&&(this.rhs=N(this.rhs,V,Y)),this}get names(){return this.rhs instanceof e._CodeOrName?this.rhs.names:{}}}class o extends a{constructor(V,Y,j){super(),this.lhs=V,this.rhs=Y,this.sideEffects=j}render({_n:V}){return`${this.lhs} = ${this.rhs};`+V}optimizeNames(V,Y){if(!(this.lhs instanceof e.Name&&!V[this.lhs.str]&&!this.sideEffects))return this.rhs=N(this.rhs,V,Y),this}get names(){const V=this.lhs instanceof e.Name?{}:{...this.lhs.names};return P(V,this.rhs)}}class l extends o{constructor(V,Y,j,Q){super(V,j,Q),this.op=Y}render({_n:V}){return`${this.lhs} ${this.op}= ${this.rhs};`+V}}class u extends a{constructor(V){super(),this.label=V,this.names={}}render({_n:V}){return`${this.label}:`+V}}class d extends a{constructor(V){super(),this.label=V,this.names={}}render({_n:V}){return`break${this.label?` ${this.label}`:""};`+V}}class h extends a{constructor(V){super(),this.error=V}render({_n:V}){return`throw ${this.error};`+V}get names(){return this.error.names}}class f extends a{constructor(V){super(),this.code=V}render({_n:V}){return`${this.code};`+V}optimizeNodes(){return`${this.code}`?this:void 0}optimizeNames(V,Y){return this.code=N(this.code,V,Y),this}get names(){return this.code instanceof e._CodeOrName?this.code.names:{}}}class p extends a{constructor(V=[]){super(),this.nodes=V}render(V){return this.nodes.reduce((Y,j)=>Y+j.render(V),"")}optimizeNodes(){const{nodes:V}=this;let Y=V.length;for(;Y--;){const j=V[Y].optimizeNodes();Array.isArray(j)?V.splice(Y,1,...j):j?V[Y]=j:V.splice(Y,1)}return V.length>0?this:void 0}optimizeNames(V,Y){const{nodes:j}=this;let Q=j.length;for(;Q--;){const ae=j[Q];ae.optimizeNames(V,Y)||(k(V,ae.names),j.splice(Q,1))}return j.length>0?this:void 0}get names(){return this.nodes.reduce((V,Y)=>F(V,Y.names),{})}}class g extends p{render(V){return"{"+V._n+super.render(V)+"}"+V._n}}class m extends p{}class _ extends g{}_.kind="else";class v extends g{constructor(V,Y){super(Y),this.condition=V}render(V){let Y=`if(${this.condition})`+super.render(V);return this.else&&(Y+="else "+this.else.render(V)),Y}optimizeNodes(){super.optimizeNodes();const V=this.condition;if(V===!0)return this.nodes;let Y=this.else;if(Y){const j=Y.optimizeNodes();Y=this.else=Array.isArray(j)?new _(j):j}if(Y)return V===!1?Y instanceof v?Y:Y.nodes:this.nodes.length?this:new v(M(V),Y instanceof v?[Y]:Y.nodes);if(!(V===!1||!this.nodes.length))return this}optimizeNames(V,Y){var j;if(this.else=(j=this.else)===null||j===void 0?void 0:j.optimizeNames(V,Y),!!(super.optimizeNames(V,Y)||this.else))return this.condition=N(this.condition,V,Y),this}get names(){const V=super.names;return P(V,this.condition),this.else&&F(V,this.else.names),V}}v.kind="if";class b extends g{}b.kind="for";class y extends b{constructor(V){super(),this.iteration=V}render(V){return`for(${this.iteration})`+super.render(V)}optimizeNames(V,Y){if(super.optimizeNames(V,Y))return this.iteration=N(this.iteration,V,Y),this}get names(){return F(super.names,this.iteration.names)}}class E extends b{constructor(V,Y,j,Q){super(),this.varKind=V,this.name=Y,this.from=j,this.to=Q}render(V){const Y=V.es5?r.varKinds.var:this.varKind,{name:j,from:Q,to:ae}=this;return`for(${Y} ${j}=${Q}; ${j}<${ae}; ${j}++)`+super.render(V)}get names(){const V=P(super.names,this.from);return P(V,this.to)}}class T extends b{constructor(V,Y,j,Q){super(),this.loop=V,this.varKind=Y,this.name=j,this.iterable=Q}render(V){return`for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})`+super.render(V)}optimizeNames(V,Y){if(super.optimizeNames(V,Y))return this.iterable=N(this.iterable,V,Y),this}get names(){return F(super.names,this.iterable.names)}}class C extends g{constructor(V,Y,j){super(),this.name=V,this.args=Y,this.async=j}render(V){return`${this.async?"async ":""}function ${this.name}(${this.args})`+super.render(V)}}C.kind="func";class w extends p{render(V){return"return "+super.render(V)}}w.kind="return";class x extends g{render(V){let Y="try"+super.render(V);return this.catch&&(Y+=this.catch.render(V)),this.finally&&(Y+=this.finally.render(V)),Y}optimizeNodes(){var V,Y;return super.optimizeNodes(),(V=this.catch)===null||V===void 0||V.optimizeNodes(),(Y=this.finally)===null||Y===void 0||Y.optimizeNodes(),this}optimizeNames(V,Y){var j,Q;return super.optimizeNames(V,Y),(j=this.catch)===null||j===void 0||j.optimizeNames(V,Y),(Q=this.finally)===null||Q===void 0||Q.optimizeNames(V,Y),this}get names(){const V=super.names;return this.catch&&F(V,this.catch.names),this.finally&&F(V,this.finally.names),V}}class A extends g{constructor(V){super(),this.error=V}render(V){return`catch(${this.error})`+super.render(V)}}A.kind="catch";class R extends g{render(V){return"finally"+super.render(V)}}R.kind="finally";class O{constructor(V,Y={}){this._values={},this._blockStarts=[],this._constants={},this.opts={...Y,_n:Y.lines?` +`:""},this._extScope=V,this._scope=new r.Scope({parent:V}),this._nodes=[new m]}toString(){return this._root.render(this.opts)}name(V){return this._scope.name(V)}scopeName(V){return this._extScope.name(V)}scopeValue(V,Y){const j=this._extScope.value(V,Y);return(this._values[j.prefix]||(this._values[j.prefix]=new Set)).add(j),j}getScopeValue(V,Y){return this._extScope.getValue(V,Y)}scopeRefs(V){return this._extScope.scopeRefs(V,this._values)}scopeCode(){return this._extScope.scopeCode(this._values)}_def(V,Y,j,Q){const ae=this._scope.toName(Y);return j!==void 0&&Q&&(this._constants[ae.str]=j),this._leafNode(new s(V,ae,j)),ae}const(V,Y,j){return this._def(r.varKinds.const,V,Y,j)}let(V,Y,j){return this._def(r.varKinds.let,V,Y,j)}var(V,Y,j){return this._def(r.varKinds.var,V,Y,j)}assign(V,Y,j){return this._leafNode(new o(V,Y,j))}add(V,Y){return this._leafNode(new l(V,t.operators.ADD,Y))}code(V){return typeof V=="function"?V():V!==e.nil&&this._leafNode(new f(V)),this}object(...V){const Y=["{"];for(const[j,Q]of V)Y.length>1&&Y.push(","),Y.push(j),(j!==Q||this.opts.es5)&&(Y.push(":"),(0,e.addCodeArg)(Y,Q));return Y.push("}"),new e._Code(Y)}if(V,Y,j){if(this._blockNode(new v(V)),Y&&j)this.code(Y).else().code(j).endIf();else if(Y)this.code(Y).endIf();else if(j)throw new Error('CodeGen: "else" body without "then" body');return this}elseIf(V){return this._elseNode(new v(V))}else(){return this._elseNode(new _)}endIf(){return this._endBlockNode(v,_)}_for(V,Y){return this._blockNode(V),Y&&this.code(Y).endFor(),this}for(V,Y){return this._for(new y(V),Y)}forRange(V,Y,j,Q,ae=this.opts.es5?r.varKinds.var:r.varKinds.let){const re=this._scope.toName(V);return this._for(new E(ae,re,Y,j),()=>Q(re))}forOf(V,Y,j,Q=r.varKinds.const){const ae=this._scope.toName(V);if(this.opts.es5){const re=Y instanceof e.Name?Y:this.var("_arr",Y);return this.forRange("_i",0,(0,e._)`${re}.length`,ne=>{this.var(ae,(0,e._)`${re}[${ne}]`),j(ae)})}return this._for(new T("of",Q,ae,Y),()=>j(ae))}forIn(V,Y,j,Q=this.opts.es5?r.varKinds.var:r.varKinds.const){if(this.opts.ownProperties)return this.forOf(V,(0,e._)`Object.keys(${Y})`,j);const ae=this._scope.toName(V);return this._for(new T("in",Q,ae,Y),()=>j(ae))}endFor(){return this._endBlockNode(b)}label(V){return this._leafNode(new u(V))}break(V){return this._leafNode(new d(V))}return(V){const Y=new w;if(this._blockNode(Y),this.code(V),Y.nodes.length!==1)throw new Error('CodeGen: "return" should have one node');return this._endBlockNode(w)}try(V,Y,j){if(!Y&&!j)throw new Error('CodeGen: "try" without "catch" and "finally"');const Q=new x;if(this._blockNode(Q),this.code(V),Y){const ae=this.name("e");this._currNode=Q.catch=new A(ae),Y(ae)}return j&&(this._currNode=Q.finally=new R,this.code(j)),this._endBlockNode(A,R)}throw(V){return this._leafNode(new h(V))}block(V,Y){return this._blockStarts.push(this._nodes.length),V&&this.code(V).endBlock(Y),this}endBlock(V){const Y=this._blockStarts.pop();if(Y===void 0)throw new Error("CodeGen: not in self-balancing block");const j=this._nodes.length-Y;if(j<0||V!==void 0&&j!==V)throw new Error(`CodeGen: wrong number of nodes: ${j} vs ${V} expected`);return this._nodes.length=Y,this}func(V,Y=e.nil,j,Q){return this._blockNode(new C(V,Y,j)),Q&&this.code(Q).endFunc(),this}endFunc(){return this._endBlockNode(C)}optimize(V=1){for(;V-- >0;)this._root.optimizeNodes(),this._root.optimizeNames(this._root.names,this._constants)}_leafNode(V){return this._currNode.nodes.push(V),this}_blockNode(V){this._currNode.nodes.push(V),this._nodes.push(V)}_endBlockNode(V,Y){const j=this._currNode;if(j instanceof V||Y&&j instanceof Y)return this._nodes.pop(),this;throw new Error(`CodeGen: not in block "${Y?`${V.kind}/${Y.kind}`:V.kind}"`)}_elseNode(V){const Y=this._currNode;if(!(Y instanceof v))throw new Error('CodeGen: "else" without "if"');return this._currNode=Y.else=V,this}get _root(){return this._nodes[0]}get _currNode(){const V=this._nodes;return V[V.length-1]}set _currNode(V){const Y=this._nodes;Y[Y.length-1]=V}}t.CodeGen=O;function F(q,V){for(const Y in V)q[Y]=(q[Y]||0)+(V[Y]||0);return q}function P(q,V){return V instanceof e._CodeOrName?F(q,V.names):q}function N(q,V,Y){if(q instanceof e.Name)return j(q);if(!Q(q))return q;return new e._Code(q._items.reduce((ae,re)=>(re instanceof e.Name&&(re=j(re)),re instanceof e._Code?ae.push(...re._items):ae.push(re),ae),[]));function j(ae){const re=Y[ae.str];return re===void 0||V[ae.str]!==1?ae:(delete V[ae.str],re)}function Q(ae){return ae instanceof e._Code&&ae._items.some(re=>re instanceof e.Name&&V[re.str]===1&&Y[re.str]!==void 0)}}function k(q,V){for(const Y in V)q[Y]=(q[Y]||0)-(V[Y]||0)}function M(q){return typeof q=="boolean"||typeof q=="number"||q===null?!q:(0,e._)`!${H(q)}`}t.not=M;const L=$(t.operators.AND);function I(...q){return q.reduce(L)}t.and=I;const U=$(t.operators.OR);function B(...q){return q.reduce(U)}t.or=B;function $(q){return(V,Y)=>V===e.nil?Y:Y===e.nil?V:(0,e._)`${H(V)} ${q} ${H(Y)}`}function H(q){return q instanceof e.Name?q:(0,e._)`(${q})`}})(hK)),hK}var Wi={},rSe;function wa(){if(rSe)return Wi;rSe=1,Object.defineProperty(Wi,"__esModule",{value:!0}),Wi.checkStrictMode=Wi.getErrorPath=Wi.Type=Wi.useFunc=Wi.setEvaluated=Wi.evaluatedPropsToName=Wi.mergeEvaluated=Wi.eachItem=Wi.unescapeJsonPointer=Wi.escapeJsonPointer=Wi.escapeFragment=Wi.unescapeFragment=Wi.schemaRefOrVal=Wi.schemaHasRulesButRef=Wi.schemaHasRules=Wi.checkUnknownRules=Wi.alwaysValidSchema=Wi.toHash=void 0;const t=Ji(),e=lP();function r(T){const C={};for(const w of T)C[w]=!0;return C}Wi.toHash=r;function n(T,C){return typeof C=="boolean"?C:Object.keys(C).length===0?!0:(i(T,C),!a(C,T.self.RULES.all))}Wi.alwaysValidSchema=n;function i(T,C=T.schema){const{opts:w,self:x}=T;if(!w.strictSchema||typeof C=="boolean")return;const A=x.RULES.keywords;for(const R in C)A[R]||E(T,`unknown keyword: "${R}"`)}Wi.checkUnknownRules=i;function a(T,C){if(typeof T=="boolean")return!T;for(const w in T)if(C[w])return!0;return!1}Wi.schemaHasRules=a;function s(T,C){if(typeof T=="boolean")return!T;for(const w in T)if(w!=="$ref"&&C.all[w])return!0;return!1}Wi.schemaHasRulesButRef=s;function o({topSchemaRef:T,schemaPath:C},w,x,A){if(!A){if(typeof w=="number"||typeof w=="boolean")return w;if(typeof w=="string")return(0,t._)`${w}`}return(0,t._)`${T}${C}${(0,t.getProperty)(x)}`}Wi.schemaRefOrVal=o;function l(T){return h(decodeURIComponent(T))}Wi.unescapeFragment=l;function u(T){return encodeURIComponent(d(T))}Wi.escapeFragment=u;function d(T){return typeof T=="number"?`${T}`:T.replace(/~/g,"~0").replace(/\//g,"~1")}Wi.escapeJsonPointer=d;function h(T){return T.replace(/~1/g,"/").replace(/~0/g,"~")}Wi.unescapeJsonPointer=h;function f(T,C){if(Array.isArray(T))for(const w of T)C(w);else C(T)}Wi.eachItem=f;function p({mergeNames:T,mergeToName:C,mergeValues:w,resultToName:x}){return(A,R,O,F)=>{const P=O===void 0?R:O instanceof t.Name?(R instanceof t.Name?T(A,R,O):C(A,R,O),O):R instanceof t.Name?(C(A,O,R),R):w(R,O);return F===t.Name&&!(P instanceof t.Name)?x(A,P):P}}Wi.mergeEvaluated={props:p({mergeNames:(T,C,w)=>T.if((0,t._)`${w} !== true && ${C} !== undefined`,()=>{T.if((0,t._)`${C} === true`,()=>T.assign(w,!0),()=>T.assign(w,(0,t._)`${w} || {}`).code((0,t._)`Object.assign(${w}, ${C})`))}),mergeToName:(T,C,w)=>T.if((0,t._)`${w} !== true`,()=>{C===!0?T.assign(w,!0):(T.assign(w,(0,t._)`${w} || {}`),m(T,w,C))}),mergeValues:(T,C)=>T===!0?!0:{...T,...C},resultToName:g}),items:p({mergeNames:(T,C,w)=>T.if((0,t._)`${w} !== true && ${C} !== undefined`,()=>T.assign(w,(0,t._)`${C} === true ? true : ${w} > ${C} ? ${w} : ${C}`)),mergeToName:(T,C,w)=>T.if((0,t._)`${w} !== true`,()=>T.assign(w,C===!0?!0:(0,t._)`${w} > ${C} ? ${w} : ${C}`)),mergeValues:(T,C)=>T===!0?!0:Math.max(T,C),resultToName:(T,C)=>T.var("items",C)})};function g(T,C){if(C===!0)return T.var("props",!0);const w=T.var("props",(0,t._)`{}`);return C!==void 0&&m(T,w,C),w}Wi.evaluatedPropsToName=g;function m(T,C,w){Object.keys(w).forEach(x=>T.assign((0,t._)`${C}${(0,t.getProperty)(x)}`,!0))}Wi.setEvaluated=m;const _={};function v(T,C){return T.scopeValue("func",{ref:C,code:_[C.code]||(_[C.code]=new e._Code(C.code))})}Wi.useFunc=v;var b;(function(T){T[T.Num=0]="Num",T[T.Str=1]="Str"})(b||(Wi.Type=b={}));function y(T,C,w){if(T instanceof t.Name){const x=C===b.Num;return w?x?(0,t._)`"[" + ${T} + "]"`:(0,t._)`"['" + ${T} + "']"`:x?(0,t._)`"/" + ${T}`:(0,t._)`"/" + ${T}.replace(/~/g, "~0").replace(/\\//g, "~1")`}return w?(0,t.getProperty)(T).toString():"/"+d(T)}Wi.getErrorPath=y;function E(T,C,w=T.opts.strictSchema){if(w){if(C=`strict mode: ${C}`,w===!0)throw new Error(C);T.self.logger.warn(C)}}return Wi.checkStrictMode=E,Wi}var tI={},nSe;function Nv(){if(nSe)return tI;nSe=1,Object.defineProperty(tI,"__esModule",{value:!0});const t=Ji(),e={data:new t.Name("data"),valCxt:new t.Name("valCxt"),instancePath:new t.Name("instancePath"),parentData:new t.Name("parentData"),parentDataProperty:new t.Name("parentDataProperty"),rootData:new t.Name("rootData"),dynamicAnchors:new t.Name("dynamicAnchors"),vErrors:new t.Name("vErrors"),errors:new t.Name("errors"),this:new t.Name("this"),self:new t.Name("self"),scope:new t.Name("scope"),json:new t.Name("json"),jsonPos:new t.Name("jsonPos"),jsonLen:new t.Name("jsonLen"),jsonPart:new t.Name("jsonPart")};return tI.default=e,tI}var iSe;function a$(){return iSe||(iSe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.extendErrors=t.resetErrorsCount=t.reportExtraError=t.reportError=t.keyword$DataError=t.keywordError=void 0;const e=Ji(),r=wa(),n=Nv();t.keywordError={message:({keyword:_})=>(0,e.str)`must pass "${_}" keyword validation`},t.keyword$DataError={message:({keyword:_,schemaType:v})=>v?(0,e.str)`"${_}" keyword must be ${v} ($data)`:(0,e.str)`"${_}" keyword is invalid ($data)`};function i(_,v=t.keywordError,b,y){const{it:E}=_,{gen:T,compositeRule:C,allErrors:w}=E,x=h(_,v,b);y??(C||w)?l(T,x):u(E,(0,e._)`[${x}]`)}t.reportError=i;function a(_,v=t.keywordError,b){const{it:y}=_,{gen:E,compositeRule:T,allErrors:C}=y,w=h(_,v,b);l(E,w),T||C||u(y,n.default.vErrors)}t.reportExtraError=a;function s(_,v){_.assign(n.default.errors,v),_.if((0,e._)`${n.default.vErrors} !== null`,()=>_.if(v,()=>_.assign((0,e._)`${n.default.vErrors}.length`,v),()=>_.assign(n.default.vErrors,null)))}t.resetErrorsCount=s;function o({gen:_,keyword:v,schemaValue:b,data:y,errsCount:E,it:T}){if(E===void 0)throw new Error("ajv implementation error");const C=_.name("err");_.forRange("i",E,n.default.errors,w=>{_.const(C,(0,e._)`${n.default.vErrors}[${w}]`),_.if((0,e._)`${C}.instancePath === undefined`,()=>_.assign((0,e._)`${C}.instancePath`,(0,e.strConcat)(n.default.instancePath,T.errorPath))),_.assign((0,e._)`${C}.schemaPath`,(0,e.str)`${T.errSchemaPath}/${v}`),T.opts.verbose&&(_.assign((0,e._)`${C}.schema`,b),_.assign((0,e._)`${C}.data`,y))})}t.extendErrors=o;function l(_,v){const b=_.const("err",v);_.if((0,e._)`${n.default.vErrors} === null`,()=>_.assign(n.default.vErrors,(0,e._)`[${b}]`),(0,e._)`${n.default.vErrors}.push(${b})`),_.code((0,e._)`${n.default.errors}++`)}function u(_,v){const{gen:b,validateName:y,schemaEnv:E}=_;E.$async?b.throw((0,e._)`new ${_.ValidationError}(${v})`):(b.assign((0,e._)`${y}.errors`,v),b.return(!1))}const d={keyword:new e.Name("keyword"),schemaPath:new e.Name("schemaPath"),params:new e.Name("params"),propertyName:new e.Name("propertyName"),message:new e.Name("message"),schema:new e.Name("schema"),parentSchema:new e.Name("parentSchema")};function h(_,v,b){const{createErrors:y}=_.it;return y===!1?(0,e._)`{}`:f(_,v,b)}function f(_,v,b={}){const{gen:y,it:E}=_,T=[p(E,b),g(_,b)];return m(_,v,T),y.object(...T)}function p({errorPath:_},{instancePath:v}){const b=v?(0,e.str)`${_}${(0,r.getErrorPath)(v,r.Type.Str)}`:_;return[n.default.instancePath,(0,e.strConcat)(n.default.instancePath,b)]}function g({keyword:_,it:{errSchemaPath:v}},{schemaPath:b,parentSchema:y}){let E=y?v:(0,e.str)`${v}/${_}`;return b&&(E=(0,e.str)`${E}${(0,r.getErrorPath)(b,r.Type.Str)}`),[d.schemaPath,E]}function m(_,{params:v,message:b},y){const{keyword:E,data:T,schemaValue:C,it:w}=_,{opts:x,propertyName:A,topSchemaRef:R,schemaPath:O}=w;y.push([d.keyword,E],[d.params,typeof v=="function"?v(_):v||(0,e._)`{}`]),x.messages&&y.push([d.message,typeof b=="function"?b(_):b]),x.verbose&&y.push([d.schema,C],[d.parentSchema,(0,e._)`${R}${O}`],[n.default.data,T]),A&&y.push([d.propertyName,A])}})(dK)),dK}var aSe;function YOt(){if(aSe)return ay;aSe=1,Object.defineProperty(ay,"__esModule",{value:!0}),ay.boolOrEmptySchema=ay.topBoolOrEmptySchema=void 0;const t=a$(),e=Ji(),r=Nv(),n={message:"boolean schema is false"};function i(o){const{gen:l,schema:u,validateName:d}=o;u===!1?s(o,!1):typeof u=="object"&&u.$async===!0?l.return(r.default.data):(l.assign((0,e._)`${d}.errors`,null),l.return(!0))}ay.topBoolOrEmptySchema=i;function a(o,l){const{gen:u,schema:d}=o;d===!1?(u.var(l,!1),s(o)):u.var(l,!0)}ay.boolOrEmptySchema=a;function s(o,l){const{gen:u,data:d}=o,h={gen:u,keyword:"false schema",data:d,schema:!1,schemaCode:!1,schemaValue:!1,params:{},it:o};(0,t.reportError)(h,n,void 0,l)}return ay}var ec={},sy={},sSe;function NDe(){if(sSe)return sy;sSe=1,Object.defineProperty(sy,"__esModule",{value:!0}),sy.getRules=sy.isJSONType=void 0;const t=["string","number","integer","boolean","null","object","array"],e=new Set(t);function r(i){return typeof i=="string"&&e.has(i)}sy.isJSONType=r;function n(){const i={number:{type:"number",rules:[]},string:{type:"string",rules:[]},array:{type:"array",rules:[]},object:{type:"object",rules:[]}};return{types:{...i,integer:!0,boolean:!0,null:!0},rules:[{rules:[]},i.number,i.string,i.array,i.object],post:{rules:[]},all:{},keywords:{}}}return sy.getRules=n,sy}var km={},oSe;function ODe(){if(oSe)return km;oSe=1,Object.defineProperty(km,"__esModule",{value:!0}),km.shouldUseRule=km.shouldUseGroup=km.schemaHasRulesForType=void 0;function t({schema:n,self:i},a){const s=i.RULES.types[a];return s&&s!==!0&&e(n,s)}km.schemaHasRulesForType=t;function e(n,i){return i.rules.some(a=>r(n,a))}km.shouldUseGroup=e;function r(n,i){var a;return n[i.keyword]!==void 0||((a=i.definition.implements)===null||a===void 0?void 0:a.some(s=>n[s]!==void 0))}return km.shouldUseRule=r,km}var lSe;function cP(){if(lSe)return ec;lSe=1,Object.defineProperty(ec,"__esModule",{value:!0}),ec.reportTypeError=ec.checkDataTypes=ec.checkDataType=ec.coerceAndCheckDataType=ec.getJSONTypes=ec.getSchemaTypes=ec.DataType=void 0;const t=NDe(),e=ODe(),r=a$(),n=Ji(),i=wa();var a;(function(b){b[b.Correct=0]="Correct",b[b.Wrong=1]="Wrong"})(a||(ec.DataType=a={}));function s(b){const y=o(b.type);if(y.includes("null")){if(b.nullable===!1)throw new Error("type: null contradicts nullable: false")}else{if(!y.length&&b.nullable!==void 0)throw new Error('"nullable" cannot be used without "type"');b.nullable===!0&&y.push("null")}return y}ec.getSchemaTypes=s;function o(b){const y=Array.isArray(b)?b:b?[b]:[];if(y.every(t.isJSONType))return y;throw new Error("type must be JSONType or JSONType[]: "+y.join(","))}ec.getJSONTypes=o;function l(b,y){const{gen:E,data:T,opts:C}=b,w=d(y,C.coerceTypes),x=y.length>0&&!(w.length===0&&y.length===1&&(0,e.schemaHasRulesForType)(b,y[0]));if(x){const A=g(y,T,C.strictNumbers,a.Wrong);E.if(A,()=>{w.length?h(b,y,w):_(b)})}return x}ec.coerceAndCheckDataType=l;const u=new Set(["string","number","integer","boolean","null"]);function d(b,y){return y?b.filter(E=>u.has(E)||y==="array"&&E==="array"):[]}function h(b,y,E){const{gen:T,data:C,opts:w}=b,x=T.let("dataType",(0,n._)`typeof ${C}`),A=T.let("coerced",(0,n._)`undefined`);w.coerceTypes==="array"&&T.if((0,n._)`${x} == 'object' && Array.isArray(${C}) && ${C}.length == 1`,()=>T.assign(C,(0,n._)`${C}[0]`).assign(x,(0,n._)`typeof ${C}`).if(g(y,C,w.strictNumbers),()=>T.assign(A,C))),T.if((0,n._)`${A} !== undefined`);for(const O of E)(u.has(O)||O==="array"&&w.coerceTypes==="array")&&R(O);T.else(),_(b),T.endIf(),T.if((0,n._)`${A} !== undefined`,()=>{T.assign(C,A),f(b,A)});function R(O){switch(O){case"string":T.elseIf((0,n._)`${x} == "number" || ${x} == "boolean"`).assign(A,(0,n._)`"" + ${C}`).elseIf((0,n._)`${C} === null`).assign(A,(0,n._)`""`);return;case"number":T.elseIf((0,n._)`${x} == "boolean" || ${C} === null + || (${x} == "string" && ${C} && ${C} == +${C})`).assign(A,(0,n._)`+${C}`);return;case"integer":T.elseIf((0,n._)`${x} === "boolean" || ${C} === null + || (${x} === "string" && ${C} && ${C} == +${C} && !(${C} % 1))`).assign(A,(0,n._)`+${C}`);return;case"boolean":T.elseIf((0,n._)`${C} === "false" || ${C} === 0 || ${C} === null`).assign(A,!1).elseIf((0,n._)`${C} === "true" || ${C} === 1`).assign(A,!0);return;case"null":T.elseIf((0,n._)`${C} === "" || ${C} === 0 || ${C} === false`),T.assign(A,null);return;case"array":T.elseIf((0,n._)`${x} === "string" || ${x} === "number" + || ${x} === "boolean" || ${C} === null`).assign(A,(0,n._)`[${C}]`)}}}function f({gen:b,parentData:y,parentDataProperty:E},T){b.if((0,n._)`${y} !== undefined`,()=>b.assign((0,n._)`${y}[${E}]`,T))}function p(b,y,E,T=a.Correct){const C=T===a.Correct?n.operators.EQ:n.operators.NEQ;let w;switch(b){case"null":return(0,n._)`${y} ${C} null`;case"array":w=(0,n._)`Array.isArray(${y})`;break;case"object":w=(0,n._)`${y} && typeof ${y} == "object" && !Array.isArray(${y})`;break;case"integer":w=x((0,n._)`!(${y} % 1) && !isNaN(${y})`);break;case"number":w=x();break;default:return(0,n._)`typeof ${y} ${C} ${b}`}return T===a.Correct?w:(0,n.not)(w);function x(A=n.nil){return(0,n.and)((0,n._)`typeof ${y} == "number"`,A,E?(0,n._)`isFinite(${y})`:n.nil)}}ec.checkDataType=p;function g(b,y,E,T){if(b.length===1)return p(b[0],y,E,T);let C;const w=(0,i.toHash)(b);if(w.array&&w.object){const x=(0,n._)`typeof ${y} != "object"`;C=w.null?x:(0,n._)`!${y} || ${x}`,delete w.null,delete w.array,delete w.object}else C=n.nil;w.number&&delete w.integer;for(const x in w)C=(0,n.and)(C,p(x,y,E,T));return C}ec.checkDataTypes=g;const m={message:({schema:b})=>`must be ${b}`,params:({schema:b,schemaValue:y})=>typeof b=="string"?(0,n._)`{type: ${b}}`:(0,n._)`{type: ${y}}`};function _(b){const y=v(b);(0,r.reportError)(y,m)}ec.reportTypeError=_;function v(b){const{gen:y,data:E,schema:T}=b,C=(0,i.schemaRefOrVal)(b,T,"type");return{gen:y,keyword:"type",data:E,schema:T.type,schemaCode:C,schemaValue:C,parentSchema:T,params:{},it:b}}return ec}var xA={},cSe;function WOt(){if(cSe)return xA;cSe=1,Object.defineProperty(xA,"__esModule",{value:!0}),xA.assignDefaults=void 0;const t=Ji(),e=wa();function r(i,a){const{properties:s,items:o}=i.schema;if(a==="object"&&s)for(const l in s)n(i,l,s[l].default);else a==="array"&&Array.isArray(o)&&o.forEach((l,u)=>n(i,u,l.default))}xA.assignDefaults=r;function n(i,a,s){const{gen:o,compositeRule:l,data:u,opts:d}=i;if(s===void 0)return;const h=(0,t._)`${u}${(0,t.getProperty)(a)}`;if(l){(0,e.checkStrictMode)(i,`default is ignored for: ${h}`);return}let f=(0,t._)`${h} === undefined`;d.useDefaults==="empty"&&(f=(0,t._)`${f} || ${h} === null || ${h} === ""`),o.if(f,(0,t._)`${h} = ${(0,t.stringify)(s)}`)}return xA}var Df={},Xa={},uSe;function Pp(){if(uSe)return Xa;uSe=1,Object.defineProperty(Xa,"__esModule",{value:!0}),Xa.validateUnion=Xa.validateArray=Xa.usePattern=Xa.callValidateCode=Xa.schemaProperties=Xa.allSchemaProperties=Xa.noPropertyInData=Xa.propertyInData=Xa.isOwnProperty=Xa.hasPropFunc=Xa.reportMissingProp=Xa.checkMissingProp=Xa.checkReportMissingProp=void 0;const t=Ji(),e=wa(),r=Nv(),n=wa();function i(b,y){const{gen:E,data:T,it:C}=b;E.if(d(E,T,y,C.opts.ownProperties),()=>{b.setParams({missingProperty:(0,t._)`${y}`},!0),b.error()})}Xa.checkReportMissingProp=i;function a({gen:b,data:y,it:{opts:E}},T,C){return(0,t.or)(...T.map(w=>(0,t.and)(d(b,y,w,E.ownProperties),(0,t._)`${C} = ${w}`)))}Xa.checkMissingProp=a;function s(b,y){b.setParams({missingProperty:y},!0),b.error()}Xa.reportMissingProp=s;function o(b){return b.scopeValue("func",{ref:Object.prototype.hasOwnProperty,code:(0,t._)`Object.prototype.hasOwnProperty`})}Xa.hasPropFunc=o;function l(b,y,E){return(0,t._)`${o(b)}.call(${y}, ${E})`}Xa.isOwnProperty=l;function u(b,y,E,T){const C=(0,t._)`${y}${(0,t.getProperty)(E)} !== undefined`;return T?(0,t._)`${C} && ${l(b,y,E)}`:C}Xa.propertyInData=u;function d(b,y,E,T){const C=(0,t._)`${y}${(0,t.getProperty)(E)} === undefined`;return T?(0,t.or)(C,(0,t.not)(l(b,y,E))):C}Xa.noPropertyInData=d;function h(b){return b?Object.keys(b).filter(y=>y!=="__proto__"):[]}Xa.allSchemaProperties=h;function f(b,y){return h(y).filter(E=>!(0,e.alwaysValidSchema)(b,y[E]))}Xa.schemaProperties=f;function p({schemaCode:b,data:y,it:{gen:E,topSchemaRef:T,schemaPath:C,errorPath:w},it:x},A,R,O){const F=O?(0,t._)`${b}, ${y}, ${T}${C}`:y,P=[[r.default.instancePath,(0,t.strConcat)(r.default.instancePath,w)],[r.default.parentData,x.parentData],[r.default.parentDataProperty,x.parentDataProperty],[r.default.rootData,r.default.rootData]];x.opts.dynamicRef&&P.push([r.default.dynamicAnchors,r.default.dynamicAnchors]);const N=(0,t._)`${F}, ${E.object(...P)}`;return R!==t.nil?(0,t._)`${A}.call(${R}, ${N})`:(0,t._)`${A}(${N})`}Xa.callValidateCode=p;const g=(0,t._)`new RegExp`;function m({gen:b,it:{opts:y}},E){const T=y.unicodeRegExp?"u":"",{regExp:C}=y.code,w=C(E,T);return b.scopeValue("pattern",{key:w.toString(),ref:w,code:(0,t._)`${C.code==="new RegExp"?g:(0,n.useFunc)(b,C)}(${E}, ${T})`})}Xa.usePattern=m;function _(b){const{gen:y,data:E,keyword:T,it:C}=b,w=y.name("valid");if(C.allErrors){const A=y.let("valid",!0);return x(()=>y.assign(A,!1)),A}return y.var(w,!0),x(()=>y.break()),w;function x(A){const R=y.const("len",(0,t._)`${E}.length`);y.forRange("i",0,R,O=>{b.subschema({keyword:T,dataProp:O,dataPropType:e.Type.Num},w),y.if((0,t.not)(w),A)})}}Xa.validateArray=_;function v(b){const{gen:y,schema:E,keyword:T,it:C}=b;if(!Array.isArray(E))throw new Error("ajv implementation error");if(E.some(R=>(0,e.alwaysValidSchema)(C,R))&&!C.opts.unevaluated)return;const x=y.let("valid",!1),A=y.name("_valid");y.block(()=>E.forEach((R,O)=>{const F=b.subschema({keyword:T,schemaProp:O,compositeRule:!0},A);y.assign(x,(0,t._)`${x} || ${A}`),b.mergeValidEvaluated(F,A)||y.if((0,t.not)(x))})),b.result(x,()=>b.reset(),()=>b.error(!0))}return Xa.validateUnion=v,Xa}var dSe;function KOt(){if(dSe)return Df;dSe=1,Object.defineProperty(Df,"__esModule",{value:!0}),Df.validateKeywordUsage=Df.validSchemaType=Df.funcKeywordCode=Df.macroKeywordCode=void 0;const t=Ji(),e=Nv(),r=Pp(),n=a$();function i(f,p){const{gen:g,keyword:m,schema:_,parentSchema:v,it:b}=f,y=p.macro.call(b.self,_,v,b),E=u(g,m,y);b.opts.validateSchema!==!1&&b.self.validateSchema(y,!0);const T=g.name("valid");f.subschema({schema:y,schemaPath:t.nil,errSchemaPath:`${b.errSchemaPath}/${m}`,topSchemaRef:E,compositeRule:!0},T),f.pass(T,()=>f.error(!0))}Df.macroKeywordCode=i;function a(f,p){var g;const{gen:m,keyword:_,schema:v,parentSchema:b,$data:y,it:E}=f;l(E,p);const T=!y&&p.compile?p.compile.call(E.self,v,b,E):p.validate,C=u(m,_,T),w=m.let("valid");f.block$data(w,x),f.ok((g=p.valid)!==null&&g!==void 0?g:w);function x(){if(p.errors===!1)O(),p.modifying&&s(f),F(()=>f.error());else{const P=p.async?A():R();p.modifying&&s(f),F(()=>o(f,P))}}function A(){const P=m.let("ruleErrs",null);return m.try(()=>O((0,t._)`await `),N=>m.assign(w,!1).if((0,t._)`${N} instanceof ${E.ValidationError}`,()=>m.assign(P,(0,t._)`${N}.errors`),()=>m.throw(N))),P}function R(){const P=(0,t._)`${C}.errors`;return m.assign(P,null),O(t.nil),P}function O(P=p.async?(0,t._)`await `:t.nil){const N=E.opts.passContext?e.default.this:e.default.self,k=!("compile"in p&&!y||p.schema===!1);m.assign(w,(0,t._)`${P}${(0,r.callValidateCode)(f,C,N,k)}`,p.modifying)}function F(P){var N;m.if((0,t.not)((N=p.valid)!==null&&N!==void 0?N:w),P)}}Df.funcKeywordCode=a;function s(f){const{gen:p,data:g,it:m}=f;p.if(m.parentData,()=>p.assign(g,(0,t._)`${m.parentData}[${m.parentDataProperty}]`))}function o(f,p){const{gen:g}=f;g.if((0,t._)`Array.isArray(${p})`,()=>{g.assign(e.default.vErrors,(0,t._)`${e.default.vErrors} === null ? ${p} : ${e.default.vErrors}.concat(${p})`).assign(e.default.errors,(0,t._)`${e.default.vErrors}.length`),(0,n.extendErrors)(f)},()=>f.error())}function l({schemaEnv:f},p){if(p.async&&!f.$async)throw new Error("async keyword in sync schema")}function u(f,p,g){if(g===void 0)throw new Error(`keyword "${p}" failed to compile`);return f.scopeValue("keyword",typeof g=="function"?{ref:g}:{ref:g,code:(0,t.stringify)(g)})}function d(f,p,g=!1){return!p.length||p.some(m=>m==="array"?Array.isArray(f):m==="object"?f&&typeof f=="object"&&!Array.isArray(f):typeof f==m||g&&typeof f>"u")}Df.validSchemaType=d;function h({schema:f,opts:p,self:g,errSchemaPath:m},_,v){if(Array.isArray(_.keyword)?!_.keyword.includes(v):_.keyword!==v)throw new Error("ajv implementation error");const b=_.dependencies;if(b?.some(y=>!Object.prototype.hasOwnProperty.call(f,y)))throw new Error(`parent schema must have dependencies of ${v}: ${b.join(",")}`);if(_.validateSchema&&!_.validateSchema(f[v])){const E=`keyword "${v}" value is invalid at path "${m}": `+g.errorsText(_.validateSchema.errors);if(p.validateSchema==="log")g.logger.error(E);else throw new Error(E)}}return Df.validateKeywordUsage=h,Df}var Dm={},hSe;function jOt(){if(hSe)return Dm;hSe=1,Object.defineProperty(Dm,"__esModule",{value:!0}),Dm.extendSubschemaMode=Dm.extendSubschemaData=Dm.getSubschema=void 0;const t=Ji(),e=wa();function r(a,{keyword:s,schemaProp:o,schema:l,schemaPath:u,errSchemaPath:d,topSchemaRef:h}){if(s!==void 0&&l!==void 0)throw new Error('both "keyword" and "schema" passed, only one allowed');if(s!==void 0){const f=a.schema[s];return o===void 0?{schema:f,schemaPath:(0,t._)`${a.schemaPath}${(0,t.getProperty)(s)}`,errSchemaPath:`${a.errSchemaPath}/${s}`}:{schema:f[o],schemaPath:(0,t._)`${a.schemaPath}${(0,t.getProperty)(s)}${(0,t.getProperty)(o)}`,errSchemaPath:`${a.errSchemaPath}/${s}/${(0,e.escapeFragment)(o)}`}}if(l!==void 0){if(u===void 0||d===void 0||h===void 0)throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');return{schema:l,schemaPath:u,topSchemaRef:h,errSchemaPath:d}}throw new Error('either "keyword" or "schema" must be passed')}Dm.getSubschema=r;function n(a,s,{dataProp:o,dataPropType:l,data:u,dataTypes:d,propertyName:h}){if(u!==void 0&&o!==void 0)throw new Error('both "data" and "dataProp" passed, only one allowed');const{gen:f}=s;if(o!==void 0){const{errorPath:g,dataPathArr:m,opts:_}=s,v=f.let("data",(0,t._)`${s.data}${(0,t.getProperty)(o)}`,!0);p(v),a.errorPath=(0,t.str)`${g}${(0,e.getErrorPath)(o,l,_.jsPropertySyntax)}`,a.parentDataProperty=(0,t._)`${o}`,a.dataPathArr=[...m,a.parentDataProperty]}if(u!==void 0){const g=u instanceof t.Name?u:f.let("data",u,!0);p(g),h!==void 0&&(a.propertyName=h)}d&&(a.dataTypes=d);function p(g){a.data=g,a.dataLevel=s.dataLevel+1,a.dataTypes=[],s.definedProperties=new Set,a.parentData=s.data,a.dataNames=[...s.dataNames,g]}}Dm.extendSubschemaData=n;function i(a,{jtdDiscriminator:s,jtdMetadata:o,compositeRule:l,createErrors:u,allErrors:d}){l!==void 0&&(a.compositeRule=l),u!==void 0&&(a.createErrors=u),d!==void 0&&(a.allErrors=d),a.jtdDiscriminator=s,a.jtdMetadata=o}return Dm.extendSubschemaMode=i,Dm}var au={},gK,fSe;function IDe(){return fSe||(fSe=1,gK=function t(e,r){if(e===r)return!0;if(e&&r&&typeof e=="object"&&typeof r=="object"){if(e.constructor!==r.constructor)return!1;var n,i,a;if(Array.isArray(e)){if(n=e.length,n!=r.length)return!1;for(i=n;i--!==0;)if(!t(e[i],r[i]))return!1;return!0}if(e.constructor===RegExp)return e.source===r.source&&e.flags===r.flags;if(e.valueOf!==Object.prototype.valueOf)return e.valueOf()===r.valueOf();if(e.toString!==Object.prototype.toString)return e.toString()===r.toString();if(a=Object.keys(e),n=a.length,n!==Object.keys(r).length)return!1;for(i=n;i--!==0;)if(!Object.prototype.hasOwnProperty.call(r,a[i]))return!1;for(i=n;i--!==0;){var s=a[i];if(!t(e[s],r[s]))return!1}return!0}return e!==e&&r!==r}),gK}var mK={exports:{}},pSe;function XOt(){if(pSe)return mK.exports;pSe=1;var t=mK.exports=function(n,i,a){typeof i=="function"&&(a=i,i={}),a=i.cb||a;var s=typeof a=="function"?a:a.pre||function(){},o=a.post||function(){};e(i,s,o,n,"",n)};t.keywords={additionalItems:!0,items:!0,contains:!0,additionalProperties:!0,propertyNames:!0,not:!0,if:!0,then:!0,else:!0},t.arrayKeywords={items:!0,allOf:!0,anyOf:!0,oneOf:!0},t.propsKeywords={$defs:!0,definitions:!0,properties:!0,patternProperties:!0,dependencies:!0},t.skipKeywords={default:!0,enum:!0,const:!0,required:!0,maximum:!0,minimum:!0,exclusiveMaximum:!0,exclusiveMinimum:!0,multipleOf:!0,maxLength:!0,minLength:!0,pattern:!0,format:!0,maxItems:!0,minItems:!0,uniqueItems:!0,maxProperties:!0,minProperties:!0};function e(n,i,a,s,o,l,u,d,h,f){if(s&&typeof s=="object"&&!Array.isArray(s)){i(s,o,l,u,d,h,f);for(var p in s){var g=s[p];if(Array.isArray(g)){if(p in t.arrayKeywords)for(var m=0;m_+=o(b)),_===1/0))return 1/0}return _}function l(m,_="",v){v!==!1&&(_=h(_));const b=m.parse(_);return u(m,b)}au.getFullPath=l;function u(m,_){return m.serialize(_).split("#")[0]+"#"}au._getFullPath=u;const d=/#\/?$/;function h(m){return m?m.replace(d,""):""}au.normalizeId=h;function f(m,_,v){return v=h(v),m.resolve(_,v)}au.resolveUrl=f;const p=/^[a-z_][-a-z0-9._]*$/i;function g(m,_){if(typeof m=="boolean")return{};const{schemaId:v,uriResolver:b}=this.opts,y=h(m[v]||_),E={"":y},T=l(b,y,!1),C={},w=new Set;return r(m,{allKeys:!0},(R,O,F,P)=>{if(P===void 0)return;const N=T+O;let k=E[P];typeof R[v]=="string"&&(k=M.call(this,R[v])),L.call(this,R.$anchor),L.call(this,R.$dynamicAnchor),E[O]=k;function M(I){const U=this.opts.uriResolver.resolve;if(I=h(k?U(k,I):I),w.has(I))throw A(I);w.add(I);let B=this.refs[I];return typeof B=="string"&&(B=this.refs[B]),typeof B=="object"?x(R,B.schema,I):I!==h(N)&&(I[0]==="#"?(x(R,C[I],I),C[I]=R):this.refs[I]=N),I}function L(I){if(typeof I=="string"){if(!p.test(I))throw new Error(`invalid anchor "${I}"`);M.call(this,`#${I}`)}}}),C;function x(R,O,F){if(O!==void 0&&!e(R,O))throw A(F)}function A(R){return new Error(`reference "${R}" resolves to more than one schema`)}}return au.getSchemaRefs=g,au}var mSe;function o$(){if(mSe)return Im;mSe=1,Object.defineProperty(Im,"__esModule",{value:!0}),Im.getData=Im.KeywordCxt=Im.validateFunctionCode=void 0;const t=YOt(),e=cP(),r=ODe(),n=cP(),i=WOt(),a=KOt(),s=jOt(),o=Ji(),l=Nv(),u=s$(),d=wa(),h=a$();function f(ee){if(T(ee)&&(w(ee),E(ee))){_(ee);return}p(ee,()=>(0,t.topBoolOrEmptySchema)(ee))}Im.validateFunctionCode=f;function p({gen:ee,validateName:J,schema:fe,schemaEnv:ue,opts:ge},ye){ge.code.es5?ee.func(J,(0,o._)`${l.default.data}, ${l.default.valCxt}`,ue.$async,()=>{ee.code((0,o._)`"use strict"; ${b(fe,ge)}`),m(ee,ge),ee.code(ye)}):ee.func(J,(0,o._)`${l.default.data}, ${g(ge)}`,ue.$async,()=>ee.code(b(fe,ge)).code(ye))}function g(ee){return(0,o._)`{${l.default.instancePath}="", ${l.default.parentData}, ${l.default.parentDataProperty}, ${l.default.rootData}=${l.default.data}${ee.dynamicRef?(0,o._)`, ${l.default.dynamicAnchors}={}`:o.nil}}={}`}function m(ee,J){ee.if(l.default.valCxt,()=>{ee.var(l.default.instancePath,(0,o._)`${l.default.valCxt}.${l.default.instancePath}`),ee.var(l.default.parentData,(0,o._)`${l.default.valCxt}.${l.default.parentData}`),ee.var(l.default.parentDataProperty,(0,o._)`${l.default.valCxt}.${l.default.parentDataProperty}`),ee.var(l.default.rootData,(0,o._)`${l.default.valCxt}.${l.default.rootData}`),J.dynamicRef&&ee.var(l.default.dynamicAnchors,(0,o._)`${l.default.valCxt}.${l.default.dynamicAnchors}`)},()=>{ee.var(l.default.instancePath,(0,o._)`""`),ee.var(l.default.parentData,(0,o._)`undefined`),ee.var(l.default.parentDataProperty,(0,o._)`undefined`),ee.var(l.default.rootData,l.default.data),J.dynamicRef&&ee.var(l.default.dynamicAnchors,(0,o._)`{}`)})}function _(ee){const{schema:J,opts:fe,gen:ue}=ee;p(ee,()=>{fe.$comment&&J.$comment&&P(ee),R(ee),ue.let(l.default.vErrors,null),ue.let(l.default.errors,0),fe.unevaluated&&v(ee),x(ee),N(ee)})}function v(ee){const{gen:J,validateName:fe}=ee;ee.evaluated=J.const("evaluated",(0,o._)`${fe}.evaluated`),J.if((0,o._)`${ee.evaluated}.dynamicProps`,()=>J.assign((0,o._)`${ee.evaluated}.props`,(0,o._)`undefined`)),J.if((0,o._)`${ee.evaluated}.dynamicItems`,()=>J.assign((0,o._)`${ee.evaluated}.items`,(0,o._)`undefined`))}function b(ee,J){const fe=typeof ee=="object"&&ee[J.schemaId];return fe&&(J.code.source||J.code.process)?(0,o._)`/*# sourceURL=${fe} */`:o.nil}function y(ee,J){if(T(ee)&&(w(ee),E(ee))){C(ee,J);return}(0,t.boolOrEmptySchema)(ee,J)}function E({schema:ee,self:J}){if(typeof ee=="boolean")return!ee;for(const fe in ee)if(J.RULES.all[fe])return!0;return!1}function T(ee){return typeof ee.schema!="boolean"}function C(ee,J){const{schema:fe,gen:ue,opts:ge}=ee;ge.$comment&&fe.$comment&&P(ee),O(ee),F(ee);const ye=ue.const("_errs",l.default.errors);x(ee,ye),ue.var(J,(0,o._)`${ye} === ${l.default.errors}`)}function w(ee){(0,d.checkUnknownRules)(ee),A(ee)}function x(ee,J){if(ee.opts.jtd)return M(ee,[],!1,J);const fe=(0,e.getSchemaTypes)(ee.schema),ue=(0,e.coerceAndCheckDataType)(ee,fe);M(ee,fe,!ue,J)}function A(ee){const{schema:J,errSchemaPath:fe,opts:ue,self:ge}=ee;J.$ref&&ue.ignoreKeywordsWithRef&&(0,d.schemaHasRulesButRef)(J,ge.RULES)&&ge.logger.warn(`$ref: keywords ignored in schema at path "${fe}"`)}function R(ee){const{schema:J,opts:fe}=ee;J.default!==void 0&&fe.useDefaults&&fe.strictSchema&&(0,d.checkStrictMode)(ee,"default is ignored in the schema root")}function O(ee){const J=ee.schema[ee.opts.schemaId];J&&(ee.baseId=(0,u.resolveUrl)(ee.opts.uriResolver,ee.baseId,J))}function F(ee){if(ee.schema.$async&&!ee.schemaEnv.$async)throw new Error("async schema in sync schema")}function P({gen:ee,schemaEnv:J,schema:fe,errSchemaPath:ue,opts:ge}){const ye=fe.$comment;if(ge.$comment===!0)ee.code((0,o._)`${l.default.self}.logger.log(${ye})`);else if(typeof ge.$comment=="function"){const Ie=(0,o.str)`${ue}/$comment`,we=ee.scopeValue("root",{ref:J.root});ee.code((0,o._)`${l.default.self}.opts.$comment(${ye}, ${Ie}, ${we}.schema)`)}}function N(ee){const{gen:J,schemaEnv:fe,validateName:ue,ValidationError:ge,opts:ye}=ee;fe.$async?J.if((0,o._)`${l.default.errors} === 0`,()=>J.return(l.default.data),()=>J.throw((0,o._)`new ${ge}(${l.default.vErrors})`)):(J.assign((0,o._)`${ue}.errors`,l.default.vErrors),ye.unevaluated&&k(ee),J.return((0,o._)`${l.default.errors} === 0`))}function k({gen:ee,evaluated:J,props:fe,items:ue}){fe instanceof o.Name&&ee.assign((0,o._)`${J}.props`,fe),ue instanceof o.Name&&ee.assign((0,o._)`${J}.items`,ue)}function M(ee,J,fe,ue){const{gen:ge,schema:ye,data:Ie,allErrors:we,opts:Te,self:Ve}=ee,{RULES:Ce}=Ve;if(ye.$ref&&(Te.ignoreKeywordsWithRef||!(0,d.schemaHasRulesButRef)(ye,Ce))){ge.block(()=>Q(ee,"$ref",Ce.all.$ref.definition));return}Te.jtd||I(ee,J),ge.block(()=>{for(const Ne of Ce.rules)rt(Ne);rt(Ce.post)});function rt(Ne){(0,r.shouldUseGroup)(ye,Ne)&&(Ne.type?(ge.if((0,n.checkDataType)(Ne.type,Ie,Te.strictNumbers)),L(ee,Ne),J.length===1&&J[0]===Ne.type&&fe&&(ge.else(),(0,n.reportTypeError)(ee)),ge.endIf()):L(ee,Ne),we||ge.if((0,o._)`${l.default.errors} === ${ue||0}`))}}function L(ee,J){const{gen:fe,schema:ue,opts:{useDefaults:ge}}=ee;ge&&(0,i.assignDefaults)(ee,J.type),fe.block(()=>{for(const ye of J.rules)(0,r.shouldUseRule)(ue,ye)&&Q(ee,ye.keyword,ye.definition,J.type)})}function I(ee,J){ee.schemaEnv.meta||!ee.opts.strictTypes||(U(ee,J),ee.opts.allowUnionTypes||B(ee,J),$(ee,ee.dataTypes))}function U(ee,J){if(J.length){if(!ee.dataTypes.length){ee.dataTypes=J;return}J.forEach(fe=>{q(ee.dataTypes,fe)||Y(ee,`type "${fe}" not allowed by context "${ee.dataTypes.join(",")}"`)}),V(ee,J)}}function B(ee,J){J.length>1&&!(J.length===2&&J.includes("null"))&&Y(ee,"use allowUnionTypes to allow union type keyword")}function $(ee,J){const fe=ee.self.RULES.all;for(const ue in fe){const ge=fe[ue];if(typeof ge=="object"&&(0,r.shouldUseRule)(ee.schema,ge)){const{type:ye}=ge.definition;ye.length&&!ye.some(Ie=>H(J,Ie))&&Y(ee,`missing type "${ye.join(",")}" for keyword "${ue}"`)}}}function H(ee,J){return ee.includes(J)||J==="number"&&ee.includes("integer")}function q(ee,J){return ee.includes(J)||J==="integer"&&ee.includes("number")}function V(ee,J){const fe=[];for(const ue of ee.dataTypes)q(J,ue)?fe.push(ue):J.includes("integer")&&ue==="number"&&fe.push("integer");ee.dataTypes=fe}function Y(ee,J){const fe=ee.schemaEnv.baseId+ee.errSchemaPath;J+=` at "${fe}" (strictTypes)`,(0,d.checkStrictMode)(ee,J,ee.opts.strictTypes)}class j{constructor(J,fe,ue){if((0,a.validateKeywordUsage)(J,fe,ue),this.gen=J.gen,this.allErrors=J.allErrors,this.keyword=ue,this.data=J.data,this.schema=J.schema[ue],this.$data=fe.$data&&J.opts.$data&&this.schema&&this.schema.$data,this.schemaValue=(0,d.schemaRefOrVal)(J,this.schema,ue,this.$data),this.schemaType=fe.schemaType,this.parentSchema=J.schema,this.params={},this.it=J,this.def=fe,this.$data)this.schemaCode=J.gen.const("vSchema",ne(this.$data,J));else if(this.schemaCode=this.schemaValue,!(0,a.validSchemaType)(this.schema,fe.schemaType,fe.allowUndefined))throw new Error(`${ue} value must be ${JSON.stringify(fe.schemaType)}`);("code"in fe?fe.trackErrors:fe.errors!==!1)&&(this.errsCount=J.gen.const("_errs",l.default.errors))}result(J,fe,ue){this.failResult((0,o.not)(J),fe,ue)}failResult(J,fe,ue){this.gen.if(J),ue?ue():this.error(),fe?(this.gen.else(),fe(),this.allErrors&&this.gen.endIf()):this.allErrors?this.gen.endIf():this.gen.else()}pass(J,fe){this.failResult((0,o.not)(J),void 0,fe)}fail(J){if(J===void 0){this.error(),this.allErrors||this.gen.if(!1);return}this.gen.if(J),this.error(),this.allErrors?this.gen.endIf():this.gen.else()}fail$data(J){if(!this.$data)return this.fail(J);const{schemaCode:fe}=this;this.fail((0,o._)`${fe} !== undefined && (${(0,o.or)(this.invalid$data(),J)})`)}error(J,fe,ue){if(fe){this.setParams(fe),this._error(J,ue),this.setParams({});return}this._error(J,ue)}_error(J,fe){(J?h.reportExtraError:h.reportError)(this,this.def.error,fe)}$dataError(){(0,h.reportError)(this,this.def.$dataError||h.keyword$DataError)}reset(){if(this.errsCount===void 0)throw new Error('add "trackErrors" to keyword definition');(0,h.resetErrorsCount)(this.gen,this.errsCount)}ok(J){this.allErrors||this.gen.if(J)}setParams(J,fe){fe?Object.assign(this.params,J):this.params=J}block$data(J,fe,ue=o.nil){this.gen.block(()=>{this.check$data(J,ue),fe()})}check$data(J=o.nil,fe=o.nil){if(!this.$data)return;const{gen:ue,schemaCode:ge,schemaType:ye,def:Ie}=this;ue.if((0,o.or)((0,o._)`${ge} === undefined`,fe)),J!==o.nil&&ue.assign(J,!0),(ye.length||Ie.validateSchema)&&(ue.elseIf(this.invalid$data()),this.$dataError(),J!==o.nil&&ue.assign(J,!1)),ue.else()}invalid$data(){const{gen:J,schemaCode:fe,schemaType:ue,def:ge,it:ye}=this;return(0,o.or)(Ie(),we());function Ie(){if(ue.length){if(!(fe instanceof o.Name))throw new Error("ajv implementation error");const Te=Array.isArray(ue)?ue:[ue];return(0,o._)`${(0,n.checkDataTypes)(Te,fe,ye.opts.strictNumbers,n.DataType.Wrong)}`}return o.nil}function we(){if(ge.validateSchema){const Te=J.scopeValue("validate$data",{ref:ge.validateSchema});return(0,o._)`!${Te}(${fe})`}return o.nil}}subschema(J,fe){const ue=(0,s.getSubschema)(this.it,J);(0,s.extendSubschemaData)(ue,this.it,J),(0,s.extendSubschemaMode)(ue,J);const ge={...this.it,...ue,items:void 0,props:void 0};return y(ge,fe),ge}mergeEvaluated(J,fe){const{it:ue,gen:ge}=this;ue.opts.unevaluated&&(ue.props!==!0&&J.props!==void 0&&(ue.props=d.mergeEvaluated.props(ge,J.props,ue.props,fe)),ue.items!==!0&&J.items!==void 0&&(ue.items=d.mergeEvaluated.items(ge,J.items,ue.items,fe)))}mergeValidEvaluated(J,fe){const{it:ue,gen:ge}=this;if(ue.opts.unevaluated&&(ue.props!==!0||ue.items!==!0))return ge.if(fe,()=>this.mergeEvaluated(J,o.Name)),!0}}Im.KeywordCxt=j;function Q(ee,J,fe,ue){const ge=new j(ee,fe,J);"code"in fe?fe.code(ge,ue):ge.$data&&fe.validate?(0,a.funcKeywordCode)(ge,fe):"macro"in fe?(0,a.macroKeywordCode)(ge,fe):(fe.compile||fe.validate)&&(0,a.funcKeywordCode)(ge,fe)}const ae=/^\/(?:[^~]|~0|~1)*$/,re=/^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;function ne(ee,{dataLevel:J,dataNames:fe,dataPathArr:ue}){let ge,ye;if(ee==="")return l.default.rootData;if(ee[0]==="/"){if(!ae.test(ee))throw new Error(`Invalid JSON-pointer: ${ee}`);ge=ee,ye=l.default.rootData}else{const Ve=re.exec(ee);if(!Ve)throw new Error(`Invalid JSON-pointer: ${ee}`);const Ce=+Ve[1];if(ge=Ve[2],ge==="#"){if(Ce>=J)throw new Error(Te("property/index",Ce));return ue[J-Ce]}if(Ce>J)throw new Error(Te("data",Ce));if(ye=fe[J-Ce],!ge)return ye}let Ie=ye;const we=ge.split("/");for(const Ve of we)Ve&&(ye=(0,o._)`${ye}${(0,o.getProperty)((0,d.unescapeJsonPointer)(Ve))}`,Ie=(0,o._)`${Ie} && ${ye}`);return Ie;function Te(Ve,Ce){return`Cannot access ${Ve} ${Ce} levels up, current level is ${J}`}}return Im.getData=ne,Im}var rI={},_Se;function Bce(){if(_Se)return rI;_Se=1,Object.defineProperty(rI,"__esModule",{value:!0});class t extends Error{constructor(r){super("validation failed"),this.errors=r,this.ajv=this.validation=!0}}return rI.default=t,rI}var nI={},vSe;function l$(){if(vSe)return nI;vSe=1,Object.defineProperty(nI,"__esModule",{value:!0});const t=s$();class e extends Error{constructor(n,i,a,s){super(s||`can't resolve reference ${a} from id ${i}`),this.missingRef=(0,t.resolveUrl)(n,i,a),this.missingSchema=(0,t.normalizeId)((0,t.getFullPath)(n,this.missingRef))}}return nI.default=e,nI}var Gd={},ySe;function Uce(){if(ySe)return Gd;ySe=1,Object.defineProperty(Gd,"__esModule",{value:!0}),Gd.resolveSchema=Gd.getCompilingSchema=Gd.resolveRef=Gd.compileSchema=Gd.SchemaEnv=void 0;const t=Ji(),e=Bce(),r=Nv(),n=s$(),i=wa(),a=o$();class s{constructor(v){var b;this.refs={},this.dynamicAnchors={};let y;typeof v.schema=="object"&&(y=v.schema),this.schema=v.schema,this.schemaId=v.schemaId,this.root=v.root||this,this.baseId=(b=v.baseId)!==null&&b!==void 0?b:(0,n.normalizeId)(y?.[v.schemaId||"$id"]),this.schemaPath=v.schemaPath,this.localRefs=v.localRefs,this.meta=v.meta,this.$async=y?.$async,this.refs={}}}Gd.SchemaEnv=s;function o(_){const v=d.call(this,_);if(v)return v;const b=(0,n.getFullPath)(this.opts.uriResolver,_.root.baseId),{es5:y,lines:E}=this.opts.code,{ownProperties:T}=this.opts,C=new t.CodeGen(this.scope,{es5:y,lines:E,ownProperties:T});let w;_.$async&&(w=C.scopeValue("Error",{ref:e.default,code:(0,t._)`require("ajv/dist/runtime/validation_error").default`}));const x=C.scopeName("validate");_.validateName=x;const A={gen:C,allErrors:this.opts.allErrors,data:r.default.data,parentData:r.default.parentData,parentDataProperty:r.default.parentDataProperty,dataNames:[r.default.data],dataPathArr:[t.nil],dataLevel:0,dataTypes:[],definedProperties:new Set,topSchemaRef:C.scopeValue("schema",this.opts.code.source===!0?{ref:_.schema,code:(0,t.stringify)(_.schema)}:{ref:_.schema}),validateName:x,ValidationError:w,schema:_.schema,schemaEnv:_,rootId:b,baseId:_.baseId||b,schemaPath:t.nil,errSchemaPath:_.schemaPath||(this.opts.jtd?"":"#"),errorPath:(0,t._)`""`,opts:this.opts,self:this};let R;try{this._compilations.add(_),(0,a.validateFunctionCode)(A),C.optimize(this.opts.code.optimize);const O=C.toString();R=`${C.scopeRefs(r.default.scope)}return ${O}`,this.opts.code.process&&(R=this.opts.code.process(R,_));const P=new Function(`${r.default.self}`,`${r.default.scope}`,R)(this,this.scope.get());if(this.scope.value(x,{ref:P}),P.errors=null,P.schema=_.schema,P.schemaEnv=_,_.$async&&(P.$async=!0),this.opts.code.source===!0&&(P.source={validateName:x,validateCode:O,scopeValues:C._values}),this.opts.unevaluated){const{props:N,items:k}=A;P.evaluated={props:N instanceof t.Name?void 0:N,items:k instanceof t.Name?void 0:k,dynamicProps:N instanceof t.Name,dynamicItems:k instanceof t.Name},P.source&&(P.source.evaluated=(0,t.stringify)(P.evaluated))}return _.validate=P,_}catch(O){throw delete _.validate,delete _.validateName,R&&this.logger.error("Error compiling schema, function code:",R),O}finally{this._compilations.delete(_)}}Gd.compileSchema=o;function l(_,v,b){var y;b=(0,n.resolveUrl)(this.opts.uriResolver,v,b);const E=_.refs[b];if(E)return E;let T=f.call(this,_,b);if(T===void 0){const C=(y=_.localRefs)===null||y===void 0?void 0:y[b],{schemaId:w}=this.opts;C&&(T=new s({schema:C,schemaId:w,root:_,baseId:v}))}if(T!==void 0)return _.refs[b]=u.call(this,T)}Gd.resolveRef=l;function u(_){return(0,n.inlineRef)(_.schema,this.opts.inlineRefs)?_.schema:_.validate?_:o.call(this,_)}function d(_){for(const v of this._compilations)if(h(v,_))return v}Gd.getCompilingSchema=d;function h(_,v){return _.schema===v.schema&&_.root===v.root&&_.baseId===v.baseId}function f(_,v){let b;for(;typeof(b=this.refs[v])=="string";)v=b;return b||this.schemas[v]||p.call(this,_,v)}function p(_,v){const b=this.opts.uriResolver.parse(v),y=(0,n._getFullPath)(this.opts.uriResolver,b);let E=(0,n.getFullPath)(this.opts.uriResolver,_.baseId,void 0);if(Object.keys(_.schema).length>0&&y===E)return m.call(this,b,_);const T=(0,n.normalizeId)(y),C=this.refs[T]||this.schemas[T];if(typeof C=="string"){const w=p.call(this,_,C);return typeof w?.schema!="object"?void 0:m.call(this,b,w)}if(typeof C?.schema=="object"){if(C.validate||o.call(this,C),T===(0,n.normalizeId)(v)){const{schema:w}=C,{schemaId:x}=this.opts,A=w[x];return A&&(E=(0,n.resolveUrl)(this.opts.uriResolver,E,A)),new s({schema:w,schemaId:x,root:_,baseId:E})}return m.call(this,b,C)}}Gd.resolveSchema=p;const g=new Set(["properties","patternProperties","enum","dependencies","definitions"]);function m(_,{baseId:v,schema:b,root:y}){var E;if(((E=_.fragment)===null||E===void 0?void 0:E[0])!=="/")return;for(const w of _.fragment.slice(1).split("/")){if(typeof b=="boolean")return;const x=b[(0,i.unescapeFragment)(w)];if(x===void 0)return;b=x;const A=typeof b=="object"&&b[this.opts.schemaId];!g.has(w)&&A&&(v=(0,n.resolveUrl)(this.opts.uriResolver,v,A))}let T;if(typeof b!="boolean"&&b.$ref&&!(0,i.schemaHasRulesButRef)(b,this.RULES)){const w=(0,n.resolveUrl)(this.opts.uriResolver,v,b.$ref);T=p.call(this,y,w)}const{schemaId:C}=this.opts;if(T=T||new s({schema:b,schemaId:C,root:y,baseId:v}),T.schema!==T.root.schema)return T}return Gd}const QOt="https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",ZOt="Meta-schema for $data reference (JSON AnySchema extension proposal)",JOt="object",eIt=["$data"],tIt={$data:{type:"string",anyOf:[{format:"relative-json-pointer"},{format:"json-pointer"}]}},rIt=!1,nIt={$id:QOt,description:ZOt,type:JOt,required:eIt,properties:tIt,additionalProperties:rIt};var iI={},AA={exports:{}},_K,bSe;function kDe(){if(bSe)return _K;bSe=1;const t=RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu),e=RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u),r=RegExp.prototype.test.bind(/^[\da-f]{2}$/iu),n=RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu),i=RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);function a(T){let C="",w=0,x=0;for(x=0;x=48&&w<=57||w>=65&&w<=70||w>=97&&w<=102))return"";C+=T[x];break}for(x+=1;x=48&&w<=57||w>=65&&w<=70||w>=97&&w<=102))return"";C+=T[x]}return C}const s=RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);function o(T){return T.length=0,!0}function l(T,C,w){if(T.length){const x=a(T);if(x!=="")C.push(x);else return w.error=!0,!1;T.length=0}return!0}function u(T){let C=0;const w={error:!1,address:"",zone:""},x=[],A=[];let R=!1,O=!1,F=l;for(let P=0;P7){w.error=!0;break}P>0&&T[P-1]===":"&&(R=!0),x.push(":");continue}else if(N==="%"){if(!F(A,x,w))break;F=o}else{A.push(N);continue}}return A.length&&(F===o?w.zone=A.join(""):O?x.push(A.join("")):x.push(a(A))),w.address=x.join(""),w}function d(T){if(h(T,":")<2)return{host:T,isIPV6:!1};const C=u(T);if(C.error)return{host:T,isIPV6:!1};{let w=C.address,x=C.address;return C.zone&&(w+="%"+C.zone,x+="%25"+C.zone),{host:w,isIPV6:!0,escapedHost:x}}}function h(T,C){let w=0;for(let x=0;xp[x])}function v(T,C=!1){if(T.indexOf("%")===-1)return T;let w="";for(let x=0;x65535))return"URI port is malformed."}function E(R,O){const F=Object.assign({},O),P={scheme:void 0,userinfo:void 0,host:"",port:void 0,path:"",query:void 0,fragment:void 0};let N=!1,k=!1;F.reference==="suffix"&&(F.scheme?R=F.scheme+":"+R:R="//"+R);const M=R.match(v);M!==null&&M[1].indexOf("\\")!==-1&&(P.error="URI authority must not contain a literal backslash.",N=!0);const L=R.match(b);if(L!==null){const U=L[1],B=U.replace(/[\t\n\r]/g,"");B.length>=2&&(B.slice(0,2)!=="//"?(P.error=P.error||"URI authority must not contain a literal backslash.",N=!0):U.length!==B.length&&(P.error=P.error||"URI authority introducer must not contain whitespace.",N=!0))}const I=R.match(_);if(I){P.scheme=I[1],P.userinfo=I[3],P.host=I[4],P.port=parseInt(I[5],10),P.path=I[6]||"",P.query=I[7],P.fragment=I[8],isNaN(P.port)&&(P.port=I[5]);const U=y(P,I);if(U!==void 0&&(P.error=P.error||U,N=!0),P.host)if(o(P.host)===!1){const H=t(P.host);P.host=H.host.toLowerCase(),k=H.isIPV6}else k=!0;P.scheme===void 0&&P.userinfo===void 0&&P.host===void 0&&P.port===void 0&&P.query===void 0&&!P.path?P.reference="same-document":P.scheme===void 0?P.reference="relative":P.fragment===void 0?P.reference="absolute":P.reference="uri",F.reference&&F.reference!=="suffix"&&F.reference!==P.reference&&(P.error=P.error||"URI is not a "+F.reference+" reference.");const B=d(F.scheme||P.scheme);if(!F.unicodeSupport&&(!B||!B.unicodeSupport)&&P.host&&(F.domainHost||B&&B.domainHost)&&k===!1&&l(P.host))try{P.host=new URL("http://"+P.host).hostname}catch($){P.error=P.error||"Host's domain name can not be converted to ASCII: "+$}if((!B||B&&!B.skipNormalize)&&(R.indexOf("%")!==-1&&(P.scheme!==void 0&&(P.scheme=unescape(P.scheme)),P.host!==void 0&&(P.host=s(unescape(P.host),k))),P.path&&(P.path=i(P.path)),P.fragment))try{P.fragment=encodeURI(decodeURIComponent(P.fragment))}catch{P.error=P.error||"URI malformed"}B&&B.parse&&B.parse(P,F)}else P.error=P.error||"URI can not be parsed.";return{parsed:P,malformedAuthorityOrPort:N}}function T(R,O){return E(R,O).parsed}function C(R,O){return w(R,O).normalized}function w(R,O){const{parsed:F,malformedAuthorityOrPort:P}=E(R,O);return{normalized:P?R:m(F,O),malformedAuthorityOrPort:P}}function x(R,O){if(typeof R=="string"){const{normalized:F,malformedAuthorityOrPort:P}=w(R,O);return P?void 0:F}if(typeof R=="object")return m(R,O)}const A={SCHEMES:u,normalize:h,resolve:f,resolveComponent:p,equal:g,serialize:m,parse:T};return AA.exports=A,AA.exports.default=A,AA.exports.fastUri=A,AA.exports}var TSe;function sIt(){if(TSe)return iI;TSe=1,Object.defineProperty(iI,"__esModule",{value:!0});const t=aIt();return t.code='require("ajv/dist/runtime/uri").default',iI.default=t,iI}var CSe;function oIt(){return CSe||(CSe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.CodeGen=t.Name=t.nil=t.stringify=t.str=t._=t.KeywordCxt=void 0;var e=o$();Object.defineProperty(t,"KeywordCxt",{enumerable:!0,get:function(){return e.KeywordCxt}});var r=Ji();Object.defineProperty(t,"_",{enumerable:!0,get:function(){return r._}}),Object.defineProperty(t,"str",{enumerable:!0,get:function(){return r.str}}),Object.defineProperty(t,"stringify",{enumerable:!0,get:function(){return r.stringify}}),Object.defineProperty(t,"nil",{enumerable:!0,get:function(){return r.nil}}),Object.defineProperty(t,"Name",{enumerable:!0,get:function(){return r.Name}}),Object.defineProperty(t,"CodeGen",{enumerable:!0,get:function(){return r.CodeGen}});const n=Bce(),i=l$(),a=NDe(),s=Uce(),o=Ji(),l=s$(),u=cP(),d=wa(),h=nIt,f=sIt(),p=(B,$)=>new RegExp(B,$);p.code="new RegExp";const g=["removeAdditional","useDefaults","coerceTypes"],m=new Set(["validate","serialize","parse","wrapper","root","schema","keyword","pattern","formats","validate$data","func","obj","Error"]),_={errorDataPath:"",format:"`validateFormats: false` can be used instead.",nullable:'"nullable" keyword is supported by default.',jsonPointers:"Deprecated jsPropertySyntax can be used instead.",extendRefs:"Deprecated ignoreKeywordsWithRef can be used instead.",missingRefs:"Pass empty schema with $id that should be ignored to ajv.addSchema.",processCode:"Use option `code: {process: (code, schemaEnv: object) => string}`",sourceCode:"Use option `code: {source: true}`",strictDefaults:"It is default now, see option `strict`.",strictKeywords:"It is default now, see option `strict`.",uniqueItems:'"uniqueItems" keyword is always validated.',unknownFormats:"Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",cache:"Map is used as cache, schema object as key.",serialize:"Map is used as cache, schema object as key.",ajvErrors:"It is default now."},v={ignoreKeywordsWithRef:"",jsPropertySyntax:"",unicode:'"minLength"/"maxLength" account for unicode characters by default.'},b=200;function y(B){var $,H,q,V,Y,j,Q,ae,re,ne,ee,J,fe,ue,ge,ye,Ie,we,Te,Ve,Ce,rt,Ne,et,ut;const Pe=B.strict,qe=($=B.code)===null||$===void 0?void 0:$.optimize,Ze=qe===!0||qe===void 0?1:qe||0,De=(q=(H=B.code)===null||H===void 0?void 0:H.regExp)!==null&&q!==void 0?q:p,Fe=(V=B.uriResolver)!==null&&V!==void 0?V:f.default;return{strictSchema:(j=(Y=B.strictSchema)!==null&&Y!==void 0?Y:Pe)!==null&&j!==void 0?j:!0,strictNumbers:(ae=(Q=B.strictNumbers)!==null&&Q!==void 0?Q:Pe)!==null&&ae!==void 0?ae:!0,strictTypes:(ne=(re=B.strictTypes)!==null&&re!==void 0?re:Pe)!==null&&ne!==void 0?ne:"log",strictTuples:(J=(ee=B.strictTuples)!==null&&ee!==void 0?ee:Pe)!==null&&J!==void 0?J:"log",strictRequired:(ue=(fe=B.strictRequired)!==null&&fe!==void 0?fe:Pe)!==null&&ue!==void 0?ue:!1,code:B.code?{...B.code,optimize:Ze,regExp:De}:{optimize:Ze,regExp:De},loopRequired:(ge=B.loopRequired)!==null&&ge!==void 0?ge:b,loopEnum:(ye=B.loopEnum)!==null&&ye!==void 0?ye:b,meta:(Ie=B.meta)!==null&&Ie!==void 0?Ie:!0,messages:(we=B.messages)!==null&&we!==void 0?we:!0,inlineRefs:(Te=B.inlineRefs)!==null&&Te!==void 0?Te:!0,schemaId:(Ve=B.schemaId)!==null&&Ve!==void 0?Ve:"$id",addUsedSchema:(Ce=B.addUsedSchema)!==null&&Ce!==void 0?Ce:!0,validateSchema:(rt=B.validateSchema)!==null&&rt!==void 0?rt:!0,validateFormats:(Ne=B.validateFormats)!==null&&Ne!==void 0?Ne:!0,unicodeRegExp:(et=B.unicodeRegExp)!==null&&et!==void 0?et:!0,int32range:(ut=B.int32range)!==null&&ut!==void 0?ut:!0,uriResolver:Fe}}class E{constructor($={}){this.schemas={},this.refs={},this.formats=Object.create(null),this._compilations=new Set,this._loading={},this._cache=new Map,$=this.opts={...$,...y($)};const{es5:H,lines:q}=this.opts.code;this.scope=new o.ValueScope({scope:{},prefixes:m,es5:H,lines:q}),this.logger=F($.logger);const V=$.validateFormats;$.validateFormats=!1,this.RULES=(0,a.getRules)(),T.call(this,_,$,"NOT SUPPORTED"),T.call(this,v,$,"DEPRECATED","warn"),this._metaOpts=R.call(this),$.formats&&x.call(this),this._addVocabularies(),this._addDefaultMetaSchema(),$.keywords&&A.call(this,$.keywords),typeof $.meta=="object"&&this.addMetaSchema($.meta),w.call(this),$.validateFormats=V}_addVocabularies(){this.addKeyword("$async")}_addDefaultMetaSchema(){const{$data:$,meta:H,schemaId:q}=this.opts;let V=h;q==="id"&&(V={...h},V.id=V.$id,delete V.$id),H&&$&&this.addMetaSchema(V,V[q],!1)}defaultMeta(){const{meta:$,schemaId:H}=this.opts;return this.opts.defaultMeta=typeof $=="object"?$[H]||$:void 0}validate($,H){let q;if(typeof $=="string"){if(q=this.getSchema($),!q)throw new Error(`no schema with key or ref "${$}"`)}else q=this.compile($);const V=q(H);return"$async"in q||(this.errors=q.errors),V}compile($,H){const q=this._addSchema($,H);return q.validate||this._compileSchemaEnv(q)}compileAsync($,H){if(typeof this.opts.loadSchema!="function")throw new Error("options.loadSchema should be a function");const{loadSchema:q}=this.opts;return V.call(this,$,H);async function V(ne,ee){await Y.call(this,ne.$schema);const J=this._addSchema(ne,ee);return J.validate||j.call(this,J)}async function Y(ne){ne&&!this.getSchema(ne)&&await V.call(this,{$ref:ne},!0)}async function j(ne){try{return this._compileSchemaEnv(ne)}catch(ee){if(!(ee instanceof i.default))throw ee;return Q.call(this,ee),await ae.call(this,ee.missingSchema),j.call(this,ne)}}function Q({missingSchema:ne,missingRef:ee}){if(this.refs[ne])throw new Error(`AnySchema ${ne} is loaded but ${ee} cannot be resolved`)}async function ae(ne){const ee=await re.call(this,ne);this.refs[ne]||await Y.call(this,ee.$schema),this.refs[ne]||this.addSchema(ee,ne,H)}async function re(ne){const ee=this._loading[ne];if(ee)return ee;try{return await(this._loading[ne]=q(ne))}finally{delete this._loading[ne]}}}addSchema($,H,q,V=this.opts.validateSchema){if(Array.isArray($)){for(const j of $)this.addSchema(j,void 0,q,V);return this}let Y;if(typeof $=="object"){const{schemaId:j}=this.opts;if(Y=$[j],Y!==void 0&&typeof Y!="string")throw new Error(`schema ${j} must be string`)}return H=(0,l.normalizeId)(H||Y),this._checkUnique(H),this.schemas[H]=this._addSchema($,q,H,V,!0),this}addMetaSchema($,H,q=this.opts.validateSchema){return this.addSchema($,H,!0,q),this}validateSchema($,H){if(typeof $=="boolean")return!0;let q;if(q=$.$schema,q!==void 0&&typeof q!="string")throw new Error("$schema must be a string");if(q=q||this.opts.defaultMeta||this.defaultMeta(),!q)return this.logger.warn("meta-schema not available"),this.errors=null,!0;const V=this.validate(q,$);if(!V&&H){const Y="schema is invalid: "+this.errorsText();if(this.opts.validateSchema==="log")this.logger.error(Y);else throw new Error(Y)}return V}getSchema($){let H;for(;typeof(H=C.call(this,$))=="string";)$=H;if(H===void 0){const{schemaId:q}=this.opts,V=new s.SchemaEnv({schema:{},schemaId:q});if(H=s.resolveSchema.call(this,V,$),!H)return;this.refs[$]=H}return H.validate||this._compileSchemaEnv(H)}removeSchema($){if($ instanceof RegExp)return this._removeAllSchemas(this.schemas,$),this._removeAllSchemas(this.refs,$),this;switch(typeof $){case"undefined":return this._removeAllSchemas(this.schemas),this._removeAllSchemas(this.refs),this._cache.clear(),this;case"string":{const H=C.call(this,$);return typeof H=="object"&&this._cache.delete(H.schema),delete this.schemas[$],delete this.refs[$],this}case"object":{const H=$;this._cache.delete(H);let q=$[this.opts.schemaId];return q&&(q=(0,l.normalizeId)(q),delete this.schemas[q],delete this.refs[q]),this}default:throw new Error("ajv.removeSchema: invalid parameter")}}addVocabulary($){for(const H of $)this.addKeyword(H);return this}addKeyword($,H){let q;if(typeof $=="string")q=$,typeof H=="object"&&(this.logger.warn("these parameters are deprecated, see docs for addKeyword"),H.keyword=q);else if(typeof $=="object"&&H===void 0){if(H=$,q=H.keyword,Array.isArray(q)&&!q.length)throw new Error("addKeywords: keyword must be string or non-empty array")}else throw new Error("invalid addKeywords parameters");if(N.call(this,q,H),!H)return(0,d.eachItem)(q,Y=>k.call(this,Y)),this;L.call(this,H);const V={...H,type:(0,u.getJSONTypes)(H.type),schemaType:(0,u.getJSONTypes)(H.schemaType)};return(0,d.eachItem)(q,V.type.length===0?Y=>k.call(this,Y,V):Y=>V.type.forEach(j=>k.call(this,Y,V,j))),this}getKeyword($){const H=this.RULES.all[$];return typeof H=="object"?H.definition:!!H}removeKeyword($){const{RULES:H}=this;delete H.keywords[$],delete H.all[$];for(const q of H.rules){const V=q.rules.findIndex(Y=>Y.keyword===$);V>=0&&q.rules.splice(V,1)}return this}addFormat($,H){return typeof H=="string"&&(H=new RegExp(H)),this.formats[$]=H,this}errorsText($=this.errors,{separator:H=", ",dataVar:q="data"}={}){return!$||$.length===0?"No errors":$.map(V=>`${q}${V.instancePath} ${V.message}`).reduce((V,Y)=>V+H+Y)}$dataMetaSchema($,H){const q=this.RULES.all;$=JSON.parse(JSON.stringify($));for(const V of H){const Y=V.split("/").slice(1);let j=$;for(const Q of Y)j=j[Q];for(const Q in q){const ae=q[Q];if(typeof ae!="object")continue;const{$data:re}=ae.definition,ne=j[Q];re&&ne&&(j[Q]=U(ne))}}return $}_removeAllSchemas($,H){for(const q in $){const V=$[q];(!H||H.test(q))&&(typeof V=="string"?delete $[q]:V&&!V.meta&&(this._cache.delete(V.schema),delete $[q]))}}_addSchema($,H,q,V=this.opts.validateSchema,Y=this.opts.addUsedSchema){let j;const{schemaId:Q}=this.opts;if(typeof $=="object")j=$[Q];else{if(this.opts.jtd)throw new Error("schema must be object");if(typeof $!="boolean")throw new Error("schema must be object or boolean")}let ae=this._cache.get($);if(ae!==void 0)return ae;q=(0,l.normalizeId)(j||q);const re=l.getSchemaRefs.call(this,$,q);return ae=new s.SchemaEnv({schema:$,schemaId:Q,meta:H,baseId:q,localRefs:re}),this._cache.set(ae.schema,ae),Y&&!q.startsWith("#")&&(q&&this._checkUnique(q),this.refs[q]=ae),V&&this.validateSchema($,!0),ae}_checkUnique($){if(this.schemas[$]||this.refs[$])throw new Error(`schema with key or id "${$}" already exists`)}_compileSchemaEnv($){if($.meta?this._compileMetaSchema($):s.compileSchema.call(this,$),!$.validate)throw new Error("ajv implementation error");return $.validate}_compileMetaSchema($){const H=this.opts;this.opts=this._metaOpts;try{s.compileSchema.call(this,$)}finally{this.opts=H}}}E.ValidationError=n.default,E.MissingRefError=i.default,t.default=E;function T(B,$,H,q="error"){for(const V in B){const Y=V;Y in $&&this.logger[q](`${H}: option ${V}. ${B[Y]}`)}}function C(B){return B=(0,l.normalizeId)(B),this.schemas[B]||this.refs[B]}function w(){const B=this.opts.schemas;if(B)if(Array.isArray(B))this.addSchema(B);else for(const $ in B)this.addSchema(B[$],$)}function x(){for(const B in this.opts.formats){const $=this.opts.formats[B];$&&this.addFormat(B,$)}}function A(B){if(Array.isArray(B)){this.addVocabulary(B);return}this.logger.warn("keywords option as map is deprecated, pass array");for(const $ in B){const H=B[$];H.keyword||(H.keyword=$),this.addKeyword(H)}}function R(){const B={...this.opts};for(const $ of g)delete B[$];return B}const O={log(){},warn(){},error(){}};function F(B){if(B===!1)return O;if(B===void 0)return console;if(B.log&&B.warn&&B.error)return B;throw new Error("logger must implement log, warn and error methods")}const P=/^[a-z_$][a-z0-9_$:-]*$/i;function N(B,$){const{RULES:H}=this;if((0,d.eachItem)(B,q=>{if(H.keywords[q])throw new Error(`Keyword ${q} is already defined`);if(!P.test(q))throw new Error(`Keyword ${q} has invalid name`)}),!!$&&$.$data&&!("code"in $||"validate"in $))throw new Error('$data keyword must have "code" or "validate" function')}function k(B,$,H){var q;const V=$?.post;if(H&&V)throw new Error('keyword with "post" flag cannot have "type"');const{RULES:Y}=this;let j=V?Y.post:Y.rules.find(({type:ae})=>ae===H);if(j||(j={type:H,rules:[]},Y.rules.push(j)),Y.keywords[B]=!0,!$)return;const Q={keyword:B,definition:{...$,type:(0,u.getJSONTypes)($.type),schemaType:(0,u.getJSONTypes)($.schemaType)}};$.before?M.call(this,j,Q,$.before):j.rules.push(Q),Y.all[B]=Q,(q=$.implements)===null||q===void 0||q.forEach(ae=>this.addKeyword(ae))}function M(B,$,H){const q=B.rules.findIndex(V=>V.keyword===H);q>=0?B.rules.splice(q,0,$):(B.rules.push($),this.logger.warn(`rule ${H} is not defined`))}function L(B){let{metaSchema:$}=B;$!==void 0&&(B.$data&&this.opts.$data&&($=U($)),B.validateSchema=this.compile($,!0))}const I={$ref:"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"};function U(B){return{anyOf:[B,I]}}})(uK)),uK}var aI={},sI={},oI={},wSe;function lIt(){if(wSe)return oI;wSe=1,Object.defineProperty(oI,"__esModule",{value:!0});const t={keyword:"id",code(){throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID')}};return oI.default=t,oI}var G1={},xSe;function cIt(){if(xSe)return G1;xSe=1,Object.defineProperty(G1,"__esModule",{value:!0}),G1.callRef=G1.getValidate=void 0;const t=l$(),e=Pp(),r=Ji(),n=Nv(),i=Uce(),a=wa(),s={keyword:"$ref",schemaType:"string",code(u){const{gen:d,schema:h,it:f}=u,{baseId:p,schemaEnv:g,validateName:m,opts:_,self:v}=f,{root:b}=g;if((h==="#"||h==="#/")&&p===b.baseId)return E();const y=i.resolveRef.call(v,b,p,h);if(y===void 0)throw new t.default(f.opts.uriResolver,p,h);if(y instanceof i.SchemaEnv)return T(y);return C(y);function E(){if(g===b)return l(u,m,g,g.$async);const w=d.scopeValue("root",{ref:b});return l(u,(0,r._)`${w}.validate`,b,b.$async)}function T(w){const x=o(u,w);l(u,x,w,w.$async)}function C(w){const x=d.scopeValue("schema",_.code.source===!0?{ref:w,code:(0,r.stringify)(w)}:{ref:w}),A=d.name("valid"),R=u.subschema({schema:w,dataTypes:[],schemaPath:r.nil,topSchemaRef:x,errSchemaPath:h},A);u.mergeEvaluated(R),u.ok(A)}}};function o(u,d){const{gen:h}=u;return d.validate?h.scopeValue("validate",{ref:d.validate}):(0,r._)`${h.scopeValue("wrapper",{ref:d})}.validate`}G1.getValidate=o;function l(u,d,h,f){const{gen:p,it:g}=u,{allErrors:m,schemaEnv:_,opts:v}=g,b=v.passContext?n.default.this:r.nil;f?y():E();function y(){if(!_.$async)throw new Error("async schema referenced by sync schema");const w=p.let("valid");p.try(()=>{p.code((0,r._)`await ${(0,e.callValidateCode)(u,d,b)}`),C(d),m||p.assign(w,!0)},x=>{p.if((0,r._)`!(${x} instanceof ${g.ValidationError})`,()=>p.throw(x)),T(x),m||p.assign(w,!1)}),u.ok(w)}function E(){u.result((0,e.callValidateCode)(u,d,b),()=>C(d),()=>T(d))}function T(w){const x=(0,r._)`${w}.errors`;p.assign(n.default.vErrors,(0,r._)`${n.default.vErrors} === null ? ${x} : ${n.default.vErrors}.concat(${x})`),p.assign(n.default.errors,(0,r._)`${n.default.vErrors}.length`)}function C(w){var x;if(!g.opts.unevaluated)return;const A=(x=h?.validate)===null||x===void 0?void 0:x.evaluated;if(g.props!==!0)if(A&&!A.dynamicProps)A.props!==void 0&&(g.props=a.mergeEvaluated.props(p,A.props,g.props));else{const R=p.var("props",(0,r._)`${w}.evaluated.props`);g.props=a.mergeEvaluated.props(p,R,g.props,r.Name)}if(g.items!==!0)if(A&&!A.dynamicItems)A.items!==void 0&&(g.items=a.mergeEvaluated.items(p,A.items,g.items));else{const R=p.var("items",(0,r._)`${w}.evaluated.items`);g.items=a.mergeEvaluated.items(p,R,g.items,r.Name)}}}return G1.callRef=l,G1.default=s,G1}var ASe;function uIt(){if(ASe)return sI;ASe=1,Object.defineProperty(sI,"__esModule",{value:!0});const t=lIt(),e=cIt(),r=["$schema","$id","$defs","$vocabulary",{keyword:"$comment"},"definitions",t.default,e.default];return sI.default=r,sI}var lI={},cI={},RSe;function dIt(){if(RSe)return cI;RSe=1,Object.defineProperty(cI,"__esModule",{value:!0});const t=Ji(),e=t.operators,r={maximum:{okStr:"<=",ok:e.LTE,fail:e.GT},minimum:{okStr:">=",ok:e.GTE,fail:e.LT},exclusiveMaximum:{okStr:"<",ok:e.LT,fail:e.GTE},exclusiveMinimum:{okStr:">",ok:e.GT,fail:e.LTE}},n={message:({keyword:a,schemaCode:s})=>(0,t.str)`must be ${r[a].okStr} ${s}`,params:({keyword:a,schemaCode:s})=>(0,t._)`{comparison: ${r[a].okStr}, limit: ${s}}`},i={keyword:Object.keys(r),type:"number",schemaType:"number",$data:!0,error:n,code(a){const{keyword:s,data:o,schemaCode:l}=a;a.fail$data((0,t._)`${o} ${r[s].fail} ${l} || isNaN(${o})`)}};return cI.default=i,cI}var uI={},NSe;function hIt(){if(NSe)return uI;NSe=1,Object.defineProperty(uI,"__esModule",{value:!0});const t=Ji(),r={keyword:"multipleOf",type:"number",schemaType:"number",$data:!0,error:{message:({schemaCode:n})=>(0,t.str)`must be multiple of ${n}`,params:({schemaCode:n})=>(0,t._)`{multipleOf: ${n}}`},code(n){const{gen:i,data:a,schemaCode:s,it:o}=n,l=o.opts.multipleOfPrecision,u=i.let("res"),d=l?(0,t._)`Math.abs(Math.round(${u}) - ${u}) > 1e-${l}`:(0,t._)`${u} !== parseInt(${u})`;n.fail$data((0,t._)`(${s} === 0 || (${u} = ${a}/${s}, ${d}))`)}};return uI.default=r,uI}var dI={},hI={},OSe;function fIt(){if(OSe)return hI;OSe=1,Object.defineProperty(hI,"__esModule",{value:!0});function t(e){const r=e.length;let n=0,i=0,a;for(;i=55296&&a<=56319&&i(0,t._)`{limit: ${a}}`},code(a){const{keyword:s,data:o,schemaCode:l,it:u}=a,d=s==="maxLength"?t.operators.GT:t.operators.LT,h=u.opts.unicode===!1?(0,t._)`${o}.length`:(0,t._)`${(0,e.useFunc)(a.gen,r.default)}(${o})`;a.fail$data((0,t._)`${h} ${d} ${l}`)}};return dI.default=i,dI}var fI={},kSe;function gIt(){if(kSe)return fI;kSe=1,Object.defineProperty(fI,"__esModule",{value:!0});const t=Pp(),e=wa(),r=Ji(),i={keyword:"pattern",type:"string",schemaType:"string",$data:!0,error:{message:({schemaCode:a})=>(0,r.str)`must match pattern "${a}"`,params:({schemaCode:a})=>(0,r._)`{pattern: ${a}}`},code(a){const{gen:s,data:o,$data:l,schema:u,schemaCode:d,it:h}=a,f=h.opts.unicodeRegExp?"u":"";if(l){const{regExp:p}=h.opts.code,g=p.code==="new RegExp"?(0,r._)`new RegExp`:(0,e.useFunc)(s,p),m=s.let("valid");s.try(()=>s.assign(m,(0,r._)`${g}(${d}, ${f}).test(${o})`),()=>s.assign(m,!1)),a.fail$data((0,r._)`!${m}`)}else{const p=(0,t.usePattern)(a,u);a.fail$data((0,r._)`!${p}.test(${o})`)}}};return fI.default=i,fI}var pI={},DSe;function mIt(){if(DSe)return pI;DSe=1,Object.defineProperty(pI,"__esModule",{value:!0});const t=Ji(),r={keyword:["maxProperties","minProperties"],type:"object",schemaType:"number",$data:!0,error:{message({keyword:n,schemaCode:i}){const a=n==="maxProperties"?"more":"fewer";return(0,t.str)`must NOT have ${a} than ${i} properties`},params:({schemaCode:n})=>(0,t._)`{limit: ${n}}`},code(n){const{keyword:i,data:a,schemaCode:s}=n,o=i==="maxProperties"?t.operators.GT:t.operators.LT;n.fail$data((0,t._)`Object.keys(${a}).length ${o} ${s}`)}};return pI.default=r,pI}var gI={},MSe;function _It(){if(MSe)return gI;MSe=1,Object.defineProperty(gI,"__esModule",{value:!0});const t=Pp(),e=Ji(),r=wa(),i={keyword:"required",type:"object",schemaType:"array",$data:!0,error:{message:({params:{missingProperty:a}})=>(0,e.str)`must have required property '${a}'`,params:({params:{missingProperty:a}})=>(0,e._)`{missingProperty: ${a}}`},code(a){const{gen:s,schema:o,schemaCode:l,data:u,$data:d,it:h}=a,{opts:f}=h;if(!d&&o.length===0)return;const p=o.length>=f.loopRequired;if(h.allErrors?g():m(),f.strictRequired){const b=a.parentSchema.properties,{definedProperties:y}=a.it;for(const E of o)if(b?.[E]===void 0&&!y.has(E)){const T=h.schemaEnv.baseId+h.errSchemaPath,C=`required property "${E}" is not defined at "${T}" (strictRequired)`;(0,r.checkStrictMode)(h,C,h.opts.strictRequired)}}function g(){if(p||d)a.block$data(e.nil,_);else for(const b of o)(0,t.checkReportMissingProp)(a,b)}function m(){const b=s.let("missing");if(p||d){const y=s.let("valid",!0);a.block$data(y,()=>v(b,y)),a.ok(y)}else s.if((0,t.checkMissingProp)(a,o,b)),(0,t.reportMissingProp)(a,b),s.else()}function _(){s.forOf("prop",l,b=>{a.setParams({missingProperty:b}),s.if((0,t.noPropertyInData)(s,u,b,f.ownProperties),()=>a.error())})}function v(b,y){a.setParams({missingProperty:b}),s.forOf(b,l,()=>{s.assign(y,(0,t.propertyInData)(s,u,b,f.ownProperties)),s.if((0,e.not)(y),()=>{a.error(),s.break()})},e.nil)}}};return gI.default=i,gI}var mI={},LSe;function vIt(){if(LSe)return mI;LSe=1,Object.defineProperty(mI,"__esModule",{value:!0});const t=Ji(),r={keyword:["maxItems","minItems"],type:"array",schemaType:"number",$data:!0,error:{message({keyword:n,schemaCode:i}){const a=n==="maxItems"?"more":"fewer";return(0,t.str)`must NOT have ${a} than ${i} items`},params:({schemaCode:n})=>(0,t._)`{limit: ${n}}`},code(n){const{keyword:i,data:a,schemaCode:s}=n,o=i==="maxItems"?t.operators.GT:t.operators.LT;n.fail$data((0,t._)`${a}.length ${o} ${s}`)}};return mI.default=r,mI}var _I={},vI={},PSe;function $ce(){if(PSe)return vI;PSe=1,Object.defineProperty(vI,"__esModule",{value:!0});const t=IDe();return t.code='require("ajv/dist/runtime/equal").default',vI.default=t,vI}var FSe;function yIt(){if(FSe)return _I;FSe=1,Object.defineProperty(_I,"__esModule",{value:!0});const t=cP(),e=Ji(),r=wa(),n=$ce(),a={keyword:"uniqueItems",type:"array",schemaType:"boolean",$data:!0,error:{message:({params:{i:s,j:o}})=>(0,e.str)`must NOT have duplicate items (items ## ${o} and ${s} are identical)`,params:({params:{i:s,j:o}})=>(0,e._)`{i: ${s}, j: ${o}}`},code(s){const{gen:o,data:l,$data:u,schema:d,parentSchema:h,schemaCode:f,it:p}=s;if(!u&&!d)return;const g=o.let("valid"),m=h.items?(0,t.getSchemaTypes)(h.items):[];s.block$data(g,_,(0,e._)`${f} === false`),s.ok(g);function _(){const E=o.let("i",(0,e._)`${l}.length`),T=o.let("j");s.setParams({i:E,j:T}),o.assign(g,!0),o.if((0,e._)`${E} > 1`,()=>(v()?b:y)(E,T))}function v(){return m.length>0&&!m.some(E=>E==="object"||E==="array")}function b(E,T){const C=o.name("item"),w=(0,t.checkDataTypes)(m,C,p.opts.strictNumbers,t.DataType.Wrong),x=o.const("indices",(0,e._)`{}`);o.for((0,e._)`;${E}--;`,()=>{o.let(C,(0,e._)`${l}[${E}]`),o.if(w,(0,e._)`continue`),m.length>1&&o.if((0,e._)`typeof ${C} == "string"`,(0,e._)`${C} += "_"`),o.if((0,e._)`typeof ${x}[${C}] == "number"`,()=>{o.assign(T,(0,e._)`${x}[${C}]`),s.error(),o.assign(g,!1).break()}).code((0,e._)`${x}[${C}] = ${E}`)})}function y(E,T){const C=(0,r.useFunc)(o,n.default),w=o.name("outer");o.label(w).for((0,e._)`;${E}--;`,()=>o.for((0,e._)`${T} = ${E}; ${T}--;`,()=>o.if((0,e._)`${C}(${l}[${E}], ${l}[${T}])`,()=>{s.error(),o.assign(g,!1).break(w)})))}}};return _I.default=a,_I}var yI={},BSe;function bIt(){if(BSe)return yI;BSe=1,Object.defineProperty(yI,"__esModule",{value:!0});const t=Ji(),e=wa(),r=$ce(),i={keyword:"const",$data:!0,error:{message:"must be equal to constant",params:({schemaCode:a})=>(0,t._)`{allowedValue: ${a}}`},code(a){const{gen:s,data:o,$data:l,schemaCode:u,schema:d}=a;l||d&&typeof d=="object"?a.fail$data((0,t._)`!${(0,e.useFunc)(s,r.default)}(${o}, ${u})`):a.fail((0,t._)`${d} !== ${o}`)}};return yI.default=i,yI}var bI={},USe;function SIt(){if(USe)return bI;USe=1,Object.defineProperty(bI,"__esModule",{value:!0});const t=Ji(),e=wa(),r=$ce(),i={keyword:"enum",schemaType:"array",$data:!0,error:{message:"must be equal to one of the allowed values",params:({schemaCode:a})=>(0,t._)`{allowedValues: ${a}}`},code(a){const{gen:s,data:o,$data:l,schema:u,schemaCode:d,it:h}=a;if(!l&&u.length===0)throw new Error("enum must have non-empty array");const f=u.length>=h.opts.loopEnum;let p;const g=()=>p??(p=(0,e.useFunc)(s,r.default));let m;if(f||l)m=s.let("valid"),a.block$data(m,_);else{if(!Array.isArray(u))throw new Error("ajv implementation error");const b=s.const("vSchema",d);m=(0,t.or)(...u.map((y,E)=>v(b,E)))}a.pass(m);function _(){s.assign(m,!1),s.forOf("v",d,b=>s.if((0,t._)`${g()}(${o}, ${b})`,()=>s.assign(m,!0).break()))}function v(b,y){const E=u[y];return typeof E=="object"&&E!==null?(0,t._)`${g()}(${o}, ${b}[${y}])`:(0,t._)`${o} === ${E}`}}};return bI.default=i,bI}var $Se;function EIt(){if($Se)return lI;$Se=1,Object.defineProperty(lI,"__esModule",{value:!0});const t=dIt(),e=hIt(),r=pIt(),n=gIt(),i=mIt(),a=_It(),s=vIt(),o=yIt(),l=bIt(),u=SIt(),d=[t.default,e.default,r.default,n.default,i.default,a.default,s.default,o.default,{keyword:"type",schemaType:["string","array"]},{keyword:"nullable",schemaType:"boolean"},l.default,u.default];return lI.default=d,lI}var SI={},JS={},GSe;function DDe(){if(GSe)return JS;GSe=1,Object.defineProperty(JS,"__esModule",{value:!0}),JS.validateAdditionalItems=void 0;const t=Ji(),e=wa(),n={keyword:"additionalItems",type:"array",schemaType:["boolean","object"],before:"uniqueItems",error:{message:({params:{len:a}})=>(0,t.str)`must NOT have more than ${a} items`,params:({params:{len:a}})=>(0,t._)`{limit: ${a}}`},code(a){const{parentSchema:s,it:o}=a,{items:l}=s;if(!Array.isArray(l)){(0,e.checkStrictMode)(o,'"additionalItems" is ignored when "items" is not an array of schemas');return}i(a,l)}};function i(a,s){const{gen:o,schema:l,data:u,keyword:d,it:h}=a;h.items=!0;const f=o.const("len",(0,t._)`${u}.length`);if(l===!1)a.setParams({len:s.length}),a.pass((0,t._)`${f} <= ${s.length}`);else if(typeof l=="object"&&!(0,e.alwaysValidSchema)(h,l)){const g=o.var("valid",(0,t._)`${f} <= ${s.length}`);o.if((0,t.not)(g),()=>p(g)),a.ok(g)}function p(g){o.forRange("i",s.length,f,m=>{a.subschema({keyword:d,dataProp:m,dataPropType:e.Type.Num},g),h.allErrors||o.if((0,t.not)(g),()=>o.break())})}}return JS.validateAdditionalItems=i,JS.default=n,JS}var EI={},eE={},zSe;function MDe(){if(zSe)return eE;zSe=1,Object.defineProperty(eE,"__esModule",{value:!0}),eE.validateTuple=void 0;const t=Ji(),e=wa(),r=Pp(),n={keyword:"items",type:"array",schemaType:["object","array","boolean"],before:"uniqueItems",code(a){const{schema:s,it:o}=a;if(Array.isArray(s))return i(a,"additionalItems",s);o.items=!0,!(0,e.alwaysValidSchema)(o,s)&&a.ok((0,r.validateArray)(a))}};function i(a,s,o=a.schema){const{gen:l,parentSchema:u,data:d,keyword:h,it:f}=a;m(u),f.opts.unevaluated&&o.length&&f.items!==!0&&(f.items=e.mergeEvaluated.items(l,o.length,f.items));const p=l.name("valid"),g=l.const("len",(0,t._)`${d}.length`);o.forEach((_,v)=>{(0,e.alwaysValidSchema)(f,_)||(l.if((0,t._)`${g} > ${v}`,()=>a.subschema({keyword:h,schemaProp:v,dataProp:v},p)),a.ok(p))});function m(_){const{opts:v,errSchemaPath:b}=f,y=o.length,E=y===_.minItems&&(y===_.maxItems||_[s]===!1);if(v.strictTuples&&!E){const T=`"${h}" is ${y}-tuple, but minItems or maxItems/${s} are not specified or different at path "${b}"`;(0,e.checkStrictMode)(f,T,v.strictTuples)}}}return eE.validateTuple=i,eE.default=n,eE}var qSe;function TIt(){if(qSe)return EI;qSe=1,Object.defineProperty(EI,"__esModule",{value:!0});const t=MDe(),e={keyword:"prefixItems",type:"array",schemaType:["array"],before:"uniqueItems",code:r=>(0,t.validateTuple)(r,"items")};return EI.default=e,EI}var TI={},HSe;function CIt(){if(HSe)return TI;HSe=1,Object.defineProperty(TI,"__esModule",{value:!0});const t=Ji(),e=wa(),r=Pp(),n=DDe(),a={keyword:"items",type:"array",schemaType:["object","boolean"],before:"uniqueItems",error:{message:({params:{len:s}})=>(0,t.str)`must NOT have more than ${s} items`,params:({params:{len:s}})=>(0,t._)`{limit: ${s}}`},code(s){const{schema:o,parentSchema:l,it:u}=s,{prefixItems:d}=l;u.items=!0,!(0,e.alwaysValidSchema)(u,o)&&(d?(0,n.validateAdditionalItems)(s,d):s.ok((0,r.validateArray)(s)))}};return TI.default=a,TI}var CI={},VSe;function wIt(){if(VSe)return CI;VSe=1,Object.defineProperty(CI,"__esModule",{value:!0});const t=Ji(),e=wa(),n={keyword:"contains",type:"array",schemaType:["object","boolean"],before:"uniqueItems",trackErrors:!0,error:{message:({params:{min:i,max:a}})=>a===void 0?(0,t.str)`must contain at least ${i} valid item(s)`:(0,t.str)`must contain at least ${i} and no more than ${a} valid item(s)`,params:({params:{min:i,max:a}})=>a===void 0?(0,t._)`{minContains: ${i}}`:(0,t._)`{minContains: ${i}, maxContains: ${a}}`},code(i){const{gen:a,schema:s,parentSchema:o,data:l,it:u}=i;let d,h;const{minContains:f,maxContains:p}=o;u.opts.next?(d=f===void 0?1:f,h=p):d=1;const g=a.const("len",(0,t._)`${l}.length`);if(i.setParams({min:d,max:h}),h===void 0&&d===0){(0,e.checkStrictMode)(u,'"minContains" == 0 without "maxContains": "contains" keyword ignored');return}if(h!==void 0&&d>h){(0,e.checkStrictMode)(u,'"minContains" > "maxContains" is always invalid'),i.fail();return}if((0,e.alwaysValidSchema)(u,s)){let y=(0,t._)`${g} >= ${d}`;h!==void 0&&(y=(0,t._)`${y} && ${g} <= ${h}`),i.pass(y);return}u.items=!0;const m=a.name("valid");h===void 0&&d===1?v(m,()=>a.if(m,()=>a.break())):d===0?(a.let(m,!0),h!==void 0&&a.if((0,t._)`${l}.length > 0`,_)):(a.let(m,!1),_()),i.result(m,()=>i.reset());function _(){const y=a.name("_valid"),E=a.let("count",0);v(y,()=>a.if(y,()=>b(E)))}function v(y,E){a.forRange("i",0,g,T=>{i.subschema({keyword:"contains",dataProp:T,dataPropType:e.Type.Num,compositeRule:!0},y),E()})}function b(y){a.code((0,t._)`${y}++`),h===void 0?a.if((0,t._)`${y} >= ${d}`,()=>a.assign(m,!0).break()):(a.if((0,t._)`${y} > ${h}`,()=>a.assign(m,!1).break()),d===1?a.assign(m,!0):a.if((0,t._)`${y} >= ${d}`,()=>a.assign(m,!0)))}}};return CI.default=n,CI}var yK={},YSe;function xIt(){return YSe||(YSe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.validateSchemaDeps=t.validatePropertyDeps=t.error=void 0;const e=Ji(),r=wa(),n=Pp();t.error={message:({params:{property:l,depsCount:u,deps:d}})=>{const h=u===1?"property":"properties";return(0,e.str)`must have ${h} ${d} when property ${l} is present`},params:({params:{property:l,depsCount:u,deps:d,missingProperty:h}})=>(0,e._)`{property: ${l}, + missingProperty: ${h}, + depsCount: ${u}, + deps: ${d}}`};const i={keyword:"dependencies",type:"object",schemaType:"object",error:t.error,code(l){const[u,d]=a(l);s(l,u),o(l,d)}};function a({schema:l}){const u={},d={};for(const h in l){if(h==="__proto__")continue;const f=Array.isArray(l[h])?u:d;f[h]=l[h]}return[u,d]}function s(l,u=l.schema){const{gen:d,data:h,it:f}=l;if(Object.keys(u).length===0)return;const p=d.let("missing");for(const g in u){const m=u[g];if(m.length===0)continue;const _=(0,n.propertyInData)(d,h,g,f.opts.ownProperties);l.setParams({property:g,depsCount:m.length,deps:m.join(", ")}),f.allErrors?d.if(_,()=>{for(const v of m)(0,n.checkReportMissingProp)(l,v)}):(d.if((0,e._)`${_} && (${(0,n.checkMissingProp)(l,m,p)})`),(0,n.reportMissingProp)(l,p),d.else())}}t.validatePropertyDeps=s;function o(l,u=l.schema){const{gen:d,data:h,keyword:f,it:p}=l,g=d.name("valid");for(const m in u)(0,r.alwaysValidSchema)(p,u[m])||(d.if((0,n.propertyInData)(d,h,m,p.opts.ownProperties),()=>{const _=l.subschema({keyword:f,schemaProp:m},g);l.mergeValidEvaluated(_,g)},()=>d.var(g,!0)),l.ok(g))}t.validateSchemaDeps=o,t.default=i})(yK)),yK}var wI={},WSe;function AIt(){if(WSe)return wI;WSe=1,Object.defineProperty(wI,"__esModule",{value:!0});const t=Ji(),e=wa(),n={keyword:"propertyNames",type:"object",schemaType:["object","boolean"],error:{message:"property name must be valid",params:({params:i})=>(0,t._)`{propertyName: ${i.propertyName}}`},code(i){const{gen:a,schema:s,data:o,it:l}=i;if((0,e.alwaysValidSchema)(l,s))return;const u=a.name("valid");a.forIn("key",o,d=>{i.setParams({propertyName:d}),i.subschema({keyword:"propertyNames",data:d,dataTypes:["string"],propertyName:d,compositeRule:!0},u),a.if((0,t.not)(u),()=>{i.error(!0),l.allErrors||a.break()})}),i.ok(u)}};return wI.default=n,wI}var xI={},KSe;function LDe(){if(KSe)return xI;KSe=1,Object.defineProperty(xI,"__esModule",{value:!0});const t=Pp(),e=Ji(),r=Nv(),n=wa(),a={keyword:"additionalProperties",type:["object"],schemaType:["boolean","object"],allowUndefined:!0,trackErrors:!0,error:{message:"must NOT have additional properties",params:({params:s})=>(0,e._)`{additionalProperty: ${s.additionalProperty}}`},code(s){const{gen:o,schema:l,parentSchema:u,data:d,errsCount:h,it:f}=s;if(!h)throw new Error("ajv implementation error");const{allErrors:p,opts:g}=f;if(f.props=!0,g.removeAdditional!=="all"&&(0,n.alwaysValidSchema)(f,l))return;const m=(0,t.allSchemaProperties)(u.properties),_=(0,t.allSchemaProperties)(u.patternProperties);v(),s.ok((0,e._)`${h} === ${r.default.errors}`);function v(){o.forIn("key",d,C=>{!m.length&&!_.length?E(C):o.if(b(C),()=>E(C))})}function b(C){let w;if(m.length>8){const x=(0,n.schemaRefOrVal)(f,u.properties,"properties");w=(0,t.isOwnProperty)(o,x,C)}else m.length?w=(0,e.or)(...m.map(x=>(0,e._)`${C} === ${x}`)):w=e.nil;return _.length&&(w=(0,e.or)(w,..._.map(x=>(0,e._)`${(0,t.usePattern)(s,x)}.test(${C})`))),(0,e.not)(w)}function y(C){o.code((0,e._)`delete ${d}[${C}]`)}function E(C){if(g.removeAdditional==="all"||g.removeAdditional&&l===!1){y(C);return}if(l===!1){s.setParams({additionalProperty:C}),s.error(),p||o.break();return}if(typeof l=="object"&&!(0,n.alwaysValidSchema)(f,l)){const w=o.name("valid");g.removeAdditional==="failing"?(T(C,w,!1),o.if((0,e.not)(w),()=>{s.reset(),y(C)})):(T(C,w),p||o.if((0,e.not)(w),()=>o.break()))}}function T(C,w,x){const A={keyword:"additionalProperties",dataProp:C,dataPropType:n.Type.Str};x===!1&&Object.assign(A,{compositeRule:!0,createErrors:!1,allErrors:!1}),s.subschema(A,w)}}};return xI.default=a,xI}var AI={},jSe;function RIt(){if(jSe)return AI;jSe=1,Object.defineProperty(AI,"__esModule",{value:!0});const t=o$(),e=Pp(),r=wa(),n=LDe(),i={keyword:"properties",type:"object",schemaType:"object",code(a){const{gen:s,schema:o,parentSchema:l,data:u,it:d}=a;d.opts.removeAdditional==="all"&&l.additionalProperties===void 0&&n.default.code(new t.KeywordCxt(d,n.default,"additionalProperties"));const h=(0,e.allSchemaProperties)(o);for(const _ of h)d.definedProperties.add(_);d.opts.unevaluated&&h.length&&d.props!==!0&&(d.props=r.mergeEvaluated.props(s,(0,r.toHash)(h),d.props));const f=h.filter(_=>!(0,r.alwaysValidSchema)(d,o[_]));if(f.length===0)return;const p=s.name("valid");for(const _ of f)g(_)?m(_):(s.if((0,e.propertyInData)(s,u,_,d.opts.ownProperties)),m(_),d.allErrors||s.else().var(p,!0),s.endIf()),a.it.definedProperties.add(_),a.ok(p);function g(_){return d.opts.useDefaults&&!d.compositeRule&&o[_].default!==void 0}function m(_){a.subschema({keyword:"properties",schemaProp:_,dataProp:_},p)}}};return AI.default=i,AI}var RI={},XSe;function NIt(){if(XSe)return RI;XSe=1,Object.defineProperty(RI,"__esModule",{value:!0});const t=Pp(),e=Ji(),r=wa(),n=wa(),i={keyword:"patternProperties",type:"object",schemaType:"object",code(a){const{gen:s,schema:o,data:l,parentSchema:u,it:d}=a,{opts:h}=d,f=(0,t.allSchemaProperties)(o),p=f.filter(E=>(0,r.alwaysValidSchema)(d,o[E]));if(f.length===0||p.length===f.length&&(!d.opts.unevaluated||d.props===!0))return;const g=h.strictSchema&&!h.allowMatchingProperties&&u.properties,m=s.name("valid");d.props!==!0&&!(d.props instanceof e.Name)&&(d.props=(0,n.evaluatedPropsToName)(s,d.props));const{props:_}=d;v();function v(){for(const E of f)g&&b(E),d.allErrors?y(E):(s.var(m,!0),y(E),s.if(m))}function b(E){for(const T in g)new RegExp(E).test(T)&&(0,r.checkStrictMode)(d,`property ${T} matches pattern ${E} (use allowMatchingProperties)`)}function y(E){s.forIn("key",l,T=>{s.if((0,e._)`${(0,t.usePattern)(a,E)}.test(${T})`,()=>{const C=p.includes(E);C||a.subschema({keyword:"patternProperties",schemaProp:E,dataProp:T,dataPropType:n.Type.Str},m),d.opts.unevaluated&&_!==!0?s.assign((0,e._)`${_}[${T}]`,!0):!C&&!d.allErrors&&s.if((0,e.not)(m),()=>s.break())})})}}};return RI.default=i,RI}var NI={},QSe;function OIt(){if(QSe)return NI;QSe=1,Object.defineProperty(NI,"__esModule",{value:!0});const t=wa(),e={keyword:"not",schemaType:["object","boolean"],trackErrors:!0,code(r){const{gen:n,schema:i,it:a}=r;if((0,t.alwaysValidSchema)(a,i)){r.fail();return}const s=n.name("valid");r.subschema({keyword:"not",compositeRule:!0,createErrors:!1,allErrors:!1},s),r.failResult(s,()=>r.reset(),()=>r.error())},error:{message:"must NOT be valid"}};return NI.default=e,NI}var OI={},ZSe;function IIt(){if(ZSe)return OI;ZSe=1,Object.defineProperty(OI,"__esModule",{value:!0});const e={keyword:"anyOf",schemaType:"array",trackErrors:!0,code:Pp().validateUnion,error:{message:"must match a schema in anyOf"}};return OI.default=e,OI}var II={},JSe;function kIt(){if(JSe)return II;JSe=1,Object.defineProperty(II,"__esModule",{value:!0});const t=Ji(),e=wa(),n={keyword:"oneOf",schemaType:"array",trackErrors:!0,error:{message:"must match exactly one schema in oneOf",params:({params:i})=>(0,t._)`{passingSchemas: ${i.passing}}`},code(i){const{gen:a,schema:s,parentSchema:o,it:l}=i;if(!Array.isArray(s))throw new Error("ajv implementation error");if(l.opts.discriminator&&o.discriminator)return;const u=s,d=a.let("valid",!1),h=a.let("passing",null),f=a.name("_valid");i.setParams({passing:h}),a.block(p),i.result(d,()=>i.reset(),()=>i.error(!0));function p(){u.forEach((g,m)=>{let _;(0,e.alwaysValidSchema)(l,g)?a.var(f,!0):_=i.subschema({keyword:"oneOf",schemaProp:m,compositeRule:!0},f),m>0&&a.if((0,t._)`${f} && ${d}`).assign(d,!1).assign(h,(0,t._)`[${h}, ${m}]`).else(),a.if(f,()=>{a.assign(d,!0),a.assign(h,m),_&&i.mergeEvaluated(_,t.Name)})})}}};return II.default=n,II}var kI={},eEe;function DIt(){if(eEe)return kI;eEe=1,Object.defineProperty(kI,"__esModule",{value:!0});const t=wa(),e={keyword:"allOf",schemaType:"array",code(r){const{gen:n,schema:i,it:a}=r;if(!Array.isArray(i))throw new Error("ajv implementation error");const s=n.name("valid");i.forEach((o,l)=>{if((0,t.alwaysValidSchema)(a,o))return;const u=r.subschema({keyword:"allOf",schemaProp:l},s);r.ok(s),r.mergeEvaluated(u)})}};return kI.default=e,kI}var DI={},tEe;function MIt(){if(tEe)return DI;tEe=1,Object.defineProperty(DI,"__esModule",{value:!0});const t=Ji(),e=wa(),n={keyword:"if",schemaType:["object","boolean"],trackErrors:!0,error:{message:({params:a})=>(0,t.str)`must match "${a.ifClause}" schema`,params:({params:a})=>(0,t._)`{failingKeyword: ${a.ifClause}}`},code(a){const{gen:s,parentSchema:o,it:l}=a;o.then===void 0&&o.else===void 0&&(0,e.checkStrictMode)(l,'"if" without "then" and "else" is ignored');const u=i(l,"then"),d=i(l,"else");if(!u&&!d)return;const h=s.let("valid",!0),f=s.name("_valid");if(p(),a.reset(),u&&d){const m=s.let("ifClause");a.setParams({ifClause:m}),s.if(f,g("then",m),g("else",m))}else u?s.if(f,g("then")):s.if((0,t.not)(f),g("else"));a.pass(h,()=>a.error(!0));function p(){const m=a.subschema({keyword:"if",compositeRule:!0,createErrors:!1,allErrors:!1},f);a.mergeEvaluated(m)}function g(m,_){return()=>{const v=a.subschema({keyword:m},f);s.assign(h,f),a.mergeValidEvaluated(v,h),_?s.assign(_,(0,t._)`${m}`):a.setParams({ifClause:m})}}}};function i(a,s){const o=a.schema[s];return o!==void 0&&!(0,e.alwaysValidSchema)(a,o)}return DI.default=n,DI}var MI={},rEe;function LIt(){if(rEe)return MI;rEe=1,Object.defineProperty(MI,"__esModule",{value:!0});const t=wa(),e={keyword:["then","else"],schemaType:["object","boolean"],code({keyword:r,parentSchema:n,it:i}){n.if===void 0&&(0,t.checkStrictMode)(i,`"${r}" without "if" is ignored`)}};return MI.default=e,MI}var nEe;function PIt(){if(nEe)return SI;nEe=1,Object.defineProperty(SI,"__esModule",{value:!0});const t=DDe(),e=TIt(),r=MDe(),n=CIt(),i=wIt(),a=xIt(),s=AIt(),o=LDe(),l=RIt(),u=NIt(),d=OIt(),h=IIt(),f=kIt(),p=DIt(),g=MIt(),m=LIt();function _(v=!1){const b=[d.default,h.default,f.default,p.default,g.default,m.default,s.default,o.default,a.default,l.default,u.default];return v?b.push(e.default,n.default):b.push(t.default,r.default),b.push(i.default),b}return SI.default=_,SI}var LI={},PI={},iEe;function FIt(){if(iEe)return PI;iEe=1,Object.defineProperty(PI,"__esModule",{value:!0});const t=Ji(),r={keyword:"format",type:["number","string"],schemaType:"string",$data:!0,error:{message:({schemaCode:n})=>(0,t.str)`must match format "${n}"`,params:({schemaCode:n})=>(0,t._)`{format: ${n}}`},code(n,i){const{gen:a,data:s,$data:o,schema:l,schemaCode:u,it:d}=n,{opts:h,errSchemaPath:f,schemaEnv:p,self:g}=d;if(!h.validateFormats)return;o?m():_();function m(){const v=a.scopeValue("formats",{ref:g.formats,code:h.code.formats}),b=a.const("fDef",(0,t._)`${v}[${u}]`),y=a.let("fType"),E=a.let("format");a.if((0,t._)`typeof ${b} == "object" && !(${b} instanceof RegExp)`,()=>a.assign(y,(0,t._)`${b}.type || "string"`).assign(E,(0,t._)`${b}.validate`),()=>a.assign(y,(0,t._)`"string"`).assign(E,b)),n.fail$data((0,t.or)(T(),C()));function T(){return h.strictSchema===!1?t.nil:(0,t._)`${u} && !${E}`}function C(){const w=p.$async?(0,t._)`(${b}.async ? await ${E}(${s}) : ${E}(${s}))`:(0,t._)`${E}(${s})`,x=(0,t._)`(typeof ${E} == "function" ? ${w} : ${E}.test(${s}))`;return(0,t._)`${E} && ${E} !== true && ${y} === ${i} && !${x}`}}function _(){const v=g.formats[l];if(!v){T();return}if(v===!0)return;const[b,y,E]=C(v);b===i&&n.pass(w());function T(){if(h.strictSchema===!1){g.logger.warn(x());return}throw new Error(x());function x(){return`unknown format "${l}" ignored in schema at path "${f}"`}}function C(x){const A=x instanceof RegExp?(0,t.regexpCode)(x):h.code.formats?(0,t._)`${h.code.formats}${(0,t.getProperty)(l)}`:void 0,R=a.scopeValue("formats",{key:l,ref:x,code:A});return typeof x=="object"&&!(x instanceof RegExp)?[x.type||"string",x.validate,(0,t._)`${R}.validate`]:["string",x,R]}function w(){if(typeof v=="object"&&!(v instanceof RegExp)&&v.async){if(!p.$async)throw new Error("async format in sync schema");return(0,t._)`await ${E}(${s})`}return typeof y=="function"?(0,t._)`${E}(${s})`:(0,t._)`${E}.test(${s})`}}}};return PI.default=r,PI}var aEe;function BIt(){if(aEe)return LI;aEe=1,Object.defineProperty(LI,"__esModule",{value:!0});const e=[FIt().default];return LI.default=e,LI}var oy={},sEe;function UIt(){return sEe||(sEe=1,Object.defineProperty(oy,"__esModule",{value:!0}),oy.contentVocabulary=oy.metadataVocabulary=void 0,oy.metadataVocabulary=["title","description","default","deprecated","readOnly","writeOnly","examples"],oy.contentVocabulary=["contentMediaType","contentEncoding","contentSchema"]),oy}var oEe;function $It(){if(oEe)return aI;oEe=1,Object.defineProperty(aI,"__esModule",{value:!0});const t=uIt(),e=EIt(),r=PIt(),n=BIt(),i=UIt(),a=[t.default,e.default,(0,r.default)(),n.default,i.metadataVocabulary,i.contentVocabulary];return aI.default=a,aI}var FI={},RA={},lEe;function GIt(){if(lEe)return RA;lEe=1,Object.defineProperty(RA,"__esModule",{value:!0}),RA.DiscrError=void 0;var t;return(function(e){e.Tag="tag",e.Mapping="mapping"})(t||(RA.DiscrError=t={})),RA}var cEe;function zIt(){if(cEe)return FI;cEe=1,Object.defineProperty(FI,"__esModule",{value:!0});const t=Ji(),e=GIt(),r=Uce(),n=l$(),i=wa(),s={keyword:"discriminator",type:"object",schemaType:"object",error:{message:({params:{discrError:o,tagName:l}})=>o===e.DiscrError.Tag?`tag "${l}" must be string`:`value of tag "${l}" must be in oneOf`,params:({params:{discrError:o,tag:l,tagName:u}})=>(0,t._)`{error: ${o}, tag: ${u}, tagValue: ${l}}`},code(o){const{gen:l,data:u,schema:d,parentSchema:h,it:f}=o,{oneOf:p}=h;if(!f.opts.discriminator)throw new Error("discriminator: requires discriminator option");const g=d.propertyName;if(typeof g!="string")throw new Error("discriminator: requires propertyName");if(d.mapping)throw new Error("discriminator: mapping is not supported");if(!p)throw new Error("discriminator: requires oneOf keyword");const m=l.let("valid",!1),_=l.const("tag",(0,t._)`${u}${(0,t.getProperty)(g)}`);l.if((0,t._)`typeof ${_} == "string"`,()=>v(),()=>o.error(!1,{discrError:e.DiscrError.Tag,tag:_,tagName:g})),o.ok(m);function v(){const E=y();l.if(!1);for(const T in E)l.elseIf((0,t._)`${_} === ${T}`),l.assign(m,b(E[T]));l.else(),o.error(!1,{discrError:e.DiscrError.Mapping,tag:_,tagName:g}),l.endIf()}function b(E){const T=l.name("valid"),C=o.subschema({keyword:"oneOf",schemaProp:E},T);return o.mergeEvaluated(C,t.Name),T}function y(){var E;const T={},C=x(h);let w=!0;for(let O=0;Othis.addVocabulary(g)),this.opts.discriminator&&this.addKeyword(i.default)}_addDefaultMetaSchema(){if(super._addDefaultMetaSchema(),!this.opts.meta)return;const g=this.opts.$data?this.$dataMetaSchema(a,s):a;this.addMetaSchema(g,o,!1),this.refs["http://json-schema.org/schema"]=o}defaultMeta(){return this.opts.defaultMeta=super.defaultMeta()||(this.getSchema(o)?o:void 0)}}e.Ajv=l,t.exports=e=l,t.exports.Ajv=l,Object.defineProperty(e,"__esModule",{value:!0}),e.default=l;var u=o$();Object.defineProperty(e,"KeywordCxt",{enumerable:!0,get:function(){return u.KeywordCxt}});var d=Ji();Object.defineProperty(e,"_",{enumerable:!0,get:function(){return d._}}),Object.defineProperty(e,"str",{enumerable:!0,get:function(){return d.str}}),Object.defineProperty(e,"stringify",{enumerable:!0,get:function(){return d.stringify}}),Object.defineProperty(e,"nil",{enumerable:!0,get:function(){return d.nil}}),Object.defineProperty(e,"Name",{enumerable:!0,get:function(){return d.Name}}),Object.defineProperty(e,"CodeGen",{enumerable:!0,get:function(){return d.CodeGen}});var h=Bce();Object.defineProperty(e,"ValidationError",{enumerable:!0,get:function(){return h.default}});var f=l$();Object.defineProperty(e,"MissingRefError",{enumerable:!0,get:function(){return f.default}})})(eI,eI.exports)),eI.exports}var XIt=PDe();const QIt=kd(XIt);var BI={exports:{}},bK={},dEe;function ZIt(){return dEe||(dEe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.formatNames=t.fastFormats=t.fullFormats=void 0;function e(O,F){return{validate:O,compare:F}}t.fullFormats={date:e(a,s),time:e(l(!0),u),"date-time":e(f(!0),p),"iso-time":e(l(),d),"iso-date-time":e(f(),g),duration:/^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,uri:v,"uri-reference":/^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,"uri-template":/^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,url:/^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,email:/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,hostname:/^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,ipv4:/^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,ipv6:/^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,regex:R,uuid:/^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,"json-pointer":/^(?:\/(?:[^~/]|~0|~1)*)*$/,"json-pointer-uri-fragment":/^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,"relative-json-pointer":/^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,byte:y,int32:{type:"number",validate:C},int64:{type:"number",validate:w},float:{type:"number",validate:x},double:{type:"number",validate:x},password:!0,binary:!0},t.fastFormats={...t.fullFormats,date:e(/^\d\d\d\d-[0-1]\d-[0-3]\d$/,s),time:e(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,u),"date-time":e(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,p),"iso-time":e(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,d),"iso-date-time":e(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,g),uri:/^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,"uri-reference":/^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,email:/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i},t.formatNames=Object.keys(t.fullFormats);function r(O){return O%4===0&&(O%100!==0||O%400===0)}const n=/^(\d\d\d\d)-(\d\d)-(\d\d)$/,i=[0,31,28,31,30,31,30,31,31,30,31,30,31];function a(O){const F=n.exec(O);if(!F)return!1;const P=+F[1],N=+F[2],k=+F[3];return N>=1&&N<=12&&k>=1&&k<=(N===2&&r(P)?29:i[N])}function s(O,F){if(O&&F)return O>F?1:O23||$>59||O&&!I)return!1;if(k<=23&&M<=59&&L<60)return!0;const H=M-$*U,q=k-B*U-(H<0?1:0);return(q===23||q===-1)&&(H===59||H===-1)&&L<61}}function u(O,F){if(!(O&&F))return;const P=new Date("2020-01-01T"+O).valueOf(),N=new Date("2020-01-01T"+F).valueOf();if(P&&N)return P-N}function d(O,F){if(!(O&&F))return;const P=o.exec(O),N=o.exec(F);if(P&&N)return O=P[1]+P[2]+P[3],F=N[1]+N[2]+N[3],O>F?1:O=E}function w(O){return Number.isInteger(O)}function x(){return!0}const A=/[^\\]\\Z/;function R(O){if(A.test(O))return!1;try{return new RegExp(O),!0}catch{return!1}}})(bK)),bK}var SK={},hEe;function JIt(){return hEe||(hEe=1,(function(t){Object.defineProperty(t,"__esModule",{value:!0}),t.formatLimitDefinition=void 0;const e=PDe(),r=Ji(),n=r.operators,i={formatMaximum:{okStr:"<=",ok:n.LTE,fail:n.GT},formatMinimum:{okStr:">=",ok:n.GTE,fail:n.LT},formatExclusiveMaximum:{okStr:"<",ok:n.LT,fail:n.GTE},formatExclusiveMinimum:{okStr:">",ok:n.GT,fail:n.LTE}},a={message:({keyword:o,schemaCode:l})=>(0,r.str)`should be ${i[o].okStr} ${l}`,params:({keyword:o,schemaCode:l})=>(0,r._)`{comparison: ${i[o].okStr}, limit: ${l}}`};t.formatLimitDefinition={keyword:Object.keys(i),type:"string",schemaType:"string",$data:!0,error:a,code(o){const{gen:l,data:u,schemaCode:d,keyword:h,it:f}=o,{opts:p,self:g}=f;if(!p.validateFormats)return;const m=new e.KeywordCxt(f,g.RULES.all.format.definition,"format");m.$data?_():v();function _(){const y=l.scopeValue("formats",{ref:g.formats,code:p.code.formats}),E=l.const("fmt",(0,r._)`${y}[${m.schemaCode}]`);o.fail$data((0,r.or)((0,r._)`typeof ${E} != "object"`,(0,r._)`${E} instanceof RegExp`,(0,r._)`typeof ${E}.compare != "function"`,b(E)))}function v(){const y=m.schema,E=g.formats[y];if(!E||E===!0)return;if(typeof E!="object"||E instanceof RegExp||typeof E.compare!="function")throw new Error(`"${h}": format "${y}" does not define "compare" function`);const T=l.scopeValue("formats",{key:y,ref:E,code:p.code.formats?(0,r._)`${p.code.formats}${(0,r.getProperty)(y)}`:void 0});o.fail$data(b(T))}function b(y){return(0,r._)`${y}.compare(${u}, ${d}) ${i[h].fail} 0`}},dependencies:["format"]};const s=o=>(o.addKeyword(t.formatLimitDefinition),o);t.default=s})(SK)),SK}var fEe;function ekt(){return fEe||(fEe=1,(function(t,e){Object.defineProperty(e,"__esModule",{value:!0});const r=ZIt(),n=JIt(),i=Ji(),a=new i.Name("fullFormats"),s=new i.Name("fastFormats"),o=(u,d={keywords:!0})=>{if(Array.isArray(d))return l(u,d,r.fullFormats,a),u;const[h,f]=d.mode==="fast"?[r.fastFormats,s]:[r.fullFormats,a],p=d.formats||r.formatNames;return l(u,p,h,f),d.keywords&&(0,n.default)(u),u};o.get=(u,d="full")=>{const f=(d==="fast"?r.fastFormats:r.fullFormats)[u];if(!f)throw new Error(`Unknown format "${u}"`);return f};function l(u,d,h,f){var p,g;(p=(g=u.opts.code).formats)!==null&&p!==void 0||(g.formats=(0,i._)`require("ajv-formats/dist/formats").${f}`);for(const m of d)u.addFormat(m,h[m])}t.exports=e=o,Object.defineProperty(e,"__esModule",{value:!0}),e.default=o})(BI,BI.exports)),BI.exports}var tkt=ekt();const rkt=kd(tkt);function nkt(){const t=new QIt({strict:!1,validateFormats:!0,validateSchema:!1,allErrors:!0});return rkt(t),t}class ikt{constructor(e){this._ajv=e??nkt()}getValidator(e){const r="$id"in e&&typeof e.$id=="string"?this._ajv.getSchema(e.$id)??this._ajv.compile(e):this._ajv.compile(e);return n=>r(n)?{valid:!0,data:n,errorMessage:void 0}:{valid:!1,data:void 0,errorMessage:this._ajv.errorsText(r.errors)}}}class akt{constructor(e){this._client=e}async*callToolStream(e,r=i$,n){const i=this._client,a={...n,task:n?.task??(i.isToolTask(e.name)?{}:void 0)},s=i.requestStream({method:"tools/call",params:e},r,a),o=i.getToolOutputValidator(e.name);for await(const l of s){if(l.type==="result"&&o){const u=l.result;if(!u.structuredContent&&!u.isError){yield{type:"error",error:new ci(Oi.InvalidRequest,`Tool ${e.name} has an output schema but did not return structured content`)};return}if(u.structuredContent)try{const d=o(u.structuredContent);if(!d.valid){yield{type:"error",error:new ci(Oi.InvalidParams,`Structured content does not match the tool's output schema: ${d.errorMessage}`)};return}}catch(d){if(d instanceof ci){yield{type:"error",error:d};return}yield{type:"error",error:new ci(Oi.InvalidParams,`Failed to validate structured content: ${d instanceof Error?d.message:String(d)}`)};return}}yield l}}async getTask(e,r){return this._client.getTask({taskId:e},r)}async getTaskResult(e,r,n){return this._client.getTaskResult({taskId:e},r,n)}async listTasks(e,r){return this._client.listTasks(e?{cursor:e}:void 0,r)}async cancelTask(e,r){return this._client.cancelTask({taskId:e},r)}requestStream(e,r,n){return this._client.requestStream(e,r,n)}}function skt(t,e,r){if(!t)throw new Error(`${r} does not support task creation (required for ${e})`);switch(e){case"tools/call":if(!t.tools?.call)throw new Error(`${r} does not support task creation for tools/call (required for ${e})`);break}}function okt(t,e,r){if(!t)throw new Error(`${r} does not support task creation (required for ${e})`);switch(e){case"sampling/createMessage":if(!t.sampling?.createMessage)throw new Error(`${r} does not support task creation for sampling/createMessage (required for ${e})`);break;case"elicitation/create":if(!t.elicitation?.create)throw new Error(`${r} does not support task creation for elicitation/create (required for ${e})`);break}}function DD(t,e){if(!(!t||e===null||typeof e!="object")){if(t.type==="object"&&t.properties&&typeof t.properties=="object"){const r=e,n=t.properties;for(const i of Object.keys(n)){const a=n[i];r[i]===void 0&&Object.prototype.hasOwnProperty.call(a,"default")&&(r[i]=a.default),r[i]!==void 0&&DD(a,r[i])}}if(Array.isArray(t.anyOf))for(const r of t.anyOf)typeof r!="boolean"&&DD(r,e);if(Array.isArray(t.oneOf))for(const r of t.oneOf)typeof r!="boolean"&&DD(r,e)}}function lkt(t){if(!t)return{supportsFormMode:!1,supportsUrlMode:!1};const e=t.form!==void 0,r=t.url!==void 0;return{supportsFormMode:e||!e&&!r,supportsUrlMode:r}}class ckt extends HOt{constructor(e,r){super(r),this._clientInfo=e,this._cachedToolOutputValidators=new Map,this._cachedKnownTaskTools=new Set,this._cachedRequiredTaskTools=new Set,this._listChangedDebounceTimers=new Map,this._capabilities=r?.capabilities??{},this._jsonSchemaValidator=r?.jsonSchemaValidator??new ikt,r?.listChanged&&(this._pendingListChangedConfig=r.listChanged)}_setupListChangedHandlers(e){e.tools&&this._serverCapabilities?.tools?.listChanged&&this._setupListChangedHandler("tools",SDe,e.tools,async()=>(await this.listTools()).tools),e.prompts&&this._serverCapabilities?.prompts?.listChanged&&this._setupListChangedHandler("prompts",vDe,e.prompts,async()=>(await this.listPrompts()).prompts),e.resources&&this._serverCapabilities?.resources?.listChanged&&this._setupListChangedHandler("resources",gDe,e.resources,async()=>(await this.listResources()).resources)}get experimental(){return this._experimental||(this._experimental={tasks:new akt(this)}),this._experimental}registerCapabilities(e){if(this.transport)throw new Error("Cannot register capabilities after connecting to transport");this._capabilities=VOt(this._capabilities,e)}setRequestHandler(e,r){const i=Gke(e)?.method;if(!i)throw new Error("Schema is missing a method literal");const a=zke(i);if(typeof a!="string")throw new Error("Schema method literal must be a string");const s=a;if(s==="elicitation/create"){const o=async(l,u)=>{const d=t_(xDe,l);if(!d.success){const b=d.error instanceof Error?d.error.message:String(d.error);throw new ci(Oi.InvalidParams,`Invalid elicitation request: ${b}`)}const{params:h}=d.data;h.mode=h.mode??"form";const{supportsFormMode:f,supportsUrlMode:p}=lkt(this._capabilities.elicitation);if(h.mode==="form"&&!f)throw new ci(Oi.InvalidParams,"Client does not support form-mode elicitation requests");if(h.mode==="url"&&!p)throw new ci(Oi.InvalidParams,"Client does not support URL-mode elicitation requests");const g=await Promise.resolve(r(l,u));if(h.task){const b=t_(KR,g);if(!b.success){const y=b.error instanceof Error?b.error.message:String(b.error);throw new ci(Oi.InvalidParams,`Invalid task creation result: ${y}`)}return b.data}const m=t_(ADe,g);if(!m.success){const b=m.error instanceof Error?m.error.message:String(m.error);throw new ci(Oi.InvalidParams,`Invalid elicitation result: ${b}`)}const _=m.data,v=h.mode==="form"?h.requestedSchema:void 0;if(h.mode==="form"&&_.action==="accept"&&_.content&&v&&this._capabilities.elicitation?.form?.applyDefaults)try{DD(v,_.content)}catch{}return _};return super.setRequestHandler(e,o)}if(s==="sampling/createMessage"){const o=async(l,u)=>{const d=t_(TDe,l);if(!d.success){const _=d.error instanceof Error?d.error.message:String(d.error);throw new ci(Oi.InvalidParams,`Invalid sampling request: ${_}`)}const{params:h}=d.data,f=await Promise.resolve(r(l,u));if(h.task){const _=t_(KR,f);if(!_.success){const v=_.error instanceof Error?_.error.message:String(_.error);throw new ci(Oi.InvalidParams,`Invalid task creation result: ${v}`)}return _.data}const g=h.tools||h.toolChoice?wDe:CDe,m=t_(g,f);if(!m.success){const _=m.error instanceof Error?m.error.message:String(m.error);throw new ci(Oi.InvalidParams,`Invalid sampling result: ${_}`)}return m.data};return super.setRequestHandler(e,o)}return super.setRequestHandler(e,r)}assertCapability(e,r){if(!this._serverCapabilities?.[e])throw new Error(`Server does not support ${e} (required for ${r})`)}async connect(e,r){if(await super.connect(e),e.sessionId===void 0)try{const n=await this.request({method:"initialize",params:{protocolVersion:t$,capabilities:this._capabilities,clientInfo:this._clientInfo}},sDe,r);if(n===void 0)throw new Error(`Server sent invalid initialize result: ${n}`);if(!dNt.includes(n.protocolVersion))throw new Error(`Server's protocol version is not supported: ${n.protocolVersion}`);this._serverCapabilities=n.capabilities,this._serverVersion=n.serverInfo,e.setProtocolVersion&&e.setProtocolVersion(n.protocolVersion),this._instructions=n.instructions,await this.notification({method:"notifications/initialized"}),this._pendingListChangedConfig&&(this._setupListChangedHandlers(this._pendingListChangedConfig),this._pendingListChangedConfig=void 0)}catch(n){throw this.close(),n}}getServerCapabilities(){return this._serverCapabilities}getServerVersion(){return this._serverVersion}getInstructions(){return this._instructions}assertCapabilityForMethod(e){switch(e){case"logging/setLevel":if(!this._serverCapabilities?.logging)throw new Error(`Server does not support logging (required for ${e})`);break;case"prompts/get":case"prompts/list":if(!this._serverCapabilities?.prompts)throw new Error(`Server does not support prompts (required for ${e})`);break;case"resources/list":case"resources/templates/list":case"resources/read":case"resources/subscribe":case"resources/unsubscribe":if(!this._serverCapabilities?.resources)throw new Error(`Server does not support resources (required for ${e})`);if(e==="resources/subscribe"&&!this._serverCapabilities.resources.subscribe)throw new Error(`Server does not support resource subscriptions (required for ${e})`);break;case"tools/call":case"tools/list":if(!this._serverCapabilities?.tools)throw new Error(`Server does not support tools (required for ${e})`);break;case"completion/complete":if(!this._serverCapabilities?.completions)throw new Error(`Server does not support completions (required for ${e})`);break}}assertNotificationCapability(e){switch(e){case"notifications/roots/list_changed":if(!this._capabilities.roots?.listChanged)throw new Error(`Client does not support roots list changed notifications (required for ${e})`);break}}assertRequestHandlerCapability(e){if(this._capabilities)switch(e){case"sampling/createMessage":if(!this._capabilities.sampling)throw new Error(`Client does not support sampling capability (required for ${e})`);break;case"elicitation/create":if(!this._capabilities.elicitation)throw new Error(`Client does not support elicitation capability (required for ${e})`);break;case"roots/list":if(!this._capabilities.roots)throw new Error(`Client does not support roots capability (required for ${e})`);break;case"tasks/get":case"tasks/list":case"tasks/result":case"tasks/cancel":if(!this._capabilities.tasks)throw new Error(`Client does not support tasks capability (required for ${e})`);break}}assertTaskCapability(e){skt(this._serverCapabilities?.tasks?.requests,e,"Server")}assertTaskHandlerCapability(e){this._capabilities&&okt(this._capabilities.tasks?.requests,e,"Client")}async ping(e){return this.request({method:"ping"},hT,e)}async complete(e,r){return this.request({method:"completion/complete",params:e},RDe,r)}async setLoggingLevel(e,r){return this.request({method:"logging/setLevel",params:{level:e}},hT,r)}async getPrompt(e,r){return this.request({method:"prompts/get",params:e},_De,r)}async listPrompts(e,r){return this.request({method:"prompts/list",params:e},mDe,r)}async listResources(e,r){return this.request({method:"resources/list",params:e},hDe,r)}async listResourceTemplates(e,r){return this.request({method:"resources/templates/list",params:e},fDe,r)}async readResource(e,r){return this.request({method:"resources/read",params:e},pDe,r)}async subscribeResource(e,r){return this.request({method:"resources/subscribe",params:e},hT,r)}async unsubscribeResource(e,r){return this.request({method:"resources/unsubscribe",params:e},hT,r)}async callTool(e,r=i$,n){if(this.isToolTaskRequired(e.name))throw new ci(Oi.InvalidRequest,`Tool "${e.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);const i=await this.request({method:"tools/call",params:e},r,n),a=this.getToolOutputValidator(e.name);if(a){if(!i.structuredContent&&!i.isError)throw new ci(Oi.InvalidRequest,`Tool ${e.name} has an output schema but did not return structured content`);if(i.structuredContent)try{const s=a(i.structuredContent);if(!s.valid)throw new ci(Oi.InvalidParams,`Structured content does not match the tool's output schema: ${s.errorMessage}`)}catch(s){throw s instanceof ci?s:new ci(Oi.InvalidParams,`Failed to validate structured content: ${s instanceof Error?s.message:String(s)}`)}}return i}isToolTask(e){return this._serverCapabilities?.tasks?.requests?.tools?.call?this._cachedKnownTaskTools.has(e):!1}isToolTaskRequired(e){return this._cachedRequiredTaskTools.has(e)}cacheToolMetadata(e){this._cachedToolOutputValidators.clear(),this._cachedKnownTaskTools.clear(),this._cachedRequiredTaskTools.clear();for(const r of e){if(r.outputSchema){const i=this._jsonSchemaValidator.getValidator(r.outputSchema);this._cachedToolOutputValidators.set(r.name,i)}const n=r.execution?.taskSupport;(n==="required"||n==="optional")&&this._cachedKnownTaskTools.add(r.name),n==="required"&&this._cachedRequiredTaskTools.add(r.name)}}getToolOutputValidator(e){return this._cachedToolOutputValidators.get(e)}async listTools(e,r){const n=await this.request({method:"tools/list",params:e},bDe,r);return this.cacheToolMetadata(n.tools),n}_setupListChangedHandler(e,r,n,i){const a=aOt.safeParse(n);if(!a.success)throw new Error(`Invalid ${e} listChanged options: ${a.error.message}`);if(typeof n.onChanged!="function")throw new Error(`Invalid ${e} listChanged options: onChanged must be a function`);const{autoRefresh:s,debounceMs:o}=a.data,{onChanged:l}=n,u=async()=>{if(!s){l(null,null);return}try{const h=await i();l(null,h)}catch(h){const f=h instanceof Error?h:new Error(String(h));l(f,null)}},d=()=>{if(o){const h=this._listChangedDebounceTimers.get(e);h&&clearTimeout(h);const f=setTimeout(u,o);this._listChangedDebounceTimers.set(e,f)}else u()};this.setNotificationHandler(r,d)}async sendRootsListChanged(){return this.notification({method:"notifications/roots/list_changed"})}}let EK=class extends Error{constructor(e,r){super(e),this.name="ParseError",this.type=r.type,this.field=r.field,this.value=r.value,this.line=r.line}};const pEe=10,ukt=13,ly=32;function TK(t){}function FDe(t){if(typeof t=="function")throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");const{onEvent:e=TK,onError:r=TK,onRetry:n=TK,onComment:i,maxBufferSize:a}=t,s=[];let o=0,l=!0,u,d="",h=0,f,p=!1;function g(T){if(p)throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");if(l&&(l=!1,T.charCodeAt(0)===239&&T.charCodeAt(1)===187&&T.charCodeAt(2)===191&&(T=T.slice(3))),s.length===0){const x=_(T);x!==""&&(s.push(x),o=x.length),m();return}if(T.indexOf(` +`)===-1&&T.indexOf("\r")===-1){s.push(T),o+=T.length,m();return}s.push(T);const C=s.join("");s.length=0,o=0;const w=_(C);w!==""&&(s.push(w),o=w.length),m()}function m(){a!==void 0&&(o+d.length<=a||(p=!0,s.length=0,o=0,u=void 0,d="",h=0,f=void 0,r(new EK(`Buffered data exceeded max buffer size of ${a} characters`,{type:"max-buffer-size-exceeded"}))))}function _(T){let C=0;if(T.indexOf("\r")===-1){let w=T.indexOf(` +`,C);for(;w!==-1;){if(C===w){h>0&&e({id:u,event:f,data:d}),u=void 0,d="",h=0,f=void 0,C=w+1,w=T.indexOf(` +`,C);continue}const x=T.charCodeAt(C);if(gEe(T,C,x)){const A=T.charCodeAt(C+5)===ly?C+6:C+5,R=T.slice(A,w);if(h===0&&T.charCodeAt(w+1)===pEe){e({id:u,event:f,data:R}),u=void 0,d="",f=void 0,C=w+2,w=T.indexOf(` +`,C);continue}d=h===0?R:`${d} +${R}`,h++}else mEe(T,C,x)?f=T.slice(T.charCodeAt(C+6)===ly?C+7:C+6,w)||void 0:v(T,C,w);C=w+1,w=T.indexOf(` +`,C)}return T.slice(C)}for(;C20?`${T.slice(0,20)}…`:T}"`,{type:"unknown-field",field:T,value:C,line:w}));break}}function y(){h>0&&e({id:u,event:f,data:d}),u=void 0,d="",h=0,f=void 0}function E(T={}){if(T.consume&&s.length>0){const C=s.join("");v(C,0,C.length)}l=!0,u=void 0,d="",h=0,f=void 0,s.length=0,o=0,p=!1}return{feed:g,reset:E}}function gEe(t,e,r){return r===100&&t.charCodeAt(e+1)===97&&t.charCodeAt(e+2)===116&&t.charCodeAt(e+3)===97&&t.charCodeAt(e+4)===58}function mEe(t,e,r){return r===101&&t.charCodeAt(e+1)===118&&t.charCodeAt(e+2)===101&&t.charCodeAt(e+3)===110&&t.charCodeAt(e+4)===116&&t.charCodeAt(e+5)===58}class _Ee extends Event{constructor(e,r){var n,i;super(e),this.code=(n=r?.code)!=null?n:void 0,this.message=(i=r?.message)!=null?i:void 0}[Symbol.for("nodejs.util.inspect.custom")](e,r,n){return n(vEe(this),r)}[Symbol.for("Deno.customInspect")](e,r){return e(vEe(this),r)}}function dkt(t){const e=globalThis.DOMException;return typeof e=="function"?new e(t,"SyntaxError"):new SyntaxError(t)}function see(t){return t instanceof Error?"errors"in t&&Array.isArray(t.errors)?t.errors.map(see).join(", "):"cause"in t&&t.cause instanceof Error?`${t}: ${see(t.cause)}`:t.message:`${t}`}function vEe(t){return{type:t.type,message:t.message,code:t.code,defaultPrevented:t.defaultPrevented,cancelable:t.cancelable,timeStamp:t.timeStamp}}var BDe=t=>{throw TypeError(t)},Gce=(t,e,r)=>e.has(t)||BDe("Cannot "+r),sa=(t,e,r)=>(Gce(t,e,"read from private field"),r?r.call(t):e.get(t)),hl=(t,e,r)=>e.has(t)?BDe("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,r),Us=(t,e,r,n)=>(Gce(t,e,"write to private field"),e.set(t,r),r),qm=(t,e,r)=>(Gce(t,e,"access private method"),r),hd,Zy,OE,MD,uP,B9,fT,U9,f_,IE,HT,kE,U6,Uf,oee,lee,cee,yEe,uee,dee,$6,hee,fee;class LD extends EventTarget{constructor(e,r){var n,i;super(),hl(this,Uf),this.CONNECTING=0,this.OPEN=1,this.CLOSED=2,hl(this,hd),hl(this,Zy),hl(this,OE),hl(this,MD),hl(this,uP),hl(this,B9),hl(this,fT),hl(this,U9,null),hl(this,f_),hl(this,IE),hl(this,HT,null),hl(this,kE,null),hl(this,U6,null),hl(this,lee,async a=>{var s;sa(this,IE).reset();const{body:o,redirected:l,status:u,headers:d}=a;if(u===204){qm(this,Uf,$6).call(this,"Server sent HTTP 204, not reconnecting",204),this.close();return}if(l?Us(this,OE,new URL(a.url)):Us(this,OE,void 0),u!==200){qm(this,Uf,$6).call(this,`Non-200 status code (${u})`,u);return}if(!(d.get("content-type")||"").startsWith("text/event-stream")){qm(this,Uf,$6).call(this,'Invalid content type, expected "text/event-stream"',u);return}if(sa(this,hd)===this.CLOSED)return;Us(this,hd,this.OPEN);const h=new Event("open");if((s=sa(this,U6))==null||s.call(this,h),this.dispatchEvent(h),typeof o!="object"||!o||!("getReader"in o)){qm(this,Uf,$6).call(this,"Invalid response body, expected a web ReadableStream",u),this.close();return}const f=new TextDecoder,p=o.getReader();let g=!0;do{const{done:m,value:_}=await p.read();_&&sa(this,IE).feed(f.decode(_,{stream:!m})),m&&(g=!1,sa(this,IE).reset(),qm(this,Uf,hee).call(this))}while(g)}),hl(this,cee,a=>{Us(this,f_,void 0),!(a.name==="AbortError"||a.type==="aborted")&&qm(this,Uf,hee).call(this,see(a))}),hl(this,uee,a=>{typeof a.id=="string"&&Us(this,U9,a.id);const s=new MessageEvent(a.event||"message",{data:a.data,origin:sa(this,OE)?sa(this,OE).origin:sa(this,Zy).origin,lastEventId:a.id||""});sa(this,kE)&&(!a.event||a.event==="message")&&sa(this,kE).call(this,s),this.dispatchEvent(s)}),hl(this,dee,a=>{Us(this,B9,a)}),hl(this,fee,()=>{Us(this,fT,void 0),sa(this,hd)===this.CONNECTING&&qm(this,Uf,oee).call(this)});try{if(e instanceof URL)Us(this,Zy,e);else if(typeof e=="string")Us(this,Zy,new URL(e,hkt()));else throw new Error("Invalid URL")}catch{throw dkt("An invalid or illegal string was specified")}Us(this,IE,FDe({onEvent:sa(this,uee),onRetry:sa(this,dee)})),Us(this,hd,this.CONNECTING),Us(this,B9,3e3),Us(this,uP,(n=r?.fetch)!=null?n:globalThis.fetch),Us(this,MD,(i=r?.withCredentials)!=null?i:!1),qm(this,Uf,oee).call(this)}get readyState(){return sa(this,hd)}get url(){return sa(this,Zy).href}get withCredentials(){return sa(this,MD)}get onerror(){return sa(this,HT)}set onerror(e){Us(this,HT,e)}get onmessage(){return sa(this,kE)}set onmessage(e){Us(this,kE,e)}get onopen(){return sa(this,U6)}set onopen(e){Us(this,U6,e)}addEventListener(e,r,n){const i=r;super.addEventListener(e,i,n)}removeEventListener(e,r,n){const i=r;super.removeEventListener(e,i,n)}close(){sa(this,fT)&&clearTimeout(sa(this,fT)),sa(this,hd)!==this.CLOSED&&(sa(this,f_)&&sa(this,f_).abort(),Us(this,hd,this.CLOSED),Us(this,f_,void 0))}}hd=new WeakMap,Zy=new WeakMap,OE=new WeakMap,MD=new WeakMap,uP=new WeakMap,B9=new WeakMap,fT=new WeakMap,U9=new WeakMap,f_=new WeakMap,IE=new WeakMap,HT=new WeakMap,kE=new WeakMap,U6=new WeakMap,Uf=new WeakSet,oee=function(){Us(this,hd,this.CONNECTING),Us(this,f_,new AbortController),sa(this,uP)(sa(this,Zy),qm(this,Uf,yEe).call(this)).then(sa(this,lee)).catch(sa(this,cee))},lee=new WeakMap,cee=new WeakMap,yEe=function(){var t;const e={mode:"cors",redirect:"follow",headers:{Accept:"text/event-stream",...sa(this,U9)?{"Last-Event-ID":sa(this,U9)}:void 0},cache:"no-store",signal:(t=sa(this,f_))==null?void 0:t.signal};return"window"in globalThis&&(e.credentials=this.withCredentials?"include":"same-origin"),e},uee=new WeakMap,dee=new WeakMap,$6=function(t,e){var r;sa(this,hd)!==this.CLOSED&&Us(this,hd,this.CLOSED);const n=new _Ee("error",{code:e,message:t});(r=sa(this,HT))==null||r.call(this,n),this.dispatchEvent(n)},hee=function(t,e){var r;if(sa(this,hd)===this.CLOSED)return;Us(this,hd,this.CONNECTING);const n=new _Ee("error",{code:e,message:t});(r=sa(this,HT))==null||r.call(this,n),this.dispatchEvent(n),Us(this,fT,setTimeout(sa(this,fee),sa(this,B9)))},fee=new WeakMap,LD.CONNECTING=0,LD.OPEN=1,LD.CLOSED=2;function hkt(){const t="document"in globalThis?globalThis.document:void 0;return t&&typeof t=="object"&&"baseURI"in t&&typeof t.baseURI=="string"?t.baseURI:void 0}function dP(t){return t?t instanceof Headers?Object.fromEntries(t.entries()):Array.isArray(t)?Object.fromEntries(t):{...t}:{}}function UDe(t=fetch,e){return e?async(r,n)=>{const i={...e,...n,headers:n?.headers?{...dP(e.headers),...dP(n.headers)}:e.headers};return t(r,i)}:t}let zce;zce=globalThis.crypto;async function fkt(t){return(await zce).getRandomValues(new Uint8Array(t))}async function pkt(t){const e="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~",r=Math.pow(2,8)-Math.pow(2,8)%e.length;let n="";for(;n.length128)throw`Expected a length between 43 and 128. Received ${t}.`;const e=await gkt(t),r=await mkt(e);return{code_verifier:e,code_challenge:r}}const pc=_8t().superRefine((t,e)=>{if(!URL.canParse(t))return e.addIssue({code:cNt.custom,message:"URL must be parseable",fatal:!0}),y6t}).refine(t=>{const e=new URL(t);return e.protocol!=="javascript:"&&e.protocol!=="data:"&&e.protocol!=="vbscript:"},{message:"URL cannot use javascript:, data:, or vbscript: scheme"}),vkt=vc({resource:xt().url(),authorization_servers:sn(pc).optional(),jwks_uri:xt().url().optional(),scopes_supported:sn(xt()).optional(),bearer_methods_supported:sn(xt()).optional(),resource_signing_alg_values_supported:sn(xt()).optional(),resource_name:xt().optional(),resource_documentation:xt().optional(),resource_policy_uri:xt().url().optional(),resource_tos_uri:xt().url().optional(),tls_client_certificate_bound_access_tokens:xs().optional(),authorization_details_types_supported:sn(xt()).optional(),dpop_signing_alg_values_supported:sn(xt()).optional(),dpop_bound_access_tokens_required:xs().optional()}),$De=vc({issuer:xt(),authorization_endpoint:pc,token_endpoint:pc,registration_endpoint:pc.optional(),scopes_supported:sn(xt()).optional(),response_types_supported:sn(xt()),response_modes_supported:sn(xt()).optional(),grant_types_supported:sn(xt()).optional(),token_endpoint_auth_methods_supported:sn(xt()).optional(),token_endpoint_auth_signing_alg_values_supported:sn(xt()).optional(),service_documentation:pc.optional(),revocation_endpoint:pc.optional(),revocation_endpoint_auth_methods_supported:sn(xt()).optional(),revocation_endpoint_auth_signing_alg_values_supported:sn(xt()).optional(),introspection_endpoint:xt().optional(),introspection_endpoint_auth_methods_supported:sn(xt()).optional(),introspection_endpoint_auth_signing_alg_values_supported:sn(xt()).optional(),code_challenge_methods_supported:sn(xt()).optional(),client_id_metadata_document_supported:xs().optional()}),ykt=vc({issuer:xt(),authorization_endpoint:pc,token_endpoint:pc,userinfo_endpoint:pc.optional(),jwks_uri:pc,registration_endpoint:pc.optional(),scopes_supported:sn(xt()).optional(),response_types_supported:sn(xt()),response_modes_supported:sn(xt()).optional(),grant_types_supported:sn(xt()).optional(),acr_values_supported:sn(xt()).optional(),subject_types_supported:sn(xt()),id_token_signing_alg_values_supported:sn(xt()),id_token_encryption_alg_values_supported:sn(xt()).optional(),id_token_encryption_enc_values_supported:sn(xt()).optional(),userinfo_signing_alg_values_supported:sn(xt()).optional(),userinfo_encryption_alg_values_supported:sn(xt()).optional(),userinfo_encryption_enc_values_supported:sn(xt()).optional(),request_object_signing_alg_values_supported:sn(xt()).optional(),request_object_encryption_alg_values_supported:sn(xt()).optional(),request_object_encryption_enc_values_supported:sn(xt()).optional(),token_endpoint_auth_methods_supported:sn(xt()).optional(),token_endpoint_auth_signing_alg_values_supported:sn(xt()).optional(),display_values_supported:sn(xt()).optional(),claim_types_supported:sn(xt()).optional(),claims_supported:sn(xt()).optional(),service_documentation:xt().optional(),claims_locales_supported:sn(xt()).optional(),ui_locales_supported:sn(xt()).optional(),claims_parameter_supported:xs().optional(),request_parameter_supported:xs().optional(),request_uri_parameter_supported:xs().optional(),require_request_uri_registration:xs().optional(),op_policy_uri:pc.optional(),op_tos_uri:pc.optional(),client_id_metadata_document_supported:xs().optional()}),bkt=ln({...ykt.shape,...$De.pick({code_challenge_methods_supported:!0}).shape}),Skt=ln({access_token:xt(),id_token:xt().optional(),token_type:xt(),expires_in:uNt().optional(),scope:xt().optional(),refresh_token:xt().optional()}).strip(),Ekt=ln({error:xt(),error_description:xt().optional(),error_uri:xt().optional()}),bEe=pc.optional().or(qn("").transform(()=>{})),Tkt=ln({redirect_uris:sn(pc),token_endpoint_auth_method:xt().optional(),grant_types:sn(xt()).optional(),response_types:sn(xt()).optional(),client_name:xt().optional(),client_uri:pc.optional(),logo_uri:bEe,scope:xt().optional(),contacts:sn(xt()).optional(),tos_uri:bEe,policy_uri:xt().optional(),jwks_uri:pc.optional(),jwks:B8t().optional(),software_id:xt().optional(),software_version:xt().optional(),software_statement:xt().optional()}).strip(),Ckt=ln({client_id:xt(),client_secret:xt().optional(),client_id_issued_at:qa().optional(),client_secret_expires_at:qa().optional()}).strip(),wkt=Tkt.merge(Ckt);ln({error:xt(),error_description:xt().optional()}).strip();ln({token:xt(),token_type_hint:xt().optional()}).strip();function xkt(t){const e=typeof t=="string"?new URL(t):new URL(t.href);return e.hash="",e}function Akt({requestedResource:t,configuredResource:e}){const r=typeof t=="string"?new URL(t):new URL(t.href),n=typeof e=="string"?new URL(e):new URL(e.href);if(r.origin!==n.origin||r.pathname.length=400&&t.status<500&&e!=="/"}async function Ukt(t,e,r,n){const i=new URL(t),a=n?.protocolVersion??t$;let s;if(n?.metadataUrl)s=new URL(n.metadataUrl);else{const l=Fkt(e,i.pathname);s=new URL(l,n?.metadataServerUrl??i),s.search=i.search}let o=await SEe(s,a,r);if(!n?.metadataUrl&&Bkt(o,i.pathname)){const l=new URL(`/.well-known/${e}`,i);o=await SEe(l,a,r)}return o}function $kt(t){const e=typeof t=="string"?new URL(t):t,r=e.pathname!=="/",n=[];if(!r)return n.push({url:new URL("/.well-known/oauth-authorization-server",e.origin),type:"oauth"}),n.push({url:new URL("/.well-known/openid-configuration",e.origin),type:"oidc"}),n;let i=e.pathname;return i.endsWith("/")&&(i=i.slice(0,-1)),n.push({url:new URL(`/.well-known/oauth-authorization-server${i}`,e.origin),type:"oauth"}),n.push({url:new URL(`/.well-known/openid-configuration${i}`,e.origin),type:"oidc"}),n.push({url:new URL(`${i}/.well-known/openid-configuration`,e.origin),type:"oidc"}),n}async function qDe(t,{fetchFn:e=fetch,protocolVersion:r=t$}={}){const n={"MCP-Protocol-Version":r,Accept:"application/json"},i=$kt(t);for(const{url:a,type:s}of i){const o=await qce(a,n,e);if(o){if(!o.ok){if(await o.body?.cancel(),o.status>=400&&o.status<500)continue;throw new Error(`HTTP ${o.status} trying to load ${s==="oauth"?"OAuth":"OpenID provider"} metadata from ${a}`)}return s==="oauth"?$De.parse(await o.json()):bkt.parse(await o.json())}}}async function Gkt(t,e){let r,n;try{r=await zDe(t,{resourceMetadataUrl:e?.resourceMetadataUrl},e?.fetchFn),r.authorization_servers&&r.authorization_servers.length>0&&(n=r.authorization_servers[0])}catch{}n||(n=String(new URL("/",t)));const i=await qDe(n,{fetchFn:e?.fetchFn});return{authorizationServerUrl:n,authorizationServerMetadata:i,resourceMetadata:r}}async function zkt(t,{metadata:e,clientInformation:r,redirectUrl:n,scope:i,state:a,resource:s}){let o;if(e){if(o=new URL(e.authorization_endpoint),!e.response_types_supported.includes(CK))throw new Error(`Incompatible auth server: does not support response type ${CK}`);if(e.code_challenge_methods_supported&&!e.code_challenge_methods_supported.includes(wK))throw new Error(`Incompatible auth server: does not support code challenge method ${wK}`)}else o=new URL("/authorize",t);const l=await _kt(),u=l.code_verifier,d=l.code_challenge;return o.searchParams.set("response_type",CK),o.searchParams.set("client_id",r.client_id),o.searchParams.set("code_challenge",d),o.searchParams.set("code_challenge_method",wK),o.searchParams.set("redirect_uri",String(n)),a&&o.searchParams.set("state",a),i&&o.searchParams.set("scope",i),i?.includes("offline_access")&&o.searchParams.append("prompt","consent"),s&&o.searchParams.set("resource",s.href),{authorizationUrl:o,codeVerifier:u}}function qkt(t,e,r){return new URLSearchParams({grant_type:"authorization_code",code:t,code_verifier:e,redirect_uri:String(r)})}async function HDe(t,{metadata:e,tokenRequestParams:r,clientInformation:n,addClientAuthentication:i,resource:a,fetchFn:s}){const o=e?.token_endpoint?new URL(e.token_endpoint):new URL("/token",t),l=new Headers({"Content-Type":"application/x-www-form-urlencoded",Accept:"application/json"});if(a&&r.set("resource",a.href),i)await i(l,r,o,e);else if(n){const d=e?.token_endpoint_auth_methods_supported??[],h=Okt(n,d);Ikt(h,n,l,r)}const u=await(s??fetch)(o,{method:"POST",headers:l,body:r});if(!u.ok)throw await GDe(u);return Skt.parse(await u.json())}async function Hkt(t,{metadata:e,clientInformation:r,refreshToken:n,resource:i,addClientAuthentication:a,fetchFn:s}){const o=new URLSearchParams({grant_type:"refresh_token",refresh_token:n}),l=await HDe(t,{metadata:e,tokenRequestParams:o,clientInformation:r,addClientAuthentication:a,resource:i,fetchFn:s});return{refresh_token:n,...l}}async function Vkt(t,e,{metadata:r,resource:n,authorizationCode:i,fetchFn:a}={}){const s=t.clientMetadata.scope;let o;if(t.prepareTokenRequest&&(o=await t.prepareTokenRequest(s)),!o){if(!i)throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");if(!t.redirectUrl)throw new Error("redirectUrl is required for authorization_code flow");const u=await t.codeVerifier();o=qkt(i,u,t.redirectUrl)}const l=await t.clientInformation();return HDe(e,{metadata:r,tokenRequestParams:o,clientInformation:l??void 0,addClientAuthentication:t.addClientAuthentication,resource:n,fetchFn:a})}async function Ykt(t,{metadata:e,clientMetadata:r,scope:n,fetchFn:i}){let a;if(e){if(!e.registration_endpoint)throw new Error("Incompatible auth server: does not support dynamic client registration");a=new URL(e.registration_endpoint)}else a=new URL("/register",t);const s=await(i??fetch)(a,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({...r,...n!==void 0?{scope:n}:{}})});if(!s.ok)throw await GDe(s);return wkt.parse(await s.json())}class Wkt extends Error{constructor(e,r,n){super(`SSE error: ${r}`),this.code=e,this.event=n}}class EEe{constructor(e,r){this._url=e,this._resourceMetadataUrl=void 0,this._scope=void 0,this._eventSourceInit=r?.eventSourceInit,this._requestInit=r?.requestInit,this._authProvider=r?.authProvider,this._fetch=r?.fetch,this._fetchWithInit=UDe(r?.fetch,r?.requestInit)}async _authThenStart(){if(!this._authProvider)throw new Wf("No auth provider");let e;try{e=await wb(this._authProvider,{serverUrl:this._url,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})}catch(r){throw this.onerror?.(r),r}if(e!=="AUTHORIZED")throw new Wf;return await this._startOrAuth()}async _commonHeaders(){const e={};if(this._authProvider){const n=await this._authProvider.tokens();n&&(e.Authorization=`Bearer ${n.access_token}`)}this._protocolVersion&&(e["mcp-protocol-version"]=this._protocolVersion);const r=dP(this._requestInit?.headers);return new Headers({...e,...r})}_startOrAuth(){const e=this?._eventSourceInit?.fetch??this._fetch??fetch;return new Promise((r,n)=>{this._eventSource=new LD(this._url.href,{...this._eventSourceInit,fetch:async(i,a)=>{const s=await this._commonHeaders();s.set("Accept","text/event-stream");const o=await e(i,{...a,headers:s});if(o.status===401&&o.headers.has("www-authenticate")){const{resourceMetadataUrl:l,scope:u}=mP(o);this._resourceMetadataUrl=l,this._scope=u}return o}}),this._abortController=new AbortController,this._eventSource.onerror=i=>{if(i.code===401&&this._authProvider){this._authThenStart().then(r,n);return}const a=new Wkt(i.code,i.message,i);n(a),this.onerror?.(a)},this._eventSource.onopen=()=>{},this._eventSource.addEventListener("endpoint",i=>{const a=i;try{if(this._endpoint=new URL(a.data,this._url),this._endpoint.origin!==this._url.origin)throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`)}catch(s){n(s),this.onerror?.(s),this.close();return}r()}),this._eventSource.onmessage=i=>{const a=i;let s;try{s=F9.parse(JSON.parse(a.data))}catch(o){this.onerror?.(o);return}this.onmessage?.(s)}})}async start(){if(this._eventSource)throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");return await this._startOrAuth()}async finishAuth(e){if(!this._authProvider)throw new Wf("No auth provider");if(await wb(this._authProvider,{serverUrl:this._url,authorizationCode:e,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})!=="AUTHORIZED")throw new Wf("Failed to authorize")}async close(){this._abortController?.abort(),this._eventSource?.close(),this.onclose?.()}async send(e){if(!this._endpoint)throw new Error("Not connected");try{const r=await this._commonHeaders();r.set("content-type","application/json");const n={...this._requestInit,method:"POST",headers:r,body:JSON.stringify(e),signal:this._abortController?.signal},i=await(this._fetch??fetch)(this._endpoint,n);if(!i.ok){const a=await i.text().catch(()=>null);if(i.status===401&&this._authProvider){const{resourceMetadataUrl:s,scope:o}=mP(i);if(this._resourceMetadataUrl=s,this._scope=o,await wb(this._authProvider,{serverUrl:this._url,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})!=="AUTHORIZED")throw new Wf;return this.send(e)}throw new Error(`Error POSTing to endpoint (HTTP ${i.status}): ${a}`)}await i.body?.cancel()}catch(r){throw this.onerror?.(r),r}}setProtocolVersion(e){this._protocolVersion=e}}var UI={};var TEe;function Kkt(){if(TEe)return UI;TEe=1;var t=/; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g,e=/^[\u000b\u0020-\u007e\u0080-\u00ff]+$/,r=/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/,n=/\\([\u000b\u0020-\u00ff])/g,i=/([\\"])/g,a=/^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;UI.format=s,UI.parse=o;function s(h){if(!h||typeof h!="object")throw new TypeError("argument obj is required");var f=h.parameters,p=h.type;if(!p||!a.test(p))throw new TypeError("invalid type");var g=p;if(f&&typeof f=="object")for(var m,_=Object.keys(f).sort(),v=0;v<_.length;v++){if(m=_[v],!r.test(m))throw new TypeError("invalid parameter name");g+="; "+m+"="+u(f[m])}return g}function o(h){if(!h)throw new TypeError("argument string is required");var f=typeof h=="object"?l(h):h;if(typeof f!="string")throw new TypeError("argument string is required to be a string");var p=f.indexOf(";"),g=p!==-1?f.slice(0,p).trim():f.trim();if(!a.test(g))throw new TypeError("invalid media type");var m=new d(g.toLowerCase());if(p!==-1){var _,v,b;for(t.lastIndex=p;v=t.exec(f);){if(v.index!==p)throw new TypeError("invalid parameter format");p+=v[0].length,_=v[1].toLowerCase(),b=v[2],b.charCodeAt(0)===34&&(b=b.slice(1,-1),b.indexOf("\\")!==-1&&(b=b.replace(n,"$1"))),m.parameters[_]=b}if(p!==f.length)throw new TypeError("invalid parameter format")}return m}function l(h){var f;if(typeof h.getHeader=="function"?f=h.getHeader("content-type"):typeof h.headers=="object"&&(f=h.headers&&h.headers["content-type"]),typeof f!="string")throw new TypeError("content-type header is missing from object");return f}function u(h){var f=String(h);if(r.test(f))return f;if(f.length>0&&!e.test(f))throw new TypeError("invalid parameter value");return'"'+f.replace(i,"\\$1")+'"'}function d(h){this.parameters=Object.create(null),this.type=h}return UI}var jkt=Kkt();const Xkt=kd(jkt);function Qkt(t){if(t)try{return Xkt.parse(t).type}catch{const e=(t.split(";",1)[0]??"").trim().toLowerCase();return e===""||t.slice(e.length).includes(",")?void 0:e}}class Zkt extends TransformStream{constructor({onError:e,onRetry:r,onComment:n,maxBufferSize:i}={}){let a;super({start(s){a=FDe({onEvent:o=>{s.enqueue(o)},onError(o){typeof e=="function"&&e(o),(e==="terminate"||o.type==="max-buffer-size-exceeded")&&s.error(o)},onRetry:r,onComment:n,maxBufferSize:i})},transform(s){a.feed(s)}})}}const Jkt={initialReconnectionDelay:1e3,maxReconnectionDelay:3e4,reconnectionDelayGrowFactor:1.5,maxRetries:2};class My extends Error{constructor(e,r){super(`Streamable HTTP error: ${r}`),this.code=e}}class CEe{constructor(e,r){this._hasCompletedAuthFlow=!1,this._url=e,this._resourceMetadataUrl=void 0,this._scope=void 0,this._requestInit=r?.requestInit,this._authProvider=r?.authProvider,this._fetch=r?.fetch,this._fetchWithInit=UDe(r?.fetch,r?.requestInit),this._sessionId=r?.sessionId,this._reconnectionOptions=r?.reconnectionOptions??Jkt}async _authThenStart(){if(!this._authProvider)throw new Wf("No auth provider");let e;try{e=await wb(this._authProvider,{serverUrl:this._url,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})}catch(r){throw this.onerror?.(r),r}if(e!=="AUTHORIZED")throw new Wf;return await this._startOrAuthSse({resumptionToken:void 0})}async _commonHeaders(){const e={};if(this._authProvider){const n=await this._authProvider.tokens();n&&(e.Authorization=`Bearer ${n.access_token}`)}this._sessionId&&(e["mcp-session-id"]=this._sessionId),this._protocolVersion&&(e["mcp-protocol-version"]=this._protocolVersion);const r=dP(this._requestInit?.headers);return new Headers({...e,...r})}async _startOrAuthSse(e){const{resumptionToken:r}=e;try{const n=await this._commonHeaders();n.set("Accept","text/event-stream"),r&&n.set("last-event-id",r);const i=await(this._fetch??fetch)(this._url,{method:"GET",headers:n,signal:this._abortController?.signal});if(!i.ok){if(await i.body?.cancel(),i.status===401&&this._authProvider)return await this._authThenStart();if(i.status===405)return;throw new My(i.status,`Failed to open SSE stream: ${i.statusText}`)}this._handleSseStream(i.body,e,!0)}catch(n){throw this.onerror?.(n),n}}_getNextReconnectionDelay(e){if(this._serverRetryMs!==void 0)return this._serverRetryMs;const r=this._reconnectionOptions.initialReconnectionDelay,n=this._reconnectionOptions.reconnectionDelayGrowFactor,i=this._reconnectionOptions.maxReconnectionDelay;return Math.min(r*Math.pow(n,e),i)}_scheduleReconnection(e,r=0){const n=this._reconnectionOptions.maxRetries;if(r>=n){this.onerror?.(new Error(`Maximum reconnection attempts (${n}) exceeded.`));return}const i=this._getNextReconnectionDelay(r);this._reconnectionTimeout=setTimeout(()=>{this._startOrAuthSse(e).catch(a=>{this.onerror?.(new Error(`Failed to reconnect SSE stream: ${a instanceof Error?a.message:String(a)}`)),this._scheduleReconnection(e,r+1)})},i)}_handleSseStream(e,r,n){if(!e)return;const{onresumptiontoken:i,replayMessageId:a}=r;let s,o=!1,l=!1;(async()=>{try{const d=e.pipeThrough(new TextDecoderStream).pipeThrough(new Zkt({onRetry:p=>{this._serverRetryMs=p}})).getReader();for(;;){const{value:p,done:g}=await d.read();if(g)break;if(p.id&&(s=p.id,o=!0,i?.(p.id)),!!p.data&&(!p.event||p.event==="message"))try{const m=F9.parse(JSON.parse(p.data));B6(m)&&(l=!0,a!==void 0&&(m.id=a)),this.onmessage?.(m)}catch(m){this.onerror?.(m)}}(n||o)&&!l&&this._abortController&&!this._abortController.signal.aborted&&this._scheduleReconnection({resumptionToken:s,onresumptiontoken:i,replayMessageId:a},0)}catch(d){if(this.onerror?.(new Error(`SSE stream disconnected: ${d}`)),(n||o)&&!l&&this._abortController&&!this._abortController.signal.aborted)try{this._scheduleReconnection({resumptionToken:s,onresumptiontoken:i,replayMessageId:a},0)}catch(p){this.onerror?.(new Error(`Failed to reconnect: ${p instanceof Error?p.message:String(p)}`))}}})()}async start(){if(this._abortController)throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");this._abortController=new AbortController}async finishAuth(e){if(!this._authProvider)throw new Wf("No auth provider");if(await wb(this._authProvider,{serverUrl:this._url,authorizationCode:e,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})!=="AUTHORIZED")throw new Wf("Failed to authorize")}async close(){this._reconnectionTimeout&&(clearTimeout(this._reconnectionTimeout),this._reconnectionTimeout=void 0),this._abortController?.abort(),this.onclose?.()}async send(e,r){try{const{resumptionToken:n,onresumptiontoken:i}=r||{};if(n){this._startOrAuthSse({resumptionToken:n,replayMessageId:aee(e)?e.id:void 0}).catch(p=>this.onerror?.(p));return}const a=await this._commonHeaders();a.set("content-type","application/json"),a.set("accept","application/json, text/event-stream");const s={...this._requestInit,method:"POST",headers:a,body:JSON.stringify(e),signal:this._abortController?.signal},o=await(this._fetch??fetch)(this._url,s),l=o.headers.get("mcp-session-id");if(l&&(this._sessionId=l),!o.ok){const p=await o.text().catch(()=>null);if(o.status===401&&this._authProvider){if(this._hasCompletedAuthFlow)throw new My(401,"Server returned 401 after successful authentication");const{resourceMetadataUrl:g,scope:m}=mP(o);if(this._resourceMetadataUrl=g,this._scope=m,await wb(this._authProvider,{serverUrl:this._url,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetchWithInit})!=="AUTHORIZED")throw new Wf;return this._hasCompletedAuthFlow=!0,this.send(e)}if(o.status===403&&this._authProvider){const{resourceMetadataUrl:g,scope:m,error:_}=mP(o);if(_==="insufficient_scope"){const v=o.headers.get("WWW-Authenticate");if(this._lastUpscopingHeader===v)throw new My(403,"Server returned 403 after trying upscoping");if(m&&(this._scope=m),g&&(this._resourceMetadataUrl=g),this._lastUpscopingHeader=v??void 0,await wb(this._authProvider,{serverUrl:this._url,resourceMetadataUrl:this._resourceMetadataUrl,scope:this._scope,fetchFn:this._fetch})!=="AUTHORIZED")throw new Wf;return this.send(e)}}throw new My(o.status,`Error POSTing to endpoint: ${p}`)}if(this._hasCompletedAuthFlow=!1,this._lastUpscopingHeader=void 0,o.status===202){await o.body?.cancel(),ANt(e)&&this._startOrAuthSse({resumptionToken:void 0}).catch(p=>this.onerror?.(p));return}const d=(Array.isArray(e)?e:[e]).filter(p=>"method"in p&&"id"in p&&p.id!==void 0).length>0,h=o.headers.get("content-type"),f=Qkt(h);if(d)if(f==="text/event-stream")this._handleSseStream(o.body,{onresumptiontoken:i},!1);else if(f==="application/json"){const p=await o.json(),g=Array.isArray(p)?p.map(m=>F9.parse(m)):[F9.parse(p)];for(const m of g)this.onmessage?.(m)}else throw await o.body?.cancel(),new My(-1,`Unexpected content type: ${h}`);else await o.body?.cancel()}catch(n){throw this.onerror?.(n),n}}get sessionId(){return this._sessionId}async terminateSession(){if(this._sessionId)try{const e=await this._commonHeaders(),r={...this._requestInit,method:"DELETE",headers:e,signal:this._abortController?.signal},n=await(this._fetch??fetch)(this._url,r);if(await n.body?.cancel(),!n.ok&&n.status!==405)throw new My(n.status,`Failed to terminate session: ${n.statusText}`);this._sessionId=void 0}catch(e){throw this.onerror?.(e),e}}setProtocolVersion(e){this._protocolVersion=e}get protocolVersion(){return this._protocolVersion}async resumeStream(e,r){await this._startOrAuthSse({resumptionToken:e,onresumptiontoken:r?.onresumptiontoken})}}const eDt="mcp";class tDt{constructor(e){this._url=e}start(){if(this._socket)throw new Error("WebSocketClientTransport already started! If using Client class, note that connect() calls start() automatically.");return new Promise((e,r)=>{this._socket=new WebSocket(this._url,eDt),this._socket.onerror=n=>{const i="error"in n?n.error:new Error(`WebSocket error: ${JSON.stringify(n)}`);r(i),this.onerror?.(i)},this._socket.onopen=()=>{e()},this._socket.onclose=()=>{this.onclose?.()},this._socket.onmessage=n=>{let i;try{i=F9.parse(JSON.parse(n.data))}catch(a){this.onerror?.(a);return}this.onmessage?.(i)}})}async close(){this._socket?.close()}send(e){return new Promise((r,n)=>{if(!this._socket){n(new Error("Not connected"));return}this._socket?.send(JSON.stringify(e)),r()})}}class Qa{static createLog(e,r,n=_u.INFO,i){return{details:i,level:n,message:r,phase:e,timestamp:new Date}}static createDiagnosticRequestDetails(e,r,n,i,a){const s=tMt(e,r),o={body:rMt(s),credentials:r?.credentials??n.credentials,headers:wH(i,a,yH),method:eMt(e,r,n).toUpperCase(),mode:r?.mode??n.mode,url:JDt(e)},l=iMt(s);return l&&(o.jsonRpcMethods=l),o}static addRequestHeaders(e,r,n){for(const[i,a]of new Headers(r).entries()){const s=n&&!i.toLowerCase().startsWith(GR)?`${GR}${i}`:i;e.set(s,a)}}static summarizeError(e){return e instanceof Error?{cause:e.cause instanceof Error?{message:e.cause.message,name:e.cause.name}:e.cause,message:e.message,name:e.name,stack:e.stack?.split(` +`).slice(0,6).join(` +`)}:{value:String(e)}}static getBrowserContext(e,r){if(!(typeof window>"u"))return{isSecureContext:window.isSecureContext,location:window.location.href,origin:window.location.origin,protocol:window.location.protocol,sameOrigin:window.location.origin===e.origin,targetOrigin:e.origin,targetProtocol:e.protocol,useProxy:r}}static getConnectionHints(e,r,n){const i=[],a=n instanceof Error?n.message:String(n),s=Object.keys(r.headers??{});return typeof window<"u"&&(window.location.protocol==="https:"&&e.protocol==="http:"&&!r.useProxy&&i.push("The page is running over HTTPS but the MCP server is HTTP. Browsers often block this as mixed content; enable the proxy or use HTTPS/WSS for the MCP server."),window.location.origin!==e.origin&&!r.useProxy&&i.push("This is a cross-origin browser request. If the server is reachable from curl or Node but not from the browser, missing CORS headers are the most likely cause.")),s.length>0&&i.push(`Custom request headers are configured (${s.join(", ")}). That triggers a CORS preflight, so the server must allow OPTIONS and include the matching Access-Control-Allow-Headers response.`),r.credentials&&r.credentials!=="omit"&&i.push("Credentials are enabled for this connection. Cross-origin credentialed requests need Access-Control-Allow-Credentials: true and cannot use a wildcard Access-Control-Allow-Origin."),a.includes("Failed to fetch")&&i.push('"Failed to fetch" is a browser-level network failure. Common causes are CORS rejection, mixed-content blocking, certificate/TLS errors, DNS failures, or nothing listening on the target port.'),i}static createDiagnosticFetch(e,r,n,i,a,s){let o=!0;const l=u=>{o&&s?.(u)};return{disable:()=>{o=!1},fetch:async(u,d)=>{if(a&&typeof window<"u"){let _="";if(typeof u=="string"?_=u:u instanceof URL&&(_=u.href),_){const v=new URL(_,window.location.origin);if(v.origin===window.location.origin&&!v.pathname.includes(FJ)){const b=new URL(r.url),y=new URL(v.pathname+v.search,b.origin),E=zO(y.href);typeof u=="string"?u=E.href:u instanceof URL&&(u=E)}}}const h=performance.now(),f=new Headers(n.headers);typeof Request<"u"&&u instanceof Request&&this.addRequestHeaders(f,u.headers,a),d?.headers&&this.addRequestHeaders(f,d.headers,a);const p=this.createDiagnosticRequestDetails(u,d,n,f,Object.keys(r.headers??{})),{method:g,url:m}=p;if(l(this.createLog(Fa.INITIALIZING,`HTTP ${g} ${m}`,_u.INFO,{request:p,serverName:e})),g==="DELETE"&&m.includes(FJ)){const _=new Response(null,{status:200,statusText:"OK"});return l(this.createLog(Fa.INITIALIZING,`HTTP 200 ${g} ${m} (fake response)`,_u.INFO,{response:{durationMs:0,isFake:!0,status:_.status,statusText:_.statusText,url:m}})),_}try{const _=await fetch(u,{...n,...d,headers:f}),v=Math.round(performance.now()-h);return l(this.createLog(Fa.INITIALIZING,`HTTP ${_.status} ${g} ${m} (${v}ms)`,_.ok?_u.INFO:_u.WARN,{response:{durationMs:v,headers:wH(_.headers,void 0,yH),status:_.status,statusText:_.statusText,url:m}})),_}catch(_){const v=Math.round(performance.now()-h);throw l(this.createLog(Fa.ERROR,`HTTP ${g} ${m} failed: ${nMt(_)}`,_u.ERROR,{browser:this.getBrowserContext(i,a),durationMs:v,error:this.summarizeError(_),hints:this.getConnectionHints(i,r,_),request:p,serverName:e})),_}}}}static isSessionExpiredError(e){return e instanceof My&&e.code===404}static createTransport(e,r,n){if(!r.url)throw new Error("MCP server configuration is missing url");const i=r.useProxy??!1,a={};if(r.headers&&(a.headers=r.useProxy?R4t(r.headers):r.headers),i&&(a.headers={...op(),...a.headers}),r.credentials&&(a.credentials=r.credentials),r.transport===fc.WEBSOCKET){if(i)throw new Error("WebSocket transport is not supported when using CORS proxy. Use HTTP transport instead.");const u=new URL(r.url);return{stopPhaseLogging:()=>{},transport:new tDt(u),type:fc.WEBSOCKET}}if(r.transport===fc.SSE){const u=i?zO(r.url):new URL(r.url),{disable:d,fetch:h}=this.createDiagnosticFetch(e,r,a,u,i,n);return{stopPhaseLogging:d,transport:new EEe(u,{eventSourceInit:{fetch:h},fetch:h,requestInit:a}),type:fc.SSE}}const s=i?zO(r.url):new URL(r.url),{disable:o,fetch:l}=this.createDiagnosticFetch(e,r,a,s,i,n);try{return{stopPhaseLogging:o,transport:new CEe(s,{fetch:l,requestInit:a}),type:fc.STREAMABLE_HTTP}}catch(u){console.warn("[MCPService] StreamableHTTP failed, trying SSE transport...",u);try{return{stopPhaseLogging:o,transport:new EEe(s,{eventSourceInit:{fetch:l},fetch:l,requestInit:a}),type:fc.SSE}}catch(d){const h=u instanceof Error?u.message:String(u),f=d instanceof Error?d.message:String(d);throw new Error(`Failed to create transport. StreamableHTTP: ${h}; SSE: ${f}`)}}}static extractServerInfo(e){if(e)return{description:e.description,icons:e.icons?.map(r=>({mimeType:r.mimeType,sizes:r.sizes,src:r.src,theme:r.theme})),name:e.name,title:e.title,version:e.version,websiteUrl:e.websiteUrl}}static async connect(e,r,n,i,a,s){const o=performance.now(),l=n??Ro.clientInfo,u=i??Ro.capabilities;a?.(Fa.TRANSPORT_CREATING,this.createLog(Fa.TRANSPORT_CREATING,`Creating transport for ${r.url}`));const{stopPhaseLogging:d,transport:h,type:f}=this.createTransport(e,r,C=>a?.(C.phase,C));f===fc.WEBSOCKET&&(h.onclose=()=>{console.log(`[MCPService][${e}] WebSocket closed, notifying for reconnection`),a?.(Fa.DISCONNECTED,this.createLog(Fa.DISCONNECTED,"WebSocket connection closed"))}),a?.(Fa.TRANSPORT_READY,this.createLog(Fa.TRANSPORT_READY,`Transport ready (${f})`),{transportType:f});const p=new ckt({name:l.name,version:l.version??EIe},{capabilities:u,listChanged:s}),g=C=>{if(vu(C))return;const w=C?.message??"";/SSE stream disconnected:.*AbortError/i.test(w)||/AbortError: .*aborted/i.test(w)||/stream locked by a reader/i.test(w)||console.error(`[MCPService][${e}] Protocol error after initialize:`,C)};p.onerror=C=>{a?.(Fa.ERROR,this.createLog(Fa.ERROR,`Protocol error: ${C.message}`,_u.ERROR,{error:this.summarizeError(C)}))},a?.(Fa.INITIALIZING,this.createLog(Fa.INITIALIZING,"Sending initialize request..."));const m=r.handshakeTimeoutMs??Ro.connectionTimeoutMs;try{let C;const w=new Promise((x,A)=>{C=setTimeout(()=>{h.close().catch(()=>{}),A(new Error(`Connection timed out after ${Math.round(m/1e3)}s`))},m)});try{await Promise.race([p.connect(h,{timeout:m}),w])}finally{clearTimeout(C)}d(),p.onerror=g}catch(C){p.onerror=g;const w=r.useProxy??!1?zO(r.url):new URL(r.url);throw a?.(Fa.ERROR,this.createLog(Fa.ERROR,`Connection failed during initialize: ${C instanceof Error?C.message:String(C)}`,_u.ERROR,{browser:this.getBrowserContext(w,r.useProxy??!1),config:{configuredUrl:r.url,credentials:r.credentials,effectiveUrl:w.href,headers:wH(r.headers,Object.keys(r.headers??{}),yH),serverName:e,transportType:f,useProxy:r.useProxy??!1},error:this.summarizeError(C),hints:this.getConnectionHints(w,r,C)})),C}const _=p.getServerVersion(),v=p.getServerCapabilities(),b=p.getInstructions(),y=this.extractServerInfo(_);a?.(Fa.CAPABILITIES_EXCHANGED,this.createLog(Fa.CAPABILITIES_EXCHANGED,"Capabilities exchanged successfully",_u.INFO,{serverCapabilities:v,serverInfo:y}),{clientCapabilities:u,instructions:b,serverCapabilities:v,serverInfo:y}),a?.(Fa.LISTING_TOOLS,this.createLog(Fa.LISTING_TOOLS,"Listing available tools..."));const E=await this.listTools({client:p,connectionTimeMs:0,requestTimeoutMs:r.requestTimeoutMs??Ro.requestTimeoutSeconds*1e3,serverName:e,tools:[],transport:h,transportType:f}),T=Math.round(performance.now()-o);return a?.(Fa.CONNECTED,this.createLog(Fa.CONNECTED,`Connection established with ${E.length} tools (${T}ms)`)),{client:p,clientCapabilities:u,connectionTimeMs:T,instructions:b,protocolVersion:Ro.protocolVersion,requestTimeoutMs:r.requestTimeoutMs??Ro.requestTimeoutSeconds*1e3,serverCapabilities:v,serverInfo:y,serverName:e,tools:E,transport:h,transportType:f}}static async disconnect(e){try{e.transport instanceof CEe&&await e.transport.terminateSession(),e.client.onerror=void 0,e.transport.onclose&&(e.transport.onclose=void 0),await e.client.close()}catch(r){console.warn(`[MCPService][${e.serverName}] Error during disconnect:`,r)}}static async listTools(e){try{return(await e.client.listTools()).tools??[]}catch(r){if(this.isSessionExpiredError(r))throw r;return console.warn(`[MCPService][${e.serverName}] Failed to list tools:`,r),[]}}static async listPrompts(e){try{return(await e.client.listPrompts()).prompts??[]}catch(r){if(this.isSessionExpiredError(r))throw r;return console.warn(`[MCPService][${e.serverName}] Failed to list prompts:`,r),[]}}static async getPrompt(e,r,n){try{return await e.client.getPrompt({arguments:n,name:r})}catch(i){throw console.error(`[MCPService][${e.serverName}] Failed to get prompt:`,i),i}}static async callTool(e,r,n){sMt(n);try{const i=await e.client.callTool({arguments:r.arguments,name:r.name},void 0,{signal:n,timeout:e.requestTimeoutMs});return{content:this.formatToolResult(i),isError:i.isError??!1}}catch(i){if(vu(i)||this.isSessionExpiredError(i))throw i;const a=i instanceof Error?i.message:String(i);throw new Error(`Tool "${r.name}" execution failed on server "${e.serverName}": ${a}`,{cause:i instanceof Error?i:void 0})}}static formatToolResult(e){const r=e.content;return Array.isArray(r)?r.map(n=>this.formatSingleContent(n)).filter(Boolean).join(` +`):""}static formatSingleContent(e){if(e.type===xD.TEXT&&e.text)return e.text;if(e.type===xD.IMAGE&&e.data)return HR(e.mimeType??ATt,e.data);if(e.type===xD.RESOURCE&&e.resource){const r=e.resource;return r.text?r.text:r.blob?r.blob:JSON.stringify(r)}return e.data&&e.mimeType?HR(e.mimeType,e.data):JSON.stringify(e)}static async complete(e,r,n){try{return(await e.client.complete({argument:n,ref:r})).completion}catch(i){return console.error("[MCPService] Failed to get completions:",i),null}}static async listResources(e,r){try{const n=await e.client.listResources(r?{cursor:r}:void 0);return{nextCursor:n.nextCursor,resources:n.resources??[]}}catch(n){if(this.isSessionExpiredError(n))throw n;return console.warn(`[MCPService][${e.serverName}] Failed to list resources:`,n),{resources:[]}}}static async listAllResources(e){const r=[];let n;do{const i=await this.listResources(e,n);r.push(...i.resources),n=i.nextCursor}while(n);return r}static async listResourceTemplates(e,r){try{const n=await e.client.listResourceTemplates(r?{cursor:r}:void 0);return{nextCursor:n.nextCursor,resourceTemplates:n.resourceTemplates??[]}}catch(n){if(this.isSessionExpiredError(n))throw n;return console.warn(`[MCPService][${e.serverName}] Failed to list resource templates:`,n),{resourceTemplates:[]}}}static async listAllResourceTemplates(e){const r=[];let n;do{const i=await this.listResourceTemplates(e,n);r.push(...i.resourceTemplates),n=i.nextCursor}while(n);return r}static async readResource(e,r){try{const n=await e.client.readResource({uri:r});return{_meta:n._meta,contents:n.contents??[]}}catch(n){throw console.error(`[MCPService][${e.serverName}] Failed to read resource:`,n),n}}static async subscribeResource(e,r){try{await e.client.subscribeResource({uri:r}),console.log(`[MCPService][${e.serverName}] Subscribed to resource: ${r}`)}catch(n){throw console.error(`[MCPService][${e.serverName}] Failed to subscribe to resource:`,n),n}}static async unsubscribeResource(e,r){try{await e.client.unsubscribeResource({uri:r})}catch(n){throw console.error(`[MCPService][${e.serverName}] Failed to unsubscribe from resource:`,n),n}}static supportsResources(e){return e.serverCapabilities?.resources!==void 0}static supportsResourceSubscriptions(e){return!!e.serverCapabilities?.resources?.subscribe}}function rDt(){return`${jTt}-${Date.now()}-${Math.random().toString(36).substring(2,9)}`}class nDt{#e=Oe(Zr(new ws));get _serverResources(){return S(this.#e)}set _serverResources(e){X(this.#e,e,!0)}#t=Oe(Zr(new ws));get _cachedResources(){return S(this.#t)}set _cachedResources(e){X(this.#t,e,!0)}#r=Oe(Zr(new ws));get _subscriptions(){return S(this.#r)}set _subscriptions(e){X(this.#r,e,!0)}#n=Oe(Zr([]));get _attachments(){return S(this.#n)}set _attachments(e){X(this.#n,e,!0)}#i=Oe(!1);get _isLoading(){return S(this.#i)}set _isLoading(e){X(this.#i,e,!0)}get serverResources(){return this._serverResources}get cachedResources(){return this._cachedResources}get subscriptions(){return this._subscriptions}get attachments(){return this._attachments}get isLoading(){return this._isLoading}get totalResourceCount(){let e=0;for(const r of this._serverResources.values())e+=r.resources.length;return e}get totalTemplateCount(){let e=0;for(const r of this._serverResources.values())e+=r.templates.length;return e}get attachmentCount(){return this._attachments.length}get hasAttachments(){return this._attachments.length>0}setServerResources(e,r,n){this._serverResources.set(e,{error:void 0,lastFetched:new Date,loading:!1,resources:r,serverName:e,templates:n}),console.log(`[MCPResources][${e}] Set ${r.length} resources, ${n.length} templates`)}setServerLoading(e,r){const n=this._serverResources.get(e);n?this._serverResources.set(e,{...n,loading:r}):this._serverResources.set(e,{error:void 0,loading:r,resources:[],serverName:e,templates:[]})}setServerError(e,r){const n=this._serverResources.get(e);n?this._serverResources.set(e,{...n,error:r,loading:!1}):this._serverResources.set(e,{error:r,loading:!1,resources:[],serverName:e,templates:[]})}getServerResources(e){return this._serverResources.get(e)}getAllResourceInfos(){const e=[];for(const[r,n]of this._serverResources)for(const i of n.resources)e.push({annotations:i.annotations,description:i.description,icons:i.icons,mimeType:i.mimeType,name:i.name,serverName:r,title:i.title,uri:i.uri});return e}getAllTemplateInfos(){const e=[];for(const[r,n]of this._serverResources)for(const i of n.templates)e.push({annotations:i.annotations,description:i.description,icons:i.icons,mimeType:i.mimeType,name:i.name,serverName:r,title:i.title,uriTemplate:i.uriTemplate});return e}clearServerResources(e){this._serverResources.delete(e);for(const[r,n]of this._cachedResources)n.resource.serverName===e&&this._cachedResources.delete(r);for(const[r,n]of this._subscriptions)n.serverName===e&&this._subscriptions.delete(r);console.log(`[MCPResources][${e}] Cleared all resources`)}cacheResourceContent(e,r){if(this._cachedResources.size>=hEt){const n=this._cachedResources.keys().next().value;n&&this._cachedResources.delete(n)}this._cachedResources.set(e.uri,{content:r,fetchedAt:new Date,resource:e,subscribed:this._subscriptions.has(e.uri)}),console.log(`[MCPResources] Cached content for: ${e.uri}`)}getCachedContent(e){const r=this._cachedResources.get(e);if(!r)return;if(Date.now()-r.fetchedAt.getTime()>fEt&&!r.subscribed){this._cachedResources.delete(e);return}return r}invalidateCache(e){this._cachedResources.delete(e),console.log(`[MCPResources] Invalidated cache for: ${e}`)}clearCache(){this._cachedResources.clear(),console.log("[MCPResources] Cleared all cached content")}addSubscription(e,r){this._subscriptions.set(e,{serverName:r,subscribedAt:new Date,uri:e});const n=this._cachedResources.get(e);n&&this._cachedResources.set(e,{...n,subscribed:!0}),console.log(`[MCPResources] Added subscription: ${e}`)}removeSubscription(e){this._subscriptions.delete(e);const r=this._cachedResources.get(e);r&&this._cachedResources.set(e,{...r,subscribed:!1}),console.log(`[MCPResources] Removed subscription: ${e}`)}isSubscribed(e){return this._subscriptions.has(e)}handleResourceUpdate(e){this.invalidateCache(e);const r=this._subscriptions.get(e);r&&this._subscriptions.set(e,{...r,lastUpdate:new Date}),console.log(`[MCPResources] Resource updated: ${e}`)}handleResourcesListChanged(e){const r=this._serverResources.get(e);r&&this._serverResources.set(e,{...r,lastFetched:void 0}),console.log(`[MCPResources][${e}] Resources list changed, needs refresh`)}addAttachment(e){const r={id:rDt(),loading:!0,resource:e};return this._attachments=[...this._attachments,r],console.log(`[MCPResources] Added attachment: ${e.uri}`),r}updateAttachmentContent(e,r){this._attachments=this._attachments.map(n=>n.id===e?{...n,content:r,error:void 0,loading:!1}:n)}updateAttachmentError(e,r){this._attachments=this._attachments.map(n=>n.id===e?{...n,error:r,loading:!1}:n)}removeAttachment(e){this._attachments=this._attachments.filter(r=>r.id!==e),console.log(`[MCPResources] Removed attachment: ${e}`)}clearAttachments(){this._attachments=[],console.log("[MCPResources] Cleared all attachments")}getAttachment(e){return this._attachments.find(r=>r.id===e)}isAttached(e){const r=jO(e);return this._attachments.some(n=>n.resource.uri===e||jO(n.resource.uri)===r)}setLoading(e){this._isLoading=e}findResourceByUri(e){const r=jO(e);for(const[n,i]of this._serverResources){const a=i.resources.find(s=>s.uri===e)??i.resources.find(s=>jO(s.uri)===r);if(a)return{annotations:a.annotations,description:a.description,icons:a.icons,mimeType:a.mimeType,name:a.name,serverName:n,title:a.title,uri:a.uri}}}findServerForUri(e){for(const[r,n]of this._serverResources)if(n.resources.some(i=>i.uri===e))return r}clear(){this._serverResources.clear(),this._cachedResources.clear(),this._subscriptions.clear(),this._attachments=[],this._isLoading=!1,console.log("[MCPResources] Cleared all state")}formatAttachmentsForContext(){if(this._attachments.length===0)return"";const e=[];for(const r of this._attachments){if(r.error||!r.content||r.content.length===0)continue;const n=r.resource.title||r.resource.name,i=r.resource.serverName;for(const a of r.content)"text"in a&&a.text?e.push(` + +--- Resource: ${n} (from ${i}) --- +${a.text}`):"blob"in a&&a.blob&&e.push(` + +--- Resource: ${n} (from ${i}) --- +[${v_e}: ${a.mimeType||__e}]`)}return e.join("")}toMessageExtras(){const e=[];for(const r of this._attachments){if(r.error||!r.content||r.content.length===0)continue;const n=r.resource.title||r.resource.name,i=[];for(const a of r.content)"text"in a&&a.text?i.push(a.text):"blob"in a&&a.blob&&i.push(`[${v_e}: ${a.mimeType||__e}]`);i.length>0&&e.push({content:i.join(Na),mimeType:r.resource.mimeType,name:n,serverName:r.resource.serverName,type:Ti.MCP_RESOURCE,uri:r.resource.uri})}return e}}const da=new nDt,VDe=()=>da.serverResources,iDt=()=>da.attachments,YDe=()=>da.hasAttachments,aDt=()=>da.totalResourceCount,sDt=()=>da.isLoading;class oDt{#e=Oe(!1);get _isInitializing(){return S(this.#e)}set _isInitializing(e){X(this.#e,e,!0)}#t=Oe(null);get _error(){return S(this.#t)}set _error(e){X(this.#t,e,!0)}#r=Oe(0);get _toolCount(){return S(this.#r)}set _toolCount(e){X(this.#r,e,!0)}#n=Oe(Zr([]));get _connectedServers(){return S(this.#n)}set _connectedServers(e){X(this.#n,e,!0)}#i=Oe(Zr({}));get _healthChecks(){return S(this.#i)}set _healthChecks(e){X(this.#i,e,!0)}connections=new Map;toolsIndex=new Map;serverConfigs=new Map;reconnectingServers=new Set;configSignature=null;initPromise=null;activeFlowCount=0;get isProxyAvailable(){return $a.props?.cors_proxy_enabled??!1}#a(e,r){return typeof e=="string"&&e.trim()?e.trim():`${HL}-${r+1}`}#s(e){if(!e)return[];let r;if(typeof e=="string"){const n=e.trim();if(!n)return[];try{r=JSON.parse(n)}catch(i){return console.warn("[MCP] Failed to parse mcpServers JSON:",i),[]}}else r=e;return Array.isArray(r)?r.map((n,i)=>{const a=typeof n?.url=="string"?n.url.trim():"",s=typeof n?.headers=="string"?n.headers.trim():void 0;return{displayName:n?.displayName,enabled:!!n?.enabled,headers:s||void 0,id:this.#a(n?.id,i),name:n?.name,url:a,useProxy:!!n?.useProxy}}):[]}#o(){const e=Number(Vn().mcpRequestTimeoutSeconds)||Ro.requestTimeoutSeconds;return Math.round(e*1e3)}#l(e,r=Ro.connectionTimeoutMs){if(!e?.url)return;let n;if(e.headers)try{const i=JSON.parse(e.headers);typeof i=="object"&&i!==null&&!Array.isArray(i)&&(n=i)}catch{console.warn("[MCP] Failed to parse custom headers JSON:",e.headers)}return{handshakeTimeoutMs:r,headers:n,requestTimeoutMs:this.#o(),transport:y2e(e.url),url:e.url,useProxy:e.useProxy}}#c(e,r){return r?.find(i=>i.serverId===e.id)?.enabled??e.enabled}#d(e,r){const n=this.#s(e.mcpServers);if(!n.length)return;const i={};for(const[a,s]of n.entries()){if(!this.#c(s,r))continue;const o=this.#l(s);o&&(i[this.#a(s.id,a)]=o)}if(Object.keys(i).length!==0)return{capabilities:Ro.capabilities,clientInfo:Ro.clientInfo,protocolVersion:Ro.protocolVersion,requestTimeoutMs:this.#o(),servers:i}}#u(e,r){return{client:{elicitation:r?.elicitation?{form:!!r.elicitation.form,url:!!r.elicitation.url}:void 0,roots:r?.roots?{listChanged:r.roots.listChanged}:void 0,sampling:!!r?.sampling,tasks:!!r?.tasks},server:{completions:!!e?.completions,logging:!!e?.logging,prompts:e?.prompts?{listChanged:e.prompts.listChanged}:void 0,resources:e?.resources?{listChanged:e.resources.listChanged,subscribe:e.resources.subscribe}:void 0,tasks:!!e?.tasks,tools:e?.tools?{listChanged:e.tools.listChanged}:void 0}}}get isInitializing(){return this._isInitializing}get isInitialized(){return this.connections.size>0}get error(){return this._error}get toolCount(){return this._toolCount}get connectedServerCount(){return this._connectedServers.length}get connectedServerNames(){return this._connectedServers}get isEnabled(){const e=this.#d(Vn());return e!=null&&Object.keys(e.servers).length>0}get availableTools(){return Array.from(this.toolsIndex.keys())}updateState(e){e.isInitializing!==void 0&&(this._isInitializing=e.isInitializing),e.error!==void 0&&(this._error=e.error),e.toolCount!==void 0&&(this._toolCount=e.toolCount),e.connectedServers!==void 0&&(this._connectedServers=e.connectedServers)}updateHealthCheck(e,r){this._healthChecks={...this._healthChecks,[e]:r}}getHealthCheckState(e){return this._healthChecks[e]??{status:Aa.IDLE}}hasHealthCheck(e){return e in this._healthChecks&&this._healthChecks[e].status!==Aa.IDLE}clearHealthCheck(e){const{[e]:r,...n}=this._healthChecks;this._healthChecks=n}clearAllHealthChecks(){this._healthChecks={}}clearError(){this._error=null}getServers(){return b2e(Vn().mcpServers)}getConnections(){return this.connections}#p(e){if(e.displayName)return e.displayName;const r=this.getHealthCheckState(e.id);return r?.status===Aa.SUCCESS?r.serverInfo?.title||r.serverInfo?.name||e.name||e.url:e.name||e.url}getServerLabel(e){const r=this.#p(e),n=this.getServers().filter(a=>this.#p(a)===r);if(n.length<2)return r;const i=n.findIndex(a=>a.id===e.id);return i<0?r:`${r} (${i+1})`}getServerById(e){return this.getServers().find(r=>r.id===e)}getServerDisplayName(e){const r=this.getServerById(e);return r?this.getServerLabel(r):e}#g(e){try{return e.startsWith(Uu.DATA)?!0:new URL(e).protocol===Uu.HTTPS}catch{return!1}}#f(e,r=!1){if(!e?.length)return null;const n=e.filter(o=>!(!o.src||!this.#g(o.src)||o.mimeType&&!RTt.has(o.mimeType)));if(n.length===0)return null;const i=r?pf.DARK:pf.LIGHT,a=n.find(o=>o.theme===i);if(a)return a.src;const s=n.filter(o=>!o.theme);return s.length===DTt?s[r?1:0].src:s.length>0?s[0].src:n[0].src}getServerFavicon(e){const r=this.getServerById(e);if(!r)return null;const n=f2.current===pf.DARK,i=this.getHealthCheckState(e);if(i.status===Aa.SUCCESS&&i.serverInfo?.icons){const a=this.#f(i.serverInfo.icons,n);if(a)return a}return this.#h(r.url)}#h(e){try{const r=new URL(e),n=O4t(r);if(!n)return null;const i=`${r.protocol}//${n}`,a=["favicon.ico","favicon.png"];for(const s of a){const o=`${i}/${s}`;if(this.#g(o))return o}}catch{}return null}addServer(e){const r=this.getServers(),n={displayName:e.displayName,enabled:e.enabled,headers:e.headers?.trim()||void 0,id:e.id||(mg()??`server-${Date.now()}`),name:e.name,url:e.url.trim(),useProxy:e.useProxy};return nl.updateConfig(hr.MCP_SERVERS,JSON.stringify([...r,n])),n}updateServer(e,r){const n=this.getServers();nl.updateConfig(hr.MCP_SERVERS,JSON.stringify(n.map(i=>i.id===e?{...i,...r}:i)))}removeServer(e){const r=this.getServers();nl.updateConfig(hr.MCP_SERVERS,JSON.stringify(r.filter(n=>n.id!==e))),this.clearHealthCheck(e)}hasAvailableServers(){return b2e(Vn().mcpServers).some(e=>e.enabled&&e.url.trim())}hasEnabledServers(e){return!!this.#d(Vn(),e)}getEnabledServersForConversation(e){return this.getServers().filter(r=>this.#c(r,e))}async ensureInitialized(e){const r=this.#d(Vn(),e),n=r?JSON.stringify(r):null;return n?this.isInitialized&&this.configSignature===n?!0:this.initPromise&&this.configSignature===n?this.initPromise:((this.connections.size>0||this.initPromise)&&await this.shutdown(),this.initialize(n,r)):(await this.shutdown(),!1)}async initialize(e,r){this.updateState({error:null,isInitializing:!0}),this.configSignature=e;const n=Object.entries(r.servers);return n.length===0?(this.updateState({connectedServers:[],isInitializing:!1,toolCount:0}),!1):(this.initPromise=this.doInitialize(e,r,n),this.initPromise)}async doInitialize(e,r,n){const i=r.clientInfo??Ro.clientInfo,a=r.capabilities??Ro.capabilities,s=await Promise.allSettled(n.map(async([l,u])=>{this.serverConfigs.set(l,u);const d=this.createListChangedHandlers(l);return{connection:await Qa.connect(l,u,i,a,f=>{f===Fa.DISCONNECTED&&(console.log(`[MCPStore][${l}] Connection lost, starting auto-reconnect`),this.autoReconnect(l))},d),name:l}}));if(this.configSignature!==e){for(const l of s)l.status==="fulfilled"&&await Qa.disconnect(l.value.connection).catch(console.warn);return!1}for(const l of s)if(l.status==="fulfilled"){const{connection:u,name:d}=l.value;this.connections.set(d,u);for(const h of u.tools)this.toolsIndex.has(h.name)&&console.warn(`[MCPStore] Tool name conflict: "${h.name}" exists in "${this.toolsIndex.get(h.name)}" and "${d}". Using tool from "${d}".`),this.toolsIndex.set(h.name,d)}else console.error("[MCPStore] Failed to connect:",l.reason);return this.connections.size===0&&n.length>0?(this.updateState({connectedServers:[],error:"All MCP server connections failed",isInitializing:!1,toolCount:0}),this.initPromise=null,!1):(this.updateState({connectedServers:Array.from(this.connections.keys()),error:null,isInitializing:!1,toolCount:this.toolsIndex.size}),this.initPromise=null,!0)}createListChangedHandlers(e){return{prompts:{onChanged:r=>{if(r){console.warn(`[MCPStore][${e}] Prompts list changed error:`,r);return}}},tools:{onChanged:(r,n)=>{if(r){console.warn(`[MCPStore][${e}] Tools list changed error:`,r);return}this.handleToolsListChanged(e,n??[])}}}}handleToolsListChanged(e,r){const n=this.connections.get(e);if(n){for(const[i,a]of this.toolsIndex.entries())a===e&&this.toolsIndex.delete(i);n.tools=r;for(const i of r)this.toolsIndex.has(i.name)&&console.warn(`[MCPStore] Tool name conflict after list change: "${i.name}" exists in "${this.toolsIndex.get(i.name)}" and "${e}". Using tool from "${e}".`),this.toolsIndex.set(i.name,e);this.updateState({toolCount:this.toolsIndex.size})}}acquireConnection(){this.activeFlowCount++}async releaseConnection(e=!1){this.activeFlowCount=Math.max(0,this.activeFlowCount-1),e&&this.activeFlowCount===0&&await this.shutdown()}getActiveFlowCount(){return this.activeFlowCount}async shutdown(){this.initPromise&&(await this.initPromise.catch(()=>{}),this.initPromise=null),this.connections.size!==0&&(await Promise.all(Array.from(this.connections.values()).map(e=>Qa.disconnect(e).catch(r=>console.warn(`[MCPStore] Error disconnecting ${e.serverName}:`,r)))),this.connections.clear(),this.toolsIndex.clear(),this.serverConfigs.clear(),this.configSignature=null,this.updateState({connectedServers:[],error:null,isInitializing:!1,toolCount:0}))}async reconnectServer(e){const r=this.serverConfigs.get(e);if(!r)throw new Error(`[MCPStore] No config found for ${e}, cannot reconnect`);const n=this.connections.get(e);n&&(await Qa.disconnect(n).catch(console.warn),this.connections.delete(e)),console.log(`[MCPStore][${e}] Session expired, reconnecting with fresh session...`);const i=this.createListChangedHandlers(e),a=await Qa.connect(e,r,Ro.clientInfo,Ro.capabilities,s=>{s===Fa.DISCONNECTED&&(console.log(`[MCPStore][${e}] Connection lost, starting auto-reconnect`),this.autoReconnect(e))},i);this.connections.set(e,a);for(const s of a.tools)this.toolsIndex.set(s.name,e);console.log(`[MCPStore][${e}] Session recovered successfully`)}async autoReconnect(e){if(this.reconnectingServers.has(e)){console.log(`[MCPStore][${e}] Reconnection already in progress, skipping`);return}const r=this.serverConfigs.get(e);if(!r){console.error(`[MCPStore] No config found for ${e}, cannot reconnect`);return}this.reconnectingServers.add(e);let n=OTt,i=!1;try{for(;;){await new Promise(a=>setTimeout(a,n)),console.log(`[MCPStore][${e}] Auto-reconnecting...`);try{const a=new Promise((u,d)=>setTimeout(()=>d(new Error(`Reconnect attempt timed out after ${m_e}ms`)),m_e));i=!1;const s=this.createListChangedHandlers(e),o=Qa.connect(e,r,Ro.clientInfo,Ro.capabilities,u=>{u===Fa.DISCONNECTED&&(this.reconnectingServers.has(e)?i=!0:(console.log(`[MCPStore][${e}] Connection lost, restarting auto-reconnect`),this.autoReconnect(e)))},s),l=await Promise.race([o,a]);this.connections.set(e,l);for(const u of l.tools)this.toolsIndex.set(u.name,e);console.log(`[MCPStore][${e}] Reconnected successfully`);break}catch(a){console.warn(`[MCPStore][${e}] Reconnection failed:`,a),n=Math.min(n*ITt,kTt)}}}finally{this.reconnectingServers.delete(e),i&&(console.log(`[MCPStore][${e}] Deferred disconnect detected, restarting auto-reconnect`),this.autoReconnect(e))}}getToolNames(){return Array.from(this.toolsIndex.keys())}hasTool(e){return this.toolsIndex.has(e)}getToolServer(e){return this.toolsIndex.get(e)}findServerForTool(e){const r=this.toolsIndex.get(e);if(r)return r;for(const n of this.getServers()){const i=this._healthChecks[n.id];if(!(!i||i.status!==Aa.SUCCESS)&&i.tools.some(a=>a.name===e))return n.id}}getServerFaviconForTool(e){if(!e)return null;const r=this.findServerForTool(e);return r?this.getServerFavicon(r):null}hasPromptsSupport(){for(const e of this.connections.values())if(e.serverCapabilities?.prompts)return!0;return!1}hasPromptsCapability(e){let r;if(e!==void 0?r=new Set(e.filter(n=>n.enabled).map(n=>n.serverId)):r=new Set(this.getServers().filter(n=>n.enabled).map(n=>n.id)),r.size===0)return!1;for(const[n,i]of Object.entries(this._healthChecks))if(r.has(n)&&i.status===Aa.SUCCESS&&i.capabilities?.server?.prompts!==void 0)return!0;for(const[n,i]of this.connections)if(r.has(n)&&i.serverCapabilities?.prompts)return!0;return!1}async getAllPrompts(){const e=[];for(const[r,n]of this.connections){if(!n.serverCapabilities?.prompts)continue;const i=await Qa.listPrompts(n);for(const a of i)e.push({arguments:a.arguments?.map(s=>({description:s.description,name:s.name,required:s.required})),description:a.description,name:a.name,serverName:r,title:a.title})}return e}async getPrompt(e,r,n){const i=this.connections.get(e);if(!i)throw new Error(`Server "${e}" not found for prompt "${r}"`);return Qa.getPrompt(i,r,n)}async executeTool(e,r){const n=e.function.name,i=this.toolsIndex.get(n);if(!i)throw new Error(`Unknown tool: ${n}`);const a=this.connections.get(i);if(!a)throw new Error(`Server "${i}" is not connected`);const s=this.parseToolArguments(e.function.arguments);try{return await Qa.callTool(a,{arguments:s,name:n},r)}catch(o){if(Qa.isSessionExpiredError(o)){await this.reconnectServer(i);const l=this.connections.get(i);if(!l)throw new Error(`Failed to reconnect to "${i}"`);return Qa.callTool(l,{arguments:s,name:n},r)}throw o}}async executeToolByName(e,r,n){const i=this.toolsIndex.get(e);if(!i)throw new Error(`Unknown tool: ${e}`);const a=this.connections.get(i);if(!a)throw new Error(`Server "${i}" is not connected`);try{return await Qa.callTool(a,{arguments:r,name:e},n)}catch(s){if(Qa.isSessionExpiredError(s)){await this.reconnectServer(i);const o=this.connections.get(i);if(!o)throw new Error(`Failed to reconnect to "${i}"`);return Qa.callTool(o,{arguments:r,name:e},n)}throw s}}parseToolArguments(e){if(typeof e=="string"){const r=e.trim();if(r==="")return{};try{const n=JSON.parse(r);if(typeof n!="object"||n===null||Array.isArray(n))throw new Error(`Tool arguments must be an object, got ${Array.isArray(n)?"array":typeof n}`);return n}catch(n){throw new Error(`Failed to parse tool arguments as JSON: ${n.message}`)}}if(typeof e=="object"&&e!==null&&!Array.isArray(e))return e;throw new Error(`Invalid tool arguments type: ${typeof e}`)}async getPromptCompletions(e,r,n,i){const a=this.connections.get(e);return a?a.serverCapabilities?.completions?Qa.complete(a,{name:r,type:kJ.PROMPT},{name:n,value:i}):null:(console.warn(`[MCPStore] Server "${e}" is not connected`),null)}async getResourceCompletions(e,r,n,i){const a=this.connections.get(e);return a?a.serverCapabilities?.completions?Qa.complete(a,{type:kJ.RESOURCE,uri:r},{name:n,value:i}):null:(console.warn(`[MCPStore] Server "${e}" is not connected`),null)}async readResourceByUri(e,r){const n=this.connections.get(e);if(!n)return console.error(`[MCPStore] No connection found for server: ${e}`),null;try{return(await Qa.readResource(n,r)).contents}catch(i){return console.error(`[MCPStore] Failed to read resource ${r}:`,i),null}}parseHeaders(e){if(e?.trim())try{const r=JSON.parse(e);if(typeof r=="object"&&r!==null&&!Array.isArray(r))return r}catch{console.warn("[MCPStore] Failed to parse custom headers JSON:",e)}}async runHealthChecksForServers(e,r=!0,n=!1){const i=r?e.filter(s=>!this.hasHealthCheck(s.id)&&s.url.trim()):e.filter(s=>s.url.trim());if(i.length===0)return;const a=5;for(let s=0;sthis.runHealthCheck(l,n)))}}getExistingConnection(e){return this.connections.get(e)}async runHealthCheck(e,r=!1){const n=this.connections.get(e.id);if(n)try{const u=await Qa.listTools(n),d=this.#u(n.serverCapabilities,n.clientCapabilities);this.updateHealthCheck(e.id,{capabilities:d,connectionTimeMs:n.connectionTimeMs,instructions:n.instructions,logs:[],protocolVersion:n.protocolVersion,serverInfo:n.serverInfo,status:Aa.SUCCESS,tools:u.map(h=>({description:h.description,name:h.name,title:h.title})),transportType:n.transportType});return}catch(u){console.warn(`[MCPStore] Failed to reuse connection for ${e.id}, creating new one:`,u),this.connections.delete(e.id)}const i=e.url.trim(),a=[];let s=Fa.IDLE;if(!i){this.updateHealthCheck(e.id,{logs:[],message:"Please enter a server URL first.",status:Aa.ERROR});return}this.updateHealthCheck(e.id,{logs:[],phase:Fa.TRANSPORT_CREATING,status:Aa.CONNECTING});const o=this.#o(),l=this.parseHeaders(e.headers);try{const u={handshakeTimeoutMs:Ro.connectionTimeoutMs,headers:l,requestTimeoutMs:o,transport:y2e(i),url:i,useProxy:e.useProxy};this.serverConfigs.set(e.id,u);const d=await Qa.connect(e.id,u,Ro.clientInfo,Ro.capabilities,(p,g)=>{s=p,a.push(g),this.updateHealthCheck(e.id,{logs:[...a],phase:p,status:Aa.CONNECTING}),p===Fa.DISCONNECTED&&r&&(console.log(`[MCPStore][${e.id}] Connection lost during health check, starting auto-reconnect`),this.autoReconnect(e.id))}),h=d.tools.map(p=>({description:p.description,name:p.name,title:p.title})),f=this.#u(d.serverCapabilities,d.clientCapabilities);this.updateHealthCheck(e.id,{capabilities:f,connectionTimeMs:d.connectionTimeMs,instructions:d.instructions,logs:a,protocolVersion:d.protocolVersion,serverInfo:d.serverInfo,status:Aa.SUCCESS,tools:h,transportType:d.transportType}),r&&e.enabled?this.promoteHealthCheckToConnection(e.id,d):await Qa.disconnect(d)}catch(u){const d=u instanceof Error?u.message:"Unknown error occurred";a.at(-1)?.phase!==Fa.ERROR&&a.push({level:_u.ERROR,message:`Connection failed: ${d}`,phase:Fa.ERROR,timestamp:new Date}),this.updateHealthCheck(e.id,{logs:a,message:d,phase:s,status:Aa.ERROR})}}promoteHealthCheckToConnection(e,r){for(const n of r.tools)this.toolsIndex.has(n.name)&&console.warn(`[MCPStore] Tool name conflict during promotion: "${n.name}" exists in "${this.toolsIndex.get(n.name)}" and "${e}". Using tool from "${e}".`),this.toolsIndex.set(n.name,e);this.connections.set(e,r),this.updateState({connectedServers:Array.from(this.connections.keys()),toolCount:this.toolsIndex.size})}getServersStatus(){const e=[];for(const[r,n]of this.connections)e.push({error:void 0,isConnected:!0,name:r,toolCount:n.tools.length});return e}getServerInstructions(){const e=[];for(const[r,n]of this.connections)n.instructions&&e.push({instructions:n.instructions,serverName:r,serverTitle:n.serverInfo?.title||n.serverInfo?.name});return e}getHealthCheckInstructions(){const e=[];for(const[r,n]of Object.entries(this._healthChecks))n.status===Aa.SUCCESS&&n.instructions&&e.push({instructions:n.instructions,serverId:r,serverTitle:n.serverInfo?.title||n.serverInfo?.name});return e}hasServerInstructions(){for(const e of this.connections.values())if(e.instructions)return!0;return!1}hasResourcesCapability(e){let r;if(e!==void 0?r=new Set(e.filter(n=>n.enabled).map(n=>n.serverId)):r=new Set(this.getServers().filter(n=>n.enabled).map(n=>n.id)),r.size===0)return!1;for(const[n,i]of Object.entries(this._healthChecks))if(r.has(n)&&i.status===Aa.SUCCESS&&i.capabilities?.server?.resources!==void 0)return!0;for(const[n,i]of this.connections)if(r.has(n)&&Qa.supportsResources(i))return!0;return!1}getServersWithResources(){const e=new Set(this.getServers().filter(n=>n.enabled).map(n=>n.id)),r=[];for(const[n,i]of this.connections)e.has(n)&&Qa.supportsResources(i)&&!r.includes(n)&&r.push(n);for(const[n,i]of Object.entries(this._healthChecks))e.has(n)&&!r.includes(n)&&i.status===Aa.SUCCESS&&i.capabilities?.server?.resources!==void 0&&r.push(n);return r}async fetchAllResources(e=!1){const r=this.getServersWithResources();if(r.length!==0){if(!e&&r.every(i=>{const a=da.getServerResources(i);return!a||!a.lastFetched?!1:Date.now()-a.lastFetched.getTime()this.fetchServerResources(n)))}finally{da.setLoading(!1)}}}async fetchServerResources(e){const r=this.connections.get(e);if(!r){console.warn(`[MCPStore] No connection found for server: ${e}`);return}if(Qa.supportsResources(r)){da.setServerLoading(e,!0);try{const[n,i]=await Promise.all([Qa.listAllResources(r),Qa.listAllResourceTemplates(r)]);da.setServerResources(e,n,i)}catch(n){const i=n instanceof Error?n.message:String(n);da.setServerError(e,i),console.error(`[MCPStore][${e}] Failed to fetch resources:`,n)}}}async readResource(e){const r=da.getCachedContent(e);if(r)return r.content;const n=da.findServerForUri(e);if(!n)return console.error(`[MCPStore] No server found for resource URI: ${e}`),null;const i=this.connections.get(n);if(!i)return console.error(`[MCPStore] No connection found for server: ${n}`),null;try{const a=await Qa.readResource(i,e),s=da.findResourceByUri(e);return s&&da.cacheResourceContent(s,a.contents),a.contents}catch(a){return console.error(`[MCPStore] Failed to read resource ${e}:`,a),null}}async subscribeToResource(e){const r=da.findServerForUri(e);if(!r)return console.error(`[MCPStore] No server found for resource URI: ${e}`),!1;const n=this.connections.get(r);if(!n)return console.error(`[MCPStore] No connection found for server: ${r}`),!1;if(!Qa.supportsResourceSubscriptions(n))return!1;try{return await Qa.subscribeResource(n,e),da.addSubscription(e,r),!0}catch(i){return console.error(`[MCPStore] Failed to subscribe to resource ${e}:`,i),!1}}async unsubscribeFromResource(e){const r=da.findServerForUri(e);if(!r)return console.error(`[MCPStore] No server found for resource URI: ${e}`),!1;const n=this.connections.get(r);if(!n)return console.error(`[MCPStore] No connection found for server: ${r}`),!1;try{return await Qa.unsubscribeResource(n,e),da.removeSubscription(e),!0}catch(i){return console.error(`[MCPStore] Failed to unsubscribe from resource ${e}:`,i),!1}}async attachResource(e){const r=da.findResourceByUri(e);if(!r)return console.error(`[MCPStore] Resource not found: ${e}`),null;if(da.isAttached(e))return null;const n=da.addAttachment(r);try{const i=await this.readResource(e);i?da.updateAttachmentContent(n.id,i):da.updateAttachmentError(n.id,"Failed to read resource")}catch(i){const a=i instanceof Error?i.message:String(i);da.updateAttachmentError(n.id,a)}return da.getAttachment(n.id)??null}removeResourceAttachment(e){da.removeAttachment(e)}clearResourceAttachments(){da.clearAttachments()}getResourceContextForChat(){return da.formatAttachmentsForContext()}consumeResourceAttachmentsAsExtras(){const e=da.toMessageExtras();return e.length>0&&da.clearAttachments(),e}}const Xr=new oDt;class lDt{#e=Oe(Zr([...lEt]));get _builtinTools(){return S(this.#e)}set _builtinTools(e){X(this.#e,e,!0)}#t=Oe(!1);get _loading(){return S(this.#t)}set _loading(e){X(this.#t,e,!0)}#r=Oe(null);get _error(){return S(this.#r)}set _error(e){X(this.#r,e,!0)}#n=Oe(Zr(new ka));get _disabledTools(){return S(this.#n)}set _disabledTools(e){X(this.#n,e,!0)}#i=Oe(Zr(new ka([rn.READ_FILE,rn.WRITE_FILE,rn.EDIT_FILE,rn.FILE_GLOB_SEARCH,rn.GREP_SEARCH,rn.EXEC_SHELL_COMMAND])));get _cwdAwareTools(){return S(this.#i)}set _cwdAwareTools(e){X(this.#i,e,!0)}#a=Oe(!1);get _toolsEndpointUnreachable(){return S(this.#a)}set _toolsEndpointUnreachable(e){X(this.#a,e,!0)}#s=Oe(void 0);get _serverHome(){return S(this.#s)}set _serverHome(e){X(this.#s,e,!0)}constructor(){try{const e=localStorage.getItem(Q1e);if(e){const r=JSON.parse(e);if(Array.isArray(r))for(const n of r)typeof n=="string"&&this._disabledTools.add(n)}}catch(e){console.error("[ToolsStore] Failed to load disabled tools from localStorage:",e)}this.fetchBuiltinTools()}persistDisabledTools(){try{localStorage.setItem(Q1e,JSON.stringify([...this._disabledTools]))}catch{}}toolKey(e,r,n){switch(e){case Jn.MCP:return n?`mcp-${n}:${r}`:`mcp:${r}`;case Jn.CUSTOM:return`custom:${r}`;case Jn.FRONTEND:return`frontend:${r}`;default:return`builtin:${r}`}}inferTypeFromDefault(e){if(typeof e=="string")return"string";if(typeof e=="boolean")return"boolean";if(typeof e=="number")return Number.isInteger(e)?"integer":"number";if(Array.isArray(e))return"array";if(e!==null&&typeof e=="object")return"object"}normalizeJsonSchema(e){if(!e||typeof e!="object")return e;const r={...e};if(r.properties&&typeof r.properties=="object"){const n=r.properties,i={};for(const[a,s]of Object.entries(n)){if(!s||typeof s!="object"){i[a]=s;continue}const o={...s};if(!o.type&&o.default!==void 0){const l=this.inferTypeFromDefault(o.default);l&&(o.type=l)}o.properties&&Object.assign(o,this.normalizeJsonSchema(o)),o.items&&typeof o.items=="object"&&(o.items=this.normalizeJsonSchema(o.items)),i[a]=o}r.properties=i}return r}mcpDefinition(e,r,n){return{function:{description:r,name:e,parameters:n??{properties:{},required:[],type:UT.OBJECT}},type:ud.FUNCTION}}get builtinTools(){return this._builtinTools}get serverHome(){return this._serverHome??null}get mcpTools(){return this.mcpEntries().map(e=>e.definition)}get frontendTools(){return Vn().jsSandboxEnabled?[wCt(!!Vn().symbolicMathEnabled)]:[]}get customTools(){const e=Vn().customJson;if(!e||typeof e!="string")return[];try{const r=JSON.parse(e);return Array.isArray(r)?r.filter(n=>typeof n=="object"&&n!==null&&"type"in n&&n.type==="function"&&"function"in n&&typeof n.function?.name=="string"):[]}catch{return[]}}mcpEntries(){const e=[],r=Xr.getConnections();if(r.size>0)for(const[n,i]of r){const a=Xr.getServerDisplayName(n);for(const s of i.tools){const o=s.inputSchema??{properties:{},required:[],type:UT.OBJECT};e.push({definition:{function:{description:s.description,name:s.name,parameters:this.normalizeJsonSchema(o)},type:ud.FUNCTION},serverId:n,serverName:a})}}else for(const{serverId:n,serverName:i,tools:a}of this.getMcpToolsFromHealthChecks())for(const s of a)e.push({definition:this.mcpDefinition(s.name,s.description),serverId:n,serverName:i});return e}get allTools(){const e=[],r=new ka,n=i=>{r.has(i.key)||(r.add(i.key),e.push(i))};for(const i of this._builtinTools){const a=i.function.name;n({definition:i,key:this.toolKey(Jn.BUILTIN,a),source:Jn.BUILTIN})}for(const i of this.frontendTools){const a=i.function.name;n({definition:i,key:this.toolKey(Jn.FRONTEND,a),source:Jn.FRONTEND})}for(const{definition:i,serverId:a,serverName:s}of this.mcpEntries()){const o=i.function.name;n({definition:i,key:this.toolKey(Jn.MCP,o,a),serverId:a,serverName:s,source:Jn.MCP})}for(const i of this.customTools){const a=i.function.name;n({definition:i,key:this.toolKey(Jn.CUSTOM,a),source:Jn.CUSTOM})}return e}get toolGroups(){const e=[],r=new ws;for(const n of this.allTools){const i=n.source===Jn.MCP?`mcp:${n.serverId??""}`:n.source;let a=r.get(i);a||(a={key:i,label:this.groupLabel(n),serverId:n.serverId,source:n.source,tools:[]},r.set(i,a),e.push(a)),a.tools.push(n)}return e}groupLabel(e){switch(e.source){case Jn.MCP:return e.serverName??"";case Jn.CUSTOM:return SH[Jn.CUSTOM];case Jn.FRONTEND:return SH[Jn.FRONTEND];default:return SH[Jn.BUILTIN]}}getEnabledToolsForLLM(){const e=new ka;for(const a of this.allTools)this._disabledTools.has(a.key)||e.add(a.definition.function.name);const r=[],n=new ka,i=a=>{const s=a.function.name;!e.has(s)||n.has(s)||(n.add(s),r.push(a))};for(const a of this._builtinTools)i(a);for(const a of this.frontendTools)i(a);for(const a of this.mcpEntries())i(a.definition);for(const a of this.customTools)i(a);return r}get allToolDefinitions(){return this.allTools.map(e=>e.definition)}get loading(){return this._loading}get error(){return this._error}get isToolsEndpointUnreachable(){return this._toolsEndpointUnreachable}get disabledTools(){return this._disabledTools}isToolEnabled(e){return!this._disabledTools.has(e)}toggleTool(e){this._disabledTools.has(e)?this._disabledTools.delete(e):this._disabledTools.add(e),this.persistDisabledTools()}setToolEnabled(e,r){r?this._disabledTools.delete(e):this._disabledTools.add(e)}enableAllToolsForServer(e){const r=Xr.getConnections().get(e);if(r){for(const n of r.tools)this._disabledTools.delete(this.toolKey(Jn.MCP,n.name,e));this.persistDisabledTools()}}toggleGroup(e){const n=!e.tools.every(i=>this.isToolEnabled(i.key));for(const i of e.tools)n?this._disabledTools.delete(i.key):this._disabledTools.add(i.key);this.persistDisabledTools()}isGroupFullyEnabled(e){return e.tools.length>0&&e.tools.every(r=>this.isToolEnabled(r.key))}getMcpToolsFromHealthChecks(){const e=[];for(const r of Xr.getServers()){if(!r.enabled)continue;const n=Xr.getHealthCheckState(r.id);n.status===Aa.SUCCESS&&n.tools.length>0&&e.push({serverId:r.id,serverName:Xr.getServerLabel(r),tools:n.tools})}return e}findEntryByName(e){for(const r of this.allTools)if(r.definition.function.name===e)return r;return null}getToolSource(e){return this.findEntryByName(e)?.source??null}getToolServerLabel(e){const r=this.findEntryByName(e);return r?r.serverName?Xr.getServerDisplayName(r.serverName):r.source===Jn.BUILTIN?L9[Jn.BUILTIN]:r.source===Jn.CUSTOM?L9[Jn.CUSTOM]:r.source===Jn.FRONTEND?L9[Jn.FRONTEND]:"":""}getPermissionKey(e){return this.findEntryByName(e)?.key??null}get hasEnabledTools(){return this.getEnabledToolsForLLM().length>0}get hasEnabledCwdTools(){return this._builtinTools.some(e=>{const r=e.function.name;return this._cwdAwareTools.has(r)&&!this._disabledTools.has(this.toolKey(Jn.BUILTIN,r))})}async fetchBuiltinTools(){if(!this._loading){this._loading=!0,this._error=null,this._toolsEndpointUnreachable=!1;try{const e=await lx.list();this._builtinTools=e.map(r=>r.definition),this._cwdAwareTools=new ka(e.filter(r=>r.uses_cwd).map(r=>r.tool))}catch(e){const r=e instanceof Error?e.message:String(e);this._error=r,r.includes("this feature is disabled")?(this._toolsEndpointUnreachable=!0,console.info("[ToolsStore] Built-in tools are disabled on the server")):console.error("[ToolsStore] Failed to fetch built-in tools:",e)}finally{this._loading=!1}}}async resolveServerHome(){if(this._serverHome!==void 0)return this._serverHome;try{const e=await lx.executeToolRaw(rn.FILE_GLOB_SEARCH,{limit:1,max_depth:1,path:th,type:ex.DIR});this._serverHome=typeof e.base=="string"?e.base:null}catch{this._serverHome=null}return this._serverHome}}const Ln=new lDt,Hce=new Set(["DIV","P"]),wEe=oce("g");function c$(t,e){return!t||!e?0:`[${t}](file://${e})`.length}const _P=/(```[\s\S]*?```)|(`[^`\n]+`)/g;function cDt(t){return _P.lastIndex=0,_P.test(t)}const xEe=/```/g;function WDe(t,e){let r=!1;xEe.lastIndex=0;let n;for(;(n=xEe.exec(t))!==null&&!(n.index+n[0].length>e);)r=!r;return r}function pT(t){const e=[];let r=0;_P.lastIndex=0;let n;for(;(n=_P.exec(t))!==null;){const i=n.index;i>r&&AEe(t.slice(r,i),e),e.push(n[1]!==void 0?{kind:"codeBlock",text:n[1]}:{kind:"inlineCode",text:n[2]}),r=i+n[0].length}return rr&&e.push({kind:"text",text:t.slice(r,o)}),e.push({kind:"badge",name:a,path:s}),r=o+i.length}r{let a=!0;for(const s of Array.from(i.childNodes)){if(s.nodeType===Node.TEXT_NODE){const l=s.textContent??"";l.length>0&&(r&&(e+=` +`,r=!1),e+=l,a=!1);continue}if(s.nodeType!==Node.ELEMENT_NODE)continue;const o=s;if(o.dataset.mentionBadge==="true"){const l=o.dataset.mentionName??"",u=o.dataset.mentionPath??"";l&&u&&(r&&(e+=` +`,r=!1),e+=`[${l}](file://${u})`,a=!1);continue}if(o.dataset.codeToken!==void 0){const l=o.dataset.codeToken==="block";l&&(r||!a)&&(e+=` +`),r=!1,n(o),a=!1,l&&(r=!0);continue}if(o.tagName==="BR"){!(Zd(o.previousSibling)||Zd(o.nextSibling))&&o.nextSibling&&(r&&(e+=` +`,r=!1),e+=` +`,a=!1);continue}if(Hce.has(o.tagName)){(r||!a)&&(e+=` +`),r=!1,n(o),a=!1;continue}n(o),r&&(a=!1)}};return n(t),e}function uDt(t,e){const r=e.filter(a=>a.kind!=="text");let n=0;const i=a=>{for(const s of Array.from(a.childNodes)){if(s.nodeType!==Node.ELEMENT_NODE)continue;const o=s,l=o.dataset.mentionBadge==="true",u=o.dataset.codeToken!==void 0;if(!l&&!u){if(!i(o))return!1;continue}const d=r[n++];if(!d)return!1;if(l){if(d.kind!=="badge"||d.name!==(o.dataset.mentionName??"")||d.path!==(o.dataset.mentionPath??""))return!1;continue}const h=o.dataset.codeToken==="block"?"codeBlock":"inlineCode";if(d.kind!==h||(d.kind==="inlineCode"||d.kind==="codeBlock")&&d.text!==(o.textContent??""))return!1}return!0};return i(t)&&n===r.length}function Bh(t,e){if(!e)return X1(t).length;const r=e.cloneRange();r.selectNodeContents(t),r.setEnd(e.endContainer,e.endOffset);const n=(l,u)=>r.comparePoint(l,u)!==1;let i=0,a=!1,s=null;const o=l=>{let u=!0;for(const d of Array.from(l.childNodes)){if(a)return;if(d.nodeType===Node.TEXT_NODE){const m=d.textContent??"";if(m.length===0)continue;if(s){const{index:_,node:v}=s;if(s=null,!n(v,_)){a=!0;return}i+=1}if(!n(d,0)){a=!0;return}if(e.endContainer===d){i+=e.endOffset,a=!0;return}i+=m.length,u=!1;continue}if(d.nodeType!==Node.ELEMENT_NODE)continue;const h=d,f=h.parentNode,p=Array.prototype.indexOf.call(f.childNodes,h);if(s){const{index:m,node:_}=s;if(s=null,!n(_,m)){a=!0;return}i+=1}if(h.dataset.mentionBadge==="true"){const m=c$(h.dataset.mentionName??"",h.dataset.mentionPath??"");if(m===0)continue;if(!n(f,p+1)){a=!0;return}i+=m,u=!1;continue}if(h.dataset.codeToken!==void 0){const m=h.dataset.codeToken==="block";if(m&&!u){if(!n(h,0)){a=!0;return}i+=1}o(h),u=!1,m&&(s={index:p+1,node:f});continue}if(h.tagName==="BR"){if(Zd(h.previousSibling)||Zd(h.nextSibling)||!h.nextSibling)continue;if(!n(f,p+1)){a=!0;return}i+=1,u=!1;continue}if(Hce.has(h.tagName)){if(!u){if(!n(h,0)){a=!0;return}i+=1}o(h),u=!1;continue}const g=i;o(h),i>g&&(u=!1)}};return o(t),i}function dDt(t){const e=document.createDocumentFragment();for(let r=0;rpDt.test(n[f]),s=f=>i.find(([p])=>p===f),o=f=>i.find(([,p])=>p===f),l=n.length;let u=e;if(r==="forward"){if(!(u0&&a(u-1)))for(;u>0&&!a(u-1);)u--;for(;u>0&&a(u-1);){const f=o(u);if(f){u=f[0];break}u--}}if(u===e)return null;const d=Math.min(e,u),h=Math.max(e,u);return i.some(([f,p])=>fd)?u:null}function mDt(t,e){const[r]=pT(t);return!r||r.kind!=="badge"?null:e===c$(r.name,r.path)?0:null}function _Dt(t,e){const r=document.createRange();let n=e,i=!1,a=!1;const s=(l,u)=>{r.setStart(l,u),r.setEnd(l,u),i=!0},o=l=>{let u=!0;for(const d of Array.from(l.childNodes)){if(i)return;if(d.nodeType===Node.TEXT_NODE){const p=d.textContent??"";if(p.length===0)continue;if(a){if(a=!1,n===0){s(d,0);return}n-=1}if(n<=p.length){s(d,n);return}n-=p.length,u=!1;continue}if(d.nodeType!==Node.ELEMENT_NODE)continue;const h=d;if(h.dataset.mentionBadge==="true"){const p=c$(h.dataset.mentionName??"",h.dataset.mentionPath??"");if(p===0)continue;if(a){if(a=!1,n===0){r.setStartBefore(h),r.setEndBefore(h),i=!0;return}n-=1}if(n<=p){n===0?(r.setStartBefore(h),r.setEndBefore(h)):(r.setStartAfter(h),r.setEndAfter(h)),i=!0;return}n-=p,u=!1;continue}if(h.dataset.codeToken!==void 0){const p=h.dataset.codeToken==="block";if(p&&(a||!u)){if(a=!1,n===0){r.setStartBefore(h),r.setEndBefore(h),i=!0;return}n-=1}const g=(h.textContent??"").length;if(n===0){r.setStartBefore(h),r.setEndBefore(h),i=!0;return}if(n===g){r.setStartAfter(h),r.setEndAfter(h),i=!0;return}if(n=this.groupWindowMs||this.undoStack.length===0)&&(this.undoStack.push(e),this.undoStack.length>this.limit&&this.undoStack.shift()),this.lastPush=r,this.redoStack=[]}undo(e){const r=this.undoStack.pop();return r?(this.redoStack.push(e),this.lastPush=0,r):null}redo(e){const r=this.redoStack.pop();return r?(this.undoStack.push(e),this.lastPush=0,r):null}}function RK(t,e=[],r=[],n=!1){const i=[];if(t.reasoningContent){const l=yP(t.toolCalls),u=!!t.content?.trim()||l.length>0||r.length>0,d=n&&!u;i.push({content:t.reasoningContent,type:d?Fi.REASONING_PENDING:Fi.REASONING,wasInterrupted:!n&&!u})}t.content?.trim()&&i.push({content:t.content,type:Fi.TEXT});const a=yP(t.toolCalls),s=new Map;for(const l of e)l.toolCallId&&!s.has(l.toolCallId)&&s.set(l.toolCallId,l);for(const l of a){const u=l.id?s.get(l.id):void 0,d=u?Fi.TOOL_CALL:n?Fi.TOOL_CALL_PENDING:Fi.TOOL_CALL;i.push({content:u?.content||"",toolArgs:l.function?.arguments,toolCallId:l.id,toolCwd:u?.toolCwd,toolName:l.function?.name,toolResult:u?.content,toolResultExtras:u?.extra,type:d})}const o=new Set(a.map(l=>l.id).filter(Boolean));for(const l of r)l.id&&o.has(l.id)||i.push({content:"",toolArgs:l.function?.arguments,toolCallId:l.id,toolName:l.function?.name,type:Fi.TOOL_CALL_STREAMING});return i}function Vce(t,e=[],r=[],n=!1){if(!e.some(l=>l.role===Sr.ASSISTANT))return RK(t,e,r,n);const a=[],s=NEe(e,0);a.push(...RK(t,s));let o=s.length;for(;o=e.length;a.push(...RK(l,u,d?r:[],d&&n)),o+=1+u.length}else o++}return a}function yDt(t){const e=[];for(const r of t)switch(r.type){case Fi.REASONING:case Fi.REASONING_PENDING:e.push(`${UL.START}${Na}${r.content}${UL.END}`);break;case Fi.TEXT:e.push(r.content);break;case Fi.TOOL_CALL:case Fi.TOOL_CALL_PENDING:case Fi.TOOL_CALL_STREAMING:{const n={name:r.toolName};if(r.toolArgs)try{n.arguments=JSON.parse(r.toolArgs)}catch{n.arguments=r.toolArgs}e.push(JSON.stringify(n,null,2)),r.toolResult&&e.push(`${Na}${r.toolResult}`);break}}return e.join(`${Na}${Na}`)}function NEe(t,e){const r=[];for(let n=e;no.trim()).filter(o=>o.length>0)}}const bDt=32,NA=new Map;function KDe(t,e){const n=`${(e??[]).filter(o=>o.type===Ti.IMAGE).map(o=>o.name).join(Na)}:${t}`,i=NA.get(n);if(i!==void 0)return i;const s=t.split(Na).map(o=>{const l=o.match(SSt);if(!l||!e)return{text:o};const u=l[1];return{image:e.find(h=>h.type===Ti.IMAGE&&h.name===u),text:o}});return NA.size>=bDt&&NA.delete(NA.keys().next().value),NA.set(n,s),s}const SDt=32,OA=new Map;function EDt(t){if(!t)return t0.TEXT;const e=OA.get(t);if(e!==void 0)return e;const r=t.trim();if(!r)return t0.TEXT;let n=t0.TEXT;if(ESt.test(r))try{JSON.parse(r),n=t0.JSON}catch(i){console.error("[agentic] tool result looked like JSON but failed to parse:",i)}return n===t0.TEXT&&TDt(r)&&(n=t0.MARKDOWN),OA.size>=SDt&&OA.delete(OA.keys().next().value),OA.set(t,n),n}function TDt(t){if(TSt.test(t))return!0;const e=t.split(Na);for(const r of e)if(CSt.test(r)||wSt.test(r)||xSt.test(r)||ASt.test(r))return!0;if(RSt.test(t)||NSt.test(t))return!0;if(e.length>=2){const r=e[0],n=e[1];if(r.includes("|")&&OSt.test(n))return!0}return!1}const CDt=64,IA=new Map;function yP(t){if(!t)return[];const e=IA.get(t);if(e)return e;let r;try{const n=JSON.parse(t);r=Array.isArray(n)?n:[]}catch{r=[]}return IA.size>=CDt&&IA.delete(IA.keys().next().value),IA.set(t,r),r}function jDe(t,e=[]){return t.toolCalls&&yP(t.toolCalls).length>0?!0:e.length>0}function wDt(t,e){const r=t[e];if(!r||r.role!==Sr.ASSISTANT)return{kind:bb.APPEND_TEXT};if(!(yP(r.toolCalls).length>0))return{kind:bb.APPEND_TEXT};let i=e;for(let a=e+1;ae?{kind:bb.NEXT_TURN,truncateAfter:i}:{kind:bb.RERUN_TURN,truncateAfter:e-1}}function xDt(t,e){const r=OEe(t),n=OEe(e),i=r.length,a=n.length;if(i===0&&a===0)return[];if(i===0)return n.map((d,h)=>({kind:lg.ADD,newLine:h+1,text:d}));if(a===0)return r.map((d,h)=>({kind:lg.REMOVE,oldLine:h+1,text:d}));const s=Array.from({length:i+1},()=>new Array(a+1).fill(0));for(let d=1;d<=i;d++)for(let h=1;h<=a;h++)r[d-1]===n[h-1]?s[d][h]=s[d-1][h-1]+1:s[d][h]=Math.max(s[d-1][h],s[d][h-1]);const o=[];let l=i,u=a;for(;l>0&&u>0;)r[l-1]===n[u-1]?(o.push({kind:lg.CONTEXT,newLine:u,oldLine:l,text:r[l-1]}),l--,u--):s[l-1][u]>=s[l][u-1]?(o.push({kind:lg.REMOVE,oldLine:l,text:r[l-1]}),l--):(o.push({kind:lg.ADD,newLine:u,text:n[u-1]}),u--);for(;l>0;)o.push({kind:lg.REMOVE,oldLine:l,text:r[l-1]}),l--;for(;u>0;)o.push({kind:lg.ADD,newLine:u,text:n[u-1]}),u--;return o.reverse(),o}function ADt(t){return t===lg.ADD?"+":t===lg.REMOVE?"-":" "}function OEe(t){if(t==="")return[];const e=t.split(` +`);return e[e.length-1]===""&&e.pop(),e.map(r=>r.endsWith("\r")?r.slice(0,-1):r)}const IEe='"',kEe="\\",$I="{",DEe="}",NK="[",MEe="]",RDt=/,?\s*$/,NDt=32,G6=new Map;function ODt(t,e){G6.size>=NDt&&G6.delete(G6.keys().next().value),G6.set(t,e)}function IDt(t){const e=G6.get(t);if(e!==void 0)return e;let r;try{const n=JSON.parse(t);r=n&&typeof n=="object"&&!Array.isArray(n)?n:null}catch{r=kDt(t)}return ODt(t,r),r}function kDt(t){let e=!1,r=!1;const n=[];for(let a=0;a=0;a--)i+=n[a]===$I?DEe:MEe;try{const a=JSON.parse(i);return a&&typeof a=="object"&&!Array.isArray(a)?a:null}catch{return null}}function DDt(t){if(t)try{const e=JSON.parse(t);if(e&&typeof e=="object"&&!Array.isArray(e)&&typeof e.error=="string")return e.error}catch{}}const MDt=/\[exit code: (-?\d+)\](?: \[exit due to timed out\])?\s*$/;function LDt(t){if(!t)return;const e=t.match(MDt);if(e)return{code:Number.parseInt(e[1],10),rawText:e[0],timedOut:e[0].includes("exit due to timed out")}}function PDt(t,e){return e?t.trim()===e.rawText.trim():!1}const FDt=/^\s*---\s*$/,BDt=/^https?:\/\//i,XDe=/\r?\n/,UDt="N/A",$Dt="Highlights:",GDt="query",zDt=["https:","http:"],qDt="/favicon.ico",HDt=[{key:"title",prefix:"Title:"},{key:"url",prefix:"URL:"},{key:"published",prefix:"Published:"},{key:"author",prefix:"Author:"}];function VDt(t){const e=t.split(XDe),r=[];let n=[];for(const i of e)FDt.test(i)?n.length>0&&(r.push(n.join(` +`)),n=[]):n.push(i);return n.length>0&&r.push(n.join(` +`)),r}function YDt(t){if(!t.trim())return null;const r=t.split(XDe),n={author:void 0,published:void 0,title:void 0,url:void 0},i=[];let a=!1;for(const l of r){if(!a&&l.trim()===$Dt){a=!0;continue}if(a){i.push(l);continue}for(const{key:u,prefix:d}of HDt){if(!l.startsWith(d))continue;const h=l.slice(d.length).trim();h&&h!==UDt&&(n[u]=h);break}}if(!n.title||!n.url||!BDt.test(n.url))return null;const s=i.join(` +`).trim(),o={title:n.title,url:n.url};return n.published&&(o.published=n.published),n.author&&(o.author=n.author),s&&(o.highlights=s),o}const WDt=32,kA=new Map;function QDe(t){if(!t)return[];const e=kA.get(t);if(e)return e;const r=[];for(const n of VDt(t)){const i=YDt(n);i&&r.push(i)}return kA.size>=WDt&&kA.delete(kA.keys().next().value),kA.set(t,r),r}const KDt=32,DA=new Map;function ZDe(t){if(!t)return"";const e=DA.get(t);if(e!==void 0)return e;let r="";try{const n=JSON.parse(t);if(n&&typeof n=="object"&&!Array.isArray(n)){const i=n[GDt];typeof i=="string"&&(r=i.trim())}}catch{r=""}return DA.size>=KDt&&DA.delete(DA.keys().next().value),DA.set(t,r),r}function jDt(t){try{const e=new URL(t);return zDt.includes(e.protocol)?`${e.protocol}//${e.host}${qDt}`:null}catch{return null}}const XDt=["web_search_exa"];function QDt(t){return t?XDt.includes(t):!1}class ZDt{cache=new Map;ttlMs;maxEntries;onEvict;constructor(e={}){this.ttlMs=e.ttlMs??lIe,this.maxEntries=e.maxEntries??cEt,this.onEvict=e.onEvict}get(e){const r=this.cache.get(e);return r?Date.now()>r.expiresAt?(this.delete(e),null):(r.lastAccessed=Date.now(),r.value):null}set(e,r,n){this.cache.size>=this.maxEntries&&!this.cache.has(e)&&this.evictOldest();const i=n??this.ttlMs,a=Date.now();this.cache.set(e,{expiresAt:a+i,lastAccessed:a,value:r})}has(e){const r=this.cache.get(e);return r?Date.now()>r.expiresAt?(this.delete(e),!1):!0:!1}delete(e){const r=this.cache.get(e);return r&&this.onEvict&&this.onEvict(e,r.value),this.cache.delete(e)}clear(){if(this.onEvict)for(const[e,r]of this.cache)this.onEvict(e,r.value);this.cache.clear()}get size(){return this.cache.size}prune(){const e=Date.now();let r=0;for(const[n,i]of this.cache)e>i.expiresAt&&(this.delete(n),r++);return r}keys(){const e=Date.now(),r=[];for(const[n,i]of this.cache)e<=i.expiresAt&&r.push(n);return r}evictOldest(){let e=null,r=1/0;for(const[n,i]of this.cache)i.lastAccessedr.expiresAt?(this.delete(e),!1):(r.expiresAt=n+this.ttlMs,r.lastAccessed=n,!0)}}function JDt(t){return typeof t=="string"?t:t instanceof URL?t.href:t.url}function eMt(t,e,r){return e?.method?e.method:typeof Request<"u"&&t instanceof Request?t.method:r?.method??"GET"}function tMt(t,e){if(e?.body!==void 0)return e.body;if(typeof Request<"u"&&t instanceof Request)return t.body}function rMt(t){return t==null?{kind:"empty"}:typeof t=="string"?{kind:"string",size:t.length}:t instanceof Blob?{kind:"blob",size:t.size}:t instanceof URLSearchParams?{kind:"urlsearchparams",size:t.toString().length}:t instanceof FormData?{kind:"formdata"}:t instanceof ArrayBuffer?{kind:"arraybuffer",size:t.byteLength}:ArrayBuffer.isView(t)?{kind:t.constructor.name,size:t.byteLength}:{kind:typeof t}}function nMt(t){const e=t instanceof Error?t.message:String(t);return e.includes("Failed to fetch")?`${e} (check CORS?)`:e}function iMt(t){if(typeof t=="string")try{const e=JSON.parse(t),n=(Array.isArray(e)?e:[e]).map(i=>typeof i?.method=="string"?i.method:void 0).filter(i=>!!i);return n.length>0?n:void 0}catch{return}}const xee="AbortError",aMt=[/input stream/i,/network connection was lost/i,/load failed/i];function sMt(t){if(t?.aborted)throw new DOMException("Operation was aborted",xee)}function vu(t){if(t instanceof DOMException&&t.name===xee)return!0;if(t instanceof Error){if(t.name===xee)return!0;if(t instanceof TypeError){const e=t.message??"";if(aMt.some(r=>r.test(e)))return!0}}return!1}function JDe(t){if(!t)return null;try{const e=JSON.parse(t);return e&&typeof e=="object"&&!Array.isArray(e)?e:null}catch{return null}}function mg(){return globalThis.crypto?.randomUUID?.()??Math.random().toString(36).substring(2)}function j_(t,e){at(e,!1);let r=ce(e,"ariaLabel",8,"Copy to clipboard"),n=ce(e,"canCopy",8,!0),i=ce(e,"text",8);d4();{let a=H_(()=>!n());va(t,{get icon(){return jOe},get tooltip(){return r()},get iconSize(){return vr},get disabled(){return S(a)},onclick:()=>n()&&p2(i())})}st()}var oMt=new Set(["$$slots","$$events","$$legacy","children","class","icon"]),lMt=se("");function Aee(t,e){let r=ce(e,"class",3,""),n=Tt(e,oMt);var i=lMt();Er(i,()=>({...n,class:["inline-flex cursor-pointer items-center gap-1 rounded-sm bg-muted-foreground/15 px-1.5 py-0.75",r()]}));var a=te(i);{var s=l=>{var u=Ae(),d=oe(u);Pt(d,()=>e.icon),G(l,u)};ve(a,l=>{e.icon&&l(s)})}var o=ie(a,2);Pt(o,()=>e.children),Z(i),G(t,i)}var cMt=se(" Vision (Image)",1),uMt=se(" Vision (Video)",1),dMt=se(" Audio",1),hMt=se("");function fMt(t,e){at(e,!0);let r=ce(e,"class",3,"");var n=Ae(),i=oe(n);qr(i,16,()=>e.modalities,a=>a,(a,s)=>{var o=Ae(),l=oe(o);{var u=d=>{var h=hMt(),f=te(h);{var p=_=>{var v=cMt(),b=oe(v);Fle(b,{class:"h-3 w-3"}),Ct(),G(_,v)},g=_=>{var v=uMt(),b=oe(v);y4(b,{class:"h-3 w-3"}),Ct(),G(_,v)},m=_=>{var v=dMt(),b=oe(v);$le(b,{class:"h-3 w-3"}),Ct(),G(_,v)};ve(f,_=>{s===h0.VISION?_(p):s===h0.VIDEO?_(g,1):_(m,-1)})}Z(h),$e(()=>Yt(h,1,dn(["inline-flex items-center gap-1 rounded-md bg-muted px-2 py-1 text-xs font-medium",r()]))),G(d,h)};ve(l,d=>{(s===h0.VISION||s===h0.AUDIO||s===h0.VIDEO)&&d(u)})}G(a,o)}),G(t,n),st()}var pMt=se('
      '),gMt=se("
      "),mMt=se(" ",1);function eMe(t,e){at(e,!0);const r=(R,O=Vt)=>{_Mt(R,{get imageClass(){return a()},get imageHeight(){return s()},get imageWidth(){return o()},get item(){return O()},get limitToSingleRow(){return l()},get onFileRemove(){return e.onFileRemove},onMcpResourcePreview:y,onPreview:(F,P)=>b(F,P),get readonly(){return u()}})};let n=ce(e,"attachments",19,()=>[]),i=ce(e,"class",3,""),a=ce(e,"imageClass",3,""),s=ce(e,"imageHeight",3,"h-24"),o=ce(e,"imageWidth",3,"w-auto"),l=ce(e,"limitToSingleRow",3,!1),u=ce(e,"readonly",3,!1),d=ce(e,"style",3,""),h=ce(e,"uploadedFiles",27,()=>Zr([])),f=Oe(void 0),p=Oe(!1),g=Oe(null),m=Oe(0),_=Oe(!1),v=W(()=>KIe({attachments:n(),uploadedFiles:h()}));function b(R,O){O?.stopPropagation(),O?.preventDefault();const P=S(v).filter(N=>!Jle(N)&&!ece(N)).findIndex(N=>N.id===R.id);X(m,P>=0?P:0,!0),X(_,!0)}function y(R){X(g,R,!0),X(p,!0)}Kt(()=>{S(f)&&S(v).length&&S(f).resetScroll()});var E=mMt(),T=oe(E);{var C=R=>{var O=gMt(),F=te(O);{var P=k=>{Jr(Zce(k,{children:(M,L)=>{var I=Ae(),U=oe(I);qr(U,17,()=>S(v),B=>B.id,(B,$)=>{r(B,()=>S($))}),G(M,I)},$$slots:{default:!0}}),M=>X(f,M,!0),()=>S(f))},N=k=>{var M=pMt();qr(M,21,()=>S(v),L=>L.id,(L,I)=>{r(L,()=>S(I))}),Z(M),G(k,M)};ve(F,k=>{l()?k(P):k(N,-1)})}Z(O),$e(()=>{Yt(O,1,dn(i())),zs(O,d())}),G(R,O)};ve(T,R=>{S(v).length>0&&R(C)})}var w=ie(T,2);Bfr(w,{get activeModelId(){return e.activeModelId},get attachments(){return n()},get previewFocusIndex(){return S(m)},get uploadedFiles(){return h()},get open(){return S(_)},set open(R){X(_,R,!0)}});var x=ie(w,2);{var A=R=>{Qpr(R,{get extra(){return S(g)},get open(){return S(p)},set open(O){X(p,O,!0)}})};ve(x,R=>{S(g)&&R(A)})}G(t,E),st()}function _Mt(t,e){at(e,!0);let r=ce(e,"class",3,""),n=ce(e,"imageClass",3,""),i=ce(e,"imageHeight",3,"h-24"),a=ce(e,"imageWidth",3,"w-auto"),s=ce(e,"limitToSingleRow",3,!1),o=ce(e,"readonly",3,!1);const l=W(()=>s()?"first:ml-4 last:mr-4":"");function u(E,T){return{id:T,resource:{name:E.name,serverName:E.serverName,title:E.name,uri:E.uri}}}var d=Ae(),h=oe(d);{var f=E=>{const T=W(()=>e.item.attachment?.type===Ti.MCP_PROMPT?e.item.attachment:e.item.uploadedFile?.mcpPrompt?{arguments:e.item.uploadedFile.mcpPrompt.arguments,content:e.item.textContent??"",name:e.item.name,promptName:e.item.uploadedFile.mcpPrompt.promptName,serverName:e.item.uploadedFile.mcpPrompt.serverName,type:Ti.MCP_PROMPT}:null);var C=Ae(),w=oe(C);{var x=A=>{{let R=W(()=>e.onFileRemove?()=>e.onFileRemove(e.item.id):void 0);bMt(A,{get class(){return`max-w-[300px] min-w-[200px] flex-shrink-0 ${r()??""} ${S(l)??""}`},get prompt(){return S(T)},get readonly(){return o()},get isLoading(){return e.item.isLoading},get loadError(){return e.item.loadError},get onRemove(){return S(R)}})}};ve(w,A=>{S(T)&&A(x)})}G(E,C)},p=W(()=>Jle(e.item)),g=E=>{const T=W(()=>e.item.attachment);{let C=W(()=>u(S(T),e.item.id));tMe(E,{get class(){return`flex-shrink-0 ${r()??""} ${S(l)??""}`},get attachment(){return S(C)},onclick:()=>e.onMcpResourcePreview?.(S(T))})}},m=W(()=>ece(e.item)),_=E=>{BMt(E,{get class(){return`flex-shrink-0 cursor-pointer ${r()??""} ${S(l)??""}`},get id(){return e.item.id},get name(){return e.item.name},get preview(){return e.item.preview},get readonly(){return o()},get onRemove(){return e.onFileRemove},get height(){return i()},get width(){return a()},get imageClass(){return n()},onclick:()=>e.onPreview?.(e.item)})},v=E=>{PEe(E,{get class(){return`flex-shrink-0 cursor-pointer ${r()??""} ${S(l)??""}`},get id(){return e.item.id},get name(){return e.item.name},get size(){return e.item.size},get readonly(){return o()},get onRemove(){return e.onFileRemove},get textContent(){return e.item.textContent},get attachment(){return e.item.attachment},get uploadedFile(){return e.item.uploadedFile},onclick:()=>e.onPreview?.(e.item)})},b=W(()=>tce(e.item.attachment,e.item.uploadedFile)),y=E=>{PEe(E,{get class(){return`flex-shrink-0 cursor-pointer ${r()??""} ${S(l)??""}`},get id(){return e.item.id},get name(){return e.item.name},get size(){return e.item.size},get readonly(){return o()},get onRemove(){return e.onFileRemove},get textContent(){return e.item.textContent},get attachment(){return e.item.attachment},get uploadedFile(){return e.item.uploadedFile},onclick:()=>e.onPreview?.(e.item)})};ve(h,E=>{S(p)?E(f):S(m)?E(g,1):e.item.isImage&&e.item.preview?E(_,2):S(b)?E(v,3):E(y,-1)})}G(t,d),st()}var vMt=se('
      '),yMt=se("
      ");function bMt(t,e){at(e,!0);let r=ce(e,"class",3,""),n=ce(e,"isLoading",3,!1),i=ce(e,"readonly",3,!1);var a=yMt(),s=te(a);DLe(s,{get isLoading(){return n()},get loadError(){return e.loadError},get prompt(){return e.prompt},get variant(){return FR.ATTACHMENT}});var o=ie(s,2);{var l=u=>{var d=vMt(),h=te(d);va(h,{get icon(){return Jc},tooltip:"Remove",stopPropagationOnClick:!0,onclick:()=>e.onRemove?.()}),Z(d),G(u,d)};ve(o,u=>{!i()&&e.onRemove&&u(l)})}Z(a),$e(()=>Yt(a,1,`group relative ${r()??""}`)),G(t,a),st()}var SMt=se(''),EMt=se(''),TMt=se('
      '),CMt=se(" ",1);function tMe(t,e){at(e,!0);const r=W(()=>ake(e.attachment.resource.mimeType,e.attachment.resource.uri)),n=W(()=>Xr.getServerDisplayName(e.attachment.resource.serverName)),i=W(()=>Xr.getServerFavicon(e.attachment.resource.serverName));function a(l){return l.error?"border-red-500/50 bg-red-500/10":(l.loading,"border-border/50 bg-muted/30")}var s=Ae(),o=oe(s);Me(o,()=>po,(l,u)=>{u(l,{children:(d,h)=>{var f=CMt(),p=oe(f);Me(p,()=>fo,(m,_)=>{_(m,{children:(v,b)=>{var y=SMt(),E=te(y);{var T=F=>{us(F,{class:"h-3 w-3 animate-spin text-muted-foreground"})},C=F=>{Lle(F,{class:"h-3 w-3 text-red-500"})},w=F=>{var P=Ae(),N=oe(P);Me(N,()=>S(r),(k,M)=>{M(k,{class:"h-3 w-3 text-muted-foreground"})}),G(F,P)};ve(E,F=>{e.attachment.loading?F(T):e.attachment.error?F(C,1):F(w,-1)})}var x=ie(E,2),A=te(x,!0);Z(x);var R=ie(x,2);{var O=F=>{va(F,{class:"-my-2 -mr-1.5 bg-transparent",get icon(){return Jc},iconSize:"h-2 w-2",onclick:()=>e.onRemove?.(e.attachment.id),stopPropagationOnClick:!0,tooltip:"Remove"})};ve(R,F=>{e.onRemove&&F(O)})}Z(y),$e((F,P)=>{Yt(y,1,F),y.disabled=!e.onclick,it(A,P)},[()=>dn(["flex flex-shrink-0 items-center gap-1.5 rounded-md border px-2 py-0.75 text-sm transition-colors",a(e.attachment),e.onclick&&"cursor-pointer hover:bg-muted/50",e.class]),()=>eee(e.attachment.resource)]),Kr("click",y,function(...F){e.onclick?.apply(this,F)}),G(v,y)},$$slots:{default:!0}})});var g=ie(p,2);Me(g,()=>ho,(m,_)=>{_(m,{children:(v,b)=>{var y=TMt(),E=te(y);{var T=x=>{var A=EMt();$e(()=>{lr(A,"alt",e.attachment.resource.serverName),lr(A,"src",S(i))}),Zn("error",A,R=>{R.currentTarget.style.display="none"}),_f(A),G(x,A)};ve(E,x=>{S(i)&&x(T)})}var C=ie(E,2),w=te(C,!0);Z(C),Z(y),$e(()=>it(w,S(n))),G(v,y)},$$slots:{default:!0}})}),G(d,f)},$$slots:{default:!0}})}),G(t,s),st()}Hi(["click"]);const LEe=(t,e=Vt)=>{var r=Ae(),n=oe(r);{var i=a=>{var s=NMt(),o=te(s,!0);Z(s),$e(()=>it(o,e())),G(a,s)};ve(n,a=>{e()&&a(i)})}G(t,r)};var wMt=se("
      "),xMt=se('
      '),AMt=se('
      '),RMt=se('
      '),NMt=se(' '),OMt=se('
      '),IMt=se(' ',1),kMt=se(''),DMt=se('');function PEe(t,e){at(e,!0);const r=(y,E=Vt)=>{var T=xMt(),C=te(T),w=te(C,!0);Z(C);var x=ie(C,2);{var A=R=>{var O=wMt();$e(()=>Yt(O,1,`pointer-events-none absolute right-0 bottom-0 left-0 h-4 bg-gradient-to-t from-muted to-transparent ${s()?"h-6":""}`)),G(R,O)};ve(x,R=>{E().length>150&&R(A)})}Z(T),$e(R=>{Yt(C,1,`font-mono text-xs leading-relaxed break-words whitespace-pre-wrap text-muted-foreground ${s()?"":"max-h-3rem line-height-1.2"}`),it(w,R)},[()=>DAt(E())]),G(y,T)},n=y=>{var E=AMt(),T=te(E);va(T,{get icon(){return Jc},tooltip:"Remove",stopPropagationOnClick:!0,onclick:()=>e.onRemove?.(e.id)}),Z(E),G(y,E)},i=y=>{var E=RMt(),T=te(E);{var C=A=>{HU(A,{get class(){return`${vr} text-white/70`}})},w=A=>{y4(A,{get class(){return`${vr} text-white/70`}})},x=A=>{var R=or();$e(()=>it(R,S(p))),G(A,R)};ve(T,A=>{S(l)?A(C):S(u)?A(w,1):A(x,-1)})}Z(E),G(y,E)};let a=ce(e,"class",3,""),s=ce(e,"readonly",3,!1),o=W(()=>tce(e.attachment,e.uploadedFile)),l=W(()=>QJ(e.attachment,e.uploadedFile)),u=W(()=>ZJ(e.attachment,e.uploadedFile)),d=W(()=>S(o)&&!!e.textContent),h=W(()=>jIe(e.attachment,e.uploadedFile)),f=W(()=>S(h)&&!!e.textContent),p=W(()=>{if(e.uploadedFile?.type)return YO(e.uploadedFile.type);if(e.attachment){if("mimeType"in e.attachment&&e.attachment.mimeType)return YO(e.attachment.mimeType);if(e.attachment.type)return YO(e.attachment.type)}return YO(e.name)}),g=W(()=>e.attachment?.type===Ti.PDF?e.attachment.processedAsImages?"Sent as Image":"Sent as Text":null);var m=Ae(),_=oe(m);{var v=y=>{var E=kMt(),T=te(E);{var C=O=>{n(O)};ve(T,O=>{s()||O(C)})}var w=ie(T,2),x=te(w);{var A=O=>{var F=OMt(),P=te(F),N=te(P),k=te(N,!0);Z(N);var M=ie(N,2);{let U=W(()=>S(g)||(e.size?JL(e.size):void 0));LEe(M,()=>S(U))}var L=ie(M,2);{var I=U=>{r(U,()=>e.textContent)};ve(L,U=>{e.textContent&&U(I)})}Z(P),Z(F),$e(()=>it(k,e.name)),G(O,F)},R=O=>{var F=IMt(),P=oe(F),N=te(P,!0);Z(P);var k=ie(P,2);{var M=L=>{r(L,()=>e.textContent)};ve(k,L=>{e.textContent&&L(M)})}$e(()=>it(N,e.name)),G(O,F)};ve(x,O=>{s()?O(A):O(R,-1)})}Z(w),Z(E),$e(()=>{lr(E,"aria-label",s()?`Preview ${e.name}`:void 0),Yt(E,1,`rounded-lg border border-border bg-muted p-3 ${a()??""} cursor-pointer ${s()?"w-full max-w-2xl transition-shadow hover:shadow-md":`group relative text-left ${e.textContent?"max-h-24 max-w-72":"max-w-36"}`} overflow-hidden`),Yt(w,1,dn([!s()&&"pr-8","overflow-hidden"]))}),Kr("click",E,function(...O){e.onclick?.apply(this,O)}),G(y,E)},b=y=>{var E=DMt(),T=te(E);i(T);var C=ie(T,2),w=te(C),x=te(w,!0);Z(w);var A=ie(w,2);{let F=W(()=>S(g)||(e.size?JL(e.size):void 0));LEe(A,()=>S(F))}Z(C);var R=ie(C,2);{var O=F=>{n(F)};ve(R,F=>{s()||F(O)})}Z(E),$e(()=>{Yt(E,1,`group flex items-center gap-3 rounded-lg border border-border bg-muted p-3 ${a()??""} relative`),Yt(w,1,`max-w-24 truncate text-sm font-medium text-foreground ${s()?"":"group-hover:pr-6"} md:max-w-32`),it(x,e.name)}),Kr("click",E,function(...F){e.onclick?.apply(this,F)}),G(y,E)};ve(_,y=>{S(f)||S(d)?y(v):y(b,-1)})}G(t,m),st()}Hi(["click"]);var MMt=se(""),LMt=se(''),PMt=se('
      '),FMt=se("
      ");function BMt(t,e){at(e,!0);const r=g=>{var m=MMt();$e(()=>{lr(m,"src",e.preview),lr(m,"alt",e.name),Yt(m,1,`${i()??""} ${o()??""} cursor-pointer object-cover ${a()??""}`)}),G(g,m)};let n=ce(e,"class",3,""),i=ce(e,"height",3,"h-16"),a=ce(e,"imageClass",3,""),s=ce(e,"readonly",3,!1),o=ce(e,"width",3,"w-auto");var l=FMt(),u=te(l);{var d=g=>{var m=LMt(),_=te(m);r(_),Z(m),$e(()=>lr(m,"aria-label",`Preview ${e.name??""}`)),Kr("click",m,function(...v){e.onclick?.apply(this,v)}),G(g,m)},h=g=>{r(g)};ve(u,g=>{e.onclick?g(d):g(h,-1)})}var f=ie(u,2);{var p=g=>{var m=PMt(),_=te(m);va(_,{class:"text-white",get icon(){return Jc},onclick:()=>e.onRemove?.(e.id),stopPropagationOnClick:!0,tooltip:"Remove"}),Z(m),G(g,m)};ve(f,g=>{s()||g(p)})}Z(l),$e(()=>Yt(l,1,`group relative overflow-hidden rounded-lg bg-muted shadow-lg dark:border dark:border-muted ${n()??""}`)),G(t,l),st()}Hi(["click"]);class Ly{static async list(){return $T(k6.LIST)}static async listRouter(){return $T(k6.LIST)}static async load(e,r){const n={model:e};return r&&r.length>0&&(n.extra_args=r),N_e(k6.LOAD,n)}static async unload(e){return N_e(k6.UNLOAD,{model:e})}static isModelLoaded(e){return e.status.value===Io.LOADED}static isModelLoading(e){return e.status.value===Io.LOADING}static parseModelId(e){const r={activatedParams:null,modelName:null,orgName:null,params:null,quantization:null,raw:e,tags:[]},n=ike(e).replace(bCt,""),i=n.indexOf(gCt);let a;i!==xm?(r.quantization=n.slice(i+1)||null,a=n.slice(0,i)):a=n;const s=a.indexOf(pCt);let o;s!==xm?(r.orgName=a.slice(0,s),o=a.slice(s+1)):o=a;const l=o.lastIndexOf(".");if(l!==xm&&!r.quantization){const p=o.slice(l+1);S_e.test(p)&&(r.quantization=p,o=o.slice(0,l))}const u=o.split(b_e);if(!r.quantization&&u.length>1){const p=u[u.length-1],g=u.length>2?u[u.length-2]:null;S_e.test(p)&&(g&&mCt.test(g)?(r.quantization=`${g}-${p}`,u.splice(u.length-2,2)):(r.quantization=p,u.pop()))}let d=xm,h=xm;for(let p=0;p{const m=d+1+g;return m===h?!1:!yCt.has(u[m].toUpperCase())})),r}}var PD={exports:{}},UMt=PD.exports,FEe;function $Mt(){return FEe||(FEe=1,(function(t,e){((r,n)=>{t.exports=n()})(UMt,function(){var r=function(K,le){return(r=Object.setPrototypeOf||({__proto__:[]}instanceof Array?function(me,be){me.__proto__=be}:function(me,be){for(var ke in be)Object.prototype.hasOwnProperty.call(be,ke)&&(me[ke]=be[ke])}))(K,le)},n=function(){return(n=Object.assign||function(K){for(var le,me=1,be=arguments.length;me"u"||a.Promise||(a.Promise=Promise);var u=Object.getPrototypeOf,d={}.hasOwnProperty;function h(K,le){return d.call(K,le)}function f(K,le){typeof le=="function"&&(le=le(u(K))),(typeof Reflect>"u"?s:Reflect.ownKeys)(le).forEach(function(me){g(K,me,le[me])})}var p=Object.defineProperty;function g(K,le,me,be){p(K,le,l(me&&h(me,"get")&&typeof me.get=="function"?{get:me.get,set:me.set,configurable:!0}:{value:me,configurable:!0,writable:!0},be))}function m(K){return{from:function(le){return K.prototype=Object.create(le.prototype),g(K.prototype,"constructor",K),{extend:f.bind(null,K.prototype)}}}}var _=Object.getOwnPropertyDescriptor,v=[].slice;function b(K,le,me){return v.call(K,le,me)}function y(K,le){return le(K)}function E(K){if(!K)throw new Error("Assertion Failed")}function T(K){a.setImmediate?setImmediate(K):setTimeout(K,0)}function C(K,le){if(typeof le=="string"&&h(K,le))return K[le];if(!le)return K;if(typeof le!="string"){for(var me=[],be=0,ke=le.length;be"u"?[]:(Pe=Promise.resolve(),typeof crypto<"u"&&crypto.subtle?[ut=crypto.subtle.digest("SHA-512",new Uint8Array([0])),u(ut),Pe]:[Pe,u(Pe),Pe]),Pe=ut[0],VS=ut[1],VS=VS&&VS.then,qe=Pe&&Pe.constructor,Ze=!!ut[2],De=function(K,le){Re.push([K,le]),de&&(queueMicrotask(Ye),de=!1)},Fe=!0,de=!0,Ee=[],he=[],Le=fe,_e={id:"global",global:!0,ref:0,unhandleds:[],onunhandled:J,pgp:!1,env:{},finalize:J},He=_e,Re=[],Xe=0,je=[];function Be(K){if(typeof this!="object")throw new TypeError("Promises must be constructed via new");this._listeners=[],this._lib=!1;var le=this._PSD=He;if(typeof K!="function"){if(K!==Ne)throw new TypeError("Not a function");this._state=arguments[1],this._value=arguments[2],this._state===!1&&tt(this,this._value)}else this._state=null,this._value=null,++le.ref,(function me(be,ke){try{ke(function(Qe){if(be._state===null){if(Qe===be)throw new TypeError("A promise cannot be resolved with itself.");var lt=be._lib&&kt();Qe&&typeof Qe.then=="function"?me(be,function(pt,Mt){Qe instanceof Be?Qe._then(pt,Mt):Qe.then(pt,Mt)}):(be._state=!0,be._value=Qe,Ge(be)),lt&&At()}},tt.bind(null,be))}catch(Qe){tt(be,Qe)}})(this,K)}var Je={get:function(){var K=He,le=ar;function me(be,ke){var Qe=this,lt=!K.global&&(K!==He||le!==ar),pt=lt&&!Dt(),Mt=new Be(function(Wt,Bt){xe(Qe,new ht(jn(be,K,lt,pt),jn(ke,K,lt,pt),Wt,Bt,K))});return this._consoleTask&&(Mt._consoleTask=this._consoleTask),Mt}return me.prototype=Ne,me},set:function(K){g(this,"then",K&&K.prototype===Ne?Je:{get:function(){return K},set:Je.set})}};function ht(K,le,me,be,ke){this.onFulfilled=typeof K=="function"?K:null,this.onRejected=typeof le=="function"?le:null,this.resolve=me,this.reject=be,this.psd=ke}function tt(K,le){var me,be;he.push(le),K._state===null&&(me=K._lib&&kt(),le=Le(le),K._state=!1,K._value=le,be=K,Ee.some(function(ke){return ke._value===be._value})||Ee.push(be),Ge(K),me)&&At()}function Ge(K){var le=K._listeners;K._listeners=[];for(var me=0,be=le.length;me{for(var lt=Ee.length;lt;)if(Ee[--lt]._value===Qe._value)return Ee.splice(lt,1)})(le),me.resolve(be)}catch(Qe){me.reject(Qe)}finally{--Xe==0&&ft(),--me.psd.ref||me.psd.finalize()}}function Ye(){_n(_e,function(){kt()&&At()})}function kt(){var K=Fe;return de=Fe=!1,K}function At(){var K,le,me;do for(;0.",Gi="String expected.",bi="__dbnames",La="readonly",cl="readwrite";function _r(K,le){return K?le?function(){return K.apply(this,arguments)&&le.apply(this,arguments)}:K:le}var on={type:3,lower:-1/0,lowerOpen:!1,upper:[[]],upperOpen:!1};function dr(K){return typeof K!="string"||/\./.test(K)?function(le){return le}:function(le){return le[K]===void 0&&K in le&&delete(le=P(le))[K],le}}function nr(){throw ne.Type("Entity instances must never be new:ed. Instances are generated by the framework bypassing the constructor.")}function rr(K,le){try{var me=fr(K),be=fr(le);if(me!==be)return me==="Array"?1:be==="Array"?-1:me==="binary"?1:be==="binary"?-1:me==="string"?1:be==="string"?-1:me==="Date"?1:be!=="Date"?NaN:-1;switch(me){case"number":case"Date":case"string":return le{var pt=Bt,Mt=lt;if(typeof Mt!="function"&&Mt!==null)throw new TypeError("Class extends value "+String(Mt)+" is not a constructor or null");function Wt(){this.constructor=pt}function Bt(){return lt!==null&<.apply(this,arguments)||this}return r(pt,Mt),pt.prototype=Mt===null?Object.create(Mt):(Wt.prototype=Mt.prototype,new Wt),Object.defineProperty(Bt.prototype,"db",{get:function(){return le},enumerable:!1,configurable:!0}),Bt.prototype.table=function(){return me},Bt})(K)),new Set),ke=K.prototype;ke;ke=u(ke))Object.getOwnPropertyNames(ke).forEach(function(lt){return be.add(lt)});function Qe(lt){if(!lt)return lt;var pt,Mt=Object.create(K.prototype);for(pt in lt)if(!be.has(pt))try{Mt[pt]=lt[pt]}catch{}return Mt}return this.schema.readHook&&this.hook.reading.unsubscribe(this.schema.readHook),this.schema.readHook=Qe,this.hook("reading",Qe),K},ca.prototype.defineClass=function(){return this.mapToClass(function(K){l(this,K)})},ca.prototype.add=function(K,le){var me=this,be=this.schema.primKey,ke=be.auto,Qe=be.keyPath,lt=K;return Qe&&ke&&(lt=dr(Qe)(K)),this._trans("readwrite",function(pt){return me.core.mutate({trans:pt,type:"add",keys:le!=null?[le]:null,values:[lt]})}).then(function(pt){return pt.numFailures?Be.reject(pt.failures[0]):pt.lastResult}).then(function(pt){if(Qe)try{w(K,Qe,pt)}catch{}return pt})},ca.prototype.upsert=function(K,le){var me=this,be=this.schema.primKey.keyPath;return this._trans("readwrite",function(ke){return me.core.get({trans:ke,key:K}).then(function(Qe){var lt=Qe??{};return xa(lt,le),be&&w(lt,be,K),me.core.mutate({trans:ke,type:"put",values:[lt],keys:[K],upsert:!0,updates:{keys:[K],changeSpecs:[le]}}).then(function(pt){return pt.numFailures?Be.reject(pt.failures[0]):!!Qe})})})},ca.prototype.update=function(K,le){return typeof K!="object"||o(K)?this.where(":id").equals(K).modify(le):(K=C(K,this.schema.primKey.keyPath))===void 0?Qr(new ne.InvalidArgument("Given object does not contain its primary key")):this.where(":id").equals(K).modify(le)},ca.prototype.put=function(K,le){var me=this,be=this.schema.primKey,ke=be.auto,Qe=be.keyPath,lt=K;return Qe&&ke&&(lt=dr(Qe)(K)),this._trans("readwrite",function(pt){return me.core.mutate({trans:pt,type:"put",values:[lt],keys:le!=null?[le]:null})}).then(function(pt){return pt.numFailures?Be.reject(pt.failures[0]):pt.lastResult}).then(function(pt){if(Qe)try{w(K,Qe,pt)}catch{}return pt})},ca.prototype.delete=function(K){var le=this;return this._trans("readwrite",function(me){return le.core.mutate({trans:me,type:"delete",keys:[K]}).then(function(be){return dt(le,[K],be)}).then(function(be){return be.numFailures?Be.reject(be.failures[0]):void 0})})},ca.prototype.clear=function(){var K=this;return this._trans("readwrite",function(le){return K.core.mutate({trans:le,type:"deleteRange",range:on}).then(function(me){return dt(K,null,me)})}).then(function(le){return le.numFailures?Be.reject(le.failures[0]):void 0})},ca.prototype.bulkGet=function(K){var le=this;return this._trans("readonly",function(me){return le.core.getMany({keys:K,trans:me}).then(function(be){return be.map(function(ke){return le.hook.reading.fire(ke)})})})},ca.prototype.bulkAdd=function(K,le,me){var be=this,ke=Array.isArray(le)?le:void 0,Qe=(me=me||(ke?void 0:le))?me.allKeys:void 0;return this._trans("readwrite",function(lt){var pt=be.schema.primKey,Wt=pt.auto,pt=pt.keyPath;if(pt&&ke)throw new ne.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");if(ke&&ke.length!==K.length)throw new ne.InvalidArgument("Arguments objects and keys must have the same length");var Mt=K.length,Wt=pt&&Wt?K.map(dr(pt)):K;return be.core.mutate({trans:lt,type:"add",keys:ke,values:Wt,wantResults:Qe}).then(function(Bt){var It=Bt.numFailures,Lt=Bt.failures;if(It===0)return Qe?Bt.results:Bt.lastResult;throw new Q("".concat(be.name,".bulkAdd(): ").concat(It," of ").concat(Mt," operations failed"),Lt)})})},ca.prototype.bulkPut=function(K,le,me){var be=this,ke=Array.isArray(le)?le:void 0,Qe=(me=me||(ke?void 0:le))?me.allKeys:void 0;return this._trans("readwrite",function(lt){var pt=be.schema.primKey,Wt=pt.auto,pt=pt.keyPath;if(pt&&ke)throw new ne.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");if(ke&&ke.length!==K.length)throw new ne.InvalidArgument("Arguments objects and keys must have the same length");var Mt=K.length,Wt=pt&&Wt?K.map(dr(pt)):K;return be.core.mutate({trans:lt,type:"put",keys:ke,values:Wt,wantResults:Qe}).then(function(Bt){var It=Bt.numFailures,Lt=Bt.failures;if(It===0)return Qe?Bt.results:Bt.lastResult;throw new Q("".concat(be.name,".bulkPut(): ").concat(It," of ").concat(Mt," operations failed"),Lt)})})},ca.prototype.bulkUpdate=function(K){var le=this,me=this.core,be=K.map(function(lt){return lt.key}),ke=K.map(function(lt){return lt.changes}),Qe=[];return this._trans("readwrite",function(lt){return me.getMany({trans:lt,keys:be,cache:"clone"}).then(function(pt){var Mt=[],Wt=[],Bt=(K.forEach(function(It,Lt){var Ht=It.key,Ut=It.changes,$t=pt[Lt];if($t){for(var zt=0,Qt=Object.keys(Ut);ztjt+cr&&zt(jt+Wt)})})}var Qt=Pa(me)&&me.limit===1/0&&(typeof K!="function"||Ut)&&{index:me.index,range:me.range};return zt(0).then(function(){if(0{for(var Ei=Math.min(Fr.length,Nn.length),Li=-1,ua=0;ua=Lt})).length===0?Be.resolve():(zt.forEach(function(jt){$t.push(function(){var cr,Rr,kr,Vr=Qt,Fr=jt._cfg.dbschema,Cn=(mO(It,Vr,Ut),mO(It,Fr,Ut),Qt=It._dbSchema=Fr,Iq(Vr,Fr)),zr=(Cn.add.forEach(function(Nn){kq(Ut,Nn[0],Nn[1].primKey,Nn[1].indexes)}),Cn.change.forEach(function(Nn){if(Nn.recreate)throw new ne.Upgrade("Not yet support for changing primary key");var Nr=Ut.objectStore(Nn.name);Nn.add.forEach(function(Si){return pO(Nr,Si)}),Nn.change.forEach(function(Si){Nr.deleteIndex(Si.name),pO(Nr,Si)}),Nn.del.forEach(function(Si){return Nr.deleteIndex(Si)})}),jt._cfg.contentUpgrade);if(zr&&jt._cfg.version>Lt)return hO(It,Ut),Ht._memoizedTables={},cr=x(Fr),Cn.del.forEach(function(Nn){cr[Nn]=Vr[Nn]}),Oq(It,[It.Transaction.prototype]),fO(It,[It.Transaction.prototype],s(cr),cr),Ht.schema=cr,(Rr=$(zr))&&ct(),Fr=Be.follow(function(){var Nn;(kr=zr(Ht))&&Rr&&(Nn=Dt.bind(null,null),kr.then(Nn,Nn))}),kr&&typeof kr.then=="function"?Be.resolve(kr):Fr.then(function(){return kr})}),$t.push(function(cr){var Rr,kr,Vr=jt._cfg.dbschema;Rr=Vr,kr=cr,[].slice.call(kr.db.objectStoreNames).forEach(function(Fr){return Rr[Fr]==null&&kr.db.deleteObjectStore(Fr)}),Oq(It,[It.Transaction.prototype]),fO(It,[It.Transaction.prototype],It._storeNames,It._dbSchema),Ht.schema=It._dbSchema}),$t.push(function(cr){It.idbdb.objectStoreNames.contains("$meta")&&(Math.ceil(It.idbdb.version/10)===jt._cfg.version?(It.idbdb.deleteObjectStore("$meta"),delete It._dbSchema.$meta,It._storeNames=It._storeNames.filter(function(Rr){return Rr!=="$meta"})):cr.objectStore("$meta").put(jt._cfg.version,"version"))})}),(function jt(){return $t.length?Be.resolve($t.shift()(Ht.idbtrans)).then(jt):Be.resolve()})().then(function(){d0e(Qt,Ut)}))}).catch(lt);var Mt,Wt;s(ke).forEach(function(Bt){kq(me,Bt,ke[Bt].primKey,ke[Bt].indexes)}),hO(K,me),Be.follow(function(){return K.on.populate.fire(Qe)}).catch(lt)})}function Hut(K,le){d0e(K._dbSchema,le),le.db.version%10!=0||le.objectStoreNames.contains("$meta")||le.db.createObjectStore("$meta").add(Math.ceil(le.db.version/10-1),"version");var me=gO(0,K.idbdb,le);mO(K,K._dbSchema,le);for(var be=0,ke=Iq(me,K._dbSchema).change;be{if(lt.change.length||lt.recreate)return console.warn("Unable to patch indexes of table ".concat(lt.name," because it has changes on the type of index or primary key.")),{value:void 0};var pt=le.objectStore(lt.name);lt.add.forEach(function(Mt){Ce&&console.debug("Dexie upgrade patch: Creating missing index ".concat(lt.name,".").concat(Mt.src)),pO(pt,Mt)})})(ke[be]);if(typeof Qe=="object")return Qe.value}}function Iq(K,le){var me,be={del:[],add:[],change:[]};for(me in K)le[me]||be.del.push(me);for(me in le){var ke=K[me],Qe=le[me];if(ke){var lt={name:me,def:Qe,recreate:!1,del:[],add:[],change:[]};if(""+(ke.primKey.keyPath||"")!=""+(Qe.primKey.keyPath||"")||ke.primKey.auto!==Qe.primKey.auto)lt.recreate=!0,be.change.push(lt);else{var pt=ke.idxByName,Mt=Qe.idxByName,Wt=void 0;for(Wt in pt)Mt[Wt]||lt.del.push(Wt);for(Wt in Mt){var Bt=pt[Wt],It=Mt[Wt];Bt?Bt.src!==It.src&<.change.push(It):lt.add.push(It)}(0{var K,le,me;return typeof FinalizationRegistry<"u"&&typeof WeakRef<"u"?(K=new Set,le=new FinalizationRegistry(function(be){K.delete(be)}),{toArray:function(){return Array.from(K).map(function(be){return be.deref()}).filter(function(be){return be!==void 0})},add:function(be){var ke=new WeakRef(be._novip);K.add(ke),le.register(be._novip,ke,ke),K.size>be._options.maxConnections&&(ke=K.values().next().value,K.delete(ke),le.unregister(ke))},remove:function(be){if(be)for(var ke=K.values(),Qe=ke.next();!Qe.done;){var lt=Qe.value;if(lt.deref()===be._novip)return K.delete(lt),void le.unregister(lt);Qe=ke.next()}}}):(me=[],{toArray:function(){return me},add:function(be){me.push(be._novip)},remove:function(be){be&&(be=me.indexOf(be._novip))!==-1&&me.splice(be,1)}})})();function Dq(K,le){var me=K._dbNamesDB;return me||(me=K._dbNamesDB=new Cm(bi,{addons:[],indexedDB:K,IDBKeyRange:le})).version(1).stores({dbnames:"name"}),me.table("dbnames")}function Mq(K){return K&&typeof K.databases=="function"}function Lq(K){return Un(function(){return He.letThrough=!0,K()})}function Pq(K){return!("from"in K)}var kc=function(K,le){var me;if(!this)return me=new kc,K&&"d"in K&&l(me,K),me;l(this,arguments.length?{d:1,from:K,to:1Math.pow(2,62)?0:zt.oldVersion,It=Qt<1,K.idbdb=$t.result,Qe&&Hut(K,Bt),qut(K,Qt/10,Bt,Ht))},Ht),$t.onsuccess=bt(function(){Bt=null;var zt,Qt,jt,cr,Rr,kr,Vr=K.idbdb=$t.result,Fr=b(Vr.objectStoreNames);if(0"u"?Be.resolve():!navigator.userAgentData&&/Safari\//.test(navigator.userAgent)&&!/Chrom(e|ium)\//.test(navigator.userAgent)&&indexedDB.databases?new Promise(function(Lt){function Ht(){return indexedDB.databases().finally(Lt)}Mt=setInterval(Ht,100),Ht()}).finally(function(){return clearInterval(Mt)}):Promise.resolve()).then(pt)]).then(function(){return lt(),le.onReadyBeingFired=[],Be.resolve(Lq(function(){return K.on.ready.fire(K.vip)})).then(function Lt(){var Ht;if(0le.limit?be.length=le.limit:K.length===le.limit&&be.length{if(me===void 0)return be!==void 0?-1:0;if(be===void 0)return 1;if((me=rr(me,be))===0){if(ke&&Qe)return 0;if(ke)return 1;if(Qe)return-1}return me})(K.lower,le.lower,K.lowerOpen,le.lowerOpen)<=0&&0<=((me,be,ke,Qe)=>{if(me===void 0)return be!==void 0?1:0;if(be===void 0)return-1;if((me=rr(me,be))===0){if(ke&&Qe)return 0;if(ke)return-1;if(Qe)return 1}return me})(K.upper,le.upper,K.upperOpen,le.upperOpen)}function Zut(K,le,me,be){K.subscribers.add(me),be.addEventListener("abort",function(){var ke,Qe;K.subscribers.delete(me),K.subscribers.size===0&&(ke=K,Qe=le,setTimeout(function(){ke.subscribers.size===0&&I(Qe,ke)},3e3))})}var Jut={stack:"dbcore",level:0,name:"Cache",create:function(K){var le=K.schema.name;return n(n({},K),{transaction:function(me,be,ke){var Qe,lt,pt=K.transaction(me,be,ke);return be==="readwrite"&&(ke=(Qe=new AbortController).signal,pt.addEventListener("abort",(lt=function(Mt){return function(){if(Qe.abort(),be==="readwrite"){for(var Wt=new Set,Bt=0,It=me;Bt{var Qt=Qv["idb://".concat(Ht,"/").concat(Ut)];if(!Qt)return[];if(!(Ht=Qt.queries[$t]))return[null,!1,Qt,null];var jt=Ht[(zt.query?zt.query.index.name:null)||""];if(!jt)return[null,!1,Qt,null];switch($t){case"query":var cr=(Rr=zt.direction)!=null?Rr:"next",Rr=jt.find(function(kr){var Vr;return kr.req.limit===zt.limit&&kr.req.values===zt.values&&((Vr=kr.req.direction)!=null?Vr:"next")===cr&&E0e(kr.req.query.range,zt.query.range)});return Rr?[Rr,!0,Qt,jt]:[jt.find(function(kr){var Vr;return("limit"in kr.req?kr.req.limit:1/0)>=zt.limit&&((Vr=kr.req.direction)!=null?Vr:"next")===cr&&(!zt.values||kr.req.values)&&Qut(kr.req.query.range,zt.query.range)}),!1,Qt,jt];case"count":return Rr=jt.find(function(kr){return E0e(kr.req.query.range,zt.query.range)}),[Rr,!!Rr,Qt,jt]}})(le,me,"query",Qe),Lt=It[0],Wt=It[2],Bt=It[3],Lt&&It[1]?Lt.obsSet=Qe.obsSet:(It=be.query(Qe).then(function(Ht){var Ut=Ht.result;if(Lt&&(Lt.res=Ut),lt){for(var $t=0,zt=Ut.length;$t{var Rr=kt();try{Qe&&ct();var kr=Un(K,cr);return kr=Qe?kr.finally(Dt):kr}finally{Rr&&At()}})(Qt={subscr:zt,signal:lt.signal,requery:Lt,querier:K,trans:null}),It||(P1.storagemutated.subscribe(Ut),It=!0),Promise.resolve(jt).then(function(cr){me=!0,le=cr,pt||Qt.signal.aborted||(Ht()||(Wt=zt,Ht())?Lt():(Mt={},xr(function(){return!pt&&ke.next&&ke.next(cr)})))},function(cr){me=!1,["DatabaseClosedError","AbortError"].includes(cr?.name)||pt||xr(function(){pt||ke.error&&ke.error(cr)})}))};return setTimeout(Lt,0),Bt});return be.hasValue=function(){return me},be.getValue=function(){return le},be}var Zv=Cm;function Yq(K){var le=F1;try{F1=!0,P1.storagemutated.fire(K),$q(K,!0)}finally{F1=le}}f(Zv,n(n({},H),{delete:function(K){return new Zv(K,{addons:[]}).delete()},exists:function(K){return new Zv(K,{addons:[]}).open().then(function(le){return le.close(),!0}).catch("NoSuchDatabaseError",function(){return!1})},getDatabaseNames:function(K){try{return le=Zv.dependencies,me=le.indexedDB,le=le.IDBKeyRange,(Mq(me)?Promise.resolve(me.databases()).then(function(be){return be.map(function(ke){return ke.name}).filter(function(ke){return ke!==bi})}):Dq(me,le).toCollection().primaryKeys()).then(K)}catch{return Qr(new ne.MissingAPI)}var le,me},defineClass:function(){return function(K){l(this,K)}},ignoreTransaction:function(K){return He.trans?_n(He.transless||_e,K):K()},vip:Lq,async:function(K){return function(){try{var le=Gq(K.apply(this,arguments));return le&&typeof le.then=="function"?le:Be.resolve(le)}catch(me){return Qr(me)}}},spawn:function(K,le,me){try{var be=Gq(K.apply(me,le||[]));return be&&typeof be.then=="function"?be:Be.resolve(be)}catch(ke){return Qr(ke)}},currentTransaction:{get:function(){return He.trans||null}},waitFor:function(K,le){return K=Be.resolve(typeof K=="function"?Zv.ignoreTransaction(K):K).timeout(le||6e4),He.trans?He.trans.waitFor(K):K},Promise:Be,debug:{get:function(){return Ce},set:function(K){rt(K)}},derive:m,extend:l,props:f,override:y,Events:nu,on:P1,liveQuery:T0e,extendObservabilitySet:vO,getByKeyPath:C,setByKeyPath:w,delByKeyPath:function(K,le){typeof le=="string"?w(K,le,void 0):"length"in le&&[].map.call(le,function(me){w(K,me,void 0)})},shallowClone:x,deepClone:P,getObjectDiff:zq,cmp:rr,asap:T,minKey:-1/0,addons:[],connections:{get:lA.toArray},errnames:ae,dependencies:EO,cache:Qv,semVer:"4.4.3",version:"4.4.3".split(".").map(function(K){return parseInt(K)}).reduce(function(K,le,me){return K+le/Math.pow(10,2*me)})})),Zv.maxKey=sA(Zv.dependencies.IDBKeyRange),typeof dispatchEvent<"u"&&typeof addEventListener<"u"&&(P1(L1,function(K){F1||(K=new CustomEvent(qS,{detail:K}),F1=!0,dispatchEvent(K),F1=!1)}),addEventListener(qS,function(K){K=K.detail,F1||Yq(K)}));var YS,F1=!1,C0e=function(){};return typeof BroadcastChannel<"u"&&((C0e=function(){(YS=new BroadcastChannel(qS)).onmessage=function(K){return K.data&&Yq(K.data)}})(),typeof YS.unref=="function"&&YS.unref(),P1(L1,function(K){F1||YS.postMessage(K)})),typeof addEventListener<"u"&&(addEventListener("pagehide",function(K){if(!Cm.disableBfCache&&K.persisted){Ce&&console.debug("Dexie: handling persisted pagehide"),YS?.close();for(var le=0,me=lA.toArray();le{if(r!==null&&!await pn[gn.messages].get(r))throw new Error(`Parent message ${r} not found`);const n={...e,children:[],id:mg(),parent:r,toolCalls:e.toolCalls??""};if(await pn[gn.messages].add(n),r!==null){const i=await pn[gn.messages].get(r);i&&await pn[gn.messages].update(r,{children:[...i.children,n.id]})}return await this.updateConversation(e.convId,{currNode:n.id}),n})}static async createRootMessage(e){const r={children:[],content:"",convId:e,id:mg(),parent:null,role:Sr.SYSTEM,timestamp:Date.now(),toolCalls:"",type:"root"};return await pn[gn.messages].add(r),r.id}static async createSystemMessage(e,r,n){const i=r.trim();if(!i)throw new Error("Cannot create system message with empty content");return await pn.transaction("rw",pn[gn.messages],async()=>{const a=await pn[gn.messages].get(n);if(!a)throw new Error(`Parent message ${n} not found`);const s={children:[],content:i,convId:e,id:mg(),parent:n,role:Sr.SYSTEM,timestamp:Date.now(),type:Sr.SYSTEM};return await pn[gn.messages].add(s),await pn[gn.messages].update(n,{children:[...a.children,s.id]}),s})}static async deleteConversation(e,r){await pn.transaction("rw",[pn[gn.conversations],pn[gn.messages]],async()=>{if(r?.deleteWithForks){const n=[],i=[e];for(;i.length>0;){const a=i.pop(),s=await pn[gn.conversations].filter(o=>o.forkedFromConversationId===a).toArray();for(const o of s)n.push(o.id),i.push(o.id)}for(const a of n)await pn[gn.conversations].delete(a),await pn[gn.messages].where("convId").equals(a).delete()}else await this.reparentDirectChildren(e);await pn[gn.conversations].delete(e),await pn[gn.messages].where("convId").equals(e).delete()})}static async reparentDirectChildren(e,r=new Set,n){const i=n?.get(e)??await pn[gn.conversations].get(e);if(!i)return;let a=i.forkedFromConversationId;const s=new Set([e]);for(;a&&r.has(a);){if(s.has(a)){a=void 0;break}s.add(a);const u=n?.get(a)??await pn[gn.conversations].get(a);if(!u){a=void 0;break}a=u.forkedFromConversationId}const o=await pn[gn.conversations].filter(u=>u.forkedFromConversationId===e).toArray(),l=[];for(const u of o)r.has(u.id)||l.push({...u,forkedFromConversationId:a});l.length!==0&&await pn[gn.conversations].bulkPut(l)}static async bulkDeleteConversations(e){const r=e.filter(i=>typeof i=="string"&&i.length>0);if(r.length===0)return;const n=new Set(r);await pn.transaction("rw",[pn[gn.conversations],pn[gn.messages]],async()=>{const i=new Map;let a=[...r];const s=new Set(a);for(;a.length>0;){const o=await pn[gn.conversations].bulkGet(a);a=[];for(let l=0;l{const r=await pn[gn.messages].get(e);if(r){if(r.parent){const n=await pn[gn.messages].get(r.parent);n&&(n.children=n.children.filter(i=>i!==e),await pn[gn.messages].put(n))}await pn[gn.messages].delete(e)}})}static async deleteMessageCascading(e,r){return await pn.transaction("rw",pn[gn.messages],async()=>{const n=await pn[gn.messages].where("convId").equals(e).toArray(),i=QIe(n,r),a=[r,...i],s=await pn[gn.messages].get(r);if(s&&s.parent){const o=await pn[gn.messages].get(s.parent);o&&(o.children=o.children.filter(l=>l!==r),await pn[gn.messages].put(o))}return await pn[gn.messages].bulkDelete(a),a})}static async getAllConversations(){return await pn[gn.conversations].orderBy("lastModified").reverse().toArray()}static async getConversation(e){return await pn[gn.conversations].get(e)}static async getConversationMessages(e){return await pn[gn.messages].where("convId").equals(e).sortBy("timestamp")}static async getConversationsWithMessages(e){const r=new Map,n=e.filter(o=>typeof o=="string"&&o.length>0);if(n.length===0)return r;const[i,a]=await Promise.all([pn[gn.conversations].bulkGet(n),pn[gn.messages].where("convId").anyOf(n).toArray()]),s=new Map;for(const o of a){const l=s.get(o.convId);l?l.push(o):s.set(o.convId,[o])}for(let o=0;od.timestamp-h.timestamp);r.set(l.id,{conv:l,messages:u})}return r}static async updateConversation(e,r){await pn[gn.conversations].update(e,r)}static async toggleConversationPin(e){const r=await pn[gn.conversations].get(e);if(!r)throw new Error(`Conversation ${e} not found`);const n=!r.pinned;return await this.updateConversation(e,{pinned:n}),n}static async bulkToggleConversationPins(e){const r=e.filter(i=>typeof i=="string"&&i.length>0),n=new Map;return r.length===0||await pn.transaction("rw",pn[gn.conversations],async()=>{const i=await pn[gn.conversations].bulkGet(r),a=[];for(let s=0;s{for(const i of e){const{conv:a,messages:s}=i;if(await pn[gn.conversations].get(a.id)){n.push(a);continue}await pn[gn.conversations].add(a);for(const l of s)await pn[gn.messages].put(l);r.push(a)}return{imported:r,skipped:n}})}static async forkConversation(e,r,n){return await pn.transaction("rw",[pn[gn.conversations],pn[gn.messages]],async()=>{const i=await pn[gn.conversations].get(e);if(!i)throw new Error(`Source conversation ${e} not found`);const a=await pn[gn.messages].where("convId").equals(e).toArray(),s=Cb(a,r,!0);if(s.length===0)throw new Error(`Could not resolve message path to ${r}`);const o=new Map;for(const f of s)o.set(f.id,mg());const l=mg(),u=s.map(f=>{const p=o.get(f.id),g=f.parent?o.get(f.parent)??null:null,m=f.children.filter(_=>o.has(_)).map(_=>o.get(_));return{...f,children:m,convId:l,extra:n.includeAttachments?f.extra:void 0,id:p,parent:g}}),h={currNode:u[u.length-1].id,cwd:i.cwd,forkedFromConversationId:e,id:l,lastModified:Date.now(),mcpServerOverrides:i.mcpServerOverrides?i.mcpServerOverrides.map(f=>({enabled:f.enabled,serverId:f.serverId})):void 0,name:n.name};await pn[gn.conversations].add(h);for(const f of u)await pn[gn.messages].add(f);return h})}};const qMt=Object.freeze(Object.defineProperty({__proto__:null,DatabaseService:cn},Symbol.toStringTag,{value:"Module"})),Yce=`${Id}.migration-state`,rMe=1;function jR(){try{const t=localStorage.getItem(Yce);if(!t)return{completed:[],failed:[],lastRun:""};const e=JSON.parse(t);return e.version!==rMe?{completed:[],failed:[],lastRun:""}:{completed:e.completed??[],failed:e.failed??[],lastRun:e.lastRun??""}}catch{return{completed:[],failed:[],lastRun:""}}}function nMe(t){localStorage.setItem(Yce,JSON.stringify({version:rMe,...t,lastRun:new Date().toISOString()}))}function UEe(t){return jR().completed.includes(t)}function HMt(t){const e=jR();e.completed.includes(t)||e.completed.push(t),e.failed=e.failed.filter(r=>r!==t),nMe(e)}function VMt(t){const e=jR();e.failed.includes(t)||e.failed.push(t),nMe(e)}const YMt="localstorage-prefix-v1",WMt={description:"Copy localStorage keys from LlamaCppWebui to LlamaUi prefix (non-destructive)",id:YMt,async run(){for(const[t,e]of Object.entries(VSt)){if(localStorage.getItem(t)!==null)continue;const n=localStorage.getItem(e);n!==null&&localStorage.setItem(t,n)}}},KMt="idxdb-database-v1",jMt={description:"Copy IndexedDB from LlamacppWebui to LlamaUi database (non-destructive)",id:KMt,async run(){if(!(await Wb.getDatabaseNames()).includes(X1e))return;const e=new Wb(Id);if(e.version(1).stores($J),await e.table(gn.conversations).count()>0)return;const n=new Wb(X1e);n.version(1).stores($J);const i=await n.table(gn.conversations).toArray(),a=await n.table(gn.messages).toArray();i.length>0&&await e.table(gn.conversations).bulkAdd(i),a.length>0&&await e.table(gn.messages).bulkAdd(a)}},XMt="legacy-message-format-v2";function QMt(t){const e=[],r=new RegExp(Yb.COMPLETED_TOOL_CALL.source,"g");let n=0,i={textBefore:"",toolCalls:[]},a;for(;(a=r.exec(t))!==null;){const o=t.slice(n,a.index).trim();o&&i.toolCalls.length>0?(e.push(i),i={textBefore:o,toolCalls:[]}):o&&i.toolCalls.length===0&&(i.textBefore=o),i.toolCalls.push({args:a[2],name:a[1],result:a[3].replace(/^\n+|\n+$/g,"")}),n=a.index+a[0].length}const s=t.slice(n).trim();if(i.toolCalls.length>0&&e.push(i),s){const o=s.replace(Yb.AGENTIC_TOOL_CALL_OPEN,"").trim();o&&e.push({textBefore:o,toolCalls:[]})}return e.length===0&&e.push({textBefore:t.trim(),toolCalls:[]}),e}function $Ee(t){let e="",r=t;const n=new RegExp(Yb.REASONING_EXTRACT.source,"g");let i;for(;(i=n.exec(t))!==null;)e+=i[1];return r=r.replace(new RegExp(Yb.REASONING_BLOCK.source,"g"),"").replace(Yb.REASONING_OPEN,""),{cleanContent:r,reasoning:e}}function ZMt(t){return Yb.HAS_LEGACY_MARKERS.test(t)}let OK=null;async function JMt(){return OK||(OK=(await Fn(()=>Promise.resolve().then(()=>qMt),void 0,import.meta.url)).DatabaseService),OK}const eLt={description:"Migrate legacy marker-based messages to structured format",id:XMt,async run(){const t=await JMt(),e=await t.getAllConversations();for(const r of e){const n=await t.getConversationMessages(r.id);for(const i of n){if(i.role!==Sr.ASSISTANT){if(i.content?.includes(kSt.START)){const{cleanContent:p,reasoning:g}=$Ee(i.content);await t.updateMessage(i.id,{content:p.trim(),reasoningContent:g||void 0})}continue}if(!ZMt(i.content??""))continue;const{cleanContent:a,reasoning:s}=$Ee(i.content),o=QMt(a);let l=[];if(i.toolCalls)try{l=JSON.parse(i.toolCalls)}catch{}const u=o[0];if(!u)continue;const d=u.toolCalls.map((p,g)=>{const m=l.find(_=>_.function?.name===p.name)||l[g];return{function:{arguments:p.args,name:p.name},id:m?.id||`legacy_tool_${g}`,type:"function"}});await t.updateMessage(i.id,{content:u.textBefore,reasoningContent:s||void 0,toolCalls:d.length>0?JSON.stringify(d):""});let h=i.id,f=l.length;for(let p=0;p{const y=f+b,E=l[y];return{function:{arguments:v.args,name:v.name},id:E?.id||`legacy_tool_${y}`,type:"function"}});f+=g.toolCalls.length,h=(await t.createMessageBranch({children:[],content:g.textBefore,convId:r.id,model:i.model,role:Sr.ASSISTANT,timestamp:i.timestamp+p*100,toolCalls:m.length>0?JSON.stringify(m):"",type:"text"},h)).id;for(let v=0;v0&&h!==i.id){for(const p of i.children){const g=n.find(m=>m.id===p);g&&g.role!==Sr.TOOL&&await t.updateMessage(p,{parent:h})}await t.updateMessage(i.id,{children:[]})}}}}},tLt="theme-key-v1",rLt={description:"Copy standalone theme key to config object (non-destructive)",id:tLt,async run(){const t=localStorage.getItem("theme");if(t===null)return;const e=localStorage.getItem($u),r=e?JSON.parse(e):{};hr.THEME in r||(r[hr.THEME]=t,localStorage.setItem($u,JSON.stringify(r)))}},nLt="custom-json-key-v1",iLt={description:"Copy legacy custom config key to customJson (non-destructive)",id:nLt,async run(){const t=localStorage.getItem($u);if(t===null)return;const e=JSON.parse(t);"custom"in e&&(hr.CUSTOM_JSON in e||(e[hr.CUSTOM_JSON]=e.custom,localStorage.setItem($u,JSON.stringify(e))))}},aLt="mcp-default-enabled-to-config-v1",sLt=`${Id}.mcpDefaultEnabled`,oLt=`${b4}.mcpDefaultEnabled`,lLt={description:"Copy mcpDefaultEnabled localStorage key into settings config (preserves legacy keys)",id:aLt,async run(){const t=localStorage.getItem(sLt)??localStorage.getItem(oLt);if(t===null)return;const e=localStorage.getItem($u),r=e?JSON.parse(e):{};if(!(Nee in r)){try{const n=JSON.parse(t);if(!Array.isArray(n)||!n.every(a=>typeof a=="object"&&a!==null&&typeof a.serverId=="string"&&typeof a.enabled=="boolean"))return}catch{return}r[Nee]=t,localStorage.setItem($u,JSON.stringify(r))}}},cLt="config-type-normalization-v1",uLt={description:"Coerce legacy string-encoded booleans in persisted config to real booleans",id:cLt,async run(){const t=localStorage.getItem($u);if(t===null)return;const e=JSON.parse(t);let r=!1;for(const n of Object.keys(e))e[n]==="true"?(e[n]=!0,r=!0):e[n]==="false"&&(e[n]=!1,r=!0);r&&localStorage.setItem($u,JSON.stringify(e))}},dLt="render-keys-unfold-v1",IK="renderContentAsRawText",hLt={description:"Unfold the single raw text render toggle onto the per-surface render keys",id:dLt,async run(){const t=localStorage.getItem($u);if(t===null)return;const e=JSON.parse(t);IK in e&&(hr.RENDER_USER_CONTENT_AS_MARKDOWN in e||(e[hr.RENDER_USER_CONTENT_AS_MARKDOWN]=e[IK]!==!0),delete e[IK],localStorage.setItem($u,JSON.stringify(e)))}},Nee=`${Id}.mcpDefaultServerOverrides`,fLt="mcp-default-overrides-merge-v1",pLt={description:"Merge mcpDefaultServerOverrides entries onto mcpServers[i].enabled (preserves legacy key)",id:fLt,async run(){const t=localStorage.getItem($u);if(t===null)return;const e=JSON.parse(t),r=e[Nee];if(typeof r!="string"||r.length===0)return;let n;try{const l=JSON.parse(r);if(!Array.isArray(l))return;n=l.filter(u=>typeof u=="object"&&u!==null&&typeof u.serverId=="string"&&typeof u.enabled=="boolean")}catch{return}const i=e[hr.MCP_SERVERS];let a;try{a=typeof i=="string"?JSON.parse(i):[]}catch{return}Array.isArray(a)||(a=[]);let s=!1;const o=new Set(a.map(l=>l.id));for(const l of n){if(!o.has(l.serverId))continue;const u=a.findIndex(d=>d.id===l.serverId);u>=0&&a[u].enabled!==l.enabled&&(a[u]={...a[u],enabled:l.enabled},s=!0)}s&&(e[hr.MCP_SERVERS]=JSON.stringify(a),localStorage.setItem($u,JSON.stringify(e)))}},GEe=[WMt,jMt,eLt,rLt,iLt,lLt,pLt,uLt,hLt],gLt={getMigrations(){return[...GEe]},getState(){return jR()},isCompleted(t){return UEe(t)},resetState(){localStorage.removeItem(Yce)},async runAllMigrations(){jR();for(const t of GEe)if(!UEe(t.id))try{await t.run(),HMt(t.id)}catch(e){console.error(`[Migration] ${t.id}: failed`,e),VMt(t.id)}}};class Xg{static chat(e){return`${Sa.CHAT}/${e}`}static settings(e){return`${Sa.SETTINGS}/${e}`}}var Lo=Uint8Array,ih=Uint16Array,Wce=Int32Array,u$=new Lo([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),d$=new Lo([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),Oee=new Lo([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),iMe=function(t,e){for(var r=new ih(31),n=0;n<31;++n)r[n]=e+=1<>1|(As&21845)<<1;z1=(z1&52428)>>2|(z1&13107)<<2,z1=(z1&61680)>>4|(z1&3855)<<4,kee[As]=((z1&65280)>>8|(z1&255)<<8)>>1}var Ug=(function(t,e,r){for(var n=t.length,i=0,a=new ih(e);i>l]=u}else for(o=new ih(n),i=0;i>15-t[i]);return o}),X_=new Lo(288);for(var As=0;As<144;++As)X_[As]=8;for(var As=144;As<256;++As)X_[As]=9;for(var As=256;As<280;++As)X_[As]=7;for(var As=280;As<288;++As)X_[As]=8;var XR=new Lo(32);for(var As=0;As<32;++As)XR[As]=5;var _Lt=Ug(X_,9,0),vLt=Ug(X_,9,1),yLt=Ug(XR,5,0),bLt=Ug(XR,5,1),kK=function(t){for(var e=t[0],r=1;re&&(e=t[r]);return e},Mf=function(t,e,r){var n=e/8|0;return(t[n]|t[n+1]<<8)>>(e&7)&r},DK=function(t,e){var r=e/8|0;return(t[r]|t[r+1]<<8|t[r+2]<<16)>>(e&7)},Kce=function(t){return(t+7)/8|0},W8=function(t,e,r){return(e==null||e<0)&&(e=0),(r==null||r>t.length)&&(r=t.length),new Lo(t.subarray(e,r))},SLt=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],qc=function(t,e,r){var n=new Error(e||SLt[t]);if(n.code=t,Error.captureStackTrace&&Error.captureStackTrace(n,qc),!r)throw n;return n},ELt=function(t,e,r,n){var i=t.length,a=n?n.length:0;if(!i||e.f&&!e.l)return r||new Lo(0);var s=!r,o=s||e.i!=2,l=e.i;s&&(r=new Lo(i*3));var u=function(ee){var J=r.length;if(ee>J){var fe=new Lo(Math.max(J*2,ee));fe.set(r),r=fe}},d=e.f||0,h=e.p||0,f=e.b||0,p=e.l,g=e.d,m=e.m,_=e.n,v=i*8;do{if(!p){d=Mf(t,h,1);var b=Mf(t,h+1,3);if(h+=3,b)if(b==1)p=vLt,g=bLt,m=9,_=5;else if(b==2){var C=Mf(t,h,31)+257,w=Mf(t,h+10,15)+4,x=C+Mf(t,h+5,31)+1;h+=14;for(var A=new Lo(x),R=new Lo(19),O=0;O>4;if(y<16)A[O++]=y;else{var M=0,L=0;for(y==16?(L=3+Mf(t,h,3),h+=2,M=A[O-1]):y==17?(L=3+Mf(t,h,7),h+=3):y==18&&(L=11+Mf(t,h,127),h+=7);L--;)A[O++]=M}}var I=A.subarray(0,C),U=A.subarray(C);m=kK(I),_=kK(U),p=Ug(I,m,1),g=Ug(U,_,1)}else qc(1);else{var y=Kce(h)+4,E=t[y-4]|t[y-3]<<8,T=y+E;if(T>i){l&&qc(0);break}o&&u(f+E),r.set(t.subarray(y,T),f),e.b=f+=E,e.p=h=T*8,e.f=d;continue}if(h>v){l&&qc(0);break}}o&&u(f+131072);for(var B=(1<>4;if(h+=M&15,h>v){l&&qc(0);break}if(M||qc(2),q<256)r[f++]=q;else if(q==256){H=h,p=null;break}else{var V=q-254;if(q>264){var O=q-257,Y=u$[O];V=Mf(t,h,(1<>4;j||qc(3),h+=j&15;var U=mLt[Q];if(Q>3){var Y=d$[Q];U+=DK(t,h)&(1<v){l&&qc(0);break}o&&u(f+131072);var ae=f+V;if(f>8},MA=function(t,e,r){r<<=e&7;var n=e/8|0;t[n]|=r,t[n+1]|=r>>8,t[n+2]|=r>>16},MK=function(t,e){for(var r=[],n=0;nf&&(f=a[n].s);var p=new ih(f+1),g=Dee(r[d-1],p,0);if(g>e){var n=0,m=0,_=g-e,v=1<<_;for(a.sort(function(C,w){return p[w.s]-p[C.s]||C.f-w.f});ne)m+=v-(1<>=_;m>0;){var y=a[n].s;p[y]=0&&m;--n){var E=a[n].s;p[E]==e&&(--p[E],++m)}g=e}return{t:new Lo(p),l:g}},Dee=function(t,e,r){return t.s==-1?Math.max(Dee(t.l,e,r+1),Dee(t.r,e,r+1)):e[t.s]=r},qEe=function(t){for(var e=t.length;e&&!t[--e];);for(var r=new ih(++e),n=0,i=t[0],a=1,s=function(l){r[n++]=l},o=1;o<=e;++o)if(t[o]==i&&o!=e)++a;else{if(!i&&a>2){for(;a>138;a-=138)s(32754);a>2&&(s(a>10?a-11<<5|28690:a-3<<5|12305),a=0)}else if(a>3){for(s(i),--a;a>6;a-=6)s(8304);a>2&&(s(a-3<<5|8208),a=0)}for(;a--;)s(i);a=1,i=t[o]}return{c:r.subarray(0,n),n:e}},LA=function(t,e){for(var r=0,n=0;n>8,t[i+2]=t[i]^255,t[i+3]=t[i+1]^255;for(var a=0;a4&&!R[Oee[F-1]];--F);var P=u+5<<3,N=LA(i,X_)+LA(a,XR)+s,k=LA(i,f)+LA(a,m)+s+14+3*F+LA(w,R)+2*w[16]+3*w[17]+7*w[18];if(l>=0&&P<=N&&P<=k)return lMe(e,d,t.subarray(l,l+u));var M,L,I,U;if(Mm(e,d,1+(k15&&(Mm(e,d,q[x]>>5&127),d+=q[x]>>12)}}else M=_Lt,L=X_,I=yLt,U=XR;for(var x=0;x255){var V=Y>>18&31;MA(e,d,M[V+257]),d+=L[V+257],V>7&&(Mm(e,d,Y>>23&31),d+=u$[V]);var j=Y&31;MA(e,d,I[j]),d+=U[j],j>3&&(MA(e,d,Y>>5&8191),d+=d$[j])}else MA(e,d,M[Y]),d+=L[Y]}return MA(e,d,M[256]),d+L[256]},TLt=new Wce([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),cMe=new Lo(0),CLt=function(t,e,r,n,i,a){var s=a.z||t.length,o=new Lo(n+s+5*(1+Math.ceil(s/7e3))+i),l=o.subarray(n,o.length-i),u=a.l,d=(a.r||0)&7;if(e){d&&(l[0]=a.r>>3);for(var h=TLt[e-1],f=h>>13,p=h&8191,g=(1<7e3||R>24576)&&(M>423||!u)){d=HEe(t,l,0,E,T,C,x,R,F,A-F,d),R=w=x=0,F=A;for(var L=0;L<286;++L)T[L]=0;for(var L=0;L<30;++L)C[L]=0}var I=2,U=0,B=p,$=N-k&32767;if(M>2&&P==y(A-$))for(var H=Math.min(f,M)-1,q=Math.min(32767,A),V=Math.min(258,M);$<=q&&--B&&N!=k;){if(t[A+I]==t[A+I-$]){for(var Y=0;YI){if(I=Y,U=$,Y>H)break;for(var j=Math.min($,Y-2),Q=0,L=0;LQ&&(Q=ne,k=ae)}}}N=k,k=m[N],$+=N-k&32767}if(U){E[R++]=268435456|Iee[I]<<18|zEe[U];var ee=Iee[I]&31,J=zEe[U]&31;x+=u$[ee]+d$[J],++T[257+ee],++C[J],O=A+I,++w}else E[R++]=t[A],++T[t[A]]}}for(A=Math.max(A,O);A=s&&(l[d/8|0]=u,fe=s),d=lMe(l,d+1,t.subarray(A,fe))}a.i=s}return W8(o,0,n+Kce(d)+i)},wLt=(function(){for(var t=new Int32Array(256),e=0;e<256;++e){for(var r=e,n=9;--n;)r=(r&1&&-306674912)^r>>>1;t[e]=r}return t})(),xLt=function(){var t=-1;return{p:function(e){for(var r=t,n=0;n>>8;t=r},d:function(){return~t}}},ALt=function(t,e,r,n,i){if(!i&&(i={l:1},e.dictionary)){var a=e.dictionary.subarray(-32768),s=new Lo(a.length+t.length);s.set(a),s.set(t,a.length),t=s,i.w=a.length}return CLt(t,e.level==null?6:e.level,e.mem==null?i.l?Math.ceil(Math.max(8,Math.min(13,Math.log(t.length)))*1.5):20:12+e.mem,r,n,i)},uMe=function(t,e){var r={};for(var n in t)r[n]=t[n];for(var n in e)r[n]=e[n];return r},Eg=function(t,e){return t[e]|t[e+1]<<8},Kh=function(t,e){return(t[e]|t[e+1]<<8|t[e+2]<<16|t[e+3]<<24)>>>0},LK=function(t,e){return Kh(t,e)+Kh(t,e+4)*4294967296},lc=function(t,e,r){for(;r;++e)t[e]=r,r>>>=8};function RLt(t,e){return ALt(t,e||{},0,0)}function NLt(t,e){return ELt(t,{i:2},e&&e.out,e&&e.dictionary)}var dMe=function(t,e,r,n){for(var i in t){var a=t[i],s=e+i,o=n;Array.isArray(a)&&(o=uMe(n,a[1]),a=a[0]),ArrayBuffer.isView(a)?r[s]=[a,o]:(r[s+="/"]=[new Lo(0),o],dMe(a,s,r,n))}},VEe=typeof TextEncoder<"u"&&new TextEncoder,Mee=typeof TextDecoder<"u"&&new TextDecoder,OLt=0;try{Mee.decode(cMe,{stream:!0}),OLt=1}catch{}var ILt=function(t){for(var e="",r=0;;){var n=t[r++],i=(n>127)+(n>223)+(n>239);if(r+i>t.length)return{s:e,r:W8(t,r-1)};i?i==3?(n=((n&15)<<18|(t[r++]&63)<<12|(t[r++]&63)<<6|t[r++]&63)-65536,e+=String.fromCharCode(55296|n>>10,56320|n&1023)):i&1?e+=String.fromCharCode((n&31)<<6|t[r++]&63):e+=String.fromCharCode((n&15)<<12|(t[r++]&63)<<6|t[r++]&63):e+=String.fromCharCode(n)}};function Lee(t,e){var r;if(VEe)return VEe.encode(t);for(var n=t.length,i=new Lo(t.length+(t.length>>1)),a=0,s=function(u){i[a++]=u},r=0;ri.length){var o=new Lo(a+8+(n-r<<1));o.set(i),i=o}var l=t.charCodeAt(r);l<128||e?s(l):l<2048?(s(192|l>>6),s(128|l&63)):l>55295&&l<57344?(l=65536+(l&1047552)|t.charCodeAt(++r)&1023,s(240|l>>18),s(128|l>>12&63),s(128|l>>6&63),s(128|l&63)):(s(224|l>>12),s(128|l>>6&63),s(128|l&63))}return W8(i,0,a)}function Pee(t,e){if(e){for(var r="",n=0;n65535&&qc(9),e+=n+4}return e},YEe=function(t,e,r,n,i,a,s,o){var l=n.length,u=r.extra,d=o&&o.length,h=Fee(u);lc(t,e,s!=null?33639248:67324752),e+=4,s!=null&&(t[e++]=20,t[e++]=r.os),t[e]=20,e+=2,t[e++]=r.flag<<1|(a<0&&8),t[e++]=i&&8,t[e++]=r.compression&255,t[e++]=r.compression>>8;var f=new Date(r.mtime==null?Date.now():r.mtime),p=f.getFullYear()-1980;if((p<0||p>119)&&qc(10),lc(t,e,p<<25|f.getMonth()+1<<21|f.getDate()<<16|f.getHours()<<11|f.getMinutes()<<5|f.getSeconds()>>1),e+=4,a!=-1&&(lc(t,e,r.crc),lc(t,e+4,a<0?-a-2:a),lc(t,e+8,r.size)),lc(t,e+12,l),lc(t,e+14,h),e+=16,s!=null&&(lc(t,e,d),lc(t,e+6,r.attrs),lc(t,e+10,s),e+=14),t.set(n,e),e+=l,h)for(var g in u){var m=u[g],_=m.length;lc(t,e,+g),lc(t,e+2,_),t.set(m,e+4),e+=4+_}return d&&(t.set(o,e),e+=d),e},LLt=function(t,e,r,n,i){lc(t,e,101010256),lc(t,e+8,r),lc(t,e+10,r),lc(t,e+12,n),lc(t,e+16,i)};function PLt(t,e){e||(e={});var r={},n=[];dMe(t,"",r,e);var i=0,a=0;for(var s in r){var o=r[s],l=o[0],u=o[1],d=u.level==0?0:8,h=Lee(s),f=h.length,p=u.comment,g=p&&Lee(p),m=g&&g.length,_=Fee(u.extra);f>65535&&qc(11);var v=d?RLt(l,u):l,b=v.length,y=xLt();y.p(l),n.push(uMe(u,{size:l.length,crc:y.d(),c:v,f:h,m:g,u:f!=s.length||g&&p.length!=m,o:i,compression:d})),i+=30+f+_+b,a+=76+2*(f+_)+(m||0)+b}for(var E=new Lo(a+22),T=i,C=a-i,w=0;w65558)&&qc(13);var i=Eg(t,n+8);if(!i)return{};var a=Kh(t,n+16),s=Kh(t,n-20)==117853008;if(s){var o=Kh(t,n-12);s=Kh(t,o)==101075792,s&&(i=Kh(t,o+32),a=Kh(t,o+48))}for(var l=0;l"u")return is.DEFAULT;try{return localStorage.getItem(Z1e)||is.DEFAULT}catch{return is.DEFAULT}}saveReasoningEffortDefaults(){typeof globalThis.localStorage>"u"||localStorage.setItem(Z1e,this.pendingReasoningEffort)}messageUpdateCallback=null;initPromise=null;init(){return this.initPromise?this.initPromise:(this.initPromise=(async()=>{try{await gLt.runAllMigrations(),await this.loadConversations(),this.isInitialized=!0}catch(e){console.error("Failed to initialize conversations:",e),this.initPromise=null}})(),this.initPromise)}async initialize(){return this.init()}registerMessageUpdateCallback(e){this.messageUpdateCallback=e}addMessageToActive(e){this.activeMessages.push(e)}updateMessageAtIndex(e,r){const n=e===-1?void 0:this.activeMessages[e];if(!n)return;const i=n;for(const[a,s]of Object.entries(r))i[a]!==s&&(i[a]=s)}findMessageIndex(e){return this.activeMessages.findIndex(r=>r.id===e)}sliceActiveMessages(e){this.activeMessages=this.activeMessages.slice(0,e)}removeMessageAtIndex(e){if(e!==-1)return this.activeMessages.splice(e,1)[0]}async loadConversations(){const e=await cn.getAllConversations();this.conversations=e}async createConversation(e){const r=e||`Chat ${new Date().toLocaleString()}`,n=await cn.createConversation(r,{cwd:this.pendingCwd??void 0,reasoningEffort:this.pendingReasoningEffort});return this.pendingCwd=null,this.conversations=[n,...this.conversations],this.activeConversation=n,this.activeMessages=[],await Ga(Xg.chat(n.id)),n.id}async loadConversation(e){try{const r=await cn.getConversation(e);if(!r)return!1;if(this.pendingCwd=null,this.activeConversation=r,r.currNode){const n=await cn.getConversationMessages(e),i=Cb(n,r.currNode,!1);this.activeMessages=i}else{const n=await cn.getConversationMessages(e);this.activeMessages=n}return!0}catch(r){return console.error("Failed to load conversation:",r),!1}}clearActiveConversation(){this.activeConversation=null,this.activeMessages=[],this.pendingReasoningEffort=bP.loadReasoningEffortDefault(),this.pendingCwd=null}async deleteConversation(e,r){try{if(await cn.deleteConversation(e,r),r?.deleteWithForks){const n=new ka([e]),i=[e];for(;i.length>0;){const a=i.pop();for(const s of this.conversations)s.forkedFromConversationId===a&&!n.has(s.id)&&(n.add(s.id),i.push(s.id))}this.conversations=this.conversations.filter(a=>!n.has(a.id)),this.activeConversation&&n.has(this.activeConversation.id)&&(this.clearActiveConversation(),await Ga(Sa.NEW_CHAT))}else{const i=this.conversations.find(a=>a.id===e)?.forkedFromConversationId;this.conversations=this.conversations.filter(a=>a.id!==e).map(a=>a.forkedFromConversationId===e?{...a,forkedFromConversationId:i}:a),this.activeConversation?.id===e&&(this.clearActiveConversation(),await Ga(Sa.NEW_CHAT))}}catch(n){console.error("Failed to delete conversation:",n)}}async deleteAll(){try{const e=await cn.getAllConversations();await cn.bulkDeleteConversations(e.map(r=>r.id)),this.clearActiveConversation(),this.conversations=[],Qi.success("All conversations deleted"),await Ga(Sa.NEW_CHAT)}catch(e){console.error("Failed to delete all conversations:",e),Qi.error("Failed to delete conversations")}}async bulkDeleteConversations(e){if(e.length!==0)try{const r=new ka(e),n=[...e];for(;n.length>0;){const a=n.pop();for(const s of this.conversations)s.forkedFromConversationId===a&&!r.has(s.id)&&(r.add(s.id),n.push(s.id))}const i=this.activeConversation!==null&&r.has(this.activeConversation.id);await cn.bulkDeleteConversations([...r]),this.conversations=this.conversations.filter(a=>!r.has(a.id)),i&&(this.clearActiveConversation(),await Ga(Sa.NEW_CHAT)),Qi.success(r.size===1?"Conversation deleted":`${r.size} conversations deleted`)}catch(r){console.error("Failed to bulk delete conversations:",r),Qi.error("Failed to delete conversations")}}async bulkToggleConversationPin(e){if(e.length!==0)try{const r=await cn.bulkToggleConversationPins(e),n=this.activeConversation?.id;n&&r.has(n)&&(this.activeConversation={...this.activeConversation,pinned:r.get(n)});for(let i=0;ia.timestamp>i.timestamp?a:i).id,n=Cb(e,r,!1);this.activeMessages=n}async getConversationMessages(e){return await cn.getConversationMessages(e)}async updateConversationName(e,r){try{await cn.updateConversation(e,{name:r});const n=this.conversations.findIndex(i=>i.id===e);n!==-1&&(this.conversations[n].name=r),this.activeConversation?.id===e&&(this.activeConversation={...this.activeConversation,name:r})}catch(n){console.error("Failed to update conversation name:",n)}}async toggleConversationPin(e){try{const r=await cn.toggleConversationPin(e),n=this.conversations.findIndex(i=>i.id===e);return n!==-1&&(this.conversations[n].pinned=r),this.activeConversation?.id===e&&(this.activeConversation={...this.activeConversation,pinned:r}),r}catch(r){return console.error("Failed to toggle conversation pin:",r),!1}}updateConversationTimestamp(e){const r=e??this.activeConversation?.id;if(!r)return;const n=Date.now(),i=this.conversations.findIndex(a=>a.id===r);if(i!==-1){this.conversations[i].lastModified=n;const a=this.conversations.splice(i,1)[0];this.conversations=[a,...this.conversations]}this.activeConversation?.id===r&&(this.activeConversation={...this.activeConversation,lastModified:n}),cn.updateConversation(r,{lastModified:n}).catch(a=>console.error("Failed to update conversation timestamp:",a))}async updateCurrentNode(e){this.activeConversation&&(await cn.updateCurrentNode(this.activeConversation.id,e),this.activeConversation={...this.activeConversation,currNode:e})}async navigateToSibling(e){if(!this.activeConversation)return;const r=await cn.getConversationMessages(this.activeConversation.id),n=r.find(s=>s.type==="root"&&s.parent===null),i=this.activeMessages.find(s=>s.role===Sr.USER&&s.parent===n?.id),a=JJ(r,e);if(await cn.updateCurrentNode(this.activeConversation.id,a),this.activeConversation={...this.activeConversation,currNode:a},await this.refreshActiveMessages(),n&&this.activeMessages.length>0){const s=this.activeMessages.find(o=>o.role===Sr.USER&&o.parent===n.id);s&&s.content.trim()&&(!i||s.id!==i.id||s.content.trim()!==i.content.trim())&&await this.updateConversationName(this.activeConversation.id,P6(s.content,!!Vn().titleGenerationUseFirstLine))}}#s(e){const r=Xr.getServers().find(n=>n.id===e);if(r)return{enabled:r.enabled,serverId:e}}getMcpServerOverride(e){const r=this.activeConversation?.mcpServerOverrides?.find(n=>n.serverId===e);return r||this.#s(e)}getAllMcpServerOverrides(){const e=this.activeConversation?.mcpServerOverrides;return Xr.getServers().map(r=>({enabled:e?.find(i=>i.serverId===r.id)?.enabled??r.enabled,serverId:r.id}))}isMcpServerEnabledForChat(e){return this.getMcpServerOverride(e)?.enabled??!1}async setMcpServerOverride(e,r){if(!this.activeConversation){r!==void 0&&Xr.updateServer(e,{enabled:r});return}const n=(this.activeConversation.mcpServerOverrides||[]).map(s=>({enabled:s.enabled,serverId:s.serverId}));let i;if(r===void 0)i=n.filter(s=>s.serverId!==e);else{const s=n.findIndex(o=>o.serverId===e);s>=0?(i=[...n],i[s]={enabled:r,serverId:e}):i=[...n,{enabled:r,serverId:e}]}await cn.updateConversation(this.activeConversation.id,{mcpServerOverrides:i.length>0?i:void 0}),this.activeConversation={...this.activeConversation,mcpServerOverrides:i.length>0?i:void 0};const a=this.conversations.findIndex(s=>s.id===this.activeConversation.id);a!==-1&&(this.conversations[a].mcpServerOverrides=i.length>0?i:void 0)}async toggleMcpServerForChat(e){const r=this.isMcpServerEnabledForChat(e);await this.setMcpServerOverride(e,!r)}async removeMcpServerOverride(e){await this.setMcpServerOverride(e,void 0)}getReasoningEffort(){if(this.activeConversation){if(this.activeConversation.reasoningEffort!==void 0)return this.activeConversation.reasoningEffort;if(this.activeConversation.thinkingEnabled===!1)return is.OFF}return this.pendingReasoningEffort}async setReasoningEffort(e){if(!this.activeConversation){this.pendingReasoningEffort=e,this.saveReasoningEffortDefaults();return}this.activeConversation={...this.activeConversation,reasoningEffort:e},await cn.updateConversation(this.activeConversation.id,{reasoningEffort:e});const r=this.conversations.findIndex(n=>n.id===this.activeConversation.id);r!==-1&&(this.conversations[r].reasoningEffort=e)}async setCwd(e){const r=e?.trim()||void 0;if(!this.activeConversation){this.pendingCwd=r??null;return}this.activeConversation={...this.activeConversation,cwd:r},await cn.updateConversation(this.activeConversation.id,{cwd:r});const n=this.conversations.findIndex(i=>i.id===this.activeConversation.id);n!==-1&&(this.conversations[n].cwd=r,this.conversations=[...this.conversations]),this.pendingCwd=null}async forkConversation(e,r){if(!this.activeConversation)return null;try{const n=await cn.forkConversation(this.activeConversation.id,e,r);return this.conversations=[n,...this.conversations],await Ga(Xg.chat(n.id)),Qi.success("Conversation forked"),n.id}catch(n){return console.error("Failed to fork conversation:",n),Qi.error("Failed to fork conversation"),null}}generateConversationFilename(e,r){const i=(e.name??"").trim().toLowerCase().replace(sCt,oCt).replace(lCt,"_").substring(0,nCt),o=(r?.length?new Date(Math.max(...r.map(u=>u.timestamp))):new Date).toISOString().slice(0,iCt).replace(y_e,cCt).replaceAll(uCt,dCt),l=e.id?.slice(0,rCt)??"";return`${o}_conv_${l}_${i}${Lr.JSONL}`}serializeSessionToJsonl(e){const{conv:r,messages:n}=e,i=JSON.stringify({harness:aCt,type:RE.SESSION,...r}),a=n.map(s=>{const{toolCalls:o,...l}=s,u=o?{...l,toolCalls:JSON.parse(o)}:l;return JSON.stringify({message:u,type:RE.MESSAGE})});return[i,...a].join(Na)}parseSessionsJsonl(e){const r=[];let n=null;for(const i of e.split(Na)){const a=i.trim();if(!a)continue;const s=JSON.parse(a);if(s.type===RE.SESSION){const o={...s};delete o.type,delete o.harness,n={conv:o,messages:[]},r.push(n)}else if(s.type===RE.MESSAGE){if(!n)throw new Error("Invalid JSONL: message record before any session record");const o=s.message;o.toolCalls!==void 0&&typeof o.toolCalls!="string"&&(o.toolCalls=JSON.stringify(o.toolCalls)),n.messages.push(o)}}return r}isSessionsJsonl(e){const r=e.trimStart(),n=r.indexOf(Na),i=n===-1?r:r.slice(0,n);try{return JSON.parse(i).type===RE.SESSION}catch{return!1}}async parseImportFile(e){const r=new Uint8Array(await e.arrayBuffer());if(aEt.every((a,s)=>r[s]===a)){const a=FLt(r),s=[];for(const[o,l]of Object.entries(a))o.toLowerCase().endsWith(Lr.JSONL)&&s.push(...this.parseSessionsJsonl(Pee(l)));return s}const n=Pee(r);if(this.isSessionsJsonl(n))return this.parseSessionsJsonl(n);const i=JSON.parse(n);if(Array.isArray(i))return i;if(i&&typeof i=="object"&&"conv"in i&&"messages"in i)return[i];throw new Error("Invalid file format: expected array of conversations or single conversation object")}downloadConversationFile(e,r){const{conv:n,messages:i}=e;if(!n){console.error("Invalid data: missing conversation");return}const a=r??this.generateConversationFilename(n,i),s=this.serializeSessionToJsonl(e),o=new Blob([s],{type:Or.JSONL});this.triggerDownload(o,a)}downloadConversationsArchive(e){if(e.length===0){console.error("Invalid data: no conversations to export");return}const r=new ka,n={};for(const o of e){const l=this.generateConversationFilename(o.conv,o.messages);let u=l,d=1;for(;r.has(u);)u=l.replace(new RegExp(`${Lr.JSONL}$`),`_${d++}${Lr.JSONL}`);r.add(u),n[u]=Lee(this.serializeSessionToJsonl(o))}const i=`${new Date().toISOString().split(y_e)[0]}_conversations${Lr.ZIP}`,a=PLt(n),s=new Blob([a],{type:jg.ZIP});this.triggerDownload(s,i)}triggerDownload(e,r){const n=URL.createObjectURL(e),i=document.createElement("a");i.href=n,i.download=r,document.body.appendChild(i),i.click(),document.body.removeChild(i),URL.revokeObjectURL(n)}async downloadConversation(e){const r=this.activeConversation?.id===e?this.activeConversation:await cn.getConversation(e);if(!r)return;const n=await cn.getConversationMessages(e);this.downloadConversationFile({conv:r,messages:n})}async importConversationsData(e){const r=await cn.importConversations(e);return await this.loadConversations(),r}}const Et=new bP;Et.init();const Qh=()=>Et.conversations,yl=()=>Et.activeConversation,Cu=()=>Et.activeMessages,BLt=()=>Et.pendingCwd,ULt=()=>Et.isInitialized,WEe=(t,e)=>t.pinned&&!e.pinned?-1:!t.pinned&&e.pinned?1:e.lastModified-t.lastModified;function jce(t){const e=new ws,r=new ka;for(const o of t)if(o.forkedFromConversationId){r.add(o.id);const l=e.get(o.forkedFromConversationId)||[];l.push(o),e.set(o.forkedFromConversationId,l)}const n=[],i=new ka;function a(o,l){i.add(o.id),n.push({conversation:o,depth:l});const u=e.get(o.id);if(u){u.sort(WEe);for(const d of u)a(d,l+1)}}const s=t.filter(o=>!r.has(o.id)).sort(WEe);for(const o of s)a(o,0);for(const o of t)i.has(o.id)||a(o,1);return n}const hMe=["enable_thinking","reasoning_effort","thinking_budget"],fMe=[["",""],["<|channel>thought","<|channel|>"],["<|think|>",""],["",""],["",null]],pMe=[/\{%-?\s*if\s+\(?\s*\w*enable[\s_]+\w*(thinking|think|reasoning)/i,/\{%-?\s*if\s+\w*(thinking|reasoning)\s*(is not|==|!=)/i,/\{%-?\s*if\s+not\s+\w*enable/i,/\{%-?\s*if\s+ns\.enable_thinking/i];function GI(t){if(!t)return!1;for(const e of hMe)if(new RegExp(`(\\{\\{[^{}]*\\b${e}\\b[^{}]*\\}\\}|\\{%[^{}]*\\b${e}\\b[^{}]*%\\})`,"i").test(t))return!0;for(const e of pMe)if(e.test(t))return!0;for(const[e,r]of fMe)if(t.includes(e)&&(!r||t.includes(r)))return!0;return!1}function KEe(t){if(!t)return{reason:"No chat template available",supported:!1};for(const e of hMe)if(new RegExp(`(\\{\\{[^{}]*\\b${e}\\b[^{}]*\\}\\}|\\{%[^{}]*\\b${e}\\b[^{}]*%\\})`,"i").test(t))return{reason:"Found: "+e,supported:!0};for(const e of pMe)if(e.test(t))return{reason:"Found: thinking conditional",supported:!0};for(const[e,r]of fMe)if(t.includes(e)&&(!r||t.includes(r)))return{reason:"Found: "+e+(r?" .. "+r:" (self)"),supported:!0};return{reason:"No thinking patterns found",supported:!1}}class Xce{#e=Oe(Zr([]));get models(){return S(this.#e)}set models(e){X(this.#e,e,!0)}#t=Oe(Zr([]));get routerModels(){return S(this.#t)}set routerModels(e){X(this.#t,e,!0)}#r=Oe(!1);get loading(){return S(this.#r)}set loading(e){X(this.#r,e,!0)}#n=Oe(!1);get updating(){return S(this.#n)}set updating(e){X(this.#n,e,!0)}#i=Oe(null);get error(){return S(this.#i)}set error(e){X(this.#i,e,!0)}#a=Oe(null);get selectedModelId(){return S(this.#a)}set selectedModelId(e){X(this.#a,e,!0)}#s=Oe(null);get selectedModelName(){return S(this.#s)}set selectedModelName(e){X(this.#s,e,!0)}inflightFetch=null;#o=Oe(Zr(new Map));get modelUsage(){return S(this.#o)}set modelUsage(e){X(this.#o,e,!0)}modelLoadingStates=new ws;statusAbort=null;statusReaderActive=!1;loadProgress=new ws;statusWaiters=new Map;#l=Oe(Zr(this.loadFavoritesFromStorage()));get favoriteModelIds(){return S(this.#l)}set favoriteModelIds(e){X(this.#l,e,!0)}modelPropsCache=new ZDt({maxEntries:dEt,ttlMs:uEt});#c=Oe(Zr(new Set));get modelPropsFetching(){return S(this.#c)}set modelPropsFetching(e){X(this.#c,e,!0)}#d=Oe(0);get propsCacheVersion(){return S(this.#d)}set propsCacheVersion(e){X(this.#d,e,!0)}get selectedModel(){return this.selectedModelId?this.models.find(e=>e.id===this.selectedModelId)??null:null}get loadedModelIds(){return this.routerModels.filter(e=>e.status.value===Io.LOADED||e.status.value===Io.SLEEPING).map(e=>e.id)}get loadingModelIds(){return Array.from(this.modelLoadingStates.entries()).filter(([,e])=>e).map(([e])=>e)}get singleModelName(){if(ls())return null;const e=$a.props;return e?.model_alias?e.model_alias:e?.model_path&&e.model_path.split(/(\\|\/)/).pop()||null}get selectedModelContextSize(){return this.selectedModelName?this.getModelContextSize(this.selectedModelName):null}getModelModalities(e){if(!ls()&&$a.props?.modalities)return this.buildModalities($a.props.modalities);const r=this.models.find(i=>i.model===e||i.id===e);if(r?.modalities)return r.modalities;const n=this.modelPropsCache.get(e);return n?.modalities?this.buildModalities(n.modalities):null}modelSupportsVision(e){return this.getModelModalities(e)?.vision??!1}modelSupportsAudio(e){return this.getModelModalities(e)?.audio??!1}modelSupportsVideo(e){return this.getModelModalities(e)?.video??!1}getModelModalitiesArray(e){const r=this.getModelModalities(e);if(!r)return[];const n=[];return r.vision&&n.push(h0.VISION),r.audio&&n.push(h0.AUDIO),r.video&&n.push(h0.VIDEO),n}getModelProps(e){return this.modelPropsCache.get(e)}getModelContextSize(e){const n=this.getModelProps(e)?.default_generation_settings?.n_ctx;return typeof n=="number"?n:null}isModelPropsFetching(e){return this.modelPropsFetching.has(e)}isModelLoaded(e){const r=this.routerModels.find(n=>n.id===e);return r?.status.value===Io.LOADED||r?.status.value===Io.SLEEPING}isModelOperationInProgress(e){return this.modelLoadingStates.get(e)??!1}getModelStatus(e){return this.routerModels.find(n=>n.id===e)?.status.value??null}getModelUsage(e){return this.modelUsage.get(e)??new ka}isModelInUse(e){const r=this.modelUsage.get(e);return r!==void 0&&r.size>0}get supportsThinking(){if(!ls())return GI($a.props?.chat_template??"");const e=this.selectedModelName;if(!e)return!1;this.modelPropsCache.get(e)||this.fetchModelProps(e);const r=this.getModelProps(e);return GI(r?.chat_template??"")}checkModelSupportsThinking(e){if(!ls())return GI($a.props?.chat_template??"");if(!e)return!1;this.modelPropsCache.get(e)||this.fetchModelProps(e);const r=this.getModelProps(e);return GI(r?.chat_template??"")}get thinkingSupportDetails(){if(!ls())return KEe($a.props?.chat_template??"");const e=this.selectedModelName;if(!e)return{reason:"No model selected",supported:!1};this.modelPropsCache.get(e)||this.fetchModelProps(e);const r=this.getModelProps(e);return KEe(r?.chat_template??"")}async fetch(e=!1){if(this.inflightFetch)return this.inflightFetch;if(!(this.models.length>0&&!e)){this.inflightFetch=this.runFetch();try{await this.inflightFetch}finally{this.inflightFetch=null}}}async runFetch(){this.loading=!0,this.error=null;try{if($a.props||await $a.fetch(),ls()){const r=await Ly.listRouter();this.routerModels=r.data,this.models=this.buildModelOptions(r),await this.fetchModalitiesForLoadedModels();const n=this.getVisibleModels();n.length===1&&this.isModelLoaded(n[0].model)&&this.selectModelById(n[0].id)}else this.models=await this.fetchModelModeInternal()}catch(e){throw this.models=[],this.error=e instanceof Error?e.message:"Failed to load models",e}finally{this.loading=!1}}async fetchModelModeInternal(){const e=await Ly.list();return this.buildModelOptions(e)}buildModelOptions(e){return e.data.map((r,n)=>{const i=e.models?.[n],a=Array.isArray(i?.capabilities)?i?.capabilities:[],s=i?.name&&i.name.trim().length>0?i.name:r.id,o=i?.model||r.id;return{aliases:r.aliases??[],capabilities:a.filter(l=>!!l),description:i?.description,details:i?.details,id:r.id,meta:r.meta??null,modalities:this.buildArchitectureModalities(r.architecture),model:o,name:this.toDisplayName(s),parsedId:Ly.parseModelId(o),tags:r.tags??[]}})}async fetchRouterModels(){if(ls())try{const e=await Ly.listRouter();this.routerModels=e.data,await this.fetchModalitiesForLoadedModels();const r=this.getVisibleModels();r.length===1&&this.isModelLoaded(r[0].model)&&this.selectModelById(r[0].id)}catch(e){console.warn("Failed to fetch router models:",e),this.routerModels=[]}}async fetchModelProps(e){const r=this.modelPropsCache.get(e);if(r)return r;if($a.isRouterMode&&!this.isModelLoaded(e)||this.modelPropsFetching.has(e))return null;this.modelPropsFetching.add(e);try{const n=await UIe.fetchForModel(e);return this.modelPropsCache.set(e,n),this.propsCacheVersion++,n}catch(n){return console.warn(`Failed to fetch props for model ${e}:`,n),null}finally{this.modelPropsFetching.delete(e)}}async fetchModalitiesForLoadedModels(){const e=this.loadedModelIds;if(e.length===0)return;const r=e.map(n=>this.fetchModelProps(n));try{const n=await Promise.all(r);this.models=this.models.map(i=>{const a=e.indexOf(i.model);if(a===-1)return i;const s=n[a];return s?.modalities?{...i,modalities:this.buildModalities(s.modalities)}:i}),this.propsCacheVersion++}catch(n){console.warn("Failed to fetch modalities for loaded models:",n)}}async updateModelModalities(e){const r=await this.fetchModelProps(e);r?.modalities&&(this.models=this.models.map(n=>n.model===e?{...n,modalities:this.buildModalities(r.modalities)}:n),this.propsCacheVersion++)}getVisibleModels(){return this.models.filter(e=>this.getModelProps(e.model)?.ui!==!1)}getModelFromLastAssistantResponse(){const e=Et.activeMessages;if(!e||e.length===0)return null;for(let r=e.length-1;r>=0;r--)if(e[r].model)return e[r].model;return null}async selectModelFromLastAssistantResponse(){const e=this.getModelFromLastAssistantResponse();if(!e||this.selectedModelName===e)return!1;const r=this.models.find(n=>n.model===e);if(!r||!this.isModelLoaded(e))return!1;try{return await this.selectModelById(r.id),console.log(`[modelsStore] Automatically selected model: ${e} from last message`),!0}catch(n){return console.warn("[modelsStore] Failed to automatically select model from last message:",n),!1}}async ensureFirstModelSelected(){if(this.selectedModelName)return;const e=this.getVisibleModels();if(e.length===0)return;const r=this.getModelFromLastAssistantResponse();if(r){const a=e.find(s=>s.model===r);if(a){await this.selectModelById(a.id),this.isModelLoaded(r)&&await this.fetchModelProps(r);return}}const n=e.find(a=>this.isModelLoaded(a.model));if(n){await this.selectModelById(n.id),await this.fetchModelProps(n.model);return}const i=this.favoriteModelIds.values().next()?.value;if(i){await this.selectModelById(i);return}await this.selectModelById(e[0].id)}async selectModelById(e){if(!e||this.updating||this.selectedModelId===e)return;const r=this.models.find(n=>n.id===e);if(!r)throw new Error("Selected model is not available");this.updating=!0,this.error=null;try{this.selectedModelId=r.id,this.selectedModelName=r.model}finally{this.updating=!1}}selectModelByName(e){const r=this.models.find(n=>n.model===e);r&&(this.selectedModelId=r.id,this.selectedModelName=r.model)}clearSelection(){this.selectedModelId=null,this.selectedModelName=null}findModelByName(e){return this.models.find(r=>r.model===e||r.id===e||r.aliases?.includes(e))??null}findModelById(e){return this.models.find(r=>r.id===e)??null}hasModel(e){return this.models.some(r=>r.model===e)}static SSE_RECONNECT_MS=1e3;subscribeStatus(){this.statusReaderActive||ls()&&(this.statusReaderActive=!0,this.statusAbort=new AbortController,this.runStatusReader(this.statusAbort.signal))}unsubscribeStatus(){this.statusReaderActive=!1,this.statusAbort?.abort(),this.statusAbort=null,this.loadProgress.clear()}getLoadProgress(e){return this.loadProgress.get(e)??null}async runStatusReader(e){const r=new TextDecoder;for(;!e.aborted;){try{const n=await fetch(`${tl}${k6.SSE}`,{headers:op(),signal:e});if(n.ok&&n.body){const i=n.body.getReader();let a="";for(;!e.aborted;){const{done:s,value:o}=await i.read();if(s)break;a+=r.decode(o,{stream:!0});let l=a.indexOf(RD);for(;l!==-1;)this.handleStatusRecord(a.slice(0,l)),a=a.slice(l+RD.length),l=a.indexOf(RD)}}}catch{}if(e.aborted)return;await new Promise(n=>setTimeout(n,Xce.SSE_RECONNECT_MS))}}handleStatusRecord(e){const r=e.split(WL).filter(i=>i.startsWith(ix)).map(i=>i.slice(ix.length).trim()).join(WL);if(r.length===0)return;let n;try{n=JSON.parse(r)}catch{return}this.applyStatusEvent(n)}applyStatusEvent(e){switch(e.event){case Oy.STATUS_CHANGE:case Oy.MODEL_STATUS:case Oy.STATUS_UPDATE:this.applyModelStatus(e);break;case Oy.MODELS_RELOAD:this.fetchRouterModels();break;case Oy.MODEL_REMOVE:this.removeRouterModel(e.model);break;case Oy.DOWNLOAD_PROGRESS:break}}applyModelStatus(e){const r=e.model,n=e.data;if(!r||!n?.status)return;const i=n.status;if(this.setRouterModelStatus(r,i),i===Io.LOADING?n.progress&&this.loadProgress.set(r,n.progress):this.loadProgress.delete(r),i===Io.LOADED&&this.updateModelModalities(r),i===Io.FAILED||i===Io.UNLOADED&&(n.exit_code??0)!==0){this.rejectStatus(r,new Error(`Model failed: ${this.toDisplayName(r)}`));return}this.settleStatus(r,i)}removeRouterModel(e){this.routerModels.findIndex(r=>r.id===e)!==-1&&(this.routerModels=this.routerModels.filter(r=>r.id!==e),this.loadProgress.delete(e),this.rejectStatus(e,new Error(`Model removed: ${this.toDisplayName(e)}`)))}setRouterModelStatus(e,r){const n=this.routerModels.findIndex(s=>s.id===e);if(n===-1)return;const i=this.routerModels[n];if(i.status.value===r)return;const a=[...this.routerModels];a[n]={...i,status:{...i.status,value:r}},this.routerModels=a}waitForStatus(e,r){return new Promise((n,i)=>{this.statusWaiters.set(e,{reject:i,resolve:n,target:r})})}settleStatus(e,r){const n=this.statusWaiters.get(e);n&&n.target===r&&(this.statusWaiters.delete(e),n.resolve())}rejectStatus(e,r){const n=this.statusWaiters.get(e);n&&(this.statusWaiters.delete(e),n.reject(r))}async loadModel(e){if(this.isModelLoaded(e)||this.modelLoadingStates.get(e))return;this.modelLoadingStates.set(e,!0),this.error=null,this.subscribeStatus();const r=this.waitForStatus(e,Io.LOADED);r.catch(()=>{});try{await Ly.load(e),await r,Qi.success(`Model loaded: ${this.toDisplayName(e)}`)}catch(n){throw this.rejectStatus(e,n instanceof Error?n:new Error("load failed")),this.error=n instanceof Error?n.message:"Failed to load model",Qi.error(`Failed to load model: ${this.toDisplayName(e)}`),n}finally{this.modelLoadingStates.set(e,!1)}}async unloadModel(e){if(!this.isModelLoaded(e)||this.modelLoadingStates.get(e))return;this.modelLoadingStates.set(e,!0),this.error=null,this.subscribeStatus();const r=this.waitForStatus(e,Io.UNLOADED);r.catch(()=>{});try{await Ly.unload(e),await r,Qi.info(`Model unloaded: ${this.toDisplayName(e)}`)}catch(n){throw this.rejectStatus(e,n instanceof Error?n:new Error("unload failed")),this.error=n instanceof Error?n.message:"Failed to unload model",Qi.error(`Failed to unload model: ${this.toDisplayName(e)}`),n}finally{this.modelLoadingStates.set(e,!1)}}async ensureModelLoaded(e){this.isModelLoaded(e)||await this.loadModel(e)}isFavorite(e){return this.favoriteModelIds.has(e)}toggleFavorite(e){const r=new ka(this.favoriteModelIds);r.has(e)?r.delete(e):r.add(e),this.favoriteModelIds=r;try{localStorage.setItem(BJ,JSON.stringify([...r]))}catch{Qi.error("Failed to save favorite models to local storage")}}loadFavoritesFromStorage(){try{const e=localStorage.getItem(BJ);return e?new Set(JSON.parse(e)):new Set}catch{return Qi.error("Failed to load favorite models from local storage"),new Set}}toDisplayName(e){const n=e.split(/\\|\//).pop();return n&&n.trim().length>0?n:e}buildModalities(e){return{audio:e.audio??!1,video:e.video??!1,vision:e.vision??!1}}buildArchitectureModalities(e){if(!e)return;const r=e.input_modalities;return{audio:r.includes(pi.AUDIO),video:r.includes(pi.VIDEO),vision:r.includes(pi.IMAGE)}}clear(){this.unsubscribeStatus(),this.statusWaiters.forEach(e=>e.reject(new Error("Models store cleared"))),this.statusWaiters.clear(),this.models=[],this.routerModels=[],this.loading=!1,this.updating=!1,this.error=null,this.selectedModelId=null,this.selectedModelName=null,this.modelUsage.clear(),this.modelLoadingStates.clear(),this.modelPropsCache.clear(),this.modelPropsFetching.clear()}pruneExpiredCache(){return this.modelPropsCache.prune()}}const Ar=new Xce,rf=()=>Ar.models,SP=()=>Ar.routerModels,gMe=()=>Ar.loading,$Lt=()=>Ar.updating,L_=()=>Ar.selectedModelId,r_=()=>Ar.selectedModelName,GLt=()=>Ar.loadedModelIds,mMe=()=>Ar.propsCacheVersion,Qce=()=>Ar.singleModelName,zLt=()=>Ar.selectedModelContextSize,qLt=()=>Ar.supportsThinking,HLt=t=>Ar.checkModelSupportsThinking(t);var VLt=se(" ",1),YLt=se('
      ');function WLt(t,e){at(e,!0);let r=ce(e,"attachments",19,()=>[]),n=ce(e,"class",3,""),i=ce(e,"previewFocusIndex",3,0),a=ce(e,"uploadedFiles",19,()=>[]),s=W(()=>KIe({attachments:r(),uploadedFiles:a()}).filter(L=>!Jle(L)&&!ece(L)).map(L=>({...L,isAudio:QJ(L.attachment,L.uploadedFile),isImage:XJ(L.attachment,L.uploadedFile),isVideo:ZJ(L.attachment,L.uploadedFile)}))),o=Oe(0);Kt(()=>{i()>=0&&i(){const L=I=>{I.detail<0?X(o,S(o)>0?S(o)-1:S(s).length-1,!0):X(o,S(o)document.removeEventListener("chat-attachments-nav",L)}),Kt(()=>{const L=S(o);setTimeout(()=>{document.querySelector(`[data-thumbnail-index="${L}"]`)?.scrollIntoView({behavior:"smooth",block:"nearest",inline:"center"})},0)});let l=W(()=>S(s)[S(o)]??null),u=W(()=>S(l)?.name||S(l)?.uploadedFile?.name||S(l)?.attachment?.name||"Unknown File"),d=W(()=>S(l)?QJ(S(l).attachment,S(l).uploadedFile):!1),h=W(()=>S(l)?ZJ(S(l).attachment,S(l).uploadedFile):!1),f=W(()=>S(l)?XJ(S(l).attachment,S(l).uploadedFile):!1),p=W(()=>S(l)?tce(S(l).attachment,S(l).uploadedFile):!1),g=W(()=>S(l)?jIe(S(l).attachment,S(l).uploadedFile):!1),m=W(()=>S(l)?.uploadedFile?.preview||(S(f)&&S(l)?.attachment&&"base64Url"in S(l).attachment?S(l).attachment.base64Url:S(l)?.preview)),_=W(()=>S(l)?.uploadedFile?.textContent||(S(l)?.attachment&&"content"in S(l).attachment?S(l).attachment.content:S(l)?.textContent)),v=W(()=>nce(S(u))),b=W(()=>S(l)?.size?JL(S(l).size):""),y=W(()=>S(l)&&e.activeModelId?Ar.modelSupportsVision(e.activeModelId):!1),E=W(()=>S(d)&&S(l)?S(l).uploadedFile?.preview??(S(l).attachment&&"mimeType"in S(l).attachment&&"base64Data"in S(l).attachment?HR(S(l).attachment.mimeType,S(l).attachment.base64Data):null):null),T=W(()=>S(h)&&S(l)?S(l).uploadedFile?.preview??(S(l).attachment&&"mimeType"in S(l).attachment&&"base64Data"in S(l).attachment?HR(S(l).attachment.mimeType,S(l).attachment.base64Data):null):null);function C(){X(o,S(o)>0?S(o)-1:S(s).length-1,!0)}function w(){X(o,S(o)S(s).length>1);jLt(F,{onPrev:C,onNext:w,get show(){return S(L)}})}var P=ie(F,2),N=te(P);{var k=L=>{var I=VLt(),U=oe(I);ZLt(U,{get displayName(){return S(u)},get fileSize(){return S(b)}});var B=ie(U,2);pUt(B,{get currentItem(){return S(l)},get isImage(){return S(f)},get isAudio(){return S(d)},get isVideo(){return S(h)},get isPdf(){return S(p)},get isText(){return S(g)},get displayPreview(){return S(m)},get displayTextContent(){return S(_)},get audioSrc(){return S(E)},get videoSrc(){return S(T)},get language(){return S(v)},get hasVisionModality(){return S(y)},get activeModelId(){return e.activeModelId}}),G(L,I)};ve(N,L=>{S(l)&&L(k)})}var M=ie(N,2);return IPt(M,{get items(){return S(s)},get currentIndex(){return S(o)},onNavigate:x}),Z(P),Z(O),Z(R),$e(()=>Yt(R,1,`${n()??""} flex flex-col text-white`)),G(t,R),st(A)}var KLt=se(" ",1);function jLt(t,e){var r=Ae(),n=oe(r);{var i=a=>{var s=KLt(),o=oe(s);Gn(o,{variant:"secondary",size:"icon",class:"absolute top-1/2 left-4 z-10 h-8 w-8 -translate-y-1/2 rounded-full bg-background/5 p-0 text-white!",get onclick(){return e.onPrev},"aria-label":"Previous",children:(u,d)=>{GU(u,{class:"size-4"})},$$slots:{default:!0}});var l=ie(o,2);Gn(l,{variant:"secondary",size:"icon",class:"absolute top-1/2 right-4 z-10 h-8 w-8 -translate-y-1/2 rounded-full bg-background/5 p-0 text-white!",get onclick(){return e.onNext},"aria-label":"Next",children:(u,d)=>{Vc(u,{class:"size-4"})},$$slots:{default:!0}}),G(a,s)};ve(n,a=>{e.show&&a(i)})}G(t,r)}var XLt=se('

      '),QLt=se('

      ');function ZLt(t,e){var r=QLt(),n=te(r),i=te(n,!0);Z(n);var a=ie(n,2);{var s=o=>{var l=XLt(),u=te(l,!0);Z(l),$e(()=>it(u,e.fileSize)),G(o,l)};ve(a,o=>{e.fileSize&&o(s)})}Z(r),$e(()=>it(i,e.displayName)),G(t,r)}var JLt=new Set(["$$slots","$$events","$$legacy","class","files","ref","type","value"]),jEe=se("");function lp(t,e){at(e,!0);let r=ce(e,"files",15),n=ce(e,"ref",15,null),i=ce(e,"value",15),a=Tt(e,JLt);var s=Ae(),o=oe(s);{var l=d=>{var h=jEe();Er(h,f=>({"data-slot":"input",class:f,type:"file",...a}),[()=>jr("flex h-9 w-full min-w-0 rounded-md border border-input bg-transparent px-3 pt-1.5 text-sm font-medium shadow-xs ring-offset-background transition-[color,box-shadow] outline-none selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50 md:text-sm dark:bg-input/30","focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50","aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40",e.class)],void 0,void 0,void 0,!0),Jr(h,f=>n(f),()=>n()),zht(h,r),wR(h,i),G(d,h)},u=d=>{var h=jEe();Er(h,f=>({"data-slot":"input",class:f,style:"backdrop-filter: blur(0.5rem);",type:e.type,...a}),[()=>jr("flex h-9 w-full min-w-0 rounded-md border border-input bg-background px-3 py-1 text-base shadow-xs ring-offset-background transition-[color,box-shadow] outline-none selection:bg-primary selection:text-primary-foreground placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50 md:text-sm dark:bg-input/30","focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50","aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40",e.class)],void 0,void 0,void 0,!0),Jr(h,f=>n(f),()=>n()),wR(h,i),G(d,h)};ve(o,d=>{e.type==="file"?d(l):d(u,-1)})}G(t,s),st()}var ePt=se(''),tPt=se("
      ");function Ov(t,e){at(e,!0);let r=ce(e,"isCancelAlwaysVisible",3,!1),n=ce(e,"placeholder",3,"Search..."),i=ce(e,"ref",15,null),a=ce(e,"value",15,""),s=W(()=>r()||!!a()||!!e.onClose);function o(g){const m=g.target;a(m.value),e.onInput?.(m.value)}function l(){a()?(a(""),e.onInput?.(""),i()?.focus({preventScroll:!0})):e.onClose?.()}var u=tPt(),d=te(u);FL(d,{get class(){return`absolute top-1/2 left-3 z-10 ${vr} -translate-y-1/2 transform text-muted-foreground`}});var h=ie(d,2);{let g=W(()=>S(s)?"pr-9":"");lp(h,{get autofocus(){return e.autofocus},get id(){return e.id},get class(){return`pl-9 ${S(g)??""}`},oninput:o,get onkeydown(){return e.onKeyDown},get placeholder(){return n()},type:"search",get value(){return a()},set value(m){a(m)},get ref(){return i()},set ref(m){i(m)}})}var f=ie(h,2);{var p=g=>{var m=ePt(),_=te(m);Jc(_,{get class(){return vr}}),Z(m),$e(()=>lr(m,"aria-label",a()?"Clear search":"Close")),Kr("click",m,l),G(g,m)};ve(f,g=>{S(s)&&g(p)})}Z(u),$e(()=>Yt(u,1,`relative ${e.class??""}`)),G(t,u),st()}Hi(["click"]);var rPt=new Set(["$$slots","$$events","$$legacy","checked","class","indeterminate","ref"]),nPt=se('
      ');function fh(t,e){at(e,!0);let r=ce(e,"checked",15,!1),n=ce(e,"indeterminate",15,!1),i=ce(e,"ref",15,null),a=Tt(e,rPt);var s=Ae(),o=oe(s);{const l=(d,h)=>{let f=()=>h?.().checked,p=()=>h?.().indeterminate;var g=nPt(),m=te(g);{var _=b=>{X2(b,{class:"size-3.5"})},v=b=>{d2t(b,{class:"size-3.5"})};ve(m,b=>{f()?b(_):p()&&b(v,1)})}Z(g),G(d,g)};let u=W(()=>jr("peer flex size-4 shrink-0 items-center justify-center rounded-[4px] border border-input bg-background shadow-xs transition-shadow outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 data-[state=checked]:border-primary data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:bg-input/30 dark:aria-invalid:ring-destructive/40 dark:data-[state=checked]:bg-primary",e.class));Me(o,()=>U0t,(d,h)=>{h(d,Rt({"data-slot":"checkbox",get class(){return S(u)}},()=>a,{get ref(){return i()},set ref(f){i(f)},get checked(){return r()},set checked(f){r(f)},get indeterminate(){return n()},set indeterminate(f){n(f)},children:l,$$slots:{default:!0}}))})}G(t,s),st()}var iPt=new Set(["$$slots","$$events","$$legacy","children","class","orientation","ref","scrollbarXClasses","scrollbarYClasses"]),aPt=se(" ",1);function _Me(t,e){at(e,!0);let r=ce(e,"orientation",3,"vertical"),n=ce(e,"ref",15,null),i=ce(e,"scrollbarXClasses",3,""),a=ce(e,"scrollbarYClasses",3,""),s=Tt(e,iPt);var o=Ae(),l=oe(o);{let u=W(()=>jr("relative",e.class));Me(l,()=>Mvt,(d,h)=>{h(d,Rt({"data-slot":"scroll-area",get class(){return S(u)}},()=>s,{get ref(){return n()},set ref(f){n(f)},children:(f,p)=>{var g=aPt(),m=oe(g);Me(m,()=>Fvt,(T,C)=>{C(T,{"data-slot":"scroll-area-viewport",class:"size-full rounded-[inherit] ring-ring/10 outline-ring/50 transition-[color,box-shadow] focus-visible:ring-4 focus-visible:outline-1 dark:ring-ring/20 dark:outline-ring/40",children:(w,x)=>{var A=Ae(),R=oe(A);Pt(R,()=>e.children??Vt),G(w,A)},$$slots:{default:!0}})});var _=ie(m,2);{var v=T=>{XEe(T,{orientation:"vertical",get class(){return a()}})};ve(_,T=>{(r()==="vertical"||r()==="both")&&T(v)})}var b=ie(_,2);{var y=T=>{XEe(T,{orientation:"horizontal",get class(){return i()}})};ve(b,T=>{(r()==="horizontal"||r()==="both")&&T(y)})}var E=ie(b,2);Me(E,()=>lyt,(T,C)=>{C(T,{})}),G(f,g)},$$slots:{default:!0}}))})}G(t,o),st()}var sPt=new Set(["$$slots","$$events","$$legacy","children","class","orientation","ref"]),oPt=se(" ",1);function XEe(t,e){at(e,!0);let r=ce(e,"orientation",3,"vertical"),n=ce(e,"ref",15,null),i=Tt(e,sPt);var a=Ae(),s=oe(a);{let o=W(()=>jr("flex touch-none p-px transition-colors select-none",r()==="vertical"&&"h-full w-2.5 border-l border-l-transparent",r()==="horizontal"&&"h-2.5 flex-col border-t border-t-transparent",e.class));Me(s,()=>Zvt,(l,u)=>{u(l,Rt({"data-slot":"scroll-area-scrollbar",get orientation(){return r()},get class(){return S(o)}},()=>i,{get ref(){return n()},set ref(d){n(d)},children:(d,h)=>{var f=oPt(),p=oe(f);Pt(p,()=>e.children??Vt);var g=ie(p,2);Me(g,()=>nyt,(m,_)=>{_(m,{"data-slot":"scroll-area-thumb",class:"relative flex-1 rounded-full bg-border"})}),G(d,f)},$$slots:{default:!0}}))})}G(t,a),st()}function vMe(t){const e=t.dragThresholdPx??5;let r=Oe(null),n=Oe(!1),i=!1,a=0,s=0,o=null,l=null,u=!1;function d(){return t.attributeName?.()??"conversation-row"}function h(C=d()){return C.replace(/-([a-z])/g,(w,x)=>x.toUpperCase())}function f(C,w){return C!==null&&w.has(C)?"remove":"add"}function p(C,w){const x=t.selectedIds(),A=t.orderedIds(),R=A.indexOf(C),O=A.indexOf(w);if(R===-1||O===-1)return;const[F,P]=R=N.top&&w<=N.bottom&&C>=N.left&&C<=N.right)return P.dataset[R]??null;if(C>=N.left&&C<=N.right){const k=Math.abs(w-(N.top+N.height/2));kN||U.bottomk);l==="add"?B&&O.add(I):l==="remove"&&B&&O.has(I)&&O.delete(I)}}function _(C){if(i){if(C.shiftKey&&S(r)!==null){const w=g(C.clientX,C.clientY);w&&w!==o&&p(S(r),w);return}if(!S(n)){const w=C.clientX-a,x=C.clientY-s;if(Math.hypot(w,x){if(!t.enabled()){T();return}return document.addEventListener("mousemove",_),document.addEventListener("mouseup",v),document.addEventListener("click",b,{capture:!0}),()=>{document.removeEventListener("mousemove",_),document.removeEventListener("mouseup",v),document.removeEventListener("click",b,{capture:!0})}});function y(C,w){t.enabled()&&w.button===0&&(w.preventDefault(),i=!0,o=C,a=w.clientX,s=w.clientY,X(n,!1),l=null)}function E(C,w){if(!t.enabled())return;const x=t.selectedIds();if(w){const A=S(r);A!==null&&A!==C?p(A,C):x.has(C)?x.delete(C):x.add(C),X(r,C,!0);return}x.has(C)?x.delete(C):x.add(C),X(r,C,!0)}function T(){X(r,null),X(n,!1),i=!1,u=!1,o=null,l=null,a=0,s=0}return{get dragAnchorId(){return S(r)},reset:T,rowClick:E,rowMouseDown:y}}var lPt=se(''),cPt=se('
      '),uPt=se('
      Conversation NameMessages
      '),dPt=se('
      ');function hPt(t,e){at(e,!0);let r=ce(e,"isOpen",3,!0),n=ce(e,"messageCountMap",19,()=>new Map),i=Oe(""),a=Oe(s());function s(){return new ka(e.conversations.map(P=>P.id))}let o=W(()=>e.conversations.filter(P=>(P.name||"Untitled conversation").toLowerCase().includes(S(i).toLowerCase()))),l=W(()=>S(o).map(P=>P.id)),u=W(()=>S(o).length>0&&S(o).every(P=>S(a).has(P.id))),d=W(()=>S(o).some(P=>S(a).has(P.id))&&!S(u));const h=vMe({enabled:()=>r(),orderedIds:()=>S(l),selectedIds:()=>S(a)});function f(){const P=new ka(S(a));S(u)?S(o).forEach(N=>P.delete(N.id)):S(o).forEach(N=>P.add(N.id)),X(a,P)}function p(){const P=e.conversations.filter(N=>S(a).has(N.id));e.onConfirm(P)}function g(){X(a,s()),X(i,""),h.reset(),e.onCancel()}function m(){X(a,s()),X(i,""),h.reset()}var _={reset:m},v=dPt(),b=te(v);Ov(b,{placeholder:"Search conversations...",get value(){return S(i)},set value(P){X(i,P,!0)}});var y=ie(b,2),E=te(y),T=te(E),C=ie(T);{var w=P=>{var N=or();$e(()=>it(N,`(${S(o).length??""} shown)`)),G(P,N)};ve(C,P=>{S(i)&&P(w)})}Z(E),Z(y);var x=ie(y,2),A=te(x);_Me(A,{class:"h-100",children:(P,N)=>{var k=uPt(),M=te(k),L=te(M),I=te(L),U=te(I);fh(U,{get checked(){return S(u)},get indeterminate(){return S(d)},onCheckedChange:f}),Z(I),Ct(2),Z(L),Z(M);var B=ie(M),$=te(B);{var H=V=>{var Y=lPt(),j=te(Y),Q=te(j);{var ae=ne=>{var ee=or();$e(()=>it(ee,`No conversations found matching "${S(i)??""}"`)),G(ne,ee)},re=ne=>{var ee=or("No conversations available");G(ne,ee)};ve(Q,ne=>{S(i)?ne(ae):ne(re,-1)})}Z(j),Z(Y),G(V,Y)},q=V=>{var Y=Ae(),j=oe(Y);qr(j,17,()=>S(o),Q=>Q.id,(Q,ae)=>{const re=W(()=>S(a).has(S(ae).id));var ne=cPt(),ee=te(ne),J=te(ee);fh(J,{get checked(){return S(re)},onclick:we=>{we.preventDefault(),we.stopPropagation(),h.rowClick(S(ae).id,we.shiftKey)}}),Z(ee);var fe=ie(ee),ue=te(fe),ge=te(ue,!0);Z(ue),Z(fe);var ye=ie(fe),Ie=te(ye,!0);Z(ye),Z(ne),$e(we=>{Yt(ne,1,`cursor-pointer border-b transition-colors hover:bg-muted/50 ${S(re)?"bg-muted/75":""}`),lr(ne,"data-conversation-row",S(ae).id),lr(ue,"title",S(ae).name||"Untitled conversation"),it(ge,S(ae).name||"Untitled conversation"),it(Ie,we)},[()=>n().get(S(ae).id)??0]),Kr("mousedown",ne,we=>h.rowMouseDown(S(ae).id,we)),Kr("click",ne,we=>h.rowClick(S(ae).id,we.shiftKey)),G(Q,ne)}),G(V,Y)};ve($,V=>{S(o).length===0?V(H):V(q,-1)})}Z(B),Z(k),G(P,k)},$$slots:{default:!0}}),Z(x);var R=ie(x,2),O=te(R);Gn(O,{variant:"outline",onclick:g,children:(P,N)=>{Ct();var k=or("Cancel");G(P,k)},$$slots:{default:!0}});var F=ie(O,2);{let P=W(()=>S(a).size===0);Gn(F,{onclick:p,get disabled(){return S(P)},children:(N,k)=>{Ct();var M=or();$e(()=>it(M,`${e.mode==="export"?"Export":"Import"} (${S(a).size??""})`)),G(N,M)},$$slots:{default:!0}})}return Z(R),Z(v),$e(()=>it(T,`${S(a).size??""} of ${e.conversations.length??""} selected `)),G(t,v),st(_)}Hi(["mousedown","click"]);var fPt=se('
      ');function Zce(t,e){at(e,!0);let r=ce(e,"class",3,""),n=ce(e,"gapSize",3,"3"),i=Oe(!1),a=Oe(!1),s=Oe(void 0);function o(y){y?.stopPropagation(),y?.preventDefault(),S(s)&&S(s).scrollBy({behavior:"smooth",left:S(s).clientWidth*-.67})}function l(y){y?.stopPropagation(),y?.preventDefault(),S(s)&&S(s).scrollBy({behavior:"smooth",left:S(s).clientWidth*.67})}function u(){if(!S(s))return;const{clientWidth:y,scrollLeft:E,scrollWidth:T}=S(s);X(i,E>0),X(a,Ey;e.onScrollableChange?.(C)}function d(){S(s)&&(S(s).scrollLeft=0,setTimeout(()=>{u()},0))}Kt(()=>{if(!S(s))return;const y=new ResizeObserver(()=>u());return y.observe(S(s)),()=>y.disconnect()});var h={resetScroll:d},f=fPt(),p=te(f),g=te(p);GU(g,{get class(){return vr}}),Z(p);var m=ie(p,2),_=te(m);Pt(_,()=>e.children??Vt),Z(m),Jr(m,y=>X(s,y),()=>S(s));var v=ie(m,2),b=te(v);return Vc(b,{get class(){return vr}}),Z(v),Z(f),$e(()=>{Yt(f,1,`relative ${r()??""}`),p.disabled=!S(i),Yt(m,1,`scrollbar-hide flex items-start gap-${n()??""} overflow-x-auto`),v.disabled=!S(a)}),Kr("click",p,o),Zn("scroll",m,u),Kr("click",v,l),G(t,f),st(h)}Hi(["click"]);var pPt=se(' '),gPt=se("

      "),mPt=se(" ",1),_Pt=se(" ");function m2(t,e){at(e,!0);let r=ce(e,"class",3,""),n=ce(e,"showTooltip",3,!0),i=Oe(void 0),a=Oe(!1);function s(){S(i)&&X(a,S(i).scrollWidth>S(i).clientWidth)}Kt(()=>{if(S(i)){s();const h=new ResizeObserver(s);return h.observe(S(i)),()=>h.disconnect()}});var o=Ae(),l=oe(o);{var u=h=>{var f=Ae(),p=oe(f);Me(p,()=>po,(g,m)=>{m(g,{children:(_,v)=>{var b=mPt(),y=oe(b);Me(y,()=>fo,(T,C)=>{C(T,{get class(){return`${r()??""} min-w-0`},children:(w,x)=>{var A=pPt(),R=te(A,!0);Z(A),Jr(A,O=>X(i,O),()=>S(i)),$e(()=>it(R,e.text)),G(w,A)},$$slots:{default:!0}})});var E=ie(y,2);Me(E,()=>ho,(T,C)=>{C(T,{class:"z-[9999]",children:(w,x)=>{var A=gPt(),R=te(A,!0);Z(A),$e(()=>it(R,e.text)),G(w,A)},$$slots:{default:!0}})}),G(_,b)},$$slots:{default:!0}})}),G(h,f)},d=h=>{var f=_Pt(),p=te(f,!0);Z(f),Jr(f,g=>X(i,g),()=>S(i)),$e(()=>{Yt(f,1,`${r()??""} block min-w-0 truncate`),it(p,e.text)}),G(h,f)};ve(l,h=>{S(a)&&n()?h(u):h(d,-1)})}G(t,o),st()}var vPt=se("⌘"),yPt=se(""),bPt=se(" ",1),SPt=se("");function yMe(t,e){at(e,!0);let r=ce(e,"class",3,""),n=ce(e,"variant",3,"default"),i=W(()=>n()==="destructive"?"text-destructive":"text-muted-foreground");var a=SPt();qr(a,21,()=>e.keys,Vl,(s,o,l)=>{var u=bPt(),d=oe(u);{var h=_=>{{let v=W(()=>n()==="destructive"?"text-destructive":"");Wyt(_,{get class(){return`h-1 w-1 ${S(v)??""} -mr-1`}})}},f=_=>{var v=vPt();$e(()=>Yt(v,1,dn(n()==="destructive"?"text-destructive":""))),G(_,v)},p=_=>{var v=or();$e(b=>it(v,b),[()=>S(o).toUpperCase()]),G(_,v)};ve(d,_=>{S(o)==="shift"?_(h):S(o)==="cmd"?_(f,1):_(p,-1)})}var g=ie(d,2);{var m=_=>{var v=yPt();G(_,v)};ve(g,_=>{lYt(a,1,`px-1 pointer-events-none inline-flex select-none items-center gap-0.5 font-sans text-md font-medium opacity-0 transition-opacity -my-1 ${S(i)??""} ${r()??""}`)),G(t,a),st()}var EPt=se('
      ');function TPt(t,e){at(e,!0);let r=ce(e,"disabled",3,!1);const n=W(()=>e.language?.toLowerCase()===mi.HTML);var i=EPt(),a=te(i);{let l=W(()=>!r()),u=W(()=>r()?"Code incomplete":"Copy code");j_(a,{get text(){return e.code},get canCopy(){return S(l)},get ariaLabel(){return S(u)}})}var s=ie(a,2);{var o=l=>{{let u=W(()=>r()?"Code incomplete":"Preview code");va(l,{get icon(){return Fle},get tooltip(){return S(u)},get disabled(){return r()},onclick:()=>e.onPreview(e.code,e.language)})}};ve(s,l=>{S(n)&&l(o)})}Z(i),G(t,i),st()}const CPt=` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +`;var wPt=se("
      ");function xPt(t,e){let r=ce(e,"class",3,""),n=ce(e,"style",3,"");var i=wPt();D_(i,()=>CPt,!0),Z(i),$e(()=>{Yt(i,1,dn(r()),"svelte-2vbth6"),zs(i,n())}),G(t,i)}var APt=se(''),RPt=se('
      '),NPt=se(""),OPt=se('
      ');function IPt(t,e){at(e,!0);function r(s){const o=s.split(".");return o.length>1?o.pop()?.toUpperCase()??"":""}var n=Ae(),i=oe(n);{var a=s=>{var o=OPt(),l=te(o);Zce(l,{class:"max-w-full",children:(u,d)=>{var h=Ae(),f=oe(h);qr(f,19,()=>e.items,p=>p.id,(p,g,m)=>{var _=NPt(),v=te(_);{var b=E=>{var T=APt();$e(()=>{lr(T,"src",S(g).preview),lr(T,"alt",S(g).name)}),G(E,T)},y=E=>{var T=RPt(),C=te(T);{var w=F=>{HU(F,{get class(){return`${vr} text-white/70`}})},x=F=>{y4(F,{get class(){return`${vr} text-white/70`}})},A=F=>{sp(F,{get class(){return`${vr} text-white/70`}})};ve(C,F=>{S(g).isAudio?F(w):S(g).isVideo?F(x,1):F(A,-1)})}var R=ie(C,2),O=te(R,!0);Z(R),Z(T),$e(F=>it(O,F),[()=>r(S(g).name)]),G(E,T)};ve(v,E=>{S(g).isImage&&S(g).preview?E(b):E(y,-1)})}Z(_),$e(()=>{lr(_,"data-thumbnail-index",S(m)),Yt(_,1,dn(["relative flex-shrink-0 cursor-pointer overflow-hidden rounded border-2 bg-black/80 backdrop-blur-sm transition-all hover:opacity-90",S(m)===e.currentIndex?"border-white":"border-transparent opacity-60","[&:not(:first-child)]:last:mr-4 [&:not(:last-child)]:first:ml-4"])),lr(_,"aria-label",`Go to ${S(g).name}`)}),Kr("click",_,()=>e.onNavigate(S(m))),G(p,_)}),G(u,h)},$$slots:{default:!0}}),Z(o),G(s,o)};ve(i,s=>{e.items.length>1&&s(a)})}G(t,n),st()}Hi(["click"]);var kPt=se(''),DPt=se('

      Audio preview not available

      '),MPt=se('

      ');function LPt(t,e){at(e,!0);var r=MPt(),n=te(r),i=te(n);HU(i,{class:"mx-auto mb-4 h-16 w-16 text-white/50"});var a=ie(i,2);{var s=d=>{var h=kPt();$e(()=>lr(h,"src",e.audioSrc)),G(d,h)},o=d=>{var h=DPt();G(d,h)};ve(a,d=>{e.audioSrc?d(s):d(o,-1)})}var l=ie(a,2),u=te(l,!0);Z(l),Z(n),Z(r),$e(()=>it(u,e.currentItem?.name||"Audio")),G(t,r),st()}var PPt=se('
      ');function FPt(t,e){at(e,!0);var r=Ae(),n=oe(r);{var i=a=>{var s=PPt(),o=te(s);Z(s),$e(()=>{lr(o,"src",e.displayPreview),lr(o,"alt",e.currentItem?.name||"preview")}),G(a,s)};ve(n,a=>{e.displayPreview&&a(i)})}G(t,r),st()}const BPt=T8({base:"relative grid w-full grid-cols-[0_1fr] items-start gap-y-0.5 rounded-lg border px-4 py-3 text-sm has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] has-[>svg]:gap-x-3 [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current",defaultVariants:{variant:"default"},variants:{variant:{default:"bg-card text-card-foreground",destructive:"text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current"}}});var UPt=new Set(["$$slots","$$events","$$legacy","children","class","ref","variant"]),$Pt=se("
      ");function bMe(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=ce(e,"variant",3,"default"),i=Tt(e,UPt);var a=$Pt();Er(a,o=>({"data-slot":"alert",class:o,...i,role:"alert"}),[()=>jr(BPt({variant:n()}),e.class)]);var s=te(a);Pt(s,()=>e.children??Vt),Z(a),Jr(a,o=>r(o),()=>r()),G(t,a),st()}var GPt=new Set(["$$slots","$$events","$$legacy","children","class","ref"]),zPt=se("
      ");function SMe(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,GPt);var i=zPt();Er(i,s=>({"data-slot":"alert-description",class:s,...n}),[()=>jr("col-start-2 grid justify-items-start gap-1 text-sm text-muted-foreground [&_p]:leading-relaxed",e.class)]);var a=te(i);Pt(a,()=>e.children??Vt),Z(i),Jr(i,s=>r(s),()=>r()),G(t,i),st()}var qPt=new Set(["$$slots","$$events","$$legacy","children","class","ref"]),HPt=se("
      ");function EMe(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,qPt);var i=HPt();Er(i,s=>({"data-slot":"alert-title",class:s,...n}),[()=>jr("col-start-2 line-clamp-1 min-h-4 font-medium tracking-tight",e.class)]);var a=te(i);Pt(a,()=>e.children??Vt),Z(i),Jr(i,s=>r(s),()=>r()),G(t,i),st()}class VPt{mediaRecorder=null;audioChunks=[];stream=null;recordingState=!1;async startRecording(){try{this.stream=await navigator.mediaDevices.getUserMedia({audio:{autoGainControl:!0,echoCancellation:!0,noiseSuppression:!0}}),this.initializeRecorder(this.stream),this.audioChunks=[],this.mediaRecorder.start(100),this.recordingState=!0}catch(e){throw console.error("Failed to start recording:",e),new Error("Failed to access microphone. Please check permissions.")}}async stopRecording(){return new Promise((e,r)=>{const n=this.mediaRecorder,i=this.audioChunks,a=this.stream;if(!n||n.state==="inactive"){r(new Error("No active recording to stop"));return}this.mediaRecorder=null,this.audioChunks=[],this.stream=null,this.recordingState=!1,n.onstop=()=>{const s=new Blob(i,{type:n.mimeType||Ua.WAV});if(a)for(const o of a.getTracks())o.stop();e(s)},n.onerror=s=>{if(console.error("Recording error:",s),a)for(const o of a.getTracks())o.stop();r(new Error("Recording failed"))},n.stop()})}isRecording(){return this.recordingState}cancelRecording(){const e=this.mediaRecorder,r=this.stream;if(this.mediaRecorder=null,this.audioChunks=[],this.stream=null,this.recordingState=!1,e&&e.state!=="inactive"&&(e.onstop=null,e.onerror=null,e.stop()),r)for(const n of r.getTracks())n.stop()}initializeRecorder(e){const r={};MediaRecorder.isTypeSupported(Ua.WAV)?r.mimeType=Ua.WAV:MediaRecorder.isTypeSupported(Ua.WEBM_OPUS)?r.mimeType=Ua.WEBM_OPUS:MediaRecorder.isTypeSupported(Ua.WEBM)?r.mimeType=Ua.WEBM:MediaRecorder.isTypeSupported(Ua.MP4)?r.mimeType=Ua.MP4:console.warn("No preferred audio format supported, using default"),this.mediaRecorder=new MediaRecorder(e,r),this.mediaRecorder.ondataavailable=n=>{n.data.size>0&&this.audioChunks.push(n.data)},this.mediaRecorder.onstop=()=>{this.recordingState=!1},this.mediaRecorder.onerror=n=>{console.error("MediaRecorder error:",n),this.recordingState=!1}}}async function YPt(t){try{if(t.type.includes("wav"))return t;const e=await t.arrayBuffer(),r=new(window.AudioContext||window.webkitAudioContext);try{const n=await r.decodeAudioData(e);return WPt(n)}finally{r.close()}}catch(e){return console.error("Failed to convert audio to WAV:",e),t}}function WPt(t){const e=t.length,r=t.numberOfChannels,n=t.sampleRate,a=r*2,s=n*a,o=e*a,l=44+o,u=new ArrayBuffer(l),d=new DataView(u),h=(m,_)=>{for(let v=0;v<_.length;v++)d.setUint8(m+v,_.charCodeAt(v))};h(0,"RIFF"),d.setUint32(4,l-8,!0),h(8,"WAVE"),h(12,"fmt "),d.setUint32(16,16,!0),d.setUint16(20,1,!0),d.setUint16(22,r,!0),d.setUint32(24,n,!0),d.setUint32(28,s,!0),d.setUint16(32,a,!0),d.setUint16(34,16,!0),h(36,"data"),d.setUint32(40,o,!0);const f=new Array(r);for(let m=0;m1?v=1:v<-1&&(v=-1),p[g++]=v*32767}return new Blob([u],{type:Ua.WAV})}function KPt(t,e){const r=new Date().toISOString().replace(/[:.]/g,"-"),n=t.type.includes("wav")?"wav":"mp3",i=`recording-${r}.${n}`;return new File([t],i,{lastModified:Date.now(),type:t.type})}function jPt(){return!!(typeof navigator<"u"&&navigator.mediaDevices&&typeof navigator.mediaDevices.getUserMedia=="function"&&typeof window<"u"&&window.MediaRecorder)}const pu=typeof process=="object"&&process+""=="[object process]"&&!process.versions.nw&&!(process.versions.electron&&process.type&&process.type!=="browser"),Bee=[.001,0,0,.001,0,0],PK=1.35,Wd={ANY:1,DISPLAY:2,PRINT:4,ANNOTATIONS_FORMS:16,ANNOTATIONS_STORAGE:32,ANNOTATIONS_DISABLE:64,IS_EDITING:128,OPLIST:256},p_={DISABLE:0,ENABLE:1,ENABLE_FORMS:2,ENABLE_STORAGE:3},TMe="pdfjs_internal_editor_",Ii={DISABLE:-1,NONE:0,FREETEXT:3,HIGHLIGHT:9,STAMP:13,INK:15,SIGNATURE:101,COMMENT:102},_a={RESIZE:1,CREATE:2,FREETEXT_SIZE:11,FREETEXT_COLOR:12,FREETEXT_OPACITY:13,INK_COLOR:21,INK_THICKNESS:22,INK_OPACITY:23,HIGHLIGHT_COLOR:31,HIGHLIGHT_THICKNESS:32,HIGHLIGHT_FREE:33,HIGHLIGHT_SHOW_ALL:34,DRAW_STEP:41},XPt={PRINT:4,MODIFY_CONTENTS:8,COPY:16,MODIFY_ANNOTATIONS:32,FILL_INTERACTIVE_FORMS:256,COPY_FOR_ACCESSIBILITY:512,ASSEMBLE:1024,PRINT_HIGH_QUALITY:2048},Fc={FILL:0,STROKE:1,FILL_STROKE:2,INVISIBLE:3,FILL_STROKE_MASK:3,ADD_TO_PATH_FLAG:4},FD={GRAYSCALE_1BPP:1,RGB_24BPP:2,RGBA_32BPP:3},qo={TEXT:1,LINK:2,FREETEXT:3,LINE:4,SQUARE:5,CIRCLE:6,POLYGON:7,POLYLINE:8,HIGHLIGHT:9,UNDERLINE:10,SQUIGGLY:11,STRIKEOUT:12,STAMP:13,CARET:14,INK:15,POPUP:16,FILEATTACHMENT:17,SOUND:18,MOVIE:19,WIDGET:20,SCREEN:21,PRINTERMARK:22,TRAPNET:23,WATERMARK:24,THREED:25,REDACT:26},DE={SOLID:1,DASHED:2,BEVELED:3,INSET:4,UNDERLINE:5},h$={ERRORS:0,WARNINGS:1,INFOS:5},EP={dependency:1,setLineWidth:2,setLineCap:3,setLineJoin:4,setMiterLimit:5,setDash:6,setRenderingIntent:7,setFlatness:8,setGState:9,save:10,restore:11,transform:12,moveTo:13,lineTo:14,curveTo:15,curveTo2:16,curveTo3:17,closePath:18,rectangle:19,stroke:20,closeStroke:21,fill:22,eoFill:23,fillStroke:24,eoFillStroke:25,closeFillStroke:26,closeEOFillStroke:27,endPath:28,clip:29,eoClip:30,beginText:31,endText:32,setCharSpacing:33,setWordSpacing:34,setHScale:35,setLeading:36,setFont:37,setTextRenderingMode:38,setTextRise:39,moveText:40,setLeadingMoveText:41,setTextMatrix:42,nextLine:43,showText:44,showSpacedText:45,nextLineShowText:46,nextLineSetSpacingShowText:47,setCharWidth:48,setCharWidthAndBounds:49,setStrokeColorSpace:50,setFillColorSpace:51,setStrokeColor:52,setStrokeColorN:53,setFillColor:54,setFillColorN:55,setStrokeGray:56,setFillGray:57,setStrokeRGBColor:58,setFillRGBColor:59,setStrokeCMYKColor:60,setFillCMYKColor:61,shadingFill:62,beginInlineImage:63,beginImageData:64,endInlineImage:65,paintXObject:66,markPoint:67,markPointProps:68,beginMarkedContent:69,beginMarkedContentProps:70,endMarkedContent:71,beginCompat:72,endCompat:73,paintFormXObjectBegin:74,paintFormXObjectEnd:75,beginGroup:76,endGroup:77,beginAnnotation:80,endAnnotation:81,paintImageMaskXObject:83,paintImageMaskXObjectGroup:84,paintImageXObject:85,paintInlineImageXObject:86,paintInlineImageXObjectGroup:87,paintImageXObjectRepeat:88,paintImageMaskXObjectRepeat:89,paintSolidColorImageMask:90,constructPath:91,setStrokeTransparent:92,setFillTransparent:93,rawFillPath:94},zI={moveTo:0,lineTo:1,curveTo:2,closePath:3},QPt={NEED_PASSWORD:1,INCORRECT_PASSWORD:2};let f$=h$.WARNINGS;function ZPt(t){Number.isInteger(t)&&(f$=t)}function JPt(){return f$}function p$(t){f$>=h$.INFOS&&console.log(`Info: ${t}`)}function ki(t){f$>=h$.WARNINGS&&console.log(`Warning: ${t}`)}function as(t){throw new Error(t)}function Xo(t,e){t||as(e)}function eFt(t){switch(t?.protocol){case"http:":case"https:":case"ftp:":case"mailto:":case"tel:":return!0;default:return!1}}function CMe(t,e=null,r=null){if(!t)return null;if(r&&typeof t=="string"&&(r.addDefaultProtocol&&t.startsWith("www.")&&t.match(/\./g)?.length>=2&&(t=`http://${t}`),r.tryConvertEncoding))try{t=aFt(t)}catch{}const n=e?URL.parse(t,e):URL.parse(t);return eFt(n)?n:null}function wMe(t,e,r=!1){const n=URL.parse(t);return n?(n.hash=e,n.href):r&&CMe(t,"http://example.com")?t.split("#",1)[0]+`${e?`#${e}`:""}`:""}function na(t,e,r,n=!1){return Object.defineProperty(t,e,{value:r,enumerable:!n,configurable:!0,writable:!1}),r}const J2=(function(){function e(r,n){this.message=r,this.name=n}return e.prototype=new Error,e.constructor=e,e})();class QEe extends J2{constructor(e,r){super(e,"PasswordException"),this.code=r}}class FK extends J2{constructor(e,r){super(e,"UnknownErrorException"),this.details=r}}class Uee extends J2{constructor(e){super(e,"InvalidPDFException")}}class TP extends J2{constructor(e,r,n){super(e,"ResponseException"),this.status=r,this.missing=n}}class tFt extends J2{constructor(e){super(e,"FormatError")}}class Q_ extends J2{constructor(e){super(e,"AbortException")}}function xMe(t){(typeof t!="object"||t?.length===void 0)&&as("Invalid argument for bytesToString");const e=t.length,r=8192;if(e>24&255,t>>16&255,t>>8&255,t&255)}function nFt(){const t=new Uint8Array(4);return t[0]=1,new Uint32Array(t.buffer,0,1)[0]===1}function iFt(){try{return new Function(""),!0}catch{return!1}}class Sc{static get isLittleEndian(){return na(this,"isLittleEndian",nFt())}static get isEvalSupported(){return na(this,"isEvalSupported",iFt())}static get isOffscreenCanvasSupported(){return na(this,"isOffscreenCanvasSupported",typeof OffscreenCanvas<"u")}static get isImageDecoderSupported(){return na(this,"isImageDecoderSupported",typeof ImageDecoder<"u")}static get platform(){const{platform:e,userAgent:r}=navigator;return na(this,"platform",{isAndroid:r.includes("Android"),isLinux:e.includes("Linux"),isMac:e.includes("Mac"),isWindows:e.includes("Win"),isFirefox:r.includes("Firefox")})}static get isCSSRoundSupported(){return na(this,"isCSSRoundSupported",globalThis.CSS?.supports?.("width: round(1.5px, 1px)"))}}const BK=Array.from(Array(256).keys(),t=>t.toString(16).padStart(2,"0"));class Xn{static makeHexColor(e,r,n){return`#${BK[e]}${BK[r]}${BK[n]}`}static scaleMinMax(e,r){let n;e[0]?(e[0]<0&&(n=r[0],r[0]=r[2],r[2]=n),r[0]*=e[0],r[2]*=e[0],e[3]<0&&(n=r[1],r[1]=r[3],r[3]=n),r[1]*=e[3],r[3]*=e[3]):(n=r[0],r[0]=r[1],r[1]=n,n=r[2],r[2]=r[3],r[3]=n,e[1]<0&&(n=r[1],r[1]=r[3],r[3]=n),r[1]*=e[1],r[3]*=e[1],e[2]<0&&(n=r[0],r[0]=r[2],r[2]=n),r[0]*=e[2],r[2]*=e[2]),r[0]+=e[4],r[1]+=e[5],r[2]+=e[4],r[3]+=e[5]}static transform(e,r){return[e[0]*r[0]+e[2]*r[1],e[1]*r[0]+e[3]*r[1],e[0]*r[2]+e[2]*r[3],e[1]*r[2]+e[3]*r[3],e[0]*r[4]+e[2]*r[5]+e[4],e[1]*r[4]+e[3]*r[5]+e[5]]}static applyTransform(e,r,n=0){const i=e[n],a=e[n+1];e[n]=i*r[0]+a*r[2]+r[4],e[n+1]=i*r[1]+a*r[3]+r[5]}static applyTransformToBezier(e,r,n=0){const i=r[0],a=r[1],s=r[2],o=r[3],l=r[4],u=r[5];for(let d=0;d<6;d+=2){const h=e[n+d],f=e[n+d+1];e[n+d]=h*i+f*s+l,e[n+d+1]=h*a+f*o+u}}static applyInverseTransform(e,r){const n=e[0],i=e[1],a=r[0]*r[3]-r[1]*r[2];e[0]=(n*r[3]-i*r[2]+r[2]*r[5]-r[4]*r[3])/a,e[1]=(-n*r[1]+i*r[0]+r[4]*r[1]-r[5]*r[0])/a}static axialAlignedBoundingBox(e,r,n){const i=r[0],a=r[1],s=r[2],o=r[3],l=r[4],u=r[5],d=e[0],h=e[1],f=e[2],p=e[3];let g=i*d+l,m=g,_=i*f+l,v=_,b=o*h+u,y=b,E=o*p+u,T=E;if(a!==0||s!==0){const C=a*d,w=a*f,x=s*h,A=s*p;g+=x,v+=x,_+=A,m+=A,b+=C,T+=C,E+=w,y+=w}n[0]=Math.min(n[0],g,_,m,v),n[1]=Math.min(n[1],b,E,y,T),n[2]=Math.max(n[2],g,_,m,v),n[3]=Math.max(n[3],b,E,y,T)}static inverseTransform(e){const r=e[0]*e[3]-e[1]*e[2];return[e[3]/r,-e[1]/r,-e[2]/r,e[0]/r,(e[2]*e[5]-e[4]*e[3])/r,(e[4]*e[1]-e[5]*e[0])/r]}static singularValueDecompose2dScale(e,r){const n=e[0],i=e[1],a=e[2],s=e[3],o=n**2+i**2,l=n*a+i*s,u=a**2+s**2,d=(o+u)/2,h=Math.sqrt(d**2-(o*u-l**2));r[0]=Math.sqrt(d+h||1),r[1]=Math.sqrt(d-h||1)}static normalizeRect(e){const r=e.slice(0);return e[0]>e[2]&&(r[0]=e[2],r[2]=e[0]),e[1]>e[3]&&(r[1]=e[3],r[3]=e[1]),r}static intersect(e,r){const n=Math.max(Math.min(e[0],e[2]),Math.min(r[0],r[2])),i=Math.min(Math.max(e[0],e[2]),Math.max(r[0],r[2]));if(n>i)return null;const a=Math.max(Math.min(e[1],e[3]),Math.min(r[1],r[3])),s=Math.min(Math.max(e[1],e[3]),Math.max(r[1],r[3]));return a>s?null:[n,a,i,s]}static pointBoundingBox(e,r,n){n[0]=Math.min(n[0],e),n[1]=Math.min(n[1],r),n[2]=Math.max(n[2],e),n[3]=Math.max(n[3],r)}static rectBoundingBox(e,r,n,i,a){a[0]=Math.min(a[0],e,n),a[1]=Math.min(a[1],r,i),a[2]=Math.max(a[2],e,n),a[3]=Math.max(a[3],r,i)}static#e(e,r,n,i,a,s,o,l,u,d){if(u<=0||u>=1)return;const h=1-u,f=u*u,p=f*u,g=h*(h*(h*e+3*u*r)+3*f*n)+p*i,m=h*(h*(h*a+3*u*s)+3*f*o)+p*l;d[0]=Math.min(d[0],g),d[1]=Math.min(d[1],m),d[2]=Math.max(d[2],g),d[3]=Math.max(d[3],m)}static#t(e,r,n,i,a,s,o,l,u,d,h,f){if(Math.abs(u)<1e-12){Math.abs(d)>=1e-12&&this.#e(e,r,n,i,a,s,o,l,-h/d,f);return}const p=d**2-4*h*u;if(p<0)return;const g=Math.sqrt(p),m=2*u;this.#e(e,r,n,i,a,s,o,l,(-d+g)/m,f),this.#e(e,r,n,i,a,s,o,l,(-d-g)/m,f)}static bezierBoundingBox(e,r,n,i,a,s,o,l,u){u[0]=Math.min(u[0],e,o),u[1]=Math.min(u[1],r,l),u[2]=Math.max(u[2],e,o),u[3]=Math.max(u[3],r,l),this.#t(e,n,a,o,r,i,s,l,3*(-e+3*(n-a)+o),6*(e-2*n+a),3*(n-e),u),this.#t(e,n,a,o,r,i,s,l,3*(-r+3*(i-s)+l),6*(r-2*i+s),3*(i-r),u)}}function aFt(t){return decodeURIComponent(escape(t))}let UK=null,ZEe=null;function sFt(t){return UK||(UK=/([\u00a0\u00b5\u037e\u0eb3\u2000-\u200a\u202f\u2126\ufb00-\ufb04\ufb06\ufb20-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufba1\ufba4-\ufba9\ufbae-\ufbb1\ufbd3-\ufbdc\ufbde-\ufbe7\ufbea-\ufbf8\ufbfc-\ufbfd\ufc00-\ufc5d\ufc64-\ufcf1\ufcf5-\ufd3d\ufd88\ufdf4\ufdfa-\ufdfb\ufe71\ufe77\ufe79\ufe7b\ufe7d]+)|(\ufb05+)/gu,ZEe=new Map([["ſt","ſt"]])),t.replaceAll(UK,(e,r,n)=>r?r.normalize("NFKC"):ZEe.get(n))}function AMe(){if(typeof crypto.randomUUID=="function")return crypto.randomUUID();const t=new Uint8Array(32);return crypto.getRandomValues(t),xMe(t)}const Jce="pdfjs_internal_id_";function oFt(t,e,r){if(!Array.isArray(r)||r.length<2)return!1;const[n,i,...a]=r;if(!t(n)&&!Number.isInteger(n)||!e(i))return!1;const s=a.length;let o=!0;switch(i.name){case"XYZ":if(s<2||s>3)return!1;break;case"Fit":case"FitB":return s===0;case"FitH":case"FitBH":case"FitV":case"FitBV":if(s>1)return!1;break;case"FitR":if(s!==4)return!1;o=!1;break;default:return!1}for(const l of a)if(!(typeof l=="number"||o&&l===null))return!1;return!0}function gu(t,e,r){return Math.min(Math.max(t,e),r)}function RMe(t){return Uint8Array.prototype.toBase64?t.toBase64():btoa(xMe(t))}function lFt(t){return Uint8Array.fromBase64?Uint8Array.fromBase64(t):K8(atob(t))}typeof Promise.try!="function"&&(Promise.try=function(t,...e){return new Promise(r=>{r(t(...e))})});typeof Math.sumPrecise!="function"&&(Math.sumPrecise=function(t){return t.reduce((e,r)=>e+r,0)});const Hm="http://www.w3.org/2000/svg";class fx{static CSS=96;static PDF=72;static PDF_TO_CSS_UNITS=this.CSS/this.PDF}async function j8(t,e="text"){if(z6(t,document.baseURI)){const r=await fetch(t);if(!r.ok)throw new Error(r.statusText);switch(e){case"arraybuffer":return r.arrayBuffer();case"blob":return r.blob();case"json":return r.json()}return r.text()}return new Promise((r,n)=>{const i=new XMLHttpRequest;i.open("GET",t,!0),i.responseType=e,i.onreadystatechange=()=>{if(i.readyState===XMLHttpRequest.DONE){if(i.status===200||i.status===0){switch(e){case"arraybuffer":case"blob":case"json":r(i.response);return}r(i.responseText);return}n(new Error(i.statusText))}},i.send(null)})}class X8{constructor({viewBox:e,userUnit:r,scale:n,rotation:i,offsetX:a=0,offsetY:s=0,dontFlip:o=!1}){this.viewBox=e,this.userUnit=r,this.scale=n,this.rotation=i,this.offsetX=a,this.offsetY=s,n*=r;const l=(e[2]+e[0])/2,u=(e[3]+e[1])/2;let d,h,f,p;switch(i%=360,i<0&&(i+=360),i){case 180:d=-1,h=0,f=0,p=1;break;case 90:d=0,h=1,f=1,p=0;break;case 270:d=0,h=-1,f=-1,p=0;break;case 0:d=1,h=0,f=0,p=-1;break;default:throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.")}o&&(f=-f,p=-p);let g,m,_,v;d===0?(g=Math.abs(u-e[1])*n+a,m=Math.abs(l-e[0])*n+s,_=(e[3]-e[1])*n,v=(e[2]-e[0])*n):(g=Math.abs(l-e[0])*n+a,m=Math.abs(u-e[1])*n+s,_=(e[2]-e[0])*n,v=(e[3]-e[1])*n),this.transform=[d*n,h*n,f*n,p*n,g-d*n*l-f*n*u,m-h*n*l-p*n*u],this.width=_,this.height=v}get rawDims(){const e=this.viewBox;return na(this,"rawDims",{pageWidth:e[2]-e[0],pageHeight:e[3]-e[1],pageX:e[0],pageY:e[1]})}clone({scale:e=this.scale,rotation:r=this.rotation,offsetX:n=this.offsetX,offsetY:i=this.offsetY,dontFlip:a=!1}={}){return new X8({viewBox:this.viewBox.slice(),userUnit:this.userUnit,scale:e,rotation:r,offsetX:n,offsetY:i,dontFlip:a})}convertToViewportPoint(e,r){const n=[e,r];return Xn.applyTransform(n,this.transform),n}convertToViewportRectangle(e){const r=[e[0],e[1]];Xn.applyTransform(r,this.transform);const n=[e[2],e[3]];return Xn.applyTransform(n,this.transform),[r[0],r[1],n[0],n[1]]}convertToPdfPoint(e,r){const n=[e,r];return Xn.applyInverseTransform(n,this.transform),n}}class eue extends J2{constructor(e,r=0){super(e,"RenderingCancelledException"),this.extraDelay=r}}function g$(t){const e=t.length;let r=0;for(;r{try{return new URL(o)}catch{try{return new URL(decodeURIComponent(o))}catch{try{return new URL(o,"https://foo.bar")}catch{try{return new URL(decodeURIComponent(o),"https://foo.bar")}catch{return null}}}}})(t);if(!n)return e;const i=o=>{try{let l=decodeURIComponent(o);return l.includes("/")?(l=l.split("/").at(-1),l.test(/^\.pdf$/i)?l:o):l}catch{return o}},a=/\.pdf$/i,s=n.pathname.split("/").at(-1);if(a.test(s))return i(s);if(n.searchParams.size>0){const o=Array.from(n.searchParams.values()).reverse();for(const u of o)if(a.test(u))return i(u);const l=Array.from(n.searchParams.keys()).reverse();for(const u of l)if(a.test(u))return i(u)}if(n.hash){const l=/[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i.exec(n.hash);if(l)return i(l[0])}return e}class JEe{started=Object.create(null);times=[];time(e){e in this.started&&ki(`Timer is already running for ${e}`),this.started[e]=Date.now()}timeEnd(e){e in this.started||ki(`Timer has not been started for ${e}`),this.times.push({name:e,start:this.started[e],end:Date.now()}),delete this.started[e]}toString(){const e=[];let r=0;for(const{name:n}of this.times)r=Math.max(n.length,r);for(const{name:n,start:i,end:a}of this.times)e.push(`${n.padEnd(r)} ${a-i}ms +`);return e.join("")}}function z6(t,e){const r=e?URL.parse(t,e):URL.parse(t);return r?.protocol==="http:"||r?.protocol==="https:"}function yf(t){t.preventDefault()}function Wo(t){t.preventDefault(),t.stopPropagation()}function dFt(t){console.log("Deprecated API usage: "+t)}class $ee{static#e;static toDateObject(e){if(e instanceof Date)return e;if(!e||typeof e!="string")return null;this.#e||=new RegExp("^D:(\\d{4})(\\d{2})?(\\d{2})?(\\d{2})?(\\d{2})?(\\d{2})?([Z|+|-])?(\\d{2})?'?(\\d{2})?'?");const r=this.#e.exec(e);if(!r)return null;const n=parseInt(r[1],10);let i=parseInt(r[2],10);i=i>=1&&i<=12?i-1:0;let a=parseInt(r[3],10);a=a>=1&&a<=31?a:1;let s=parseInt(r[4],10);s=s>=0&&s<=23?s:0;let o=parseInt(r[5],10);o=o>=0&&o<=59?o:0;let l=parseInt(r[6],10);l=l>=0&&l<=59?l:0;const u=r[7]||"Z";let d=parseInt(r[8],10);d=d>=0&&d<=23?d:0;let h=parseInt(r[9],10)||0;return h=h>=0&&h<=59?h:0,u==="-"?(s+=d,o+=h):u==="+"&&(s-=d,o-=h),new Date(Date.UTC(n,i,a,s,o,l))}}function hFt(t,{scale:e=1,rotation:r=0}){const{width:n,height:i}=t.attributes.style,a=[0,0,parseInt(n),parseInt(i)];return new X8({viewBox:a,userUnit:1,scale:e,rotation:r})}function m$(t){if(t.startsWith("#")){const e=parseInt(t.slice(1),16);return[(e&16711680)>>16,(e&65280)>>8,e&255]}return t.startsWith("rgb(")?t.slice(4,-1).split(",").map(e=>parseInt(e)):t.startsWith("rgba(")?t.slice(5,-1).split(",").map(e=>parseInt(e)).slice(0,3):(ki(`Not a valid color format: "${t}"`),[0,0,0])}function fFt(t){const e=document.createElement("span");e.style.visibility="hidden",e.style.colorScheme="only light",document.body.append(e);for(const r of t.keys()){e.style.color=r;const n=window.getComputedStyle(e).color;t.set(r,m$(n))}e.remove()}function to(t){const{a:e,b:r,c:n,d:i,e:a,f:s}=t.getTransform();return[e,r,n,i,a,s]}function Wp(t){const{a:e,b:r,c:n,d:i,e:a,f:s}=t.getTransform().invertSelf();return[e,r,n,i,a,s]}function _2(t,e,r=!1,n=!0){if(e instanceof X8){const{pageWidth:i,pageHeight:a}=e.rawDims,{style:s}=t,o=Sc.isCSSRoundSupported,l=`var(--total-scale-factor) * ${i}px`,u=`var(--total-scale-factor) * ${a}px`,d=o?`round(down, ${l}, var(--scale-round-x))`:`calc(${l})`,h=o?`round(down, ${u}, var(--scale-round-y))`:`calc(${u})`;!r||e.rotation%180===0?(s.width=d,s.height=h):(s.width=h,s.height=d)}n&&t.setAttribute("data-main-rotation",e.rotation)}class Qg{constructor(){const{pixelRatio:e}=Qg;this.sx=e,this.sy=e}get scaled(){return this.sx!==1||this.sy!==1}get symmetric(){return this.sx===this.sy}limitCanvas(e,r,n,i,a=-1){let s=1/0,o=1/0,l=1/0;n=Qg.capPixels(n,a),n>0&&(s=Math.sqrt(n/(e*r))),i!==-1&&(o=i/e,l=i/r);const u=Math.min(s,o,l);return this.sx>u||this.sy>u?(this.sx=u,this.sy=u,!0):!1}static get pixelRatio(){return globalThis.devicePixelRatio||1}static capPixels(e,r){if(r>=0){const n=Math.ceil(window.screen.availWidth*window.screen.availHeight*this.pixelRatio**2*(1+r/100));return e>0?Math.min(e,n):n}return e}}const Gee=["image/apng","image/avif","image/bmp","image/gif","image/jpeg","image/png","image/svg+xml","image/webp","image/x-icon"];class $9{#e=null;#t=null;#r;#n=null;#i=null;#a=null;#s=null;static#o=null;constructor(e){this.#r=e,$9.#o||=Object.freeze({freetext:"pdfjs-editor-remove-freetext-button",highlight:"pdfjs-editor-remove-highlight-button",ink:"pdfjs-editor-remove-ink-button",stamp:"pdfjs-editor-remove-stamp-button",signature:"pdfjs-editor-remove-signature-button"})}render(){const e=this.#e=document.createElement("div");e.classList.add("editToolbar","hidden"),e.setAttribute("role","toolbar");const r=this.#r._uiManager._signal;e.addEventListener("contextmenu",yf,{signal:r}),e.addEventListener("pointerdown",$9.#l,{signal:r});const n=this.#n=document.createElement("div");n.className="buttons",e.append(n);const i=this.#r.toolbarPosition;if(i){const{style:a}=e,s=this.#r._uiManager.direction==="ltr"?1-i[0]:i[0];a.insetInlineEnd=`${100*s}%`,a.top=`calc(${100*i[1]}% + var(--editor-toolbar-vert-offset))`}return e}get div(){return this.#e}static#l(e){e.stopPropagation()}#c(e){this.#r._focusEventsAllowed=!1,Wo(e)}#d(e){this.#r._focusEventsAllowed=!0,Wo(e)}#u(e){const r=this.#r._uiManager._signal;e.addEventListener("focusin",this.#c.bind(this),{capture:!0,signal:r}),e.addEventListener("focusout",this.#d.bind(this),{capture:!0,signal:r}),e.addEventListener("contextmenu",yf,{signal:r})}hide(){this.#e.classList.add("hidden"),this.#t?.hideDropdown()}show(){this.#e.classList.remove("hidden"),this.#i?.shown(),this.#a?.shown()}addDeleteButton(){const{editorType:e,_uiManager:r}=this.#r,n=document.createElement("button");n.className="delete",n.tabIndex=0,n.setAttribute("data-l10n-id",$9.#o[e]),this.#u(n),n.addEventListener("click",i=>{r.delete()},{signal:r._signal}),this.#n.append(n)}get#p(){const e=document.createElement("div");return e.className="divider",e}async addAltText(e){const r=await e.render();this.#u(r),this.#n.append(r,this.#p),this.#i=e}addComment(e){if(this.#a)return;const r=e.render();r&&(this.#u(r),this.#n.prepend(r,this.#p),this.#a=e,e.toolbar=this)}addColorPicker(e){if(this.#t)return;this.#t=e;const r=e.renderButton();this.#u(r),this.#n.append(r,this.#p)}async addEditSignatureButton(e){const r=this.#s=await e.renderEditButton(this.#r);this.#u(r),this.#n.append(r,this.#p)}async addButton(e,r){switch(e){case"colorPicker":this.addColorPicker(r);break;case"altText":await this.addAltText(r);break;case"editSignature":await this.addEditSignatureButton(r);break;case"delete":this.addDeleteButton();break;case"comment":this.addComment(r);break}}updateEditSignatureButton(e){this.#s&&(this.#s.title=e)}remove(){this.#e.remove(),this.#t?.destroy(),this.#t=null}}class pFt{#e=null;#t=null;#r;constructor(e){this.#r=e}#n(){const e=this.#t=document.createElement("div");e.className="editToolbar",e.setAttribute("role","toolbar"),e.addEventListener("contextmenu",yf,{signal:this.#r._signal});const r=this.#e=document.createElement("div");return r.className="buttons",e.append(r),this.#a(),e}#i(e,r){let n=0,i=0;for(const a of e){const s=a.y+a.height;if(sn){i=o,n=s;continue}r?o>i&&(i=o):o{this.#r.highlightSelection("floating_button")},{signal:n}),this.#e.append(e)}}function NMe(t,e,r){for(const n of r)e.addEventListener(n,t[n].bind(t))}class gFt{#e=0;get id(){return`${TMe}${this.#e++}`}}class rue{#e=AMe();#t=0;#r=null;static get _isSVGFittingCanvas(){const e='data:image/svg+xml;charset=UTF-8,',n=new OffscreenCanvas(1,3).getContext("2d",{willReadFrequently:!0}),i=new Image;i.src=e;const a=i.decode().then(()=>(n.drawImage(i,0,0,1,1,0,0,1,3),new Uint32Array(n.getImageData(0,0,1,1).data.buffer)[0]===0));return na(this,"_isSVGFittingCanvas",a)}async#n(e,r){this.#r||=new Map;let n=this.#r.get(e);if(n===null)return null;if(n?.bitmap)return n.refCounter+=1,n;try{n||={bitmap:null,id:`image_${this.#e}_${this.#t++}`,refCounter:0,isSvg:!1};let i;if(typeof r=="string"?(n.url=r,i=await j8(r,"blob")):r instanceof File?i=n.file=r:r instanceof Blob&&(i=r),i.type==="image/svg+xml"){const a=rue._isSVGFittingCanvas,s=new FileReader,o=new Image,l=new Promise((u,d)=>{o.onload=()=>{n.bitmap=o,n.isSvg=!0,u()},s.onload=async()=>{const h=n.svgUrl=s.result;o.src=await a?`${h}#svgView(preserveAspectRatio(none))`:h},o.onerror=s.onerror=d});s.readAsDataURL(i),await l}else n.bitmap=await createImageBitmap(i);n.refCounter=1}catch(i){ki(i),n=null}return this.#r.set(e,n),n&&this.#r.set(n.id,n),n}async getFromFile(e){const{lastModified:r,name:n,size:i,type:a}=e;return this.#n(`${r}_${n}_${i}_${a}`,e)}async getFromUrl(e){return this.#n(e,e)}async getFromBlob(e,r){const n=await r;return this.#n(e,n)}async getFromId(e){this.#r||=new Map;const r=this.#r.get(e);if(!r)return null;if(r.bitmap)return r.refCounter+=1,r;if(r.file)return this.getFromFile(r.file);if(r.blobPromise){const{blobPromise:n}=r;return delete r.blobPromise,this.getFromBlob(r.id,n)}return this.getFromUrl(r.url)}getFromCanvas(e,r){this.#r||=new Map;let n=this.#r.get(e);if(n?.bitmap)return n.refCounter+=1,n;const i=new OffscreenCanvas(r.width,r.height);return i.getContext("2d").drawImage(r,0,0),n={bitmap:i.transferToImageBitmap(),id:`image_${this.#e}_${this.#t++}`,refCounter:1,isSvg:!1},this.#r.set(e,n),this.#r.set(n.id,n),n}getSvgUrl(e){const r=this.#r.get(e);return r?.isSvg?r.svgUrl:null}deleteId(e){this.#r||=new Map;const r=this.#r.get(e);if(!r||(r.refCounter-=1,r.refCounter!==0))return;const{bitmap:n}=r;if(!r.url&&!r.file){const i=new OffscreenCanvas(n.width,n.height);i.getContext("bitmaprenderer").transferFromImageBitmap(n),r.blobPromise=i.convertToBlob()}n.close?.(),r.bitmap=null}isValidId(e){return e.startsWith(`image_${this.#e}_`)}}class mFt{#e=[];#t=!1;#r;#n=-1;constructor(e=128){this.#r=e}add({cmd:e,undo:r,post:n,mustExec:i,type:a=NaN,overwriteIfSameType:s=!1,keepUndo:o=!1}){if(i&&e(),this.#t)return;const l={cmd:e,undo:r,post:n,type:a};if(this.#n===-1){this.#e.length>0&&(this.#e.length=0),this.#n=0,this.#e.push(l);return}if(s&&this.#e[this.#n].type===a){o&&(l.undo=this.#e[this.#n].undo),this.#e[this.#n]=l;return}const u=this.#n+1;u===this.#r?this.#e.splice(0,1):(this.#n=u,u=0;r--)if(this.#e[r].type!==e){this.#e.splice(r+1,this.#n-r),this.#n=r;return}this.#e.length=0,this.#n=-1}}destroy(){this.#e=null}}class Q8{constructor(e){this.buffer=[],this.callbacks=new Map,this.allKeys=new Set;const{isMac:r}=Sc.platform;for(const[n,i,a={}]of e)for(const s of n){const o=s.startsWith("mac+");r&&o?(this.callbacks.set(s.slice(4),{callback:i,options:a}),this.allKeys.add(s.split("+").at(-1))):!r&&!o&&(this.callbacks.set(s,{callback:i,options:a}),this.allKeys.add(s.split("+").at(-1)))}}#e(e){e.altKey&&this.buffer.push("alt"),e.ctrlKey&&this.buffer.push("ctrl"),e.metaKey&&this.buffer.push("meta"),e.shiftKey&&this.buffer.push("shift"),this.buffer.push(e.key);const r=this.buffer.join("+");return this.buffer.length=0,r}exec(e,r){if(!this.allKeys.has(r.key))return;const n=this.callbacks.get(this.#e(r));if(!n)return;const{callback:i,options:{bubbles:a=!1,args:s=[],checker:o=null}}=n;o&&!o(e,r)||(i.bind(e,...s,r)(),a||Wo(r))}}class nue{static _colorsMapping=new Map([["CanvasText",[0,0,0]],["Canvas",[255,255,255]]]);get _colors(){const e=new Map([["CanvasText",null],["Canvas",null]]);return fFt(e),na(this,"_colors",e)}convert(e){const r=m$(e);if(!window.matchMedia("(forced-colors: active)").matches)return r;for(const[n,i]of this._colors)if(i.every((a,s)=>a===r[s]))return nue._colorsMapping.get(n);return r}getHexCode(e){const r=this._colors.get(e);return r?Xn.makeHexColor(...r):e}}class Z_{#e=new AbortController;#t=null;#r=new Map;#n=new Map;#i=null;#a=null;#s=null;#o=new mFt;#l=null;#c=null;#d=null;#u=0;#p=new Set;#g=null;#f=null;#h=new Set;_editorUndoBar=null;#m=!1;#v=!1;#_=!1;#S=null;#b=null;#y=null;#E=null;#C=!1;#w=null;#O=new gFt;#N=!1;#R=!1;#A=null;#k=null;#F=null;#D=null;#G=null;#x=Ii.NONE;#T=new Set;#B=null;#U=null;#z=null;#V=null;#Y={isEditing:!1,isEmpty:!0,hasSomethingToUndo:!1,hasSomethingToRedo:!1,hasSelectedEditor:!1,hasSelectedText:!1};#q=[0,0];#M=null;#L=null;#H=null;#X=null;#P=null;static TRANSLATE_SMALL=1;static TRANSLATE_BIG=10;static get _keyboardManager(){const e=Z_.prototype,r=s=>s.#L.contains(document.activeElement)&&document.activeElement.tagName!=="BUTTON"&&s.hasSomethingToControl(),n=(s,{target:o})=>{if(o instanceof HTMLInputElement){const{type:l}=o;return l!=="text"&&l!=="number"}return!0},i=this.TRANSLATE_SMALL,a=this.TRANSLATE_BIG;return na(this,"_keyboardManager",new Q8([[["ctrl+a","mac+meta+a"],e.selectAll,{checker:n}],[["ctrl+z","mac+meta+z"],e.undo,{checker:n}],[["ctrl+y","ctrl+shift+z","mac+meta+shift+z","ctrl+shift+Z","mac+meta+shift+Z"],e.redo,{checker:n}],[["Backspace","alt+Backspace","ctrl+Backspace","shift+Backspace","mac+Backspace","mac+alt+Backspace","mac+ctrl+Backspace","Delete","ctrl+Delete","shift+Delete","mac+Delete"],e.delete,{checker:n}],[["Enter","mac+Enter"],e.addNewEditorFromKeyboard,{checker:(s,{target:o})=>!(o instanceof HTMLButtonElement)&&s.#L.contains(o)&&!s.isEnterHandled}],[[" ","mac+ "],e.addNewEditorFromKeyboard,{checker:(s,{target:o})=>!(o instanceof HTMLButtonElement)&&s.#L.contains(document.activeElement)}],[["Escape","mac+Escape"],e.unselectAll],[["ArrowLeft","mac+ArrowLeft"],e.translateSelectedEditors,{args:[-i,0],checker:r}],[["ctrl+ArrowLeft","mac+shift+ArrowLeft"],e.translateSelectedEditors,{args:[-a,0],checker:r}],[["ArrowRight","mac+ArrowRight"],e.translateSelectedEditors,{args:[i,0],checker:r}],[["ctrl+ArrowRight","mac+shift+ArrowRight"],e.translateSelectedEditors,{args:[a,0],checker:r}],[["ArrowUp","mac+ArrowUp"],e.translateSelectedEditors,{args:[0,-i],checker:r}],[["ctrl+ArrowUp","mac+shift+ArrowUp"],e.translateSelectedEditors,{args:[0,-a],checker:r}],[["ArrowDown","mac+ArrowDown"],e.translateSelectedEditors,{args:[0,i],checker:r}],[["ctrl+ArrowDown","mac+shift+ArrowDown"],e.translateSelectedEditors,{args:[0,a],checker:r}]]))}constructor(e,r,n,i,a,s,o,l,u,d,h,f,p,g,m,_){const v=this._signal=this.#e.signal;this.#L=e,this.#H=r,this.#X=n,this.#i=i,this.#l=a,this.#U=s,this._eventBus=o,o._on("editingaction",this.onEditingAction.bind(this),{signal:v}),o._on("pagechanging",this.onPageChanging.bind(this),{signal:v}),o._on("scalechanging",this.onScaleChanging.bind(this),{signal:v}),o._on("rotationchanging",this.onRotationChanging.bind(this),{signal:v}),o._on("setpreference",this.onSetPreference.bind(this),{signal:v}),o._on("switchannotationeditorparams",b=>this.updateParams(b.type,b.value),{signal:v}),this.#ae(),this.#ce(),this.#Z(),this.#a=l.annotationStorage,this.#S=l.filterFactory,this.#z=u,this.#E=d||null,this.#m=h,this.#v=f,this.#_=p,this.#G=g||null,this.viewParameters={realScale:fx.PDF_TO_CSS_UNITS,rotation:0},this.isShiftKeyDown=!1,this._editorUndoBar=m||null,this._supportsPinchToZoom=_!==!1}destroy(){this.#P?.resolve(),this.#P=null,this.#e?.abort(),this.#e=null,this._signal=null;for(const e of this.#n.values())e.destroy();this.#n.clear(),this.#r.clear(),this.#h.clear(),this.#D?.clear(),this.#t=null,this.#T.clear(),this.#o.destroy(),this.#i?.destroy(),this.#l?.destroy(),this.#U?.destroy(),this.#w?.hide(),this.#w=null,this.#F?.destroy(),this.#F=null,this.#b&&(clearTimeout(this.#b),this.#b=null),this.#M&&(clearTimeout(this.#M),this.#M=null),this._editorUndoBar?.destroy()}combinedSignal(e){return AbortSignal.any([this._signal,e.signal])}get mlManager(){return this.#G}get useNewAltTextFlow(){return this.#v}get useNewAltTextWhenAddingImage(){return this.#_}get hcmFilter(){return na(this,"hcmFilter",this.#z?this.#S.addHCMFilter(this.#z.foreground,this.#z.background):"none")}get direction(){return na(this,"direction",getComputedStyle(this.#L).direction)}get _highlightColors(){return na(this,"_highlightColors",this.#E?new Map(this.#E.split(",").map(e=>(e=e.split("=").map(r=>r.trim()),e[1]=e[1].toUpperCase(),e))):null)}get highlightColors(){const{_highlightColors:e}=this;if(!e)return na(this,"highlightColors",null);const r=new Map,n=!!this.#z;for(const[i,a]of e){const s=i.endsWith("_HCM");if(n&&s){r.set(i.replace("_HCM",""),a);continue}!n&&!s&&r.set(i,a)}return na(this,"highlightColors",r)}get highlightColorNames(){return na(this,"highlightColorNames",this.highlightColors?new Map(Array.from(this.highlightColors,e=>e.reverse())):null)}getNonHCMColor(e){if(!this._highlightColors)return e;const r=this.highlightColorNames.get(e);return this._highlightColors.get(r)||e}getNonHCMColorName(e){return this.highlightColorNames.get(e)||e}setCurrentDrawingSession(e){e?(this.unselectAll(),this.disableUserSelect(!0)):this.disableUserSelect(!1),this.#d=e}setMainHighlightColorPicker(e){this.#F=e}editAltText(e,r=!1){this.#i?.editAltText(this,e,r)}hasCommentManager(){return!!this.#l}editComment(e,r){this.#l?.open(this,e,r)}getSignature(e){this.#U?.getSignature({uiManager:this,editor:e})}get signatureManager(){return this.#U}switchToMode(e,r){this._eventBus.on("annotationeditormodechanged",r,{once:!0,signal:this._signal}),this._eventBus.dispatch("showannotationeditorui",{source:this,mode:e})}setPreference(e,r){this._eventBus.dispatch("setpreference",{source:this,name:e,value:r})}onSetPreference({name:e,value:r}){e==="enableNewAltTextWhenAddingImage"&&(this.#_=r)}onPageChanging({pageNumber:e}){this.#u=e-1}focusMainContainer(){this.#L.focus()}findParent(e,r){for(const n of this.#n.values()){const{x:i,y:a,width:s,height:o}=n.div.getBoundingClientRect();if(e>=i&&e<=i+s&&r>=a&&r<=a+o)return n}return null}disableUserSelect(e=!1){this.#H.classList.toggle("noUserSelect",e)}addShouldRescale(e){this.#h.add(e)}removeShouldRescale(e){this.#h.delete(e)}onScaleChanging({scale:e}){this.commitOrRemove(),this.viewParameters.realScale=e*fx.PDF_TO_CSS_UNITS;for(const r of this.#h)r.onScaleChanging();this.#d?.onScaleChanging()}onRotationChanging({pagesRotation:e}){this.commitOrRemove(),this.viewParameters.rotation=e}#K({anchorNode:e}){return e.nodeType===Node.TEXT_NODE?e.parentElement:e}#Q(e){const{currentLayer:r}=this;if(r.hasTextLayer(e))return r;for(const n of this.#n.values())if(n.hasTextLayer(e))return n;return null}highlightSelection(e=""){const r=document.getSelection();if(!r||r.isCollapsed)return;const{anchorNode:n,anchorOffset:i,focusNode:a,focusOffset:s}=r,o=r.toString(),u=this.#K(r).closest(".textLayer"),d=this.getSelectionBoxes(u);if(!d)return;r.empty();const h=this.#Q(u),f=this.#x===Ii.NONE,p=()=>{h?.createAndAddNewEditor({x:0,y:0},!1,{methodOfCreation:e,boxes:d,anchorNode:n,anchorOffset:i,focusNode:a,focusOffset:s,text:o}),f&&this.showAllEditors("highlight",!0,!0)};if(f){this.switchToMode(Ii.HIGHLIGHT,p);return}p()}#ne(){const e=document.getSelection();if(!e||e.isCollapsed)return;const n=this.#K(e).closest(".textLayer"),i=this.getSelectionBoxes(n);i&&(this.#w||=new pFt(this),this.#w.show(n,i,this.direction==="ltr"))}addToAnnotationStorage(e){!e.isEmpty()&&this.#a&&!this.#a.has(e.id)&&this.#a.setValue(e.id,e)}a11yAlert(e,r=null){const n=this.#X;n&&(n.setAttribute("data-l10n-id",e),r?n.setAttribute("data-l10n-args",JSON.stringify(r)):n.removeAttribute("data-l10n-args"))}#ie(){const e=document.getSelection();if(!e||e.isCollapsed){this.#B&&(this.#w?.hide(),this.#B=null,this.#I({hasSelectedText:!1}));return}const{anchorNode:r}=e;if(r===this.#B)return;const i=this.#K(e).closest(".textLayer");if(!i){this.#B&&(this.#w?.hide(),this.#B=null,this.#I({hasSelectedText:!1}));return}if(this.#w?.hide(),this.#B=r,this.#I({hasSelectedText:!0}),!(this.#x!==Ii.HIGHLIGHT&&this.#x!==Ii.NONE)&&(this.#x===Ii.HIGHLIGHT&&this.showAllEditors("highlight",!0,!0),this.#C=this.isShiftKeyDown,!this.isShiftKeyDown)){const a=this.#x===Ii.HIGHLIGHT?this.#Q(i):null;a?.toggleDrawing();const s=new AbortController,o=this.combinedSignal(s),l=u=>{u.type==="pointerup"&&u.button!==0||(s.abort(),a?.toggleDrawing(!0),u.type==="pointerup"&&this.#j("main_toolbar"))};window.addEventListener("pointerup",l,{signal:o}),window.addEventListener("blur",l,{signal:o})}}#j(e=""){this.#x===Ii.HIGHLIGHT?this.highlightSelection(e):this.#m&&this.#ne()}#ae(){document.addEventListener("selectionchange",this.#ie.bind(this),{signal:this._signal})}#se(){if(this.#y)return;this.#y=new AbortController;const e=this.combinedSignal(this.#y);window.addEventListener("focus",this.focus.bind(this),{signal:e}),window.addEventListener("blur",this.blur.bind(this),{signal:e})}#oe(){this.#y?.abort(),this.#y=null}blur(){if(this.isShiftKeyDown=!1,this.#C&&(this.#C=!1,this.#j("main_toolbar")),!this.hasSelection)return;const{activeElement:e}=document;for(const r of this.#T)if(r.div.contains(e)){this.#k=[r,e],r._focusEventsAllowed=!1;break}}focus(){if(!this.#k)return;const[e,r]=this.#k;this.#k=null,r.addEventListener("focusin",()=>{e._focusEventsAllowed=!0},{once:!0,signal:this._signal}),r.focus()}#Z(){if(this.#A)return;this.#A=new AbortController;const e=this.combinedSignal(this.#A);window.addEventListener("keydown",this.keydown.bind(this),{signal:e}),window.addEventListener("keyup",this.keyup.bind(this),{signal:e})}#le(){this.#A?.abort(),this.#A=null}#J(){if(this.#c)return;this.#c=new AbortController;const e=this.combinedSignal(this.#c);document.addEventListener("copy",this.copy.bind(this),{signal:e}),document.addEventListener("cut",this.cut.bind(this),{signal:e}),document.addEventListener("paste",this.paste.bind(this),{signal:e})}#ee(){this.#c?.abort(),this.#c=null}#ce(){const e=this._signal;document.addEventListener("dragover",this.dragOver.bind(this),{signal:e}),document.addEventListener("drop",this.drop.bind(this),{signal:e})}addEditListeners(){this.#Z(),this.#J()}removeEditListeners(){this.#le(),this.#ee()}dragOver(e){for(const{type:r}of e.dataTransfer.items)for(const n of this.#f)if(n.isHandlingMimeForPasting(r)){e.dataTransfer.dropEffect="copy",e.preventDefault();return}}drop(e){for(const r of e.dataTransfer.items)for(const n of this.#f)if(n.isHandlingMimeForPasting(r.type)){n.paste(r,this.currentLayer),e.preventDefault();return}}copy(e){if(e.preventDefault(),this.#t?.commitOrRemove(),!this.hasSelection)return;const r=[];for(const n of this.#T){const i=n.serialize(!0);i&&r.push(i)}r.length!==0&&e.clipboardData.setData("application/pdfjs",JSON.stringify(r))}cut(e){this.copy(e),this.delete()}async paste(e){e.preventDefault();const{clipboardData:r}=e;for(const a of r.items)for(const s of this.#f)if(s.isHandlingMimeForPasting(a.type)){s.paste(a,this.currentLayer);return}let n=r.getData("application/pdfjs");if(!n)return;try{n=JSON.parse(n)}catch(a){ki(`paste: "${a.message}".`);return}if(!Array.isArray(n))return;this.unselectAll();const i=this.currentLayer;try{const a=[];for(const l of n){const u=await i.deserialize(l);if(!u)return;a.push(u)}const s=()=>{for(const l of a)this.#te(l);this.#re(a)},o=()=>{for(const l of a)l.remove()};this.addCommands({cmd:s,undo:o,mustExec:!0})}catch(a){ki(`paste: "${a.message}".`)}}keydown(e){!this.isShiftKeyDown&&e.key==="Shift"&&(this.isShiftKeyDown=!0),this.#x!==Ii.NONE&&!this.isEditorHandlingKeyboard&&Z_._keyboardManager.exec(this,e)}keyup(e){this.isShiftKeyDown&&e.key==="Shift"&&(this.isShiftKeyDown=!1,this.#C&&(this.#C=!1,this.#j("main_toolbar")))}onEditingAction({name:e}){switch(e){case"undo":case"redo":case"delete":case"selectAll":this[e]();break;case"highlightSelection":this.highlightSelection("context_menu");break}}#I(e){Object.entries(e).some(([n,i])=>this.#Y[n]!==i)&&(this._eventBus.dispatch("annotationeditorstateschanged",{source:this,details:Object.assign(this.#Y,e)}),this.#x===Ii.HIGHLIGHT&&e.hasSelectedEditor===!1&&this.#$([[_a.HIGHLIGHT_FREE,!0]]))}#$(e){this._eventBus.dispatch("annotationeditorparamschanged",{source:this,details:e})}setEditingState(e){e?(this.#se(),this.#J(),this.#I({isEditing:this.#x!==Ii.NONE,isEmpty:this.#W(),hasSomethingToUndo:this.#o.hasSomethingToUndo(),hasSomethingToRedo:this.#o.hasSomethingToRedo(),hasSelectedEditor:!1})):(this.#oe(),this.#ee(),this.#I({isEditing:!1}),this.disableUserSelect(!1))}registerEditorTypes(e){if(!this.#f){this.#f=e;for(const r of this.#f)this.#$(r.defaultPropertiesToUpdate)}}getId(){return this.#O.id}get currentLayer(){return this.#n.get(this.#u)}getLayer(e){return this.#n.get(e)}get currentPageIndex(){return this.#u}addLayer(e){this.#n.set(e.pageIndex,e),this.#N?e.enable():e.disable()}removeLayer(e){this.#n.delete(e.pageIndex)}async updateMode(e,r=null,n=!1,i=!1,a=!1){if(this.#x!==e&&!(this.#P&&(await this.#P.promise,!this.#P))){if(this.#P=Promise.withResolvers(),this.#d?.commitOrRemove(),this.#x=e,e===Ii.NONE){this.setEditingState(!1),this.#de(),this._editorUndoBar?.hide(),this.#P.resolve();return}e===Ii.SIGNATURE&&await this.#U?.loadSignatures(),this.setEditingState(!0),await this.#ue(),this.unselectAll();for(const s of this.#n.values())s.updateMode(e);if(!r){n&&this.addNewEditorFromKeyboard(),this.#P.resolve();return}for(const s of this.#r.values())s.annotationElementId===r||s.id===r?(this.setSelected(s),a?s.editComment():i&&s.enterInEditMode()):s.unselect();this.#P.resolve()}}addNewEditorFromKeyboard(){this.currentLayer.canCreateNewEmptyEditor()&&this.currentLayer.addNewEditor()}updateToolbar(e){e.mode!==this.#x&&this._eventBus.dispatch("switchannotationeditormode",{source:this,...e})}updateParams(e,r){if(this.#f){switch(e){case _a.CREATE:this.currentLayer.addNewEditor(r);return;case _a.HIGHLIGHT_SHOW_ALL:this._eventBus.dispatch("reporttelemetry",{source:this,details:{type:"editing",data:{type:"highlight",action:"toggle_visibility"}}}),(this.#V||=new Map).set(e,r),this.showAllEditors("highlight",r);break}if(this.hasSelection)for(const n of this.#T)n.updateParams(e,r);else for(const n of this.#f)n.updateDefaultParams(e,r)}}showAllEditors(e,r,n=!1){for(const a of this.#r.values())a.editorType===e&&a.show(r);(this.#V?.get(_a.HIGHLIGHT_SHOW_ALL)??!0)!==r&&this.#$([[_a.HIGHLIGHT_SHOW_ALL,r]])}enableWaiting(e=!1){if(this.#R!==e){this.#R=e;for(const r of this.#n.values())e?r.disableClick():r.enableClick(),r.div.classList.toggle("waiting",e)}}async#ue(){if(!this.#N){this.#N=!0;const e=[];for(const r of this.#n.values())e.push(r.enable());await Promise.all(e);for(const r of this.#r.values())r.enable()}}#de(){if(this.unselectAll(),this.#N){this.#N=!1;for(const e of this.#n.values())e.disable();for(const e of this.#r.values())e.disable()}}getEditors(e){const r=[];for(const n of this.#r.values())n.pageIndex===e&&r.push(n);return r}getEditor(e){return this.#r.get(e)}addEditor(e){this.#r.set(e.id,e)}removeEditor(e){e.div.contains(document.activeElement)&&(this.#b&&clearTimeout(this.#b),this.#b=setTimeout(()=>{this.focusMainContainer(),this.#b=null},0)),this.#r.delete(e.id),e.annotationElementId&&this.#D?.delete(e.annotationElementId),this.unselect(e),(!e.annotationElementId||!this.#p.has(e.annotationElementId))&&this.#a?.remove(e.id)}addDeletedAnnotationElement(e){this.#p.add(e.annotationElementId),this.addChangedExistingAnnotation(e),e.deleted=!0}isDeletedAnnotationElement(e){return this.#p.has(e)}removeDeletedAnnotationElement(e){this.#p.delete(e.annotationElementId),this.removeChangedExistingAnnotation(e),e.deleted=!1}#te(e){const r=this.#n.get(e.pageIndex);r?r.addOrRebuild(e):(this.addEditor(e),this.addToAnnotationStorage(e))}setActiveEditor(e){this.#t!==e&&(this.#t=e,e&&this.#$(e.propertiesToUpdate))}get#he(){let e=null;for(e of this.#T);return e}updateUI(e){this.#he===e&&this.#$(e.propertiesToUpdate)}updateUIForDefaultProperties(e){this.#$(e.defaultPropertiesToUpdate)}toggleSelected(e){if(this.#T.has(e)){this.#T.delete(e),e.unselect(),this.#I({hasSelectedEditor:this.hasSelection});return}this.#T.add(e),e.select(),this.#$(e.propertiesToUpdate),this.#I({hasSelectedEditor:!0})}setSelected(e){this.updateToolbar({mode:e.mode,editId:e.id}),this.#d?.commitOrRemove();for(const r of this.#T)r!==e&&r.unselect();this.#T.clear(),this.#T.add(e),e.select(),this.#$(e.propertiesToUpdate),this.#I({hasSelectedEditor:!0})}isSelected(e){return this.#T.has(e)}get firstSelectedEditor(){return this.#T.values().next().value}unselect(e){e.unselect(),this.#T.delete(e),this.#I({hasSelectedEditor:this.hasSelection})}get hasSelection(){return this.#T.size!==0}get isEnterHandled(){return this.#T.size===1&&this.firstSelectedEditor.isEnterHandled}undo(){this.#o.undo(),this.#I({hasSomethingToUndo:this.#o.hasSomethingToUndo(),hasSomethingToRedo:!0,isEmpty:this.#W()}),this._editorUndoBar?.hide()}redo(){this.#o.redo(),this.#I({hasSomethingToUndo:!0,hasSomethingToRedo:this.#o.hasSomethingToRedo(),isEmpty:this.#W()})}addCommands(e){this.#o.add(e),this.#I({hasSomethingToUndo:!0,hasSomethingToRedo:!1,isEmpty:this.#W()})}cleanUndoStack(e){this.#o.cleanType(e)}#W(){if(this.#r.size===0)return!0;if(this.#r.size===1)for(const e of this.#r.values())return e.isEmpty();return!1}delete(){this.commitOrRemove();const e=this.currentLayer?.endDrawingSession(!0);if(!this.hasSelection&&!e)return;const r=e?[e]:[...this.#T],n=()=>{this._editorUndoBar?.show(i,r.length===1?r[0].editorType:r.length);for(const a of r)a.remove()},i=()=>{for(const a of r)this.#te(a)};this.addCommands({cmd:n,undo:i,mustExec:!0})}commitOrRemove(){this.#t?.commitOrRemove()}hasSomethingToControl(){return this.#t||this.hasSelection}#re(e){for(const r of this.#T)r.unselect();this.#T.clear();for(const r of e)r.isEmpty()||(this.#T.add(r),r.select());this.#I({hasSelectedEditor:this.hasSelection})}selectAll(){for(const e of this.#T)e.commit();this.#re(this.#r.values())}unselectAll(){if(!(this.#t&&(this.#t.commitOrRemove(),this.#x!==Ii.NONE))&&!this.#d?.commitOrRemove()&&this.hasSelection){for(const e of this.#T)e.unselect();this.#T.clear(),this.#I({hasSelectedEditor:!1})}}translateSelectedEditors(e,r,n=!1){if(n||this.commitOrRemove(),!this.hasSelection)return;this.#q[0]+=e,this.#q[1]+=r;const[i,a]=this.#q,s=[...this.#T],o=1e3;this.#M&&clearTimeout(this.#M),this.#M=setTimeout(()=>{this.#M=null,this.#q[0]=this.#q[1]=0,this.addCommands({cmd:()=>{for(const l of s)this.#r.has(l.id)&&(l.translateInPage(i,a),l.translationDone())},undo:()=>{for(const l of s)this.#r.has(l.id)&&(l.translateInPage(-i,-a),l.translationDone())},mustExec:!1})},o);for(const l of s)l.translateInPage(e,r),l.translationDone()}setUpDragSession(){if(this.hasSelection){this.disableUserSelect(!0),this.#g=new Map;for(const e of this.#T)this.#g.set(e,{savedX:e.x,savedY:e.y,savedPageIndex:e.pageIndex,newX:0,newY:0,newPageIndex:-1})}}endDragSession(){if(!this.#g)return!1;this.disableUserSelect(!1);const e=this.#g;this.#g=null;let r=!1;for(const[{x:i,y:a,pageIndex:s},o]of e)o.newX=i,o.newY=a,o.newPageIndex=s,r||=i!==o.savedX||a!==o.savedY||s!==o.savedPageIndex;if(!r)return!1;const n=(i,a,s,o)=>{if(this.#r.has(i.id)){const l=this.#n.get(o);l?i._setParentAndPosition(l,a,s):(i.pageIndex=o,i.x=a,i.y=s)}};return this.addCommands({cmd:()=>{for(const[i,{newX:a,newY:s,newPageIndex:o}]of e)n(i,a,s,o)},undo:()=>{for(const[i,{savedX:a,savedY:s,savedPageIndex:o}]of e)n(i,a,s,o)},mustExec:!0}),!0}dragSelectedEditors(e,r){if(this.#g)for(const n of this.#g.keys())n.drag(e,r)}rebuild(e){if(e.parent===null){const r=this.getLayer(e.pageIndex);r?(r.changeParent(e),r.addOrRebuild(e)):(this.addEditor(e),this.addToAnnotationStorage(e),e.rebuild())}else e.parent.addOrRebuild(e)}get isEditorHandlingKeyboard(){return this.getActive()?.shouldGetKeyboardEvents()||this.#T.size===1&&this.firstSelectedEditor.shouldGetKeyboardEvents()}isActive(e){return this.#t===e}getActive(){return this.#t}getMode(){return this.#x}get imageManager(){return na(this,"imageManager",new rue)}getSelectionBoxes(e){if(!e)return null;const r=document.getSelection();for(let u=0,d=r.rangeCount;u({x:(d-i)/s,y:1-(u+h-n)/a,width:f/s,height:h/a});break;case"180":o=(u,d,h,f)=>({x:1-(u+h-n)/a,y:1-(d+f-i)/s,width:h/a,height:f/s});break;case"270":o=(u,d,h,f)=>({x:1-(d+f-i)/s,y:(u-n)/a,width:f/s,height:h/a});break;default:o=(u,d,h,f)=>({x:(u-n)/a,y:(d-i)/s,width:h/a,height:f/s});break}const l=[];for(let u=0,d=r.rangeCount;ua.stopPropagation(),{signal:n});const i=a=>{a.preventDefault(),this.#l._uiManager.editAltText(this.#l),this.#u&&this.#l._reportTelemetry({action:"pdfjs.image.alt_text.image_status_label_clicked",data:{label:this.#g}})};return e.addEventListener("click",i,{capture:!0,signal:n}),e.addEventListener("keydown",a=>{a.target===e&&a.key==="Enter"&&(this.#s=!0,i(a))},{signal:n}),await this.#f(),e}get#g(){return this.#e&&"added"||this.#e===null&&this.guessedText&&"review"||"missing"}finish(){this.#r&&(this.#r.focus({focusVisible:this.#s}),this.#s=!1)}isEmpty(){return this.#u?this.#e===null:!this.#e&&!this.#t}hasData(){return this.#u?this.#e!==null||!!this.#c:this.isEmpty()}get guessedText(){return this.#c}async setGuessedText(e){this.#e===null&&(this.#c=e,this.#d=await ug._l10n.get("pdfjs-editor-new-alt-text-generated-alt-text-with-disclaimer",{generatedAltText:e}),this.#f())}toggleAltTextBadge(e=!1){if(!this.#u||this.#e){this.#o?.remove(),this.#o=null;return}if(!this.#o){const r=this.#o=document.createElement("div");r.className="noAltTextBadge",this.#l.div.append(r)}this.#o.classList.toggle("hidden",!e)}serialize(e){let r=this.#e;return!e&&this.#c===r&&(r=this.#d),{altText:r,decorative:this.#t,guessedText:this.#c,textWithDisclaimer:this.#d}}get data(){return{altText:this.#e,decorative:this.#t}}set data({altText:e,decorative:r,guessedText:n,textWithDisclaimer:i,cancel:a=!1}){n&&(this.#c=n,this.#d=i),!(this.#e===e&&this.#t===r)&&(a||(this.#e=e,this.#t=r),this.#f())}toggle(e=!1){this.#r&&(!e&&this.#a&&(clearTimeout(this.#a),this.#a=null),this.#r.disabled=!e)}shown(){this.#l._reportTelemetry({action:"pdfjs.image.alt_text.image_status_label_displayed",data:{label:this.#g}})}destroy(){this.#r?.remove(),this.#r=null,this.#n=null,this.#i=null,this.#o?.remove(),this.#o=null}async#f(){const e=this.#r;if(!e)return;if(this.#u){if(e.classList.toggle("done",!!this.#e),e.setAttribute("data-l10n-id",ug.#p[this.#g]),this.#n?.setAttribute("data-l10n-id",ug.#p[`${this.#g}-label`]),!this.#e){this.#i?.remove();return}}else{if(!this.#e&&!this.#t){e.classList.remove("done"),this.#i?.remove();return}e.classList.add("done"),e.setAttribute("data-l10n-id","pdfjs-editor-alt-text-edit-button")}let r=this.#i;if(!r){this.#i=r=document.createElement("span"),r.className="tooltip",r.setAttribute("role","tooltip"),r.id=`alt-text-tooltip-${this.#l.id}`;const i=100,a=this.#l._uiManager._signal;a.addEventListener("abort",()=>{clearTimeout(this.#a),this.#a=null},{once:!0}),e.addEventListener("mouseenter",()=>{this.#a=setTimeout(()=>{this.#a=null,this.#i.classList.add("show"),this.#l._reportTelemetry({action:"alt_text_tooltip"})},i)},{signal:a}),e.addEventListener("mouseleave",()=>{this.#a&&(clearTimeout(this.#a),this.#a=null),this.#i?.classList.remove("show")},{signal:a})}this.#t?r.setAttribute("data-l10n-id","pdfjs-editor-alt-text-decorative-tooltip"):(r.removeAttribute("data-l10n-id"),r.textContent=this.#e),r.parentNode||e.append(r),this.#l.getElementForAltText()?.setAttribute("aria-describedby",r.id)}}let qI=class{#e=null;#t=!1;#r=null;#n=null;#i=null;#a=null;#s=!1;constructor(e){this.#r=e,this.toolbar=null}render(){if(!this.#r._uiManager.hasCommentManager())return null;const e=this.#e=document.createElement("button");e.className="comment",e.tabIndex="0",e.setAttribute("data-l10n-id","pdfjs-editor-edit-comment-button");const r=this.#r._uiManager._signal;e.addEventListener("contextmenu",yf,{signal:r}),e.addEventListener("pointerdown",i=>i.stopPropagation(),{signal:r});const n=i=>{i.preventDefault(),this.edit()};return e.addEventListener("click",n,{capture:!0,signal:r}),e.addEventListener("keydown",i=>{i.target===e&&i.key==="Enter"&&(this.#t=!0,n(i))},{signal:r}),e}edit(){const{bottom:e,left:r,right:n}=this.#r.getClientDimensions(),i={top:e};this.#r._uiManager.direction==="ltr"?i.right=n:i.left=r,this.#r._uiManager.editComment(this.#r,i)}finish(){this.#e&&(this.#e.focus({focusVisible:this.#t}),this.#t=!1)}isDeleted(){return this.#s||this.#i===""}hasBeenEdited(){return this.isDeleted()||this.#i!==this.#n}serialize(){return this.data}get data(){return{text:this.#i,date:this.#a,deleted:this.#s}}set data(e){if(e===null){this.#i="",this.#s=!0;return}this.#i=e,this.#a=new Date,this.#s=!1}setInitialText(e){this.#n=e,this.data=e}toggle(e=!1){this.#e&&(this.#e.disabled=!e)}shown(){}destroy(){this.#e?.remove(),this.#e=null,this.#i="",this.#a=null,this.#r=null,this.#t=!1,this.#s=!1}};class _${#e;#t=!1;#r=null;#n;#i;#a;#s;#o=null;#l;#c=null;#d;#u=null;constructor({container:e,isPinchingDisabled:r=null,isPinchingStopped:n=null,onPinchStart:i=null,onPinching:a=null,onPinchEnd:s=null,signal:o}){this.#e=e,this.#r=n,this.#n=r,this.#i=i,this.#a=a,this.#s=s,this.#d=new AbortController,this.#l=AbortSignal.any([o,this.#d.signal]),e.addEventListener("touchstart",this.#p.bind(this),{passive:!1,signal:this.#l})}get MIN_TOUCH_DISTANCE_TO_PINCH(){return 35/Qg.pixelRatio}#p(e){if(this.#n?.())return;if(e.touches.length===1){if(this.#o)return;const i=this.#o=new AbortController,a=AbortSignal.any([this.#l,i.signal]),s=this.#e,o={capture:!0,signal:a,passive:!1},l=u=>{u.pointerType==="touch"&&(this.#o?.abort(),this.#o=null)};s.addEventListener("pointerdown",u=>{u.pointerType==="touch"&&(Wo(u),l(u))},o),s.addEventListener("pointerup",l,o),s.addEventListener("pointercancel",l,o);return}if(!this.#u){this.#u=new AbortController;const i=AbortSignal.any([this.#l,this.#u.signal]),a=this.#e,s={signal:i,capture:!1,passive:!1};a.addEventListener("touchmove",this.#g.bind(this),s);const o=this.#f.bind(this);a.addEventListener("touchend",o,s),a.addEventListener("touchcancel",o,s),s.capture=!0,a.addEventListener("pointerdown",Wo,s),a.addEventListener("pointermove",Wo,s),a.addEventListener("pointercancel",Wo,s),a.addEventListener("pointerup",Wo,s),this.#i?.()}if(Wo(e),e.touches.length!==2||this.#r?.()){this.#c=null;return}let[r,n]=e.touches;r.identifier>n.identifier&&([r,n]=[n,r]),this.#c={touch0X:r.screenX,touch0Y:r.screenY,touch1X:n.screenX,touch1Y:n.screenY}}#g(e){if(!this.#c||e.touches.length!==2)return;Wo(e);let[r,n]=e.touches;r.identifier>n.identifier&&([r,n]=[n,r]);const{screenX:i,screenY:a}=r,{screenX:s,screenY:o}=n,l=this.#c,{touch0X:u,touch0Y:d,touch1X:h,touch1Y:f}=l,p=h-u,g=f-d,m=s-i,_=o-a,v=Math.hypot(m,_)||1,b=Math.hypot(p,g)||1;if(!this.#t&&Math.abs(b-v)<=_$.MIN_TOUCH_DISTANCE_TO_PINCH)return;if(l.touch0X=i,l.touch0Y=a,l.touch1X=s,l.touch1Y=o,!this.#t){this.#t=!0;return}const y=[(i+s)/2,(a+o)/2];this.#a?.(y,b,v)}#f(e){e.touches.length>=2||(this.#u&&(this.#u.abort(),this.#u=null,this.#s?.()),this.#c&&(Wo(e),this.#c=null,this.#t=!1))}destroy(){this.#d?.abort(),this.#d=null,this.#o?.abort(),this.#o=null}}class ti{#e=null;#t=null;#r=null;#n=null;#i=!1;#a=null;#s="";#o=!1;#l=null;#c=null;#d=null;#u=null;#p="";#g=!1;#f=null;#h=!1;#m=!1;#v=!1;#_=null;#S=0;#b=0;#y=null;#E=null;isSelected=!1;_isCopy=!1;_editToolbar=null;_initialOptions=Object.create(null);_initialData=null;_isVisible=!0;_uiManager=null;_focusEventsAllowed=!0;static _l10n=null;static _l10nResizer=null;#C=!1;#w=ti._zIndex++;static _borderLineWidth=-1;static _colorManager=new nue;static _zIndex=1;static _telemetryTimeout=1e3;static get _resizerKeyboardManager(){const e=ti.prototype._resizeWithKeyboard,r=Z_.TRANSLATE_SMALL,n=Z_.TRANSLATE_BIG;return na(this,"_resizerKeyboardManager",new Q8([[["ArrowLeft","mac+ArrowLeft"],e,{args:[-r,0]}],[["ctrl+ArrowLeft","mac+shift+ArrowLeft"],e,{args:[-n,0]}],[["ArrowRight","mac+ArrowRight"],e,{args:[r,0]}],[["ctrl+ArrowRight","mac+shift+ArrowRight"],e,{args:[n,0]}],[["ArrowUp","mac+ArrowUp"],e,{args:[0,-r]}],[["ctrl+ArrowUp","mac+shift+ArrowUp"],e,{args:[0,-n]}],[["ArrowDown","mac+ArrowDown"],e,{args:[0,r]}],[["ctrl+ArrowDown","mac+shift+ArrowDown"],e,{args:[0,n]}],[["Escape","mac+Escape"],ti.prototype._stopResizingWithKeyboard]]))}constructor(e){this.parent=e.parent,this.id=e.id,this.width=this.height=null,this.pageIndex=e.parent.pageIndex,this.name=e.name,this.div=null,this._uiManager=e.uiManager,this.annotationElementId=null,this._willKeepAspectRatio=!1,this._initialOptions.isCentered=e.isCentered,this._structTreeParentId=null,this.annotationElementId=e.annotationElementId||null;const{rotation:r,rawDims:{pageWidth:n,pageHeight:i,pageX:a,pageY:s}}=this.parent.viewport;this.rotation=r,this.pageRotation=(360+r-this._uiManager.viewParameters.rotation)%360,this.pageDimensions=[n,i],this.pageTranslation=[a,s];const[o,l]=this.parentDimensions;this.x=e.x/o,this.y=e.y/l,this.isAttachedToDOM=!1,this.deleted=!1}get editorType(){return Object.getPrototypeOf(this).constructor._type}get mode(){return Object.getPrototypeOf(this).constructor._editorType}static get isDrawer(){return!1}static get _defaultLineColor(){return na(this,"_defaultLineColor",this._colorManager.getHexCode("CanvasText"))}static deleteAnnotationElement(e){const r=new _Ft({id:e.parent.getNextId(),parent:e.parent,uiManager:e._uiManager});r.annotationElementId=e.annotationElementId,r.deleted=!0,r._uiManager.addToAnnotationStorage(r)}static initialize(e,r){if(ti._l10n??=e,ti._l10nResizer||=Object.freeze({topLeft:"pdfjs-editor-resizer-top-left",topMiddle:"pdfjs-editor-resizer-top-middle",topRight:"pdfjs-editor-resizer-top-right",middleRight:"pdfjs-editor-resizer-middle-right",bottomRight:"pdfjs-editor-resizer-bottom-right",bottomMiddle:"pdfjs-editor-resizer-bottom-middle",bottomLeft:"pdfjs-editor-resizer-bottom-left",middleLeft:"pdfjs-editor-resizer-middle-left"}),ti._borderLineWidth!==-1)return;const n=getComputedStyle(document.documentElement);ti._borderLineWidth=parseFloat(n.getPropertyValue("--outline-width"))||0}static updateDefaultParams(e,r){}static get defaultPropertiesToUpdate(){return[]}static isHandlingMimeForPasting(e){return!1}static paste(e,r){as("Not implemented")}get propertiesToUpdate(){return[]}get _isDraggable(){return this.#C}set _isDraggable(e){this.#C=e,this.div?.classList.toggle("draggable",e)}get isEnterHandled(){return!0}center(){const[e,r]=this.pageDimensions;switch(this.parentRotation){case 90:this.x-=this.height*r/(e*2),this.y+=this.width*e/(r*2);break;case 180:this.x+=this.width/2,this.y+=this.height/2;break;case 270:this.x+=this.height*r/(e*2),this.y-=this.width*e/(r*2);break;default:this.x-=this.width/2,this.y-=this.height/2;break}this.fixAndSetPosition()}addCommands(e){this._uiManager.addCommands(e)}get currentLayer(){return this._uiManager.currentLayer}setInBackground(){this.div.style.zIndex=0}setInForeground(){this.div.style.zIndex=this.#w}setParent(e){e!==null?(this.pageIndex=e.pageIndex,this.pageDimensions=e.pageDimensions):this.#H(),this.parent=e}focusin(e){this._focusEventsAllowed&&(this.#g?this.#g=!1:this.parent.setSelected(this))}focusout(e){!this._focusEventsAllowed||!this.isAttachedToDOM||e.relatedTarget?.closest(`#${this.id}`)||(e.preventDefault(),this.parent?.isMultipleSelection||this.commitOrRemove())}commitOrRemove(){this.isEmpty()?this.remove():this.commit()}commit(){this.isInEditMode()&&this.addToAnnotationStorage()}addToAnnotationStorage(){this._uiManager.addToAnnotationStorage(this)}setAt(e,r,n,i){const[a,s]=this.parentDimensions;[n,i]=this.screenToPageTranslation(n,i),this.x=(e+n)/a,this.y=(r+i)/s,this.fixAndSetPosition()}_moveAfterPaste(e,r){const[n,i]=this.parentDimensions;this.setAt(e*n,r*i,this.width*n,this.height*i),this._onTranslated()}#O([e,r],n,i){[n,i]=this.screenToPageTranslation(n,i),this.x+=n/e,this.y+=i/r,this._onTranslating(this.x,this.y),this.fixAndSetPosition()}translate(e,r){this.#O(this.parentDimensions,e,r)}translateInPage(e,r){this.#f||=[this.x,this.y,this.width,this.height],this.#O(this.pageDimensions,e,r),this.div.scrollIntoView({block:"nearest"})}translationDone(){this._onTranslated(this.x,this.y)}drag(e,r){this.#f||=[this.x,this.y,this.width,this.height];const{div:n,parentDimensions:[i,a]}=this;if(this.x+=e/i,this.y+=r/a,this.parent&&(this.x<0||this.x>1||this.y<0||this.y>1)){const{x:h,y:f}=this.div.getBoundingClientRect();this.parent.findNewParent(this,h,f)&&(this.x-=Math.floor(this.x),this.y-=Math.floor(this.y))}let{x:s,y:o}=this;const[l,u]=this.getBaseTranslation();s+=l,o+=u;const{style:d}=n;d.left=`${(100*s).toFixed(2)}%`,d.top=`${(100*o).toFixed(2)}%`,this._onTranslating(s,o),n.scrollIntoView({block:"nearest"})}_onTranslating(e,r){}_onTranslated(e,r){}get _hasBeenMoved(){return!!this.#f&&(this.#f[0]!==this.x||this.#f[1]!==this.y)}get _hasBeenResized(){return!!this.#f&&(this.#f[2]!==this.width||this.#f[3]!==this.height)}getBaseTranslation(){const[e,r]=this.parentDimensions,{_borderLineWidth:n}=ti,i=n/e,a=n/r;switch(this.rotation){case 90:return[-i,a];case 180:return[i,a];case 270:return[i,-a];default:return[-i,-a]}}get _mustFixPosition(){return!0}fixAndSetPosition(e=this.rotation){const{div:{style:r},pageDimensions:[n,i]}=this;let{x:a,y:s,width:o,height:l}=this;if(o*=n,l*=i,a*=n,s*=i,this._mustFixPosition)switch(e){case 0:a=gu(a,0,n-o),s=gu(s,0,i-l);break;case 90:a=gu(a,0,n-l),s=gu(s,o,i);break;case 180:a=gu(a,o,n),s=gu(s,l,i);break;case 270:a=gu(a,l,n),s=gu(s,0,i-o);break}this.x=a/=n,this.y=s/=i;const[u,d]=this.getBaseTranslation();a+=u,s+=d,r.left=`${(100*a).toFixed(2)}%`,r.top=`${(100*s).toFixed(2)}%`,this.moveInDOM()}static#N(e,r,n){switch(n){case 90:return[r,-e];case 180:return[-e,-r];case 270:return[-r,e];default:return[e,r]}}screenToPageTranslation(e,r){return ti.#N(e,r,this.parentRotation)}pageTranslationToScreen(e,r){return ti.#N(e,r,360-this.parentRotation)}#R(e){switch(e){case 90:{const[r,n]=this.pageDimensions;return[0,-r/n,n/r,0]}case 180:return[-1,0,0,-1];case 270:{const[r,n]=this.pageDimensions;return[0,r/n,-n/r,0]}default:return[1,0,0,1]}}get parentScale(){return this._uiManager.viewParameters.realScale}get parentRotation(){return(this._uiManager.viewParameters.rotation+this.pageRotation)%360}get parentDimensions(){const{parentScale:e,pageDimensions:[r,n]}=this;return[r*e,n*e]}setDims(e,r){const[n,i]=this.parentDimensions,{style:a}=this.div;a.width=`${(100*e/n).toFixed(2)}%`,this.#o||(a.height=`${(100*r/i).toFixed(2)}%`)}fixDims(){const{style:e}=this.div,{height:r,width:n}=e,i=n.endsWith("%"),a=!this.#o&&r.endsWith("%");if(i&&a)return;const[s,o]=this.parentDimensions;i||(e.width=`${(100*parseFloat(n)/s).toFixed(2)}%`),!this.#o&&!a&&(e.height=`${(100*parseFloat(r)/o).toFixed(2)}%`)}getInitialTranslation(){return[0,0]}#A(){if(this.#l)return;this.#l=document.createElement("div"),this.#l.classList.add("resizers");const e=this._willKeepAspectRatio?["topLeft","topRight","bottomRight","bottomLeft"]:["topLeft","topMiddle","topRight","middleRight","bottomRight","bottomMiddle","bottomLeft","middleLeft"],r=this._uiManager._signal;for(const n of e){const i=document.createElement("div");this.#l.append(i),i.classList.add("resizer",n),i.setAttribute("data-resizer-name",n),i.addEventListener("pointerdown",this.#k.bind(this,n),{signal:r}),i.addEventListener("contextmenu",yf,{signal:r}),i.tabIndex=-1}this.div.prepend(this.#l)}#k(e,r){r.preventDefault();const{isMac:n}=Sc.platform;if(r.button!==0||r.ctrlKey&&n)return;this.#r?.toggle(!1);const i=this._isDraggable;this._isDraggable=!1,this.#c=[r.screenX,r.screenY];const a=new AbortController,s=this._uiManager.combinedSignal(a);this.parent.togglePointerEvents(!1),window.addEventListener("pointermove",this.#G.bind(this,e),{passive:!0,capture:!0,signal:s}),window.addEventListener("touchmove",Wo,{passive:!1,signal:s}),window.addEventListener("contextmenu",yf,{signal:s}),this.#d={savedX:this.x,savedY:this.y,savedWidth:this.width,savedHeight:this.height};const o=this.parent.div.style.cursor,l=this.div.style.cursor;this.div.style.cursor=this.parent.div.style.cursor=window.getComputedStyle(r.target).cursor;const u=()=>{a.abort(),this.parent.togglePointerEvents(!0),this.#r?.toggle(!0),this._isDraggable=i,this.parent.div.style.cursor=o,this.div.style.cursor=l,this.#D()};window.addEventListener("pointerup",u,{signal:s}),window.addEventListener("blur",u,{signal:s})}#F(e,r,n,i){this.width=n,this.height=i,this.x=e,this.y=r;const[a,s]=this.parentDimensions;this.setDims(a*n,s*i),this.fixAndSetPosition(),this._onResized()}_onResized(){}#D(){if(!this.#d)return;const{savedX:e,savedY:r,savedWidth:n,savedHeight:i}=this.#d;this.#d=null;const a=this.x,s=this.y,o=this.width,l=this.height;a===e&&s===r&&o===n&&l===i||this.addCommands({cmd:this.#F.bind(this,a,s,o,l),undo:this.#F.bind(this,e,r,n,i),mustExec:!0})}static _round(e){return Math.round(e*1e4)/1e4}#G(e,r){const[n,i]=this.parentDimensions,a=this.x,s=this.y,o=this.width,l=this.height,u=ti.MIN_SIZE/n,d=ti.MIN_SIZE/i,h=this.#R(this.rotation),f=(M,L)=>[h[0]*M+h[2]*L,h[1]*M+h[3]*L],p=this.#R(360-this.rotation),g=(M,L)=>[p[0]*M+p[2]*L,p[1]*M+p[3]*L];let m,_,v=!1,b=!1;switch(e){case"topLeft":v=!0,m=(M,L)=>[0,0],_=(M,L)=>[M,L];break;case"topMiddle":m=(M,L)=>[M/2,0],_=(M,L)=>[M/2,L];break;case"topRight":v=!0,m=(M,L)=>[M,0],_=(M,L)=>[0,L];break;case"middleRight":b=!0,m=(M,L)=>[M,L/2],_=(M,L)=>[0,L/2];break;case"bottomRight":v=!0,m=(M,L)=>[M,L],_=(M,L)=>[0,0];break;case"bottomMiddle":m=(M,L)=>[M/2,L],_=(M,L)=>[M/2,0];break;case"bottomLeft":v=!0,m=(M,L)=>[0,L],_=(M,L)=>[M,0];break;case"middleLeft":b=!0,m=(M,L)=>[0,L/2],_=(M,L)=>[M,L/2];break}const y=m(o,l),E=_(o,l);let T=f(...E);const C=ti._round(a+T[0]),w=ti._round(s+T[1]);let x=1,A=1,R,O;if(r.fromKeyboard)({deltaX:R,deltaY:O}=r);else{const{screenX:M,screenY:L}=r,[I,U]=this.#c;[R,O]=this.screenToPageTranslation(M-I,L-U),this.#c[0]=M,this.#c[1]=L}if([R,O]=g(R/n,O/i),v){const M=Math.hypot(o,l);x=A=Math.max(Math.min(Math.hypot(E[0]-y[0]-R,E[1]-y[1]-O)/M,1/o,1/l),u/o,d/l)}else b?x=gu(Math.abs(E[0]-y[0]-R),u,1)/o:A=gu(Math.abs(E[1]-y[1]-O),d,1)/l;const F=ti._round(o*x),P=ti._round(l*A);T=f(..._(F,P));const N=C-T[0],k=w-T[1];this.#f||=[this.x,this.y,this.width,this.height],this.width=F,this.height=P,this.x=N,this.y=k,this.setDims(n*F,i*P),this.fixAndSetPosition(),this._onResizing()}_onResizing(){}altTextFinish(){this.#r?.finish()}get toolbarButtons(){return null}async addEditToolbar(){if(this._editToolbar||this.#m)return this._editToolbar;this._editToolbar=new $9(this),this.div.append(this._editToolbar.render()),this._editToolbar.addButton("comment",this.addCommentButton());const{toolbarButtons:e}=this;if(e)for(const[r,n]of e)await this._editToolbar.addButton(r,n);return this._editToolbar.addButton("delete"),this._editToolbar}removeEditToolbar(){this._editToolbar&&(this._editToolbar.remove(),this._editToolbar=null,this.#r?.destroy())}addContainer(e){const r=this._editToolbar?.div;r?r.before(e):this.div.append(e)}getClientDimensions(){return this.div.getBoundingClientRect()}createAltText(){return this.#r||(ug.initialize(ti._l10n),this.#r=new ug(this),this.#e&&(this.#r.data=this.#e,this.#e=null)),this.#r}get altTextData(){return this.#r?.data}set altTextData(e){this.#r&&(this.#r.data=e)}get guessedAltText(){return this.#r?.guessedText}async setGuessedAltText(e){await this.#r?.setGuessedText(e)}serializeAltText(e){return this.#r?.serialize(e)}hasAltText(){return!!this.#r&&!this.#r.isEmpty()}hasAltTextData(){return this.#r?.hasData()??!1}addCommentButton(){return this.#n?this.#n:this.#n=new qI(this)}get commentColor(){return null}get comment(){const e=this.#n;return{text:e.data.text,date:e.data.date,deleted:e.isDeleted(),color:this.commentColor}}set comment(e){this.#n||(this.#n=new qI(this)),this.#n.data=e}setCommentData(e){this.#n||(this.#n=new qI(this)),this.#n.setInitialText(e)}get hasEditedComment(){return this.#n?.hasBeenEdited()}async editComment(){this.#n||(this.#n=new qI(this)),this.#n.edit()}addComment(e){this.hasEditedComment&&(e.popup={contents:this.comment.text,deleted:this.comment.deleted})}render(){const e=this.div=document.createElement("div");e.setAttribute("data-editor-rotation",(360-this.rotation)%360),e.className=this.name,e.setAttribute("id",this.id),e.tabIndex=this.#i?-1:0,e.setAttribute("role","application"),this.defaultL10nId&&e.setAttribute("data-l10n-id",this.defaultL10nId),this._isVisible||e.classList.add("hidden"),this.setInForeground(),this.#V();const[r,n]=this.parentDimensions;this.parentRotation%180!==0&&(e.style.maxWidth=`${(100*n/r).toFixed(2)}%`,e.style.maxHeight=`${(100*r/n).toFixed(2)}%`);const[i,a]=this.getInitialTranslation();return this.translate(i,a),NMe(this,e,["keydown","pointerdown","dblclick"]),this.isResizable&&this._uiManager._supportsPinchToZoom&&(this.#E||=new _$({container:e,isPinchingDisabled:()=>!this.isSelected,onPinchStart:this.#x.bind(this),onPinching:this.#T.bind(this),onPinchEnd:this.#B.bind(this),signal:this._uiManager._signal})),this._uiManager._editorUndoBar?.hide(),e}#x(){this.#d={savedX:this.x,savedY:this.y,savedWidth:this.width,savedHeight:this.height},this.#r?.toggle(!1),this.parent.togglePointerEvents(!1)}#T(e,r,n){let a=.7*(n/r)+1-.7;if(a===1)return;const s=this.#R(this.rotation),o=(C,w)=>[s[0]*C+s[2]*w,s[1]*C+s[3]*w],[l,u]=this.parentDimensions,d=this.x,h=this.y,f=this.width,p=this.height,g=ti.MIN_SIZE/l,m=ti.MIN_SIZE/u;a=Math.max(Math.min(a,1/f,1/p),g/f,m/p);const _=ti._round(f*a),v=ti._round(p*a);if(_===f&&v===p)return;this.#f||=[d,h,f,p];const b=o(f/2,p/2),y=ti._round(d+b[0]),E=ti._round(h+b[1]),T=o(_/2,v/2);this.x=y-T[0],this.y=E-T[1],this.width=_,this.height=v,this.setDims(l*_,u*v),this.fixAndSetPosition(),this._onResizing()}#B(){this.#r?.toggle(!0),this.parent.togglePointerEvents(!0),this.#D()}pointerdown(e){const{isMac:r}=Sc.platform;if(e.button!==0||e.ctrlKey&&r){e.preventDefault();return}if(this.#g=!0,this._isDraggable){this.#z(e);return}this.#U(e)}#U(e){const{isMac:r}=Sc.platform;e.ctrlKey&&!r||e.shiftKey||e.metaKey&&r?this.parent.toggleSelected(this):this.parent.setSelected(this)}#z(e){const{isSelected:r}=this;this._uiManager.setUpDragSession();let n=!1;const i=new AbortController,a=this._uiManager.combinedSignal(i),s={capture:!0,passive:!1,signal:a},o=u=>{i.abort(),this.#a=null,this.#g=!1,this._uiManager.endDragSession()||this.#U(u),n&&this._onStopDragging()};r&&(this.#S=e.clientX,this.#b=e.clientY,this.#a=e.pointerId,this.#s=e.pointerType,window.addEventListener("pointermove",u=>{n||(n=!0,this._onStartDragging());const{clientX:d,clientY:h,pointerId:f}=u;if(f!==this.#a){Wo(u);return}const[p,g]=this.screenToPageTranslation(d-this.#S,h-this.#b);this.#S=d,this.#b=h,this._uiManager.dragSelectedEditors(p,g)},s),window.addEventListener("touchmove",Wo,s),window.addEventListener("pointerdown",u=>{u.pointerType===this.#s&&(this.#E||u.isPrimary)&&o(u),Wo(u)},s));const l=u=>{if(!this.#a||this.#a===u.pointerId){o(u);return}Wo(u)};window.addEventListener("pointerup",l,{signal:a}),window.addEventListener("blur",l,{signal:a})}_onStartDragging(){}_onStopDragging(){}moveInDOM(){this.#_&&clearTimeout(this.#_),this.#_=setTimeout(()=>{this.#_=null,this.parent?.moveEditorInDOM(this)},0)}_setParentAndPosition(e,r,n){e.changeParent(this),this.x=r,this.y=n,this.fixAndSetPosition(),this._onTranslated()}getRect(e,r,n=this.rotation){const i=this.parentScale,[a,s]=this.pageDimensions,[o,l]=this.pageTranslation,u=e/i,d=r/i,h=this.x*a,f=this.y*s,p=this.width*a,g=this.height*s;switch(n){case 0:return[h+u+o,s-f-d-g+l,h+u+p+o,s-f-d+l];case 90:return[h+d+o,s-f+u+l,h+d+g+o,s-f+u+p+l];case 180:return[h-u-p+o,s-f+d+l,h-u+o,s-f+d+g+l];case 270:return[h-d-g+o,s-f-u-p+l,h-d+o,s-f-u+l];default:throw new Error("Invalid rotation")}}getRectInCurrentCoords(e,r){const[n,i,a,s]=e,o=a-n,l=s-i;switch(this.rotation){case 0:return[n,r-s,o,l];case 90:return[n,r-i,l,o];case 180:return[a,r-i,o,l];case 270:return[a,r-s,l,o];default:throw new Error("Invalid rotation")}}onceAdded(e){}isEmpty(){return!1}enableEditMode(){return this.isInEditMode()?!1:(this.parent.setEditingState(!1),this.#m=!0,!0)}disableEditMode(){return this.isInEditMode()?(this.parent.setEditingState(!0),this.#m=!1,!0):!1}isInEditMode(){return this.#m}shouldGetKeyboardEvents(){return this.#v}needsToBeRebuilt(){return this.div&&!this.isAttachedToDOM}get isOnScreen(){const{top:e,left:r,bottom:n,right:i}=this.getClientDimensions(),{innerHeight:a,innerWidth:s}=window;return r0&&e0}#V(){if(this.#u||!this.div)return;this.#u=new AbortController;const e=this._uiManager.combinedSignal(this.#u);this.div.addEventListener("focusin",this.focusin.bind(this),{signal:e}),this.div.addEventListener("focusout",this.focusout.bind(this),{signal:e})}rebuild(){this.#V()}rotate(e){}resize(){}serializeDeleted(){return{id:this.annotationElementId,deleted:!0,pageIndex:this.pageIndex,popupRef:this._initialData?.popupRef||""}}serialize(e=!1,r=null){as("An editor must be serializable")}static async deserialize(e,r,n){const i=new this.prototype.constructor({parent:r,id:r.getNextId(),uiManager:n,annotationElementId:e.annotationElementId});i.rotation=e.rotation,i.#e=e.accessibilityData,i._isCopy=e.isCopy||!1;const[a,s]=i.pageDimensions,[o,l,u,d]=i.getRectInCurrentCoords(e.rect,s);return i.x=o/a,i.y=l/s,i.width=u/a,i.height=d/s,i}get hasBeenModified(){return!!this.annotationElementId&&(this.deleted||this.serialize()!==null)}remove(){if(this.#u?.abort(),this.#u=null,this.isEmpty()||this.commit(),this.parent?this.parent.remove(this):this._uiManager.removeEditor(this),this.#_&&(clearTimeout(this.#_),this.#_=null),this.#H(),this.removeEditToolbar(),this.#y){for(const e of this.#y.values())clearTimeout(e);this.#y=null}this.parent=null,this.#E?.destroy(),this.#E=null}get isResizable(){return!1}makeResizable(){this.isResizable&&(this.#A(),this.#l.classList.remove("hidden"))}get toolbarPosition(){return null}keydown(e){if(!this.isResizable||e.target!==this.div||e.key!=="Enter")return;this._uiManager.setSelected(this),this.#d={savedX:this.x,savedY:this.y,savedWidth:this.width,savedHeight:this.height};const r=this.#l.children;if(!this.#t){this.#t=Array.from(r);const s=this.#Y.bind(this),o=this.#q.bind(this),l=this._uiManager._signal;for(const u of this.#t){const d=u.getAttribute("data-resizer-name");u.setAttribute("role","spinbutton"),u.addEventListener("keydown",s,{signal:l}),u.addEventListener("blur",o,{signal:l}),u.addEventListener("focus",this.#M.bind(this,d),{signal:l}),u.setAttribute("data-l10n-id",ti._l10nResizer[d])}}const n=this.#t[0];let i=0;for(const s of r){if(s===n)break;i++}const a=(360-this.rotation+this.parentRotation)%360/90*(this.#t.length/4);if(a!==i){if(ai)for(let o=0;o{this.div?.classList.contains("selectedEditor")&&this._editToolbar?.show()});return}this._editToolbar?.show(),this.#r?.toggleAltTextBadge(!1)}}unselect(){this.isSelected&&(this.isSelected=!1,this.#l?.classList.add("hidden"),this.div?.classList.remove("selectedEditor"),this.div?.contains(document.activeElement)&&this._uiManager.currentLayer.div.focus({preventScroll:!0}),this._editToolbar?.hide(),this.#r?.toggleAltTextBadge(!0))}updateParams(e,r){}disableEditing(){}enableEditing(){}get canChangeContent(){return!1}enterInEditMode(){this.canChangeContent&&(this.enableEditMode(),this.div.focus())}dblclick(e){this.enterInEditMode(),this.parent.updateToolbar({mode:this.constructor._editorType,editId:this.id})}getElementForAltText(){return this.div}get contentDiv(){return this.div}get isEditing(){return this.#h}set isEditing(e){this.#h=e,this.parent&&(e?(this.parent.setSelected(this),this.parent.setActiveEditor(this)):this.parent.setActiveEditor(null))}setAspectRatio(e,r){this.#o=!0;const n=e/r,{style:i}=this.div;i.aspectRatio=n,i.height="auto"}static get MIN_SIZE(){return 16}static canCreateNewEmptyEditor(){return!0}get telemetryInitialData(){return{action:"added"}}get telemetryFinalData(){return null}_reportTelemetry(e,r=!1){if(r){this.#y||=new Map;const{action:n}=e;let i=this.#y.get(n);i&&clearTimeout(i),i=setTimeout(()=>{this._reportTelemetry(e),this.#y.delete(n),this.#y.size===0&&(this.#y=null)},ti._telemetryTimeout),this.#y.set(n,i);return}e.type||=this.editorType,this._uiManager._eventBus.dispatch("reporttelemetry",{source:this,details:{type:"editing",data:e}})}show(e=this._isVisible){this.div.classList.toggle("hidden",!e),this._isVisible=e}enable(){this.div&&(this.div.tabIndex=0),this.#i=!1}disable(){this.div&&(this.div.tabIndex=-1),this.#i=!0}renderAnnotationElement(e){let r=e.container.querySelector(".annotationContent");if(!r)r=document.createElement("div"),r.classList.add("annotationContent",this.editorType),e.container.prepend(r);else if(r.nodeName==="CANVAS"){const n=r;r=document.createElement("div"),r.classList.add("annotationContent",this.editorType),n.before(r)}return r}resetAnnotationElement(e){const{firstChild:r}=e.container;r?.nodeName==="DIV"&&r.classList.contains("annotationContent")&&r.remove()}}class _Ft extends ti{constructor(e){super(e),this.annotationElementId=e.annotationElementId,this.deleted=!0}serialize(){return this.serializeDeleted()}}const eTe=3285377520,Uh=4294901760,Kp=65535;class OMe{constructor(e){this.h1=e?e&4294967295:eTe,this.h2=e?e&4294967295:eTe}update(e){let r,n;if(typeof e=="string"){r=new Uint8Array(e.length*2),n=0;for(let m=0,_=e.length;m<_;m++){const v=e.charCodeAt(m);v<=255?r[n++]=v:(r[n++]=v>>>8,r[n++]=v&255)}}else if(ArrayBuffer.isView(e))r=e.slice(),n=r.byteLength;else throw new Error("Invalid data format, must be a string or TypedArray.");const i=n>>2,a=n-i*4,s=new Uint32Array(r.buffer,0,i);let o=0,l=0,u=this.h1,d=this.h2;const h=3432918353,f=461845907,p=h&Kp,g=f&Kp;for(let m=0;m>>17,o=o*f&Uh|o*g&Kp,u^=o,u=u<<13|u>>>19,u=u*5+3864292196):(l=s[m],l=l*h&Uh|l*p&Kp,l=l<<15|l>>>17,l=l*f&Uh|l*g&Kp,d^=l,d=d<<13|d>>>19,d=d*5+3864292196);switch(o=0,a){case 3:o^=r[i*4+2]<<16;case 2:o^=r[i*4+1]<<8;case 1:o^=r[i*4],o=o*h&Uh|o*p&Kp,o=o<<15|o>>>17,o=o*f&Uh|o*g&Kp,i&1?u^=o:d^=o}this.h1=u,this.h2=d}hexdigest(){let e=this.h1,r=this.h2;return e^=r>>>1,e=e*3981806797&Uh|e*36045&Kp,r=r*4283543511&Uh|((r<<16|e>>>16)*2950163797&Uh)>>>16,e^=r>>>1,e=e*444984403&Uh|e*60499&Kp,r=r*3301882366&Uh|((r<<16|e>>>16)*3120437893&Uh)>>>16,e^=r>>>1,(e>>>0).toString(16).padStart(8,"0")+(r>>>0).toString(16).padStart(8,"0")}}const zee=Object.freeze({map:null,hash:"",transfer:void 0});class iue{#e=!1;#t=null;#r=new Map;constructor(){this.onSetModified=null,this.onResetModified=null,this.onAnnotationEditor=null}getValue(e,r){const n=this.#r.get(e);return n===void 0?r:Object.assign(r,n)}getRawValue(e){return this.#r.get(e)}remove(e){if(this.#r.delete(e),this.#r.size===0&&this.resetModified(),typeof this.onAnnotationEditor=="function"){for(const r of this.#r.values())if(r instanceof ti)return;this.onAnnotationEditor(null)}}setValue(e,r){const n=this.#r.get(e);let i=!1;if(n!==void 0)for(const[a,s]of Object.entries(r))n[a]!==s&&(i=!0,n[a]=s);else i=!0,this.#r.set(e,r);i&&this.#n(),r instanceof ti&&typeof this.onAnnotationEditor=="function"&&this.onAnnotationEditor(r.constructor._type)}has(e){return this.#r.has(e)}get size(){return this.#r.size}#n(){this.#e||(this.#e=!0,typeof this.onSetModified=="function"&&this.onSetModified())}resetModified(){this.#e&&(this.#e=!1,typeof this.onResetModified=="function"&&this.onResetModified())}get print(){return new IMe(this)}get serializable(){if(this.#r.size===0)return zee;const e=new Map,r=new OMe,n=[],i=Object.create(null);let a=!1;for(const[s,o]of this.#r){const l=o instanceof ti?o.serialize(!1,i):o;l&&(e.set(s,l),r.update(`${s}:${JSON.stringify(l)}`),a||=!!l.bitmap)}if(a)for(const s of e.values())s.bitmap&&n.push(s.bitmap);return e.size>0?{map:e,hash:r.hexdigest(),transfer:n}:zee}get editorStats(){let e=null;const r=new Map;for(const n of this.#r.values()){if(!(n instanceof ti))continue;const i=n.telemetryFinalData;if(!i)continue;const{type:a}=i;r.has(a)||r.set(a,Object.getPrototypeOf(n).constructor),e||=Object.create(null);const s=e[a]||=new Map;for(const[o,l]of Object.entries(i)){if(o==="type")continue;let u=s.get(o);u||(u=new Map,s.set(o,u));const d=u.get(l)??0;u.set(l,d+1)}}for(const[n,i]of r)e[n]=i.computeTelemetryFinalData(e[n]);return e}resetModifiedIds(){this.#t=null}get modifiedIds(){if(this.#t)return this.#t;const e=[];for(const r of this.#r.values())!(r instanceof ti)||!r.annotationElementId||!r.serialize()||e.push(r.annotationElementId);return this.#t={ids:new Set(e),hash:e.join(",")}}[Symbol.iterator](){return this.#r.entries()}}class IMe extends iue{#e;constructor(e){super();const{map:r,hash:n,transfer:i}=e.serializable,a=structuredClone(r,i?{transfer:i}:null);this.#e={map:a,hash:n,transfer:i}}get print(){as("Should not call PrintAnnotationStorage.print")}get serializable(){return this.#e}get modifiedIds(){return na(this,"modifiedIds",{ids:new Set,hash:""})}}class vFt{#e=new Set;constructor({ownerDocument:e=globalThis.document,styleElement:r=null}){this._document=e,this.nativeFontFaces=new Set,this.styleElement=null,this.loadingRequests=[],this.loadTestFontId=0}addNativeFontFace(e){this.nativeFontFaces.add(e),this._document.fonts.add(e)}removeNativeFontFace(e){this.nativeFontFaces.delete(e),this._document.fonts.delete(e)}insertRule(e){this.styleElement||(this.styleElement=this._document.createElement("style"),this._document.documentElement.getElementsByTagName("head")[0].append(this.styleElement));const r=this.styleElement.sheet;r.insertRule(e,r.cssRules.length)}clear(){for(const e of this.nativeFontFaces)this._document.fonts.delete(e);this.nativeFontFaces.clear(),this.#e.clear(),this.styleElement&&(this.styleElement.remove(),this.styleElement=null)}async loadSystemFont({systemFontInfo:e,disableFontFace:r,_inspectFont:n}){if(!(!e||this.#e.has(e.loadedName))){if(Xo(!r,"loadSystemFont shouldn't be called when `disableFontFace` is set."),this.isFontLoadingAPISupported){const{loadedName:i,src:a,style:s}=e,o=new FontFace(i,a,s);this.addNativeFontFace(o);try{await o.load(),this.#e.add(i),n?.(e)}catch{ki(`Cannot load system font: ${e.baseFontName}, installing it could help to improve PDF rendering.`),this.removeNativeFontFace(o)}return}as("Not implemented: loadSystemFont without the Font Loading API.")}}async bind(e){if(e.attached||e.missingFile&&!e.systemFontInfo)return;if(e.attached=!0,e.systemFontInfo){await this.loadSystemFont(e);return}if(this.isFontLoadingAPISupported){const n=e.createNativeFontFace();if(n){this.addNativeFontFace(n);try{await n.loaded}catch(i){throw ki(`Failed to load font '${n.family}': '${i}'.`),e.disableFontFace=!0,i}}return}const r=e.createFontFaceRule();if(r){if(this.insertRule(r),this.isSyncFontLoadingSupported)return;await new Promise(n=>{const i=this._queueLoadingCallback(n);this._prepareFontLoadEvent(e,i)})}}get isFontLoadingAPISupported(){const e=!!this._document?.fonts;return na(this,"isFontLoadingAPISupported",e)}get isSyncFontLoadingSupported(){return na(this,"isSyncFontLoadingSupported",pu||Sc.platform.isFirefox)}_queueLoadingCallback(e){function r(){for(Xo(!i.done,"completeRequest() cannot be called twice."),i.done=!0;n.length>0&&n[0].done;){const a=n.shift();setTimeout(a.callback,0)}}const{loadingRequests:n}=this,i={done:!1,complete:r,callback:e};return n.push(i),i}get _loadTestFont(){const e=atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQAFQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAAALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgAAAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACMAooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4DIP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAAAAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUAAQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgABAAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABYAAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAAAC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAAAAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQACAQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTjFQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==");return na(this,"_loadTestFont",e)}_prepareFontLoadEvent(e,r){function n(E,T){return E.charCodeAt(T)<<24|E.charCodeAt(T+1)<<16|E.charCodeAt(T+2)<<8|E.charCodeAt(T+3)&255}function i(E,T,C,w){const x=E.substring(0,T),A=E.substring(T+C);return x+w+A}let a,s;const o=this._document.createElement("canvas");o.width=1,o.height=1;const l=o.getContext("2d");let u=0;function d(E,T){if(++u>30){ki("Load test font never loaded."),T();return}if(l.font="30px "+E,l.fillText(".",0,20),l.getImageData(0,0,1,1).data[3]>0){T();return}setTimeout(d.bind(null,E,T))}const h=`lt${Date.now()}${this.loadTestFontId++}`;let f=this._loadTestFont;f=i(f,976,h.length,h);const g=16,m=1482184792;let _=n(f,g);for(a=0,s=h.length-3;a{y.remove(),r.complete()})}}class yFt{constructor(e,r=null){this.compiledGlyphs=Object.create(null);for(const n in e)this[n]=e[n];this._inspectFont=r}createNativeFontFace(){if(!this.data||this.disableFontFace)return null;let e;if(!this.cssFontInfo)e=new FontFace(this.loadedName,this.data,{});else{const r={weight:this.cssFontInfo.fontWeight};this.cssFontInfo.italicAngle&&(r.style=`oblique ${this.cssFontInfo.italicAngle}deg`),e=new FontFace(this.cssFontInfo.fontFamily,this.data,r)}return this._inspectFont?.(this),e}createFontFaceRule(){if(!this.data||this.disableFontFace)return null;const e=`url(data:${this.mimetype};base64,${RMe(this.data)});`;let r;if(!this.cssFontInfo)r=`@font-face {font-family:"${this.loadedName}";src:${e}}`;else{let n=`font-weight: ${this.cssFontInfo.fontWeight};`;this.cssFontInfo.italicAngle&&(n+=`font-style: oblique ${this.cssFontInfo.italicAngle}deg;`),r=`@font-face {font-family:"${this.cssFontInfo.fontFamily}";${n}src:${e}}`}return this._inspectFont?.(this,e),r}getPathGenerator(e,r){if(this.compiledGlyphs[r]!==void 0)return this.compiledGlyphs[r];const n=this.loadedName+"_path_"+r;let i;try{i=e.get(n)}catch(s){ki(`getPathGenerator - ignoring character: "${s}".`)}const a=new Path2D(i||"");return this.fontExtraProperties||e.delete(n),this.compiledGlyphs[r]=a}}function bFt(t){if(t instanceof URL)return t.href;if(typeof t=="string"){if(pu)return t;const e=URL.parse(t,window.location);if(e)return e.href}throw new Error("Invalid PDF url data: either string or URL-object is expected in the url property.")}function SFt(t){if(pu&&typeof Buffer<"u"&&t instanceof Buffer)throw new Error("Please provide binary data as `Uint8Array`, rather than `Buffer`.");if(t instanceof Uint8Array&&t.byteLength===t.buffer.byteLength)return t;if(typeof t=="string")return K8(t);if(t instanceof ArrayBuffer||ArrayBuffer.isView(t)||typeof t=="object"&&!isNaN(t?.length))return new Uint8Array(t);throw new Error("Invalid PDF binary data: either TypedArray, string, or array-like object is expected in the data property.")}function HI(t){if(typeof t!="string")return null;if(t.endsWith("/"))return t;throw new Error(`Invalid factory url: "${t}" must include trailing slash.`)}const qee=t=>typeof t=="object"&&Number.isInteger(t?.num)&&t.num>=0&&Number.isInteger(t?.gen)&&t.gen>=0,EFt=t=>typeof t=="object"&&typeof t?.name=="string",TFt=oFt.bind(null,qee,EFt);class CFt{#e=new Map;#t=Promise.resolve();postMessage(e,r){const n={data:structuredClone(e,r?{transfer:r}:null)};this.#t.then(()=>{for(const[i]of this.#e)i.call(this,n)})}addEventListener(e,r,n=null){let i=null;if(n?.signal instanceof AbortSignal){const{signal:a}=n;if(a.aborted){ki("LoopbackPort - cannot use an `aborted` signal.");return}const s=()=>this.removeEventListener(e,r);i=()=>a.removeEventListener("abort",s),a.addEventListener("abort",s)}this.#e.set(r,i)}removeEventListener(e,r){this.#e.get(r)?.(),this.#e.delete(r)}terminate(){for(const[,e]of this.#e)e?.();this.#e.clear()}}const VI={DATA:1,ERROR:2},zo={CANCEL:1,CANCEL_COMPLETE:2,CLOSE:3,ENQUEUE:4,ERROR:5,PULL:6,PULL_COMPLETE:7,START_COMPLETE:8};function tTe(){}function id(t){if(t instanceof Q_||t instanceof Uee||t instanceof QEe||t instanceof TP||t instanceof FK)return t;switch(t instanceof Error||typeof t=="object"&&t!==null||as('wrapReason: Expected "reason" to be a (possibly cloned) Error.'),t.name){case"AbortException":return new Q_(t.message);case"InvalidPDFException":return new Uee(t.message);case"PasswordException":return new QEe(t.message,t.code);case"ResponseException":return new TP(t.message,t.status,t.missing);case"UnknownErrorException":return new FK(t.message,t.details)}return new FK(t.message,t.toString())}class q6{#e=new AbortController;constructor(e,r,n){this.sourceName=e,this.targetName=r,this.comObj=n,this.callbackId=1,this.streamId=1,this.streamSinks=Object.create(null),this.streamControllers=Object.create(null),this.callbackCapabilities=Object.create(null),this.actionHandler=Object.create(null),n.addEventListener("message",this.#t.bind(this),{signal:this.#e.signal})}#t({data:e}){if(e.targetName!==this.sourceName)return;if(e.stream){this.#n(e);return}if(e.callback){const n=e.callbackId,i=this.callbackCapabilities[n];if(!i)throw new Error(`Cannot resolve callback ${n}`);if(delete this.callbackCapabilities[n],e.callback===VI.DATA)i.resolve(e.data);else if(e.callback===VI.ERROR)i.reject(id(e.reason));else throw new Error("Unexpected callback case");return}const r=this.actionHandler[e.action];if(!r)throw new Error(`Unknown action from worker: ${e.action}`);if(e.callbackId){const n=this.sourceName,i=e.sourceName,a=this.comObj;Promise.try(r,e.data).then(function(s){a.postMessage({sourceName:n,targetName:i,callback:VI.DATA,callbackId:e.callbackId,data:s})},function(s){a.postMessage({sourceName:n,targetName:i,callback:VI.ERROR,callbackId:e.callbackId,reason:id(s)})});return}if(e.streamId){this.#r(e);return}r(e.data)}on(e,r){const n=this.actionHandler;if(n[e])throw new Error(`There is already an actionName called "${e}"`);n[e]=r}send(e,r,n){this.comObj.postMessage({sourceName:this.sourceName,targetName:this.targetName,action:e,data:r},n)}sendWithPromise(e,r,n){const i=this.callbackId++,a=Promise.withResolvers();this.callbackCapabilities[i]=a;try{this.comObj.postMessage({sourceName:this.sourceName,targetName:this.targetName,action:e,callbackId:i,data:r},n)}catch(s){a.reject(s)}return a.promise}sendWithStream(e,r,n,i){const a=this.streamId++,s=this.sourceName,o=this.targetName,l=this.comObj;return new ReadableStream({start:u=>{const d=Promise.withResolvers();return this.streamControllers[a]={controller:u,startCall:d,pullCall:null,cancelCall:null,isClosed:!1},l.postMessage({sourceName:s,targetName:o,action:e,streamId:a,data:r,desiredSize:u.desiredSize},i),d.promise},pull:u=>{const d=Promise.withResolvers();return this.streamControllers[a].pullCall=d,l.postMessage({sourceName:s,targetName:o,stream:zo.PULL,streamId:a,desiredSize:u.desiredSize}),d.promise},cancel:u=>{Xo(u instanceof Error,"cancel must have a valid reason");const d=Promise.withResolvers();return this.streamControllers[a].cancelCall=d,this.streamControllers[a].isClosed=!0,l.postMessage({sourceName:s,targetName:o,stream:zo.CANCEL,streamId:a,reason:id(u)}),d.promise}},n)}#r(e){const r=e.streamId,n=this.sourceName,i=e.sourceName,a=this.comObj,s=this,o=this.actionHandler[e.action],l={enqueue(u,d=1,h){if(this.isCancelled)return;const f=this.desiredSize;this.desiredSize-=d,f>0&&this.desiredSize<=0&&(this.sinkCapability=Promise.withResolvers(),this.ready=this.sinkCapability.promise),a.postMessage({sourceName:n,targetName:i,stream:zo.ENQUEUE,streamId:r,chunk:u},h)},close(){this.isCancelled||(this.isCancelled=!0,a.postMessage({sourceName:n,targetName:i,stream:zo.CLOSE,streamId:r}),delete s.streamSinks[r])},error(u){Xo(u instanceof Error,"error must have a valid reason"),!this.isCancelled&&(this.isCancelled=!0,a.postMessage({sourceName:n,targetName:i,stream:zo.ERROR,streamId:r,reason:id(u)}))},sinkCapability:Promise.withResolvers(),onPull:null,onCancel:null,isCancelled:!1,desiredSize:e.desiredSize,ready:null};l.sinkCapability.resolve(),l.ready=l.sinkCapability.promise,this.streamSinks[r]=l,Promise.try(o,e.data,l).then(function(){a.postMessage({sourceName:n,targetName:i,stream:zo.START_COMPLETE,streamId:r,success:!0})},function(u){a.postMessage({sourceName:n,targetName:i,stream:zo.START_COMPLETE,streamId:r,reason:id(u)})})}#n(e){const r=e.streamId,n=this.sourceName,i=e.sourceName,a=this.comObj,s=this.streamControllers[r],o=this.streamSinks[r];switch(e.stream){case zo.START_COMPLETE:e.success?s.startCall.resolve():s.startCall.reject(id(e.reason));break;case zo.PULL_COMPLETE:e.success?s.pullCall.resolve():s.pullCall.reject(id(e.reason));break;case zo.PULL:if(!o){a.postMessage({sourceName:n,targetName:i,stream:zo.PULL_COMPLETE,streamId:r,success:!0});break}o.desiredSize<=0&&e.desiredSize>0&&o.sinkCapability.resolve(),o.desiredSize=e.desiredSize,Promise.try(o.onPull||tTe).then(function(){a.postMessage({sourceName:n,targetName:i,stream:zo.PULL_COMPLETE,streamId:r,success:!0})},function(u){a.postMessage({sourceName:n,targetName:i,stream:zo.PULL_COMPLETE,streamId:r,reason:id(u)})});break;case zo.ENQUEUE:if(Xo(s,"enqueue should have stream controller"),s.isClosed)break;s.controller.enqueue(e.chunk);break;case zo.CLOSE:if(Xo(s,"close should have stream controller"),s.isClosed)break;s.isClosed=!0,s.controller.close(),this.#i(s,r);break;case zo.ERROR:Xo(s,"error should have stream controller"),s.controller.error(id(e.reason)),this.#i(s,r);break;case zo.CANCEL_COMPLETE:e.success?s.cancelCall.resolve():s.cancelCall.reject(id(e.reason)),this.#i(s,r);break;case zo.CANCEL:if(!o)break;const l=id(e.reason);Promise.try(o.onCancel||tTe,l).then(function(){a.postMessage({sourceName:n,targetName:i,stream:zo.CANCEL_COMPLETE,streamId:r,success:!0})},function(u){a.postMessage({sourceName:n,targetName:i,stream:zo.CANCEL_COMPLETE,streamId:r,reason:id(u)})}),o.sinkCapability.reject(l),o.isCancelled=!0,delete this.streamSinks[r];break;default:throw new Error("Unexpected stream case")}}async#i(e,r){await Promise.allSettled([e.startCall?.promise,e.pullCall?.promise,e.cancelCall?.promise]),delete this.streamControllers[r]}destroy(){this.#e?.abort(),this.#e=null}}class kMe{#e=!1;constructor({enableHWA:e=!1}){this.#e=e}create(e,r){if(e<=0||r<=0)throw new Error("Invalid canvas size");const n=this._createCanvas(e,r);return{canvas:n,context:n.getContext("2d",{willReadFrequently:!this.#e})}}reset(e,r,n){if(!e.canvas)throw new Error("Canvas is not specified");if(r<=0||n<=0)throw new Error("Invalid canvas size");e.canvas.width=r,e.canvas.height=n}destroy(e){if(!e.canvas)throw new Error("Canvas is not specified");e.canvas.width=0,e.canvas.height=0,e.canvas=null,e.context=null}_createCanvas(e,r){as("Abstract method `_createCanvas` called.")}}class wFt extends kMe{constructor({ownerDocument:e=globalThis.document,enableHWA:r=!1}){super({enableHWA:r}),this._document=e}_createCanvas(e,r){const n=this._document.createElement("canvas");return n.width=e,n.height=r,n}}class DMe{constructor({baseUrl:e=null,isCompressed:r=!0}){this.baseUrl=e,this.isCompressed=r}async fetch({name:e}){if(!this.baseUrl)throw new Error("Ensure that the `cMapUrl` and `cMapPacked` API parameters are provided.");if(!e)throw new Error("CMap name must be specified.");const r=this.baseUrl+e+(this.isCompressed?".bcmap":"");return this._fetch(r).then(n=>({cMapData:n,isCompressed:this.isCompressed})).catch(n=>{throw new Error(`Unable to load ${this.isCompressed?"binary ":""}CMap at: ${r}`)})}async _fetch(e){as("Abstract method `_fetch` called.")}}class rTe extends DMe{async _fetch(e){const r=await j8(e,this.isCompressed?"arraybuffer":"text");return r instanceof ArrayBuffer?new Uint8Array(r):K8(r)}}class MMe{addFilter(e){return"none"}addHCMFilter(e,r){return"none"}addAlphaFilter(e){return"none"}addLuminosityFilter(e){return"none"}addHighlightHCMFilter(e,r,n,i,a){return"none"}destroy(e=!1){}}class xFt extends MMe{#e;#t;#r;#n;#i;#a;#s=0;constructor({docId:e,ownerDocument:r=globalThis.document}){super(),this.#n=e,this.#i=r}get#o(){return this.#t||=new Map}get#l(){return this.#a||=new Map}get#c(){if(!this.#r){const e=this.#i.createElement("div"),{style:r}=e;r.visibility="hidden",r.contain="strict",r.width=r.height=0,r.position="absolute",r.top=r.left=0,r.zIndex=-1;const n=this.#i.createElementNS(Hm,"svg");n.setAttribute("width",0),n.setAttribute("height",0),this.#r=this.#i.createElementNS(Hm,"defs"),e.append(n),n.append(this.#r),this.#i.body.append(e)}return this.#r}#d(e){if(e.length===1){const l=e[0],u=new Array(256);for(let h=0;h<256;h++)u[h]=l[h]/255;const d=u.join(",");return[d,d,d]}const[r,n,i]=e,a=new Array(256),s=new Array(256),o=new Array(256);for(let l=0;l<256;l++)a[l]=r[l]/255,s[l]=n[l]/255,o[l]=i[l]/255;return[a.join(","),s.join(","),o.join(",")]}#u(e){if(this.#e===void 0){this.#e="";const r=this.#i.URL;r!==this.#i.baseURI&&(g$(r)?ki('#createUrl: ignore "data:"-URL for performance reasons.'):this.#e=wMe(r,""))}return`url(${this.#e}#${e})`}addFilter(e){if(!e)return"none";let r=this.#o.get(e);if(r)return r;const[n,i,a]=this.#d(e),s=e.length===1?n:`${n}${i}${a}`;if(r=this.#o.get(s),r)return this.#o.set(e,r),r;const o=`g_${this.#n}_transfer_map_${this.#s++}`,l=this.#u(o);this.#o.set(e,l),this.#o.set(s,l);const u=this.#f(o);return this.#m(n,i,a,u),l}addHCMFilter(e,r){const n=`${e}-${r}`,i="base";let a=this.#l.get(i);if(a?.key===n||(a?(a.filter?.remove(),a.key=n,a.url="none",a.filter=null):(a={key:n,url:"none",filter:null},this.#l.set(i,a)),!e||!r))return a.url;const s=this.#_(e);e=Xn.makeHexColor(...s);const o=this.#_(r);if(r=Xn.makeHexColor(...o),this.#c.style.color="",e==="#000000"&&r==="#ffffff"||e===r)return a.url;const l=new Array(256);for(let p=0;p<=255;p++){const g=p/255;l[p]=g<=.03928?g/12.92:((g+.055)/1.055)**2.4}const u=l.join(","),d=`g_${this.#n}_hcm_filter`,h=a.filter=this.#f(d);this.#m(u,u,u,h),this.#g(h);const f=(p,g)=>{const m=s[p]/255,_=o[p]/255,v=new Array(g+1);for(let b=0;b<=g;b++)v[b]=m+b/g*(_-m);return v.join(",")};return this.#m(f(0,5),f(1,5),f(2,5),h),a.url=this.#u(d),a.url}addAlphaFilter(e){let r=this.#o.get(e);if(r)return r;const[n]=this.#d([e]),i=`alpha_${n}`;if(r=this.#o.get(i),r)return this.#o.set(e,r),r;const a=`g_${this.#n}_alpha_map_${this.#s++}`,s=this.#u(a);this.#o.set(e,s),this.#o.set(i,s);const o=this.#f(a);return this.#v(n,o),s}addLuminosityFilter(e){let r=this.#o.get(e||"luminosity");if(r)return r;let n,i;if(e?([n]=this.#d([e]),i=`luminosity_${n}`):i="luminosity",r=this.#o.get(i),r)return this.#o.set(e,r),r;const a=`g_${this.#n}_luminosity_map_${this.#s++}`,s=this.#u(a);this.#o.set(e,s),this.#o.set(i,s);const o=this.#f(a);return this.#p(o),e&&this.#v(n,o),s}addHighlightHCMFilter(e,r,n,i,a){const s=`${r}-${n}-${i}-${a}`;let o=this.#l.get(e);if(o?.key===s||(o?(o.filter?.remove(),o.key=s,o.url="none",o.filter=null):(o={key:s,url:"none",filter:null},this.#l.set(e,o)),!r||!n))return o.url;const[l,u]=[r,n].map(this.#_.bind(this));let d=Math.round(.2126*l[0]+.7152*l[1]+.0722*l[2]),h=Math.round(.2126*u[0]+.7152*u[1]+.0722*u[2]),[f,p]=[i,a].map(this.#_.bind(this));h{const E=new Array(256),T=(h-d)/y,C=v/255,w=(b-v)/(255*y);let x=0;for(let A=0;A<=y;A++){const R=Math.round(d+A*T),O=C+A*w;for(let F=x;F<=R;F++)E[F]=O;x=R+1}for(let A=x;A<256;A++)E[A]=E[x-1];return E.join(",")},m=`g_${this.#n}_hcm_${e}_filter`,_=o.filter=this.#f(m);return this.#g(_),this.#m(g(f[0],p[0],5),g(f[1],p[1],5),g(f[2],p[2],5),_),o.url=this.#u(m),o.url}destroy(e=!1){e&&this.#a?.size||(this.#r?.parentNode.parentNode.remove(),this.#r=null,this.#t?.clear(),this.#t=null,this.#a?.clear(),this.#a=null,this.#s=0)}#p(e){const r=this.#i.createElementNS(Hm,"feColorMatrix");r.setAttribute("type","matrix"),r.setAttribute("values","0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.3 0.59 0.11 0 0"),e.append(r)}#g(e){const r=this.#i.createElementNS(Hm,"feColorMatrix");r.setAttribute("type","matrix"),r.setAttribute("values","0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0 0 0 1 0"),e.append(r)}#f(e){const r=this.#i.createElementNS(Hm,"filter");return r.setAttribute("color-interpolation-filters","sRGB"),r.setAttribute("id",e),this.#c.append(r),r}#h(e,r,n){const i=this.#i.createElementNS(Hm,r);i.setAttribute("type","discrete"),i.setAttribute("tableValues",n),e.append(i)}#m(e,r,n,i){const a=this.#i.createElementNS(Hm,"feComponentTransfer");i.append(a),this.#h(a,"feFuncR",e),this.#h(a,"feFuncG",r),this.#h(a,"feFuncB",n)}#v(e,r){const n=this.#i.createElementNS(Hm,"feComponentTransfer");r.append(n),this.#h(n,"feFuncA",e)}#_(e){return this.#c.style.color=e,m$(getComputedStyle(this.#c).getPropertyValue("color"))}}class LMe{constructor({baseUrl:e=null}){this.baseUrl=e}async fetch({filename:e}){if(!this.baseUrl)throw new Error("Ensure that the `standardFontDataUrl` API parameter is provided.");if(!e)throw new Error("Font filename must be specified.");const r=`${this.baseUrl}${e}`;return this._fetch(r).catch(n=>{throw new Error(`Unable to load font data at: ${r}`)})}async _fetch(e){as("Abstract method `_fetch` called.")}}class nTe extends LMe{async _fetch(e){const r=await j8(e,"arraybuffer");return new Uint8Array(r)}}class PMe{constructor({baseUrl:e=null}){this.baseUrl=e}async fetch({filename:e}){if(!this.baseUrl)throw new Error("Ensure that the `wasmUrl` API parameter is provided.");if(!e)throw new Error("Wasm filename must be specified.");const r=`${this.baseUrl}${e}`;return this._fetch(r).catch(n=>{throw new Error(`Unable to load wasm data at: ${r}`)})}async _fetch(e){as("Abstract method `_fetch` called.")}}class iTe extends PMe{async _fetch(e){const r=await j8(e,"arraybuffer");return new Uint8Array(r)}}pu&&ki("Please use the `legacy` build in Node.js environments.");async function aue(t){const r=await process.getBuiltinModule("fs").promises.readFile(t);return new Uint8Array(r)}class AFt extends MMe{}class RFt extends kMe{_createCanvas(e,r){return process.getBuiltinModule("module").createRequire(import.meta.url)("@napi-rs/canvas").createCanvas(e,r)}}class NFt extends DMe{async _fetch(e){return aue(e)}}class OFt extends LMe{async _fetch(e){return aue(e)}}class IFt extends PMe{async _fetch(e){return aue(e)}}const hc={FILL:"Fill",STROKE:"Stroke",SHADING:"Shading"};function Hee(t,e){if(!e)return;const r=e[2]-e[0],n=e[3]-e[1],i=new Path2D;i.rect(e[0],e[1],r,n),t.clip(i)}class sue{isModifyingCurrentTransform(){return!1}getPattern(){as("Abstract method `getPattern` called.")}}class kFt extends sue{constructor(e){super(),this._type=e[1],this._bbox=e[2],this._colorStops=e[3],this._p0=e[4],this._p1=e[5],this._r0=e[6],this._r1=e[7],this.matrix=null}_createGradient(e){let r;this._type==="axial"?r=e.createLinearGradient(this._p0[0],this._p0[1],this._p1[0],this._p1[1]):this._type==="radial"&&(r=e.createRadialGradient(this._p0[0],this._p0[1],this._r0,this._p1[0],this._p1[1],this._r1));for(const n of this._colorStops)r.addColorStop(n[0],n[1]);return r}getPattern(e,r,n,i){let a;if(i===hc.STROKE||i===hc.FILL){const s=r.current.getClippedPathBoundingBox(i,to(e))||[0,0,0,0],o=Math.ceil(s[2]-s[0])||1,l=Math.ceil(s[3]-s[1])||1,u=r.cachedCanvases.getCanvas("pattern",o,l),d=u.context;d.clearRect(0,0,d.canvas.width,d.canvas.height),d.beginPath(),d.rect(0,0,d.canvas.width,d.canvas.height),d.translate(-s[0],-s[1]),n=Xn.transform(n,[1,0,0,1,s[0],s[1]]),d.transform(...r.baseTransform),this.matrix&&d.transform(...this.matrix),Hee(d,this._bbox),d.fillStyle=this._createGradient(d),d.fill(),a=e.createPattern(u.canvas,"no-repeat");const h=new DOMMatrix(n);a.setTransform(h)}else Hee(e,this._bbox),a=this._createGradient(e);return a}}function $K(t,e,r,n,i,a,s,o){const l=e.coords,u=e.colors,d=t.data,h=t.width*4;let f;l[r+1]>l[n+1]&&(f=r,r=n,n=f,f=a,a=s,s=f),l[n+1]>l[i+1]&&(f=n,n=i,i=f,f=s,s=o,o=f),l[r+1]>l[n+1]&&(f=r,r=n,n=f,f=a,a=s,s=f);const p=(l[r]+e.offsetX)*e.scaleX,g=(l[r+1]+e.offsetY)*e.scaleY,m=(l[n]+e.offsetX)*e.scaleX,_=(l[n+1]+e.offsetY)*e.scaleY,v=(l[i]+e.offsetX)*e.scaleX,b=(l[i+1]+e.offsetY)*e.scaleY;if(g>=b)return;const y=u[a],E=u[a+1],T=u[a+2],C=u[s],w=u[s+1],x=u[s+2],A=u[o],R=u[o+1],O=u[o+2],F=Math.round(g),P=Math.round(b);let N,k,M,L,I,U,B,$;for(let H=F;H<=P;H++){if(H<_){const Q=Hb?Q=1:_===b?Q=0:Q=(_-H)/(_-b),N=m-(m-v)*Q,k=C-(C-A)*Q,M=w-(w-R)*Q,L=x-(x-O)*Q}let q;Hb?q=1:q=(g-H)/(g-b),I=p-(p-v)*q,U=y-(y-A)*q,B=E-(E-R)*q,$=T-(T-O)*q;const V=Math.round(Math.min(N,I)),Y=Math.round(Math.max(N,I));let j=h*H+V*4;for(let Q=V;Q<=Y;Q++)q=(N-Q)/(N-I),q<0?q=0:q>1&&(q=1),d[j++]=k-(k-U)*q|0,d[j++]=M-(M-B)*q|0,d[j++]=L-(L-$)*q|0,d[j++]=255}}function DFt(t,e,r){const n=e.coords,i=e.colors;let a,s;switch(e.type){case"lattice":const o=e.verticesPerRow,l=Math.floor(n.length/o)-1,u=o-1;for(a=0;a=O?T=l:w=!0,R>=F?C=u:x=!0;const P=this.getSizeAndScale(T,this.ctx.canvas.width,y),N=this.getSizeAndScale(C,this.ctx.canvas.height,E),k=e.cachedCanvases.getCanvas("pattern",P.size,N.size),M=k.context,L=o.createCanvasGraphics(M);if(L.groupLevel=e.groupLevel,this.setFillAndStrokeStyleToContext(L,i,s),M.translate(-P.scale*d,-N.scale*h),L.transform(P.scale,0,0,N.scale,0,0),M.save(),this.clipBbox(L,d,h,f,p),L.baseTransform=to(L.ctx),L.executeOperatorList(n),L.endDrawing(),M.restore(),w||x){const I=k.canvas;w&&(T=l),x&&(C=u);const U=this.getSizeAndScale(T,this.ctx.canvas.width,y),B=this.getSizeAndScale(C,this.ctx.canvas.height,E),$=U.size,H=B.size,q=e.cachedCanvases.getCanvas("pattern-workaround",$,H),V=q.context,Y=w?Math.floor(g/l):0,j=x?Math.floor(m/u):0;for(let Q=0;Q<=Y;Q++)for(let ae=0;ae<=j;ae++)V.drawImage(I,$*Q,H*ae,$,H,0,0,$,H);return{canvas:q.canvas,scaleX:U.scale,scaleY:B.scale,offsetX:d,offsetY:h}}return{canvas:k.canvas,scaleX:P.scale,scaleY:N.scale,offsetX:d,offsetY:h}}getSizeAndScale(e,r,n){const i=Math.max(oue.MAX_PATTERN_SIZE,r);let a=Math.ceil(e*n);return a>=i?a=i:n=a/e,{scale:n,size:a}}clipBbox(e,r,n,i,a){const s=i-r,o=a-n;e.ctx.rect(r,n,s,o),Xn.axialAlignedBoundingBox([r,n,i,a],to(e.ctx),e.current.minMax),e.clip(),e.endPath()}setFillAndStrokeStyleToContext(e,r,n){const i=e.ctx,a=e.current;switch(r){case aTe.COLORED:const{fillStyle:s,strokeStyle:o}=this.ctx;i.fillStyle=a.fillColor=s,i.strokeStyle=a.strokeColor=o;break;case aTe.UNCOLORED:i.fillStyle=i.strokeStyle=n,a.fillColor=a.strokeColor=n;break;default:throw new tFt(`Unsupported paint type: ${r}`)}}isModifyingCurrentTransform(){return!1}getPattern(e,r,n,i){let a=n;i!==hc.SHADING&&(a=Xn.transform(a,r.baseTransform),this.matrix&&(a=Xn.transform(a,this.matrix)));const s=this.createPatternCanvas(r);let o=new DOMMatrix(a);o=o.translate(s.offsetX,s.offsetY),o=o.scale(1/s.scaleX,1/s.scaleY);const l=e.createPattern(s.canvas,"repeat");return l.setTransform(o),l}}function FFt({src:t,srcPos:e=0,dest:r,width:n,height:i,nonBlackColor:a=4294967295,inverseDecode:s=!1}){const o=Sc.isLittleEndian?4278190080:255,[l,u]=s?[a,o]:[o,a],d=n>>3,h=n&7,f=t.length;r=new Uint32Array(r.buffer);let p=0;for(let g=0;g{t.save=t.__originalSave,t.restore=t.__originalRestore,t.rotate=t.__originalRotate,t.scale=t.__originalScale,t.translate=t.__originalTranslate,t.transform=t.__originalTransform,t.setTransform=t.__originalSetTransform,t.resetTransform=t.__originalResetTransform,t.clip=t.__originalClip,t.moveTo=t.__originalMoveTo,t.lineTo=t.__originalLineTo,t.bezierCurveTo=t.__originalBezierCurveTo,t.rect=t.__originalRect,t.closePath=t.__originalClosePath,t.beginPath=t.__originalBeginPath,delete t._removeMirroring},t.save=function(){e.save(),this.__originalSave()},t.restore=function(){e.restore(),this.__originalRestore()},t.translate=function(r,n){e.translate(r,n),this.__originalTranslate(r,n)},t.scale=function(r,n){e.scale(r,n),this.__originalScale(r,n)},t.transform=function(r,n,i,a,s,o){e.transform(r,n,i,a,s,o),this.__originalTransform(r,n,i,a,s,o)},t.setTransform=function(r,n,i,a,s,o){e.setTransform(r,n,i,a,s,o),this.__originalSetTransform(r,n,i,a,s,o)},t.resetTransform=function(){e.resetTransform(),this.__originalResetTransform()},t.rotate=function(r){e.rotate(r),this.__originalRotate(r)},t.clip=function(r){e.clip(r),this.__originalClip(r)},t.moveTo=function(r,n){e.moveTo(r,n),this.__originalMoveTo(r,n)},t.lineTo=function(r,n){e.lineTo(r,n),this.__originalLineTo(r,n)},t.bezierCurveTo=function(r,n,i,a,s,o){e.bezierCurveTo(r,n,i,a,s,o),this.__originalBezierCurveTo(r,n,i,a,s,o)},t.rect=function(r,n,i,a){e.rect(r,n,i,a),this.__originalRect(r,n,i,a)},t.closePath=function(){e.closePath(),this.__originalClosePath()},t.beginPath=function(){e.beginPath(),this.__originalBeginPath()}}class $Ft{constructor(e){this.canvasFactory=e,this.cache=Object.create(null)}getCanvas(e,r,n){let i;return this.cache[e]!==void 0?(i=this.cache[e],this.canvasFactory.reset(i,r,n)):(i=this.canvasFactory.create(r,n),this.cache[e]=i),i}delete(e){delete this.cache[e]}clear(){for(const e in this.cache){const r=this.cache[e];this.canvasFactory.destroy(r),delete this.cache[e]}}}function YI(t,e,r,n,i,a,s,o,l,u){const[d,h,f,p,g,m]=to(t);if(h===0&&f===0){const b=s*d+g,y=Math.round(b),E=o*p+m,T=Math.round(E),C=(s+l)*d+g,w=Math.abs(Math.round(C)-y)||1,x=(o+u)*p+m,A=Math.abs(Math.round(x)-T)||1;return t.setTransform(Math.sign(d),0,0,Math.sign(p),y,T),t.drawImage(e,r,n,i,a,0,0,w,A),t.setTransform(d,h,f,p,g,m),[w,A]}if(d===0&&p===0){const b=o*f+g,y=Math.round(b),E=s*h+m,T=Math.round(E),C=(o+u)*f+g,w=Math.abs(Math.round(C)-y)||1,x=(s+l)*h+m,A=Math.abs(Math.round(x)-T)||1;return t.setTransform(0,Math.sign(h),Math.sign(f),0,y,T),t.drawImage(e,r,n,i,a,0,0,A,w),t.setTransform(d,h,f,p,g,m),[A,w]}t.drawImage(e,r,n,i,a,s,o,l,u);const _=Math.hypot(d,h),v=Math.hypot(f,p);return[_*l,v*u]}class cTe{alphaIsShape=!1;fontSize=0;fontSizeScale=1;textMatrix=null;textMatrixScale=1;fontMatrix=Bee;leading=0;x=0;y=0;lineX=0;lineY=0;charSpacing=0;wordSpacing=0;textHScale=1;textRenderingMode=Fc.FILL;textRise=0;fillColor="#000000";strokeColor="#000000";patternFill=!1;patternStroke=!1;fillAlpha=1;strokeAlpha=1;lineWidth=1;activeSMask=null;transferMaps="none";constructor(e,r){this.clipBox=new Float32Array([0,0,e,r]),this.minMax=gT.slice()}clone(){const e=Object.create(this);return e.clipBox=this.clipBox.slice(),e.minMax=this.minMax.slice(),e}getPathBoundingBox(e=hc.FILL,r=null){const n=this.minMax.slice();if(e===hc.STROKE){r||as("Stroke bounding box must include transform."),Xn.singularValueDecompose2dScale(r,Kd);const i=Kd[0]*this.lineWidth/2,a=Kd[1]*this.lineWidth/2;n[0]-=i,n[1]-=a,n[2]+=i,n[3]+=a}return n}updateClipFromPath(){const e=Xn.intersect(this.clipBox,this.getPathBoundingBox());this.startNewPathAndClipBox(e||[0,0,0,0])}isEmptyClip(){return this.minMax[0]===1/0}startNewPathAndClipBox(e){this.clipBox.set(e,0),this.minMax.set(gT,0)}getClippedPathBoundingBox(e=hc.FILL,r=null){return Xn.intersect(this.clipBox,this.getPathBoundingBox(e,r))}}function uTe(t,e){if(e instanceof ImageData){t.putImageData(e,0,0);return}const r=e.height,n=e.width,i=r%od,a=(r-i)/od,s=i===0?a:a+1,o=t.createImageData(n,od);let l=0,u;const d=e.data,h=o.data;let f,p,g,m;if(e.kind===FD.GRAYSCALE_1BPP){const _=d.byteLength,v=new Uint32Array(h.buffer,0,h.byteLength>>2),b=v.length,y=n+7>>3,E=4294967295,T=Sc.isLittleEndian?4278190080:255;for(f=0;fy?n:C*8-7,A=x&-8;let R=0,O=0;for(;w>=1}for(;u=a&&(g=i,m=n*g),u=0,p=m;p--;)h[u++]=d[l++],h[u++]=d[l++],h[u++]=d[l++],h[u++]=255;t.putImageData(o,0,f*od)}else throw new Error(`bad image kind: ${e.kind}`)}function dTe(t,e){if(e.bitmap){t.drawImage(e.bitmap,0,0);return}const r=e.height,n=e.width,i=r%od,a=(r-i)/od,s=i===0?a:a+1,o=t.createImageData(n,od);let l=0;const u=e.data,d=o.data;for(let h=0;hlTe&&typeof n=="function",d=u?Date.now()+BFt:0;let h=0;const f=this.commonObjs,p=this.objs;let g;for(;;){if(i!==void 0&&o===i.nextBreakPoint)return i.breakIt(o,n),o;if(g=s[o],g!==EP.dependency)this[g].apply(this,a[o]);else for(const m of a[o]){const _=m.startsWith("g_")?f:p;if(!_.has(m))return _.get(m,n),o}if(o++,o===l)return o;if(u&&++h>lTe){if(Date.now()>d)return n(),o;h=0}}}#e(){for(;this.stateStack.length||this.inSMaskMode;)this.restore();this.current.activeSMask=null,this.ctx.restore(),this.transparentCanvas&&(this.ctx=this.compositeCtx,this.ctx.save(),this.ctx.setTransform(1,0,0,1,0,0),this.ctx.drawImage(this.transparentCanvas,0,0),this.ctx.restore(),this.transparentCanvas=null)}endDrawing(){this.#e(),this.cachedCanvases.clear(),this.cachedPatterns.clear();for(const e of this._cachedBitmapsMap.values()){for(const r of e.values())typeof HTMLCanvasElement<"u"&&r instanceof HTMLCanvasElement&&(r.width=r.height=0);e.clear()}this._cachedBitmapsMap.clear(),this.#t()}#t(){if(this.pageColors){const e=this.filterFactory.addHCMFilter(this.pageColors.foreground,this.pageColors.background);if(e!=="none"){const r=this.ctx.filter;this.ctx.filter=e,this.ctx.drawImage(this.ctx.canvas,0,0),this.ctx.filter=r}}}_scaleImage(e,r){const n=e.width??e.displayWidth,i=e.height??e.displayHeight;let a=Math.max(Math.hypot(r[0],r[1]),1),s=Math.max(Math.hypot(r[2],r[3]),1),o=n,l=i,u="prescale1",d,h;for(;a>2&&o>1||s>2&&l>1;){let f=o,p=l;a>2&&o>1&&(f=o>=16384?Math.floor(o/2)-1||1:Math.ceil(o/2),a/=o/f),s>2&&l>1&&(p=l>=16384?Math.floor(l/2)-1||1:Math.ceil(l)/2,s/=l/p),d=this.cachedCanvases.getCanvas(u,f,p),h=d.context,h.clearRect(0,0,f,p),h.drawImage(e,0,0,o,l,0,0,f,p),e=d.canvas,o=f,l=p,u=u==="prescale1"?"prescale2":"prescale1"}return{img:e,paintWidth:o,paintHeight:l}}_createMaskCanvas(e){const r=this.ctx,{width:n,height:i}=e,a=this.current.fillColor,s=this.current.patternFill,o=to(r);let l,u,d,h;if((e.bitmap||e.data)&&e.count>1){const A=e.bitmap||e.data.buffer;u=JSON.stringify(s?o:[o.slice(0,4),a]),l=this._cachedBitmapsMap.get(A),l||(l=new Map,this._cachedBitmapsMap.set(A,l));const R=l.get(u);if(R&&!s){const O=Math.round(Math.min(o[0],o[2])+o[4]),F=Math.round(Math.min(o[1],o[3])+o[5]);return{canvas:R,offsetX:O,offsetY:F}}d=R}d||(h=this.cachedCanvases.getCanvas("maskCanvas",n,i),dTe(h.context,e));let f=Xn.transform(o,[1/n,0,0,-1/i,0,0]);f=Xn.transform(f,[1,0,0,1,0,-i]);const p=gT.slice();Xn.axialAlignedBoundingBox([0,0,n,i],f,p);const[g,m,_,v]=p,b=Math.round(_-g)||1,y=Math.round(v-m)||1,E=this.cachedCanvases.getCanvas("fillCanvas",b,y),T=E.context,C=g,w=m;T.translate(-C,-w),T.transform(...f),d||(d=this._scaleImage(h.canvas,Wp(T)),d=d.img,l&&s&&l.set(u,d)),T.imageSmoothingEnabled=hTe(to(T),e.interpolate),YI(T,d,0,0,d.width,d.height,0,0,n,i),T.globalCompositeOperation="source-in";const x=Xn.transform(Wp(T),[1,0,0,1,-C,-w]);return T.fillStyle=s?a.getPattern(r,this,x,hc.FILL):a,T.fillRect(0,0,n,i),l&&!s&&(this.cachedCanvases.delete("fillCanvas"),l.set(u,E.canvas)),{canvas:E.canvas,offsetX:Math.round(C),offsetY:Math.round(w)}}setLineWidth(e){e!==this.current.lineWidth&&(this._cachedScaleForStroking[0]=-1),this.current.lineWidth=e,this.ctx.lineWidth=e}setLineCap(e){this.ctx.lineCap=GFt[e]}setLineJoin(e){this.ctx.lineJoin=zFt[e]}setMiterLimit(e){this.ctx.miterLimit=e}setDash(e,r){const n=this.ctx;n.setLineDash!==void 0&&(n.setLineDash(e),n.lineDashOffset=r)}setRenderingIntent(e){}setFlatness(e){}setGState(e){for(const[r,n]of e)switch(r){case"LW":this.setLineWidth(n);break;case"LC":this.setLineCap(n);break;case"LJ":this.setLineJoin(n);break;case"ML":this.setMiterLimit(n);break;case"D":this.setDash(n[0],n[1]);break;case"RI":this.setRenderingIntent(n);break;case"FL":this.setFlatness(n);break;case"Font":this.setFont(n[0],n[1]);break;case"CA":this.current.strokeAlpha=n;break;case"ca":this.ctx.globalAlpha=this.current.fillAlpha=n;break;case"BM":this.ctx.globalCompositeOperation=n;break;case"SMask":this.current.activeSMask=n?this.tempSMask:null,this.tempSMask=null,this.checkSMaskState();break;case"TR":this.ctx.filter=this.current.transferMaps=this.filterFactory.addFilter(n);break}}get inSMaskMode(){return!!this.suspendedCtx}checkSMaskState(){const e=this.inSMaskMode;this.current.activeSMask&&!e?this.beginSMaskMode():!this.current.activeSMask&&e&&this.endSMaskMode()}beginSMaskMode(){if(this.inSMaskMode)throw new Error("beginSMaskMode called while already in smask mode");const e=this.ctx.canvas.width,r=this.ctx.canvas.height,n="smaskGroupAt"+this.groupLevel,i=this.cachedCanvases.getCanvas(n,e,r);this.suspendedCtx=this.ctx;const a=this.ctx=i.context;a.setTransform(this.suspendedCtx.getTransform()),PA(this.suspendedCtx,a),UFt(a,this.suspendedCtx),this.setGState([["BM","source-over"]])}endSMaskMode(){if(!this.inSMaskMode)throw new Error("endSMaskMode called while not in smask mode");this.ctx._removeMirroring(),PA(this.ctx,this.suspendedCtx),this.ctx=this.suspendedCtx,this.suspendedCtx=null}compose(e){if(!this.current.activeSMask)return;e?(e[0]=Math.floor(e[0]),e[1]=Math.floor(e[1]),e[2]=Math.ceil(e[2]),e[3]=Math.ceil(e[3])):e=[0,0,this.ctx.canvas.width,this.ctx.canvas.height];const r=this.current.activeSMask,n=this.suspendedCtx;this.composeSMask(n,r,this.ctx,e),this.ctx.save(),this.ctx.setTransform(1,0,0,1,0,0),this.ctx.clearRect(0,0,this.ctx.canvas.width,this.ctx.canvas.height),this.ctx.restore()}composeSMask(e,r,n,i){const a=i[0],s=i[1],o=i[2]-a,l=i[3]-s;o===0||l===0||(this.genericComposeSMask(r.context,n,o,l,r.subtype,r.backdrop,r.transferMap,a,s,r.offsetX,r.offsetY),e.save(),e.globalAlpha=1,e.globalCompositeOperation="source-over",e.setTransform(1,0,0,1,0,0),e.drawImage(n.canvas,0,0),e.restore())}genericComposeSMask(e,r,n,i,a,s,o,l,u,d,h){let f=e.canvas,p=l-d,g=u-h;if(s)if(p<0||g<0||p+n>f.width||g+i>f.height){const _=this.cachedCanvases.getCanvas("maskExtension",n,i),v=_.context;v.drawImage(f,-p,-g),v.globalCompositeOperation="destination-atop",v.fillStyle=s,v.fillRect(0,0,n,i),v.globalCompositeOperation="source-over",f=_.canvas,p=g=0}else{e.save(),e.globalAlpha=1,e.setTransform(1,0,0,1,0,0);const _=new Path2D;_.rect(p,g,n,i),e.clip(_),e.globalCompositeOperation="destination-atop",e.fillStyle=s,e.fillRect(p,g,n,i),e.restore()}r.save(),r.globalAlpha=1,r.setTransform(1,0,0,1,0,0),a==="Alpha"&&o?r.filter=this.filterFactory.addAlphaFilter(o):a==="Luminosity"&&(r.filter=this.filterFactory.addLuminosityFilter(o));const m=new Path2D;m.rect(l,u,n,i),r.clip(m),r.globalCompositeOperation="destination-in",r.drawImage(f,p,g,n,i,l,u,n,i),r.restore()}save(){this.inSMaskMode&&PA(this.ctx,this.suspendedCtx),this.ctx.save();const e=this.current;this.stateStack.push(e),this.current=e.clone()}restore(){if(this.stateStack.length===0){this.inSMaskMode&&this.endSMaskMode();return}this.current=this.stateStack.pop(),this.ctx.restore(),this.inSMaskMode&&PA(this.suspendedCtx,this.ctx),this.checkSMaskState(),this.pendingClip=null,this._cachedScaleForStroking[0]=-1,this._cachedGetSinglePixelWidth=null}transform(e,r,n,i,a,s){this.ctx.transform(e,r,n,i,a,s),this._cachedScaleForStroking[0]=-1,this._cachedGetSinglePixelWidth=null}constructPath(e,r,n){let[i]=r;if(!n){i||=r[0]=new Path2D,this[e](i);return}if(!(i instanceof Path2D)){const a=r[0]=new Path2D;for(let s=0,o=i.length;soTe&&(u=oTe),this.current.fontSizeScale=r/u,this.ctx.font=`${l} ${o} ${u}px ${s}`}setTextRenderingMode(e){this.current.textRenderingMode=e}setTextRise(e){this.current.textRise=e}moveText(e,r){this.current.x=this.current.lineX+=e,this.current.y=this.current.lineY+=r}setLeadingMoveText(e,r){this.setLeading(-r),this.moveText(e,r)}setTextMatrix(e){const{current:r}=this;r.textMatrix=e,r.textMatrixScale=Math.hypot(e[0],e[1]),r.x=r.lineX=0,r.y=r.lineY=0}nextLine(){this.moveText(0,this.current.leading)}#r(e,r,n){const i=new Path2D;return i.addPath(e,new DOMMatrix(n).invertSelf().multiplySelf(r)),i}paintChar(e,r,n,i,a){const s=this.ctx,o=this.current,l=o.font,u=o.textRenderingMode,d=o.fontSize/o.fontSizeScale,h=u&Fc.FILL_STROKE_MASK,f=!!(u&Fc.ADD_TO_PATH_FLAG),p=o.patternFill&&!l.missingFile,g=o.patternStroke&&!l.missingFile;let m;if((l.disableFontFace||f||p||g)&&!l.missingFile&&(m=l.getPathGenerator(this.commonObjs,e)),m&&(l.disableFontFace||p||g)){s.save(),s.translate(r,n),s.scale(d,-d);let _;if((h===Fc.FILL||h===Fc.FILL_STROKE)&&(i?(_=s.getTransform(),s.setTransform(...i),s.fill(this.#r(m,_,i))):s.fill(m)),h===Fc.STROKE||h===Fc.FILL_STROKE)if(a){_||=s.getTransform(),s.setTransform(...a);const{a:v,b,c:y,d:E}=_,T=Xn.inverseTransform(a),C=Xn.transform([v,b,y,E,0,0],T);Xn.singularValueDecompose2dScale(C,Kd),s.lineWidth*=Math.max(Kd[0],Kd[1])/d,s.stroke(this.#r(m,_,a))}else s.lineWidth/=d,s.stroke(m);s.restore()}else(h===Fc.FILL||h===Fc.FILL_STROKE)&&s.fillText(e,r,n),(h===Fc.STROKE||h===Fc.FILL_STROKE)&&s.strokeText(e,r,n);f&&(this.pendingTextPaths||=[]).push({transform:to(s),x:r,y:n,fontSize:d,path:m})}get isFontSubpixelAAEnabled(){const{context:e}=this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled",10,10);e.scale(1.5,1),e.fillText("I",0,10);const r=e.getImageData(0,0,10,10).data;let n=!1;for(let i=3;i0&&r[i]<255){n=!0;break}return na(this,"isFontSubpixelAAEnabled",n)}showText(e){const r=this.current,n=r.font;if(n.isType3Font)return this.showType3Text(e);const i=r.fontSize;if(i===0)return;const a=this.ctx,s=r.fontSizeScale,o=r.charSpacing,l=r.wordSpacing,u=r.fontDirection,d=r.textHScale*u,h=e.length,f=n.vertical,p=f?1:-1,g=n.defaultVMetrics,m=i*r.fontMatrix[0],_=r.textRenderingMode===Fc.FILL&&!n.disableFontFace&&!r.patternFill;a.save(),r.textMatrix&&a.transform(...r.textMatrix),a.translate(r.x,r.y+r.textRise),u>0?a.scale(d,-1):a.scale(d,1);let v,b;if(r.patternFill){a.save();const w=r.fillColor.getPattern(a,this,Wp(a),hc.FILL);v=to(a),a.restore(),a.fillStyle=w}if(r.patternStroke){a.save();const w=r.strokeColor.getPattern(a,this,Wp(a),hc.STROKE);b=to(a),a.restore(),a.strokeStyle=w}let y=r.lineWidth;const E=r.textMatrixScale;if(E===0||y===0){const w=r.textRenderingMode&Fc.FILL_STROKE_MASK;(w===Fc.STROKE||w===Fc.FILL_STROKE)&&(y=this.getSinglePixelWidth())}else y/=E;if(s!==1&&(a.scale(s,s),y/=s),a.lineWidth=y,n.isInvalidPDFjsFont){const w=[];let x=0;for(const A of e)w.push(A.unicode),x+=A.width;a.fillText(w.join(""),0,0),r.x+=x*m*d,a.restore(),this.compose();return}let T=0,C;for(C=0;C0){const M=a.measureText(R).width*1e3/i*s;if(Nnew VT(a,this.commonObjs,this.objs,this.canvasFactory,this.filterFactory,{optionalContentConfig:this.optionalContentConfig,markedContentStack:this.markedContentStack})};r=new oue(e,this.ctx,i,n)}else r=this._getPattern(e[1],e[2]);return r}setStrokeColorN(){this.current.strokeColor=this.getColorN_Pattern(arguments),this.current.patternStroke=!0}setFillColorN(){this.current.fillColor=this.getColorN_Pattern(arguments),this.current.patternFill=!0}setStrokeRGBColor(e){this.ctx.strokeStyle=this.current.strokeColor=e,this.current.patternStroke=!1}setStrokeTransparent(){this.ctx.strokeStyle=this.current.strokeColor="transparent",this.current.patternStroke=!1}setFillRGBColor(e){this.ctx.fillStyle=this.current.fillColor=e,this.current.patternFill=!1}setFillTransparent(){this.ctx.fillStyle=this.current.fillColor="transparent",this.current.patternFill=!1}_getPattern(e,r=null){let n;return this.cachedPatterns.has(e)?n=this.cachedPatterns.get(e):(n=PFt(this.getObject(e)),this.cachedPatterns.set(e,n)),r&&(n.matrix=r),n}shadingFill(e){if(!this.contentVisible)return;const r=this.ctx;this.save();const n=this._getPattern(e);r.fillStyle=n.getPattern(r,this,Wp(r),hc.SHADING);const i=Wp(r);if(i){const{width:a,height:s}=r.canvas,o=gT.slice();Xn.axialAlignedBoundingBox([0,0,a,s],i,o);const[l,u,d,h]=o;this.ctx.fillRect(l,u,d-l,h-u)}else this.ctx.fillRect(-1e10,-1e10,2e10,2e10);this.compose(this.current.getClippedPathBoundingBox()),this.restore()}beginInlineImage(){as("Should not call beginInlineImage")}beginImageData(){as("Should not call beginImageData")}paintFormXObjectBegin(e,r){if(this.contentVisible&&(this.save(),this.baseTransformStack.push(this.baseTransform),e&&this.transform(...e),this.baseTransform=to(this.ctx),r)){Xn.axialAlignedBoundingBox(r,this.baseTransform,this.current.minMax);const[n,i,a,s]=r,o=new Path2D;o.rect(n,i,a-n,s-i),this.ctx.clip(o),this.endPath()}}paintFormXObjectEnd(){this.contentVisible&&(this.restore(),this.baseTransform=this.baseTransformStack.pop())}beginGroup(e){if(!this.contentVisible)return;this.save(),this.inSMaskMode&&(this.endSMaskMode(),this.current.activeSMask=null);const r=this.ctx;e.isolated||p$("TODO: Support non-isolated groups."),e.knockout&&ki("Knockout groups not supported.");const n=to(r);if(e.matrix&&r.transform(...e.matrix),!e.bbox)throw new Error("Bounding box is required.");let i=gT.slice();Xn.axialAlignedBoundingBox(e.bbox,to(r),i);const a=[0,0,r.canvas.width,r.canvas.height];i=Xn.intersect(i,a)||[0,0,0,0];const s=Math.floor(i[0]),o=Math.floor(i[1]),l=Math.max(Math.ceil(i[2])-s,1),u=Math.max(Math.ceil(i[3])-o,1);this.current.startNewPathAndClipBox([0,0,l,u]);let d="groupAt"+this.groupLevel;e.smask&&(d+="_smask_"+this.smaskCounter++%2);const h=this.cachedCanvases.getCanvas(d,l,u),f=h.context;f.translate(-s,-o),f.transform(...n);let p=new Path2D;const[g,m,_,v]=e.bbox;if(p.rect(g,m,_-g,v-m),e.matrix){const b=new Path2D;b.addPath(p,new DOMMatrix(e.matrix)),p=b}f.clip(p),e.smask?this.smaskStack.push({canvas:h.canvas,context:f,offsetX:s,offsetY:o,subtype:e.smask.subtype,backdrop:e.smask.backdrop,transferMap:e.smask.transferMap||null,startTransformInverse:null}):(r.setTransform(1,0,0,1,0,0),r.translate(s,o),r.save()),PA(r,f),this.ctx=f,this.setGState([["BM","source-over"],["ca",1],["CA",1]]),this.groupStack.push(r),this.groupLevel++}endGroup(e){if(!this.contentVisible)return;this.groupLevel--;const r=this.ctx,n=this.groupStack.pop();if(this.ctx=n,this.ctx.imageSmoothingEnabled=!1,e.smask)this.tempSMask=this.smaskStack.pop(),this.restore();else{this.ctx.restore();const i=to(this.ctx);this.restore(),this.ctx.save(),this.ctx.setTransform(...i);const a=gT.slice();Xn.axialAlignedBoundingBox([0,0,r.canvas.width,r.canvas.height],i,a),this.ctx.drawImage(r.canvas,0,0),this.ctx.restore(),this.compose(a)}}beginAnnotation(e,r,n,i,a){if(this.#e(),WI(this.ctx),this.ctx.save(),this.save(),this.baseTransform&&this.ctx.setTransform(...this.baseTransform),r){const s=r[2]-r[0],o=r[3]-r[1];if(a&&this.annotationCanvasMap){n=n.slice(),n[4]-=r[0],n[5]-=r[1],r=r.slice(),r[0]=r[1]=0,r[2]=s,r[3]=o,Xn.singularValueDecompose2dScale(to(this.ctx),Kd);const{viewportScale:l}=this,u=Math.ceil(s*this.outputScaleX*l),d=Math.ceil(o*this.outputScaleY*l);this.annotationCanvas=this.canvasFactory.create(u,d);const{canvas:h,context:f}=this.annotationCanvas;this.annotationCanvasMap.set(e,h),this.annotationCanvas.savedCtx=this.ctx,this.ctx=f,this.ctx.save(),this.ctx.setTransform(Kd[0],0,0,-Kd[1],0,o*Kd[1]),WI(this.ctx)}else{WI(this.ctx),this.endPath();const l=new Path2D;l.rect(r[0],r[1],s,o),this.ctx.clip(l)}}this.current=new cTe(this.ctx.canvas.width,this.ctx.canvas.height),this.transform(...n),this.transform(...i)}endAnnotation(){this.annotationCanvas&&(this.ctx.restore(),this.#t(),this.ctx=this.annotationCanvas.savedCtx,delete this.annotationCanvas.savedCtx,delete this.annotationCanvas)}paintImageMaskXObject(e){if(!this.contentVisible)return;const r=e.count;e=this.getObject(e.data,e),e.count=r;const n=this.ctx,i=this._createMaskCanvas(e),a=i.canvas;n.save(),n.setTransform(1,0,0,1,0,0),n.drawImage(a,i.offsetX,i.offsetY),n.restore(),this.compose()}paintImageMaskXObjectRepeat(e,r,n=0,i=0,a,s){if(!this.contentVisible)return;e=this.getObject(e.data,e);const o=this.ctx;o.save();const l=to(o);o.transform(r,n,i,a,0,0);const u=this._createMaskCanvas(e);o.setTransform(1,0,0,1,u.offsetX-l[4],u.offsetY-l[5]);for(let d=0,h=s.length;dh?d/h:1,o=u>h?u/h:1}}this._cachedScaleForStroking[0]=s,this._cachedScaleForStroking[1]=o}return this._cachedScaleForStroking}rescaleAndStroke(e,r){const{ctx:n,current:{lineWidth:i}}=this,[a,s]=this.getScaleForStroking();if(a===s){n.lineWidth=(i||1)*a,n.stroke(e);return}const o=n.getLineDash();r&&n.save(),n.scale(a,s),GK.a=1/a,GK.d=1/s;const l=new Path2D;if(l.addPath(e,GK),o.length>0){const u=Math.max(a,s);n.setLineDash(o.map(d=>d/u)),n.lineDashOffset/=u}n.lineWidth=i||1,n.stroke(l),r&&n.restore()}isContentVisible(){for(let e=this.markedContentStack.length-1;e>=0;e--)if(!this.markedContentStack[e].visible)return!1;return!0}}for(const t in EP)VT.prototype[t]!==void 0&&(VT.prototype[EP[t]]=VT.prototype[t]);class YT{static#e=null;static#t="";static get workerPort(){return this.#e}static set workerPort(e){if(!(typeof Worker<"u"&&e instanceof Worker)&&e!==null)throw new Error("Invalid `workerPort` type.");this.#e=e}static get workerSrc(){return this.#t}static set workerSrc(e){if(typeof e!="string")throw new Error("Invalid `workerSrc` type.");this.#t=e}}class HFt{#e;#t;constructor({parsedData:e,rawData:r}){this.#e=e,this.#t=r}getRaw(){return this.#t}get(e){return this.#e.get(e)??null}[Symbol.iterator](){return this.#e.entries()}}const ME=Symbol("INTERNAL");class VFt{#e=!1;#t=!1;#r=!1;#n=!0;constructor(e,{name:r,intent:n,usage:i,rbGroups:a}){this.#e=!!(e&Wd.DISPLAY),this.#t=!!(e&Wd.PRINT),this.name=r,this.intent=n,this.usage=i,this.rbGroups=a}get visible(){if(this.#r)return this.#n;if(!this.#n)return!1;const{print:e,view:r}=this.usage;return this.#e?r?.viewState!=="OFF":this.#t?e?.printState!=="OFF":!0}_setVisible(e,r,n=!1){e!==ME&&as("Internal method `_setVisible` called."),this.#r=n,this.#n=r}}class YFt{#e=null;#t=new Map;#r=null;#n=null;constructor(e,r=Wd.DISPLAY){if(this.renderingIntent=r,this.name=null,this.creator=null,e!==null){this.name=e.name,this.creator=e.creator,this.#n=e.order;for(const n of e.groups)this.#t.set(n.id,new VFt(r,n));if(e.baseState==="OFF")for(const n of this.#t.values())n._setVisible(ME,!1);for(const n of e.on)this.#t.get(n)._setVisible(ME,!0);for(const n of e.off)this.#t.get(n)._setVisible(ME,!1);this.#r=this.getHash()}}#i(e){const r=e.length;if(r<2)return!0;const n=e[0];for(let i=1;i0){const l=a instanceof Uint8Array&&a.byteLength===a.buffer.byteLength?a.buffer:new Uint8Array(a).buffer;this._queuedChunks.push(l)}this._pdfDataRangeTransport=e,this._isStreamingSupported=!n,this._isRangeSupported=!r,this._contentLength=i,this._fullRequestReader=null,this._rangeReaders=[],e.addRangeListener((l,u)=>{this._onReceiveData({begin:l,chunk:u})}),e.addProgressListener((l,u)=>{this._onProgress({loaded:l,total:u})}),e.addProgressiveReadListener(l=>{this._onReceiveData({chunk:l})}),e.addProgressiveDoneListener(()=>{this._onProgressiveDone()}),e.transportReady()}_onReceiveData({begin:e,chunk:r}){const n=r instanceof Uint8Array&&r.byteLength===r.buffer.byteLength?r.buffer:new Uint8Array(r).buffer;if(e===void 0)this._fullRequestReader?this._fullRequestReader._enqueue(n):this._queuedChunks.push(n);else{const i=this._rangeReaders.some(function(a){return a._begin!==e?!1:(a._enqueue(n),!0)});Xo(i,"_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.")}}get _progressiveDataLength(){return this._fullRequestReader?._loaded??0}_onProgress(e){e.total===void 0?this._rangeReaders[0]?.onProgress?.({loaded:e.loaded}):this._fullRequestReader?.onProgress?.({loaded:e.loaded,total:e.total})}_onProgressiveDone(){this._fullRequestReader?.progressiveDone(),this._progressiveDone=!0}_removeRangeReader(e){const r=this._rangeReaders.indexOf(e);r>=0&&this._rangeReaders.splice(r,1)}getFullReader(){Xo(!this._fullRequestReader,"PDFDataTransportStream.getFullReader can only be called once.");const e=this._queuedChunks;return this._queuedChunks=null,new KFt(this,e,this._progressiveDone,this._contentDispositionFilename)}getRangeReader(e,r){if(r<=this._progressiveDataLength)return null;const n=new jFt(this,e,r);return this._pdfDataRangeTransport.requestDataRange(e,r),this._rangeReaders.push(n),n}cancelAllRequests(e){this._fullRequestReader?.cancel(e);for(const r of this._rangeReaders.slice(0))r.cancel(e);this._pdfDataRangeTransport.abort()}}class KFt{constructor(e,r,n=!1,i=null){this._stream=e,this._done=n||!1,this._filename=tue(i)?i:null,this._queuedChunks=r||[],this._loaded=0;for(const a of this._queuedChunks)this._loaded+=a.byteLength;this._requests=[],this._headersReady=Promise.resolve(),e._fullRequestReader=this,this.onProgress=null}_enqueue(e){this._done||(this._requests.length>0?this._requests.shift().resolve({value:e,done:!1}):this._queuedChunks.push(e),this._loaded+=e.byteLength)}get headersReady(){return this._headersReady}get filename(){return this._filename}get isRangeSupported(){return this._stream._isRangeSupported}get isStreamingSupported(){return this._stream._isStreamingSupported}get contentLength(){return this._stream._contentLength}async read(){if(this._queuedChunks.length>0)return{value:this._queuedChunks.shift(),done:!1};if(this._done)return{value:void 0,done:!0};const e=Promise.withResolvers();return this._requests.push(e),e.promise}cancel(e){this._done=!0;for(const r of this._requests)r.resolve({value:void 0,done:!0});this._requests.length=0}progressiveDone(){this._done||(this._done=!0)}}class jFt{constructor(e,r,n){this._stream=e,this._begin=r,this._end=n,this._queuedChunk=null,this._requests=[],this._done=!1,this.onProgress=null}_enqueue(e){if(!this._done){if(this._requests.length===0)this._queuedChunk=e;else{this._requests.shift().resolve({value:e,done:!1});for(const n of this._requests)n.resolve({value:void 0,done:!0});this._requests.length=0}this._done=!0,this._stream._removeRangeReader(this)}}get isStreamingSupported(){return!1}async read(){if(this._queuedChunk){const r=this._queuedChunk;return this._queuedChunk=null,{value:r,done:!1}}if(this._done)return{value:void 0,done:!0};const e=Promise.withResolvers();return this._requests.push(e),e.promise}cancel(e){this._done=!0;for(const r of this._requests)r.resolve({value:void 0,done:!0});this._requests.length=0,this._stream._removeRangeReader(this)}}function XFt(t){let e=!0,r=n("filename\\*","i").exec(t);if(r){r=r[1];let d=o(r);return d=unescape(d),d=l(d),d=u(d),a(d)}if(r=s(t),r){const d=u(r);return a(d)}if(r=n("filename","i").exec(t),r){r=r[1];let d=o(r);return d=u(d),a(d)}function n(d,h){return new RegExp("(?:^|;)\\s*"+d+'\\s*=\\s*([^";\\s][^;\\s]*|"(?:[^"\\\\]|\\\\"?)+"?)',h)}function i(d,h){if(d){if(!/^[\x00-\xFF]+$/.test(h))return h;try{const f=new TextDecoder(d,{fatal:!0}),p=K8(h);h=f.decode(p),e=!1}catch{}}return h}function a(d){return e&&/[\x80-\xff]/.test(d)&&(d=i("utf-8",d),e&&(d=i("iso-8859-1",d))),d}function s(d){const h=[];let f;const p=n("filename\\*((?!0\\d)\\d+)(\\*?)","ig");for(;(f=p.exec(d))!==null;){let[,m,_,v]=f;if(m=parseInt(m,10),m in h){if(m===0)break;continue}h[m]=[_,v]}const g=[];for(let m=0;m{if(e._responseOrigin=v$(a.url),!$Me(a.status))throw Z8(a.status,i);this._reader=a.body.getReader(),this._headersCapability.resolve();const s=a.headers,{allowRangeRequests:o,suggestedLength:l}=BMe({responseHeaders:s,isHttp:e.isHttp,rangeChunkSize:this._rangeChunkSize,disableRange:this._disableRange});this._isRangeSupported=o,this._contentLength=l||this._contentLength,this._filename=UMe(s),!this._isStreamingSupported&&this._isRangeSupported&&this.cancel(new Q_("Streaming is disabled."))}).catch(this._headersCapability.reject),this.onProgress=null}get headersReady(){return this._headersCapability.promise}get filename(){return this._filename}get contentLength(){return this._contentLength}get isRangeSupported(){return this._isRangeSupported}get isStreamingSupported(){return this._isStreamingSupported}async read(){await this._headersCapability.promise;const{value:e,done:r}=await this._reader.read();return r?{value:e,done:r}:(this._loaded+=e.byteLength,this.onProgress?.({loaded:this._loaded,total:this._contentLength}),{value:zMe(e),done:!1})}cancel(e){this._reader?.cancel(e),this._abortController.abort()}}class JFt{constructor(e,r,n){this._stream=e,this._reader=null,this._loaded=0;const i=e.source;this._withCredentials=i.withCredentials||!1,this._readCapability=Promise.withResolvers(),this._isStreamingSupported=!i.disableStream,this._abortController=new AbortController;const a=new Headers(e.headers);a.append("Range",`bytes=${r}-${n-1}`);const s=i.url;fetch(s,GMe(a,this._withCredentials,this._abortController)).then(o=>{const l=v$(o.url);if(l!==e._responseOrigin)throw new Error(`Expected range response-origin "${l}" to match "${e._responseOrigin}".`);if(!$Me(o.status))throw Z8(o.status,s);this._readCapability.resolve(),this._reader=o.body.getReader()}).catch(this._readCapability.reject),this.onProgress=null}get isStreamingSupported(){return this._isStreamingSupported}async read(){await this._readCapability.promise;const{value:e,done:r}=await this._reader.read();return r?{value:e,done:r}:(this._loaded+=e.byteLength,this.onProgress?.({loaded:this._loaded}),{value:zMe(e),done:!1})}cancel(e){this._reader?.cancel(e),this._abortController.abort()}}const zK=200,qK=206;function eBt(t){const e=t.response;return typeof e!="string"?e:K8(e).buffer}class tBt{_responseOrigin=null;constructor({url:e,httpHeaders:r,withCredentials:n}){this.url=e,this.isHttp=/^https?:/i.test(e),this.headers=FMe(this.isHttp,r),this.withCredentials=n||!1,this.currXhrId=0,this.pendingRequests=Object.create(null)}request(e){const r=new XMLHttpRequest,n=this.currXhrId++,i=this.pendingRequests[n]={xhr:r};r.open("GET",this.url),r.withCredentials=this.withCredentials;for(const[a,s]of this.headers)r.setRequestHeader(a,s);return this.isHttp&&"begin"in e&&"end"in e?(r.setRequestHeader("Range",`bytes=${e.begin}-${e.end-1}`),i.expectedStatus=qK):i.expectedStatus=zK,r.responseType="arraybuffer",Xo(e.onError,"Expected `onError` callback to be provided."),r.onerror=()=>{e.onError(r.status)},r.onreadystatechange=this.onStateChange.bind(this,n),r.onprogress=this.onProgress.bind(this,n),i.onHeadersReceived=e.onHeadersReceived,i.onDone=e.onDone,i.onError=e.onError,i.onProgress=e.onProgress,r.send(null),n}onProgress(e,r){const n=this.pendingRequests[e];n&&n.onProgress?.(r)}onStateChange(e,r){const n=this.pendingRequests[e];if(!n)return;const i=n.xhr;if(i.readyState>=2&&n.onHeadersReceived&&(n.onHeadersReceived(),delete n.onHeadersReceived),i.readyState!==4||!(e in this.pendingRequests))return;if(delete this.pendingRequests[e],i.status===0&&this.isHttp){n.onError(i.status);return}const a=i.status||zK;if(!(a===zK&&n.expectedStatus===qK)&&a!==n.expectedStatus){n.onError(i.status);return}const o=eBt(i);if(a===qK){const l=i.getResponseHeader("Content-Range"),u=/bytes (\d+)-(\d+)\/(\d+)/.exec(l);u?n.onDone({begin:parseInt(u[1],10),chunk:o}):(ki('Missing or invalid "Content-Range" header.'),n.onError(0))}else o?n.onDone({begin:0,chunk:o}):n.onError(i.status)}getRequestXhr(e){return this.pendingRequests[e].xhr}isPendingRequest(e){return e in this.pendingRequests}abortRequest(e){const r=this.pendingRequests[e].xhr;delete this.pendingRequests[e],r.abort()}}class rBt{constructor(e){this._source=e,this._manager=new tBt(e),this._rangeChunkSize=e.rangeChunkSize,this._fullRequestReader=null,this._rangeRequestReaders=[]}_onRangeRequestReaderClosed(e){const r=this._rangeRequestReaders.indexOf(e);r>=0&&this._rangeRequestReaders.splice(r,1)}getFullReader(){return Xo(!this._fullRequestReader,"PDFNetworkStream.getFullReader can only be called once."),this._fullRequestReader=new nBt(this._manager,this._source),this._fullRequestReader}getRangeReader(e,r){const n=new iBt(this._manager,e,r);return n.onClosed=this._onRangeRequestReaderClosed.bind(this),this._rangeRequestReaders.push(n),n}cancelAllRequests(e){this._fullRequestReader?.cancel(e);for(const r of this._rangeRequestReaders.slice(0))r.cancel(e)}}class nBt{constructor(e,r){this._manager=e,this._url=r.url,this._fullRequestId=e.request({onHeadersReceived:this._onHeadersReceived.bind(this),onDone:this._onDone.bind(this),onError:this._onError.bind(this),onProgress:this._onProgress.bind(this)}),this._headersCapability=Promise.withResolvers(),this._disableRange=r.disableRange||!1,this._contentLength=r.length,this._rangeChunkSize=r.rangeChunkSize,!this._rangeChunkSize&&!this._disableRange&&(this._disableRange=!0),this._isStreamingSupported=!1,this._isRangeSupported=!1,this._cachedChunks=[],this._requests=[],this._done=!1,this._storedError=void 0,this._filename=null,this.onProgress=null}_onHeadersReceived(){const e=this._fullRequestId,r=this._manager.getRequestXhr(e);this._manager._responseOrigin=v$(r.responseURL);const n=r.getAllResponseHeaders(),i=new Headers(n?n.trimStart().replace(/[^\S ]+$/,"").split(/[\r\n]+/).map(o=>{const[l,...u]=o.split(": ");return[l,u.join(": ")]}):[]),{allowRangeRequests:a,suggestedLength:s}=BMe({responseHeaders:i,isHttp:this._manager.isHttp,rangeChunkSize:this._rangeChunkSize,disableRange:this._disableRange});a&&(this._isRangeSupported=!0),this._contentLength=s||this._contentLength,this._filename=UMe(i),this._isRangeSupported&&this._manager.abortRequest(e),this._headersCapability.resolve()}_onDone(e){if(e&&(this._requests.length>0?this._requests.shift().resolve({value:e.chunk,done:!1}):this._cachedChunks.push(e.chunk)),this._done=!0,!(this._cachedChunks.length>0)){for(const r of this._requests)r.resolve({value:void 0,done:!0});this._requests.length=0}}_onError(e){this._storedError=Z8(e,this._url),this._headersCapability.reject(this._storedError);for(const r of this._requests)r.reject(this._storedError);this._requests.length=0,this._cachedChunks.length=0}_onProgress(e){this.onProgress?.({loaded:e.loaded,total:e.lengthComputable?e.total:this._contentLength})}get filename(){return this._filename}get isRangeSupported(){return this._isRangeSupported}get isStreamingSupported(){return this._isStreamingSupported}get contentLength(){return this._contentLength}get headersReady(){return this._headersCapability.promise}async read(){if(await this._headersCapability.promise,this._storedError)throw this._storedError;if(this._cachedChunks.length>0)return{value:this._cachedChunks.shift(),done:!1};if(this._done)return{value:void 0,done:!0};const e=Promise.withResolvers();return this._requests.push(e),e.promise}cancel(e){this._done=!0,this._headersCapability.reject(e);for(const r of this._requests)r.resolve({value:void 0,done:!0});this._requests.length=0,this._manager.isPendingRequest(this._fullRequestId)&&this._manager.abortRequest(this._fullRequestId),this._fullRequestReader=null}}class iBt{constructor(e,r,n){this._manager=e,this._url=e.url,this._requestId=e.request({begin:r,end:n,onHeadersReceived:this._onHeadersReceived.bind(this),onDone:this._onDone.bind(this),onError:this._onError.bind(this),onProgress:this._onProgress.bind(this)}),this._requests=[],this._queuedChunk=null,this._done=!1,this._storedError=void 0,this.onProgress=null,this.onClosed=null}_onHeadersReceived(){const e=v$(this._manager.getRequestXhr(this._requestId)?.responseURL);e!==this._manager._responseOrigin&&(this._storedError=new Error(`Expected range response-origin "${e}" to match "${this._manager._responseOrigin}".`),this._onError(0))}_close(){this.onClosed?.(this)}_onDone(e){const r=e.chunk;this._requests.length>0?this._requests.shift().resolve({value:r,done:!1}):this._queuedChunk=r,this._done=!0;for(const n of this._requests)n.resolve({value:void 0,done:!0});this._requests.length=0,this._close()}_onError(e){this._storedError??=Z8(e,this._url);for(const r of this._requests)r.reject(this._storedError);this._requests.length=0,this._queuedChunk=null}_onProgress(e){this.isStreamingSupported||this.onProgress?.({loaded:e.loaded})}get isStreamingSupported(){return!1}async read(){if(this._storedError)throw this._storedError;if(this._queuedChunk!==null){const r=this._queuedChunk;return this._queuedChunk=null,{value:r,done:!1}}if(this._done)return{value:void 0,done:!0};const e=Promise.withResolvers();return this._requests.push(e),e.promise}cancel(e){this._done=!0;for(const r of this._requests)r.resolve({value:void 0,done:!0});this._requests.length=0,this._manager.isPendingRequest(this._requestId)&&this._manager.abortRequest(this._requestId),this._close()}}const aBt=/^[a-z][a-z0-9\-+.]+:/i;function sBt(t){if(aBt.test(t))return new URL(t);const e=process.getBuiltinModule("url");return new URL(e.pathToFileURL(t))}class oBt{constructor(e){this.source=e,this.url=sBt(e.url),Xo(this.url.protocol==="file:","PDFNodeStream only supports file:// URLs."),this._fullRequestReader=null,this._rangeRequestReaders=[]}get _progressiveDataLength(){return this._fullRequestReader?._loaded??0}getFullReader(){return Xo(!this._fullRequestReader,"PDFNodeStream.getFullReader can only be called once."),this._fullRequestReader=new lBt(this),this._fullRequestReader}getRangeReader(e,r){if(r<=this._progressiveDataLength)return null;const n=new cBt(this,e,r);return this._rangeRequestReaders.push(n),n}cancelAllRequests(e){this._fullRequestReader?.cancel(e);for(const r of this._rangeRequestReaders.slice(0))r.cancel(e)}}class lBt{constructor(e){this._url=e.url,this._done=!1,this._storedError=null,this.onProgress=null;const r=e.source;this._contentLength=r.length,this._loaded=0,this._filename=null,this._disableRange=r.disableRange||!1,this._rangeChunkSize=r.rangeChunkSize,!this._rangeChunkSize&&!this._disableRange&&(this._disableRange=!0),this._isStreamingSupported=!r.disableStream,this._isRangeSupported=!r.disableRange,this._readableStream=null,this._readCapability=Promise.withResolvers(),this._headersCapability=Promise.withResolvers();const n=process.getBuiltinModule("fs");n.promises.lstat(this._url).then(i=>{this._contentLength=i.size,this._setReadableStream(n.createReadStream(this._url)),this._headersCapability.resolve()},i=>{i.code==="ENOENT"&&(i=Z8(0,this._url.href)),this._storedError=i,this._headersCapability.reject(i)})}get headersReady(){return this._headersCapability.promise}get filename(){return this._filename}get contentLength(){return this._contentLength}get isRangeSupported(){return this._isRangeSupported}get isStreamingSupported(){return this._isStreamingSupported}async read(){if(await this._readCapability.promise,this._done)return{value:void 0,done:!0};if(this._storedError)throw this._storedError;const e=this._readableStream.read();return e===null?(this._readCapability=Promise.withResolvers(),this.read()):(this._loaded+=e.length,this.onProgress?.({loaded:this._loaded,total:this._contentLength}),{value:new Uint8Array(e).buffer,done:!1})}cancel(e){if(!this._readableStream){this._error(e);return}this._readableStream.destroy(e)}_error(e){this._storedError=e,this._readCapability.resolve()}_setReadableStream(e){this._readableStream=e,e.on("readable",()=>{this._readCapability.resolve()}),e.on("end",()=>{e.destroy(),this._done=!0,this._readCapability.resolve()}),e.on("error",r=>{this._error(r)}),!this._isStreamingSupported&&this._isRangeSupported&&this._error(new Q_("streaming is disabled")),this._storedError&&this._readableStream.destroy(this._storedError)}}class cBt{constructor(e,r,n){this._url=e.url,this._done=!1,this._storedError=null,this.onProgress=null,this._loaded=0,this._readableStream=null,this._readCapability=Promise.withResolvers();const i=e.source;this._isStreamingSupported=!i.disableStream;const a=process.getBuiltinModule("fs");this._setReadableStream(a.createReadStream(this._url,{start:r,end:n-1}))}get isStreamingSupported(){return this._isStreamingSupported}async read(){if(await this._readCapability.promise,this._done)return{value:void 0,done:!0};if(this._storedError)throw this._storedError;const e=this._readableStream.read();return e===null?(this._readCapability=Promise.withResolvers(),this.read()):(this._loaded+=e.length,this.onProgress?.({loaded:this._loaded}),{value:new Uint8Array(e).buffer,done:!1})}cancel(e){if(!this._readableStream){this._error(e);return}this._readableStream.destroy(e)}_error(e){this._storedError=e,this._readCapability.resolve()}_setReadableStream(e){this._readableStream=e,e.on("readable",()=>{this._readCapability.resolve()}),e.on("end",()=>{e.destroy(),this._done=!0,this._readCapability.resolve()}),e.on("error",r=>{this._error(r)}),this._storedError&&this._readableStream.destroy(this._storedError)}}const FA=Symbol("INITIAL_DATA");class qMe{#e=Object.create(null);#t(e){return this.#e[e]||={...Promise.withResolvers(),data:FA}}get(e,r=null){if(r){const i=this.#t(e);return i.promise.then(()=>r(i.data)),null}const n=this.#e[e];if(!n||n.data===FA)throw new Error(`Requesting object that isn't resolved yet ${e}.`);return n.data}has(e){const r=this.#e[e];return!!r&&r.data!==FA}delete(e){const r=this.#e[e];return!r||r.data===FA?!1:(delete this.#e[e],!0)}resolve(e,r=null){const n=this.#t(e);n.data=r,n.resolve()}clear(){for(const e in this.#e){const{data:r}=this.#e[e];r?.bitmap?.close()}this.#e=Object.create(null)}*[Symbol.iterator](){for(const e in this.#e){const{data:r}=this.#e[e];r!==FA&&(yield[e,r])}}}const uBt=1e5,pTe=30;class hu{#e=Promise.withResolvers();#t=null;#r=!1;#n=!!globalThis.FontInspector?.enabled;#i=null;#a=null;#s=0;#o=0;#l=null;#c=null;#d=0;#u=0;#p=Object.create(null);#g=[];#f=null;#h=[];#m=new WeakMap;#v=null;static#_=new Map;static#S=new Map;static#b=new WeakMap;static#y=null;static#E=new Set;constructor({textContentSource:e,container:r,viewport:n}){if(e instanceof ReadableStream)this.#f=e;else if(typeof e=="object")this.#f=new ReadableStream({start(l){l.enqueue(e),l.close()}});else throw new Error('No "textContentSource" parameter specified.');this.#t=this.#c=r,this.#u=n.scale*Qg.pixelRatio,this.#d=n.rotation,this.#a={div:null,properties:null,ctx:null};const{pageWidth:i,pageHeight:a,pageX:s,pageY:o}=n.rawDims;this.#v=[1,0,0,-1,-s,o+a],this.#o=i,this.#s=a,hu.#A(),_2(r,n),this.#e.promise.finally(()=>{hu.#E.delete(this),this.#a=null,this.#p=null}).catch(()=>{})}static get fontFamilyMap(){const{isWindows:e,isFirefox:r}=Sc.platform;return na(this,"fontFamilyMap",new Map([["sans-serif",`${e&&r?"Calibri, ":""}sans-serif`],["monospace",`${e&&r?"Lucida Console, ":""}monospace`]]))}render(){const e=()=>{this.#l.read().then(({value:r,done:n})=>{if(n){this.#e.resolve();return}this.#i??=r.lang,Object.assign(this.#p,r.styles),this.#C(r.items),e()},this.#e.reject)};return this.#l=this.#f.getReader(),hu.#E.add(this),e(),this.#e.promise}update({viewport:e,onBefore:r=null}){const n=e.scale*Qg.pixelRatio,i=e.rotation;if(i!==this.#d&&(r?.(),this.#d=i,_2(this.#c,{rotation:i})),n!==this.#u){r?.(),this.#u=n;const a={div:null,properties:null,ctx:hu.#N(this.#i)};for(const s of this.#h)a.properties=this.#m.get(s),a.div=s,this.#O(a)}}cancel(){const e=new Q_("TextLayer task cancelled.");this.#l?.cancel(e).catch(()=>{}),this.#l=null,this.#e.reject(e)}get textDivs(){return this.#h}get textContentItemsStr(){return this.#g}#C(e){if(this.#r)return;this.#a.ctx??=hu.#N(this.#i);const r=this.#h,n=this.#g;for(const i of e){if(r.length>uBt){ki("Ignoring additional textDivs for performance reasons."),this.#r=!0;return}if(i.str===void 0){if(i.type==="beginMarkedContentProps"||i.type==="beginMarkedContent"){const a=this.#t;this.#t=document.createElement("span"),this.#t.classList.add("markedContent"),i.id&&this.#t.setAttribute("id",`${i.id}`),a.append(this.#t)}else i.type==="endMarkedContent"&&(this.#t=this.#t.parentNode);continue}n.push(i.str),this.#w(i)}}#w(e){const r=document.createElement("span"),n={angle:0,canvasWidth:0,hasText:e.str!=="",hasEOL:e.hasEOL,fontSize:0};this.#h.push(r);const i=Xn.transform(this.#v,e.transform);let a=Math.atan2(i[1],i[0]);const s=this.#p[e.fontName];s.vertical&&(a+=Math.PI/2);let o=this.#n&&s.fontSubstitution||s.fontFamily;o=hu.fontFamilyMap.get(o)||o;const l=Math.hypot(i[2],i[3]),u=l*hu.#k(o,s,this.#i);let d,h;a===0?(d=i[4],h=i[5]-u):(d=i[4]+u*Math.sin(a),h=i[5]-u*Math.cos(a));const f="calc(var(--total-scale-factor) *",p=r.style;this.#t===this.#c?(p.left=`${(100*d/this.#o).toFixed(2)}%`,p.top=`${(100*h/this.#s).toFixed(2)}%`):(p.left=`${f}${d.toFixed(2)}px)`,p.top=`${f}${h.toFixed(2)}px)`),p.fontSize=`${f}${(hu.#y*l).toFixed(2)}px)`,p.fontFamily=o,n.fontSize=l,r.setAttribute("role","presentation"),r.textContent=e.str,r.dir=e.dir,this.#n&&(r.dataset.fontName=s.fontSubstitutionLoadedName||e.fontName),a!==0&&(n.angle=a*(180/Math.PI));let g=!1;if(e.str.length>1)g=!0;else if(e.str!==" "&&e.transform[0]!==e.transform[3]){const m=Math.abs(e.transform[0]),_=Math.abs(e.transform[3]);m!==_&&Math.max(m,_)/Math.min(m,_)>1.5&&(g=!0)}if(g&&(n.canvasWidth=s.vertical?e.height:e.width),this.#m.set(r,n),this.#a.div=r,this.#a.properties=n,this.#O(this.#a),n.hasText&&this.#t.append(r),n.hasEOL){const m=document.createElement("br");m.setAttribute("role","presentation"),this.#t.append(m)}}#O(e){const{div:r,properties:n,ctx:i}=e,{style:a}=r;let s="";if(hu.#y>1&&(s=`scale(${1/hu.#y})`),n.canvasWidth!==0&&n.hasText){const{fontFamily:o}=a,{canvasWidth:l,fontSize:u}=n;hu.#R(i,u*this.#u,o);const{width:d}=i.measureText(r.textContent);d>0&&(s=`scaleX(${l*this.#u/d}) ${s}`)}n.angle!==0&&(s=`rotate(${n.angle}deg) ${s}`),s.length>0&&(a.transform=s)}static cleanup(){if(!(this.#E.size>0)){this.#_.clear();for(const{canvas:e}of this.#S.values())e.remove();this.#S.clear()}}static#N(e=null){let r=this.#S.get(e||="");if(!r){const n=document.createElement("canvas");n.className="hiddenCanvasElement",n.lang=e,document.body.append(n),r=n.getContext("2d",{alpha:!1,willReadFrequently:!0}),this.#S.set(e,r),this.#b.set(r,{size:0,family:""})}return r}static#R(e,r,n){const i=this.#b.get(e);r===i.size&&n===i.family||(e.font=`${r}px ${n}`,i.size=r,i.family=n)}static#A(){if(this.#y!==null)return;const e=document.createElement("div");e.style.opacity=0,e.style.lineHeight=1,e.style.fontSize="1px",e.style.position="absolute",e.textContent="X",document.body.append(e),this.#y=e.getBoundingClientRect().height,e.remove()}static#k(e,r,n){const i=this.#_.get(e);if(i)return i;const a=this.#N(n);a.canvas.width=a.canvas.height=pTe,this.#R(a,pTe,e);const s=a.measureText(""),o=s.fontBoundingBoxAscent,l=Math.abs(s.fontBoundingBoxDescent);a.canvas.width=a.canvas.height=0;let u=.8;return o?u=o/(o+l):(Sc.platform.isFirefox&&ki("Enable the `dom.textMetrics.fontBoundingBox.enabled` preference in `about:config` to improve TextLayer rendering."),r.ascent?u=r.ascent:r.descent&&(u=1+r.descent)),this.#_.set(e,u),u}}class QR{static textContent(e){const r=[],n={items:r,styles:Object.create(null)};function i(a){if(!a)return;let s=null;const o=a.name;if(o==="#text")s=a.value;else if(QR.shouldBuildText(o))a?.attributes?.textContent?s=a.attributes.textContent:a.value&&(s=a.value);else return;if(s!==null&&r.push({str:s}),!!a.children)for(const l of a.children)i(l)}return i(e),n}static shouldBuildText(e){return!(e==="textarea"||e==="input"||e==="option"||e==="select")}}const dBt=100;function lue(t={}){typeof t=="string"||t instanceof URL?t={url:t}:(t instanceof ArrayBuffer||ArrayBuffer.isView(t))&&(t={data:t});const e=new cue,{docId:r}=e,n=t.url?bFt(t.url):null,i=t.data?SFt(t.data):null,a=t.httpHeaders||null,s=t.withCredentials===!0,o=t.password??null,l=t.range instanceof HMe?t.range:null,u=Number.isInteger(t.rangeChunkSize)&&t.rangeChunkSize>0?t.rangeChunkSize:2**16;let d=t.worker instanceof ZR?t.worker:null;const h=t.verbosity,f=typeof t.docBaseUrl=="string"&&!g$(t.docBaseUrl)?t.docBaseUrl:null,p=HI(t.cMapUrl),g=t.cMapPacked!==!1,m=t.CMapReaderFactory||(pu?NFt:rTe),_=HI(t.iccUrl),v=HI(t.standardFontDataUrl),b=t.StandardFontDataFactory||(pu?OFt:nTe),y=HI(t.wasmUrl),E=t.WasmFactory||(pu?IFt:iTe),T=t.stopAtErrors!==!0,C=Number.isInteger(t.maxImageSize)&&t.maxImageSize>-1?t.maxImageSize:-1,w=t.isEvalSupported!==!1,x=typeof t.isOffscreenCanvasSupported=="boolean"?t.isOffscreenCanvasSupported:!pu,A=typeof t.isImageDecoderSupported=="boolean"?t.isImageDecoderSupported:!pu&&(Sc.platform.isFirefox||!globalThis.chrome),R=Number.isInteger(t.canvasMaxAreaInBytes)?t.canvasMaxAreaInBytes:-1,O=typeof t.disableFontFace=="boolean"?t.disableFontFace:pu,F=t.fontExtraProperties===!0,P=t.enableXfa===!0,N=t.ownerDocument||globalThis.document,k=t.disableRange===!0,M=t.disableStream===!0,L=t.disableAutoFetch===!0,I=t.pdfBug===!0,U=t.CanvasFactory||(pu?RFt:wFt),B=t.FilterFactory||(pu?AFt:xFt),$=t.enableHWA===!0,H=t.useWasm!==!1,q=l?l.length:t.length??NaN,V=typeof t.useSystemFonts=="boolean"?t.useSystemFonts:!pu&&!O,Y=typeof t.useWorkerFetch=="boolean"?t.useWorkerFetch:!!(m===rTe&&b===nTe&&E===iTe&&p&&v&&y&&z6(p,document.baseURI)&&z6(v,document.baseURI)&&z6(y,document.baseURI)),j=null;ZPt(h);const Q={canvasFactory:new U({ownerDocument:N,enableHWA:$}),filterFactory:new B({docId:r,ownerDocument:N}),cMapReaderFactory:Y?null:new m({baseUrl:p,isCompressed:g}),standardFontDataFactory:Y?null:new b({baseUrl:v}),wasmFactory:Y?null:new E({baseUrl:y})};d||(d=ZR.create({verbosity:h,port:YT.workerPort}),e._worker=d);const ae={docId:r,apiVersion:"5.4.54",data:i,password:o,disableAutoFetch:L,rangeChunkSize:u,length:q,docBaseUrl:f,enableXfa:P,evaluatorOptions:{maxImageSize:C,disableFontFace:O,ignoreErrors:T,isEvalSupported:w,isOffscreenCanvasSupported:x,isImageDecoderSupported:A,canvasMaxAreaInBytes:R,fontExtraProperties:F,useSystemFonts:V,useWasm:H,useWorkerFetch:Y,cMapUrl:p,iccUrl:_,standardFontDataUrl:v,wasmUrl:y}},re={ownerDocument:N,pdfBug:I,styleElement:j,loadingParams:{disableAutoFetch:L,enableXfa:P}};return d.promise.then(function(){if(e.destroyed)throw new Error("Loading aborted");if(d.destroyed)throw new Error("Worker was destroyed");const ne=d.messageHandler.sendWithPromise("GetDocRequest",ae,i?[i.buffer]:null);let ee;if(l)ee=new WFt(l,{disableRange:k,disableStream:M});else if(!i){if(!n)throw new Error("getDocument - no `url` parameter provided.");const J=z6(n)?QFt:pu?oBt:rBt;ee=new J({url:n,length:q,httpHeaders:a,withCredentials:s,rangeChunkSize:u,disableRange:k,disableStream:M})}return ne.then(J=>{if(e.destroyed)throw new Error("Loading aborted");if(d.destroyed)throw new Error("Worker was destroyed");const fe=new q6(r,J,d.port),ue=new pBt(fe,e,ee,re,Q,$);e._transport=ue,fe.send("Ready",null)})}).catch(e._capability.reject),e}class cue{static#e=0;_capability=Promise.withResolvers();_transport=null;_worker=null;docId=`d${cue.#e++}`;destroyed=!1;onPassword=null;onProgress=null;get promise(){return this._capability.promise}async destroy(){this.destroyed=!0;try{this._worker?.port&&(this._worker._pendingDestroy=!0),await this._transport?.destroy()}catch(e){throw this._worker?.port&&delete this._worker._pendingDestroy,e}this._transport=null,this._worker?.destroy(),this._worker=null}async getData(){return this._transport.getData()}}class HMe{#e=Promise.withResolvers();#t=[];#r=[];#n=[];#i=[];constructor(e,r,n=!1,i=null){this.length=e,this.initialData=r,this.progressiveDone=n,this.contentDispositionFilename=i}addRangeListener(e){this.#i.push(e)}addProgressListener(e){this.#n.push(e)}addProgressiveReadListener(e){this.#r.push(e)}addProgressiveDoneListener(e){this.#t.push(e)}onDataRange(e,r){for(const n of this.#i)n(e,r)}onDataProgress(e,r){this.#e.promise.then(()=>{for(const n of this.#n)n(e,r)})}onDataProgressiveRead(e){this.#e.promise.then(()=>{for(const r of this.#r)r(e)})}onDataProgressiveDone(){this.#e.promise.then(()=>{for(const e of this.#t)e()})}transportReady(){this.#e.resolve()}requestDataRange(e,r){as("Abstract method PDFDataRangeTransport.requestDataRange")}abort(){}}class hBt{constructor(e,r){this._pdfInfo=e,this._transport=r}get annotationStorage(){return this._transport.annotationStorage}get canvasFactory(){return this._transport.canvasFactory}get filterFactory(){return this._transport.filterFactory}get numPages(){return this._pdfInfo.numPages}get fingerprints(){return this._pdfInfo.fingerprints}get isPureXfa(){return na(this,"isPureXfa",!!this._transport._htmlForXfa)}get allXfaHtml(){return this._transport._htmlForXfa}getPage(e){return this._transport.getPage(e)}getPageIndex(e){return this._transport.getPageIndex(e)}getDestinations(){return this._transport.getDestinations()}getDestination(e){return this._transport.getDestination(e)}getPageLabels(){return this._transport.getPageLabels()}getPageLayout(){return this._transport.getPageLayout()}getPageMode(){return this._transport.getPageMode()}getViewerPreferences(){return this._transport.getViewerPreferences()}getOpenAction(){return this._transport.getOpenAction()}getAttachments(){return this._transport.getAttachments()}getJSActions(){return this._transport.getDocJSActions()}getOutline(){return this._transport.getOutline()}getOptionalContentConfig({intent:e="display"}={}){const{renderingIntent:r}=this._transport.getRenderingIntent(e);return this._transport.getOptionalContentConfig(r)}getPermissions(){return this._transport.getPermissions()}getMetadata(){return this._transport.getMetadata()}getMarkInfo(){return this._transport.getMarkInfo()}getData(){return this._transport.getData()}saveDocument(){return this._transport.saveDocument()}getDownloadInfo(){return this._transport.downloadInfoCapability.promise}cleanup(e=!1){return this._transport.startCleanup(e||this.isPureXfa)}destroy(){return this.loadingTask.destroy()}cachedPageNumber(e){return this._transport.cachedPageNumber(e)}get loadingParams(){return this._transport.loadingParams}get loadingTask(){return this._transport.loadingTask}getFieldObjects(){return this._transport.getFieldObjects()}hasJSActions(){return this._transport.hasJSActions()}getCalculationOrderIds(){return this._transport.getCalculationOrderIds()}}class fBt{#e=!1;constructor(e,r,n,i=!1){this._pageIndex=e,this._pageInfo=r,this._transport=n,this._stats=i?new JEe:null,this._pdfBug=i,this.commonObjs=n.commonObjs,this.objs=new qMe,this._intentStates=new Map,this.destroyed=!1}get pageNumber(){return this._pageIndex+1}get rotate(){return this._pageInfo.rotate}get ref(){return this._pageInfo.ref}get userUnit(){return this._pageInfo.userUnit}get view(){return this._pageInfo.view}getViewport({scale:e,rotation:r=this.rotate,offsetX:n=0,offsetY:i=0,dontFlip:a=!1}={}){return new X8({viewBox:this.view,userUnit:this.userUnit,scale:e,rotation:r,offsetX:n,offsetY:i,dontFlip:a})}getAnnotations({intent:e="display"}={}){const{renderingIntent:r}=this._transport.getRenderingIntent(e);return this._transport.getAnnotations(this._pageIndex,r)}getJSActions(){return this._transport.getPageJSActions(this._pageIndex)}get filterFactory(){return this._transport.filterFactory}get isPureXfa(){return na(this,"isPureXfa",!!this._transport._htmlForXfa)}async getXfa(){return this._transport._htmlForXfa?.children[this._pageIndex]||null}render({canvasContext:e,canvas:r=e.canvas,viewport:n,intent:i="display",annotationMode:a=p_.ENABLE,transform:s=null,background:o=null,optionalContentConfigPromise:l=null,annotationCanvasMap:u=null,pageColors:d=null,printAnnotationStorage:h=null,isEditing:f=!1}){this._stats?.time("Overall");const p=this._transport.getRenderingIntent(i,a,h,f),{renderingIntent:g,cacheKey:m}=p;this.#e=!1,l||=this._transport.getOptionalContentConfig(g);let _=this._intentStates.get(m);_||(_=Object.create(null),this._intentStates.set(m,_)),_.streamReaderCancelTimeout&&(clearTimeout(_.streamReaderCancelTimeout),_.streamReaderCancelTimeout=null);const v=!!(g&Wd.PRINT);_.displayReadyCapability||(_.displayReadyCapability=Promise.withResolvers(),_.operatorList={fnArray:[],argsArray:[],lastChunk:!1,separateAnnots:null},this._stats?.time("Page Request"),this._pumpOperatorList(p));const b=T=>{_.renderTasks.delete(y),v&&(this.#e=!0),this.#t(),T?(y.capability.reject(T),this._abortOperatorList({intentState:_,reason:T instanceof Error?T:new Error(T)})):y.capability.resolve(),this._stats&&(this._stats.timeEnd("Rendering"),this._stats.timeEnd("Overall"),globalThis.Stats?.enabled&&globalThis.Stats.add(this.pageNumber,this._stats))},y=new mT({callback:b,params:{canvas:r,canvasContext:e,viewport:n,transform:s,background:o},objs:this.objs,commonObjs:this.commonObjs,annotationCanvasMap:u,operatorList:_.operatorList,pageIndex:this._pageIndex,canvasFactory:this._transport.canvasFactory,filterFactory:this._transport.filterFactory,useRequestAnimationFrame:!v,pdfBug:this._pdfBug,pageColors:d,enableHWA:this._transport.enableHWA});(_.renderTasks||=new Set).add(y);const E=y.task;return Promise.all([_.displayReadyCapability.promise,l]).then(([T,C])=>{if(this.destroyed){b();return}if(this._stats?.time("Rendering"),!(C.renderingIntent&g))throw new Error("Must use the same `intent`-argument when calling the `PDFPageProxy.render` and `PDFDocumentProxy.getOptionalContentConfig` methods.");y.initializeGraphics({transparency:T,optionalContentConfig:C}),y.operatorListChanged()}).catch(b),E}getOperatorList({intent:e="display",annotationMode:r=p_.ENABLE,printAnnotationStorage:n=null,isEditing:i=!1}={}){function a(){o.operatorList.lastChunk&&(o.opListReadCapability.resolve(o.operatorList),o.renderTasks.delete(l))}const s=this._transport.getRenderingIntent(e,r,n,i,!0);let o=this._intentStates.get(s.cacheKey);o||(o=Object.create(null),this._intentStates.set(s.cacheKey,o));let l;return o.opListReadCapability||(l=Object.create(null),l.operatorListChanged=a,o.opListReadCapability=Promise.withResolvers(),(o.renderTasks||=new Set).add(l),o.operatorList={fnArray:[],argsArray:[],lastChunk:!1,separateAnnots:null},this._stats?.time("Page Request"),this._pumpOperatorList(s)),o.opListReadCapability.promise}streamTextContent({includeMarkedContent:e=!1,disableNormalization:r=!1}={}){return this._transport.messageHandler.sendWithStream("GetTextContent",{pageIndex:this._pageIndex,includeMarkedContent:e===!0,disableNormalization:r===!0},{highWaterMark:100,size(i){return i.items.length}})}getTextContent(e={}){if(this._transport._htmlForXfa)return this.getXfa().then(n=>QR.textContent(n));const r=this.streamTextContent(e);return new Promise(function(n,i){function a(){s.read().then(function({value:l,done:u}){if(u){n(o);return}o.lang??=l.lang,Object.assign(o.styles,l.styles),o.items.push(...l.items),a()},i)}const s=r.getReader(),o={items:[],styles:Object.create(null),lang:null};a()})}getStructTree(){return this._transport.getStructTree(this._pageIndex)}_destroy(){this.destroyed=!0;const e=[];for(const r of this._intentStates.values())if(this._abortOperatorList({intentState:r,reason:new Error("Page was destroyed."),force:!0}),!r.opListReadCapability)for(const n of r.renderTasks)e.push(n.completed),n.cancel();return this.objs.clear(),this.#e=!1,Promise.all(e)}cleanup(e=!1){this.#e=!0;const r=this.#t();return e&&r&&(this._stats&&=new JEe),r}#t(){if(!this.#e||this.destroyed)return!1;for(const{renderTasks:e,operatorList:r}of this._intentStates.values())if(e.size>0||!r.lastChunk)return!1;return this._intentStates.clear(),this.objs.clear(),this.#e=!1,!0}_startRenderPage(e,r){const n=this._intentStates.get(r);n&&(this._stats?.timeEnd("Page Request"),n.displayReadyCapability?.resolve(e))}_renderPageChunk(e,r){for(let n=0,i=e.length;n{l.read().then(({value:h,done:f})=>{if(f){u.streamReader=null;return}this._transport.destroyed||(this._renderPageChunk(h,u),d())},h=>{if(u.streamReader=null,!this._transport.destroyed){if(u.operatorList){u.operatorList.lastChunk=!0;for(const f of u.renderTasks)f.operatorListChanged();this.#t()}if(u.displayReadyCapability)u.displayReadyCapability.reject(h);else if(u.opListReadCapability)u.opListReadCapability.reject(h);else throw h}})};d()}_abortOperatorList({intentState:e,reason:r,force:n=!1}){if(e.streamReader){if(e.streamReaderCancelTimeout&&(clearTimeout(e.streamReaderCancelTimeout),e.streamReaderCancelTimeout=null),!n){if(e.renderTasks.size>0)return;if(r instanceof eue){let i=dBt;r.extraDelay>0&&r.extraDelay<1e3&&(i+=r.extraDelay),e.streamReaderCancelTimeout=setTimeout(()=>{e.streamReaderCancelTimeout=null,this._abortOperatorList({intentState:e,reason:r,force:!0})},i);return}}if(e.streamReader.cancel(new Q_(r.message)).catch(()=>{}),e.streamReader=null,!this._transport.destroyed){for(const[i,a]of this._intentStates)if(a===e){this._intentStates.delete(i);break}this.cleanup()}}}get stats(){return this._stats}}var __,qf,o0,Ub,QB,$b,Gb,Mu,BD,VMe,YMe,H6,pC,UD;const Bs=class Bs{constructor({name:e=null,port:r=null,verbosity:n=JPt()}={}){zp(this,Mu);zp(this,__,Promise.withResolvers());zp(this,qf,null);zp(this,o0,null);zp(this,Ub,null);if(this.name=e,this.destroyed=!1,this.verbosity=n,r){if(Ps(Bs,Gb).has(r))throw new Error("Cannot use more than one PDFWorker per port.");Ps(Bs,Gb).set(r,this),qp(this,Mu,VMe).call(this,r)}else qp(this,Mu,YMe).call(this)}get promise(){return Ps(this,__).promise}get port(){return Ps(this,o0)}get messageHandler(){return Ps(this,qf)}destroy(){this.destroyed=!0,Ps(this,Ub)?.terminate(),Zu(this,Ub,null),Ps(Bs,Gb).delete(Ps(this,o0)),Zu(this,o0,null),Ps(this,qf)?.destroy(),Zu(this,qf,null)}static create(e){const r=Ps(this,Gb).get(e?.port);if(r){if(r._pendingDestroy)throw new Error("PDFWorker.create - the worker is being destroyed.\nPlease remember to await `PDFDocumentLoadingTask.destroy()`-calls.");return r}return new Bs(e)}static get workerSrc(){if(YT.workerSrc)return YT.workerSrc;throw new Error('No "GlobalWorkerOptions.workerSrc" specified.')}static get _setupFakeWorkerGlobal(){return na(this,"_setupFakeWorkerGlobal",(async()=>Ps(this,pC,UD)?Ps(this,pC,UD):(await import(this.workerSrc)).WorkerMessageHandler)())}};__=new WeakMap,qf=new WeakMap,o0=new WeakMap,Ub=new WeakMap,QB=new WeakMap,$b=new WeakMap,Gb=new WeakMap,Mu=new WeakSet,BD=function(){Ps(this,__).resolve(),Ps(this,qf).send("configure",{verbosity:this.verbosity})},VMe=function(e){Zu(this,o0,e),Zu(this,qf,new q6("main","worker",e)),Ps(this,qf).on("ready",()=>{}),qp(this,Mu,BD).call(this)},YMe=function(){if(Ps(Bs,$b)||Ps(Bs,pC,UD)){qp(this,Mu,H6).call(this);return}let{workerSrc:e}=Bs;try{Bs._isSameOrigin(window.location,e)||(e=Bs._createCDNWrapper(new URL(e,window.location).href));const r=new Worker(e,{type:"module"}),n=new q6("main","worker",r),i=()=>{a.abort(),n.destroy(),r.terminate(),this.destroyed?Ps(this,__).reject(new Error("Worker was destroyed")):qp(this,Mu,H6).call(this)},a=new AbortController;r.addEventListener("error",()=>{Ps(this,Ub)||i()},{signal:a.signal}),n.on("test",o=>{if(a.abort(),this.destroyed||!o){i();return}Zu(this,qf,n),Zu(this,o0,r),Zu(this,Ub,r),qp(this,Mu,BD).call(this)}),n.on("ready",o=>{if(a.abort(),this.destroyed){i();return}try{s()}catch{qp(this,Mu,H6).call(this)}});const s=()=>{const o=new Uint8Array;n.send("test",o,[o.buffer])};s();return}catch{p$("The worker has been disabled.")}qp(this,Mu,H6).call(this)},H6=function(){Ps(Bs,$b)||(ki("Setting up fake worker."),Zu(Bs,$b,!0)),Bs._setupFakeWorkerGlobal.then(e=>{if(this.destroyed){Ps(this,__).reject(new Error("Worker was destroyed"));return}const r=new CFt;Zu(this,o0,r);const n=`fake${x0e(Bs,QB)._++}`,i=new q6(n+"_worker",n,r);e.setup(i,r),Zu(this,qf,new q6(n,n+"_worker",r)),qp(this,Mu,BD).call(this)}).catch(e=>{Ps(this,__).reject(new Error(`Setting up fake worker failed: "${e.message}".`))})},pC=new WeakSet,UD=function(){try{return globalThis.pdfjsWorker?.WorkerMessageHandler||null}catch{return null}},zp(Bs,pC),zp(Bs,QB,0),zp(Bs,$b,!1),zp(Bs,Gb,new WeakMap),pu&&(Zu(Bs,$b,!0),YT.workerSrc||="./pdf.worker.mjs"),Bs._isSameOrigin=(e,r)=>{const n=URL.parse(e);if(!n?.origin||n.origin==="null")return!1;const i=new URL(r,n);return n.origin===i.origin},Bs._createCDNWrapper=e=>{const r=`await import("${e}");`;return URL.createObjectURL(new Blob([r],{type:"text/javascript"}))},Bs.fromPort=e=>{if(dFt("`PDFWorker.fromPort` - please use `PDFWorker.create` instead."),!e?.port)throw new Error("PDFWorker.fromPort - invalid method signature.");return Bs.create(e)};let ZR=Bs;class pBt{#e=new Map;#t=new Map;#r=new Map;#n=new Map;#i=null;constructor(e,r,n,i,a,s){this.messageHandler=e,this.loadingTask=r,this.commonObjs=new qMe,this.fontLoader=new vFt({ownerDocument:i.ownerDocument,styleElement:i.styleElement}),this.loadingParams=i.loadingParams,this._params=i,this.canvasFactory=a.canvasFactory,this.filterFactory=a.filterFactory,this.cMapReaderFactory=a.cMapReaderFactory,this.standardFontDataFactory=a.standardFontDataFactory,this.wasmFactory=a.wasmFactory,this.destroyed=!1,this.destroyCapability=null,this._networkStream=n,this._fullReader=null,this._lastProgress=null,this.downloadInfoCapability=Promise.withResolvers(),this.enableHWA=s,this.setupMessageHandler()}#a(e,r=null){const n=this.#e.get(e);if(n)return n;const i=this.messageHandler.sendWithPromise(e,r);return this.#e.set(e,i),i}get annotationStorage(){return na(this,"annotationStorage",new iue)}getRenderingIntent(e,r=p_.ENABLE,n=null,i=!1,a=!1){let s=Wd.DISPLAY,o=zee;switch(e){case"any":s=Wd.ANY;break;case"display":break;case"print":s=Wd.PRINT;break;default:ki(`getRenderingIntent - invalid intent: ${e}`)}const l=s&Wd.PRINT&&n instanceof IMe?n:this.annotationStorage;switch(r){case p_.DISABLE:s+=Wd.ANNOTATIONS_DISABLE;break;case p_.ENABLE:break;case p_.ENABLE_FORMS:s+=Wd.ANNOTATIONS_FORMS;break;case p_.ENABLE_STORAGE:s+=Wd.ANNOTATIONS_STORAGE,o=l.serializable;break;default:ki(`getRenderingIntent - invalid annotationMode: ${r}`)}i&&(s+=Wd.IS_EDITING),a&&(s+=Wd.OPLIST);const{ids:u,hash:d}=l.modifiedIds,h=[s,o.hash,d];return{renderingIntent:s,cacheKey:h.join("_"),annotationStorageSerializable:o,modifiedIds:u}}destroy(){if(this.destroyCapability)return this.destroyCapability.promise;this.destroyed=!0,this.destroyCapability=Promise.withResolvers(),this.#i?.reject(new Error("Worker was destroyed during onPassword callback"));const e=[];for(const n of this.#t.values())e.push(n._destroy());this.#t.clear(),this.#r.clear(),this.#n.clear(),this.hasOwnProperty("annotationStorage")&&this.annotationStorage.resetModified();const r=this.messageHandler.sendWithPromise("Terminate",null);return e.push(r),Promise.all(e).then(()=>{this.commonObjs.clear(),this.fontLoader.clear(),this.#e.clear(),this.filterFactory.destroy(),hu.cleanup(),this._networkStream?.cancelAllRequests(new Q_("Worker was terminated.")),this.messageHandler?.destroy(),this.messageHandler=null,this.destroyCapability.resolve()},this.destroyCapability.reject),this.destroyCapability.promise}setupMessageHandler(){const{messageHandler:e,loadingTask:r}=this;e.on("GetReader",(n,i)=>{Xo(this._networkStream,"GetReader - no `IPDFStream` instance available."),this._fullReader=this._networkStream.getFullReader(),this._fullReader.onProgress=a=>{this._lastProgress={loaded:a.loaded,total:a.total}},i.onPull=()=>{this._fullReader.read().then(function({value:a,done:s}){if(s){i.close();return}Xo(a instanceof ArrayBuffer,"GetReader - expected an ArrayBuffer."),i.enqueue(new Uint8Array(a),1,[a])}).catch(a=>{i.error(a)})},i.onCancel=a=>{this._fullReader.cancel(a),i.ready.catch(s=>{if(!this.destroyed)throw s})}}),e.on("ReaderHeadersReady",async n=>{await this._fullReader.headersReady;const{isStreamingSupported:i,isRangeSupported:a,contentLength:s}=this._fullReader;return(!i||!a)&&(this._lastProgress&&r.onProgress?.(this._lastProgress),this._fullReader.onProgress=o=>{r.onProgress?.({loaded:o.loaded,total:o.total})}),{isStreamingSupported:i,isRangeSupported:a,contentLength:s}}),e.on("GetRangeReader",(n,i)=>{Xo(this._networkStream,"GetRangeReader - no `IPDFStream` instance available.");const a=this._networkStream.getRangeReader(n.begin,n.end);if(!a){i.close();return}i.onPull=()=>{a.read().then(function({value:s,done:o}){if(o){i.close();return}Xo(s instanceof ArrayBuffer,"GetRangeReader - expected an ArrayBuffer."),i.enqueue(new Uint8Array(s),1,[s])}).catch(s=>{i.error(s)})},i.onCancel=s=>{a.cancel(s),i.ready.catch(o=>{if(!this.destroyed)throw o})}}),e.on("GetDoc",({pdfInfo:n})=>{this._numPages=n.numPages,this._htmlForXfa=n.htmlForXfa,delete n.htmlForXfa,r._capability.resolve(new hBt(n,this))}),e.on("DocException",n=>{r._capability.reject(id(n))}),e.on("PasswordRequest",n=>{this.#i=Promise.withResolvers();try{if(!r.onPassword)throw id(n);const i=a=>{a instanceof Error?this.#i.reject(a):this.#i.resolve({password:a})};r.onPassword(i,n.code)}catch(i){this.#i.reject(i)}return this.#i.promise}),e.on("DataLoaded",n=>{r.onProgress?.({loaded:n.length,total:n.length}),this.downloadInfoCapability.resolve(n)}),e.on("StartRenderPage",n=>{if(this.destroyed)return;this.#t.get(n.pageIndex)._startRenderPage(n.transparency,n.cacheKey)}),e.on("commonobj",([n,i,a])=>{if(this.destroyed||this.commonObjs.has(n))return null;switch(i){case"Font":if("error"in a){const u=a.error;ki(`Error during font loading: ${u}`),this.commonObjs.resolve(n,u);break}const s=this._params.pdfBug&&globalThis.FontInspector?.enabled?(u,d)=>globalThis.FontInspector.fontAdded(u,d):null,o=new yFt(a,s);this.fontLoader.bind(o).catch(()=>e.sendWithPromise("FontFallback",{id:n})).finally(()=>{!o.fontExtraProperties&&o.data&&(o.data=null),this.commonObjs.resolve(n,o)});break;case"CopyLocalImage":const{imageRef:l}=a;Xo(l,"The imageRef must be defined.");for(const u of this.#t.values())for(const[,d]of u.objs)if(d?.ref===l)return d.dataLen?(this.commonObjs.resolve(n,structuredClone(d)),d.dataLen):null;break;case"FontPath":case"Image":case"Pattern":this.commonObjs.resolve(n,a);break;default:throw new Error(`Got unknown common object type ${i}`)}return null}),e.on("obj",([n,i,a,s])=>{if(this.destroyed)return;const o=this.#t.get(i);if(!o.objs.has(n)){if(o._intentStates.size===0){s?.bitmap?.close();return}switch(a){case"Image":case"Pattern":o.objs.resolve(n,s);break;default:throw new Error(`Got unknown object type ${a}`)}}}),e.on("DocProgress",n=>{this.destroyed||r.onProgress?.({loaded:n.loaded,total:n.total})}),e.on("FetchBinaryData",async n=>{if(this.destroyed)throw new Error("Worker was destroyed.");const i=this[n.type];if(!i)throw new Error(`${n.type} not initialized, see the \`useWorkerFetch\` parameter.`);return i.fetch(n)})}getData(){return this.messageHandler.sendWithPromise("GetData",null)}saveDocument(){this.annotationStorage.size<=0&&ki("saveDocument called while `annotationStorage` is empty, please use the getData-method instead.");const{map:e,transfer:r}=this.annotationStorage.serializable;return this.messageHandler.sendWithPromise("SaveDocument",{isPureXfa:!!this._htmlForXfa,numPages:this._numPages,annotationStorage:e,filename:this._fullReader?.filename??null},r).finally(()=>{this.annotationStorage.resetModified()})}getPage(e){if(!Number.isInteger(e)||e<=0||e>this._numPages)return Promise.reject(new Error("Invalid page request."));const r=e-1,n=this.#r.get(r);if(n)return n;const i=this.messageHandler.sendWithPromise("GetPage",{pageIndex:r}).then(a=>{if(this.destroyed)throw new Error("Transport destroyed");a.refStr&&this.#n.set(a.refStr,e);const s=new fBt(r,a,this,this._params.pdfBug);return this.#t.set(r,s),s});return this.#r.set(r,i),i}getPageIndex(e){return qee(e)?this.messageHandler.sendWithPromise("GetPageIndex",{num:e.num,gen:e.gen}):Promise.reject(new Error("Invalid pageIndex request."))}getAnnotations(e,r){return this.messageHandler.sendWithPromise("GetAnnotations",{pageIndex:e,intent:r})}getFieldObjects(){return this.#a("GetFieldObjects")}hasJSActions(){return this.#a("HasJSActions")}getCalculationOrderIds(){return this.messageHandler.sendWithPromise("GetCalculationOrderIds",null)}getDestinations(){return this.messageHandler.sendWithPromise("GetDestinations",null)}getDestination(e){return typeof e!="string"?Promise.reject(new Error("Invalid destination request.")):this.messageHandler.sendWithPromise("GetDestination",{id:e})}getPageLabels(){return this.messageHandler.sendWithPromise("GetPageLabels",null)}getPageLayout(){return this.messageHandler.sendWithPromise("GetPageLayout",null)}getPageMode(){return this.messageHandler.sendWithPromise("GetPageMode",null)}getViewerPreferences(){return this.messageHandler.sendWithPromise("GetViewerPreferences",null)}getOpenAction(){return this.messageHandler.sendWithPromise("GetOpenAction",null)}getAttachments(){return this.messageHandler.sendWithPromise("GetAttachments",null)}getDocJSActions(){return this.#a("GetDocJSActions")}getPageJSActions(e){return this.messageHandler.sendWithPromise("GetPageJSActions",{pageIndex:e})}getStructTree(e){return this.messageHandler.sendWithPromise("GetStructTree",{pageIndex:e})}getOutline(){return this.messageHandler.sendWithPromise("GetOutline",null)}getOptionalContentConfig(e){return this.#a("GetOptionalContentConfig").then(r=>new YFt(r,e))}getPermissions(){return this.messageHandler.sendWithPromise("GetPermissions",null)}getMetadata(){const e="GetMetadata",r=this.#e.get(e);if(r)return r;const n=this.messageHandler.sendWithPromise(e,null).then(i=>({info:i[0],metadata:i[1]?new HFt(i[1]):null,contentDispositionFilename:this._fullReader?.filename??null,contentLength:this._fullReader?.contentLength??null}));return this.#e.set(e,n),n}getMarkInfo(){return this.messageHandler.sendWithPromise("GetMarkInfo",null)}async startCleanup(e=!1){if(!this.destroyed){await this.messageHandler.sendWithPromise("Cleanup",null);for(const r of this.#t.values())if(!r.cleanup())throw new Error(`startCleanup: Page ${r.pageNumber} is currently rendering.`);this.commonObjs.clear(),e||this.fontLoader.clear(),this.#e.clear(),this.filterFactory.destroy(!0),hu.cleanup()}}cachedPageNumber(e){if(!qee(e))return null;const r=e.gen===0?`${e.num}R`:`${e.num}R${e.gen}`;return this.#n.get(r)??null}}class gBt{#e=null;onContinue=null;onError=null;constructor(e){this.#e=e}get promise(){return this.#e.capability.promise}cancel(e=0){this.#e.cancel(null,e)}get separateAnnots(){const{separateAnnots:e}=this.#e.operatorList;if(!e)return!1;const{annotationCanvasMap:r}=this.#e;return e.form||e.canvas&&r?.size>0}}class mT{#e=null;static#t=new WeakSet;constructor({callback:e,params:r,objs:n,commonObjs:i,annotationCanvasMap:a,operatorList:s,pageIndex:o,canvasFactory:l,filterFactory:u,useRequestAnimationFrame:d=!1,pdfBug:h=!1,pageColors:f=null,enableHWA:p=!1}){this.callback=e,this.params=r,this.objs=n,this.commonObjs=i,this.annotationCanvasMap=a,this.operatorListIdx=null,this.operatorList=s,this._pageIndex=o,this.canvasFactory=l,this.filterFactory=u,this._pdfBug=h,this.pageColors=f,this.running=!1,this.graphicsReadyCallback=null,this.graphicsReady=!1,this._useRequestAnimationFrame=d===!0&&typeof window<"u",this.cancelled=!1,this.capability=Promise.withResolvers(),this.task=new gBt(this),this._cancelBound=this.cancel.bind(this),this._continueBound=this._continue.bind(this),this._scheduleNextBound=this._scheduleNext.bind(this),this._nextBound=this._next.bind(this),this._canvas=r.canvas,this._canvasContext=r.canvas?null:r.canvasContext,this._enableHWA=p}get completed(){return this.capability.promise.catch(function(){})}initializeGraphics({transparency:e=!1,optionalContentConfig:r}){if(this.cancelled)return;if(this._canvas){if(mT.#t.has(this._canvas))throw new Error("Cannot use the same canvas during multiple render() operations. Use different canvas or ensure previous operations were cancelled or completed.");mT.#t.add(this._canvas)}this._pdfBug&&globalThis.StepperManager?.enabled&&(this.stepper=globalThis.StepperManager.create(this._pageIndex),this.stepper.init(this.operatorList),this.stepper.nextBreakPoint=this.stepper.getNextBreakPoint());const{viewport:n,transform:i,background:a}=this.params,s=this._canvasContext||this._canvas.getContext("2d",{alpha:!1,willReadFrequently:!this._enableHWA});this.gfx=new VT(s,this.commonObjs,this.objs,this.canvasFactory,this.filterFactory,{optionalContentConfig:r},this.annotationCanvasMap,this.pageColors),this.gfx.beginDrawing({transform:i,viewport:n,transparency:e,background:a}),this.operatorListIdx=0,this.graphicsReady=!0,this.graphicsReadyCallback?.()}cancel(e=null,r=0){this.running=!1,this.cancelled=!0,this.gfx?.endDrawing(),this.#e&&(window.cancelAnimationFrame(this.#e),this.#e=null),mT.#t.delete(this._canvas),e||=new eue(`Rendering cancelled, page ${this._pageIndex+1}`,r),this.callback(e),this.task.onError?.(e)}operatorListChanged(){if(!this.graphicsReady){this.graphicsReadyCallback||=this._continueBound;return}this.stepper?.updateOperatorList(this.operatorList),!this.running&&this._continue()}_continue(){this.running=!0,!this.cancelled&&(this.task.onContinue?this.task.onContinue(this._scheduleNextBound):this._scheduleNext())}_scheduleNext(){this._useRequestAnimationFrame?this.#e=window.requestAnimationFrame(()=>{this.#e=null,this._nextBound().catch(this._cancelBound)}):Promise.resolve().then(this._nextBound).catch(this._cancelBound)}async _next(){this.cancelled||(this.operatorListIdx=this.gfx.executeOperatorList(this.operatorList,this.operatorListIdx,this._continueBound,this.stepper),this.operatorListIdx===this.operatorList.argsArray.length&&(this.running=!1,this.operatorList.lastChunk&&(this.gfx.endDrawing(),mT.#t.delete(this._canvas),this.callback())))}}const mBt="5.4.54",_Bt="295fb3ec4";class Yh{#e=null;#t=null;#r;#n=null;#i=!1;#a=!1;#s=null;#o;#l=null;#c=null;static#d=null;static get _keyboardManager(){return na(this,"_keyboardManager",new Q8([[["Escape","mac+Escape"],Yh.prototype._hideDropdownFromKeyboard],[[" ","mac+ "],Yh.prototype._colorSelectFromKeyboard],[["ArrowDown","ArrowRight","mac+ArrowDown","mac+ArrowRight"],Yh.prototype._moveToNext],[["ArrowUp","ArrowLeft","mac+ArrowUp","mac+ArrowLeft"],Yh.prototype._moveToPrevious],[["Home","mac+Home"],Yh.prototype._moveToBeginning],[["End","mac+End"],Yh.prototype._moveToEnd]]))}constructor({editor:e=null,uiManager:r=null}){e?(this.#a=!1,this.#s=e):this.#a=!0,this.#c=e?._uiManager||r,this.#o=this.#c._eventBus,this.#r=e?.color?.toUpperCase()||this.#c?.highlightColors.values().next().value||"#FFFF98",Yh.#d||=Object.freeze({blue:"pdfjs-editor-colorpicker-blue",green:"pdfjs-editor-colorpicker-green",pink:"pdfjs-editor-colorpicker-pink",red:"pdfjs-editor-colorpicker-red",yellow:"pdfjs-editor-colorpicker-yellow"})}renderButton(){const e=this.#e=document.createElement("button");e.className="colorPicker",e.tabIndex="0",e.setAttribute("data-l10n-id","pdfjs-editor-colorpicker-button"),e.ariaHasPopup="true",this.#s&&(e.ariaControls=`${this.#s.id}_colorpicker_dropdown`);const r=this.#c._signal;e.addEventListener("click",this.#f.bind(this),{signal:r}),e.addEventListener("keydown",this.#g.bind(this),{signal:r});const n=this.#t=document.createElement("span");return n.className="swatch",n.ariaHidden="true",n.style.backgroundColor=this.#r,e.append(n),e}renderMainDropdown(){const e=this.#n=this.#u();return e.ariaOrientation="horizontal",e.ariaLabelledBy="highlightColorPickerLabel",e}#u(){const e=document.createElement("div"),r=this.#c._signal;e.addEventListener("contextmenu",yf,{signal:r}),e.className="dropdown",e.role="listbox",e.ariaMultiSelectable="false",e.ariaOrientation="vertical",e.setAttribute("data-l10n-id","pdfjs-editor-colorpicker-dropdown"),this.#s&&(e.id=`${this.#s.id}_colorpicker_dropdown`);for(const[n,i]of this.#c.highlightColors){const a=document.createElement("button");a.tabIndex="0",a.role="option",a.setAttribute("data-color",i),a.title=n,a.setAttribute("data-l10n-id",Yh.#d[n]);const s=document.createElement("span");a.append(s),s.className="swatch",s.style.backgroundColor=i,a.ariaSelected=i===this.#r,a.addEventListener("click",this.#p.bind(this,i),{signal:r}),e.append(a)}return e.addEventListener("keydown",this.#g.bind(this),{signal:r}),e}#p(e,r){r.stopPropagation(),this.#o.dispatch("switchannotationeditorparams",{source:this,type:_a.HIGHLIGHT_COLOR,value:e}),this.updateColor(e)}_colorSelectFromKeyboard(e){if(e.target===this.#e){this.#f(e);return}const r=e.target.getAttribute("data-color");r&&this.#p(r,e)}_moveToNext(e){if(!this.#m){this.#f(e);return}if(e.target===this.#e){this.#n.firstChild?.focus();return}e.target.nextSibling?.focus()}_moveToPrevious(e){if(e.target===this.#n?.firstChild||e.target===this.#e){this.#m&&this._hideDropdownFromKeyboard();return}this.#m||this.#f(e),e.target.previousSibling?.focus()}_moveToBeginning(e){if(!this.#m){this.#f(e);return}this.#n.firstChild?.focus()}_moveToEnd(e){if(!this.#m){this.#f(e);return}this.#n.lastChild?.focus()}#g(e){Yh._keyboardManager.exec(this,e)}#f(e){if(this.#m){this.hideDropdown();return}if(this.#i=e.detail===0,this.#l||(this.#l=new AbortController,window.addEventListener("pointerdown",this.#h.bind(this),{signal:this.#c.combinedSignal(this.#l)})),this.#e.ariaExpanded="true",this.#n){this.#n.classList.remove("hidden");return}const r=this.#n=this.#u();this.#e.append(r)}#h(e){this.#n?.contains(e.target)||this.hideDropdown()}hideDropdown(){this.#n?.classList.add("hidden"),this.#e.ariaExpanded="false",this.#l?.abort(),this.#l=null}get#m(){return this.#n&&!this.#n.classList.contains("hidden")}_hideDropdownFromKeyboard(){if(!this.#a){if(!this.#m){this.#s?.unselect();return}this.hideDropdown(),this.#e.focus({preventScroll:!0,focusVisible:this.#i})}}updateColor(e){if(this.#t&&(this.#t.style.backgroundColor=e),!this.#n)return;const r=this.#c.highlightColors.values();for(const n of this.#n.children)n.ariaSelected=r.next().value===e.toUpperCase()}destroy(){this.#e?.remove(),this.#e=null,this.#t=null,this.#n?.remove(),this.#n=null}}class JR{#e=null;#t=null;#r=null;static#n=null;constructor(e){this.#t=e,this.#r=e._uiManager,JR.#n||=Object.freeze({freetext:"pdfjs-editor-color-picker-free-text-input",ink:"pdfjs-editor-color-picker-ink-input"})}renderButton(){if(this.#e)return this.#e;const{editorType:e,colorType:r,colorValue:n}=this.#t,i=this.#e=document.createElement("input");return i.type="color",i.value=n||"#000000",i.className="basicColorPicker",i.tabIndex=0,i.setAttribute("data-l10n-id",JR.#n[e]),i.addEventListener("input",()=>{this.#r.updateParams(r,i.value)},{signal:this.#r._signal}),i}update(e){this.#e&&(this.#e.value=e)}destroy(){this.#e?.remove(),this.#e=null}hideDropdown(){}}function gTe(t){return Math.floor(Math.max(0,Math.min(1,t))*255).toString(16).padStart(2,"0")}function BA(t){return Math.max(0,Math.min(255,255*t))}class mTe{static CMYK_G([e,r,n,i]){return["G",1-Math.min(1,.3*e+.59*n+.11*r+i)]}static G_CMYK([e]){return["CMYK",0,0,0,1-e]}static G_RGB([e]){return["RGB",e,e,e]}static G_rgb([e]){return e=BA(e),[e,e,e]}static G_HTML([e]){const r=gTe(e);return`#${r}${r}${r}`}static RGB_G([e,r,n]){return["G",.3*e+.59*r+.11*n]}static RGB_rgb(e){return e.map(BA)}static RGB_HTML(e){return`#${e.map(gTe).join("")}`}static T_HTML(){return"#00000000"}static T_rgb(){return[null]}static CMYK_RGB([e,r,n,i]){return["RGB",1-Math.min(1,e+i),1-Math.min(1,n+i),1-Math.min(1,r+i)]}static CMYK_rgb([e,r,n,i]){return[BA(1-Math.min(1,e+i)),BA(1-Math.min(1,n+i)),BA(1-Math.min(1,r+i))]}static CMYK_HTML(e){const r=this.CMYK_RGB(e).slice(1);return this.RGB_HTML(r)}static RGB_CMYK([e,r,n]){const i=1-e,a=1-r,s=1-n,o=Math.min(i,a,s);return["CMYK",i,a,s,o]}}class vBt{create(e,r,n=!1){if(e<=0||r<=0)throw new Error("Invalid SVG dimensions");const i=this._createSVG("svg:svg");return i.setAttribute("version","1.1"),n||(i.setAttribute("width",`${e}px`),i.setAttribute("height",`${r}px`)),i.setAttribute("preserveAspectRatio","none"),i.setAttribute("viewBox",`0 0 ${e} ${r}`),i}createElement(e){if(typeof e!="string")throw new Error("Invalid SVG element type");return this._createSVG(e)}_createSVG(e){as("Abstract method `_createSVG` called.")}}class CP extends vBt{_createSVG(e){return document.createElementNS(Hm,e)}}class WMe{static setupStorage(e,r,n,i,a){const s=i.getValue(r,{value:null});switch(n.name){case"textarea":if(s.value!==null&&(e.textContent=s.value),a==="print")break;e.addEventListener("input",o=>{i.setValue(r,{value:o.target.value})});break;case"input":if(n.attributes.type==="radio"||n.attributes.type==="checkbox"){if(s.value===n.attributes.xfaOn?e.setAttribute("checked",!0):s.value===n.attributes.xfaOff&&e.removeAttribute("checked"),a==="print")break;e.addEventListener("change",o=>{i.setValue(r,{value:o.target.checked?o.target.getAttribute("xfaOn"):o.target.getAttribute("xfaOff")})})}else{if(s.value!==null&&e.setAttribute("value",s.value),a==="print")break;e.addEventListener("input",o=>{i.setValue(r,{value:o.target.value})})}break;case"select":if(s.value!==null){e.setAttribute("value",s.value);for(const o of n.children)o.attributes.value===s.value?o.attributes.selected=!0:o.attributes.hasOwnProperty("selected")&&delete o.attributes.selected}e.addEventListener("input",o=>{const l=o.target.options,u=l.selectedIndex===-1?"":l[l.selectedIndex].value;i.setValue(r,{value:u})});break}}static setAttributes({html:e,element:r,storage:n=null,intent:i,linkService:a}){const{attributes:s}=r,o=e instanceof HTMLAnchorElement;s.type==="radio"&&(s.name=`${s.name}-${i}`);for(const[l,u]of Object.entries(s))if(u!=null)switch(l){case"class":u.length&&e.setAttribute(l,u.join(" "));break;case"dataId":break;case"id":e.setAttribute("data-element-id",u);break;case"style":Object.assign(e.style,u);break;case"textContent":e.textContent=u;break;default:(!o||l!=="href"&&l!=="newWindow")&&e.setAttribute(l,u)}o&&a.addLinkAttributes(e,s.href,s.newWindow),n&&s.dataId&&this.setupStorage(e,s.dataId,r,n)}static render(e){const r=e.annotationStorage,n=e.linkService,i=e.xfaHtml,a=e.intent||"display",s=document.createElement(i.name);i.attributes&&this.setAttributes({html:s,element:i,intent:a,linkService:n});const o=a!=="richText",l=e.div;if(l.append(s),e.viewport){const h=`matrix(${e.viewport.transform.join(",")})`;l.style.transform=h}o&&l.setAttribute("class","xfaLayer xfaFont");const u=[];if(i.children.length===0){if(i.value){const h=document.createTextNode(i.value);s.append(h),o&&QR.shouldBuildText(i.name)&&u.push(h)}return{textDivs:u}}const d=[[i,-1,s]];for(;d.length>0;){const[h,f,p]=d.at(-1);if(f+1===h.children.length){d.pop();continue}const g=h.children[++d.at(-1)[1]];if(g===null)continue;const{name:m}=g;if(m==="#text"){const v=document.createTextNode(g.value);u.push(v),p.append(v);continue}const _=g?.attributes?.xmlns?document.createElementNS(g.attributes.xmlns,m):document.createElement(m);if(p.append(_),g.attributes&&this.setAttributes({html:_,element:g,storage:r,intent:a,linkService:n}),g.children?.length>0)d.push([g,-1,_]);else if(g.value){const v=document.createTextNode(g.value);o&&QR.shouldBuildText(m)&&u.push(v),_.append(v)}}for(const h of l.querySelectorAll(".xfaNonInteractive input, .xfaNonInteractive textarea"))h.setAttribute("readOnly",!0);return{textDivs:u}}static update(e){const r=`matrix(${e.viewport.transform.join(",")})`;e.div.style.transform=r,e.div.hidden=!1}}const yBt=9,v2=new WeakSet,bBt=new Date().getTimezoneOffset()*60*1e3;class _Te{static create(e){switch(e.data.annotationType){case qo.LINK:return new uue(e);case qo.TEXT:return new SBt(e);case qo.WIDGET:switch(e.data.fieldType){case"Tx":return new EBt(e);case"Btn":return e.data.radioButton?new KMe(e):e.data.checkBox?new CBt(e):new wBt(e);case"Ch":return new xBt(e);case"Sig":return new TBt(e)}return new eS(e);case qo.POPUP:return new Vee(e);case qo.FREETEXT:return new jMe(e);case qo.LINE:return new RBt(e);case qo.SQUARE:return new NBt(e);case qo.CIRCLE:return new OBt(e);case qo.POLYLINE:return new XMe(e);case qo.CARET:return new kBt(e);case qo.INK:return new due(e);case qo.POLYGON:return new IBt(e);case qo.HIGHLIGHT:return new QMe(e);case qo.UNDERLINE:return new DBt(e);case qo.SQUIGGLY:return new MBt(e);case qo.STRIKEOUT:return new LBt(e);case qo.STAMP:return new ZMe(e);case qo.FILEATTACHMENT:return new PBt(e);default:return new $o(e)}}}class $o{#e=null;#t=!1;#r=null;constructor(e,{isRenderable:r=!1,ignoreBorder:n=!1,createQuadrilaterals:i=!1}={}){this.isRenderable=r,this.data=e.data,this.layer=e.layer,this.linkService=e.linkService,this.downloadManager=e.downloadManager,this.imageResourcesPath=e.imageResourcesPath,this.renderForms=e.renderForms,this.svgFactory=e.svgFactory,this.annotationStorage=e.annotationStorage,this.enableScripting=e.enableScripting,this.hasJSActions=e.hasJSActions,this._fieldObjects=e.fieldObjects,this.parent=e.parent,r&&(this.container=this._createContainer(n)),i&&this._createQuadrilaterals()}static _hasPopupData({contentsObj:e,richText:r}){return!!(e?.str||r?.str)}get _isEditable(){return this.data.isEditable}get hasPopupData(){return $o._hasPopupData(this.data)}updateEdited(e){if(!this.container)return;e.rect&&(this.#e||={rect:this.data.rect.slice(0)});const{rect:r,popup:n}=e;r&&this.#n(r);let i=this.#r?.popup||this.popup;!i&&n?.text&&(this._createPopup(n),i=this.#r.popup),i&&(i.updateEdited(e),n?.deleted&&(i.remove(),this.#r=null,this.popup=null))}resetEdited(){this.#e&&(this.#n(this.#e.rect),this.#r?.popup.resetEdited(),this.#e=null)}#n(e){const{container:{style:r},data:{rect:n,rotation:i},parent:{viewport:{rawDims:{pageWidth:a,pageHeight:s,pageX:o,pageY:l}}}}=this;n?.splice(0,4,...e),r.left=`${100*(e[0]-o)/a}%`,r.top=`${100*(s-e[3]+l)/s}%`,i===0?(r.width=`${100*(e[2]-e[0])/a}%`,r.height=`${100*(e[3]-e[1])/s}%`):this.setRotation(i)}_createContainer(e){const{data:r,parent:{page:n,viewport:i}}=this,a=document.createElement("section");a.setAttribute("data-annotation-id",r.id),!(this instanceof eS)&&!(this instanceof uue)&&(a.tabIndex=0);const{style:s}=a;if(s.zIndex=this.parent.zIndex++,r.alternativeText&&(a.title=r.alternativeText),r.noRotate&&a.classList.add("norotate"),!r.rect||this instanceof Vee){const{rotation:m}=r;return!r.hasOwnCanvas&&m!==0&&this.setRotation(m,a),a}const{width:o,height:l}=this;if(!e&&r.borderStyle.width>0){s.borderWidth=`${r.borderStyle.width}px`;const m=r.borderStyle.horizontalCornerRadius,_=r.borderStyle.verticalCornerRadius;if(m>0||_>0){const b=`calc(${m}px * var(--total-scale-factor)) / calc(${_}px * var(--total-scale-factor))`;s.borderRadius=b}else if(this instanceof KMe){const b=`calc(${o}px * var(--total-scale-factor)) / calc(${l}px * var(--total-scale-factor))`;s.borderRadius=b}switch(r.borderStyle.style){case DE.SOLID:s.borderStyle="solid";break;case DE.DASHED:s.borderStyle="dashed";break;case DE.BEVELED:ki("Unimplemented border style: beveled");break;case DE.INSET:ki("Unimplemented border style: inset");break;case DE.UNDERLINE:s.borderBottomStyle="solid";break}const v=r.borderColor||null;v?(this.#t=!0,s.borderColor=Xn.makeHexColor(v[0]|0,v[1]|0,v[2]|0)):s.borderWidth=0}const u=Xn.normalizeRect([r.rect[0],n.view[3]-r.rect[1]+n.view[1],r.rect[2],n.view[3]-r.rect[3]+n.view[1]]),{pageWidth:d,pageHeight:h,pageX:f,pageY:p}=i.rawDims;s.left=`${100*(u[0]-f)/d}%`,s.top=`${100*(u[1]-p)/h}%`;const{rotation:g}=r;return r.hasOwnCanvas||g===0?(s.width=`${100*o/d}%`,s.height=`${100*l/h}%`):this.setRotation(g,a),a}setRotation(e,r=this.container){if(!this.data.rect)return;const{pageWidth:n,pageHeight:i}=this.parent.viewport.rawDims;let{width:a,height:s}=this;e%180!==0&&([a,s]=[s,a]),r.style.width=`${100*a/n}%`,r.style.height=`${100*s/i}%`,r.setAttribute("data-main-rotation",(360-e)%360)}get _commonActions(){const e=(r,n,i)=>{const a=i.detail[r],s=a[0],o=a.slice(1);i.target.style[n]=mTe[`${s}_HTML`](o),this.annotationStorage.setValue(this.data.id,{[n]:mTe[`${s}_rgb`](o)})};return na(this,"_commonActions",{display:r=>{const{display:n}=r.detail,i=n%2===1;this.container.style.visibility=i?"hidden":"visible",this.annotationStorage.setValue(this.data.id,{noView:i,noPrint:n===1||n===2})},print:r=>{this.annotationStorage.setValue(this.data.id,{noPrint:!r.detail.print})},hidden:r=>{const{hidden:n}=r.detail;this.container.style.visibility=n?"hidden":"visible",this.annotationStorage.setValue(this.data.id,{noPrint:n,noView:n})},focus:r=>{setTimeout(()=>r.target.focus({preventScroll:!1}),0)},userName:r=>{r.target.title=r.detail.userName},readonly:r=>{r.target.disabled=r.detail.readonly},required:r=>{this._setRequired(r.target,r.detail.required)},bgColor:r=>{e("bgColor","backgroundColor",r)},fillColor:r=>{e("fillColor","backgroundColor",r)},fgColor:r=>{e("fgColor","color",r)},textColor:r=>{e("textColor","color",r)},borderColor:r=>{e("borderColor","borderColor",r)},strokeColor:r=>{e("strokeColor","borderColor",r)},rotation:r=>{const n=r.detail.rotation;this.setRotation(n),this.annotationStorage.setValue(this.data.id,{rotation:n})}})}_dispatchEventFromSandbox(e,r){const n=this._commonActions;for(const i of Object.keys(r.detail))(e[i]||n[i])?.(r)}_setDefaultPropertiesFromJS(e){if(!this.enableScripting)return;const r=this.annotationStorage.getRawValue(this.data.id);if(!r)return;const n=this._commonActions;for(const[i,a]of Object.entries(r)){const s=n[i];if(s){const o={detail:{[i]:a},target:e};s(o),delete r[i]}}}_createQuadrilaterals(){if(!this.container)return;const{quadPoints:e}=this.data;if(!e)return;const[r,n,i,a]=this.data.rect.map(m=>Math.fround(m));if(e.length===8){const[m,_,v,b]=e.subarray(2,6);if(i===m&&a===_&&r===v&&n===b)return}const{style:s}=this.container;let o;if(this.#t){const{borderColor:m,borderWidth:_}=s;s.borderWidth=0,o=["url('data:image/svg+xml;utf8,",'',``],this.container.classList.add("hasBorder")}const l=i-r,u=a-n,{svgFactory:d}=this,h=d.createElement("svg");h.classList.add("quadrilateralsContainer"),h.setAttribute("width",0),h.setAttribute("height",0),h.role="none";const f=d.createElement("defs");h.append(f);const p=d.createElement("clipPath"),g=`clippath_${this.data.id}`;p.setAttribute("id",g),p.setAttribute("clipPathUnits","objectBoundingBox"),f.append(p);for(let m=2,_=e.length;m<_;m+=8){const v=e[m],b=e[m+1],y=e[m+2],E=e[m+3],T=d.createElement("rect"),C=(y-r)/l,w=(a-b)/u,x=(v-y)/l,A=(b-E)/u;T.setAttribute("x",C),T.setAttribute("y",w),T.setAttribute("width",x),T.setAttribute("height",A),p.append(T),o?.push(``)}this.#t&&(o.push("')"),s.backgroundImage=o.join("")),this.container.append(h),this.container.style.clipPath=`url(#${g})`}_createPopup(e=null){const{data:r}=this;let n,i;e?(n={str:e.text},i=e.date):(n=r.contentsObj,i=r.modificationDate);const a=this.#r=new Vee({data:{color:r.color,titleObj:r.titleObj,modificationDate:i,contentsObj:n,richText:r.richText,parentRect:r.rect,borderStyle:0,id:`popup_${r.id}`,rotation:r.rotation,noRotate:!0},linkService:this.linkService,parent:this.parent,elements:[this]});this.parent.div.append(a.render())}get hasPopupElement(){return!!(this.#r||this.popup||this.data.popupRef)}render(){as("Abstract method `AnnotationElement.render` called")}_getElementsByName(e,r=null){const n=[];if(this._fieldObjects){const i=this._fieldObjects[e];if(i)for(const{page:a,id:s,exportValues:o}of i){if(a===-1||s===r)continue;const l=typeof o=="string"?o:null,u=document.querySelector(`[data-element-id="${s}"]`);if(u&&!v2.has(u)){ki(`_getElementsByName - element not allowed: ${s}`);continue}n.push({id:s,exportValue:l,domElement:u})}return n}for(const i of document.getElementsByName(e)){const{exportValue:a}=i,s=i.getAttribute("data-element-id");s!==r&&v2.has(i)&&n.push({id:s,exportValue:a,domElement:i})}return n}show(){this.container&&(this.container.hidden=!1),this.popup?.maybeShow()}hide(){this.container&&(this.container.hidden=!0),this.popup?.forceHide()}getElementsToTriggerPopup(){return this.container}addHighlightArea(){const e=this.getElementsToTriggerPopup();if(Array.isArray(e))for(const r of e)r.classList.add("highlightArea");else e.classList.add("highlightArea")}_editOnDoubleClick(){if(!this._isEditable)return;const{annotationEditorType:e,data:{id:r}}=this;this.container.addEventListener("dblclick",()=>{this.linkService.eventBus?.dispatch("switchannotationeditormode",{source:this,mode:e,editId:r,mustEnterInEditMode:!0})})}get width(){return this.data.rect[2]-this.data.rect[0]}get height(){return this.data.rect[3]-this.data.rect[1]}}class uue extends $o{constructor(e,r=null){super(e,{isRenderable:!0,ignoreBorder:!!r?.ignoreBorder,createQuadrilaterals:!0}),this.isTooltipOnly=e.data.isTooltipOnly}render(){const{data:e,linkService:r}=this,n=document.createElement("a");n.setAttribute("data-element-id",e.id);let i=!1;return e.url?(r.addLinkAttributes(n,e.url,e.newWindow),i=!0):e.action?(this._bindNamedAction(n,e.action,e.overlaidText),i=!0):e.attachment?(this.#t(n,e.attachment,e.overlaidText,e.attachmentDest),i=!0):e.setOCGState?(this.#r(n,e.setOCGState,e.overlaidText),i=!0):e.dest?(this._bindLink(n,e.dest,e.overlaidText),i=!0):(e.actions&&(e.actions.Action||e.actions["Mouse Up"]||e.actions["Mouse Down"])&&this.enableScripting&&this.hasJSActions&&(this._bindJSAction(n,e),i=!0),e.resetForm?(this._bindResetFormAction(n,e.resetForm),i=!0):this.isTooltipOnly&&!i&&(this._bindLink(n,""),i=!0)),this.container.classList.add("linkAnnotation"),i&&this.container.append(n),this.container}#e(){this.container.setAttribute("data-internal-link","")}_bindLink(e,r,n=""){e.href=this.linkService.getDestinationHash(r),e.onclick=()=>(r&&this.linkService.goToDestination(r),!1),(r||r==="")&&this.#e(),n&&(e.title=n)}_bindNamedAction(e,r,n=""){e.href=this.linkService.getAnchorUrl(""),e.onclick=()=>(this.linkService.executeNamedAction(r),!1),n&&(e.title=n),this.#e()}#t(e,r,n="",i=null){e.href=this.linkService.getAnchorUrl(""),r.description?e.title=r.description:n&&(e.title=n),e.onclick=()=>(this.downloadManager?.openOrDownloadData(r.content,r.filename,i),!1),this.#e()}#r(e,r,n=""){e.href=this.linkService.getAnchorUrl(""),e.onclick=()=>(this.linkService.executeSetOCGState(r),!1),n&&(e.title=n),this.#e()}_bindJSAction(e,r){e.href=this.linkService.getAnchorUrl("");const n=new Map([["Action","onclick"],["Mouse Up","onmouseup"],["Mouse Down","onmousedown"]]);for(const i of Object.keys(r.actions)){const a=n.get(i);a&&(e[a]=()=>(this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r.id,name:i}}),!1))}r.overlaidText&&(e.title=r.overlaidText),e.onclick||(e.onclick=()=>!1),this.#e()}_bindResetFormAction(e,r){const n=e.onclick;if(n||(e.href=this.linkService.getAnchorUrl("")),this.#e(),!this._fieldObjects){ki('_bindResetFormAction - "resetForm" action not supported, ensure that the `fieldObjects` parameter is provided.'),n||(e.onclick=()=>!1);return}e.onclick=()=>{n?.();const{fields:i,refs:a,include:s}=r,o=[];if(i.length!==0||a.length!==0){const d=new Set(a);for(const h of i){const f=this._fieldObjects[h]||[];for(const{id:p}of f)d.add(p)}for(const h of Object.values(this._fieldObjects))for(const f of h)d.has(f.id)===s&&o.push(f)}else for(const d of Object.values(this._fieldObjects))o.push(...d);const l=this.annotationStorage,u=[];for(const d of o){const{id:h}=d;switch(u.push(h),d.type){case"text":{const p=d.defaultValue||"";l.setValue(h,{value:p});break}case"checkbox":case"radiobutton":{const p=d.defaultValue===d.exportValues;l.setValue(h,{value:p});break}case"combobox":case"listbox":{const p=d.defaultValue||"";l.setValue(h,{value:p});break}default:continue}const f=document.querySelector(`[data-element-id="${h}"]`);if(f){if(!v2.has(f)){ki(`_bindResetFormAction - element not allowed: ${h}`);continue}}else continue;f.dispatchEvent(new Event("resetform"))}return this.enableScripting&&this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:"app",ids:u,name:"ResetForm"}}),!1}}}class SBt extends $o{constructor(e){super(e,{isRenderable:!0})}render(){this.container.classList.add("textAnnotation");const e=document.createElement("img");return e.src=this.imageResourcesPath+"annotation-"+this.data.name.toLowerCase()+".svg",e.setAttribute("data-l10n-id","pdfjs-text-annotation-type"),e.setAttribute("data-l10n-args",JSON.stringify({type:this.data.name})),!this.data.popupRef&&this.hasPopupData&&this._createPopup(),this.container.append(e),this.container}}class eS extends $o{render(){return this.container}showElementAndHideCanvas(e){this.data.hasOwnCanvas&&(e.previousSibling?.nodeName==="CANVAS"&&(e.previousSibling.hidden=!0),e.hidden=!1)}_getKeyModifier(e){return Sc.platform.isMac?e.metaKey:e.ctrlKey}_setEventListener(e,r,n,i,a){n.includes("mouse")?e.addEventListener(n,s=>{this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:this.data.id,name:i,value:a(s),shift:s.shiftKey,modifier:this._getKeyModifier(s)}})}):e.addEventListener(n,s=>{if(n==="blur"){if(!r.focused||!s.relatedTarget)return;r.focused=!1}else if(n==="focus"){if(r.focused)return;r.focused=!0}a&&this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:this.data.id,name:i,value:a(s)}})})}_setEventListeners(e,r,n,i){for(const[a,s]of n)(s==="Action"||this.data.actions?.[s])&&((s==="Focus"||s==="Blur")&&(r||={focused:!1}),this._setEventListener(e,r,a,s,i),s==="Focus"&&!this.data.actions?.Blur?this._setEventListener(e,r,"blur","Blur",null):s==="Blur"&&!this.data.actions?.Focus&&this._setEventListener(e,r,"focus","Focus",null))}_setBackgroundColor(e){const r=this.data.backgroundColor||null;e.style.backgroundColor=r===null?"transparent":Xn.makeHexColor(r[0],r[1],r[2])}_setTextStyle(e){const r=["left","center","right"],{fontColor:n}=this.data.defaultAppearanceData,i=this.data.defaultAppearanceData.fontSize||yBt,a=e.style;let s;const o=2,l=u=>Math.round(10*u)/10;if(this.data.multiLine){const u=Math.abs(this.data.rect[3]-this.data.rect[1]-o),d=Math.round(u/(PK*i))||1,h=u/d;s=Math.min(i,l(h/PK))}else{const u=Math.abs(this.data.rect[3]-this.data.rect[1]-o);s=Math.min(i,l(u/PK))}a.fontSize=`calc(${s}px * var(--total-scale-factor))`,a.color=Xn.makeHexColor(n[0],n[1],n[2]),this.data.textAlignment!==null&&(a.textAlign=r[this.data.textAlignment])}_setRequired(e,r){r?e.setAttribute("required",!0):e.removeAttribute("required"),e.setAttribute("aria-required",r)}}class EBt extends eS{constructor(e){const r=e.renderForms||e.data.hasOwnCanvas||!e.data.hasAppearance&&!!e.data.fieldValue;super(e,{isRenderable:r})}setPropertyOnSiblings(e,r,n,i){const a=this.annotationStorage;for(const s of this._getElementsByName(e.name,e.id))s.domElement&&(s.domElement[r]=n),a.setValue(s.id,{[i]:n})}render(){const e=this.annotationStorage,r=this.data.id;this.container.classList.add("textWidgetAnnotation");let n=null;if(this.renderForms){const i=e.getValue(r,{value:this.data.fieldValue});let a=i.value||"";const s=e.getValue(r,{charLimit:this.data.maxLen}).charLimit;s&&a.length>s&&(a=a.slice(0,s));let o=i.formattedValue||this.data.textContent?.join(` +`)||null;o&&this.data.comb&&(o=o.replaceAll(/\s+/g,""));const l={userValue:a,formattedValue:o,lastCommittedValue:null,commitKey:1,focused:!1};this.data.multiLine?(n=document.createElement("textarea"),n.textContent=o??a,this.data.doNotScroll&&(n.style.overflowY="hidden")):(n=document.createElement("input"),n.type=this.data.password?"password":"text",n.setAttribute("value",o??a),this.data.doNotScroll&&(n.style.overflowX="hidden")),this.data.hasOwnCanvas&&(n.hidden=!0),v2.add(n),n.setAttribute("data-element-id",r),n.disabled=this.data.readOnly,n.name=this.data.fieldName,n.tabIndex=0;const{datetimeFormat:u,datetimeType:d,timeStep:h}=this.data,f=!!d&&this.enableScripting;u&&(n.title=u),this._setRequired(n,this.data.required),s&&(n.maxLength=s),n.addEventListener("input",g=>{e.setValue(r,{value:g.target.value}),this.setPropertyOnSiblings(n,"value",g.target.value,"value"),l.formattedValue=null}),n.addEventListener("resetform",g=>{const m=this.data.defaultFieldValue??"";n.value=l.userValue=m,l.formattedValue=null});let p=g=>{const{formattedValue:m}=l;m!=null&&(g.target.value=m),g.target.scrollLeft=0};if(this.enableScripting&&this.hasJSActions){n.addEventListener("focus",m=>{if(l.focused)return;const{target:_}=m;if(f&&(_.type=d,h&&(_.step=h)),l.userValue){const v=l.userValue;if(f)if(d==="time"){const b=new Date(v),y=[b.getHours(),b.getMinutes(),b.getSeconds()];_.value=y.map(E=>E.toString().padStart(2,"0")).join(":")}else _.value=new Date(v-bBt).toISOString().split(d==="date"?"T":".",1)[0];else _.value=v}l.lastCommittedValue=_.value,l.commitKey=1,this.data.actions?.Focus||(l.focused=!0)}),n.addEventListener("updatefromsandbox",m=>{this.showElementAndHideCanvas(m.target);const _={value(v){l.userValue=v.detail.value??"",f||e.setValue(r,{value:l.userValue.toString()}),v.target.value=l.userValue},formattedValue(v){const{formattedValue:b}=v.detail;l.formattedValue=b,b!=null&&v.target!==document.activeElement&&(v.target.value=b);const y={formattedValue:b};f&&(y.value=b),e.setValue(r,y)},selRange(v){v.target.setSelectionRange(...v.detail.selRange)},charLimit:v=>{const{charLimit:b}=v.detail,{target:y}=v;if(b===0){y.removeAttribute("maxLength");return}y.setAttribute("maxLength",b);let E=l.userValue;!E||E.length<=b||(E=E.slice(0,b),y.value=l.userValue=E,e.setValue(r,{value:E}),this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r,name:"Keystroke",value:E,willCommit:!0,commitKey:1,selStart:y.selectionStart,selEnd:y.selectionEnd}}))}};this._dispatchEventFromSandbox(_,m)}),n.addEventListener("keydown",m=>{l.commitKey=1;let _=-1;if(m.key==="Escape"?_=0:m.key==="Enter"&&!this.data.multiLine?_=2:m.key==="Tab"&&(l.commitKey=3),_===-1)return;const{value:v}=m.target;l.lastCommittedValue!==v&&(l.lastCommittedValue=v,l.userValue=v,this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r,name:"Keystroke",value:v,willCommit:!0,commitKey:_,selStart:m.target.selectionStart,selEnd:m.target.selectionEnd}}))});const g=p;p=null,n.addEventListener("blur",m=>{if(!l.focused||!m.relatedTarget)return;this.data.actions?.Blur||(l.focused=!1);const{target:_}=m;let{value:v}=_;if(f){if(v&&d==="time"){const b=v.split(":").map(y=>parseInt(y,10));v=new Date(2e3,0,1,b[0],b[1],b[2]||0).valueOf(),_.step=""}else v=new Date(v).valueOf();_.type="text"}l.userValue=v,l.lastCommittedValue!==v&&this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r,name:"Keystroke",value:v,willCommit:!0,commitKey:l.commitKey,selStart:m.target.selectionStart,selEnd:m.target.selectionEnd}}),g(m)}),this.data.actions?.Keystroke&&n.addEventListener("beforeinput",m=>{l.lastCommittedValue=null;const{data:_,target:v}=m,{value:b,selectionStart:y,selectionEnd:E}=v;let T=y,C=E;switch(m.inputType){case"deleteWordBackward":{const w=b.substring(0,y).match(/\w*[^\w]*$/);w&&(T-=w[0].length);break}case"deleteWordForward":{const w=b.substring(y).match(/^[^\w]*\w*/);w&&(C+=w[0].length);break}case"deleteContentBackward":y===E&&(T-=1);break;case"deleteContentForward":y===E&&(C+=1);break}m.preventDefault(),this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r,name:"Keystroke",value:b,change:_||"",willCommit:!1,selStart:T,selEnd:C}})}),this._setEventListeners(n,l,[["focus","Focus"],["blur","Blur"],["mousedown","Mouse Down"],["mouseenter","Mouse Enter"],["mouseleave","Mouse Exit"],["mouseup","Mouse Up"]],m=>m.target.value)}if(p&&n.addEventListener("blur",p),this.data.comb){const m=(this.data.rect[2]-this.data.rect[0])/s;n.classList.add("comb"),n.style.letterSpacing=`calc(${m}px * var(--total-scale-factor) - 1ch)`}}else n=document.createElement("div"),n.textContent=this.data.fieldValue,n.style.verticalAlign="middle",n.style.display="table-cell",this.data.hasOwnCanvas&&(n.hidden=!0);return this._setTextStyle(n),this._setBackgroundColor(n),this._setDefaultPropertiesFromJS(n),this.container.append(n),this.container}}class TBt extends eS{constructor(e){super(e,{isRenderable:!!e.data.hasOwnCanvas})}}class CBt extends eS{constructor(e){super(e,{isRenderable:e.renderForms})}render(){const e=this.annotationStorage,r=this.data,n=r.id;let i=e.getValue(n,{value:r.exportValue===r.fieldValue}).value;typeof i=="string"&&(i=i!=="Off",e.setValue(n,{value:i})),this.container.classList.add("buttonWidgetAnnotation","checkBox");const a=document.createElement("input");return v2.add(a),a.setAttribute("data-element-id",n),a.disabled=r.readOnly,this._setRequired(a,this.data.required),a.type="checkbox",a.name=r.fieldName,i&&a.setAttribute("checked",!0),a.setAttribute("exportValue",r.exportValue),a.tabIndex=0,a.addEventListener("change",s=>{const{name:o,checked:l}=s.target;for(const u of this._getElementsByName(o,n)){const d=l&&u.exportValue===r.exportValue;u.domElement&&(u.domElement.checked=d),e.setValue(u.id,{value:d})}e.setValue(n,{value:l})}),a.addEventListener("resetform",s=>{const o=r.defaultFieldValue||"Off";s.target.checked=o===r.exportValue}),this.enableScripting&&this.hasJSActions&&(a.addEventListener("updatefromsandbox",s=>{const o={value(l){l.target.checked=l.detail.value!=="Off",e.setValue(n,{value:l.target.checked})}};this._dispatchEventFromSandbox(o,s)}),this._setEventListeners(a,null,[["change","Validate"],["change","Action"],["focus","Focus"],["blur","Blur"],["mousedown","Mouse Down"],["mouseenter","Mouse Enter"],["mouseleave","Mouse Exit"],["mouseup","Mouse Up"]],s=>s.target.checked)),this._setBackgroundColor(a),this._setDefaultPropertiesFromJS(a),this.container.append(a),this.container}}class KMe extends eS{constructor(e){super(e,{isRenderable:e.renderForms})}render(){this.container.classList.add("buttonWidgetAnnotation","radioButton");const e=this.annotationStorage,r=this.data,n=r.id;let i=e.getValue(n,{value:r.fieldValue===r.buttonValue}).value;if(typeof i=="string"&&(i=i!==r.buttonValue,e.setValue(n,{value:i})),i)for(const s of this._getElementsByName(r.fieldName,n))e.setValue(s.id,{value:!1});const a=document.createElement("input");if(v2.add(a),a.setAttribute("data-element-id",n),a.disabled=r.readOnly,this._setRequired(a,this.data.required),a.type="radio",a.name=r.fieldName,i&&a.setAttribute("checked",!0),a.tabIndex=0,a.addEventListener("change",s=>{const{name:o,checked:l}=s.target;for(const u of this._getElementsByName(o,n))e.setValue(u.id,{value:!1});e.setValue(n,{value:l})}),a.addEventListener("resetform",s=>{const o=r.defaultFieldValue;s.target.checked=o!=null&&o===r.buttonValue}),this.enableScripting&&this.hasJSActions){const s=r.buttonValue;a.addEventListener("updatefromsandbox",o=>{const l={value:u=>{const d=s===u.detail.value;for(const h of this._getElementsByName(u.target.name)){const f=d&&h.id===n;h.domElement&&(h.domElement.checked=f),e.setValue(h.id,{value:f})}}};this._dispatchEventFromSandbox(l,o)}),this._setEventListeners(a,null,[["change","Validate"],["change","Action"],["focus","Focus"],["blur","Blur"],["mousedown","Mouse Down"],["mouseenter","Mouse Enter"],["mouseleave","Mouse Exit"],["mouseup","Mouse Up"]],o=>o.target.checked)}return this._setBackgroundColor(a),this._setDefaultPropertiesFromJS(a),this.container.append(a),this.container}}class wBt extends uue{constructor(e){super(e,{ignoreBorder:e.data.hasAppearance})}render(){const e=super.render();e.classList.add("buttonWidgetAnnotation","pushButton");const r=e.lastChild;return this.enableScripting&&this.hasJSActions&&r&&(this._setDefaultPropertiesFromJS(r),r.addEventListener("updatefromsandbox",n=>{this._dispatchEventFromSandbox({},n)})),e}}class xBt extends eS{constructor(e){super(e,{isRenderable:e.renderForms})}render(){this.container.classList.add("choiceWidgetAnnotation");const e=this.annotationStorage,r=this.data.id,n=e.getValue(r,{value:this.data.fieldValue}),i=document.createElement("select");v2.add(i),i.setAttribute("data-element-id",r),i.disabled=this.data.readOnly,this._setRequired(i,this.data.required),i.name=this.data.fieldName,i.tabIndex=0;let a=this.data.combo&&this.data.options.length>0;this.data.combo||(i.size=this.data.options.length,this.data.multiSelect&&(i.multiple=!0)),i.addEventListener("resetform",d=>{const h=this.data.defaultFieldValue;for(const f of i.options)f.selected=f.value===h});for(const d of this.data.options){const h=document.createElement("option");h.textContent=d.displayValue,h.value=d.exportValue,n.value.includes(d.exportValue)&&(h.setAttribute("selected",!0),a=!1),i.append(h)}let s=null;if(a){const d=document.createElement("option");d.value=" ",d.setAttribute("hidden",!0),d.setAttribute("selected",!0),i.prepend(d),s=()=>{d.remove(),i.removeEventListener("input",s),s=null},i.addEventListener("input",s)}const o=d=>{const h=d?"value":"textContent",{options:f,multiple:p}=i;return p?Array.prototype.filter.call(f,g=>g.selected).map(g=>g[h]):f.selectedIndex===-1?null:f[f.selectedIndex][h]};let l=o(!1);const u=d=>{const h=d.target.options;return Array.prototype.map.call(h,f=>({displayValue:f.textContent,exportValue:f.value}))};return this.enableScripting&&this.hasJSActions?(i.addEventListener("updatefromsandbox",d=>{const h={value(f){s?.();const p=f.detail.value,g=new Set(Array.isArray(p)?p:[p]);for(const m of i.options)m.selected=g.has(m.value);e.setValue(r,{value:o(!0)}),l=o(!1)},multipleSelection(f){i.multiple=!0},remove(f){const p=i.options,g=f.detail.remove;p[g].selected=!1,i.remove(g),p.length>0&&Array.prototype.findIndex.call(p,_=>_.selected)===-1&&(p[0].selected=!0),e.setValue(r,{value:o(!0),items:u(f)}),l=o(!1)},clear(f){for(;i.length!==0;)i.remove(0);e.setValue(r,{value:null,items:[]}),l=o(!1)},insert(f){const{index:p,displayValue:g,exportValue:m}=f.detail.insert,_=i.children[p],v=document.createElement("option");v.textContent=g,v.value=m,_?_.before(v):i.append(v),e.setValue(r,{value:o(!0),items:u(f)}),l=o(!1)},items(f){const{items:p}=f.detail;for(;i.length!==0;)i.remove(0);for(const g of p){const{displayValue:m,exportValue:_}=g,v=document.createElement("option");v.textContent=m,v.value=_,i.append(v)}i.options.length>0&&(i.options[0].selected=!0),e.setValue(r,{value:o(!0),items:u(f)}),l=o(!1)},indices(f){const p=new Set(f.detail.indices);for(const g of f.target.options)g.selected=p.has(g.index);e.setValue(r,{value:o(!0)}),l=o(!1)},editable(f){f.target.disabled=!f.detail.editable}};this._dispatchEventFromSandbox(h,d)}),i.addEventListener("input",d=>{const h=o(!0),f=o(!1);e.setValue(r,{value:h}),d.preventDefault(),this.linkService.eventBus?.dispatch("dispatcheventinsandbox",{source:this,detail:{id:r,name:"Keystroke",value:l,change:f,changeEx:h,willCommit:!1,commitKey:1,keyDown:!1}})}),this._setEventListeners(i,null,[["focus","Focus"],["blur","Blur"],["mousedown","Mouse Down"],["mouseenter","Mouse Enter"],["mouseleave","Mouse Exit"],["mouseup","Mouse Up"],["input","Action"],["input","Validate"]],d=>d.target.value)):i.addEventListener("input",function(d){e.setValue(r,{value:o(!0)})}),this.data.combo&&this._setTextStyle(i),this._setBackgroundColor(i),this._setDefaultPropertiesFromJS(i),this.container.append(i),this.container}}class Vee extends $o{constructor(e){const{data:r,elements:n}=e;super(e,{isRenderable:$o._hasPopupData(r)}),this.elements=n,this.popup=null}render(){const{container:e}=this;e.classList.add("popupAnnotation"),e.role="comment";const r=this.popup=new ABt({container:this.container,color:this.data.color,titleObj:this.data.titleObj,modificationDate:this.data.modificationDate||this.data.creationDate,contentsObj:this.data.contentsObj,richText:this.data.richText,rect:this.data.rect,parentRect:this.data.parentRect||null,parent:this.parent,elements:this.elements,open:this.data.open}),n=[];for(const i of this.elements)i.popup=r,i.container.ariaHasPopup="dialog",n.push(i.data.id),i.addHighlightArea();return this.container.setAttribute("aria-controls",n.map(i=>`${Jce}${i}`).join(",")),this.container}}class ABt{#e=this.#O.bind(this);#t=this.#k.bind(this);#r=this.#A.bind(this);#n=this.#R.bind(this);#i=null;#a=null;#s=null;#o=null;#l=null;#c=null;#d=null;#u=!1;#p=null;#g=null;#f=null;#h=null;#m=null;#v=null;#_=null;#S=!1;constructor({container:e,color:r,elements:n,titleObj:i,modificationDate:a,contentsObj:s,richText:o,parent:l,rect:u,parentRect:d,open:h}){this.#a=e,this.#v=i,this.#s=s,this.#m=o,this.#c=l,this.#i=r,this.#h=u,this.#d=d,this.#l=n,this.#o=$ee.toDateObject(a),this.trigger=n.flatMap(f=>f.getElementsToTriggerPopup()),this.#b(),this.#a.hidden=!0,h&&this.#R()}#b(){if(this.#g)return;this.#g=new AbortController;const{signal:e}=this.#g;for(const r of this.trigger)r.addEventListener("click",this.#n,{signal:e}),r.addEventListener("mouseenter",this.#r,{signal:e}),r.addEventListener("mouseleave",this.#t,{signal:e}),r.classList.add("popupTriggerArea");for(const r of this.#l)r.container?.addEventListener("keydown",this.#e,{signal:e})}render(){if(this.#p)return;const e=this.#p=document.createElement("div");if(e.className="popup",this.#i){const i=e.style.outlineColor=Xn.makeHexColor(...this.#i);e.style.backgroundColor=`color-mix(in srgb, ${i} 30%, white)`}const r=document.createElement("span");if(r.className="header",this.#v?.str){const i=document.createElement("span");i.className="title",r.append(i),{dir:i.dir,str:i.textContent}=this.#v}if(e.append(r),this.#o){const i=document.createElement("time");i.className="popupDate",i.setAttribute("data-l10n-id","pdfjs-annotation-date-time-string"),i.setAttribute("data-l10n-args",JSON.stringify({dateObj:this.#o.valueOf()})),i.dateTime=this.#o.toISOString(),r.append(i)}const n=this.#y;if(n)WMe.render({xfaHtml:n,intent:"richText",div:e}),e.lastChild.classList.add("richText","popupContent");else{const i=this._formatContents(this.#s);e.append(i)}this.#a.append(e)}get#y(){const e=this.#m,r=this.#s;return e?.str&&(!r?.str||r.str===e.str)&&this.#m.html||null}get#E(){return this.#y?.attributes?.style?.fontSize||0}get#C(){return this.#y?.attributes?.style?.color||null}#w(e){const r=[],n={str:e,html:{name:"div",attributes:{dir:"auto"},children:[{name:"p",children:r}]}},i={style:{color:this.#C,fontSize:this.#E?`calc(${this.#E}px * var(--total-scale-factor))`:""}};for(const a of e.split(` +`))r.push({name:"span",value:a,attributes:i});return n}_formatContents({str:e,dir:r}){const n=document.createElement("p");n.classList.add("popupContent"),n.dir=r;const i=e.split(/(?:\r\n?|\n)/);for(let a=0,s=i.length;a=0&&a.setAttribute("stroke-width",r||1),n)for(let s=0,o=this.#t.length;s{a.key==="Enter"&&(i?a.metaKey:a.ctrlKey)&&this.#t()}),!r.popupRef&&this.hasPopupData?this._createPopup():n.classList.add("popupTriggerArea"),e.append(n),e}getElementsToTriggerPopup(){return this.#e}addHighlightArea(){this.container.classList.add("highlightArea")}#t(){this.downloadManager?.openOrDownloadData(this.content,this.filename)}}class hue{#e=null;#t=null;#r=new Map;#n=null;constructor({div:e,accessibilityManager:r,annotationCanvasMap:n,annotationEditorUIManager:i,page:a,viewport:s,structTreeLayer:o}){this.div=e,this.#e=r,this.#t=n,this.#n=o||null,this.page=a,this.viewport=s,this.zIndex=0,this._annotationEditorUIManager=i}hasEditableAnnotations(){return this.#r.size>0}async#i(e,r,n){const i=e.firstChild||e,a=i.id=`${Jce}${r}`,s=await this.#n?.getAriaAttributes(a);if(s)for(const[o,l]of s)i.setAttribute(o,l);n?n.at(-1).container.after(e):(this.div.append(e),this.#e?.moveElementInDOM(this.div,e,i,!1))}async render(e){const{annotations:r}=e,n=this.div;_2(n,this.viewport);const i=new Map,a={data:null,layer:n,linkService:e.linkService,downloadManager:e.downloadManager,imageResourcesPath:e.imageResourcesPath||"",renderForms:e.renderForms!==!1,svgFactory:new CP,annotationStorage:e.annotationStorage||new iue,enableScripting:e.enableScripting===!0,hasJSActions:e.hasJSActions,fieldObjects:e.fieldObjects,parent:this,elements:null};for(const s of r){if(s.noHTML)continue;const o=s.annotationType===qo.POPUP;if(o){const d=i.get(s.id);if(!d)continue;a.elements=d}else if(s.rect[2]===s.rect[0]||s.rect[3]===s.rect[1])continue;a.data=s;const l=_Te.create(a);if(!l.isRenderable)continue;if(!o&&s.popupRef){const d=i.get(s.popupRef);d?d.push(l):i.set(s.popupRef,[l])}const u=l.render();s.hidden&&(u.style.visibility="hidden"),await this.#i(u,s.id,a.elements),l._isEditable&&(this.#r.set(l.data.id,l),this._annotationEditorUIManager?.renderAnnotationElement(l))}this.#a()}async addLinkAnnotations(e,r){const n={data:null,layer:this.div,linkService:r,svgFactory:new CP,parent:this};for(const i of e){i.borderStyle||=hue._defaultBorderStyle,n.data=i;const a=_Te.create(n);if(!a.isRenderable)continue;const s=a.render();await this.#i(s,i.id,null)}}update({viewport:e}){const r=this.div;this.viewport=e,_2(r,{rotation:e.rotation}),this.#a(),r.hidden=!1}#a(){if(!this.#t)return;const e=this.div;for(const[r,n]of this.#t){const i=e.querySelector(`[data-annotation-id="${r}"]`);if(!i)continue;n.className="annotationContent";const{firstChild:a}=i;a?a.nodeName==="CANVAS"?a.replaceWith(n):a.classList.contains("annotationContent")?a.after(n):a.before(n):i.append(n);const s=this.#r.get(r);s&&(s._hasNoCanvas?(this._annotationEditorUIManager?.setMissingCanvas(r,i.id,n),s._hasNoCanvas=!1):s.canvas=n)}this.#t.clear()}getEditableAnnotations(){return Array.from(this.#r.values())}getEditableAnnotation(e){return this.#r.get(e)}static get _defaultBorderStyle(){return na(this,"_defaultBorderStyle",Object.freeze({width:1,rawWidth:1,style:DE.SOLID,dashArray:[3],horizontalCornerRadius:0,verticalCornerRadius:0}))}}const KI=/\r\n?|\n/g;class pl extends ti{#e;#t="";#r=`${this.id}-editor`;#n=null;#i;_colorPicker=null;static _freeTextDefaultContent="";static _internalPadding=0;static _defaultColor=null;static _defaultFontSize=10;static get _keyboardManager(){const e=pl.prototype,r=a=>a.isEmpty(),n=Z_.TRANSLATE_SMALL,i=Z_.TRANSLATE_BIG;return na(this,"_keyboardManager",new Q8([[["ctrl+s","mac+meta+s","ctrl+p","mac+meta+p"],e.commitOrRemove,{bubbles:!0}],[["ctrl+Enter","mac+meta+Enter","Escape","mac+Escape"],e.commitOrRemove],[["ArrowLeft","mac+ArrowLeft"],e._translateEmpty,{args:[-n,0],checker:r}],[["ctrl+ArrowLeft","mac+shift+ArrowLeft"],e._translateEmpty,{args:[-i,0],checker:r}],[["ArrowRight","mac+ArrowRight"],e._translateEmpty,{args:[n,0],checker:r}],[["ctrl+ArrowRight","mac+shift+ArrowRight"],e._translateEmpty,{args:[i,0],checker:r}],[["ArrowUp","mac+ArrowUp"],e._translateEmpty,{args:[0,-n],checker:r}],[["ctrl+ArrowUp","mac+shift+ArrowUp"],e._translateEmpty,{args:[0,-i],checker:r}],[["ArrowDown","mac+ArrowDown"],e._translateEmpty,{args:[0,n],checker:r}],[["ctrl+ArrowDown","mac+shift+ArrowDown"],e._translateEmpty,{args:[0,i],checker:r}]]))}static _type="freetext";static _editorType=Ii.FREETEXT;constructor(e){super({...e,name:"freeTextEditor"}),this.#e=e.color||pl._defaultColor||ti._defaultLineColor,this.#i=e.fontSize||pl._defaultFontSize,this.annotationElementId||this._uiManager.a11yAlert("pdfjs-editor-freetext-added-alert")}static initialize(e,r){ti.initialize(e,r);const n=getComputedStyle(document.documentElement);this._internalPadding=parseFloat(n.getPropertyValue("--freetext-padding"))}static updateDefaultParams(e,r){switch(e){case _a.FREETEXT_SIZE:pl._defaultFontSize=r;break;case _a.FREETEXT_COLOR:pl._defaultColor=r;break}}updateParams(e,r){switch(e){case _a.FREETEXT_SIZE:this.#a(r);break;case _a.FREETEXT_COLOR:this.#s(r);break}}static get defaultPropertiesToUpdate(){return[[_a.FREETEXT_SIZE,pl._defaultFontSize],[_a.FREETEXT_COLOR,pl._defaultColor||ti._defaultLineColor]]}get propertiesToUpdate(){return[[_a.FREETEXT_SIZE,this.#i],[_a.FREETEXT_COLOR,this.#e]]}get toolbarButtons(){return this._colorPicker||=new JR(this),[["colorPicker",this._colorPicker]]}get colorType(){return _a.FREETEXT_COLOR}get colorValue(){return this.#e}#a(e){const r=i=>{this.editorDiv.style.fontSize=`calc(${i}px * var(--total-scale-factor))`,this.translate(0,-(i-this.#i)*this.parentScale),this.#i=i,this.#l()},n=this.#i;this.addCommands({cmd:r.bind(this,e),undo:r.bind(this,n),post:this._uiManager.updateUI.bind(this._uiManager,this),mustExec:!0,type:_a.FREETEXT_SIZE,overwriteIfSameType:!0,keepUndo:!0})}#s(e){const r=i=>{this.#e=this.editorDiv.style.color=i,this._colorPicker?.update(i)},n=this.#e;this.addCommands({cmd:r.bind(this,e),undo:r.bind(this,n),post:this._uiManager.updateUI.bind(this._uiManager,this),mustExec:!0,type:_a.FREETEXT_COLOR,overwriteIfSameType:!0,keepUndo:!0})}_translateEmpty(e,r){this._uiManager.translateSelectedEditors(e,r,!0)}getInitialTranslation(){const e=this.parentScale;return[-pl._internalPadding*e,-(pl._internalPadding+this.#i)*e]}rebuild(){this.parent&&(super.rebuild(),this.div!==null&&(this.isAttachedToDOM||this.parent.add(this)))}enableEditMode(){if(!super.enableEditMode())return!1;this.overlayDiv.classList.remove("enabled"),this.editorDiv.contentEditable=!0,this._isDraggable=!1,this.div.removeAttribute("aria-activedescendant"),this.#n=new AbortController;const e=this._uiManager.combinedSignal(this.#n);return this.editorDiv.addEventListener("keydown",this.editorDivKeydown.bind(this),{signal:e}),this.editorDiv.addEventListener("focus",this.editorDivFocus.bind(this),{signal:e}),this.editorDiv.addEventListener("blur",this.editorDivBlur.bind(this),{signal:e}),this.editorDiv.addEventListener("input",this.editorDivInput.bind(this),{signal:e}),this.editorDiv.addEventListener("paste",this.editorDivPaste.bind(this),{signal:e}),!0}disableEditMode(){return super.disableEditMode()?(this.overlayDiv.classList.add("enabled"),this.editorDiv.contentEditable=!1,this.div.setAttribute("aria-activedescendant",this.#r),this._isDraggable=!0,this.#n?.abort(),this.#n=null,this.div.focus({preventScroll:!0}),this.isEditing=!1,this.parent.div.classList.add("freetextEditing"),!0):!1}focusin(e){this._focusEventsAllowed&&(super.focusin(e),e.target!==this.editorDiv&&this.editorDiv.focus())}onceAdded(e){this.width||(this.enableEditMode(),e&&this.editorDiv.focus(),this._initialOptions?.isCentered&&this.center(),this._initialOptions=null)}isEmpty(){return!this.editorDiv||this.editorDiv.innerText.trim()===""}remove(){this.isEditing=!1,this.parent&&(this.parent.setEditingState(!0),this.parent.div.classList.add("freetextEditing")),super.remove()}#o(){const e=[];this.editorDiv.normalize();let r=null;for(const n of this.editorDiv.childNodes)r?.nodeType===Node.TEXT_NODE&&n.nodeName==="BR"||(e.push(pl.#c(n)),r=n);return e.join(` +`)}#l(){const[e,r]=this.parentDimensions;let n;if(this.isAttachedToDOM)n=this.div.getBoundingClientRect();else{const{currentLayer:i,div:a}=this,s=a.style.display,o=a.classList.contains("hidden");a.classList.remove("hidden"),a.style.display="hidden",i.div.append(this.div),n=a.getBoundingClientRect(),a.remove(),a.style.display=s,a.classList.toggle("hidden",o)}this.rotation%180===this.parentRotation%180?(this.width=n.width/e,this.height=n.height/r):(this.width=n.height/e,this.height=n.width/r),this.fixAndSetPosition()}commit(){if(!this.isInEditMode())return;super.commit(),this.disableEditMode();const e=this.#t,r=this.#t=this.#o().trimEnd();if(e===r)return;const n=i=>{if(this.#t=i,!i){this.remove();return}this.#d(),this._uiManager.rebuild(this),this.#l()};this.addCommands({cmd:()=>{n(r)},undo:()=>{n(e)},mustExec:!1}),this.#l()}shouldGetKeyboardEvents(){return this.isInEditMode()}enterInEditMode(){this.enableEditMode(),this.editorDiv.focus()}keydown(e){e.target===this.div&&e.key==="Enter"&&(this.enterInEditMode(),e.preventDefault())}editorDivKeydown(e){pl._keyboardManager.exec(this,e)}editorDivFocus(e){this.isEditing=!0}editorDivBlur(e){this.isEditing=!1}editorDivInput(e){this.parent.div.classList.toggle("freetextEditing",this.isEmpty())}disableEditing(){this.editorDiv.setAttribute("role","comment"),this.editorDiv.removeAttribute("aria-multiline")}enableEditing(){this.editorDiv.setAttribute("role","textbox"),this.editorDiv.setAttribute("aria-multiline",!0)}get canChangeContent(){return!0}render(){if(this.div)return this.div;let e,r;(this._isCopy||this.annotationElementId)&&(e=this.x,r=this.y),super.render(),this.editorDiv=document.createElement("div"),this.editorDiv.className="internal",this.editorDiv.setAttribute("id",this.#r),this.editorDiv.setAttribute("data-l10n-id","pdfjs-free-text2"),this.editorDiv.setAttribute("data-l10n-attrs","default-content"),this.enableEditing(),this.editorDiv.contentEditable=!0;const{style:n}=this.editorDiv;if(n.fontSize=`calc(${this.#i}px * var(--total-scale-factor))`,n.color=this.#e,this.div.append(this.editorDiv),this.overlayDiv=document.createElement("div"),this.overlayDiv.classList.add("overlay","enabled"),this.div.append(this.overlayDiv),this._isCopy||this.annotationElementId){const[i,a]=this.parentDimensions;if(this.annotationElementId){const{position:s}=this._initialData;let[o,l]=this.getInitialTranslation();[o,l]=this.pageTranslationToScreen(o,l);const[u,d]=this.pageDimensions,[h,f]=this.pageTranslation;let p,g;switch(this.rotation){case 0:p=e+(s[0]-h)/u,g=r+this.height-(s[1]-f)/d;break;case 90:p=e+(s[0]-h)/u,g=r-(s[1]-f)/d,[o,l]=[l,-o];break;case 180:p=e-this.width+(s[0]-h)/u,g=r-(s[1]-f)/d,[o,l]=[-o,-l];break;case 270:p=e+(s[0]-h-this.height*d)/u,g=r+(s[1]-f-this.width*u)/d,[o,l]=[-l,o];break}this.setAt(p*i,g*a,o,l)}else this._moveAfterPaste(e,r);this.#d(),this._isDraggable=!0,this.editorDiv.contentEditable=!1}else this._isDraggable=!1,this.editorDiv.contentEditable=!0;return this.div}static#c(e){return(e.nodeType===Node.TEXT_NODE?e.nodeValue:e.innerText).replaceAll(KI,"")}editorDivPaste(e){const r=e.clipboardData||window.clipboardData,{types:n}=r;if(n.length===1&&n[0]==="text/plain")return;e.preventDefault();const i=pl.#p(r.getData("text")||"").replaceAll(KI,` +`);if(!i)return;const a=window.getSelection();if(!a.rangeCount)return;this.editorDiv.normalize(),a.deleteFromDocument();const s=a.getRangeAt(0);if(!i.includes(` +`)){s.insertNode(document.createTextNode(i)),this.editorDiv.normalize(),a.collapseToStart();return}const{startContainer:o,startOffset:l}=s,u=[],d=[];if(o.nodeType===Node.TEXT_NODE){const p=o.parentElement;if(d.push(o.nodeValue.slice(l).replaceAll(KI,"")),p!==this.editorDiv){let g=u;for(const m of this.editorDiv.childNodes){if(m===p){g=d;continue}g.push(pl.#c(m))}}u.push(o.nodeValue.slice(0,l).replaceAll(KI,""))}else if(o===this.editorDiv){let p=u,g=0;for(const m of this.editorDiv.childNodes)g++===l&&(p=d),p.push(pl.#c(m))}this.#t=`${u.join(` +`)}${i}${d.join(` +`)}`,this.#d();const h=new Range;let f=Math.sumPrecise(u.map(p=>p.length));for(const{firstChild:p}of this.editorDiv.childNodes)if(p.nodeType===Node.TEXT_NODE){const g=p.nodeValue.length;if(f<=g){h.setStart(p,f),h.setEnd(p,f);break}f-=g}a.removeAllRanges(),a.addRange(h)}#d(){if(this.editorDiv.replaceChildren(),!!this.#t)for(const e of this.#t.split(` +`)){const r=document.createElement("div");r.append(e?document.createTextNode(e):document.createElement("br")),this.editorDiv.append(r)}}#u(){return this.#t.replaceAll(" "," ")}static#p(e){return e.replaceAll(" "," ")}get contentDiv(){return this.editorDiv}static async deserialize(e,r,n){let i=null;if(e instanceof jMe){const{data:{defaultAppearanceData:{fontSize:s,fontColor:o},rect:l,rotation:u,id:d,popupRef:h,contentsObj:f},textContent:p,textPosition:g,parent:{page:{pageNumber:m}}}=e;if(!p||p.length===0)return null;i=e={annotationType:Ii.FREETEXT,color:Array.from(o),fontSize:s,value:p.join(` +`),position:g,pageIndex:m-1,rect:l.slice(0),rotation:u,annotationElementId:d,id:d,deleted:!1,popupRef:h,comment:f?.str||null}}const a=await super.deserialize(e,r,n);return a.#i=e.fontSize,a.#e=Xn.makeHexColor(...e.color),a.#t=pl.#p(e.value),a._initialData=i,e.comment&&a.setCommentData(e.comment),a}serialize(e=!1){if(this.isEmpty())return null;if(this.deleted)return this.serializeDeleted();const r=pl._internalPadding*this.parentScale,n=this.getRect(r,r),i=ti._colorManager.convert(this.isAttachedToDOM?getComputedStyle(this.editorDiv).color:this.#e),a={annotationType:Ii.FREETEXT,color:i,fontSize:this.#i,value:this.#u(),pageIndex:this.pageIndex,rect:n,rotation:this.rotation,structTreeParentId:this._structTreeParentId};return this.addComment(a),e?(a.isCopy=!0,a):this.annotationElementId&&!this.#g(a)?null:(a.id=this.annotationElementId,a)}#g(e){const{value:r,fontSize:n,color:i,pageIndex:a}=this._initialData;return this.hasEditedComment||this._hasBeenMoved||e.value!==r||e.fontSize!==n||e.color.some((s,o)=>s!==i[o])||e.pageIndex!==a}renderAnnotationElement(e){const r=super.renderAnnotationElement(e),{style:n}=r;n.fontSize=`calc(${this.#i}px * var(--total-scale-factor))`,n.color=this.#e,r.replaceChildren();for(const s of this.#t.split(` +`)){const o=document.createElement("div");o.append(s?document.createTextNode(s):document.createElement("br")),r.append(o)}const i=pl._internalPadding*this.parentScale,a={rect:this.getRect(i,i)};return a.popup=this.hasEditedComment?this.comment:{text:this.#t},e.updateEdited(a),r}resetAnnotationElement(e){super.resetAnnotationElement(e),e.resetEdited()}}class xn{static PRECISION=1e-4;toSVGPath(){as("Abstract method `toSVGPath` must be implemented.")}get box(){as("Abstract getter `box` must be implemented.")}serialize(e,r){as("Abstract method `serialize` must be implemented.")}static _rescale(e,r,n,i,a,s){s||=new Float32Array(e.length);for(let o=0,l=e.length;o=6;i-=6)isNaN(r[i])?n.push(`L${r[i+4]} ${r[i+5]}`):n.push(`C${r[i]} ${r[i+1]} ${r[i+2]} ${r[i+3]} ${r[i+4]} ${r[i+5]}`);return this.#_(n),n.join(" ")}#v(){const[e,r,n,i]=this.#e,[a,s,o,l]=this.#m();return`M${(this.#a[2]-e)/n} ${(this.#a[3]-r)/i} L${(this.#a[4]-e)/n} ${(this.#a[5]-r)/i} L${a} ${s} L${o} ${l} L${(this.#a[16]-e)/n} ${(this.#a[17]-r)/i} L${(this.#a[14]-e)/n} ${(this.#a[15]-r)/i} Z`}#_(e){const r=this.#t;e.push(`L${r[4]} ${r[5]} Z`)}#S(e){const[r,n,i,a]=this.#e,s=this.#a.subarray(4,6),o=this.#a.subarray(16,18),[l,u,d,h]=this.#m();e.push(`L${(s[0]-r)/i} ${(s[1]-n)/a} L${l} ${u} L${d} ${h} L${(o[0]-r)/i} ${(o[1]-n)/a}`)}newFreeDrawOutline(e,r,n,i,a,s){return new JMe(e,r,n,i,a,s)}getOutlines(){const e=this.#i,r=this.#t,n=this.#a,[i,a,s,o]=this.#e,l=new Float32Array((this.#p?.length??0)+2);for(let h=0,f=l.length-2;h=6;h-=6)for(let f=0;f<6;f+=2){if(isNaN(r[h+f])){u[d]=u[d+1]=NaN,d+=2;continue}u[d]=r[h+f],u[d+1]=r[h+f+1],d+=2}return this.#y(u,d),this.newFreeDrawOutline(u,l,this.#e,this.#d,this.#r,this.#n)}#b(e){const r=this.#a,[n,i,a,s]=this.#e,[o,l,u,d]=this.#m(),h=new Float32Array(36);return h.set([NaN,NaN,NaN,NaN,(r[2]-n)/a,(r[3]-i)/s,NaN,NaN,NaN,NaN,(r[4]-n)/a,(r[5]-i)/s,NaN,NaN,NaN,NaN,o,l,NaN,NaN,NaN,NaN,u,d,NaN,NaN,NaN,NaN,(r[16]-n)/a,(r[17]-i)/s,NaN,NaN,NaN,NaN,(r[14]-n)/a,(r[15]-i)/s],0),this.newFreeDrawOutline(h,e,this.#e,this.#d,this.#r,this.#n)}#y(e,r){const n=this.#t;return e.set([NaN,NaN,NaN,NaN,n[4],n[5]],r),r+=6}#E(e,r){const n=this.#a.subarray(4,6),i=this.#a.subarray(16,18),[a,s,o,l]=this.#e,[u,d,h,f]=this.#m();return e.set([NaN,NaN,NaN,NaN,(n[0]-a)/o,(n[1]-s)/l,NaN,NaN,NaN,NaN,u,d,NaN,NaN,NaN,NaN,h,f,NaN,NaN,NaN,NaN,(i[0]-a)/o,(i[1]-s)/l],r),r+=24}}class JMe extends xn{#e;#t=new Float32Array(4);#r;#n;#i;#a;#s;constructor(e,r,n,i,a,s){super(),this.#s=e,this.#i=r,this.#e=n,this.#a=i,this.#r=a,this.#n=s,this.lastPoint=[NaN,NaN],this.#o(s);const[o,l,u,d]=this.#t;for(let h=0,f=e.length;hr[0]-n[0]||r[1]-n[1]||r[2]-n[2]);const e=[];for(const r of this.#r)r[3]?(e.push(...this.#l(r)),this.#s(r)):(this.#o(r),e.push(...this.#l(r)));return this.#i(e)}#i(e){const r=[],n=new Set;for(const s of e){const[o,l,u]=s;r.push([o,l,s],[o,u,s])}r.sort((s,o)=>s[1]-o[1]||s[0]-o[0]);for(let s=0,o=r.length;s0;){const s=n.values().next().value;let[o,l,u,d,h]=s;n.delete(s);let f=o,p=l;for(a=[o,u],i.push(a);;){let g;if(n.has(d))g=d;else if(n.has(h))g=h;else break;n.delete(g),[o,l,u,d,h]=g,f!==o&&(a.push(f,p,o,p===l?l:u),f=o),p=p===l?u:l}a.push(f,p)}return new FBt(i,this.#e,this.#t)}#a(e){const r=this.#n;let n=0,i=r.length-1;for(;n<=i;){const a=n+i>>1,s=r[a][0];if(s===e)return a;s=0;i--){const[a,s]=this.#n[i];if(a!==e)break;if(a===e&&s===r){this.#n.splice(i,1);return}}}#l(e){const[r,n,i]=e,a=[[r,n,i]],s=this.#a(i);for(let o=0;o=l){if(p>u)a[d][1]=u;else{if(h===1)return[];a.splice(d,1),d--,h--}continue}a[d][2]=l,p>u&&a.push([r,u,p])}}}return a}}class FBt extends xn{#e;#t;constructor(e,r,n){super(),this.#t=e,this.#e=r,this.lastPoint=n}toSVGPath(){const e=[];for(const r of this.#t){let[n,i]=r;e.push(`M${n} ${i}`);for(let a=2;a-1?(this.#u=!0,this.#S(e),this.#w()):this.#r&&(this.#e=e.anchorNode,this.#t=e.anchorOffset,this.#s=e.focusNode,this.#o=e.focusOffset,this.#_(),this.#w(),this.rotate(this.rotation)),this.annotationElementId||this._uiManager.a11yAlert("pdfjs-editor-highlight-added-alert")}get telemetryInitialData(){return{action:"added",type:this.#u?"free_highlight":"highlight",color:this._uiManager.getNonHCMColorName(this.color),thickness:this.#m,methodOfCreation:this.#v}}get telemetryFinalData(){return{type:"highlight",color:this._uiManager.getNonHCMColorName(this.color)}}get commentColor(){return this.color}static computeTelemetryFinalData(e){return{numberOfColors:e.get("color").size}}#_(){const e=new Yee(this.#r,.001);this.#c=e.getOutlines(),[this.x,this.y,this.width,this.height]=this.#c.box;const r=new Yee(this.#r,.0025,.001,this._uiManager.direction==="ltr");this.#a=r.getOutlines();const{lastPoint:n}=this.#a;this.#p=[(n[0]-this.x)/this.width,(n[1]-this.y)/this.height]}#S({highlightOutlines:e,highlightId:r,clipPathId:n}){this.#c=e;const i=1.5;if(this.#a=e.getNewOutline(this.#m/2+i,.0025),r>=0)this.#d=r,this.#n=n,this.parent.drawLayer.finalizeDraw(r,{bbox:e.box,path:{d:e.toSVGPath()}}),this.#f=this.parent.drawLayer.drawOutline({rootClass:{highlightOutline:!0,free:!0},bbox:this.#a.box,path:{d:this.#a.toSVGPath()}},!0);else if(this.parent){const d=this.parent.viewport.rotation;this.parent.drawLayer.updateProperties(this.#d,{bbox:Ao.#O(this.#c.box,(d-this.rotation+360)%360),path:{d:e.toSVGPath()}}),this.parent.drawLayer.updateProperties(this.#f,{bbox:Ao.#O(this.#a.box,d),path:{d:this.#a.toSVGPath()}})}const[a,s,o,l]=e.box;switch(this.rotation){case 0:this.x=a,this.y=s,this.width=o,this.height=l;break;case 90:{const[d,h]=this.parentDimensions;this.x=s,this.y=1-a,this.width=o*h/d,this.height=l*d/h;break}case 180:this.x=1-a,this.y=1-s,this.width=o,this.height=l;break;case 270:{const[d,h]=this.parentDimensions;this.x=1-s,this.y=a,this.width=o*h/d,this.height=l*d/h;break}}const{lastPoint:u}=this.#a;this.#p=[(u[0]-a)/o,(u[1]-s)/l]}static initialize(e,r){ti.initialize(e,r),Ao._defaultColor||=r.highlightColors?.values().next().value||"#fff066"}static updateDefaultParams(e,r){switch(e){case _a.HIGHLIGHT_COLOR:Ao._defaultColor=r;break;case _a.HIGHLIGHT_THICKNESS:Ao._defaultThickness=r;break}}translateInPage(e,r){}get toolbarPosition(){return this.#p}updateParams(e,r){switch(e){case _a.HIGHLIGHT_COLOR:this.#b(r);break;case _a.HIGHLIGHT_THICKNESS:this.#y(r);break}}static get defaultPropertiesToUpdate(){return[[_a.HIGHLIGHT_COLOR,Ao._defaultColor],[_a.HIGHLIGHT_THICKNESS,Ao._defaultThickness]]}get propertiesToUpdate(){return[[_a.HIGHLIGHT_COLOR,this.color||Ao._defaultColor],[_a.HIGHLIGHT_THICKNESS,this.#m||Ao._defaultThickness],[_a.HIGHLIGHT_FREE,this.#u]]}#b(e){const r=(a,s)=>{this.color=a,this.#g=s,this.parent?.drawLayer.updateProperties(this.#d,{root:{fill:a,"fill-opacity":s}}),this.#i?.updateColor(a)},n=this.color,i=this.#g;this.addCommands({cmd:r.bind(this,e,Ao._defaultOpacity),undo:r.bind(this,n,i),post:this._uiManager.updateUI.bind(this._uiManager,this),mustExec:!0,type:_a.HIGHLIGHT_COLOR,overwriteIfSameType:!0,keepUndo:!0}),this._reportTelemetry({action:"color_changed",color:this._uiManager.getNonHCMColorName(e)},!0)}#y(e){const r=this.#m,n=i=>{this.#m=i,this.#E(i)};this.addCommands({cmd:n.bind(this,e),undo:n.bind(this,r),post:this._uiManager.updateUI.bind(this._uiManager,this),mustExec:!0,type:_a.INK_THICKNESS,overwriteIfSameType:!0,keepUndo:!0}),this._reportTelemetry({action:"thickness_changed",thickness:e},!0)}get toolbarButtons(){return this._uiManager.highlightColors?[["colorPicker",this.#i=new Yh({editor:this})]]:super.toolbarButtons}disableEditing(){super.disableEditing(),this.div.classList.toggle("disabled",!0)}enableEditing(){super.enableEditing(),this.div.classList.toggle("disabled",!1)}fixAndSetPosition(){return super.fixAndSetPosition(this.#A())}getBaseTranslation(){return[0,0]}getRect(e,r){return super.getRect(e,r,this.#A())}onceAdded(e){this.annotationElementId||this.parent.addUndoableEditor(this),e&&this.div.focus()}remove(){this.#C(),this._reportTelemetry({action:"deleted"}),super.remove()}rebuild(){this.parent&&(super.rebuild(),this.div!==null&&(this.#w(),this.isAttachedToDOM||this.parent.add(this)))}setParent(e){let r=!1;this.parent&&!e?this.#C():e&&(this.#w(e),r=!this.parent&&this.div?.classList.contains("selectedEditor")),super.setParent(e),this.show(this._isVisible),r&&this.select()}#E(e){if(!this.#u)return;this.#S({highlightOutlines:this.#c.getNewOutline(e/2)}),this.fixAndSetPosition();const[r,n]=this.parentDimensions;this.setDims(this.width*r,this.height*n)}#C(){this.#d===null||!this.parent||(this.parent.drawLayer.remove(this.#d),this.#d=null,this.parent.drawLayer.remove(this.#f),this.#f=null)}#w(e=this.parent){this.#d===null&&({id:this.#d,clipPathId:this.#n}=e.drawLayer.draw({bbox:this.#c.box,root:{viewBox:"0 0 1 1",fill:this.color,"fill-opacity":this.#g},rootClass:{highlight:!0,free:this.#u},path:{d:this.#c.toSVGPath()}},!1,!0),this.#f=e.drawLayer.drawOutline({rootClass:{highlightOutline:!0,free:this.#u},bbox:this.#a.box,path:{d:this.#a.toSVGPath()}},this.#u),this.#l&&(this.#l.style.clipPath=this.#n))}static#O([e,r,n,i],a){switch(a){case 90:return[1-r-i,e,i,n];case 180:return[1-e-n,1-r-i,n,i];case 270:return[r,1-e-n,i,n]}return[e,r,n,i]}rotate(e){const{drawLayer:r}=this.parent;let n;this.#u?(e=(e-this.rotation+360)%360,n=Ao.#O(this.#c.box,e)):n=Ao.#O([this.x,this.y,this.width,this.height],e),r.updateProperties(this.#d,{bbox:n,root:{"data-main-rotation":e}}),r.updateProperties(this.#f,{bbox:Ao.#O(this.#a.box,e),root:{"data-main-rotation":e}})}render(){if(this.div)return this.div;const e=super.render();this.#h&&(e.setAttribute("aria-label",this.#h),e.setAttribute("role","mark")),this.#u?e.classList.add("free"):this.div.addEventListener("keydown",this.#N.bind(this),{signal:this._uiManager._signal});const r=this.#l=document.createElement("div");e.append(r),r.setAttribute("aria-hidden","true"),r.className="internal",r.style.clipPath=this.#n;const[n,i]=this.parentDimensions;return this.setDims(this.width*n,this.height*i),NMe(this,this.#l,["pointerover","pointerleave"]),this.enableEditing(),e}pointerover(){this.isSelected||this.parent?.drawLayer.updateProperties(this.#f,{rootClass:{hovered:!0}})}pointerleave(){this.isSelected||this.parent?.drawLayer.updateProperties(this.#f,{rootClass:{hovered:!1}})}#N(e){Ao._keyboardManager.exec(this,e)}_moveCaret(e){switch(this.parent.unselect(this),e){case 0:case 2:this.#R(!0);break;case 1:case 3:this.#R(!1);break}}#R(e){if(!this.#e)return;const r=window.getSelection();e?r.setPosition(this.#e,this.#t):r.setPosition(this.#s,this.#o)}select(){super.select(),this.#f&&this.parent?.drawLayer.updateProperties(this.#f,{rootClass:{hovered:!1,selected:!0}})}unselect(){super.unselect(),this.#f&&(this.parent?.drawLayer.updateProperties(this.#f,{rootClass:{selected:!1}}),this.#u||this.#R(!1))}get _mustFixPosition(){return!this.#u}show(e=this._isVisible){super.show(e),this.parent&&(this.parent.drawLayer.updateProperties(this.#d,{rootClass:{hidden:!e}}),this.parent.drawLayer.updateProperties(this.#f,{rootClass:{hidden:!e}}))}#A(){return this.#u?this.rotation:0}#k(){if(this.#u)return null;const[e,r]=this.pageDimensions,[n,i]=this.pageTranslation,a=this.#r,s=new Float32Array(a.length*8);let o=0;for(const{x:l,y:u,width:d,height:h}of a){const f=l*e+n,p=(1-u)*r+i;s[o]=s[o+4]=f,s[o+1]=s[o+3]=p,s[o+2]=s[o+6]=f+d*e,s[o+5]=s[o+7]=p-h*r,o+=8}return s}#F(e){return this.#c.serialize(e,this.#A())}static startHighlighting(e,r,{target:n,x:i,y:a}){const{x:s,y:o,width:l,height:u}=n.getBoundingClientRect(),d=new AbortController,h=e.combinedSignal(d),f=p=>{d.abort(),this.#G(e,p)};window.addEventListener("blur",f,{signal:h}),window.addEventListener("pointerup",f,{signal:h}),window.addEventListener("pointerdown",Wo,{capture:!0,passive:!1,signal:h}),window.addEventListener("contextmenu",yf,{signal:h}),n.addEventListener("pointermove",this.#D.bind(this,e),{signal:h}),this._freeHighlight=new Wee({x:i,y:a},[s,o,l,u],e.scale,this._defaultThickness/2,r,.001),{id:this._freeHighlightId,clipPathId:this._freeHighlightClipId}=e.drawLayer.draw({bbox:[0,0,1,1],root:{viewBox:"0 0 1 1",fill:this._defaultColor,"fill-opacity":this._defaultOpacity},rootClass:{highlight:!0,free:!0},path:{d:this._freeHighlight.toSVGPath()}},!0,!0)}static#D(e,r){this._freeHighlight.add(r)&&e.drawLayer.updateProperties(this._freeHighlightId,{path:{d:this._freeHighlight.toSVGPath()}})}static#G(e,r){this._freeHighlight.isEmpty()?e.drawLayer.remove(this._freeHighlightId):e.createAndAddNewEditor(r,!1,{highlightId:this._freeHighlightId,highlightOutlines:this._freeHighlight.getOutlines(),clipPathId:this._freeHighlightClipId,methodOfCreation:"main_toolbar"}),this._freeHighlightId=-1,this._freeHighlight=null,this._freeHighlightClipId=""}static async deserialize(e,r,n){let i=null;if(e instanceof QMe){const{data:{quadPoints:g,rect:m,rotation:_,id:v,color:b,opacity:y,popupRef:E,contentsObj:T},parent:{page:{pageNumber:C}}}=e;i=e={annotationType:Ii.HIGHLIGHT,color:Array.from(b),opacity:y,quadPoints:g,boxes:null,pageIndex:C-1,rect:m.slice(0),rotation:_,annotationElementId:v,id:v,deleted:!1,popupRef:E,comment:T?.str||null}}else if(e instanceof due){const{data:{inkLists:g,rect:m,rotation:_,id:v,color:b,borderStyle:{rawWidth:y},popupRef:E,contentsObj:T},parent:{page:{pageNumber:C}}}=e;i=e={annotationType:Ii.HIGHLIGHT,color:Array.from(b),thickness:y,inkLists:g,boxes:null,pageIndex:C-1,rect:m.slice(0),rotation:_,annotationElementId:v,id:v,deleted:!1,popupRef:E,comment:T?.str||null}}const{color:a,quadPoints:s,inkLists:o,opacity:l}=e,u=await super.deserialize(e,r,n);u.color=Xn.makeHexColor(...a),u.#g=l||1,o&&(u.#m=e.thickness),u._initialData=i,e.comment&&u.setCommentData(e.comment);const[d,h]=u.pageDimensions,[f,p]=u.pageTranslation;if(s){const g=u.#r=[];for(let m=0;mn!==r[i])}renderAnnotationElement(e){const r={rect:this.getRect(0,0)};return this.hasEditedComment&&(r.popup=this.comment),e.updateEdited(r),null}static canCreateNewEmptyEditor(){return!1}}class eLe{#e=Object.create(null);updateProperty(e,r){this[e]=r,this.updateSVGProperty(e,r)}updateProperties(e){if(e)for(const[r,n]of Object.entries(e))r.startsWith("_")||this.updateProperty(r,n)}updateSVGProperty(e,r){this.#e[e]=r}toSVGProperties(){const e=this.#e;return this.#e=Object.create(null),{root:e}}reset(){this.#e=Object.create(null)}updateAll(e=this){this.updateProperties(e)}clone(){as("Not implemented")}}class li extends ti{#e=null;#t;_colorPicker=null;_drawId=null;static _currentDrawId=-1;static _currentParent=null;static#r=null;static#n=null;static#i=null;static#a=NaN;static#s=null;static#o=null;static#l=NaN;static _INNER_MARGIN=3;constructor(e){super(e),this.#t=e.mustBeCommitted||!1,this._addOutlines(e)}_addOutlines(e){e.drawOutlines&&(this.#c(e),this.#p())}#c({drawOutlines:e,drawId:r,drawingOptions:n}){this.#e=e,this._drawingOptions||=n,this.annotationElementId||this._uiManager.a11yAlert(`pdfjs-editor-${this.editorType}-added-alert`),r>=0?(this._drawId=r,this.parent.drawLayer.finalizeDraw(r,e.defaultProperties)):this._drawId=this.#d(e,this.parent),this.#h(e.box)}#d(e,r){const{id:n}=r.drawLayer.draw(li._mergeSVGProperties(this._drawingOptions.toSVGProperties(),e.defaultSVGProperties),!1,!1);return n}static _mergeSVGProperties(e,r){const n=new Set(Object.keys(e));for(const[i,a]of Object.entries(r))n.has(i)?Object.assign(e[i],a):e[i]=a;return e}static getDefaultDrawingOptions(e){as("Not implemented")}static get typesMap(){as("Not implemented")}static get isDrawer(){return!0}static get supportMultipleDrawings(){return!1}static updateDefaultParams(e,r){const n=this.typesMap.get(e);n&&this._defaultDrawingOptions.updateProperty(n,r),this._currentParent&&(li.#r.updateProperty(n,r),this._currentParent.drawLayer.updateProperties(this._currentDrawId,this._defaultDrawingOptions.toSVGProperties()))}updateParams(e,r){const n=this.constructor.typesMap.get(e);n&&this._updateProperty(e,n,r)}static get defaultPropertiesToUpdate(){const e=[],r=this._defaultDrawingOptions;for(const[n,i]of this.typesMap)e.push([n,r[i]]);return e}get propertiesToUpdate(){const e=[],{_drawingOptions:r}=this;for(const[n,i]of this.constructor.typesMap)e.push([n,r[i]]);return e}_updateProperty(e,r,n){const i=this._drawingOptions,a=i[r],s=o=>{i.updateProperty(r,o);const l=this.#e.updateProperty(r,o);l&&this.#h(l),this.parent?.drawLayer.updateProperties(this._drawId,i.toSVGProperties()),e===this.colorType&&this._colorPicker?.update(o)};this.addCommands({cmd:s.bind(this,n),undo:s.bind(this,a),post:this._uiManager.updateUI.bind(this._uiManager,this),mustExec:!0,type:e,overwriteIfSameType:!0,keepUndo:!0})}_onResizing(){this.parent?.drawLayer.updateProperties(this._drawId,li._mergeSVGProperties(this.#e.getPathResizingSVGProperties(this.#f()),{bbox:this.#m()}))}_onResized(){this.parent?.drawLayer.updateProperties(this._drawId,li._mergeSVGProperties(this.#e.getPathResizedSVGProperties(this.#f()),{bbox:this.#m()}))}_onTranslating(e,r){this.parent?.drawLayer.updateProperties(this._drawId,{bbox:this.#m()})}_onTranslated(){this.parent?.drawLayer.updateProperties(this._drawId,li._mergeSVGProperties(this.#e.getPathTranslatedSVGProperties(this.#f(),this.parentDimensions),{bbox:this.#m()}))}_onStartDragging(){this.parent?.drawLayer.updateProperties(this._drawId,{rootClass:{moving:!0}})}_onStopDragging(){this.parent?.drawLayer.updateProperties(this._drawId,{rootClass:{moving:!1}})}commit(){super.commit(),this.disableEditMode(),this.disableEditing()}disableEditing(){super.disableEditing(),this.div.classList.toggle("disabled",!0)}enableEditing(){super.enableEditing(),this.div.classList.toggle("disabled",!1)}getBaseTranslation(){return[0,0]}get isResizable(){return!0}onceAdded(e){this.annotationElementId||this.parent.addUndoableEditor(this),this._isDraggable=!0,this.#t&&(this.#t=!1,this.commit(),this.parent.setSelected(this),e&&this.isOnScreen&&this.div.focus())}remove(){this.#u(),super.remove()}rebuild(){this.parent&&(super.rebuild(),this.div!==null&&(this.#p(),this.#h(this.#e.box),this.isAttachedToDOM||this.parent.add(this)))}setParent(e){let r=!1;this.parent&&!e?(this._uiManager.removeShouldRescale(this),this.#u()):e&&(this._uiManager.addShouldRescale(this),this.#p(e),r=!this.parent&&this.div?.classList.contains("selectedEditor")),super.setParent(e),r&&this.select()}#u(){this._drawId===null||!this.parent||(this.parent.drawLayer.remove(this._drawId),this._drawId=null,this._drawingOptions.reset())}#p(e=this.parent){if(!(this._drawId!==null&&this.parent===e)){if(this._drawId!==null){this.parent.drawLayer.updateParent(this._drawId,e.drawLayer);return}this._drawingOptions.updateAll(),this._drawId=this.#d(this.#e,e)}}#g([e,r,n,i]){const{parentDimensions:[a,s],rotation:o}=this;switch(o){case 90:return[r,1-e,n*(s/a),i*(a/s)];case 180:return[1-e,1-r,n,i];case 270:return[1-r,e,n*(s/a),i*(a/s)];default:return[e,r,n,i]}}#f(){const{x:e,y:r,width:n,height:i,parentDimensions:[a,s],rotation:o}=this;switch(o){case 90:return[1-r,e,n*(a/s),i*(s/a)];case 180:return[1-e,1-r,n,i];case 270:return[r,1-e,n*(a/s),i*(s/a)];default:return[e,r,n,i]}}#h(e){if([this.x,this.y,this.width,this.height]=this.#g(e),this.div){this.fixAndSetPosition();const[r,n]=this.parentDimensions;this.setDims(this.width*r,this.height*n)}this._onResized()}#m(){const{x:e,y:r,width:n,height:i,rotation:a,parentRotation:s,parentDimensions:[o,l]}=this;switch((a*4+s)/90){case 1:return[1-r-i,e,i,n];case 2:return[1-e-n,1-r-i,n,i];case 3:return[r,1-e-n,i,n];case 4:return[e,r-n*(o/l),i*(l/o),n*(o/l)];case 5:return[1-r,e,n*(o/l),i*(l/o)];case 6:return[1-e-i*(l/o),1-r,i*(l/o),n*(o/l)];case 7:return[r-n*(o/l),1-e-i*(l/o),n*(o/l),i*(l/o)];case 8:return[e-n,r-i,n,i];case 9:return[1-r,e-n,i,n];case 10:return[1-e,1-r,n,i];case 11:return[r-i,1-e,i,n];case 12:return[e-i*(l/o),r,i*(l/o),n*(o/l)];case 13:return[1-r-n*(o/l),e-i*(l/o),n*(o/l),i*(l/o)];case 14:return[1-e,1-r-n*(o/l),i*(l/o),n*(o/l)];case 15:return[r,1-e,n*(o/l),i*(l/o)];default:return[e,r,n,i]}}rotate(){this.parent&&this.parent.drawLayer.updateProperties(this._drawId,li._mergeSVGProperties({bbox:this.#m()},this.#e.updateRotation((this.parentRotation-this.rotation+360)%360)))}onScaleChanging(){this.parent&&this.#h(this.#e.updateParentDimensions(this.parentDimensions,this.parent.scale))}static onScaleChangingWhenDrawing(){}render(){if(this.div)return this.div;let e,r;this._isCopy&&(e=this.x,r=this.y);const n=super.render();n.classList.add("draw");const i=document.createElement("div");n.append(i),i.setAttribute("aria-hidden","true"),i.className="internal";const[a,s]=this.parentDimensions;return this.setDims(this.width*a,this.height*s),this._uiManager.addShouldRescale(this),this.disableEditing(),this._isCopy&&this._moveAfterPaste(e,r),n}static createDrawerInstance(e,r,n,i,a){as("Not implemented")}static startDrawing(e,r,n,i){const{target:a,offsetX:s,offsetY:o,pointerId:l,pointerType:u}=i;if(li.#s&&li.#s!==u)return;const{viewport:{rotation:d}}=e,{width:h,height:f}=a.getBoundingClientRect(),p=li.#n=new AbortController,g=e.combinedSignal(p);if(li.#a||=l,li.#s??=u,window.addEventListener("pointerup",m=>{li.#a===m.pointerId?this._endDraw(m):li.#o?.delete(m.pointerId)},{signal:g}),window.addEventListener("pointercancel",m=>{li.#a===m.pointerId?this._currentParent.endDrawingSession():li.#o?.delete(m.pointerId)},{signal:g}),window.addEventListener("pointerdown",m=>{li.#s===m.pointerType&&((li.#o||=new Set).add(m.pointerId),li.#r.isCancellable()&&(li.#r.removeLastElement(),li.#r.isEmpty()?this._currentParent.endDrawingSession(!0):this._endDraw(null)))},{capture:!0,passive:!1,signal:g}),window.addEventListener("contextmenu",yf,{signal:g}),a.addEventListener("pointermove",this._drawMove.bind(this),{signal:g}),a.addEventListener("touchmove",m=>{m.timeStamp===li.#l&&Wo(m)},{signal:g}),e.toggleDrawing(),r._editorUndoBar?.hide(),li.#r){e.drawLayer.updateProperties(this._currentDrawId,li.#r.startNew(s,o,h,f,d));return}r.updateUIForDefaultProperties(this),li.#r=this.createDrawerInstance(s,o,h,f,d),li.#i=this.getDefaultDrawingOptions(),this._currentParent=e,{id:this._currentDrawId}=e.drawLayer.draw(this._mergeSVGProperties(li.#i.toSVGProperties(),li.#r.defaultSVGProperties),!0,!1)}static _drawMove(e){if(li.#l=-1,!li.#r)return;const{offsetX:r,offsetY:n,pointerId:i}=e;if(li.#a===i){if(li.#o?.size>=1){this._endDraw(e);return}this._currentParent.drawLayer.updateProperties(this._currentDrawId,li.#r.add(r,n)),li.#l=e.timeStamp,Wo(e)}}static _cleanup(e){e&&(this._currentDrawId=-1,this._currentParent=null,li.#r=null,li.#i=null,li.#s=null,li.#l=NaN),li.#n&&(li.#n.abort(),li.#n=null,li.#a=NaN,li.#o=null)}static _endDraw(e){const r=this._currentParent;if(r){if(r.toggleDrawing(!0),this._cleanup(!1),e?.target===r.div&&r.drawLayer.updateProperties(this._currentDrawId,li.#r.end(e.offsetX,e.offsetY)),this.supportMultipleDrawings){const n=li.#r,i=this._currentDrawId,a=n.getLastElement();r.addCommands({cmd:()=>{r.drawLayer.updateProperties(i,n.setLastElement(a))},undo:()=>{r.drawLayer.updateProperties(i,n.removeLastElement())},mustExec:!1,type:_a.DRAW_STEP});return}this.endDrawing(!1)}}static endDrawing(e){const r=this._currentParent;if(!r)return null;if(r.toggleDrawing(!0),r.cleanUndoStack(_a.DRAW_STEP),!li.#r.isEmpty()){const{pageDimensions:[n,i],scale:a}=r,s=r.createAndAddNewEditor({offsetX:0,offsetY:0},!1,{drawId:this._currentDrawId,drawOutlines:li.#r.getOutlines(n*a,i*a,a,this._INNER_MARGIN),drawingOptions:li.#i,mustBeCommitted:!e});return this._cleanup(!0),s}return r.drawLayer.remove(this._currentDrawId),this._cleanup(!0),null}createDrawingOptions(e){}static deserializeDraw(e,r,n,i,a,s){as("Not implemented")}static async deserialize(e,r,n){const{rawDims:{pageWidth:i,pageHeight:a,pageX:s,pageY:o}}=r.viewport,l=this.deserializeDraw(s,o,i,a,this._INNER_MARGIN,e),u=await super.deserialize(e,r,n);return u.createDrawingOptions(e),u.#c({drawOutlines:l}),u.#p(),u.onScaleChanging(),u.rotate(),u}serializeDraw(e){const[r,n]=this.pageTranslation,[i,a]=this.pageDimensions;return this.#e.serialize([r,n,i,a],e)}renderAnnotationElement(e){return e.updateEdited({rect:this.getRect(0,0)}),null}static canCreateNewEmptyEditor(){return!1}}class UBt{#e=new Float64Array(6);#t;#r;#n;#i;#a;#s="";#o=0;#l=new J8;#c;#d;constructor(e,r,n,i,a,s){this.#c=n,this.#d=i,this.#n=a,this.#i=s,[e,r]=this.#u(e,r);const o=this.#t=[NaN,NaN,NaN,NaN,e,r];this.#a=[e,r],this.#r=[{line:o,points:this.#a}],this.#e.set(o,0)}updateProperty(e,r){e==="stroke-width"&&(this.#i=r)}#u(e,r){return xn._normalizePoint(e,r,this.#c,this.#d,this.#n)}isEmpty(){return!this.#r||this.#r.length===0}isCancellable(){return this.#a.length<=10}add(e,r){[e,r]=this.#u(e,r);const[n,i,a,s]=this.#e.subarray(2,6),o=e-a,l=r-s;return Math.hypot(this.#c*o,this.#d*l)<=2?null:(this.#a.push(e,r),isNaN(n)?(this.#e.set([a,s,e,r],2),this.#t.push(NaN,NaN,NaN,NaN,e,r),{path:{d:this.toSVGPath()}}):(isNaN(this.#e[0])&&this.#t.splice(6,6),this.#e.set([n,i,a,s,e,r],0),this.#t.push(...xn.createBezierPoints(n,i,a,s,e,r)),{path:{d:this.toSVGPath()}}))}end(e,r){const n=this.add(e,r);return n||(this.#a.length===2?{path:{d:this.toSVGPath()}}:null)}startNew(e,r,n,i,a){this.#c=n,this.#d=i,this.#n=a,[e,r]=this.#u(e,r);const s=this.#t=[NaN,NaN,NaN,NaN,e,r];this.#a=[e,r];const o=this.#r.at(-1);return o&&(o.line=new Float32Array(o.line),o.points=new Float32Array(o.points)),this.#r.push({line:s,points:this.#a}),this.#e.set(s,0),this.#o=0,this.toSVGPath(),null}getLastElement(){return this.#r.at(-1)}setLastElement(e){return this.#r?(this.#r.push(e),this.#t=e.line,this.#a=e.points,this.#o=0,{path:{d:this.toSVGPath()}}):this.#l.setLastElement(e)}removeLastElement(){if(!this.#r)return this.#l.removeLastElement();this.#r.pop(),this.#s="";for(let e=0,r=this.#r.length;ey??NaN),h,f,p,g),points:m(o[v].map(y=>y??NaN),h,f,p,g)});const _=new this.prototype.constructor;return _.build(d,n,i,1,l,u,a),_}#c(e=this.#l){const r=this.#r+e/2*this.#s;return this.#o%180===0?[r/this.#i,r/this.#a]:[r/this.#a,r/this.#i]}#d(){const[e,r,n,i]=this.#e,[a,s]=this.#c(0);return[e+a,r+s,n-2*a,i-2*s]}#u(){const e=this.#e=new Float32Array([1/0,1/0,-1/0,-1/0]);for(const{line:i}of this.#n){if(i.length<=12){for(let o=4,l=i.length;os!==r[o])||e.thickness!==n||e.opacity!==i||e.pageIndex!==a}renderAnnotationElement(e){const{points:r,rect:n}=this.serializeDraw(!1),i={rect:n,thickness:this._drawingOptions["stroke-width"],points:r};return this.hasEditedComment&&(i.popup=this.comment),e.updateEdited(i),null}}class Kee extends J8{toSVGPath(){let e=super.toSVGPath();return e.endsWith("Z")||(e+="Z"),e}}const jI=8,UA=3;class LE{static#e={maxDim:512,sigmaSFactor:.02,sigmaR:25,kernelSize:16};static#t(e,r,n,i){return n-=e,i-=r,n===0?i>0?0:4:n===1?i+6:2-i}static#r=new Int32Array([0,1,-1,1,-1,0,-1,-1,0,-1,1,-1,1,0,1,1]);static#n(e,r,n,i,a,s,o){const l=this.#t(n,i,a,s);for(let u=0;u<8;u++){const d=(-u+l-o+16)%8,h=this.#r[2*d],f=this.#r[2*d+1];if(e[(n+h)*r+(i+f)]!==0)return d}return-1}static#i(e,r,n,i,a,s,o){const l=this.#t(n,i,a,s);for(let u=0;u<8;u++){const d=(u+l+o+16)%8,h=this.#r[2*d],f=this.#r[2*d+1];if(e[(n+h)*r+(i+f)]!==0)return d}return-1}static#a(e,r,n,i){const a=e.length,s=new Int32Array(a);for(let d=0;d=1&&s[f+1]===0)o+=1,m+=1,p>1&&(l=p);else{p!==1&&(l=Math.abs(p));continue}const _=[h,d],v=m===h+1,b={isHole:v,points:_,id:o,parent:0};u.push(b);let y;for(const O of u)if(O.id===l){y=O;break}y?y.isHole?b.parent=v?y.parent:l:b.parent=v?l:y.parent:b.parent=v?l:0;const E=this.#n(s,r,d,h,g,m,0);if(E===-1){s[f]=-o,s[f]!==1&&(l=Math.abs(s[f]));continue}let T=this.#r[2*E],C=this.#r[2*E+1];const w=d+T,x=h+C;g=w,m=x;let A=d,R=h;for(;;){const O=this.#i(s,r,A,R,g,m,1);T=this.#r[2*O],C=this.#r[2*O+1];const F=A+T,P=R+C;_.push(P,F);const N=A*r+R;if(s[N+1]===0?s[N]=-o:s[N]===1&&(s[N]=o),F===d&&P===h&&A===w&&R===x){s[f]!==1&&(l=Math.abs(s[f]));break}else g=A,m=R,A=F,R=P}}}return u}static#s(e,r,n,i){if(n-r<=4){for(let w=r;wT&&(C=w,T=x)}T>(u*E)**2?(this.#s(e,r,C+2,i),this.#s(e,C,n,i)):i.push(a,s)}static#o(e){const r=[],n=e.length;return this.#s(e,0,n,r),r.push(e[n-2],e[n-1]),r.length<=4?null:r}static#l(e,r,n,i,a,s){const o=new Float32Array(s**2),l=-2*i**2,u=s>>1;for(let m=0;m=n))for(let x=0;x=r)continue;const R=e[w*r+A],O=o[C*s+x]*d[Math.abs(R-b)];y+=R*O,E+=O}}const T=p[v]=Math.round(y/E);g[T]++}return[p,g]}static#c(e){const r=new Uint32Array(256);for(const n of e)r[n]++;return r}static#d(e){const r=e.length,n=new Uint8ClampedArray(r>>2);let i=-1/0,a=1/0;for(let o=0,l=n.length;ol!==0);let s=a,o=a;for(r=a;r<256;r++){const l=e[r];l>n&&(r-s>i&&(i=r-s,o=r-1),n=l,s=r)}for(r=o-1;r>=0&&!(e[r]>e[r+1]);r--);return r}static#p(e){const r=e,{width:n,height:i}=e,{maxDim:a}=this.#e;let s=n,o=i;if(n>a||i>a){let f=n,p=i,g=Math.log2(Math.max(n,i)/a);const m=Math.floor(g);g=g===m?m-1:m;for(let v=0;v=-128&&o<=127?u=Int8Array:s>=-32768&&o<=32767?u=Int16Array:u=Int32Array;const d=e.length,h=jI+UA*d,f=new Uint32Array(h);let p=0;f[p++]=h*Uint32Array.BYTES_PER_ELEMENT+(l-2*d)*u.BYTES_PER_ELEMENT,f[p++]=0,f[p++]=i,f[p++]=a,f[p++]=r?0:1,f[p++]=Math.max(0,Math.floor(n??0)),f[p++]=d,f[p++]=u.BYTES_PER_ELEMENT;for(const y of e)f[p++]=y.length-2,f[p++]=y[0],f[p++]=y[1];const g=new CompressionStream("deflate-raw"),m=g.writable.getWriter();await m.ready,m.write(f);const _=u.prototype.constructor;for(const y of e){const E=new _(y.length-2);for(let T=2,C=y.length;T{await a.ready,await a.close()}).catch(()=>{});let s=null,o=0;for await(const y of n)s||=new Uint8Array(new Uint32Array(y.buffer,0,4)[0]),s.set(y,o),o+=y.length;const l=new Uint32Array(s.buffer,0,s.length>>2),u=l[1];if(u!==0)throw new Error(`Invalid version: ${u}`);const d=l[2],h=l[3],f=l[4]===0,p=l[5],g=l[6],m=l[7],_=[],v=(jI+UA*g)*Uint32Array.BYTES_PER_ELEMENT;let b;switch(m){case Int8Array.BYTES_PER_ELEMENT:b=new Int8Array(s.buffer,v);break;case Int16Array.BYTES_PER_ELEMENT:b=new Int16Array(s.buffer,v);break;case Int32Array.BYTES_PER_ELEMENT:b=new Int32Array(s.buffer,v);break}o=0;for(let y=0;y{r?.updateEditSignatureButton(e)}))}getSignaturePreview(){const{newCurves:e,areContours:r,thickness:n,width:i,height:a}=this.#r,s=Math.max(i,a),o=LE.processDrawnLines({lines:{curves:e.map(l=>({points:l})),thickness:n,width:i,height:a},pageWidth:s,pageHeight:s,rotation:0,innerMargin:0,mustSmooth:!1,areContours:r});return{areContours:r,outline:o.outline}}get toolbarButtons(){return this._uiManager.signatureManager?[["editSignature",this._uiManager.signatureManager]]:super.toolbarButtons}addSignature(e,r,n,i){const{x:a,y:s}=this,{outline:o}=this.#r=e;this.#e=o instanceof Kee,this.description=n;let l;this.#e?l=ig.getDefaultDrawingOptions():(l=ig._defaultDrawnSignatureOptions.clone(),l.updateProperties({"stroke-width":o.thickness})),this._addOutlines({drawOutlines:o,drawingOptions:l});const[u,d]=this.parentDimensions,[,h]=this.pageDimensions;let f=r/h;f=f>=1?.5:f,this.width*=f/this.height,this.width>=1&&(f*=.9/this.width,this.width=.9),this.height=f,this.setDims(u*this.width,d*this.height),this.x=a,this.y=s,this.center(),this._onResized(),this.onScaleChanging(),this.rotate(),this._uiManager.addToAnnotationStorage(this),this.setUuid(i),this._reportTelemetry({action:"pdfjs.signature.inserted",data:{hasBeenSaved:!!i,hasDescription:!!n}}),this.div.hidden=!1}getFromImage(e){const{rawDims:{pageWidth:r,pageHeight:n},rotation:i}=this.parent.viewport;return LE.process(e,r,n,i,ig._INNER_MARGIN)}getFromText(e,r){const{rawDims:{pageWidth:n,pageHeight:i},rotation:a}=this.parent.viewport;return LE.extractContoursFromText(e,r,n,i,a,ig._INNER_MARGIN)}getDrawnSignature(e){const{rawDims:{pageWidth:r,pageHeight:n},rotation:i}=this.parent.viewport;return LE.processDrawnLines({lines:e,pageWidth:r,pageHeight:n,rotation:i,innerMargin:ig._INNER_MARGIN,mustSmooth:!1,areContours:!1})}createDrawingOptions({areContours:e,thickness:r}){e?this._drawingOptions=ig.getDefaultDrawingOptions():(this._drawingOptions=ig._defaultDrawnSignatureOptions.clone(),this._drawingOptions.updateProperties({"stroke-width":r}))}serialize(e=!1){if(this.isEmpty())return null;const{lines:r,points:n,rect:i}=this.serializeDraw(e),{_drawingOptions:{"stroke-width":a}}=this,s={annotationType:Ii.SIGNATURE,isSignature:!0,areContours:this.#e,color:[0,0,0],thickness:this.#e?0:a,pageIndex:this.pageIndex,rect:i,rotation:this.rotation,structTreeParentId:this._structTreeParentId};return this.addComment(s),e?(s.paths={lines:r,points:n},s.uuid=this.#n,s.isCopy=!0):s.lines=r,this.#t&&(s.accessibilityData={type:"Figure",alt:this.#t}),s}static deserializeDraw(e,r,n,i,a,s){return s.areContours?Kee.deserialize(e,r,n,i,a,s):J8.deserialize(e,r,n,i,a,s)}static async deserialize(e,r,n){const i=await super.deserialize(e,r,n);return i.#e=e.areContours,i.description=e.accessibilityData?.alt||"",i.#n=e.uuid,i}}class $Bt extends ti{#e=null;#t=null;#r=null;#n=null;#i=null;#a="";#s=null;#o=!1;#l=null;#c=!1;#d=!1;static _type="stamp";static _editorType=Ii.STAMP;constructor(e){super({...e,name:"stampEditor"}),this.#n=e.bitmapUrl,this.#i=e.bitmapFile,this.defaultL10nId="pdfjs-editor-stamp-editor"}static initialize(e,r){ti.initialize(e,r)}static isHandlingMimeForPasting(e){return Gee.includes(e)}static paste(e,r){r.pasteEditor({mode:Ii.STAMP},{bitmapFile:e.getAsFile()})}altTextFinish(){this._uiManager.useNewAltTextFlow&&(this.div.hidden=!1),super.altTextFinish()}get telemetryFinalData(){return{type:"stamp",hasAltText:!!this.altTextData?.altText}}static computeTelemetryFinalData(e){const r=e.get("hasAltText");return{hasAltText:r.get(!0)??0,hasNoAltText:r.get(!1)??0}}#u(e,r=!1){if(!e){this.remove();return}this.#e=e.bitmap,r||(this.#t=e.id,this.#c=e.isSvg),e.file&&(this.#a=e.file.name),this.#f()}#p(){if(this.#r=null,this._uiManager.enableWaiting(!1),!!this.#s){if(this._uiManager.useNewAltTextWhenAddingImage&&this._uiManager.useNewAltTextFlow&&this.#e){this.addEditToolbar().then(()=>{this._editToolbar.hide(),this._uiManager.editAltText(this,!0)});return}if(!this._uiManager.useNewAltTextWhenAddingImage&&this._uiManager.useNewAltTextFlow&&this.#e){this._reportTelemetry({action:"pdfjs.image.image_added",data:{alt_text_modal:!1,alt_text_type:"empty"}});try{this.mlGuessAltText()}catch{}}this.div.focus()}}async mlGuessAltText(e=null,r=!0){if(this.hasAltTextData())return null;const{mlManager:n}=this._uiManager;if(!n)throw new Error("No ML.");if(!await n.isEnabledFor("altText"))throw new Error("ML isn't enabled for alt text.");const{data:i,width:a,height:s}=e||this.copyCanvas(null,null,!0).imageData,o=await n.guess({name:"altText",request:{data:i,width:a,height:s,channels:i.length/(a*s)}});if(!o)throw new Error("No response from the AI service.");if(o.error)throw new Error("Error from the AI service.");if(o.cancel)return null;if(!o.output)throw new Error("No valid response from the AI service.");const l=o.output;return await this.setGuessedAltText(l),r&&!this.hasAltTextData()&&(this.altTextData={alt:l,decorative:!1}),l}#g(){if(this.#t){this._uiManager.enableWaiting(!0),this._uiManager.imageManager.getFromId(this.#t).then(n=>this.#u(n,!0)).finally(()=>this.#p());return}if(this.#n){const n=this.#n;this.#n=null,this._uiManager.enableWaiting(!0),this.#r=this._uiManager.imageManager.getFromUrl(n).then(i=>this.#u(i)).finally(()=>this.#p());return}if(this.#i){const n=this.#i;this.#i=null,this._uiManager.enableWaiting(!0),this.#r=this._uiManager.imageManager.getFromFile(n).then(i=>this.#u(i)).finally(()=>this.#p());return}const e=document.createElement("input");e.type="file",e.accept=Gee.join(",");const r=this._uiManager._signal;this.#r=new Promise(n=>{e.addEventListener("change",async()=>{if(!e.files||e.files.length===0)this.remove();else{this._uiManager.enableWaiting(!0);const i=await this._uiManager.imageManager.getFromFile(e.files[0]);this._reportTelemetry({action:"pdfjs.image.image_selected",data:{alt_text_modal:this._uiManager.useNewAltTextFlow}}),this.#u(i)}n()},{signal:r}),e.addEventListener("cancel",()=>{this.remove(),n()},{signal:r})}).finally(()=>this.#p()),e.click()}remove(){this.#t&&(this.#e=null,this._uiManager.imageManager.deleteId(this.#t),this.#s?.remove(),this.#s=null,this.#l&&(clearTimeout(this.#l),this.#l=null)),super.remove()}rebuild(){if(!this.parent){this.#t&&this.#g();return}super.rebuild(),this.div!==null&&(this.#t&&this.#s===null&&this.#g(),this.isAttachedToDOM||this.parent.add(this))}onceAdded(e){this._isDraggable=!0,e&&this.div.focus()}isEmpty(){return!(this.#r||this.#e||this.#n||this.#i||this.#t||this.#o)}get toolbarButtons(){return[["altText",this.createAltText()]]}get isResizable(){return!0}render(){if(this.div)return this.div;let e,r;return this._isCopy&&(e=this.x,r=this.y),super.render(),this.div.hidden=!0,this.createAltText(),this.#o||(this.#e?this.#f():this.#g()),this._isCopy&&this._moveAfterPaste(e,r),this._uiManager.addShouldRescale(this),this.div}setCanvas(e,r){const{id:n,bitmap:i}=this._uiManager.imageManager.getFromCanvas(e,r);r.remove(),n&&this._uiManager.imageManager.isValidId(n)&&(this.#t=n,i&&(this.#e=i),this.#o=!1,this.#f())}_onResized(){this.onScaleChanging()}onScaleChanging(){if(!this.parent)return;this.#l!==null&&clearTimeout(this.#l);const e=200;this.#l=setTimeout(()=>{this.#l=null,this.#m()},e)}#f(){const{div:e}=this;let{width:r,height:n}=this.#e;const[i,a]=this.pageDimensions,s=.75;if(this.width)r=this.width*i,n=this.height*a;else if(r>s*i||n>s*a){const d=Math.min(s*i/r,s*a/n);r*=d,n*=d}const[o,l]=this.parentDimensions;this.setDims(r*o/i,n*l/a),this._uiManager.enableWaiting(!1);const u=this.#s=document.createElement("canvas");u.setAttribute("role","img"),this.addContainer(u),this.width=r/i,this.height=n/a,this._initialOptions?.isCentered?this.center():this.fixAndSetPosition(),this._initialOptions=null,(!this._uiManager.useNewAltTextWhenAddingImage||!this._uiManager.useNewAltTextFlow||this.annotationElementId)&&(e.hidden=!1),this.#m(),this.#d||(this.parent.addUndoableEditor(this),this.#d=!0),this._reportTelemetry({action:"inserted_image"}),this.#a&&this.div.setAttribute("aria-description",this.#a),this.annotationElementId||this._uiManager.a11yAlert("pdfjs-editor-stamp-added-alert")}copyCanvas(e,r,n=!1){e||(e=224);const{width:i,height:a}=this.#e,s=new Qg;let o=this.#e,l=i,u=a,d=null;if(r){if(i>r||a>r){const C=Math.min(r/i,r/a);l=Math.floor(i*C),u=Math.floor(a*C)}d=document.createElement("canvas");const f=d.width=Math.ceil(l*s.sx),p=d.height=Math.ceil(u*s.sy);this.#c||(o=this.#h(f,p));const g=d.getContext("2d");g.filter=this._uiManager.hcmFilter;let m="white",_="#cfcfd8";this._uiManager.hcmFilter!=="none"?_="black":window.matchMedia?.("(prefers-color-scheme: dark)").matches&&(m="#8f8f9d",_="#42414d");const v=15,b=v*s.sx,y=v*s.sy,E=new OffscreenCanvas(b*2,y*2),T=E.getContext("2d");T.fillStyle=m,T.fillRect(0,0,b*2,y*2),T.fillStyle=_,T.fillRect(0,0,b,y),T.fillRect(b,y,b,y),g.fillStyle=g.createPattern(E,"repeat"),g.fillRect(0,0,f,p),g.drawImage(o,0,0,o.width,o.height,0,0,f,p)}let h=null;if(n){let f,p;if(s.symmetric&&o.widthe||a>e){const _=Math.min(e/i,e/a);f=Math.floor(i*_),p=Math.floor(a*_),this.#c||(o=this.#h(f,p))}const m=new OffscreenCanvas(f,p).getContext("2d",{willReadFrequently:!0});m.drawImage(o,0,0,o.width,o.height,0,0,f,p),h={width:f,height:p,data:m.getImageData(0,0,f,p).data}}return{canvas:d,width:l,height:u,imageData:h}}#h(e,r){const{width:n,height:i}=this.#e;let a=n,s=i,o=this.#e;for(;a>2*e||s>2*r;){const l=a,u=s;a>2*e&&(a=a>=16384?Math.floor(a/2)-1:Math.ceil(a/2)),s>2*r&&(s=s>=16384?Math.floor(s/2)-1:Math.ceil(s/2));const d=new OffscreenCanvas(a,s);d.getContext("2d").drawImage(o,0,0,l,u,0,0,a,s),o=d.transferToImageBitmap()}return o}#m(){const[e,r]=this.parentDimensions,{width:n,height:i}=this,a=new Qg,s=Math.ceil(n*e*a.sx),o=Math.ceil(i*r*a.sy),l=this.#s;if(!l||l.width===s&&l.height===o)return;l.width=s,l.height=o;const u=this.#c?this.#e:this.#h(s,o),d=l.getContext("2d");d.filter=this._uiManager.hcmFilter,d.drawImage(u,0,0,u.width,u.height,0,0,s,o)}#v(e){if(e){if(this.#c){const i=this._uiManager.imageManager.getSvgUrl(this.#t);if(i)return i}const r=document.createElement("canvas");return{width:r.width,height:r.height}=this.#e,r.getContext("2d").drawImage(this.#e,0,0),r.toDataURL()}if(this.#c){const[r,n]=this.pageDimensions,i=Math.round(this.width*r*fx.PDF_TO_CSS_UNITS),a=Math.round(this.height*n*fx.PDF_TO_CSS_UNITS),s=new OffscreenCanvas(i,a);return s.getContext("2d").drawImage(this.#e,0,0,this.#e.width,this.#e.height,0,0,i,a),s.transferToImageBitmap()}return structuredClone(this.#e)}static async deserialize(e,r,n){let i=null,a=!1;if(e instanceof ZMe){const{data:{rect:m,rotation:_,id:v,structParent:b,popupRef:y,contentsObj:E},container:T,parent:{page:{pageNumber:C}},canvas:w}=e;let x,A;w?(delete e.canvas,{id:x,bitmap:A}=n.imageManager.getFromCanvas(T.id,w),w.remove()):(a=!0,e._hasNoCanvas=!0);const R=(await r._structTree.getAriaAttributes(`${Jce}${v}`))?.get("aria-label")||"";i=e={annotationType:Ii.STAMP,bitmapId:x,bitmap:A,pageIndex:C-1,rect:m.slice(0),rotation:_,annotationElementId:v,id:v,deleted:!1,accessibilityData:{decorative:!1,altText:R},isSvg:!1,structParent:b,popupRef:y,comment:E?.str||null}}const s=await super.deserialize(e,r,n),{rect:o,bitmap:l,bitmapUrl:u,bitmapId:d,isSvg:h,accessibilityData:f}=e;a?(n.addMissingCanvas(e.id,s),s.#o=!0):d&&n.imageManager.isValidId(d)?(s.#t=d,l&&(s.#e=l)):s.#n=u,s.#c=h;const[p,g]=s.pageDimensions;return s.width=(o[2]-o[0])/p,s.height=(o[3]-o[1])/g,f&&(s.altTextData=f),s._initialData=i,e.comment&&s.setCommentData(e.comment),s.#d=!!i,s}serialize(e=!1,r=null){if(this.isEmpty())return null;if(this.deleted)return this.serializeDeleted();const n={annotationType:Ii.STAMP,bitmapId:this.#t,pageIndex:this.pageIndex,rect:this.getRect(0,0),rotation:this.rotation,isSvg:this.#c,structTreeParentId:this._structTreeParentId};if(this.addComment(n),e)return n.bitmapUrl=this.#v(!0),n.accessibilityData=this.serializeAltText(!0),n.isCopy=!0,n;const{decorative:i,altText:a}=this.serializeAltText(!1);if(!i&&a&&(n.accessibilityData={type:"Figure",alt:a}),this.annotationElementId){const o=this.#_(n);if(o.isSame)return null;o.isSameAltText?delete n.accessibilityData:n.accessibilityData.structParent=this._initialData.structParent??-1}if(n.id=this.annotationElementId,r===null)return n;r.stamps||=new Map;const s=this.#c?(n.rect[2]-n.rect[0])*(n.rect[3]-n.rect[1]):null;if(!r.stamps.has(this.#t))r.stamps.set(this.#t,{area:s,serialized:n}),n.bitmap=this.#v(!1);else if(this.#c){const o=r.stamps.get(this.#t);s>o.area&&(o.area=s,o.serialized.bitmap.close(),o.serialized.bitmap=this.#v(!1))}return n}#_(e){const{pageIndex:r,accessibilityData:{altText:n}}=this._initialData,i=e.pageIndex===r,a=(e.accessibilityData?.alt||"")===n;return{isSame:!this.hasEditedComment&&!this._hasBeenMoved&&!this._hasBeenResized&&i&&a,isSameAltText:a}}renderAnnotationElement(e){const r={rect:this.getRect(0,0)};return this.hasEditedComment&&(r.popup=this.comment),e.updateEdited(r),null}}class Qm{#e;#t=!1;#r=null;#n=null;#i=null;#a=new Map;#s=!1;#o=!1;#l=!1;#c=null;#d=null;#u=null;#p=null;#g=null;#f=-1;#h;static _initialized=!1;static#m=new Map([pl,fue,$Bt,Ao,ig].map(e=>[e._editorType,e]));constructor({uiManager:e,pageIndex:r,div:n,structTreeLayer:i,accessibilityManager:a,annotationLayer:s,drawLayer:o,textLayer:l,viewport:u,l10n:d}){const h=[...Qm.#m.values()];if(!Qm._initialized){Qm._initialized=!0;for(const f of h)f.initialize(d,e)}e.registerEditorTypes(h),this.#h=e,this.pageIndex=r,this.div=n,this.#e=a,this.#r=s,this.viewport=u,this.#u=l,this.drawLayer=o,this._structTree=i,this.#h.addLayer(this)}get isEmpty(){return this.#a.size===0}get isInvisible(){return this.isEmpty&&this.#h.getMode()===Ii.NONE}updateToolbar(e){this.#h.updateToolbar(e)}updateMode(e=this.#h.getMode()){switch(this.#y(),e){case Ii.NONE:this.disableTextSelection(),this.togglePointerEvents(!1),this.toggleAnnotationLayerPointerEvents(!0),this.disableClick();return;case Ii.INK:this.disableTextSelection(),this.togglePointerEvents(!0),this.enableClick();break;case Ii.HIGHLIGHT:this.enableTextSelection(),this.togglePointerEvents(!1),this.disableClick();break;default:this.disableTextSelection(),this.togglePointerEvents(!0),this.enableClick()}this.toggleAnnotationLayerPointerEvents(!1);const{classList:r}=this.div;for(const n of Qm.#m.values())r.toggle(`${n._type}Editing`,e===n._editorType);this.div.hidden=!1}hasTextLayer(e){return e===this.#u?.div}setEditingState(e){this.#h.setEditingState(e)}addCommands(e){this.#h.addCommands(e)}cleanUndoStack(e){this.#h.cleanUndoStack(e)}toggleDrawing(e=!1){this.div.classList.toggle("drawing",!e)}togglePointerEvents(e=!1){this.div.classList.toggle("disabled",!e)}toggleAnnotationLayerPointerEvents(e=!1){this.#r?.div.classList.toggle("disabled",!e)}async enable(){this.#l=!0,this.div.tabIndex=0,this.togglePointerEvents(!0),this.#g?.abort(),this.#g=null;const e=new Set;for(const n of this.#a.values())n.enableEditing(),n.show(!0),n.annotationElementId&&(this.#h.removeChangedExistingAnnotation(n),e.add(n.annotationElementId));if(!this.#r){this.#l=!1;return}const r=this.#r.getEditableAnnotations();for(const n of r){if(n.hide(),this.#h.isDeletedAnnotationElement(n.data.id)||e.has(n.data.id))continue;const i=await this.deserialize(n);i&&(this.addOrRebuild(i),i.enableEditing())}this.#l=!1}disable(){if(this.#o=!0,this.div.tabIndex=-1,this.togglePointerEvents(!1),this.#u&&!this.#g){this.#g=new AbortController;const i=this.#h.combinedSignal(this.#g);this.#u.div.addEventListener("pointerdown",a=>{const{clientX:o,clientY:l,timeStamp:u}=a,d=this.#f;if(u-d>500){this.#f=u;return}this.#f=-1;const{classList:h}=this.div;h.toggle("getElements",!0);const f=document.elementsFromPoint(o,l);if(h.toggle("getElements",!1),!this.div.contains(f[0]))return;let p;const g=new RegExp(`^${TMe}[0-9]+$`);for(const _ of f)if(g.test(_.id)){p=_.id;break}if(!p)return;const m=this.#a.get(p);m?.annotationElementId===null&&(a.stopPropagation(),a.preventDefault(),m.dblclick())},{signal:i,capture:!0})}const e=new Map,r=new Map;for(const i of this.#a.values())if(i.disableEditing(),!!i.annotationElementId){if(i.serialize()!==null){e.set(i.annotationElementId,i);continue}else r.set(i.annotationElementId,i);this.getEditableAnnotation(i.annotationElementId)?.show(),i.remove()}if(this.#r){const i=this.#r.getEditableAnnotations();for(const a of i){const{id:s}=a.data;if(this.#h.isDeletedAnnotationElement(s)){a.updateEdited({deleted:!0});continue}let o=r.get(s);if(o){o.resetAnnotationElement(a),o.show(!1),a.show();continue}o=e.get(s),o&&(this.#h.addChangedExistingAnnotation(o),o.renderAnnotationElement(a)&&o.show(!1)),a.show()}}this.#y(),this.isEmpty&&(this.div.hidden=!0);const{classList:n}=this.div;for(const i of Qm.#m.values())n.remove(`${i._type}Editing`);this.disableTextSelection(),this.toggleAnnotationLayerPointerEvents(!0),this.#o=!1}getEditableAnnotation(e){return this.#r?.getEditableAnnotation(e)||null}setActiveEditor(e){this.#h.getActive()!==e&&this.#h.setActiveEditor(e)}enableTextSelection(){if(this.div.tabIndex=-1,this.#u?.div&&!this.#p){this.#p=new AbortController;const e=this.#h.combinedSignal(this.#p);this.#u.div.addEventListener("pointerdown",this.#v.bind(this),{signal:e}),this.#u.div.classList.add("highlighting")}}disableTextSelection(){this.div.tabIndex=0,this.#u?.div&&this.#p&&(this.#p.abort(),this.#p=null,this.#u.div.classList.remove("highlighting"))}#v(e){this.#h.unselectAll();const{target:r}=e;if(r===this.#u.div||(r.getAttribute("role")==="img"||r.classList.contains("endOfContent"))&&this.#u.div.contains(r)){const{isMac:n}=Sc.platform;if(e.button!==0||e.ctrlKey&&n)return;this.#h.showAllEditors("highlight",!0,!0),this.#u.div.classList.add("free"),this.toggleDrawing(),Ao.startHighlighting(this,this.#h.direction==="ltr",{target:this.#u.div,x:e.x,y:e.y}),this.#u.div.addEventListener("pointerup",()=>{this.#u.div.classList.remove("free"),this.toggleDrawing(!0)},{once:!0,signal:this.#h._signal}),e.preventDefault()}}enableClick(){if(this.#n)return;this.#n=new AbortController;const e=this.#h.combinedSignal(this.#n);this.div.addEventListener("pointerdown",this.pointerdown.bind(this),{signal:e});const r=this.pointerup.bind(this);this.div.addEventListener("pointerup",r,{signal:e}),this.div.addEventListener("pointercancel",r,{signal:e})}disableClick(){this.#n?.abort(),this.#n=null}attach(e){this.#a.set(e.id,e);const{annotationElementId:r}=e;r&&this.#h.isDeletedAnnotationElement(r)&&this.#h.removeDeletedAnnotationElement(e)}detach(e){this.#a.delete(e.id),this.#e?.removePointerInTextLayer(e.contentDiv),!this.#o&&e.annotationElementId&&this.#h.addDeletedAnnotationElement(e)}remove(e){this.detach(e),this.#h.removeEditor(e),e.div.remove(),e.isAttachedToDOM=!1}changeParent(e){e.parent!==this&&(e.parent&&e.annotationElementId&&(this.#h.addDeletedAnnotationElement(e.annotationElementId),ti.deleteAnnotationElement(e),e.annotationElementId=null),this.attach(e),e.parent?.detach(e),e.setParent(this),e.div&&e.isAttachedToDOM&&(e.div.remove(),this.div.append(e.div)))}add(e){if(!(e.parent===this&&e.isAttachedToDOM)){if(this.changeParent(e),this.#h.addEditor(e),this.attach(e),!e.isAttachedToDOM){const r=e.render();this.div.append(r),e.isAttachedToDOM=!0}e.fixAndSetPosition(),e.onceAdded(!this.#l),this.#h.addToAnnotationStorage(e),e._reportTelemetry(e.telemetryInitialData)}}moveEditorInDOM(e){if(!e.isAttachedToDOM)return;const{activeElement:r}=document;e.div.contains(r)&&!this.#i&&(e._focusEventsAllowed=!1,this.#i=setTimeout(()=>{this.#i=null,e.div.contains(document.activeElement)?e._focusEventsAllowed=!0:(e.div.addEventListener("focusin",()=>{e._focusEventsAllowed=!0},{once:!0,signal:this.#h._signal}),r.focus())},0)),e._structTreeParentId=this.#e?.moveElementInDOM(this.div,e.div,e.contentDiv,!0)}addOrRebuild(e){e.needsToBeRebuilt()?(e.parent||=this,e.rebuild(),e.show()):this.add(e)}addUndoableEditor(e){const r=()=>e._uiManager.rebuild(e),n=()=>{e.remove()};this.addCommands({cmd:r,undo:n,mustExec:!1})}getNextId(){return this.#h.getId()}get#_(){return Qm.#m.get(this.#h.getMode())}combinedSignal(e){return this.#h.combinedSignal(e)}#S(e){const r=this.#_;return r?new r.prototype.constructor(e):null}canCreateNewEmptyEditor(){return this.#_?.canCreateNewEmptyEditor()}async pasteEditor(e,r){this.updateToolbar(e),await this.#h.updateMode(e.mode);const{offsetX:n,offsetY:i}=this.#b(),a=this.getNextId(),s=this.#S({parent:this,id:a,x:n,y:i,uiManager:this.#h,isCentered:!0,...r});s&&this.add(s)}async deserialize(e){return await Qm.#m.get(e.annotationType??e.annotationEditorType)?.deserialize(e,this,this.#h)||null}createAndAddNewEditor(e,r,n={}){const i=this.getNextId(),a=this.#S({parent:this,id:i,x:e.offsetX,y:e.offsetY,uiManager:this.#h,isCentered:r,...n});return a&&this.add(a),a}#b(){const{x:e,y:r,width:n,height:i}=this.div.getBoundingClientRect(),a=Math.max(0,e),s=Math.max(0,r),o=Math.min(window.innerWidth,e+n),l=Math.min(window.innerHeight,r+i),u=(a+o)/2-e,d=(s+l)/2-r,[h,f]=this.viewport.rotation%180===0?[u,d]:[d,u];return{offsetX:h,offsetY:f}}addNewEditor(e={}){this.createAndAddNewEditor(this.#b(),!0,e)}setSelected(e){this.#h.setSelected(e)}toggleSelected(e){this.#h.toggleSelected(e)}unselect(e){this.#h.unselect(e)}pointerup(e){const{isMac:r}=Sc.platform;if(e.button!==0||e.ctrlKey&&r||e.target!==this.div||!this.#s||(this.#s=!1,this.#_?.isDrawer&&this.#_.supportMultipleDrawings))return;if(!this.#t){this.#t=!0;return}const n=this.#h.getMode();if(n===Ii.STAMP||n===Ii.SIGNATURE){this.#h.unselectAll();return}this.createAndAddNewEditor(e,!1)}pointerdown(e){if(this.#h.getMode()===Ii.HIGHLIGHT&&this.enableTextSelection(),this.#s){this.#s=!1;return}const{isMac:r}=Sc.platform;if(e.button!==0||e.ctrlKey&&r||e.target!==this.div)return;if(this.#s=!0,this.#_?.isDrawer){this.startDrawingSession(e);return}const n=this.#h.getActive();this.#t=!n||n.isEmpty()}startDrawingSession(e){if(this.div.focus({preventScroll:!0}),this.#c){this.#_.startDrawing(this,this.#h,!1,e);return}this.#h.setCurrentDrawingSession(this),this.#c=new AbortController;const r=this.#h.combinedSignal(this.#c);this.div.addEventListener("blur",({relatedTarget:n})=>{n&&!this.div.contains(n)&&(this.#d=null,this.commitOrRemove())},{signal:r}),this.#_.startDrawing(this,this.#h,!1,e)}pause(e){if(e){const{activeElement:r}=document;this.div.contains(r)&&(this.#d=r);return}this.#d&&setTimeout(()=>{this.#d?.focus(),this.#d=null},0)}endDrawingSession(e=!1){return this.#c?(this.#h.setCurrentDrawingSession(null),this.#c.abort(),this.#c=null,this.#d=null,this.#_.endDrawing(e)):null}findNewParent(e,r,n){const i=this.#h.findParent(r,n);return i===null||i===this?!1:(i.changeParent(e),!0)}commitOrRemove(){return this.#c?(this.endDrawingSession(),!0):!1}onScaleChanging(){this.#c&&this.#_.onScaleChangingWhenDrawing(this)}destroy(){this.commitOrRemove(),this.#h.getActive()?.parent===this&&(this.#h.commitOrRemove(),this.#h.setActiveEditor(null)),this.#i&&(clearTimeout(this.#i),this.#i=null);for(const e of this.#a.values())this.#e?.removePointerInTextLayer(e.contentDiv),e.setParent(null),e.isAttachedToDOM=!1,e.div.remove();this.div=null,this.#a.clear(),this.#h.removeLayer(this)}#y(){for(const e of this.#a.values())e.isEmpty()&&e.remove()}render({viewport:e}){this.viewport=e,_2(this.div,e);for(const r of this.#h.getEditors(this.pageIndex))this.add(r),r.rebuild();this.updateMode()}update({viewport:e}){this.#h.commitOrRemove(),this.#y();const r=this.viewport.rotation,n=e.rotation;if(this.viewport=e,_2(this.div,{rotation:n}),r!==n)for(const i of this.#a.values())i.rotate(n)}get pageDimensions(){const{pageWidth:e,pageHeight:r}=this.viewport.rawDims;return[e,r]}get scale(){return this.#h.viewParameters.realScale}}class ac{#e=null;#t=new Map;#r=new Map;static#n=0;constructor({pageIndex:e}){this.pageIndex=e}setParent(e){if(!this.#e){this.#e=e;return}if(this.#e!==e){if(this.#t.size>0)for(const r of this.#t.values())r.remove(),e.append(r);this.#e=e}}static get _svgFactory(){return na(this,"_svgFactory",new CP)}static#i(e,[r,n,i,a]){const{style:s}=e;s.top=`${100*n}%`,s.left=`${100*r}%`,s.width=`${100*i}%`,s.height=`${100*a}%`}#a(){const e=ac._svgFactory.create(1,1,!0);return this.#e.append(e),e.setAttribute("aria-hidden",!0),e}#s(e,r){const n=ac._svgFactory.createElement("clipPath");e.append(n);const i=`clip_${r}`;n.setAttribute("id",i),n.setAttribute("clipPathUnits","objectBoundingBox");const a=ac._svgFactory.createElement("use");return n.append(a),a.setAttribute("href",`#${r}`),a.classList.add("clip"),i}#o(e,r){for(const[n,i]of Object.entries(r))i===null?e.removeAttribute(n):e.setAttribute(n,i)}draw(e,r=!1,n=!1){const i=ac.#n++,a=this.#a(),s=ac._svgFactory.createElement("defs");a.append(s);const o=ac._svgFactory.createElement("path");s.append(o);const l=`path_p${this.pageIndex}_${i}`;o.setAttribute("id",l),o.setAttribute("vector-effect","non-scaling-stroke"),r&&this.#r.set(i,o);const u=n?this.#s(s,l):null,d=ac._svgFactory.createElement("use");return a.append(d),d.setAttribute("href",`#${l}`),this.updateProperties(a,e),this.#t.set(i,a),{id:i,clipPathId:`url(#${u})`}}drawOutline(e,r){const n=ac.#n++,i=this.#a(),a=ac._svgFactory.createElement("defs");i.append(a);const s=ac._svgFactory.createElement("path");a.append(s);const o=`path_p${this.pageIndex}_${n}`;s.setAttribute("id",o),s.setAttribute("vector-effect","non-scaling-stroke");let l;if(r){const h=ac._svgFactory.createElement("mask");a.append(h),l=`mask_p${this.pageIndex}_${n}`,h.setAttribute("id",l),h.setAttribute("maskUnits","objectBoundingBox");const f=ac._svgFactory.createElement("rect");h.append(f),f.setAttribute("width","1"),f.setAttribute("height","1"),f.setAttribute("fill","white");const p=ac._svgFactory.createElement("use");h.append(p),p.setAttribute("href",`#${o}`),p.setAttribute("stroke","none"),p.setAttribute("fill","black"),p.setAttribute("fill-rule","nonzero"),p.classList.add("mask")}const u=ac._svgFactory.createElement("use");i.append(u),u.setAttribute("href",`#${o}`),l&&u.setAttribute("mask",`url(#${l})`);const d=u.cloneNode();return i.append(d),u.classList.add("mainOutline"),d.classList.add("secondaryOutline"),this.updateProperties(i,e),this.#t.set(n,i),n}finalizeDraw(e,r){this.#r.delete(e),this.updateProperties(e,r)}updateProperties(e,r){if(!r)return;const{root:n,bbox:i,rootClass:a,path:s}=r,o=typeof e=="number"?this.#t.get(e):e;if(o){if(n&&this.#o(o,n),i&&ac.#i(o,i),a){const{classList:l}=o;for(const[u,d]of Object.entries(a))l.toggle(u,d)}if(s){const u=o.firstChild.firstChild;this.#o(u,s)}}}updateParent(e,r){if(r===this)return;const n=this.#t.get(e);n&&(r.#e.append(n),this.#t.delete(e),r.#t.set(e,n))}remove(e){this.#r.delete(e),this.#e!==null&&(this.#t.get(e).remove(),this.#t.delete(e))}destroy(){this.#e=null;for(const e of this.#t.values())e.remove();this.#t.clear(),this.#r.clear()}}globalThis._pdfjsTestingUtils={HighlightOutliner:Yee};globalThis.pdfjsLib={AbortException:Q_,AnnotationEditorLayer:Qm,AnnotationEditorParamsType:_a,AnnotationEditorType:Ii,AnnotationEditorUIManager:Z_,AnnotationLayer:hue,AnnotationMode:p_,AnnotationType:qo,build:_Bt,ColorPicker:Yh,createValidAbsoluteUrl:CMe,DOMSVGFactory:CP,DrawLayer:ac,FeatureTest:Sc,fetchData:j8,getDocument:lue,getFilenameFromUrl:cFt,getPdfFilenameFromUrl:uFt,getRGB:m$,getUuid:AMe,getXfaPageViewport:hFt,GlobalWorkerOptions:YT,ImageKind:FD,InvalidPDFException:Uee,isDataScheme:g$,isPdfFile:tue,isValidExplicitDest:TFt,MathClamp:gu,noContextMenu:yf,normalizeUnicode:sFt,OPS:EP,OutputScale:Qg,PasswordResponses:QPt,PDFDataRangeTransport:HMe,PDFDateString:$ee,PDFWorker:ZR,PermissionFlag:XPt,PixelsPerInch:fx,RenderingCancelledException:eue,ResponseException:TP,setLayerDimensions:_2,shadow:na,SignatureExtractor:LE,stopEvent:Wo,SupportedImageMimeTypes:Gee,TextLayer:hu,TouchManager:_$,updateUrlHash:wMe,Util:Xn,VerbosityLevel:h$,version:mBt,XfaLayer:WMe};Fn(()=>Promise.resolve().then(()=>r_r),[],import.meta.url).then(t=>{const e=new Blob([t.default],{type:"application/javascript"});YT.workerSrc=URL.createObjectURL(e)}).catch(()=>{console.warn("Failed to load PDF.js worker, PDF processing may not work")});async function tLe(t){return new Promise((e,r)=>{const n=new FileReader;n.onload=i=>{i.target?.result?e(i.target.result):r(new Error("Failed to read file."))},n.onerror=()=>{r(new Error("Failed to read file."))},n.readAsArrayBuffer(t)})}async function jee(t){try{const e=await tLe(t),r=await lue({data:e}).promise,n=r.numPages,i=[];for(let o=1;o<=n;o++)i.push(r.getPage(o).then(l=>l.getTextContent()));return(await Promise.all(i)).flatMap(o=>o.items.map(l=>l.str??"")).join(` +`)}catch(e){throw console.error("Error converting PDF to text:",e),new Error(`Failed to convert PDF to text: ${e instanceof Error?e.message:"Unknown error"}`)}}async function rLe(t,e=1.5){try{const r=await tLe(t),n=await lue({data:r}).promise,i=[];for(let a=1;a<=n.numPages;a++){const s=await n.getPage(a),o=s.getViewport({scale:e}),l=document.createElement("canvas"),u=l.getContext("2d");if(l.width=o.width,l.height=o.height,!u)throw new Error("Failed to get 2D context from canvas");const d=s.render({canvas:l,canvasContext:u,viewport:o});i.push(d.promise.then(()=>l.toDataURL(Zi.PNG)))}return await Promise.all(i)}catch(r){throw console.error("Error converting PDF to images:",r),new Error(`Failed to convert PDF to images: ${r instanceof Error?r.message:"Unknown error"}`)}}function nLe(t,e="white"){return new Promise((r,n)=>{try{const i=new Image;i.onload=()=>{const a=document.createElement("canvas"),s=a.getContext("2d");if(!s){n(new Error("Failed to get 2D canvas context."));return}const o=i.naturalWidth||300,l=i.naturalHeight||300;a.width=o,a.height=l,e&&(s.fillStyle=e,s.fillRect(0,0,a.width,a.height)),s.drawImage(i,0,0,o,l),r(a.toDataURL(Zi.PNG))},i.onerror=()=>{n(new Error("Failed to load SVG image. Ensure the SVG data is valid."))},i.src=t}catch(i){const s=`Error converting SVG to PNG: ${i instanceof Error?i.message:String(i)}`;console.error(s,i),n(new Error(s))}})}function iLe(t){return t===Zi.SVG}function aLe(t,e="white"){return new Promise((r,n)=>{try{const i=new Image;i.onload=()=>{const a=document.createElement("canvas"),s=a.getContext("2d");if(!s){n(new Error("Failed to get 2D canvas context."));return}const o=i.naturalWidth||300,l=i.naturalHeight||300;a.width=o,a.height=l,e&&(s.fillStyle=e,s.fillRect(0,0,a.width,a.height)),s.drawImage(i,0,0,o,l),r(a.toDataURL(Zi.PNG))},i.onerror=()=>{n(new Error("Failed to load WebP image. Ensure the WebP data is valid."))},i.src=t}catch(i){const s=`Error converting WebP to PNG: ${i instanceof Error?i.message:String(i)}`;console.error(s,i),n(new Error(s))}})}function sLe(t){return t===Zi.WEBP}function HK(t){return new Promise((e,r)=>{const n=new FileReader;n.onload=()=>{const a=n.result.split(",")[1];e(a)},n.onerror=()=>r(n.error),n.readAsDataURL(t)})}async function mue(t,e){const r=[],n=[];for(const i of t){if(i.type===DR.MCP_PROMPT&&i.mcpPrompt){r.push({arguments:i.mcpPrompt.arguments,content:i.textContent??"",name:i.name,promptName:i.mcpPrompt.promptName,serverName:i.mcpPrompt.serverName,size:i.size,type:Ti.MCP_PROMPT});continue}if(nh(i.type)===pi.IMAGE){if(i.preview){let a=i.preview;if(iLe(i.type))try{a=await nLe(a)}catch(s){console.error("Failed to convert SVG to PNG for database storage:",s)}else if(sLe(i.type))try{a=await aLe(a)}catch(s){console.error("Failed to convert WebP to PNG for database storage:",s)}r.push({base64Url:a,name:i.name,size:i.size,type:Ti.IMAGE})}}else if(nh(i.type)===pi.AUDIO)try{const a=await HK(i.file);r.push({base64Data:a,mimeType:i.type,name:i.name,size:i.size,type:Ti.AUDIO})}catch(a){console.error(`Failed to process audio file ${i.name}:`,a)}else if(nh(i.type)===pi.VIDEO)try{const a=await HK(i.file);r.push({base64Data:a,mimeType:i.type,name:i.name,size:i.size,type:Ti.VIDEO})}catch(a){console.error(`Failed to process video file ${i.name}:`,a)}else if(nh(i.type)===pi.PDF)try{const a=await HK(i.file),s=Vn(),o=e?Ar.modelSupportsVision(e):!1;let l=!!s.pdfAsImage&&o;if(s.pdfAsImage&&!o&&(console.log("Non-vision model detected: forcing PDF-to-text mode and updating settings"),nl.updateConfig(hr.PDF_AS_IMAGE,!1),Qi.warning("PDF setting changed: Non-vision model detected, PDFs will be processed as text instead of images.",{duration:5e3}),l=!1),l)try{const u=await rLe(i.file);Qi.success(`PDF "${i.name}" processed as ${u.length} images for vision model.`,{duration:3e3}),r.push({base64Data:a,content:`PDF file with ${u.length} pages`,images:u,name:i.name,processedAsImages:!0,size:i.size,type:Ti.PDF})}catch(u){console.warn(`Failed to process PDF ${i.name} as images, falling back to text:`,u);const d=await jee(i.file);r.push({base64Data:a,content:d,name:i.name,processedAsImages:!1,size:i.size,type:Ti.PDF})}else{const u=await jee(i.file);Qi.success(`PDF "${i.name}" processed as text content.`,{duration:3e3}),r.push({base64Data:a,content:u,name:i.name,processedAsImages:!1,size:i.size,type:Ti.PDF})}}catch(a){console.error(`Failed to process PDF file ${i.name}:`,a)}else try{const a=await $At(i.file);a.trim()===""?(console.warn(`File ${i.name} is empty and will be skipped`),n.push(i.name)):GAt(a)?r.push({content:a,name:i.name,size:i.size,type:Ti.TEXT}):console.warn(`File ${i.name} appears to be binary and will be skipped`)}catch(a){console.error(`Failed to read file ${i.name}:`,a)}}return{emptyFiles:n,extras:r}}const GBt=1e6,zBt=.85,qBt="https://cdn.jsdelivr.net/npm/heic-to@1.5.2/dist/heic-to.js";let VK=null;function HBt(){return VK||(VK=import(qBt)),VK}async function VBt(t){const{heicTo:e}=await HBt(),r=await e({blob:t,quality:zBt,type:Zi.JPEG});return new Promise((n,i)=>{const a=new FileReader;a.onload=()=>n(a.result),a.onerror=()=>i(a.error),a.readAsDataURL(r)})}function YBt(t){const e=t.trim().toLowerCase();return e===Zi.HEIC||e===Zi.HEIF}function YK(t){return new Promise((e,r)=>{const n=new FileReader;n.onload=()=>e(n.result),n.onerror=()=>r(n.error),n.readAsDataURL(t)})}function WBt(t){return new Promise((e,r)=>{const n=new FileReader;n.onload=()=>e(n.result),n.onerror=()=>r(n.error),n.readAsText(t)})}async function oLe(t,e){const r=[];for(const n of t){const i=Date.now().toString()+Math.random().toString(36).substr(2,9),a={file:n,id:i,name:n.name,size:n.size,type:n.type};try{if(nh(n.type)===pi.IMAGE){let s=await YK(n);if(iLe(n.type))try{s=await nLe(s)}catch(o){console.error("Failed to convert SVG to PNG:",o)}else if(sLe(n.type))try{s=await aLe(s)}catch(o){console.error("Failed to convert WebP to PNG:",o)}else if(YBt(n.type))try{s=await VBt(n)}catch(o){console.error("Failed to convert HEIC to PNG:",o);continue}r.push({...a,preview:s})}else if(nh(n.type)===pi.PDF){try{const l=await jee(n);r.push({...a,textContent:l})}catch(l){console.warn("Failed to extract text from PDF, adding without content:",l),r.push(a)}const s=e?Ar.modelSupportsVision(e):!1,o=nl.config;s&&!o.pdfAsImage&&Qi.info("You can enable parsing PDF as images with vision models.",{action:{label:"Enable PDF as Images",onClick:()=>{nl.updateConfig(hr.PDF_AS_IMAGE,!0),Qi.success("PDF parsing as images enabled!",{duration:3e3})}},duration:8e3})}else if(nh(n.type)===pi.AUDIO){const s=await YK(n);r.push({...a,preview:s})}else if(nh(n.type)===pi.VIDEO){const s=await YK(n);r.push({...a,preview:s})}else try{const s=await WBt(n);r.push({...a,textContent:s})}catch(s){console.warn("Failed to read file as text, adding without content:",s),r.push(a)}}catch(s){console.error("Error processing file",n.name,s),r.push(a)}}return r}var KBt=se(" Text",1),jBt=se("
      "),XBt=se(" Pages",1),QBt=se('The selected model does not support vision. Only the extracted text will be sent to the model.'),ZBt=se(" ",1),JBt=se('

      Converting PDF to images...

      '),eUt=se('

      Failed to load PDF images

      '),tUt=se('

      ',1),rUt=se('

      No PDF pages available

      '),nUt=se('
      '),iUt=se('
      ',1);function aUt(t,e){at(e,!0);let r=Oe(Zr(zm.PAGES)),n=Oe(Zr([])),i=Oe(!1),a=Oe(null),s=W(()=>nce(e.displayName));async function o(){if(!(S(n).length>0||S(i)||!e.currentItem)){X(i,!0),X(a,null);try{let T=null;if(e.currentItem.uploadedFile?.file)T=e.currentItem.uploadedFile.file;else if(e.currentItem.attachment){if("images"in e.currentItem.attachment&&e.currentItem.attachment.images&&Array.isArray(e.currentItem.attachment.images)&&e.currentItem.attachment.images.length>0){X(n,e.currentItem.attachment.images,!0);return}if("base64Data"in e.currentItem.attachment&&e.currentItem.attachment.base64Data){const C=e.currentItem.attachment.base64Data,w=atob(C),x=new Array(w.length);for(let R=0;R{S(r)===zm.PAGES&&o()});var l=iUt(),u=oe(l),d=te(u);{let T=W(()=>S(r)===zm.TEXT?"default":"outline");Gn(d,{get variant(){return S(T)},size:"sm",onclick:()=>X(r,zm.TEXT,!0),get disabled(){return S(i)},children:(C,w)=>{var x=KBt(),A=oe(x);sp(A,{get class(){return`mr-1 ${vr}`}}),Ct(),G(C,x)},$$slots:{default:!0}})}var h=ie(d,2);{let T=W(()=>S(r)===zm.PAGES?"default":"outline");Gn(h,{get variant(){return S(T)},size:"sm",onclick:()=>X(r,zm.PAGES,!0),get disabled(){return S(i)},children:(C,w)=>{var x=XBt(),A=oe(x);{var R=F=>{var P=jBt();$e(()=>Yt(P,1,`mr-1 ${vr} animate-spin rounded-full border-2 border-current border-t-transparent`)),G(F,P)},O=F=>{Fle(F,{get class(){return`mr-1 ${vr}`}})};ve(A,F=>{S(i)?F(R):F(O,-1)})}Ct(),G(C,x)},$$slots:{default:!0}})}Z(u);var f=ie(u,2);{var p=T=>{var C=Ae(),w=oe(C);Me(w,()=>bMe,(x,A)=>{A(x,{class:"mb-4 max-w-4xl",children:(R,O)=>{var F=ZBt(),P=oe(F);A0(P,{get class(){return vr}});var N=ie(P,2);Me(N,()=>EMe,(M,L)=>{L(M,{children:(I,U)=>{Ct();var B=or("Preview only");G(I,B)},$$slots:{default:!0}})});var k=ie(N,2);Me(k,()=>SMe,(M,L)=>{L(M,{children:(I,U)=>{var B=QBt(),$=ie(te(B));Ct(),Z(B),Kr("click",$,()=>X(r,zm.TEXT,!0)),G(I,B)},$$slots:{default:!0}})}),G(R,F)},$$slots:{default:!0}})}),G(T,C)};ve(f,T=>{!e.hasVisionModality&&e.activeModelId&&e.currentItem&&T(p)})}var g=ie(f,2);{var m=T=>{var C=JBt();G(T,C)},_=T=>{var C=eUt(),w=te(C),x=te(w);sp(x,{class:"mx-auto mb-4 h-16 w-16 text-white/50"});var A=ie(x,4),R=te(A,!0);Z(A),Z(w),Z(C),$e(()=>it(R,S(a))),G(T,C)},v=T=>{var C=Ae(),w=oe(C);qr(w,18,()=>S(n),x=>x,(x,A,R)=>{var O=tUt(),F=oe(O),P=te(F);Z(F);var N=ie(F,2);Ct(2),$e(()=>{it(P,`Page ${S(R)+1}`),lr(N,"src",A),lr(N,"alt",`PDF Page ${S(R)+1}`)}),G(x,O)}),G(T,C)},b=T=>{var C=rUt(),w=te(C),x=te(w);sp(x,{class:"mx-auto mb-4 h-16 w-16 text-white/50"}),Ct(2),Z(w),Z(C),G(T,C)};ve(g,T=>{S(i)?T(m):S(a)?T(_,1):S(n).length>0?T(v,2):T(b,-1)})}var y=ie(g,2);{var E=T=>{var C=nUt(),w=te(C);dp(w,{class:"max-w-4xl",get code(){return e.displayTextContent},get language(){return S(s)},maxHeight:"none"}),Z(C),G(T,C)};ve(y,T=>{S(r)===zm.TEXT&&e.displayTextContent&&T(E)})}G(t,l),st()}Hi(["click"]);var sUt=se('
      ');function oUt(t,e){var r=Ae(),n=oe(r);{var i=a=>{var s=sUt(),o=te(s);dp(o,{class:"max-w-4xl",get code(){return e.displayTextContent},get language(){return e.language},maxHeight:"none"}),Z(s),G(a,s)};ve(n,a=>{e.displayTextContent&&a(i)})}G(t,r)}var lUt=se('

      Preview not available for this file type

      ');function cUt(t,e){var r=lUt(),n=te(r),i=te(n);Me(i,()=>e.IconComponent,(a,s)=>{s(a,{class:"mx-auto mb-4 h-16 w-16 text-white/50"})}),Ct(2),Z(n),Z(r),G(t,r)}var uUt=se('',2),dUt=se('

      Video preview not available

      '),hUt=se('

      ');function fUt(t,e){at(e,!0);var r=hUt(),n=te(r),i=te(n);y4(i,{class:"mx-auto mb-4 h-16 w-16 text-white/50"});var a=ie(i,2);{var s=d=>{var h=uUt();$e(()=>lr(h,"src",e.videoSrc)),G(d,h)},o=d=>{var h=dUt();G(d,h)};ve(a,d=>{e.videoSrc?d(s):d(o,-1)})}var l=ie(a,2),u=te(l,!0);Z(l),Z(n),Z(r),$e(()=>it(u,e.currentItem?.name||"Video")),G(t,r),st()}function pUt(t,e){at(e,!0);let r=W(()=>e.isImage?Ule:e.isText||e.isPdf?sp:e.isAudio?HU:e.isVideo?y4:v4),n=W(()=>!e.isPdf&&!e.isImage&&!(e.isText&&e.displayTextContent)&&!e.isAudio&&!e.isVideo);var i=Ae(),a=oe(i);{var s=o=>{var l=Ae(),u=oe(l);Y8e(u,()=>e.currentItem.id,d=>{var h=Ae(),f=oe(h);{var p=y=>{aUt(y,{get currentItem(){return e.currentItem},get displayName(){return e.currentItem.name},get displayTextContent(){return e.displayTextContent},get hasVisionModality(){return e.hasVisionModality},get activeModelId(){return e.activeModelId}})},g=y=>{FPt(y,{get currentItem(){return e.currentItem},get displayPreview(){return e.displayPreview}})},m=y=>{oUt(y,{get displayTextContent(){return e.displayTextContent},get language(){return e.language}})},_=y=>{LPt(y,{get currentItem(){return e.currentItem},get audioSrc(){return e.audioSrc}})},v=y=>{fUt(y,{get currentItem(){return e.currentItem},get videoSrc(){return e.videoSrc}})},b=y=>{cUt(y,{get IconComponent(){return S(r)}})};ve(f,y=>{e.isPdf?y(p):e.isImage?y(g,1):e.isText&&e.displayTextContent?y(m,2):e.isAudio?y(_,3):e.isVideo?y(v,4):S(n)&&y(b,5)})}G(d,h)}),G(o,l)};ve(a,o=>{e.currentItem&&o(s)})}G(t,i),st()}const gUt=80,mUt=95;function _Ut(t){return t===null?"neutral":t>=mUt?"critical":t>=gUt?"warning":"ok"}function lLe(t){switch(t){case"critical":return"text-red-400";case"warning":return"text-amber-400";case"ok":return"text-muted-foreground";default:return"text-muted-foreground"}}function vUt(t){switch(t){case"critical":return"bg-red-500";case"warning":return"bg-amber-500";case"ok":return"bg-green-500";default:return"bg-muted"}}var yUt=se('
      '),bUt=se('
      ');function $A(t,e){var r=bUt(),n=te(r),i=te(n),a=te(i,!0);Z(i);var s=ie(i,2),o=te(s,!0);Z(s),Z(n);var l=ie(n,2);{var u=d=>{var h=yUt(),f=te(h,!0);Z(h),$e(()=>it(f,e.subtitle)),G(d,h)};ve(l,d=>{e.subtitle&&d(u)})}Z(r),$e(()=>{it(a,e.label),it(o,e.value)}),G(t,r)}var SUt=new Set(["$$slots","$$events","$$legacy","open","ref"]);function bd(t,e){at(e,!0);let r=ce(e,"open",15,!1),n=ce(e,"ref",15,null),i=Tt(e,SUt);var a=Ae(),s=oe(a);Me(s,()=>z0t,(o,l)=>{l(o,Rt({"data-slot":"collapsible"},()=>i,{get ref(){return n()},set ref(u){n(u)},get open(){return r()},set open(u){r(u)}}))}),G(t,a),st()}var EUt=new Set(["$$slots","$$events","$$legacy","ref"]);function Sd(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,EUt);var i=Ae(),a=oe(i);Me(a,()=>V0t,(s,o)=>{o(s,Rt({"data-slot":"collapsible-content"},()=>n,{get ref(){return r()},set ref(l){r(l)}}))}),G(t,i),st()}var TUt=new Set(["$$slots","$$events","$$legacy","ref"]);function Ed(t,e){at(e,!0);let r=ce(e,"ref",15,null),n=Tt(e,TUt);var i=Ae(),a=oe(i);Me(a,()=>K0t,(s,o)=>{o(s,Rt({"data-slot":"collapsible-trigger"},()=>n,{get ref(){return r()},set ref(l){r(l)}}))}),G(t,i),st()}var CUt=se("Token usage details ",1),wUt=se('

      Across all turns

      '),xUt=se('

      This turn · KV cache

      KV cache total
      '),AUt=se('
      '),RUt=se('
      '),NUt=se(" ",1),OUt=se(" ",1);function IUt(t,e){at(e,!0);let r=Oe(!1);const n=W(()=>e.cumulativeRead>0||e.cumulativeOutput>0),i=W(()=>e.currentRead>0||e.currentOutput>0);var a=Ae(),s=oe(a);Me(s,()=>bd,(o,l)=>{l(o,{class:"mt-3 border-t border-border/50 pt-4",get open(){return S(r)},set open(u){X(r,u,!0)},children:(u,d)=>{var h=OUt(),f=oe(h);Me(f,()=>Ed,(g,m)=>{m(g,{class:"flex w-full cursor-pointer items-center gap-1 text-xs text-muted-foreground hover:text-foreground",children:(_,v)=>{var b=CUt(),y=ie(oe(b),2);{let E=W(()=>"ml-auto h-3 w-3 transition-transform"+(S(r)?" rotate-180":""));wl(y,{get class(){return S(E)}})}G(_,b)},$$slots:{default:!0}})});var p=ie(f,2);Me(p,()=>Sd,(g,m)=>{m(g,{class:"flex flex-col gap-4 text-xs pt-4",children:(_,v)=>{var b=NUt(),y=oe(b);{var E=R=>{var O=wUt(),F=ie(te(O),2),P=te(F);{var N=L=>{{let I=W(()=>`${e.cumulativeRead.toLocaleString()} tok`),U=W(()=>e.cumulativeCacheTotal>0?`${e.cumulativeCacheTotal.toLocaleString()} reused from KV cache`:void 0);$A(L,{label:"Prompt tokens evaluated",get value(){return S(I)},get subtitle(){return S(U)}})}};ve(P,L=>{e.cumulativeRead>0&&L(N)})}var k=ie(P,2);{var M=L=>{{let I=W(()=>`${e.cumulativeOutput.toLocaleString()} tok`);$A(L,{label:"Tokens generated",get value(){return S(I)}})}};ve(k,L=>{e.cumulativeOutput>0&&L(M)})}Z(F),Z(O),G(R,O)};ve(y,R=>{S(n)&&R(E)})}var T=ie(y,2);{var C=R=>{var O=xUt(),F=ie(te(O),2),P=te(F);{var N=$=>{{let H=W(()=>`${e.currentRead.toLocaleString()} tok`),q=W(()=>e.currentCache>0?`${e.currentFresh.toLocaleString()} fresh + ${e.currentCache.toLocaleString()} cached`:void 0);$A($,{label:"Prompt",get value(){return S(H)},get subtitle(){return S(q)}})}};ve(P,$=>{e.currentRead>0&&$(N)})}var k=ie(P,2);{var M=$=>{{let H=W(()=>`${e.currentOutput.toLocaleString()} tok`);$A($,{label:"Generated",get value(){return S(H)}})}};ve(k,$=>{e.currentOutput>0&&$(M)})}var L=ie(k,2),I=te(L),U=ie(te(I),2),B=te(U);Z(U),Z(I),Z(L),Z(F),Z(O),$e($=>it(B,`${$??""} tok`),[()=>e.kvTotal.toLocaleString()]),G(R,O)};ve(T,R=>{S(i)&&R(C)})}var w=ie(T,2);{var x=R=>{var O=AUt(),F=te(O);{let P=W(()=>`${e.averageTokensPerSecond.toFixed(1)}${KL.TOKENS_PER_SECOND}`);$A(F,{label:"Avg speed",get value(){return S(P)}})}Z(O),G(R,O)};ve(w,R=>{e.averageTokensPerSecond!==null&&R(x)})}var A=ie(w,2);qr(A,16,()=>e.transientDetails,R=>R,(R,O)=>{var F=RUt(),P=te(F,!0);Z(F),$e(()=>it(P,O)),G(R,F)}),G(_,b)},$$slots:{default:!0}})}),G(u,h)},$$slots:{default:!0}})}),G(t,a),st()}var kUt=se('
      Available context size is only visible once the model is loaded.
      '),DUt=se('
      Loading model...
      ');function MUt(t,e){var r=Ae(),n=oe(r);{var i=s=>{var o=kUt(),l=ie(te(o),2);Gn(l,{size:"sm",variant:"secondary",class:"self-start",get onclick(){return e.onLoad},children:(u,d)=>{Ct();var h=or("Load model");G(u,h)},$$slots:{default:!0}}),Z(o),G(s,o)},a=s=>{var o=DUt(),l=te(o);us(l,{class:"h-3.5 w-3.5 animate-spin"}),Ct(2),Z(o),G(s,o)};ve(n,s=>{e.modelId!==null&&!e.isLoading?s(i):e.isLoading&&s(a,1)})}G(t,r)}const LUt=128*1024,PUt=65496,FUt=225,BUt=218,UUt=1165519206,$Ut=18761,GUt=42,zUt=274,vTe=12;function qUt(t){try{const e=t.indexOf(",")+1;if(e<=0)return 1;const r=Math.ceil(LUt/3)*4,n=t.slice(e,e+r),i=atob(n.slice(0,n.length-n.length%4)),a=new Uint8Array(i.length);for(let s=0;sn||t.getUint32(e)!==UUt||t.getUint16(e+4)!==0)return 1;const i=e+6;if(i+8>n)return 1;const a=t.getUint16(i)===$Ut;if(t.getUint16(i+2,a)!==GUt)return 1;const s=t.getUint32(i+4,a);if(i+s+2>n)return 1;const o=t.getUint16(i+s,a);for(let l=0;ln)return 1;if(t.getUint16(u,a)===zUt){const d=t.getUint16(u+8,a);return d>=1&&d<=8?d:1}}return 1}function YUt(t){return t===Zi.JPEG||t===Zi.JPG}function WUt(t,e){return new Promise((r,n)=>{try{const i=t.match(HCt);if(!i)return n(new Error("Invalid data URL format."));const a=i[1];if(!Object.values(Zi).includes(a))return n(new Error(`Unsupported image MIME type: ${a}`));const s=YUt(a)?qUt(t):1,o=new Image;o.onload=()=>{try{const l=document.createElement("canvas"),u=l.getContext("2d");if(!u)throw new Error("Failed to get 2D canvas context.");const d=o.naturalWidth,h=o.naturalHeight,f=d*h,p=Math.floor(e*GBt);if(p>0&&f>p){const g=Math.sqrt(p/f);l.width=Math.floor(d*g),l.height=Math.floor(h*g)}else if(s>1)l.width=d,l.height=h;else return r(t);u.drawImage(o,0,0,l.width,l.height),r(l.toDataURL(a))}catch(l){n(l instanceof Error?l:new Error(String(l)))}},o.onerror=()=>{n(new Error("Failed to load image."))},o.src=t}catch(i){const s=`Error resizing image: ${i instanceof Error?i.message:String(i)}`;console.error(s,i),n(new Error(s))}})}function V6(t,e){return t?e?`${t}::${e}`:t:""}function KUt(t){const e=t.trim().toLowerCase();return e===Ua.WAV||e===Ua.WAVE||e===Ua.X_WAV||e===Ua.X_WAVE||e===Ua.VND_WAVE||e===Ua.X_PN_WAV?MR.WAV:MR.MP3}function WK(t){return USt+t}class Pi{static async generateTitle(e,r,n){let i="";try{await Pi.sendMessage([e],{custom:{chat_template_kwargs:{enable_thinking:!1}},model:r||void 0,onChunk:a=>{i+=a},stream:!0},void 0,n)}catch{return""}return i}static async sendMessage(e,r={},n,i){const{backend_sampling:a,continueFinalMessage:s,custom:o,disableReasoningParsing:l,dry_allowed_length:u,dry_base:d,dry_multiplier:h,dry_penalty_last_n:f,dynatemp_exponent:p,dynatemp_range:g,enableThinking:m,excludeReasoningFromContext:_,frequency_penalty:v,max_tokens:b,min_p:y,onChunk:E,onComplete:T,onCompletionId:C,onConnectionState:w,onError:x,onModel:A,onReasoningChunk:R,onTimings:O,onToolCallChunk:F,presence_penalty:P,reasoningEffort:N,repeat_last_n:k,repeat_penalty:M,samplers:L,stream:I,temperature:U,timings_per_token:B,tools:$,top_k:H,top_p:q,typ_p:V,xtc_probability:Y,xtc_threshold:j}=r,Q=(await Promise.all(e.map(ne=>{if("id"in ne&&"convId"in ne&&"timestamp"in ne){const ee=ne;return Pi.convertDbMessageToApiChatMessageData(ee)}else return ne}))).filter(ne=>ne.role===Sr.SYSTEM?(typeof ne.content=="string"?ne.content:"").trim().length>0:!0);r.model&&!Ar.modelSupportsVision(r.model)&&Q.forEach(ne=>{Array.isArray(ne.content)&&(ne.content=ne.content.filter(ee=>ee.type===sc.IMAGE_URL?(console.info(`[ChatService] Skipping image attachment in message history (model "${r.model}" does not support vision)`),!1):!0),ne.content.length===1&&ne.content[0].type===sc.TEXT&&typeof ne.content[0].text=="string"&&(ne.content=ne.content[0].text))});const ae={messages:Q.map(ne=>{const ee={content:ne.content,role:ne.role,tool_call_id:ne.tool_call_id,tool_calls:ne.tool_calls};return!_&&ne.reasoning_content&&(ee.reasoning_content=ne.reasoning_content),ee}),return_progress:I?!0:void 0,sse_ping_interval:I?1:void 0,stream:I,tools:$&&$.length>0?$:void 0};r.model&&(ae.model=r.model),ae.reasoning_format=l?AJ.NONE:AJ.AUTO;const re=m&&N?sIe[N]??-1:-1;if(m!==void 0&&(ae.chat_template_kwargs={...ae.chat_template_kwargs??{},enable_thinking:m}),re>=0&&(ae.thinking_budget_tokens=re),ae.reasoning_control=!0,s&&(ae.continue_final_message=!0,ae.add_generation_prompt=!1),U!==void 0&&(ae.temperature=U),b!==void 0&&(ae.max_tokens=b!==null&&b!==0?b:-1),g!==void 0&&(ae.dynatemp_range=g),p!==void 0&&(ae.dynatemp_exponent=p),H!==void 0&&(ae.top_k=H),q!==void 0&&(ae.top_p=q),y!==void 0&&(ae.min_p=y),Y!==void 0&&(ae.xtc_probability=Y),j!==void 0&&(ae.xtc_threshold=j),V!==void 0&&(ae.typ_p=V),k!==void 0&&(ae.repeat_last_n=k),M!==void 0&&(ae.repeat_penalty=M),P!==void 0&&(ae.presence_penalty=P),v!==void 0&&(ae.frequency_penalty=v),h!==void 0&&(ae.dry_multiplier=h),d!==void 0&&(ae.dry_base=d),u!==void 0&&(ae.dry_allowed_length=u),f!==void 0&&(ae.dry_penalty_last_n=f),L!==void 0&&(ae.samplers=typeof L=="string"?L.split(";").filter(ne=>ne.trim()):L),a!==void 0&&(ae.backend_sampling=a),B!==void 0&&(ae.timings_per_token=B),o)try{const ne=typeof o=="string"?JSON.parse(o):o;Object.assign(ae,ne)}catch(ne){console.warn("Failed to parse custom parameters:",ne)}try{const ne={...zT()};I&&n&&(ne["X-Conversation-Id"]=V6(n,r.model),Pi.saveStreamState(n,0,r.model??null));const ee=await fetch(mH.COMPLETIONS,{body:JSON.stringify(ae),headers:ne,method:"POST",signal:i});if(!ee.ok){n&&Pi.clearStreamState(n);const J=await Pi.parseErrorResponse(ee);throw x&&x(J),J}if(I){await Pi.handleStreamResponse(ee,E,T,x,R,F,A,C,O,n,i,w,r.model);return}else return Pi.handleNonStreamResponse(ee,T,x,F,A)}catch(ne){if(vu(ne)){console.log("Chat completion request was aborted");return}let ee;throw ne instanceof Error?ne.name==="TypeError"&&ne.message.includes("fetch")?(ee=new Error("Unable to connect to server - please check if the server is running"),ee.name="NetworkError"):ne.message.includes("ECONNREFUSED")?(ee=new Error("Connection refused - server may be offline"),ee.name="NetworkError"):ne.message.includes("ETIMEDOUT")?(ee=new Error("Request timed out - the server took too long to respond"),ee.name="TimeoutError"):ee=ne:ee=new Error("Unknown error occurred while sending message"),console.error("Error in sendMessage:",ne),x&&x(ee),ee}}static async areAllSlotsIdle(e,r){try{const n=e?`${j1e.LIST}?model=${encodeURIComponent(e)}`:j1e.LIST,i=await fetch(n,{signal:r});return i.ok?(await i.json()).every(s=>!s.is_processing):!0}catch{return!0}}static async stopReasoning(e,r){if(!e)return console.error("stopReasoning: no completion id for the active message, cannot target the running completion"),!1;const n={action:HEt.END_REASONING,id:e};r&&(n.model=r);try{const i=await fetch(mH.CONTROL,{body:JSON.stringify(n),headers:zT(),method:"POST"}),a=await i.json().catch(()=>null);return!i.ok||a?.success!==!0?(console.error("stopReasoning: control request failed",{completionId:e,response:a,status:i.status}),!1):!0}catch(i){return console.error("stopReasoning: control request threw",{completionId:e,error:i}),!1}}static async cancelServerStream(e,r){if(e)try{const n=V6(e,r);await fetch(`${_H.BASE}?conv_id=${encodeURIComponent(n)}`,{headers:op(),method:"DELETE"})}catch(n){console.warn("cancelServerStream failed:",n)}}static selectActiveStream(e){if(!Array.isArray(e)||e.length===0)return null;const r=e.filter(n=>!n.is_done);return r.length===0?null:r.reduce((n,i)=>i.started_at>n.started_at?i:n)}static saveStreamState(e,r,n){if(e)try{const i={bytesReceived:r,model:n??null,updatedAt:Date.now()};localStorage.setItem(WK(e),JSON.stringify(i))}catch{}}static getStreamState(e){if(!e)return null;try{const r=localStorage.getItem(WK(e));if(!r)return null;const n=JSON.parse(r);return!n||typeof n.bytesReceived!="number"?null:n}catch{return null}}static clearStreamState(e){if(e)try{localStorage.removeItem(WK(e))}catch{}}static resumeStreamIdentity(e,r,n){const i=r&&r.model!==void 0?r.model:n;return V6(e,i)}static async probeResumeStatus(e){if(!e)return 0;const r=new AbortController;try{const n=await fetch(`${_H.BASE}?conv_id=${encodeURIComponent(e)}&from=0`,{headers:op(),signal:r.signal});return r.abort(),n.status}catch{return 0}}static async resumeStream(e,r,n){if(!e)return null;const a=Pi.getStreamState(e)?.bytesReceived??0,s=V6(e,n),o=`${_H.BASE}?conv_id=${encodeURIComponent(s)}&from=${a}`;return await fetch(o,{headers:op(),method:"GET",signal:r})}static async preEncode(e,r,n,i){const s={messages:(await Promise.all(e.map(o=>"id"in o&&"convId"in o&&"timestamp"in o?Pi.convertDbMessageToApiChatMessageData(o):o))).filter(o=>o.role===Sr.SYSTEM?(typeof o.content=="string"?o.content:"").trim().length>0:!0).map(o=>{const l={content:n?Pi.stripReasoningContent(o.content):o.content,role:o.role,tool_call_id:o.tool_call_id,tool_calls:o.tool_calls};return!n&&o.reasoning_content&&(l.reasoning_content=o.reasoning_content),l}),n_predict:0,stream:!1};r&&(s.model=r);try{await fetch(mH.COMPLETIONS,{body:JSON.stringify(s),headers:zT(),method:"POST",signal:i})}catch(o){vu(o)||console.warn("[ChatService] Pre-encode request failed:",o)}}static async handleStreamResponse(e,r,n,i,a,s,o,l,u,d,h,f,p){let g=e.body?.getReader();if(!g)throw new Error("No response body");let m=0,_=0,v=0,b=Date.now(),y=!0;const E=new TextEncoder;d&&Pi.saveStreamState(d,0,p),f?.(h_.STREAMING);let T=new TextDecoder,C="",w="",x=[],A,R=!1,O=!1,F=!1,P=0,N=!1;const k=()=>{N&&(P=x.length,N=!1)},M=I=>{if(!I||I.length===0||(x=Pi.mergeToolCallDeltas(x,I,P),x.length===0))return;N=!0;const U=JSON.stringify(x);U&&(h?.aborted||s?.(U))},L=()=>{typeof document>"u"||document.visibilityState==="visible"&&(R||d&&Date.now()-b>DCt&&g.cancel().catch(()=>{}))};typeof document<"u"&&document.addEventListener("visibilitychange",L);try{let I="";for(;;){for(;!h?.aborted;){let $,H;try{const V=await g.read();$=V.done,H=V.value}catch(V){if(vu(V))throw V;console.warn("reader.read() rejected, treating as premature end:",V),$=!0,H=void 0}if($||h?.aborted)break;H&&H.byteLength>0&&(v+=H.byteLength,b=Date.now(),y||(y=!0,f?.(h_.STREAMING))),I+=T.decode(H,{stream:!0});const q=I.split(WL);if(I=q.pop()||"",d){const V=E.encode(I).byteLength;m=_+v-V,Pi.saveStreamState(d,m,p)}for(const V of q){if(h?.aborted)break;if(V.startsWith(ix)){const Y=V.slice(ix.length).trim();if(Y===RIe){R=!0;continue}try{const j=JSON.parse(Y),Q=j.choices?.[0],ae=Q?.delta?.content,re=Q?.delta?.reasoning_content,ne=Q?.delta?.tool_calls,ee=j.timings,J=j.prompt_progress,fe=Pi.extractModelName(j);fe&&!O&&(O=!0,o?.(fe)),j.id&&!F&&(F=!0,l?.(j.id)),J&&Pi.notifyTimings(void 0,J,u),ee&&(Pi.notifyTimings(ee,J,u),A=ee),ae&&(k(),C+=ae,h?.aborted||r?.(ae)),re&&(k(),w+=re,h?.aborted||a?.(re)),M(ne)}catch(j){console.error("Error parsing JSON chunk:",j)}}}if(h?.aborted||R)break}if(h?.aborted||R||!d)break;if(!y){f?.(h_.LOST),i?.(new Error("Stream resume produced no new bytes, giving up"));break}f?.(h_.RESUMING),y=!1;const U=await Pi.resumeStream(d,h,p).catch(()=>null);if(h?.aborted)break;if(!U||U.status!==200){f?.(h_.LOST),i?.(new Error("Stream connection lost and could not be resumed"));break}const B=U.body?.getReader();if(!B)break;try{g.releaseLock()}catch{}g=B,T=new TextDecoder,I="",_=m,v=0,b=Date.now()}if(h?.aborted)return;if(R){k(),d&&Pi.clearStreamState(d);const U=x.length>0?JSON.stringify(x):void 0;n?.(C,w||void 0,A,U)}}catch(I){const U=I instanceof Error?I:new Error("Stream error");throw i?.(U),U}finally{typeof document<"u"&&document.removeEventListener("visibilitychange",L);try{g.releaseLock()}catch{}}}static async handleNonStreamResponse(e,r,n,i,a){try{const s=await e.text();if(!s.trim())throw new Error("No response received from server. Please try again.");const o=JSON.parse(s),l=Pi.extractModelName(o);l&&a?.(l);const u=o.choices[0]?.message?.content||"",d=o.choices[0]?.message?.reasoning_content,h=o.choices[0]?.message?.tool_calls;let f;if(h&&h.length>0){const p=Pi.mergeToolCallDeltas([],h);p.length>0&&(f=JSON.stringify(p),f&&i?.(f))}if(!u.trim()&&!f)throw new Error("No response received from server. Please try again.");return r?.(u,d,void 0,f),u}catch(s){const o=s instanceof Error?s:new Error("Parse error");throw n?.(o),o}}static mergeToolCallDeltas(e,r,n=0){const i=e.map(a=>({...a,function:a.function?{...a.function}:void 0}));for(const a of r){const s=typeof a.index=="number"&&a.index>=0?a.index+n:i.length;for(;i.length<=s;)i.push({function:void 0});const o=i[s];if(a.id&&(o.id=a.id),a.type&&(o.type=a.type),a.function){const l=o.function?{...o.function}:{};a.function.name&&(l.name=a.function.name),a.function.arguments&&(l.arguments=(l.arguments??"")+a.function.arguments),o.function=l}}return i}static async convertDbMessageToApiChatMessageData(e){if(e.role===Sr.TOOL&&e.toolCallId)return{content:e.content,role:Sr.TOOL,tool_call_id:e.toolCallId};let r;if(e.toolCalls)try{r=JSON.parse(e.toolCalls)}catch{}if(!e.extra||e.extra.length===0){const p={content:e.content,role:e.role};return e.reasoningContent&&(p.reasoning_content=e.reasoningContent),r&&r.length>0&&(p.tool_calls=r),p}const n=[],i=e.extra.filter(p=>p.type===Ti.TEXT);for(const p of i)n.push({text:CA("File",p.name,p.content),type:sc.TEXT});const a=e.extra.filter(p=>p.type===Ti.LEGACY_CONTEXT);for(const p of a)n.push({text:CA("File",p.name,p.content),type:sc.TEXT});const s=e.extra.filter(p=>p.type===Ti.IMAGE);for(const p of s){const g=nl.getConfig(hr.MAX_IMAGE_RESOLUTION),m=await WUt(p.base64Url,g);n.push({image_url:{url:m},type:sc.IMAGE_URL})}const o=e.extra.filter(p=>p.type===Ti.AUDIO);for(const p of o)n.push({input_audio:{data:p.base64Data,format:KUt(p.mimeType)},type:sc.INPUT_AUDIO});e.content&&n.push({text:e.content,type:sc.TEXT});const l=e.extra.filter(p=>p.type===Ti.VIDEO);for(const p of l)n.push({input_video:{data:p.base64Data,format:p.mimeType.includes("mp4")?"mp4":p.mimeType.includes("ogg")?"ogg":"auto"},type:sc.INPUT_VIDEO});const u=e.extra.filter(p=>p.type===Ti.PDF);for(const p of u)if(p.processedAsImages&&p.images)for(let g=0;gp.type===Ti.MCP_PROMPT);for(const p of d)n.push({text:CA(PSt,p.name,p.content,p.serverName),type:sc.TEXT});const h=e.extra.filter(p=>p.type===Ti.MCP_RESOURCE);for(const p of h)n.push({text:CA(FSt,p.name,p.content,p.serverName),type:sc.TEXT});const f={content:n,role:e.role};return e.reasoningContent&&(f.reasoning_content=e.reasoningContent),r&&r.length>0&&(f.tool_calls=r),f}static stripReasoningContent(e){const r=n=>n.replace(Yb.REASONING_BLOCK,"").trim();return typeof e=="string"?r(e):e.map(n=>n.type===sc.TEXT&&n.text?{...n,text:r(n.text)}:n)}static async parseErrorResponse(e){try{const r=await e.text(),n=JSON.parse(r),i=n.error?.message||"Unknown server error",a=new Error(i);return a.name=e.status===400?"ServerError":"HttpError",n.error&&"n_prompt_tokens"in n.error&&"n_ctx"in n.error&&(a.contextInfo={n_ctx:n.error.n_ctx,n_prompt_tokens:n.error.n_prompt_tokens}),a}catch{const r=new Error(`Server error (${e.status}): ${e.statusText}`);return r.name="HttpError",r}}static extractModelName(e){const r=u=>typeof u=="object"&&u!==null?u:void 0,n=u=>typeof u=="string"&&u.trim()?u.trim():void 0,i=r(e);if(!i)return;const a=n(i.model);if(a)return a;const s=Array.isArray(i.choices)?r(i.choices[0]):void 0;if(!s)return;const o=n(r(s.delta)?.model);if(o)return o;const l=n(r(s.message)?.model);if(l)return l}static notifyTimings(e,r,n){!n||!e&&!r||n(e,r)}}const jUt=`const logs = []; +const fmt = (value) => { + if (typeof value === 'string') return value; + try { + return JSON.stringify(value); + } catch { + return String(value); + } +}; +const capture = + (level, prefix) => + (...args) => { + logs.push(prefix + args.map(fmt).join(' ')); + }; +console.log = capture('log', ''); +console.info = capture('info', ''); +console.debug = capture('debug', ''); +console.warn = capture('warn', 'warn: '); +console.error = capture('error', 'error: '); +self.onmessage = async (event) => { + const reply = { logs, result: null, error: null }; + try { + const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor; + // The prelude bundled ahead of this shim defines self.nerdamer, + // passed into the execution scope as the \`nerdamer\` parameter. + const value = await new AsyncFunction('nerdamer', event.data.code)(self.nerdamer); + if (value !== undefined) reply.result = fmt(value); + } catch (err) { + reply.error = err instanceof Error ? err.stack || err.message : String(err); + } + self.postMessage(reply); +}; +`,XUt="default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval'; worker-src blob:";function yTe(t){return` + + + diff --git a/tools/ui/.svelte-kit/output/server/.vite/manifest.json b/tools/ui/.svelte-kit/output/server/.vite/manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..877681d02b15976ceb7e121f501d4ed303e95005 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/.vite/manifest.json @@ -0,0 +1,687 @@ +{ + ".svelte-kit/generated/server/internal.js": { + "file": "internal.js", + "name": "internal", + "src": ".svelte-kit/generated/server/internal.js", + "isEntry": true, + "imports": [ + "_root.js", + "_internal.js", + "_server.js", + "_internal2.js" + ] + }, + "_ActionIcon.js": { + "file": "chunks/ActionIcon.js", + "name": "ActionIcon", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_index3.js", + "_uuid.js" + ] + }, + "_DialogConfirmation.js": { + "file": "chunks/DialogConfirmation.js", + "name": "DialogConfirmation", + "imports": [ + "_root.js", + "_uuid.js", + "_index.js", + "_keyboard.enums.js", + "_alert-dialog-cancel.js" + ] + }, + "_DialogModelNotAvailable.js": { + "file": "chunks/DialogModelNotAvailable.js", + "name": "DialogModelNotAvailable", + "imports": [ + "_root.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_index.js", + "_uuid.js", + "_arrow-right.js" + ] + }, + "_SidebarNavigationConversationItem.DCG-F5WV.css": { + "file": "_app/immutable/assets/SidebarNavigationConversationItem.DCG-F5WV.css", + "src": "_SidebarNavigationConversationItem.DCG-F5WV.css" + }, + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js": { + "file": "chunks/SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "name": "SidebarNavigationConversationItem.svelte_svelte_type_style_lang", + "imports": [ + "_root.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_uuid.js" + ], + "css": [ + "_app/immutable/assets/SidebarNavigationConversationItem.DCG-F5WV.css" + ] + }, + "_SidebarNavigationSearchResults.js": { + "file": "chunks/SidebarNavigationSearchResults.js", + "name": "SidebarNavigationSearchResults", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_index3.js", + "_uuid.js", + "_chat.svelte.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_checkbox.js", + "_TruncatedText.js" + ] + }, + "_TruncatedText.js": { + "file": "chunks/TruncatedText.js", + "name": "TruncatedText", + "imports": [ + "_root.js" + ] + }, + "_alert-dialog-cancel.js": { + "file": "chunks/alert-dialog-cancel.js", + "name": "alert-dialog-cancel", + "imports": [ + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_api-key-validation.js": { + "file": "chunks/api-key-validation.js", + "name": "api-key-validation", + "imports": [ + "_url.js", + "_root.js", + "_uuid.js" + ] + }, + "_app.js": { + "file": "chunks/app.js", + "name": "app" + }, + "_arrow-right.js": { + "file": "chunks/arrow-right.js", + "name": "arrow-right", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_bot.js": { + "file": "chunks/bot.js", + "name": "bot", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_card.js": { + "file": "chunks/card.js", + "name": "card", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_uuid.js" + ] + }, + "_chat.svelte.js": { + "file": "chunks/chat.svelte.js", + "name": "chat.svelte", + "imports": [ + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_TruncatedText.js", + "_checkbox.js", + "_bot.js", + "_settings.js", + "_models.svelte.js", + "_formatters.js", + "_url.js" + ], + "dynamicImports": [ + "virtual:nerdamer" + ] + }, + "_checkbox.js": { + "file": "chunks/checkbox.js", + "name": "checkbox", + "imports": [ + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_root.js", + "_input.js", + "_uuid.js", + "_hidden-input.js" + ] + }, + "_device.svelte.js": { + "file": "chunks/device.svelte.js", + "name": "device.svelte", + "imports": [ + "_uuid.js" + ] + }, + "_dialog-description.bHHIbcsu.css": { + "file": "_app/immutable/assets/dialog-description.bHHIbcsu.css", + "src": "_dialog-description.bHHIbcsu.css" + }, + "_dialog-description.js": { + "file": "chunks/dialog-description.js", + "name": "dialog-description", + "imports": [ + "_popper-layer-force-mount.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_root.js", + "_uuid.js", + "_index.js" + ], + "css": [ + "_app/immutable/assets/dialog-description.bHHIbcsu.css" + ] + }, + "_dialog-footer.js": { + "file": "chunks/dialog-footer.js", + "name": "dialog-footer", + "imports": [ + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_exports.js": { + "file": "chunks/exports.js", + "name": "exports", + "imports": [ + "_root.js" + ] + }, + "_formatters.js": { + "file": "chunks/formatters.js", + "name": "formatters", + "imports": [ + "_uuid.js" + ] + }, + "_hidden-input.js": { + "file": "chunks/hidden-input.js", + "name": "hidden-input", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_index.js": { + "file": "chunks/index.js", + "name": "index", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_index2.js": { + "file": "chunks/index2.js", + "name": "index", + "imports": [ + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_TruncatedText.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_index.js" + ] + }, + "_index3.js": { + "file": "chunks/index3.js", + "name": "index", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_popper-layer-force-mount.js" + ] + }, + "_input.js": { + "file": "chunks/input.js", + "name": "input", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_internal.js": { + "file": "chunks/internal.js", + "name": "internal" + }, + "_internal2.js": { + "file": "chunks/internal2.js", + "name": "internal", + "imports": [ + "_root.js", + "_internal.js", + "_server.js" + ] + }, + "_keyboard.enums.js": { + "file": "chunks/keyboard.enums.js", + "name": "keyboard.enums" + }, + "_label.js": { + "file": "chunks/label.js", + "name": "label", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_models.svelte.js": { + "file": "chunks/models.svelte.js", + "name": "models.svelte", + "imports": [ + "_server.js", + "_url.js", + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js" + ] + }, + "_pencil.js": { + "file": "chunks/pencil.js", + "name": "pencil", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_popper-layer-force-mount.js": { + "file": "chunks/popper-layer-force-mount.js", + "name": "popper-layer-force-mount", + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_uuid.js" + ] + }, + "_refresh-cw.js": { + "file": "chunks/refresh-cw.js", + "name": "refresh-cw", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_root.js": { + "file": "chunks/root.js", + "name": "root" + }, + "_rotate-ccw.js": { + "file": "chunks/rotate-ccw.js", + "name": "rotate-ccw", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_server.js": { + "file": "chunks/server.js", + "name": "server" + }, + "_settings.js": { + "file": "chunks/settings.js", + "name": "settings", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "_switch.js": { + "file": "chunks/switch.js", + "name": "switch", + "imports": [ + "_root.js", + "_uuid.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_hidden-input.js" + ] + }, + "_url.js": { + "file": "chunks/url.js", + "name": "url" + }, + "_use-marquee-selection.svelte.js": { + "file": "chunks/use-marquee-selection.svelte.js", + "name": "use-marquee-selection.svelte" + }, + "_utils.js": { + "file": "chunks/utils.js", + "name": "utils", + "imports": [ + "_utils2.js" + ] + }, + "_utils2.js": { + "file": "chunks/utils2.js", + "name": "utils" + }, + "_uuid.js": { + "file": "chunks/uuid.js", + "name": "uuid", + "imports": [ + "_root.js", + "_server.js", + "_url.js" + ] + }, + "_wrench.js": { + "file": "chunks/wrench.js", + "name": "wrench", + "imports": [ + "_root.js", + "_uuid.js" + ] + }, + "node_modules/@sveltejs/kit/src/runtime/app/server/remote/index.js": { + "file": "remote-entry.js", + "name": "remote-entry", + "src": "node_modules/@sveltejs/kit/src/runtime/app/server/remote/index.js", + "isEntry": true, + "imports": [ + "_utils.js", + "_server.js", + "_internal.js" + ] + }, + "node_modules/@sveltejs/kit/src/runtime/server/index.js": { + "file": "index.js", + "name": "index", + "src": "node_modules/@sveltejs/kit/src/runtime/server/index.js", + "isEntry": true, + "imports": [ + "_utils.js", + "_root.js", + "_server.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_internal2.js" + ] + }, + "src/routes/(chat)/+layout.svelte": { + "file": "entries/pages/(chat)/_layout.svelte.js", + "name": "entries/pages/(chat)/_layout.svelte", + "src": "src/routes/(chat)/+layout.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_checkbox.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_uuid.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_ActionIcon.js", + "_DialogConfirmation.js", + "_index.js", + "_alert-dialog-cancel.js", + "_models.svelte.js", + "_chat.svelte.js", + "_device.svelte.js", + "_dialog-description.js", + "_input.js", + "_switch.js", + "_label.js", + "_index2.js", + "_refresh-cw.js", + "_arrow-right.js", + "_TruncatedText.js", + "_index3.js", + "_card.js", + "_keyboard.enums.js", + "_formatters.js", + "_dialog-footer.js", + "_popper-layer-force-mount.js", + "_settings.js", + "_wrench.js", + "_rotate-ccw.js" + ] + }, + "src/routes/(chat)/+page.svelte": { + "file": "entries/pages/(chat)/_page.svelte.js", + "name": "entries/pages/(chat)/_page.svelte", + "src": "src/routes/(chat)/+page.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_app.js", + "_uuid.js", + "_models.svelte.js", + "_DialogModelNotAvailable.js" + ] + }, + "src/routes/(chat)/+page.ts": { + "file": "entries/pages/(chat)/_page.ts.js", + "name": "entries/pages/(chat)/_page.ts", + "src": "src/routes/(chat)/+page.ts", + "isEntry": true, + "imports": [ + "_uuid.js", + "_url.js", + "_root.js", + "_api-key-validation.js" + ] + }, + "src/routes/(chat)/chat/[id]/+page.svelte": { + "file": "entries/pages/(chat)/chat/_id_/_page.svelte.js", + "name": "entries/pages/(chat)/chat/_id_/_page.svelte", + "src": "src/routes/(chat)/chat/[id]/+page.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_app.js", + "_uuid.js", + "_models.svelte.js", + "_DialogModelNotAvailable.js" + ] + }, + "src/routes/(chat)/chat/[id]/+page.ts": { + "file": "entries/pages/(chat)/chat/_id_/_page.ts.js", + "name": "entries/pages/(chat)/chat/_id_/_page.ts", + "src": "src/routes/(chat)/chat/[id]/+page.ts", + "isEntry": true, + "imports": [ + "_uuid.js", + "_url.js", + "_root.js", + "_api-key-validation.js" + ] + }, + "src/routes/+error.svelte": { + "file": "entries/pages/_error.svelte.js", + "name": "entries/pages/_error.svelte", + "src": "src/routes/+error.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_app.js", + "_uuid.js", + "_server.js", + "_input.js", + "_label.js", + "_keyboard.enums.js", + "_refresh-cw.js" + ] + }, + "src/routes/+layout.svelte": { + "file": "entries/pages/_layout.svelte.js", + "name": "entries/pages/_layout.svelte", + "src": "src/routes/+layout.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_url.js", + "_utils2.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_index3.js", + "_uuid.js", + "_device.svelte.js", + "_DialogConfirmation.js", + "_checkbox.js", + "_ActionIcon.js", + "_use-marquee-selection.svelte.js", + "_chat.svelte.js", + "_index.js", + "_input.js", + "_pencil.js", + "_alert-dialog-cancel.js", + "_SidebarNavigationSearchResults.js", + "_app.js", + "_card.js" + ], + "css": [ + "_app/immutable/assets/_layout.CFd5szNz.css" + ] + }, + "src/routes/agents/+page.svelte": { + "file": "entries/pages/agents/_page.svelte.js", + "name": "entries/pages/agents/_page.svelte", + "src": "src/routes/agents/+page.svelte", + "isEntry": true, + "imports": [ + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_uuid.js", + "_url.js", + "_root.js", + "_utils2.js", + "_exports.js", + "_switch.js", + "_bot.js", + "_settings.js", + "_rotate-ccw.js", + "_wrench.js" + ] + }, + "src/routes/mcp-servers/+page.svelte": { + "file": "entries/pages/mcp-servers/_page.svelte.js", + "name": "entries/pages/mcp-servers/_page.svelte", + "src": "src/routes/mcp-servers/+page.svelte", + "isEntry": true, + "imports": [ + "_url.js", + "_utils2.js", + "_root.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_uuid.js", + "_TruncatedText.js", + "_ActionIcon.js", + "_index2.js", + "_dialog-footer.js", + "_input.js", + "_switch.js", + "_alert-dialog-cancel.js", + "_card.js", + "_formatters.js", + "_wrench.js", + "_pencil.js", + "_refresh-cw.js", + "_index.js" + ] + }, + "src/routes/search/+page.svelte": { + "file": "entries/pages/search/_page.svelte.js", + "name": "entries/pages/search/_page.svelte", + "src": "src/routes/search/+page.svelte", + "isEntry": true, + "imports": [ + "_root.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_checkbox.js", + "_uuid.js", + "_url.js", + "_chat.svelte.js", + "_SidebarNavigationSearchResults.js" + ] + }, + "src/routes/settings/+layout.svelte": { + "file": "entries/pages/settings/_layout.svelte.js", + "name": "entries/pages/settings/_layout.svelte", + "src": "src/routes/settings/+layout.svelte", + "isEntry": true, + "imports": [ + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_ActionIcon.js", + "_uuid.js", + "_url.js", + "_root.js" + ] + }, + "src/routes/settings/[[section]]/+page.svelte": { + "file": "entries/pages/settings/__section__/_page.svelte.js", + "name": "entries/pages/settings/__section__/_page.svelte", + "src": "src/routes/settings/[[section]]/+page.svelte", + "isEntry": true, + "imports": [ + "_url.js", + "_utils2.js", + "_root.js", + "_exports.js", + "_SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js", + "_checkbox.js", + "_uuid.js", + "_dialog-description.js", + "_settings.js", + "_index2.js", + "_index.js", + "_rotate-ccw.js", + "_alert-dialog-cancel.js", + "_label.js", + "_DialogConfirmation.js", + "_use-marquee-selection.svelte.js", + "_models.svelte.js", + "_wrench.js", + "_input.js", + "_hidden-input.js", + "_popper-layer-force-mount.js", + "_TruncatedText.js", + "_refresh-cw.js" + ], + "css": [ + "_app/immutable/assets/_page.CV-KWLNP.css" + ] + }, + "virtual:__sveltekit/env": { + "file": "env.js", + "name": "env", + "src": "virtual:__sveltekit/env", + "isEntry": true + }, + "virtual:nerdamer": { + "file": "chunks/_virtual_nerdamer.js", + "name": "_virtual_nerdamer", + "src": "virtual:nerdamer", + "isDynamicEntry": true + } +} \ No newline at end of file diff --git a/tools/ui/.svelte-kit/output/server/_app/immutable/assets/SidebarNavigationConversationItem.DCG-F5WV.css b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/SidebarNavigationConversationItem.DCG-F5WV.css new file mode 100644 index 0000000000000000000000000000000000000000..a3fcbb32740b1ce2e05ca8605457192ef55ebd48 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/SidebarNavigationConversationItem.DCG-F5WV.css @@ -0,0 +1 @@ +a.svelte-1q39rn8,button.svelte-1q39rn8{cursor:pointer}div.svelte-2vbth6 svg{width:var(--size, 1rem);height:var(--size, 1rem)}.chat-message.svelte-54wbwl{--chat-message-intrinsic-size: 500px;content-visibility:auto;contain-intrinsic-size:auto var(--chat-message-intrinsic-size)}.chat-message--synthetic.svelte-54wbwl{--chat-message-intrinsic-size: 40px}.diff-block.svelte-gafiza{overflow:auto;border-radius:.75rem;border-width:1px;border-color:color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d}.dark .diff-block.svelte-gafiza{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.diff-line.svelte-gafiza{display:grid;grid-template-columns:3.25rem 1.5rem 3.25rem 1fr;font-family:var(--font-mono);font-size:11px;line-height:1.65;align-items:stretch}.diff-old-num.svelte-gafiza,.diff-new-num.svelte-gafiza{text-align:right;padding-right:.5rem;user-select:none;color:color-mix(in oklch,var(--muted-foreground) 70%,transparent);font-variant-numeric:tabular-nums}.diff-marker.svelte-gafiza{text-align:center;color:color-mix(in oklch,var(--muted-foreground) 70%,transparent);user-select:none}.diff-line.diff-add.svelte-gafiza{background-color:#f0fff4;color:#22863a}.diff-line.diff-add.svelte-gafiza .diff-new-num:where(.svelte-gafiza),.diff-line.diff-add.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#22863a}.diff-line.diff-remove.svelte-gafiza{background-color:#ffeef0;color:#b31d28}.diff-line.diff-remove.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.diff-line.diff-remove.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#b31d28}.diff-line.diff-add.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.diff-line.diff-remove.svelte-gafiza .diff-new-num:where(.svelte-gafiza){opacity:0}.diff-text.svelte-gafiza{padding-left:.4rem;padding-right:.5rem;white-space:pre;overflow-x:auto;min-width:0}.dark .diff-line.diff-add.svelte-gafiza{background-color:#033a16;color:#aff5b4}.dark .diff-line.diff-add.svelte-gafiza .diff-new-num:where(.svelte-gafiza),.dark .diff-line.diff-add.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#aff5b4}.dark .diff-line.diff-remove.svelte-gafiza{background-color:#67060c;color:#ffdcd7}.dark .diff-line.diff-remove.svelte-gafiza .diff-old-num:where(.svelte-gafiza),.dark .diff-line.diff-remove.svelte-gafiza .diff-marker:where(.svelte-gafiza){color:#ffdcd7}:root{--exec-wd-margin: .4rem}.exec-wd.svelte-1n7e52m{font-family:var(--font-mono);color:var(--muted-foreground);margin-right:var(--exec-wd-margin)}.exec-prompt.svelte-1n7e52m{font-family:var(--font-mono);color:var(--muted-foreground);opacity:.55;margin-right:var(--exec-wd-margin)}.terminal-output.svelte-1n7e52m{overscroll-behavior:contain}.terminal-output.is-clamped.svelte-1n7e52m{max-height:28rem;overflow-y:auto;scrollbar-gutter:stable;padding-right:.25rem}.exit-badge.svelte-1n7e52m{display:inline-flex;align-items:center;gap:.35rem;margin-top:.5rem;padding:.2rem .55rem;border-radius:.375rem;font-family:var(--font-mono);font-size:11px;font-weight:500;letter-spacing:.01em;line-height:1}.exit-badge.success.svelte-1n7e52m{background:color-mix(in oklch,var(--color-green-500, #22c55e) 14%,transparent);color:var(--color-green-700, #15803d)}.dark .exit-badge.success.svelte-1n7e52m{background:color-mix(in oklch,var(--color-green-400, #4ade80) 18%,transparent);color:var(--color-green-300, #86efac)}.exit-badge.failure.svelte-1n7e52m{background:color-mix(in oklch,var(--color-red-500, #ef4444) 14%,transparent);color:var(--color-red-700, #b91c1c)}.dark .exit-badge.failure.svelte-1n7e52m{background:color-mix(in oklch,var(--color-red-400, #f87171) 18%,transparent);color:var(--color-red-300, #fca5a5)}.exit-badge.warning.svelte-1n7e52m{background:color-mix(in oklch,var(--color-amber-500, #f59e0b) 14%,transparent);color:var(--color-amber-700, #b45309)}.dark .exit-badge.warning.svelte-1n7e52m{background:color-mix(in oklch,var(--color-amber-400, #fbbf24) 18%,transparent);color:var(--color-amber-300, #fcd34d)}.exit-sep.svelte-1n7e52m{opacity:.45}.reasoning-content.is-streaming.svelte-1tx95pu{max-height:28rem;overflow-y:auto;overscroll-behavior:contain;scrollbar-gutter:stable;padding-right:.25rem}.agentic-content.svelte-1uhcmx5{display:flex;flex-direction:column;width:100%;max-width:48rem}.agentic-content.svelte-1uhcmx5>*,.agentic-turn.svelte-1uhcmx5>*{min-width:0}.agentic-text.svelte-1uhcmx5{width:100%}.turn-stats.svelte-1uhcmx5{border-top:1px solid hsl(var(--muted) / .5)}.chat-message:last-child .chat-message-assistant.svelte-3902tz{--assistant-min-height-offset: calc( var(--last-user-message-height, 19rem) + var(--chat-form-height, 6rem) + var(--chat-form-bottom-position, .5rem) + var(--chat-form-padding-top, 6rem) + var(--assistant-margin-top, 3rem) );min-height:calc(100dvh - var(--assistant-min-height-offset));@media(width>768px){--assistant-min-height-offset: calc( var(--last-user-message-height, 18rem) + var(--chat-form-height, 6rem) + var(--chat-form-bottom-position, 1rem) + var(--chat-form-padding-top, 6rem) + var(--assistant-margin-top, 3rem) )}}.raw-output.svelte-9270ee{width:100%;max-width:48rem;margin-top:1.5rem;padding:1rem 1.25rem;border-radius:1rem;background:hsl(var(--muted) / .3);color:var(--foreground);font-size:.875rem;line-height:1.6;white-space:pre-wrap;word-break:break-word}@font-face{font-family:KaTeX_AMS;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Caligraphic;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Caligraphic;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Fraktur;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Fraktur;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Main;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Math;src:url(data:font/woff2;base64,d09GMgABAAAAAEAQAA4AAAAAekQAAD+0AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmAAgUwIagmcDBEICoG+WIGVWAE2AiQDgzgLgV4ABCAFiQwHg30MgTIb7mMF45glsHEAsMl719mBGDYOGC7D0lEIbByAiMxfEPx/Tq5kDDgFfs7Mgk2GEaMNZkJGYKygcBdfmBr7/iSDZ1PQyUX5xjA/Omw2mxeK6n1MThPrWAytiLXxqvdXC9vaFjl+0e2b9r9jbvOKeixG9oDqM7Bt5E9y8g5Pzvn37uA49h0HBzvsEAIJBwlkkAR2yIJAxjYJWe4MTXQnrhlrnF2uLlv9xjF/rf7WjqkdW233H3b9Tu3v93/LWUlz/Hpz+1UqU9UNz0QDjhGHjkFV6m0m5A0hmStcMbij/dbYuUPOouRdZjbF056G6uGezX9rCXImRSV0/6ur3GntCxuCVN5xedWlAvKsg1DU6aTWSqr70rdHHsgb08AizhIfyVagDlhw221PmmoYMGSq2JyntGbJcr74lolTJnpLnn/tsGwQ/MiQ21IKQAKiCI7swBU31ubo39NtVRqni0QPUoVqbG3bp3QVvL6Z4BqlR+xfW8pFlbACo/zwPW2ADBvSkRH0g5JvfUXtolZXjdbM87abT5dwAPoE6u5D6tl/S5d7Qf1FJt1HSLAY0bpGtnpjZ+yxSy82RRiKwu3lNAi4MT5MQwn8n86yHSnkIFfX3bsq2B+VwaJO08h/xpbmj+R9Hq335NGhbC/Ii/ahDn12kMD2geM9DgCUKTrgll7PVZu2BirqFF0X+E8ns//9u0uTzhqs7jKxTqGIH2gyIXFIgdJMHEt9/MZI/Pvz0id8fqAoqlxkWqXAcLabdzW9L4pG0Y4JDLOi+fBrrp6ke6gknTZ6m9jb/KOfj040saWjiSVCsdQvohYqKRJC4rHMqgKSy2woEkG2n+dsY1bD616pW85XLECAQCix7VIeJRxfC5bDZOLWZq70r/5dHyQ4RwghVldUxroQDHdvTIjAm/RuELTltsFnWge7Ovg40A+4O995exJfGYkP7e9Ju9Lie1a1oO1vEIHF9yQI0sIvMQTiYiXov50Z0MWsFS1zqC0LaWEJB4LCZK3KE+uW1eu4V/n9v18/5euZhfsc+OnKjH93TFrRzHjVX9Ldu97wkkPTE4NekaVJU9z9/X/3jGKNGwLQFV9NJG8+L++Pe+m5qurMrQQEP7cfbO2ubjfltePibL8oFdpZ1uju3xhdSzYQqg99BVavIMHNKtG7X4F5B7S8xDFy/TNhT9eYYJIeyZGxllAzoaD0WghIMHpHAGrr2BGGWLGOCNCcIpu3JnyXJBGjL/Bm1xfTBAlz7wTkGWF2U0PG9UkLdzqMnrrxA9s7shVsTZ4+wGiE+JZMG5FmQigRjrWlUkcxYZQgQQlDWyDF7sDhBg14xcJW+VdrSUvsj/pES7CpPted3wFHmtykTFy/cV+VLOjoL3hRFDErNbRAotOI6Q50TCBXhmGMvCmNCIfHCWplkNOhu4nbi6orbQg7eRwRSgZCla/c2pYBXVOqOUtXuIwk13LFlG7VJilBqDpCdANJUbw6MoE+yPDUgCy66pFlnph5Y+1qrjqifjeQRFhYQ48G7LaNHfDgEa77LDIH1vXciaz9PzEZxTHlZOTtELdM2tEgahX03QVEg0/CpBU5skA2Oy0Eh5tgj882LyBk8InwcEzwfUXIGjiyAdAjBRxdMaTbG+/KV1W4sdesjoOWvSzBvn9tCUS4lYSyeYtlQcg8SoZH9LOhBZd6XULKwAxRe0Cf5zwiHrR7qk4Kf540jWkNqtoSAVjW6pS/KEjZCtaI1deW5hOiwJ3CnvgsRxx7CUAhV2aKD0LzSrxTSwo8boRwiXunFa4Yks6GRoIRuZMtwklkQ0RY3QuFMerpU/LHcuJITvLbYXX3PW3svhk5thgFEnX3LZGKEDRPItS2EHZfhB8aPh/BtoCIX1j8WEqG+7wJ6mfhAyvryS7byBE4LulXr1LI4WbU+HQ5QasllKMWCLohPQISKm1BSp+vmwQTBVz2AkXm0afAPPlGuHrES9nupBATNya890gQ8QYTtCKeDW7uHDxRRwoFknQcpVoHRKbDRK4jRKEziFJnEpWOErXOIhodIxk6e3o2JA4NidbVvSCoCD6KxtgE37ZBjcqfW3sz5+/PtJjgh7tPgnb+PsSHm+jQokcxoBhRTChmlEwUC0oWihU9c4CauMq9RsoqujIOjd3QQjZiTurO5wBzg7mDNoYGMKwe1UDSnFT42iXRoECc7C0ogumSeM1IDwozbfXDW3XWcfmpZtlcHvDJgWn5mBAnUnT7BAGpan8AUWfQVaT3TeZKXtpy+S5xAzWGbniEgvwpcvSgulM7FoyZRcDR2vyFKLBQz1A1RchQNL3LedPQRJgQjgz7zm++LUhp6+ZrGFkEQhSld5rhTzq8deFJgFx2jnOOAXUu+EykuBPVst1EzU9SYCe3zO+7CacMnVWjwjy7r55xixwiGyZ6Moh8gsxbjKzHNqc6DMZGyGRqDmOYTgYxMt5yp2aTINUoyyDNGSGHg43L5VDbmUa0KIJLAGNQbpjpiczFFRnZGN05ohKMuoxOS++UFxOOaYaZhSf1nGerEpccOWtQQDlEM1UqQ61iiBuT/dSFCrVYY74j4DmMgWnUzeMtH2FYMKsmfSJqaNQ/bhmgFMOGcaezXNuToQ59EFRoGrK1lGHL7GhArVVxpM1OaEL/kXfM1okHlqh54k0OgkWhOBoCiyNrtU61s5gLxowgyooOEGHbIU3tHAEvkXcwH8D3nIIalczpKY+gcCbdjz2Gqf2rGCYzuAZ8dt1a5oxNm4xVuCQ6HSrqoMPLTePMWLkknDJ9ocVsSf7LFip068Y85h5MTkVvJQoEhml60KqK8sJvrEZzyb6gwiAbGmqyBsROs3oEc4mjxQxBkUbCQLUdQCQNZkqWqOuGUH0HEA0G10bbKQiCgkRTADUvAKIlwGyVN3CbgdsN3GEwZ+gm7M7RqKsDiG6DmZal3D1DqLcDiD6Dox8eoRggFDMJxSxCMZtQzCEUcwnFPELv+bZpyBvIY7DzfsK35RD+Oez99R+B14htGshqQYFYWECjD6hkccayhEVZciwW6w9Lth8tLaBlBfbldytlRZayMksZz1ImNqFVBbS6wL6mtDLWZhnrsoz1WcaGTWhjAW0qcG62neQecP8/gSpPMmAk3GTQKXXNzYHsE1jvCcSYWLRq92eeHQIivI8QareZB8U+hVbwCARpuyHI9Ad0ZeEcg68nOn0YAh8O/MoR1mDaVGuY1InD/eaD2WHKVF9UQAJ06oj5qMPm5PERCsC8pa/mRFPXvxwGA1e6w8kiZlU2WWzCSbsiJsoTEJWZkpndbUtdRZPewTaJxCuyawRpSbquvWLRmtZYHmmT5JSSJmFTsaRB4OUVDDgXNFBkVJwnKglFmgNd6aZmH8WWSUyVdqu1Ldw6gyDGet0ii10YdJERbgW/XC7ALa15UXo+xqfIaIakWCe0V3uJunSsnywSCvMNXkmhN5/LNKi5kWmzbP95n0LLnDkZZZXY3wcm4LBDDhN1TaNZCGJQUhylN0ezNFfOlQtlbjKJ91ROqnldSBHo5xWwRBNwZC4BZB1BsQLmS7X8dQp7V80TGtwgVhLJpnmEh5E3NTfRljOOMIhCwM0yc7DQJkp9hY8ovAxIrsGJ7DFxtdkP72qmamP0+qaHmyy7HJkghocK6HuC4gbTNSIBxSKCYa8wtUuKZCMmNJTSy3J8iS/9b+g60BVGw6A4K5T/9bcQsKSV/eMIYPbSth4w4pejqP/GiCebUOK1JGaMMX5qHtkOFXDPJiArx3Exjlg2n9CaywKTwGFwlpmgQrT0qffNDMRLpUoMheUOnjDtfkCoTcvAHRWF1NJUtPTDCxH9rqCC68Sa6BpTWNLh0SxZz84xuaa+SAThKRGHCIYXgZcDghZySo7AIkIoRHonk2pqbZ3sqk/RLFNrG8dN55mqhLCIcVy1R3ZVUu/R3MfUh5gGooFvriMf7WOaJugTnrhsOkFinai6KVNmoGWNOOxIgHv6P2i3d9R/ymSwaPlWKo6AbngjSiJLNG/SAjTaJizOMvfKBxIpAg1GChug1f2mWK1mLFwW+coXN0xOJgyDVCAdx/gPmonCN2uXJrbGO1EILMCbiD7Rj1v+0aMHD5ZKpRxNKLw6k1ir5b524pLL/ByyUUuJoIhGYFCU9GRahTVlg1tt0C3jxqQaZwXXsr3PRHGxkEpn3EMdlj9N7OzI7VGiVxPEajd+QV6IeHEU/gYBFOtiqBwgGqPoOXPqP9VhLIcrqpSYB/qjO4E+IQ0SMtJxpc+bnBWGeb4nODb7d5/ieufaXh7uSvonTqnFEU3zJ/K2ijfahOcbFr1MESr5jecngghZN6BkER/lMbHBuFLO3MHekcQrRvu5VMtlwMeNOKlOoURaskZZtJIKzxzwJVncSAT9YGJJGJs8U2hZZtD097qAmuQB64XMYxosn2ws8DDHtZb4nPFu2/MAi9UMVDkQJapMGQy/oR8SJsbvnKB8zb/figViEtXOOekR5mZ8OeoJXj072AWwp+Bp9wnc/PTqC3Aessps0oQuihYUpKx2mQSelo9cH4w7bWBwKzSynsKOWjcPjFVtvtidbhSfehFyDpbsHwSxRgGmxf8le7CAgKv15ovASFCB7M9Yzw3OhtCSYnoNpFdQ/8r4rFck3k/1mqyu3Z+eIv+Rf7HMRXJcYZnfSPGv5l83rtMGau95j0LqCWk3UP3Gv3J1mW/uMk2+IHtKy/84csjVAgauVnwUL/9E038XwOKmCFT7yeoqmbKtFS5Hr9kCevL/AhBVY2wWtL8hUTLxXCPwrCSfP8LnDf3BG/+b+BI/5MGAa6nXsZjbLBFKqCytbLmB+0IlL9/p65Jt5GiEgLPcKF+hreE+97wwJsNpDFOH1SanbMq68IwozCJ+mBrILoXZ/27OZJ0w7b5zXmNtzeqCQVE7inKmIO6HJYVqw+22K19QLjAWWu1xX6nET4KLhMHZaxzLZotZZ3aW2zeIYHa5A3hU+49QxCITz0/YyCtDI+wMJGdhSBHubiQ3dW6DUUlJ17tBL9+HRzgZnsRn2dg77F9j94dB5gNgWmWL63nV2K/qdEsu3yKS70IFw22Q8mdQvQj97OkwHlqytzIrr1Gm2npvdRkxyDl7w4gxm23bEeEef6UdXOwr4ysynyhE/kCAPN1+jeRjf4InCot9o3vepTgey8BmO8p50TJXZbPghEqDu8xGrXNQFMGksiB9FpYvyBmt9cxUht9oCRgLyAetXEX78af9Gs8ZBMPcnw3h3wiocsj3vS8NHiK9XbpvcQlcw+es+1pT36UpUUcgM+yvpQRcer6EUH/mxf4vazNvY+OylQ1+5/49+dJ/+eWhwAam2A04x5EtCAw/9/3VQO36mHQylt5u5M15hjPFUbpONyhRHHCV1E8d/1B5NOolS3Xmtuj6YT5DyzzVAbgedrl10lUcKm5LluPvoP8lBteJWAiPD08Eq8oVFrLysIAR8GFgP2t/vml2kx50nR+uXK8AL/1h1oSN3MXlEzdSI53yLeJ8hxIU24cjR5xIolJyPvn5DosfFOiVLLh04kF7LUtMg5y7OdMioQikTgSRx5jxu1hKPMmAys4CI0ctsVDj15j6cTkn60kppV8s0/L50jrizktki8IjfO1QKKxqZWBhACZDupbIDIIyrD8M9qjtjYVndRzjq8AlihSCP9CqLRFOCfai0eOGJPibwNRgM+X215ac/UN2i36xMCXJMwAwFUahj8BOzxnY9yuS9DKwZ1kAElZ0n7qkxzbzoJRSa1oWdCWHoxhutKlwjbj5Mj+lGWBigfMoxDjW6fQYJRDKUbvWO8BPnhfvMC0yTIU2Y55ezsQxOlHlvDi9SQGHzijQp5Kwkaxn49QUJS575NL4ebltHXQmgYllAdOT01+lS8CB5TQoDC9COvPsV9GKrRJyT0Rtd0UcpdhrKnF4hpMSKnNl7CQG+M0F/RtxBCifCo9BZtBwTZnnkxcat6YV8Hmg3FDv3wyzrIKFA8UNrpiz5/Q3bWIeS/3MG3D6MmBtfK0daxwpSvA1HFqjh9HQvCtzzLmc1K7meYnkq1RSUwAjiSh6OOtFFxp6xDTBZnPkYXmMpTYlQHnf3ZLtia5iAbzsGwPXNdip+9eYbhHC4NI3CbZnSgb3RjWwfMNrBU1W5kMXr0BLHxFwRcjxrZNQpkVmwFSts5GPunPDG+EGuhuXrAtZHTGtrONNy/wph/oRkOH2l+gJ7DZDkFpjZUb7ZA11G6e18Thlco25Im15i7NczeWsrqxG5/SBXgHhnMqv4qDZBw4Phfow6AM1zo+b3W2GzLmZtp6Z4i5EuTJZJRP1T2mJIB1dMQyEp+vGPbAwLrwZJn7aLlEV/gSic4PYvXR8P/7nKiEV2LYoynvxBricnQSKoVDuzvYkhZoCp201n4GJgLJrs94I5XCcVznsxFMM0/5oL1Om1BrF0vmYmCtB//V42PwLjZxgr6xLYyTTsM8J1pcN52fCAnC0keL47CkkMz5FAAD7mk/Rf0jAYbSO8usEsEwpBGKCDTKD5pIsy8DWpuSH1cEVHjEviA/CjBc+DjjWcuZ6XoNSaLeltC3vebrpAPaFKd2NMcXQYiVjmKvxKVYU+pATmI2+bAS+KQQIvLtteautZdbES9aJPyYvldttEHNmIzmXNI4vKE72cxUXgaOr5l3OFJHlaGgSTtK+M+3QVLa30DLfogrDr1KgSr/QsYSTNW/EHd1drVEAe0/EXTqHCuedGgjLqf61YKVeNt25c3V6Ij7wLORZfJbwhk4h16bqDvdMcS3955Mi+UX+SxcbtorTatP8itaW4DSNR5d0s6QZJllDVNq7wvAiFdj1EuliYF2oAcvMdfzwwuk8V8YqBAnMrG+1rgYSYAGue0VTmZHUGdfYE3t7cVF5Wytr0TbwEkxdHJd0TaUmy+wwz+opRl8Q+P2o5/glx3ep79MovLrxSLJd+MMVbbP31cKmo2F1m5b3qCAoNyy7S2cE8VCRtHQ9AfoWfHsiHdi2ZYM4cvzfW8WEMjsB/e1c75lQdJ6u/Ki67DSu4VZwDb+kMzSxF4gYIFiaNZUXQhUSG17CDwSWIswtXxUmDEEa39RBTjeq0t1yRD48gnzP67I4siAryVYyjEqGEzqUBPEUh46fdOtrtfzw/qP1ajygrSaBlu8JsKnScOfCOuvWGZ+FTvQ4MKdmnN3Q/b73/dxUMWxupEvvJzCavd5y9Zi23JFIWYwOnZpTQ7MBjCgx7YDCSzNWMbU9XDYNWvM2vQhUwLMghZ23BHNaapOLFRFKZAaFgVjH2xoNSiQ6JLpfra75vodquE0J69UOmX3ABRAeW7UMiUvRUerSrGZePD3JAj9EK7zOLel0QXoBueWJW504a64CZmIuUBmeFxYMhKU91Z1VA4sVLISa07JbMbGb1kwrmoe+6XZHUzaOQKOtWou0OCZLG7sl0RImhuJ+ohjv9A5dNXYatpy5odevz+gg6s80kZ4SCt+UPzRFZwK2aWOM8QsYu1BrRArbZZDXUEgtsZ4r15j5BKlqsB5ixDxoc6wzlRUFfnEylNUyieb48JtcLVS7eN1EA4tE48pYFQnLl/snrgcis2w9s6WmrJeqQms1yKKwyOBMuGvTQGD9I+cvUyzH8xDAqXcC04z5FaAgZ6VhsQdFi74Zl5P1QudKWVNaPCu9jhVeYx+kCGv5QtDWMHco37cAlh3qzD0pttrN5DQljdS3bpsUl80MaIER7ebXjI2Q+YlPq55ljzxjSg00hSeAFxNFi/qYjUOG8UHGdRqIHs1opu1pHbkKrTjnoYeEwQoaBS/tIlAmbvEmhkVVpgtPuu8FJJcWhxV9yMrUm2JuS2X6HmWPdtYebRk2BYetsS4SUKaxQjRNWmeqZZpwedVw70FbaGZknrNo+r7IY5UE+45KQXKFKw4gLzKZIuXnXaHifidYu6HFEhfIRihjUk9slxLwPj0NfJketsBJ0voTcmrHUMpxYXaKjl3RJjB4N7Nbx9XjsnuoOuaZpSuvXEKjlJfneZ7R/c8k+M8owEQyAAsVNNkEy3l4HCcx0Kek50Q2avg+rfiwkf/HiF4NG1S39mKK037bfXX1asVmUizyNxa8ypyMSex5P74P7HKCTXH/ZE+QCQRmLadwJOXaFC3eykBGQGBRLM8X5jlWucKLqYT8JFq59J1QDCGFKfz4FPLku87mLoKuSIX/bB5A5q0YIQgKLkYSqA0sWtJ65TbnFglglyiBZVYRPGUNHmUoRTd+eStFLvHfsRbeD5AbjGJfABWixZnmKcS4vP67PkuQW/+0FavDhzkAapbdwTjm9hLWm2W3Gcd7DReuREAYvV/mRsTTr0pcOMjh2/g6fSKPUIzK1h/ChRouWiKRmNErlVNS0zXcr8CrzNWexn7Z0KAhJRaAsSxm63m6Zeqi1fcq4Hlzo3XnMKYPOILz93huZrIHju+0uvifCPDNnU8dfPOlzr4fF98aVMBKc4S16ktY24LT8OwTfpWNbhNdsdIM1u18Hi1JvdMkilu7WSKLqHRF58ogP6PlEsNYZgoXqVy/vmVTe5mbXBf74U249gzbdzbMqyTW6YvoMPydJB2jvkqfhxu7rIfiULdLN5jnk6E1f9CsRneSfeACQjFiiBPPvUYm3JmQpctvUoDqnB7QBeVI2RC3suIbjuHVCAD/z8Le815MFEVJR/FpXjrYkpnT8ppGMLO5KauHP8XSwmYig4N+LUcLzVP059smxXQRZGxSVFLkirdIV/UxESSa4oaQloH3G9z4ylICtnfUKSJnKP16msRgaxGEG9USEvCW/S6Y5q8UFr95aBiEoEjOac1jh0bAmECKSg2sX2v1J4Hjps1Vrr0mGqDdJTohb+M09WY1dEERlG9cejwmIvPpwuf95a5cU8Pdb94sPjBteS7fXva9ZfCMw5OTNkNJ33CHWIm2c/3LqUOHyvs+J2ygU6PSKCb7GwxwKVTnm2WPmDvgBIxx03aU9espAg7f201uUki3PLn8mw74y05XYbUe085B8xSFWXt80QXiVeHagR+LFH1JptcYcpZHU+h2wqn65VKJ+wLsUEHmSR3kRBNzgWqPkJ+69digk6J7w+nJw5KcVO802JqHRxAuRpx9ahxnk7tasgu6sxC5vocUAY15r4pAniQb/SzxVVqC7kCR7rqey4yWzg58yXHyfs+xUDTIAT/oP6tOyW5JmnZOO6EH8Xsj85cN1AzXCRfKxfR4mt8yOLTsoO6JYsfYxXEuQ0CUy4nq24/cribk5YSAwR3H4hMoi4m4QBqXrSw3nWHhheTVK14vvYtEidkCahA0zAdSwWwClRzWeYv37AYPBJAfBzHTTgs6lZkHFKq3BzZ4T/Rz/0p7MgLjK1N2LS2dNetR6Dp3+YB2N0nQa1gszX6xJEm/9rquu5Cggq7BUNr7w/eQ0RuX/GG1sQCxlVSgJxbBDkN/qF9PlL7bH6ionuVoO6+m73741Kkv68RLh3JDJ3+ea/HXj1dw/Eyu8WGz8e966wtQIACl6TPd+eHsUU/lvCubfsk10z1isPYn4vR21qgll2W1ox9e3ekh2YK1fge9Zt1aOmkSSSlPYjOtRxiM66hClzSS114wZ9JTjik607zGnKk7IhPN4YuagbFrPPR/eMfTsbq5EPbK6wKFkBAvjsXm8H8iTSQyBnrUgdLu3Cci4d6p4aHWV297df0GP6uUkJ740C/Sr3c2OcpX3KnvPCfOrR9YskYorRA901bvh0DAFFHUxauV76BTiUKGi2sLZglb4X4BMddm7Ty+r686mI69FykfGay4tc3XGO3dwCWKfwhmJDQub54yk3Uj4Jc1vX6pL5Ca96shcH1gBIr1YwdfYekxggmmwFr8qkpEkIm2RLungj3h4TmlQa9U5g2jUsYDjZue9obFjNlbocDIhqgzJCboNSyG4Vsy8wFcEg6gh8opR9xecHt6zfHRGwwYRzvmpqLJeO5CeNhb3J7ftX7OnKxXInhVk98CDhd+QAdcBa1AVcVVf3XvuUjmn/XJ4YdLym25LPOGPVHzH+umdrH2XSrxVno5xzfPNhelFpExuAYHkQfmmJQdl+4rI542lPkV6eB3atcesxHfHajdFKpoKvVr8rx5atOmX/qs5sCdjTnsikq25OH9SvHGo/fZQbatrMiK+cUiYsI9JFSSRBi8mPdygb7/HQlbvAm2ee3eA9mXmGWuRYSoHZiMXYCUEuTEBhbo5Kq4gCmYyYChcjPjC3xoNUc8EeqGHBUKP7j1cwjzz22wODksBIEBSE3UreqDBrCDJcywNETATf7uLEZZfTf99TXox98a+Szjd7aGJRpkSAujQ0gizo+3WU1whn91TTNz/M43h4toRv1/TFd/W3CiC+pWj2nG4LoUdLAFNzQdcCnDh32zoVnaNdo1ENzTA017AxV7tBzes2JbZ6vg8I0r2loEewlllEEi44TENyQmMUIQ8jYsHVfsa+3Yp/AzlYOFqCh08N22nja27eBoS+s3NQusujTGsFCJbcs7ZZfye/aGaix1jdktnpFPt6H2PO2Pbo3PZC0f4HViWgkqfPjlD3bKvvrsMnTTgr+ObQ+FKoIhzmAKSoSlESmc11cbY3ffcqVE4ZuP78QO+cEGAwTb7LojXOYykX4k8S6XSX1qbKKk0XyxRVJwubGzHWouzf8ABiYtOrB7V9lukpgqZPjZ+iglusZhZbXg6tHDeNZR69NH4VjTl7UYNGbtMlaJeiY5VKMJsArWXL5Mru4y7IxpVPcEvvdXrScqovyediiJIJox9Zjh+q/P4lHHbjFBr2WhPobYPYRLo57cWSKl+7QzoVk0S+ArK4WLinRHOCQdlri+wNoPxESN2u9/Jy2WiogJg5M2GBDXayDEYgf1G7R1Ac+qTUfHeIMsLyY9/v9PzvConPE4Vxe8Er0XL2EwzYzFSdODWXP2t2fWZsbxeSGqYX5tV/28499Ol5b6iXgn8B/nW1pAqJ4oqRtSd4EcEXOZyIX7aVq1QLUQTE3ds8GrL8lcw5XMBJnmNCCl7xiKW95mp6fQuu7k5OzMtIUliA/AU1MPtclm0H2QnnAHvQvjPFpLi3ULNDOBTIyLJ0I4nZenyulw4wNz4sDH476vOdyHUn4XKn46ox2Q6FgkEHpcZS/+ufQu9FMcfvY1t/WPGhGHIbI8kFkryDAoVT80I7/xs+wbvqEWfwUDb8n7bIVRSS3qWfWM8ipnoecDW2ET7kQ7Ufp9BguGWBehhumGv+Gr7Fye1HptZLgLFTUC44xJ39dcVta4T645+UPXy+MvhKgOaQeEyNHB/eur32bYCtd7d/RHnYsOnUtqhM35ybLocOdkyErGNENAIbtYcHHLyjz1NI0RYjNVcmzBOjE+HBEzkY6/RORqLbHbojWaGkZZ8KyGFofIEIEYfDN/3kqvXLEL1ncyGENdyUU5wZOIPvTBoiX4PwRaonBGmtaMS3pARQcQ9Vj9GhIBj7ToL0mI95WgRn8hNBcO8nwIEw1R9fkM4HL08/E4KAIC1RmFbjV2WZP2GvwC2r4Cg8ENzk+yk8aGVEOtDsMTQFODH8jE5vVxKD8IgT1toqiQw+P1eR5TxzclNq/4k4GGRNhfj5AjrkYb8Y371o6TTN7G1LyS1OX02OgDPWRLjzoojeQfnayfFTh5tzKRKnd0ZJGXtcPaRf7q6qbyyMepwuxxRRW3ciYbd+1ODlJSVlCr++RLCMY7Q+y6yoD/or9hjZTRC3Uq5jX9u6QEtjlCKTYxkT8ceAsJjlmmXn7o33M7E1C19QnlYHU9tEA5O4oHXpTK/q/HniOwfRhr+iFHUUuiRlDn5ul37MndsB/6rTjw9uu1zb8XnCSTJzvkb8XjDRU9VRWxmOVxUVV+U1Zv1vw2T4Kgaj89O7cn5szssXRzB1mKBtmfEv5LI/rP7q5CFH/nUOkW8OqbkLGVmxFyUNl4LOGQvIHX4nDqRhlKTLA0VQo+zXynNyulE1HhfsvBGzNaDJeR2cS//8OnE2fxyQACl/xGeeKAuRuQr33JnYy/meyGUs3yucIyBxypgDrNTIoIPYXNfIW7jotKmYHKYMRd4/mbRJg3379Fu0NY2lCkmCOuWzLUyL+qbXj62qG7vapgEOey0iBfMV895HaE80o9HH9PYaKkOnCaIbC8svv8dxHh4UqpPLZHI+8XReBwqJ8tsk6GOek8LfgZ1DIkAkb+B2SULUTLFQQ5EUpGo9Cq1fpNQn+IyB3f9eojx9R14hqy5wCHaiQR1Dxidkdqg6FWTzjjHRn7BT29mg3Uwyp9Ym9/1BrC7xgmh1bB695jgQbYyPAES7kWOOnlAI0KRx/onCEk2M7X6WsFJix1H6o0oKSinLoIXNfdNw25eOfKq57H/PR7oggRI6IfrUNgAOOdCPeGvqGxAGQNOqwYo38vqWmaHOzhjaMbj+ExoIhc90W1aYH1ImeE6dI/nNa73lcotAukgF+lOcr157stlhLqVPHVvroE9DUXP1dnNQPE/Bk5j5xbMa9y3u5bAHpb1hgJpJw9aCj5jPIgl1XbTUY/HlqeDkFru0mxP2kovIJsurXpZohYuAqXaA+jlDnPnMcwmujqnEl9Lb4jLZ8BpLKNrCqZMgLmufYzcisLWweebG2Hjcb1z9WR6DDM2CvpEtyseHs8BJDV7/hnBWZNFSoIRklZdFibQN8n4J4+koS/YGKdJwVF5qlzsCEJjdsyVFSrrfbH3/6qyLItxavtdnonB82GSwh3YhL7qV/RB2REKaMs+HgRzjAljUkA4olFi4a7hAcxT4nB+hQ0uakUO8blFtQfSumuvwPgyiOVjyd2o9xCcgYwm7qBWCYCtPPIZz9CHTfQD552/8RjbTmp+KE/2fW79j4mHxCWEGy3MUbGkWRAIO4FVd2AFJUSoSAnjUcMW2vOBY/Y7c4Rts88XJ2lnAlkbFGZ8G4lpoXnMsGP0LL/jk28o5bhrPlGoE9bife5SB1HRK7mkyTIC5bB/f0P/vdY+OGXP2xYvTVSBXVem5HINM7z7hKJQyk2HLhF5vt0TBQa4WTDUjEgMRWm+iz5fD27pVPTghQjbm03G73Jqu+uq9XtxMu754Vktx1+Rx6RqpFLX6XYmiWGzXlMoVokWb6TCYdGCaZkp9efWwyzQ7xpltGn+MqfO7+vtojHwAc/JyvJlBdS52bv7kU1i7FPWLXt9dUSIjf/A8fzDDB4hcMbBCe3kZWVl/TB5YhAlIOol2iWgtXP2+u6GuNSFz7DF6qrszaVBXNfuth5Xz6bZJFhnw0K/fG398kqDGb1jDY0DaSaa+MTbNycGA3NLNE4ntbL7lBZXy+EzVlmv764RdgzRxnvmPjr++FrPNal8qidm4OasWd8VsG3KSDtlnXD2gYnKxGhmsB3PNJss8+jy1PtKwIlqsfHkfahanYlk2jLL48PPMKlh7w1TgcPOfv9i4+aEevO+6/J92fQm5ZJAiUQsDRBHd9gL6VMqkEu/KWP6O/Qnlc+CLzeUuWt6O1XCliiDr4vnjjLVSdGP9HqP9fJ/yPTbugDzATHX7Gkho3UpiBk83vF0OGVURiSLNOcuKxZsU7/4ASZ+6dF/7ledgf9sr67IS7W4z1b1w9gtL+gPQQDAofifV/BlKZ163VrLz+rVUWyFi5Cbin0tw3ym4rMrHGvyxVYAL/1DACnr3bMUdnVxcfHnrQc2Zs/02X8BpOWS+6vHMZOtCs8cveRHNpY8ptk7UzbPTEvooqqvV1vNMgDyPolVSZDt7hZlPGUfeE9HYPF5SecN7+P9+Ko/4eGIMyhwvA023Qr5iS/LH4IBbTsTUoVW7cDld+RaUvTc52RXBsmB11/giBHyGM/V/+f27OkhT8VqI3kWb96xCJ0MtX5P8jPEyxUZ00E8/VrftDK78jVn+mkfwl2KrLXmzLe1sv+pFRUGMZ+fyxq7pzIzeHjS/nwqp/Pze8RomI6zVGte9Qv368YFVdIcKHjBfol8dezIwGOCHvSFagSoEkdR/nmG8Hi9dUJbJ34r9Z8PX8VW00g7GEtWVX2lHS4sy/rUk+gOOapzs9F4yzrpEcAyFqqYdl8s4SDX3k7VzK00zn+YtHaTIMjsyfBQmT/QUVn6EvDFKhEZMaRtQdlIcvDwixnMGuHhBCOIwuXE93GktyVYMZ9onKiXEqoCaO0g14LtNNhWIJQiSMfGLMC2o89C0Nn/lNvmMeLMTbsFXL0q6k6BaWc+aKp2yUSsJXij/wLQ3d6GJvougpXMb1OJ/rK0H5ntdSZnbu15Vmy+OfCuFNyV8LOWK1bj8hFqoSJkziU5DXqbanTLWaI4yZMqd9enalZplkqiaN/sdIjzY1zG+t8ZWnRGnKQjXYuaqzXjItTq0daCObY2mTL7KzBOdwqJi4fu7jbWXlsjSiBBzA7K38pZJyClardbgAhXgEU8hvc5/9imriErOj7NaKqfx23l8DsAe8TkcwK8KfZBsAvuUTqu+tr+SXEzIe2O1vUH4i9slD1En+R8Ct86Aeyikxin7C4UB9EXyiQig+7f3p98UUW+hQT25xjiKcqoKrAJzf6dgk+rrAQ5UQMrH5+9chUbkQbBUQVWaUvK9O8ieR5f2YzsK1+Lo6jW2/alcvkaQm0+2FRDOrHJmQaml/zcY0hxbvrZCW5F2yZZ82y/8gMe15rYLx3mk8VbbpmnDLtEs1D93oeKnR/ds1KvCh7YTB1COynzNk3bdH5ls5KbtZKImOTWnJeogyNwWsT8mp+AYe/7z+yAPcfyaLcj91125c2H6KMN4zym4oC9Dm0qILOFeo26jeCnFx6J4c4V+d2EeVEeawlR/oxxSYipatlMtD2dFclnHa5xLrNunWwTChaLkgGFovmlWM5yu0fjvej1CXJXQnLsIuIEhEaxcf/O/kvBm8mW/evn/Wj1ed3yNfK6xIaLrlyjWX2UQMD5fJ3/Poy70wWxsNlUd+6aYyO5lrx9+jlrdxQvvNAPxqRS+Pod0PRkNkf0SevejHUNA6WzW3l6106w2iWer24I/7AuDHnxEYJaxa9annEPz48PZ1Yz5Slok5XMM8k+trQvGYf+v+haEi7L+P72eK6UoFpx4/L5rYItEYDv7Y3ql7v+HIg/w1Tr/7oB8Y5PwoKOUTMueaoIcNVP/COJEz6BgpIa0M1Ps0rc/Vl4O9tO5hprqi2fqkFnGJ53tvSnCsXRzmoGMhwoZrZRpctWICVBGnxHK0GF8sSDVkH9YOiffvo+LMTisy3jbL/yOR/1tPIUpxXK/jI7HpT5RSmCZnSzX9Vhf/RUDrgS91bdKi4SVKVzc+8Zmo9SZ7iUMbRdt1RKVrVVBqQ5Qw4JtB4/dBvZ9tTFdxptjPstAi/pVeUwxgccOu/KXsOxMwg7pT8IeanJwube+r/+xd639ku1l8xyO5Idd+fVFC1+/wVwqXAH7iP/vEPB488Wb/ogowztr46lsKEGTzudCH8abomWZYc42lX8BKJ5xYCl5NQ5PWU3qqovP+kISfq3I0jDkx26F/vvOIQyMIGBD0+cvu7dHVtaWAUK+oAg6lcElx93gvlhZmYh16bAVnCdt88NRj0Iq8WLejOBESyhSA7vvk0FlwD2AlUM+aSJK/tgFm7HoEe2RAxqA7px6q8oPTN0uugsr11+PG3voawXnzroTUrNRinIfXIHwsHnuZKXSeuSHImP3X0tV0IFbRWjUpnK/9d19Se8h37+8W8kHYNHspPtbYk66K5T4bGZN2iyscehXOuW8vWiXDt81zr3wplWgLxgoF+KOulolHLY2RkWKDliPAYkAevOIAkd7mO9Ln0y+fiGw5RwgO7pbDbFAblotdTKzB2T/pYdpWyZTiccwjsK+7MCq58C0AgsENuE8rvoD/HBhGMqb93G3obcW97FNiAB+lms7hoACTvOBmpdTpNVJvonkE8O3GCXvORLINgZYEDB610WmdOtZIpcdJQbw274LzXqx9hraZ1pEi3QMrMfJR0Dx37miakUbdqmwDAkPPf0L2zg3WYCMTTtIig13CY7gsG47DHQx/hskWNgup6Ti4lshiPm8AQx1Pct7F6qN7e/qiLuIpymPaLN/yKGPzjnO7khsR6Caeu78joE0sGoce+Ked88qo8MH+tiKDPKJGWHwLDqeunj3CxenClIzznxLix/6n0EU4nEUqufoHNkN2CK2Tk4+iNZxN8KdJMKmY+ns2fo/N/0dAxMyE8l6E/Gt5B+pwGDpvsKtMYq6n8ucN7Jfrt+vUALiwNHAJC1387MfkeF826G/ayUqZhq3En2JIraBTHKnI+ri/aSVO+NIYWS7pr0B9LZDPYALuRwuYU3pshzp1T3XiaJBgwjEOyHhgUFXoDDpKulbrBcIkXTDWztEwYngBEuFEZLuhlcBU3K5P1Bes5168+D+Ciom0j++z6mG0IUKLxUHZoJwTzR6Oiqbk5GsG/3oO1wPvzY1+gmqVHP4qAhO/3YOCylNIPcoquGUhsP0v1ha7Y699QpJ55Rm0PzHG8SL80MUH4EkgyNK6dD+SC1dtFalc4rgV75KmQ2lB9/rftZ1fGhrzF/tV8Trt7x8V6kV/Z/tDwfM6VU9cZYL8YPrv+/YnxRad4dy9AtLDpgZ36TSJeBD04GsxLsI7tmzJVD/dJhZHtedXP1o3vSZYEnI35kz+sPB0MPrh4GZxR+NVwZipAE9ImE2BmtbdVuXB/T2I8GGLBtKQisjQz/IFlrp3JLY4XBlaOP7VNhj0oLzpNp/91ohDhKEkkUb6awFeXZ6qZ6D3WjAWNDT69Lys6WdebmBNedlzC2BBYc4g//j9jHVDVe2LHSUbFSfRkjZLkqfgovPhRK5n47v38c8kuXceqemPZzdmBD/CAMtUyIx15AuHuZkew1/9e2xGKyuLCylO7nn+tZGjv1hEeQZXmPLHhuYxleBD0cXhiXZJiPLIkLiufucAnLVHkQZkcxt6nxLUKVY6GlwiyemfKwpl+VC4j8v0lnsoL+u6r/xJq1sPJh73aEZOEnM38WHrYIEqE4CGAo0wHTHAM93mszjCKFdlH24IswOEyJDtiwpyaz4X+MpgsTCceSQdELMFpNnN73ZR31z4+I6oYuP/VP8SC3wjxh1STNJQWpFr9b63ua55xtCuLQP9gdYy01Jf5x/4b9QtbWrMbCz1fqlnTANmj9e/VKNbaPnRqDFWU6gPTvFf7xnrrp8wVxRFZBHhrw4u3bLR6c+SeTFVnbiwnAcOMEeK+WdmNHViKfcrlPF/csO2wdD6DF7i/cXlCTsh2wdXlq8PB7TBFkIJ78/6VsZqYSYhCAPF/UZJ1VY1vef/lTkM+qLFw3buD/BLbF/SJpXtHbEwkS+w4CHQOLLxb9BrOvzS2aEdUnF7h2JGBUY+vW0ecVljW7qQ4f7KZQzUoAh08qWjLkXzWH4S1n0B7mHVjXhHdVpWR3JY9FFRHSPRYmT9X2yBZksfi5E6y3JuOvvSFZhrW4jBgyqQ/szxLJVtNGvUgmagmKyjkubpr/6S5dQXful73FNHS1yj2grdYsnxJvctKtgy3D1iXmmcFymtqWznIdUbJe373UgnJ6a24OLc81SH86Y3CzKtK/X6Th1fMg69mLBfOtj6u1n7/aXaHtGkmDDq7UNVCzgGWK5pr52foOzJWrF42nCn9F8VpMu+1DNySCtjuxqKPinlGQN65SEXBp7PQrmUNO9t2RtIgaRiplFN/UPwP3kHA4+yequlAXvpMpuI1ecYPRtnfpRiA/9E+ef4wzwXDncg1bIA/wc4ghU+dFIW01rzSJzegBLug0u1gJRkG8EoYGUeA5TAURw/sY1/+Wbq0K4/T5n5MH2VgaV2+6+SeitjCvCX7DD39b+7XpF8UUn/JZfku/deAKNngGW9130CGwBn0GfvX5bbykwCPShraimjpqxRvjSQ9aYO7FPtoRM+oi4xGbFOBFiIih+flSu5KhBVqWY6EDHU+Yka/8gW0A8l6xn4O0Rsl0YaUw6VfBfAfr0QRoVjIzD5lP/11i7E80tKoHXbM7rZSn1DsbGVfKrVr1282H1+WXouW7xbj7DW610KysI5bY/FJmuKlHy+KuC0ee8uYhWBKYFjDsDI8rlDKMYRUINDRr4VPWvBpCiXsTeu0A9CiTYakJZP1lFsTelfsG8u/jTsAmPrp0j+tPMn9m4vx29X4L4UcxkJLwQQV279alsFlmZfPfkN2OH09F0V6BUysE03s+EqC/QIQjub67nuZpcp4xlxwiRfOhx00AmZ/0PgU1bhX0rNcSnEl3ALqw/J1Mt+XjNgBw9GjCUrbgzEfTs5PYtDHx3wjbQrqcIMjCkWUmG6Wo+IArilCwZ6gtdoyHmLXpqKp+g0/+42JooIUgAiyXtrqKXJIP6awzrW1pn6rQFGjCm9Ssizmh2D05r6cCn3AKUoSYT0mz3tCwNub15njyyAMORGruyz9SczZgYni7ylwQZMQzS6NdhHeOR75ECmaOKnQ/63B/6CLrkrlkX+uS1P3eeih96To56yGgUSNapl0xoaJXgyQP2blyVeNj7QprLXvl+bD+RYmNRqP19Zmqg0P0PmL7iuqnLHaOnN8SjUXe/EidPFC7Q0znl17ZLo2DUPiTZJJU/02hfRVCRthtPIKYBdF3wttTePRS/M0UgPp9RTJHxFGY+6hRltPbttAHs8HCxh4RoQW6cG7LmbG/xc6y1+IrNmLMkTxGZjtZiBAzZAz+K9tnLNsbgt6bn/+I35HQNhRfUFGqWepR+bfduASWf6sJ/cpYjJfhnj7m3P4V59T1e5oeHyYh5NBJNRQyZtJ1u5b1S3a1SlHICzMjYHYpFp6gcKuHTZXZJsr7POqL65kAX7HVvdjr2CFVxUa7s27PyeprJmSdshMIYLL76npSGplO7iCbxqrFx98Xh4v5sIAfJe6uWBQ2yuYvM3B3J6VS8aXa9bV5FQcSqPqa5VOnUS+tGjLvW93ZEwsdqtmBxI19fUff/8KOrrDFLlE8CMEeRmpqtrHNlKcwfL7JbtRHHp4ERnFhLKQifnwGASz13RXmXKr+SbBpV35urfyrVtqpKSysdgnDxU2952Imsswqk3aAYVkYl0aA+J6qgmBEdW9NXr0kbsaYyVSeFNvi7l/+UTEglv3X9HojJGGrEzVyJtKX7Lp/pgqsb5RrwgUuEPeE40mYcYb0paC6p+mRtg6LfG9N24ZE1s7bNnrR1SmfbtnWW+h+09+JG1MDnblXERQBPZ1/ndfEFAwCXQIDIirMCQly+MbP5iIaejKpswTVplcyaA6pJ1gYAgdI/R9Kx2a8riQapelUYXYcOd7yPT90+a4OCptBcOHQ9Sh1vKME5fXbp+X4WWupqfuzsvmMjZEDTu58K3nsDdO6SRiOo3llP67RTXI7kBfDeY2ChmcGalwR80eFkPaZlvjTBVq1ehLKmmmmtiXBep1MplAGJSlL4wtZzrUI/TRpsYqtr65E2a9E89cvlLYmCO3bri5qwYg8M5OMitgjzRZN3y/Tg047q5quQqX9pGJgfFfXlGH6rADcAMEwi1N4l6F/Y+zlTOCXVGJ/Y4eMsbHrIFall69Sxcfzrtst0G/els80myERTjDIn+2QDuhMzi+itW/nX1EQgQWhGlsTx5zIUfx+7ep6VAv9FK9R8af71iw4P7lIbAOZzowRPH8F5ZgUvZOu75IOoea85+yY+cpwjIe5iTqykcbGurqVrYQR5OlhoWGomSmec0IKgn7IefpqPRK6wB2bHPXKDIJMzuyFwTP5RmPSNpd7YvDeDCIC5K0P7G4uJwBBoWuhWMCT9OP2h01PGV0NQraOnCzSLnHdwXegF583g1NHLIswJfyu+MVbX4gkeDFnOnTLzuuFWQurqyOb51DuKRG//SOVDmHwZ86RAUkXWuxHGh95ngmg2BBsDP7lIIHFKyolcEtnSkuUhBEWL456bZnUJZbtuecP5/OVPIR8kCOXrbrTHM9AcF1pjJS7MlaO+Vj8ycdNjVfdAgAqWQCixiVfJh5EMFmJpx8SCGDap7RSdkQatJfahO01VYW5iowFWp+XwEEzZkwQUskJBOXBy2EGhY5mHB3Wb4qsMutggWpWFnG4WRuJsVFTUYxUqJlb8LAU1YBi9p08zAYNmYUQQZlFEmIPqSXcorJWKFgKJbkazAeVBA8YlMiIqoaKhHUJEJSlGpQAkSuQLqooASIDz5FLpOCA0XM7jk31lRm15CIk4YARWbhAhS/0aHZnQkdWvTCidfK52GF5tfRUErLIdg4qjSfGIqxCIWmKlVZEj5c6pYzy6jkslIcA2BD0CIgOcJG0n1WjI3M7zFF3AgFEfamadNRAB4MXFkNXEpKbBQCuBgtdRuOUK4SdZZEGElCceFsA1DeVl/hLcoAiJbfY2PDXOSILA1ehAAELT/ltWZ+N0Po/RUTlrEfAkHLnoe30nv9i+WevyoCYdBbEGEG7MB0h5YbDWmO0MH+WXMe97SVFqjW7u3AZXL+6QndpTt0baZwS/cZjhvqZa9bdjRPR/W0VbbTU2MKer+++zQWae21ufZL4UYjPCudw/J9R7pe+Q0U+xllLkel1S97XOmFlXSK2cMsMY252JrP1iiQsPvlVlYL+NSB4IfYt4tsH+yXa/sEwFd5GMtX7DGZNu+ftVkStp1UuEdJfAoaHrLK9PRO2daobHoPXrNDdpcVlObOzFZMqaVfa6Gwj9J6n9pXmc3X7l1xp6iswYRf4hKM+58Wm8h0suwhZp3BvD3LF9TrZ46luD4e1c499HuSzuMMsm2OVaf/6PRNIX9j1QHL062XtfcW767KfSm9TWQ7t1/QEAcnQcKx98ueHlsrkOp4EUu24ZAE26t+KLLlAsQOuWCUsy5Ehb+LwRrKxRQIdRY9dvH7j89PBfLmG3Rw9HK2srB0BVik9bR0cghVyD6Q5k6tkJkLh/umpwJVn7FVHE5SsepqYxzAGC1PL2BlNFWL635Z67i+86JaFm86UtJ5jXcyDrY6bABYA1edwpR7O5S2zhZmwFSO/ouLaAWzo35feVIMBuHU2RnzIGk5ksUGFwDnzFuVB8tgZu9FapTMAnmdLllBnJetD8kpr7HFxthcO1xrPu2IV/+EkBXZQeC1ndnk49VdpQJuY3/MSp8PJO2Br/yuIORksOMCNWq76hHBs/M56tw+/oXPU4Y2549LOzuASEOk7jkXJF9YRKdCAGkxE8nKtOrHHTkVgONXCWnDGp6Ek6OwKr4P6HIv2ZWt0ho4WsYZ0QX2afaWAT6CE5LB/Ag8V/gj2vD4sRkgxio6tl7f8yfiBBrXhcyO8v6XU8e8dxHfSJKYBEVKRk5BScXIxCyTRRarbDZ2OXIf0u+vk0uefG4eBQoVKeZVIoQnEElkCpVGZzBZbA6XxxcIRWKJVCYPJEqyomq6YVq243oIIiQxCYqUjJyCkio8SE0jg5aOnoGRiVkmiyxW2Wx14VTO/imiHIObj3UW5jHrev0YtVn966ZFMktw1ZyP7e9Xz5pudbk1Yhd9P4wvPNKhSUssBAW+V+lMs2vp8Hagn8LrDdmwWqPyDfdm3KKYXJMAa/vfnkqHr1KMHp77ihe8W7C2fN36VxK/oh15K+NjC4u52jgd9JY0zXC4NHpg0/KpSKrn7xumXfSanS4PVHkeejnZNA3AtuYT4GXjRoPTECtwyqGCIesw+xkDJsRgTr+vHZWjih249EeaBcEQtxPuvpAP8rW9ACEQFJo2gg21TSd8G5p60qNb1HkMauFk0KyczuyHXcTGIcCId6XrTsCs9RkTRmCwwHoe3B8ZW6fho/QUsweFQiEAAAA=) format("woff2");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:KaTeX_Math;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,d09GMgABAAAAAC+4AA4AAAAAYCgAAC9fAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmAAggwIWgmcDBEICoGKTOdTATYCJAODaguBeAAEIAWJDgeCbwyBMhu/TGWGGGwcAN/A3htFWSLdc0T1aGDZ/39Z4GSI0H4PdVMbUGFYYvGxKBW+KFKPeDWxiX9atmyEb9I4xWyNjr61bGtQtlBiB0RxEB7HcbCjUX5LWreaDuX8uXfDdSw4CBxKHjAFon15zhEa+yR3eNrmvwuOo+JASo5WQeQAbZSjxAYxezqjp4sqF+WP2i83dVF/+5nbfuT2o4rn///e9+fa544Ratg6lcahjGC6dYwmwjErFaQKPZCPny/Pk7fvcQgJjLrdSN8tTBsMONN2+Z+6cjdQVEAKPOWHd+wAHTgk0yFIQens26K+olZXPfk4/v9Pl6ZJWGN3Wm2SA4bKz0W14Ls94r2mmB93/8fdzHytxkDSUghAcAj/V1P9X7n9H99mdkwgZ00BkgMEszuGg5qqrDLILUstC0JoDDB3oeVzX69AyQ/eb6qp1Mt20qfWCBCUC2/ZDj+lN8mJsSfLGChoWzutXwlAKGL+oldLMzozkny6u48BHTP8yCMgBuxDBmjUuyttkm535KBbJ2nluOcgyb6QlezS+fw5ohCiVhd1DjGhgx8jfBr5U9PnT6mfhgQIesLfhP19a682cxecEK8LoIt3++fjZEK02RDeJawA8PkYR7W/tVWAss/HVgnWsttytZBA6isMlxqiffzv/7Hlc9NFtAEn0vKJb3G3t1KT/RpjySFixYw+3m1eAOdiXcIA4Ac+BoBt8dAAFRh8DsGdeRXw/Vi++WfHRG6DHcCLnNcgZD+jrr7z1zyw8wYBAPqrMwAgYYobIUkXBXo9EvVHVRaS9qZSNo96zZZYYdr9Zsw5F6rSC/hCPVfv1PttX46yy7N5Pi/lNPdVSipIzf/M6bMLz9Mo4PPnf6vea3tPmeSeSsg4Uv1vuv8/vn3row/fu3hwV3/P8P+aXr976i1KnvvuuuOWm2702aANqjHcqXFVXO0RsCTjZv/Vqw4OSHQBlqQwQ7rM/7lt+FzitbzT/+b6/gujZMkGgkpbO2D5AvCjy8Tuflm6D5nw4qeIlc+EPVzigoP2Tg6U1gS1BH6pBgABvzcZIZCs04wwRIvOiAD9MbJ1a2RKSgjvTYK3SpNM2U+YO0cg1wizDD3R66MB7jp6Q93iga6JH/jbY98DnHFiBkmSpAsJQcQeukGW4MEQGocECVqk7UgmNK6uQg9e3SBafg0Jice6q4n1VhNxt/XbVsarWKOMXPuSd2bMeJ+S8eKQikjomQDCN1oiDtlBhK7GYIq4JZyILflAJutl9jtJQ2mad59iirCTy46g3BIUdZS0Kyog8YnxZ+FCKF1r+IIhba0xfXCEggXpkVtEyijGZWQANYh66EEmM/nINEPcjNK6PlozYqamiMJKzLnBMaiqKtHhuSHhWndkzDSsPhHJ/5lxJMfQRLRsWr+hwpaz4rQDvXcWZWUTQYzOMjJBFicDgMcY4bEsMwKC5VSB8HxK6JvWaLNMMUDSeD67C1Ta8p7V8FZXBH113BMbA2tT/LV5rUGDOKkgUrkMqqCQVFdE3aOOhobe0AyoRmM6yUN6jRUi4kW16n9ueLQ6jQ8wyFgiPigTc8xbFySY6V0r0e61zihAgrueHS2RjEKMCQAFXKL27JYZR+E3XK4IXYVE9OAM0isuUGmPhkYRPWKLMs0i6VWM5R2b0J/KPSVvIUcBkozbtMvb57rSo0MyuBQJiMtdUWwbEWqGonDqWLCbJLjAwnqEdgREfJGT6TSivhG3YMiIcKalx/upqjYEewx3FesoYEuh8CTSjFQ249dvAuCGVIRIkDtAKV1uMQKjBA7uWIrNoCbfDHlGuBr487i9MRCNboyMMdoj6SITakm6bOXWyeETl1GGBIhJRjkTCMURGCkIgpQERSrCQGqCIQ1honiCIy1hjbFCbG9LrC7vWEFO6CNS6JBrayiROX/Pmlxidv49YyRGHA0dxxFqp+dQpOiGdZjEeqzYgBUbsWITVmzGii1YcQJWnIgVJ2GN2oECrCgl3jOuopS7Uo4nZUa7v9ZzgCnBlJmuoAC0mR1pSpiRpJ59q6w0R07+zEz8Ue9thUjNEiNt1/at01B1mSb79qgb+CT16FSMig56fgahkCNznQlkJ+CuUfVNZpI7EXo+I2lAgVb2EIGfPkEZ05HfKTJmdIsQYldbPxMJFtkz5NogMESK7WLc0lorAfZAIe5imBkyErR983XGLBDIKB901H9cl94TV3zkcHIY7QYUMeN1DtlB5KfTQMwMoQG24El97409RvU6qaxVriudQdlqNhENxCFpPM2RoSp7pONnpDwofS9kMPQTvelBoexRLi15VRA02hVpwowSstnMVkE2OdygRylLIUlS8hwhw4NJ28EgWgQgLiFWQNEkPqLbAjl2kJAYxihFSIqZeIknSHab2AgYEBwYyK3nFOGtTINTVNgchWjlO5chkx9t1DF32i2uW/gRzOjpgqNkg3sg7xYs772S/eImrbre8bW8EOQWpKZ3Oe2G2nIWhcuTI0knhbPTQ26pjY59u2VN/Ij9YFYMFhsAsyOSM/jXjYwZ3eKIMaejGQWDQOabarF6KJA78WrDdU1BgVxmWCeGkNgDN91nN5x/Fq0Hgz6AYQ8sZEZpXxmmnYwofwzImlhECjt0HqalEjTxqY8LVCLk2QCiW7yRcqfNzkthwyIkAElvMP2KFIOZf6gkDGS1wBFootdSrBRg1klfcsa5ZpCQxh4J8ssQDghy2I7zSQQFissQTgjxqTkW4Fc4cwTl5QgXDuSShECkIiE1CWlI5JYfDpIOjlFfhvBAkMd2HCYTFGguQ3ghKKtMOODY4BLt5QgfDpSzgAJfjqBbOcJ3B9MfJml39JTnN53W4HxhW34bnDvCjviJ+mlHXxeOnwv0H6E4HoZ4wunBk06PuvgD+9ASP9SIlrogtMwFoeUjQC4rvMKZi1c6c/EqZy5eLRRojQtCa12QtE6U5OH1zjy8wZmHNzrz8CahQJtdENrigqJbbac5q9qYGUz1hMLHgmsMOpWuttZnncE7ZxDjyeREbZMMIFD/P4G7sqXcv+nkEYB4AkAxDu7OIASQbTAFrq48ggEB5cKvGL4tAi5UpC5T4YIxlFWb8Cww8J1mu1PHoNYnmyCNCzlHZHd16PliqULRw8nnMjhiqYifL+Yp1OoSg0IskirVxuwsiplpkdi0QrFdwhfxFTy+ReqQmvaDugQpBD832Zki0Weog26pPI5vTKC4wWSrsSjkSo3XKMSUQM1LMQj07MwcjtipkkiNGZJwKleq41n4psxMV3IOnWoxyGQSjlQqMStIkVol4RikUq2eh4vkydq4eF0mnc1nR8vFArlCLlcoOAwOWsVBrAP+x0b+IHQ2nbesWyAo5g84I5MSkxJRVNOraem9oFycmVka6U07KzShZRGGPwcUhs0/Q3XsX09p3AFVBWrsD9tV2fxUis+volSOqQ/oyBOB4h9aJRGXH635OhPetSNiyR1tkaQgFNpLcbPZKgKElcPWLksxxwSR/uJEqvL7pQofj2Fea94OaNiYAx1AKhobCP2lwi9ca0GomElecwzLlUAoeqDRMLUfQZjQVoQIhgpM2lMb+pjUAYSYJexdD1UY2in9PYLocUL/IXSiEvWsxvgctETRg4Sds+nyCJTMZKocQpKieYt36odTk49NrpTmrr79cGP35aQqz7RmU58wTWTpZcVZQqtwQ5FpDEbFCCt5IhcKKiwQQsMOngUjDQx1YvgQYbdl24oZPbBLGqa5VXd19akSfli4i1115djlASLT89Ad02EvK7mzkKrOdDAG89VALisHTboxQhxOMB2DpDx4m0/0KDoFouiJegJOku2e8q7yIakxmrDJKgix13B0u8DTCDaFqpEinGGzY/I7oV1rLRpoHRXg7qklBlLk3DJQRqlFkMydAZwb7CDtINf19llPTcNkIWrYjRyNWnfIsf8r1+AfESXJv+cPe3YzfDojdAsXtiKEM3eEzoCwJdIR8GH5jX2m5mFoIESoLBIqOmLzKJwtBdAyXBLBZrtcyWXDEhNZIZNHIRBGpiOtG1vbLatKprF8Gk7r6aMig408iCgVKtTIs0mwKYfvSUJ/X6Ozk3R62HbkM/BMqSJBvEAKynq5QxcQ9sc+8wgFM1/h7oVnVC/5rEB9MJjw+gMB9bNiJamQyTBJI80GCFOfK9xMb3BaaelKZ/NnokAfjNmeeZffAoTucYTRO/qMGZ+HtCmNCUdE4lMMgmt3V5WG66nRywq0BoSe9qoXmCYf80H5dMNRr8MSimUPVCxwVw0RKmcdP92NoMrQDFUzLyJF2Q0X8I3SOCuyNtVLH4OZwACdLAstjTzUeAxibw25YO0PEtAfQ7G8HuxiKmOcoD11UBofp+AS58cmtyN+h6l9Abh3ygQ7xCrrrcMhpuFDc19anCSMHQ4qZxHWFbBcNaCw7L0zltQVBGtxY6cWftgAwXneHCdgla4pK4Dqrf2qomjU5NbEfb8fYUDdOX/l3M2mRYRioFT76Ou0KNO6XGWzhHlLLJWVZtiWhPt5xkCEp5cJA5xMgMLYVrMQu2AeeabZWGWASqGI8i+2sDoS827oVeuUzMcbfuwKwgKbZHnkz4C7siofHFHeEEK0i7+uS9BeuBbDYFpHegOTSUtXO0rJAc28Wa7RJp0kCmHr+kDF7QPfItxuk5kjVwb2lMH9OX/5P5WvmT8/kar6/gCBzZTQk4uFU9NYZ1XOSePDE73osTck9XhsqP7PyDuoNevYiCzt0swpFiRC6La5DJ+2Xw1kEUUi4eUgTY/KlOrf1992f/KvHY330GX4XsjkGKmy64vF9gelrU0o/FfDe0Fxz7iLKzSYXolDmTtTktZU28by++yF4MwZ4ZbUNfD+T3/7xIxsFlnkI6vVLaleSnYxnSjjQZPKPaOiKWRN/yk96W0PFP7V/TSXBoo5EZ5Rfgkp74Pe9byGx780CcpJa3m53GrFY6UQNu05yCCYsoo6neBNB60MsrZMaPG1RewWtSFCHz5ZE/N7uZHETNFcpsihVCcIrE0YIY9pTSaoh8nedzqgPBuMgbuYMPCyVE+Dmnz8Iaaw+YyBTQhx4HGIkKvHbFw7Jd/30AF1d29dTEWU7jUEdQOGag35tdazAR6k3ovonaAi92cblgXatUiIMqxZJndnySfM8D3cfDA0cmeGpxYN6kfu6pMmNbbT+GIptyFG9P+u07FAKFaqAwlCsGYn2DnnDzfF0EhYeScEfJ7k8GcG840vc5xnseI0XNhU9tBIsc4tZ1+ci7yxJuFhwiG+3dC4/v7K/yFQB2x6L7zLxce/4JILt5iMM6D4D2zMCfEAOt6N8eOqhZNXVFxnqXaqAj+9JV/b/ILwRiLVd98VX3PMTfenWjtjquIX3yFg9zL9R1C2VOlGQnWFF3YuldZbLQiChOKdjPQM07h6OZMhShKKI1Pfy9Eq1rB5N97dvzZvhYE+Www2ye8U403Fzsmk0TinYC8gD98RKobnAq2oP+O8KDrmYSNRNHi1SP5BPq7FuyRSc92Qp/zNn7eqoJ2SF248h2HcDoAM6poPr7aRj5SLE1cGPjQCd8bk2o+CSfRI06tWcaiuRR9mEC+jVYCV1Ets5ItV40dhN+EyTXoVxwpdSRCQxidMYnf3WhQ9L8G/EXzbWhqpHQqBg43QYLy5o1W4JOw1deegJfeD/U6GO4TS7YTjmovQdZ1/SFZU+XRWaGtwnfBg7/r1wK9PWJJhxehbPCNM3CSccRvBHGFaXLGGoGvJ+5MaNFUMsFCDLo4gqXMGzEzNGQvY5fZLLKJBYvH09BP1uOXWT+Gy0tAUzTGNxSMKsl1C3KtYV3tmT8K1/huCsBOY5ldvsJGmYmbNUTSdsw0sukq4QIOxhiNIr+gQzIqQw9hfsMMYYXh43M/sQUsn7gRt6tSlVZ2GkE6cY10Uy53Tbk6ND8D8/nIKK+4mvFuusRWVBFvuzkjlUlcs6hO3uc8pST08QZCEiMmzt3e943710PQy3oYQKgBKITSNBRYXe8mRzMpKU6oM8mhN+f5bQoBp8hF9xuheIWSG+QQSLICqfUVHsKhnqSBs6RVn/Xv0SraVrjzfWQZAdhcvNfaNxj7FTQoPjiIubNzYf5iwOgJb5PJa422l3CUWFpiz6o21JZt+Cm+tDhznSTCjHXIAZLUAykp7lkwe/JQiuEo4oejM3ufQbUxTRZzvJplNNXCnlZrLqtp5MrqbNDlmA+v89GRTTzD5402syNv9K+icm3mok5Qpvq9jfif2oxtgKR6CRyqEqVswxweaWZqKTiqbjYaE87UxitGsMya4SeeDSie3mbghb4uqC3XVy1RfGt6CGXmmeu7U50KsLZUEoA/U0rJ276xkwQvJO0eUFyhqRTDt/IHiqPfmwgxsWDv0J3+djs0MjnPJS9E+Flo7o3HQT6vV4qTQYgyRMmCl9SBzeg2eawQqUFueJ3Z620AuvfGujlbd1SiG1PZJ1VnHyQHcasnMnQQyLB32mcTpkd/Bn7nx8sIQM5SVjxqpiOQJi3ZV56d62VwVq082bUYVq/y1cSJVDqwWYyUlT98oB9aZjmcL83fCq3ZtfA+nIa3+ECLdBIccRvC7usfb3MGUXEJRbXpCE4sT14WKSAgnH4GOiqeFPx7mO8O+41ZcW1WuoMgQQvRnN1/cO0khD0xRDEZDSZo9YfE7VLYzklI/IPfRahPovUuIIIJkoSETrmGzAsUJC06TSgWm3lnRfVYNPQZCXGoaOhOC35A1v3Pii2swO6xlcCxl2RvaIY1iv8kV26j0xfTdtr+cJj9F/h2doz1PKCa0bjGqNVk0Fdk8eEuCQoTAtYSLei07gd+BtqlbYrCxXs0A28FbHmFwuLRxf3K9eZ0V66yBvbc1XsEg7dGySrpP5xZlBVTd9gFm9v7LJPfbRj7nJu7Bnyn3ojzoHvgiXfmW0zkj2l//53/T8QFWjla9i9onQ2Q7fVa/uujVH9s8wtQ7ZiMYw6qcOjwxs+XHttOmn5bGU/Wtjmq9TIUI9HQYxRyb91472kYtM5fjvM8H65sas5Mwupe2+2kl24+hgpLiPvfde4TRvcm237FGNgs3jBw4U8Vdr8hM+qOdTM/v0Wo/phfPVD+uLUqtlaKbIC//QDUdJy/JxydM2FzNiDecRqYsK1s5iXsTQjNObigLe0+E2bPRIZbb3eOlxariyyoix8/luRtgleOhius2ztazh1vAtZrryPqUDQeg1TeRFRn8UveeaPwdOK1eBvmfCPORNtuqDP/G7ZPuU8uGdC44f83mg6n7oZzEFNFOOU85wR/zIYLzYsj4aumrRgP2BeNZsdSno1NMVBVlpIkKolxC26bzy9lWwoebHjGhgKYNzrVd1aRIrTWJEFhjgwUfVX6z9nad8Y+uiReLmLrxSU1pLlxWCtjxmgfK6+uBJCjNR4YGv+f5y7jKuNo4pRRvrut3bIHY6ymFCwq0w4l7Qrelu8IfUslcP+J7QKP+px40yGpJPkBufR23DCwnybx8pFxQw78PrBSEhAsAbN4KF+QDSRD/TFvIbxopbTd+sO1tAcIOGlIsuNePzylRxs7hCQQ7f/0POAILD/154/vxgK/j8iH1T6z4A16BVCdhM+sEPutfCCrqgkw442CTX3AKgo/lQswXARmvfx+Fqmpj6SkN7HsMz82eef7cUQH8A2P+1nMSkiomWO3a5iZtO4sooUh7v3hSxKmRxL9SdVEs2iAWHE3VvBi4r/7Z+oPXICHquxS0raz576mdl7xnbnEe87V4vbS3xfcYTTkEdS8U9LQVKj78frJUzbB5XtzYWW3bHyVw6J+e6wx8JmV7e9eDEHjHqM2avftcb+Wdj7rjfsxnhcz071WJDXBZb4hbrsynv0vt+HM91RBfVlLZNhzGf2RWaUYtabJmCO78KGIn1SWflyt/zPMV3ciOL/1lmGVIPs2OOH6HYv3fol0FG46s1X07tGdI9/2R1RsgYDR0I4yHm8aIx5e1ZC879DDm+1pnNGzsIH6774YNpOYOgwRmXF1yICtjyeGrCBO7eVmilsX1ShmQYhRyjtPcaXVQrV0GDRvAqHGZ9mZOc+lzDa88pm0Y5ll4DXFES4nJ+2zPYTl/KgXGXbuJ5dr4h4ndu4z+UrUb7PFPfFgTf+yZ27MbcLDIFuW2COdT/RQ11vhqO0ep4rRfbRyjp7B3dhuc65x6L3ADo5gGXsrCWOef4h4RBhPE6F4JlP9HAwMuI2I7Xacw5vO51cZidTurMywEDGRS70/r2bwprUfvRyYZQNgr3wC1V1tHh7MNiZ57kZC2Sw78OFTJ87r0iji9i+eFKnHgl3eK0Ar8rSTtyfBv22XiFkv9Tz/BF3JlIkK3kI60IcJvVzmYthrCaq14FCt/LyPVb2VHvOy4Si+bUT/p/k2Stjx36Q7Hh15FyVhR4J8d3vS9roF2dJ2aBpg2aqSJeC1RLqEfuwRMY1wy/chd/vwrpzCPMmGnkYg8qHiIe88+DH2guHioq6+2rr01Z27UsnR4+dhYXyy9CUH4FUgaA/0y6KqG0zpyc5ZU39pVWZCKgv3Q02UY45rBZ1SmpRO0kbIkUEaaSE8bH6eNNGEyS9++52TVbhSZEUrY/rHy7jTBva8ojb43xfeBE9lHina+XQjwPkW1q2MUc2TRRlqqUktpI93RHgzAsfKIojlwaPyXf9t83g4+8msUYzX9Qifbs9SlFZ2P6FK/WPUbJiMCTWnUAslEWahG+9fHQor2nGzodDDW3TJk+guwbk63vLDkvVRlTVnR17uX4aV6811egnv3UUUp5Rv9MOuHD9O6vXkN+A02N+FRnYiNbez8o6ZdArbE+wGTjBppIpegjZSD3QqSnqYl5VKVInnzle+YdgttwnIYLV0d7cnT90tnanxmxRNCWkjObPcU3v7k09sreyxRHfjAna8sTDzeqrqeet2etdmeeqLRFTxJLY8PdziDqsyDHWG2cuU3D7BH9p3pfFaGpObcHqjyOxsD/3ylrsrX0yf1KKMrz+b5xsMIWqC0zfnJKUJX+MhoEQvjo6wqmA3kmVf6yvufflZPzGdNyjjEJfxWrs61rhJ4UwU+HU0bnJijTN/hxu1KT/GL1ujn5LxFl5Tcc2Cao/7nyKccjYB43FWK4+xHEKfsxjRd9JNrOMMl0lYj+MNhc2xBfyhWnB7xiMJKVF/7qiXhVGUC1CMtD0fFfSNTz+/GAwu7UcZEiG4VP209dXZ+JhKUyp3T3fwkeuTUFwNZnLizV976vKXaWbqajOy2qoZlt/jr+zYvKXjues+K3Vjc6IJ2VikLD7Y+I/5dNDEi24/rZ6kdVMdew/URllSqc6fSFXem/f8DC9a1iXYT0avmWxUbeOw3hl13nX86/La42IPJVROaxk7L0kfb2vBFwNW1MppOHjgGpGXs5upiT1HhpdcPatcVn3iqmffzI4MlLfkgcNkVWPO032o2LLrFSNq96XRMmVazuKUEFL3Fvpc9Nz93KlYiInyFbPIgxnzoMYMPYWz8851Fif1Ni39oXTKQ45Ne1cWcQhF1NwLjnSiqWFEkxrjuHYzZojaJL1Mapf/Y1vu28384vqJkqBCEvsmPgvkJmWhtun20cBiXLmb8DIvxaQZERAkysks/fN9aFk0nHwqjkCZeGi0GebksbLoYFCp2Me9at75kirjwslm/bh77P3uY8WicemvoxdasYTLUTZZnO7prsZz7O87Nzg03J7+JQik0+ZjByUD/84e0mf2tS79rW9rvuA92u0zeSl6K2Liqus/gFOrE9ELHolms/vC7Suh2qjCxbJn2BwEld3lB5eT7tC2btZu38L0WVtG5cvIPyzRLUU6yLYxzMDzYXhxtK7bcQPH9h/UnT/3mj59yoUwGQWOXZEJZZkZ0+P43TPB3/zbU7+q27dpbK6PpQmsSLW2WbwCbdu0QFYUXgftuO3Ky3mdBBFRZXFhYcOEke9SIfblI+uXOeC3hM9LXrgAqQY5qsWjVWkiTDSHzi5/CWna2s8PXZAiMSEJXm/79YeXvT5WEaJVI6RtgmFKUv75KXQQyxW6U3sBa5qu+Cp7fA0H/Y5fuhBaeVc/emmj5G9s++rB4FIYxWujlc9FFucNrP1vaveifwZ+gURih2nueylarBB7CsL13T/G35Kbmb6d+k66bHlb0ff7no8LLR/yxwiuHG9o+loYubklNDOrU3UgfA+W6cW4LnDoKpKe1F86eU69tBBWDgzZeYIPx+0xrzm/ZVQcyr1OOFJzDOpVPPlhUl3G6o7DTgAllAT/dcj+0eLa63cFsxQfcyl//bRxa0WqtendNfoCT7y17/rYAzqiBDJgAW8XS8MxM1hpywnDF2BDNyx/vlWDLYkyvUi96OHqXwLzwumV0gb2acCQW0mOPaAsMTO54BbAP7ekylO0q2dm4abN0bhfYuVtOtGR/FikC4efzi0DLTTyls7tKhDy7e99LyivXKjLZTSi/a+2FlVlRSQKGwXT93pcENKndRa7rjlEVHSJqF4cHl46MJ5iquMXWJG/u2ocfPFcoTsB8j5AJFuB3M6lHponi19R8gXUWDARC9WvFxDRC3D+uJOJ5UXADsA5YX4IfkMWP5o6IatLA91/Im6W0zTXuC1ZJ0JKl4HMW+cZ/v5kvNvRh1lkqNY3qmDeWvFPx49FsWYu89B1oroO2J+ukUuatcdGdG/cfuFN0a5wpxXL1ZxIFzEJVlbf/TnfU479nfnk6dS3EbUMgbj79d8rlutkAmZ0Vdd9J3DuGStNJl54MzKannC1O1LP1Kwq1lqmcrl8n2Xn3zO1Idz4V4jRjspGayH/FezscZmzw6wjUu6N/j5iABZ+hjFdFBFug50w/0bXyVKB963H9/S1Rb56Sw3Sbuna1bYH/LJVAKJcdCoLrEyVjn7YqZ5aKRDu2L/uzYKTLf9eGrzgIZp4j815t7YQfHLi/iAEBGD0c7TlWeeX+Vm8a+bMES122ZHbFBbB8+VoGmQxNdCVIly5bdXnVJYmYKcQO58MwwVd+oWdH08lvv6GHvpPDEpKAH/q5cknVYjESh/MQh7uc0MRLaSP92++NxaQGQvLwrw/+iHV/TdU2rVvKJY6ZtVla89iHsa6pJiLRyZqY/Jphijr9jdpr1TaSDUgdNYWJ26DKMASM5KGQacFqoSgtVQg6VlTXHCKNIOrHfPop6pcnhto5KiWnveWJX+gpzOu232up+PYkstuCl7MRFNYLaWGpqe2KeD1+YCqI94FNQS2IiUUrK6xWT1kdbb1w2Ud0M/jsE3dp5LprA3iSnO2gynmpuJeVV9djpFOuphuWbIXSe2MCLF7/TOz+b3/MHfvO4gn/Vx59xZxDnseNn3/0sghuYRYY7gyYsMWdSeX0P1/prQq7+X5LfK6Qfp8pYRd57WfBKQXMrEZReaGu7hus3fJ4qPazrGXHo+kPeoJrpybH5c1SqiYNvxmT7dSUKmqxVf56MyFl4vtQZUBJJ+Oazz65yRdZh+6VXTHvp7dsQYxxXs2stTzkjvlOKWCsHEF/KzPWLV8z6ZujG+yakf1H0NO4elr6I8WxZdWo+7fi0BD2EZqUcDpAOcVBXHfgxaTkRwieJ96wz/bWPp3m5MnIKk2eeZOefIiVgOmtD7xa0zyfmd2id8UimGw1sqfnrXlv7V/O5lBIhSY2ROs7wVAhs8j+SlRO9/rKMRE15tMU6AotSe/WPacxOBZsvSeuamFa5oYUc4MrLckVP9OdUPNWRMmtPz/RUgXK6UXsZ9bnlraFQmml+LHDqi+JPZmSNsuPgONotE+R6EpFV6+QKMkZAJqN3ozNnRFOCTshC0PJxTUJ2Zn9mdlSA3T3bRyf5hUyOwW2aTMSb56b4KZLc6W08b0Qsx3dp7Lclc965neIrAk17gtClUGpbg34BRevX1/w4U0mIvJCRjwXWY40Gaktex84+QDtOft4a2Z6+T4e03DsMFS6sHpiiRgT/TLEUnB0yneEeVWeWEVnZU42b7dROBZLPSzQoMkVwp5cnRUd6I8rtGTFusPBtGbs+GFF7cAxcBzdYXWcKkhWP/sa61BZXZJtXTxRgbnnPj+B8mXvsHwp9b5vMsy6YzER+6dvJnoWDzBFyauekn/0zdTPRtmRQIkq76NjRdln/gvYrIH/zuA+dlDV1kaxlyrL6mzJdLBx/T1FCKUrWHBo7TMHNHM5a0wbf604b6QOdJQETcW48es3TwvhadTPP8hVccYo9Ycm22AOwqxxx4JF9QH7ms6Ur3JjnI35aRkp9rpXr33/IoGnzpXVJVoVWTmNusf+TwU0g2BTXet3lRdlhNH+XhMu89tR2qauJ2NCmu8rdPsrN1Vnezl3jcjicR3e+bLDGv+ITMVqL+L2F8TSVw4TFUkNpQm/o3salhBLhb0GjB5RuhUykULsRqLpwqQECaNOJ5WBXHtkLIPqXrWs7KKg/K0px/C6HZhRt1ZXZKx1/d6Ru2oYO6ikccFkffutYOJx18PgWDRdaE9GjSL3gEcyliYRrZ4/FWDr5hhnyfaKbPvHwYYpTjMvRSiThQrMykJEiMiX5d+ZuF67oGhfB50oFD5ZS8CsnOfjW+Jb7+6gcvOojrufOWcYMY7HVWEXnksUYD2bTHsDUY9v/smBenmLqieDzU3WTMobU8c6oolJ0cBeU89GhiSdJG1/Lwmyhj1fZZx0Us+nF0og0zbzZsm+MYcJO/scm8tI23UOGhqOdoq3v7ifZ04ZWfNx2OoXi7edeHJh45KuPcBJ3hYzICSyoKQdQAW1hY0SMSa4QTq0queFj6w/EW6H2/enY089lyhGi7+J/Qs7S0J//awMl7IaGKxPOq+bLSVb79za8EbDTZyHk0m76ND070lDxhYLBkEcd+rJp017xxxmjDNxJ8STV7I06gfIYrql67yCqII+NkGnIJ7KqTRO0Y8+Qh8wEWHR7YIW7Fp1NSMtt8TJf/3zolm+PJNVebjDJt3VkOVLjqvunv/9HwFejY3M0U6qIRcSMOR3/gYaf+xYnyFxSJpesMru+dThSImizXKJzJS+qANK/OGXWfziUkUNchV1Pjxiy43wh/Tub0eSOWf1jpdI7QfyuCs6A545BwL+ZRLo6EYS6NXTxrRTkQkRpMe2zGINOwI6vUEXYyLx4Zap2zE36TRgqY8kojuD9T+DM7YzW+oijNg1rWFvPhuPZmkmHCoKNYUN20LVsZ/QgDA1TShasNq08CkYYa5is9mrmDCMvbbX4Kxy6i+D/ipIIk5imVDwGHZy3mrKj8gWFpUURmRBi0X27CYG8qOhuMjwI8LYdA57+YywQxQTuRGCiTPECc1En7mJkBHSpl/pVOxXE92Ia/NjM0RjFv0N0G/g8pbCSDkI+KtRzEwnBIQi0qjznWHU1cTrD0TTyRVLwu5KlFLk1bjYbrNQWA1obNksHc6K3v3ZNEr0qAkpl5MYCYRjpbFwIJLI4UoJpWwA/rxuXWPxo3UvFEFzsxDIXFtx6TjuiU32Dk309g/01402rVu7pWz3QvaQsNrzNaenb0v9ZqSJ+sZ9RpKV2KDJiz7d1qSBxcbmprn6eH0EWrfPfK6Pw99QAVlTybF9abbDERmrilXrOh/85x7p+/Q9DuNrFRv4nHN95n3YSALxCuR9GZLxhOc2MQkzI5pOqlU92htNRJSAGDOfrSZv3vjBDEZuS3njpLDDF+xORqNSuewpyEDehGSsq1nnUjSa3mjQgfxy1Ez4jMNsA4F5mMjOyuxqpBKtRLqOXhqAFZwfMGokdf/A5QD3qlkm6aJto5vgD5dvqu8Udxs50XSyLft8YQxwB+GLL08KOFnBcqya+dnDktQupIbNV/wY4OvDotMiu6hwcfBxY+eVrlTJw5+1HkPhNwgF0CNjvCfOD/zO4AUw2AoxcASfWEayXWb0GFY7J6RShP0GsxmBHC3wa3GqR7VEc6b3lUke3OKAELN5x1TqBw9LQIW7Gr0Zprpte/miu4RoAjOKfW6DUNlOPe3J01d8PQz+fZwbKxK32i590IiH2E8Myw1XNLqDQ8lVoIAfVd1/OHFvFWaxMPx+zMRbT+pVj+fiIFyVPHTIAF/5jMqa1x0YBDFQWMQrvsJjQp+Dz6LpMv640mb5x+Cz8ov8xjAoBLFBjv8rB7Z1rDZWXGFccyipwRR76UOrbj+9ZAKYxvgk4TNGJeiQKJLq8pddz6iKSPXa67Zd0RRPZo/f801BejgtDCKiIVSyj5DofgbGckLsbno0Pujq71ToKssLMfW6l37G+FxLb5iimdgrsaoLleuqump34cGjhxUYdtbpXNjh5cvsJL9Ez18n8E/FeeDu9fMzEgzAO6vzJjUXeS0dWqgHS85WxyJhh68xvpdb6M9LNWvkAhxiROu01pflJ4LRWS4CqRb5MPIgTIBRwQwdCM9GDDisZfOJKi6AV1TBmCLuUAo2lYvSszu02ERRCWyQpgBrzqalJOqlMLKUZqSwIG9eymfBTYZSpCQ8FChnglqgcigec8yRxIE+xneaNSqMszA45CvkOMYJO7VyJg7cpJbkIC7XVaCI5epAoxdFEnxUaRQSxDpMoulYRlo8AxcpMcZB6SbEgZAFMJmLRggt7FtSSK9eLjp4855UswRTmTQ80GFDN5TFIIFUkjEeTnNwVp6tLKRzbJBETOLaxHi+Jp12UgPiHhWGIixVySMNkQGUWReHj9kscSgUSSEm8ZDiitBA9NwEF4E8gGyAalYnCqJ0JbddRTBJdqBbApS8VwDJDFeIAZcBgohhBG/MqBRiE1Qi1qIX3mw9k1KAMyC9AlSrMN1GCkGEAg2CjmTmtl9SnJOtg0nujaOZ7/KAHaEXLvpdjfzrGAMQUHzSW19rV7Mg5z8uQL4AAFi2cuxq89ZD/2NdEfwdAHAwANauToyq64oLCW/QYm/qLfEXp50GHSb89dXQHRgoO1Pbz1NmVMcAnpYnJU6RPKTM0FaOv9UEl/2DgNsEBLlslVAMNrCDVkzD7oKgZJN5ezGF+z4k9TXUY1d7UzKvEdwumt6fjqYIVLYZe/0TxoKyvb1uXCXntkcasoGSBIjmMlUnAHFsMg3japon1aCsLK7MeuIDeBhoi5KWL5nEWlP+B/GJAE2aRW781ABgT3x/CUvkXV5aawepW4ESkJIGj41xe+59YvaRyrXu/EJZX4hjKqwm72lQVucvoKy+esB572a+tBWPsMNcmhdoR9rMhut9PwuokwG58fbLaTUgt6Ylppvt0hs9S7IDDJ5GStIG9AAAaEf0Xny7LUz3XrHUGEZdGABxtk+QI1yQrmUZgYA61lV4J1AFiXdnFQx3tQoR9mwVKiHCKgZfMk5jW1W8GoCWfC2fu33Bb9CQxUb0WKDbGFKCdolsnBxfmyk5YopWkwI6jcJ4QENMS+jkdsu2QAqc+9mxUYspbsjgorK0IgJtWnXQbL/Fii6o8Gs0ix3yKEunu7yLz6C+Ng5x/oAxf8QCnQRi53ufLCRCS3J4PBCpWpIK7qCh2A1nHzy2cNcjHmczqHtpHpAtiwBPM4OdS6Lq12ULCcPmmMhm7fq1StNtIfOkG9LmP8mVeD/7kTX3As60BntJjQ27SXo4WVK5JNKSF9nhDuRN1iaVatV/tNuj12bZKrQ+O2rMsQO6eGKBkWbykPuYVCOMECGPa+lAE5KVdBqaAsXcX2YIthf1bLEx2A7xIprsrA6mnCW1WiRMjz4LbbTcpYu0klladNBgs7DvSBMPAad87ah2+drlMRA7Ma7sU/q5n6JMSDE8CEsv8v+1wCmw9N913p/Y/cqCY2Hj4OLhExASEZOQIsjIxVFQUlHTiEfSMzAyMbNIkCiJlU0yuxQOFCcXt1Rp0mXIlCVbDo9cXjSfgKCQfGEFChUpVqJUmYiocjEVKlWpVqNWnXoNGrUGBjustd0H3gwC3nIrKHjXe973tg/DgDCICeEQC2JDHIgL8SA+JACnzTrjrDnzQ+MDPQ4H7WiOcbrSm/gzGfmt/f2tkzdyZboZFd2dY61YcZi/raMVrumBIz2MWM+C7BtXDo329A0OIJHuHiRy8qfnSWeCog/w7Jk9BUE7zmeg3y3Y3Z8CzL3ZBABL6maeV+ECFGaHJ5swovKx9i4yAQrAOIQ4JwMvb9FPgACBRyO06bRmxrupJkQdJME4hwMfds1z1SlLGHMBXwXqWoa3V6xC2vu8Bhd1MD/pA/p//Qy6/RGeEp8ZHRgI7AMA) format("woff2");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:KaTeX_SansSerif;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Script;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size1;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size2;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size3;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Size4;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:KaTeX_Typewriter;src:url(data:font/woff2;base64,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) format("woff2");font-weight:400;font-style:normal;font-display:block}.katex{font: 1.21em KaTeX_Main,Times New Roman,serif;line-height:1.2;position:relative;text-indent:0;text-rendering:auto}.katex *{-ms-high-contrast-adjust:none!important;border-color:currentColor}.katex .katex-version:after{content:""}.katex .katex-mathml{position:absolute;clip-path:inset(50%);padding:0;border:0;height:1px;width:1px;overflow:hidden}.katex .katex-html>.newline{display:block}.katex .base{position:relative;display:inline-block;white-space:nowrap;width:min-content}.katex .strut{display:inline-block}.katex .textbf{font-weight:700}.katex .textit{font-style:italic}.katex .textrm{font-family:KaTeX_Main}.katex .textsf{font-family:KaTeX_SansSerif}.katex .texttt{font-family:KaTeX_Typewriter}.katex .mathnormal{font-family:KaTeX_Math;font-style:italic}.katex .mathit{font-family:KaTeX_Main;font-style:italic}.katex .mathrm{font-style:normal}.katex .mathbf{font-family:KaTeX_Main;font-weight:700}.katex .boldsymbol{font-family:KaTeX_Math;font-weight:700;font-style:italic}.katex .amsrm,.katex .mathbb,.katex .textbb{font-family:KaTeX_AMS}.katex .mathcal{font-family:KaTeX_Caligraphic}.katex .mathfrak,.katex .textfrak{font-family:KaTeX_Fraktur}.katex .mathboldfrak,.katex .textboldfrak{font-family:KaTeX_Fraktur;font-weight:700}.katex .mathtt{font-family:KaTeX_Typewriter}.katex .mathscr,.katex .textscr{font-family:KaTeX_Script}.katex .mathsf,.katex .textsf{font-family:KaTeX_SansSerif}.katex .mathboldsf,.katex .textboldsf{font-family:KaTeX_SansSerif;font-weight:700}.katex .mathsfit,.katex .mathitsf,.katex .textitsf{font-family:KaTeX_SansSerif;font-style:italic}.katex .mainrm{font-family:KaTeX_Main;font-style:normal}.katex .vlist-t{display:inline-table;table-layout:fixed;border-collapse:collapse}.katex .vlist-r{display:table-row}.katex .vlist{display:table-cell;vertical-align:bottom;position:relative}.katex .vlist>span{display:block;height:0;position:relative}.katex .vlist>span>span{display:inline-block}.katex .vlist>span>.pstrut{overflow:hidden;width:0}.katex .vlist-t2{margin-right:-2px}.katex .vlist-s{display:table-cell;vertical-align:bottom;font-size:1px;width:2px;min-width:2px}.katex .vbox{display:inline-flex;flex-direction:column;align-items:baseline}.katex .hbox{display:inline-flex;flex-direction:row;width:100%}.katex .thinbox{display:inline-flex;flex-direction:row;width:0;max-width:0}.katex .msupsub{text-align:left}.katex .mfrac>span>span{text-align:center}.katex .mfrac .frac-line{display:inline-block;width:100%;border-bottom-style:solid}.katex .mfrac .frac-line,.katex .overline .overline-line,.katex .underline .underline-line,.katex .hline,.katex .hdashline,.katex .rule{min-height:1px}.katex .mspace{display:inline-block}.katex .smash{display:inline;line-height:0}.katex .llap,.katex .rlap,.katex .clap{width:0;position:relative}.katex .llap>.inner,.katex .rlap>.inner,.katex .clap>.inner{position:absolute}.katex .llap>.fix,.katex .rlap>.fix,.katex .clap>.fix{display:inline-block}.katex .llap>.inner{right:0}.katex .rlap>.inner,.katex .clap>.inner{left:0}.katex .clap>.inner>span{margin-left:-50%;margin-right:50%}.katex .rule{display:inline-block;border:solid 0;position:relative}.katex .overline .overline-line,.katex .underline .underline-line,.katex .hline{display:inline-block;width:100%;border-bottom-style:solid}.katex .hdashline{display:inline-block;width:100%;border-bottom-style:dashed}.katex .sqrt>.root{margin-left:.2777777778em;margin-right:-.5555555556em}.katex .sizing.reset-size1.size1,.katex .fontsize-ensurer.reset-size1.size1{font-size:1em}.katex .sizing.reset-size1.size2,.katex .fontsize-ensurer.reset-size1.size2{font-size:1.2em}.katex .sizing.reset-size1.size3,.katex .fontsize-ensurer.reset-size1.size3{font-size:1.4em}.katex .sizing.reset-size1.size4,.katex .fontsize-ensurer.reset-size1.size4{font-size:1.6em}.katex .sizing.reset-size1.size5,.katex .fontsize-ensurer.reset-size1.size5{font-size:1.8em}.katex .sizing.reset-size1.size6,.katex .fontsize-ensurer.reset-size1.size6{font-size:2em}.katex .sizing.reset-size1.size7,.katex .fontsize-ensurer.reset-size1.size7{font-size:2.4em}.katex .sizing.reset-size1.size8,.katex .fontsize-ensurer.reset-size1.size8{font-size:2.88em}.katex .sizing.reset-size1.size9,.katex .fontsize-ensurer.reset-size1.size9{font-size:3.456em}.katex .sizing.reset-size1.size10,.katex .fontsize-ensurer.reset-size1.size10{font-size:4.148em}.katex .sizing.reset-size1.size11,.katex .fontsize-ensurer.reset-size1.size11{font-size:4.976em}.katex .sizing.reset-size2.size1,.katex .fontsize-ensurer.reset-size2.size1{font-size:.8333333333em}.katex .sizing.reset-size2.size2,.katex .fontsize-ensurer.reset-size2.size2{font-size:1em}.katex .sizing.reset-size2.size3,.katex .fontsize-ensurer.reset-size2.size3{font-size:1.1666666667em}.katex .sizing.reset-size2.size4,.katex .fontsize-ensurer.reset-size2.size4{font-size:1.3333333333em}.katex .sizing.reset-size2.size5,.katex .fontsize-ensurer.reset-size2.size5{font-size:1.5em}.katex .sizing.reset-size2.size6,.katex .fontsize-ensurer.reset-size2.size6{font-size:1.6666666667em}.katex .sizing.reset-size2.size7,.katex .fontsize-ensurer.reset-size2.size7{font-size:2em}.katex .sizing.reset-size2.size8,.katex .fontsize-ensurer.reset-size2.size8{font-size:2.4em}.katex .sizing.reset-size2.size9,.katex .fontsize-ensurer.reset-size2.size9{font-size:2.88em}.katex .sizing.reset-size2.size10,.katex .fontsize-ensurer.reset-size2.size10{font-size:3.4566666667em}.katex .sizing.reset-size2.size11,.katex .fontsize-ensurer.reset-size2.size11{font-size:4.1466666667em}.katex .sizing.reset-size3.size1,.katex .fontsize-ensurer.reset-size3.size1{font-size:.7142857143em}.katex .sizing.reset-size3.size2,.katex .fontsize-ensurer.reset-size3.size2{font-size:.8571428571em}.katex .sizing.reset-size3.size3,.katex .fontsize-ensurer.reset-size3.size3{font-size:1em}.katex .sizing.reset-size3.size4,.katex .fontsize-ensurer.reset-size3.size4{font-size:1.1428571429em}.katex .sizing.reset-size3.size5,.katex .fontsize-ensurer.reset-size3.size5{font-size:1.2857142857em}.katex .sizing.reset-size3.size6,.katex .fontsize-ensurer.reset-size3.size6{font-size:1.4285714286em}.katex .sizing.reset-size3.size7,.katex .fontsize-ensurer.reset-size3.size7{font-size:1.7142857143em}.katex .sizing.reset-size3.size8,.katex .fontsize-ensurer.reset-size3.size8{font-size:2.0571428571em}.katex .sizing.reset-size3.size9,.katex .fontsize-ensurer.reset-size3.size9{font-size:2.4685714286em}.katex .sizing.reset-size3.size10,.katex .fontsize-ensurer.reset-size3.size10{font-size:2.9628571429em}.katex .sizing.reset-size3.size11,.katex .fontsize-ensurer.reset-size3.size11{font-size:3.5542857143em}.katex .sizing.reset-size4.size1,.katex .fontsize-ensurer.reset-size4.size1{font-size:.625em}.katex .sizing.reset-size4.size2,.katex .fontsize-ensurer.reset-size4.size2{font-size:.75em}.katex .sizing.reset-size4.size3,.katex .fontsize-ensurer.reset-size4.size3{font-size:.875em}.katex .sizing.reset-size4.size4,.katex .fontsize-ensurer.reset-size4.size4{font-size:1em}.katex .sizing.reset-size4.size5,.katex .fontsize-ensurer.reset-size4.size5{font-size:1.125em}.katex .sizing.reset-size4.size6,.katex .fontsize-ensurer.reset-size4.size6{font-size:1.25em}.katex .sizing.reset-size4.size7,.katex .fontsize-ensurer.reset-size4.size7{font-size:1.5em}.katex .sizing.reset-size4.size8,.katex .fontsize-ensurer.reset-size4.size8{font-size:1.8em}.katex .sizing.reset-size4.size9,.katex .fontsize-ensurer.reset-size4.size9{font-size:2.16em}.katex .sizing.reset-size4.size10,.katex .fontsize-ensurer.reset-size4.size10{font-size:2.5925em}.katex .sizing.reset-size4.size11,.katex .fontsize-ensurer.reset-size4.size11{font-size:3.11em}.katex .sizing.reset-size5.size1,.katex .fontsize-ensurer.reset-size5.size1{font-size:.5555555556em}.katex .sizing.reset-size5.size2,.katex .fontsize-ensurer.reset-size5.size2{font-size:.6666666667em}.katex .sizing.reset-size5.size3,.katex .fontsize-ensurer.reset-size5.size3{font-size:.7777777778em}.katex .sizing.reset-size5.size4,.katex .fontsize-ensurer.reset-size5.size4{font-size:.8888888889em}.katex .sizing.reset-size5.size5,.katex .fontsize-ensurer.reset-size5.size5{font-size:1em}.katex .sizing.reset-size5.size6,.katex .fontsize-ensurer.reset-size5.size6{font-size:1.1111111111em}.katex .sizing.reset-size5.size7,.katex .fontsize-ensurer.reset-size5.size7{font-size:1.3333333333em}.katex .sizing.reset-size5.size8,.katex .fontsize-ensurer.reset-size5.size8{font-size:1.6em}.katex .sizing.reset-size5.size9,.katex .fontsize-ensurer.reset-size5.size9{font-size:1.92em}.katex .sizing.reset-size5.size10,.katex .fontsize-ensurer.reset-size5.size10{font-size:2.3044444444em}.katex .sizing.reset-size5.size11,.katex .fontsize-ensurer.reset-size5.size11{font-size:2.7644444444em}.katex .sizing.reset-size6.size1,.katex .fontsize-ensurer.reset-size6.size1{font-size:.5em}.katex .sizing.reset-size6.size2,.katex .fontsize-ensurer.reset-size6.size2{font-size:.6em}.katex .sizing.reset-size6.size3,.katex .fontsize-ensurer.reset-size6.size3{font-size:.7em}.katex .sizing.reset-size6.size4,.katex .fontsize-ensurer.reset-size6.size4{font-size:.8em}.katex .sizing.reset-size6.size5,.katex .fontsize-ensurer.reset-size6.size5{font-size:.9em}.katex .sizing.reset-size6.size6,.katex .fontsize-ensurer.reset-size6.size6{font-size:1em}.katex .sizing.reset-size6.size7,.katex .fontsize-ensurer.reset-size6.size7{font-size:1.2em}.katex .sizing.reset-size6.size8,.katex .fontsize-ensurer.reset-size6.size8{font-size:1.44em}.katex .sizing.reset-size6.size9,.katex .fontsize-ensurer.reset-size6.size9{font-size:1.728em}.katex .sizing.reset-size6.size10,.katex .fontsize-ensurer.reset-size6.size10{font-size:2.074em}.katex .sizing.reset-size6.size11,.katex .fontsize-ensurer.reset-size6.size11{font-size:2.488em}.katex .sizing.reset-size7.size1,.katex .fontsize-ensurer.reset-size7.size1{font-size:.4166666667em}.katex .sizing.reset-size7.size2,.katex .fontsize-ensurer.reset-size7.size2{font-size:.5em}.katex .sizing.reset-size7.size3,.katex .fontsize-ensurer.reset-size7.size3{font-size:.5833333333em}.katex .sizing.reset-size7.size4,.katex .fontsize-ensurer.reset-size7.size4{font-size:.6666666667em}.katex .sizing.reset-size7.size5,.katex .fontsize-ensurer.reset-size7.size5{font-size:.75em}.katex .sizing.reset-size7.size6,.katex .fontsize-ensurer.reset-size7.size6{font-size:.8333333333em}.katex .sizing.reset-size7.size7,.katex .fontsize-ensurer.reset-size7.size7{font-size:1em}.katex .sizing.reset-size7.size8,.katex .fontsize-ensurer.reset-size7.size8{font-size:1.2em}.katex .sizing.reset-size7.size9,.katex .fontsize-ensurer.reset-size7.size9{font-size:1.44em}.katex .sizing.reset-size7.size10,.katex .fontsize-ensurer.reset-size7.size10{font-size:1.7283333333em}.katex .sizing.reset-size7.size11,.katex .fontsize-ensurer.reset-size7.size11{font-size:2.0733333333em}.katex .sizing.reset-size8.size1,.katex .fontsize-ensurer.reset-size8.size1{font-size:.3472222222em}.katex .sizing.reset-size8.size2,.katex .fontsize-ensurer.reset-size8.size2{font-size:.4166666667em}.katex .sizing.reset-size8.size3,.katex .fontsize-ensurer.reset-size8.size3{font-size:.4861111111em}.katex .sizing.reset-size8.size4,.katex .fontsize-ensurer.reset-size8.size4{font-size:.5555555556em}.katex .sizing.reset-size8.size5,.katex .fontsize-ensurer.reset-size8.size5{font-size:.625em}.katex .sizing.reset-size8.size6,.katex .fontsize-ensurer.reset-size8.size6{font-size:.6944444444em}.katex .sizing.reset-size8.size7,.katex .fontsize-ensurer.reset-size8.size7{font-size:.8333333333em}.katex .sizing.reset-size8.size8,.katex .fontsize-ensurer.reset-size8.size8{font-size:1em}.katex .sizing.reset-size8.size9,.katex .fontsize-ensurer.reset-size8.size9{font-size:1.2em}.katex .sizing.reset-size8.size10,.katex .fontsize-ensurer.reset-size8.size10{font-size:1.4402777778em}.katex .sizing.reset-size8.size11,.katex .fontsize-ensurer.reset-size8.size11{font-size:1.7277777778em}.katex .sizing.reset-size9.size1,.katex .fontsize-ensurer.reset-size9.size1{font-size:.2893518519em}.katex .sizing.reset-size9.size2,.katex .fontsize-ensurer.reset-size9.size2{font-size:.3472222222em}.katex .sizing.reset-size9.size3,.katex .fontsize-ensurer.reset-size9.size3{font-size:.4050925926em}.katex .sizing.reset-size9.size4,.katex .fontsize-ensurer.reset-size9.size4{font-size:.462962963em}.katex .sizing.reset-size9.size5,.katex .fontsize-ensurer.reset-size9.size5{font-size:.5208333333em}.katex .sizing.reset-size9.size6,.katex .fontsize-ensurer.reset-size9.size6{font-size:.5787037037em}.katex .sizing.reset-size9.size7,.katex .fontsize-ensurer.reset-size9.size7{font-size:.6944444444em}.katex .sizing.reset-size9.size8,.katex .fontsize-ensurer.reset-size9.size8{font-size:.8333333333em}.katex .sizing.reset-size9.size9,.katex .fontsize-ensurer.reset-size9.size9{font-size:1em}.katex .sizing.reset-size9.size10,.katex .fontsize-ensurer.reset-size9.size10{font-size:1.2002314815em}.katex .sizing.reset-size9.size11,.katex .fontsize-ensurer.reset-size9.size11{font-size:1.4398148148em}.katex .sizing.reset-size10.size1,.katex .fontsize-ensurer.reset-size10.size1{font-size:.2410800386em}.katex .sizing.reset-size10.size2,.katex .fontsize-ensurer.reset-size10.size2{font-size:.2892960463em}.katex .sizing.reset-size10.size3,.katex .fontsize-ensurer.reset-size10.size3{font-size:.337512054em}.katex .sizing.reset-size10.size4,.katex .fontsize-ensurer.reset-size10.size4{font-size:.3857280617em}.katex .sizing.reset-size10.size5,.katex .fontsize-ensurer.reset-size10.size5{font-size:.4339440694em}.katex .sizing.reset-size10.size6,.katex .fontsize-ensurer.reset-size10.size6{font-size:.4821600771em}.katex .sizing.reset-size10.size7,.katex .fontsize-ensurer.reset-size10.size7{font-size:.5785920926em}.katex .sizing.reset-size10.size8,.katex .fontsize-ensurer.reset-size10.size8{font-size:.6943105111em}.katex .sizing.reset-size10.size9,.katex .fontsize-ensurer.reset-size10.size9{font-size:.8331726133em}.katex .sizing.reset-size10.size10,.katex .fontsize-ensurer.reset-size10.size10{font-size:1em}.katex .sizing.reset-size10.size11,.katex .fontsize-ensurer.reset-size10.size11{font-size:1.1996142719em}.katex .sizing.reset-size11.size1,.katex .fontsize-ensurer.reset-size11.size1{font-size:.2009646302em}.katex .sizing.reset-size11.size2,.katex .fontsize-ensurer.reset-size11.size2{font-size:.2411575563em}.katex .sizing.reset-size11.size3,.katex .fontsize-ensurer.reset-size11.size3{font-size:.2813504823em}.katex .sizing.reset-size11.size4,.katex .fontsize-ensurer.reset-size11.size4{font-size:.3215434084em}.katex .sizing.reset-size11.size5,.katex .fontsize-ensurer.reset-size11.size5{font-size:.3617363344em}.katex .sizing.reset-size11.size6,.katex .fontsize-ensurer.reset-size11.size6{font-size:.4019292605em}.katex .sizing.reset-size11.size7,.katex .fontsize-ensurer.reset-size11.size7{font-size:.4823151125em}.katex .sizing.reset-size11.size8,.katex .fontsize-ensurer.reset-size11.size8{font-size:.578778135em}.katex .sizing.reset-size11.size9,.katex .fontsize-ensurer.reset-size11.size9{font-size:.6945337621em}.katex .sizing.reset-size11.size10,.katex .fontsize-ensurer.reset-size11.size10{font-size:.8336012862em}.katex .sizing.reset-size11.size11,.katex .fontsize-ensurer.reset-size11.size11{font-size:1em}.katex .delimsizing.size1{font-family:KaTeX_Size1}.katex .delimsizing.size2{font-family:KaTeX_Size2}.katex .delimsizing.size3{font-family:KaTeX_Size3}.katex .delimsizing.size4{font-family:KaTeX_Size4}.katex .delimsizing.mult .delim-size1>span{font-family:KaTeX_Size1}.katex .delimsizing.mult .delim-size4>span{font-family:KaTeX_Size4}.katex .nulldelimiter{display:inline-block;width:.12em}.katex .delimcenter,.katex .op-symbol{position:relative}.katex .op-symbol.small-op{font-family:KaTeX_Size1}.katex .op-symbol.large-op{font-family:KaTeX_Size2}.katex .op-limits>.vlist-t{text-align:center}.katex .accent>.vlist-t{text-align:center}.katex .accent .accent-body{position:relative}.katex .accent .accent-body:not(.accent-full){width:0}.katex .overlay{display:block}.katex .mtable .vertical-separator{display:inline-block;min-width:1px}.katex .mtable .arraycolsep{display:inline-block}.katex .mtable .col-align-c>.vlist-t{text-align:center}.katex .mtable .col-align-l>.vlist-t{text-align:left}.katex .mtable .col-align-r>.vlist-t{text-align:right}.katex .svg-align{text-align:left}.katex svg{display:block;position:absolute;width:100%;height:inherit;fill:currentColor;stroke:currentColor}.katex svg path{stroke:none}.katex svg{fill-rule:nonzero;fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1}.katex img{border-style:none;min-width:0;min-height:0;max-width:none;max-height:none}.katex .stretchy{width:100%;display:block;position:relative;overflow:hidden}.katex .stretchy:before,.katex .stretchy:after{content:""}.katex .hide-tail{width:100%;position:relative;overflow:hidden}.katex .halfarrow-left{position:absolute;left:0;width:50.2%;overflow:hidden}.katex .halfarrow-right{position:absolute;right:0;width:50.2%;overflow:hidden}.katex .brace-left{position:absolute;left:0;width:25.1%;overflow:hidden}.katex .brace-center{position:absolute;left:25%;width:50%;overflow:hidden}.katex .brace-right{position:absolute;right:0;width:25.1%;overflow:hidden}.katex .x-arrow-pad{padding:0 .5em}.katex .cd-arrow-pad{padding:0 .55556em 0 .27778em}.katex .x-arrow,.katex .mover,.katex .munder{text-align:center}.katex .boxpad{padding:0 .3em}.katex .fbox,.katex .fcolorbox{box-sizing:border-box;border:.04em solid}.katex .cancel-pad{padding:0 .2em}.katex .cancel-lap{margin-left:-.2em;margin-right:-.2em}.katex .sout{border-bottom-style:solid;border-bottom-width:.08em}.katex .angl{box-sizing:border-box;border-top:.049em solid;border-right:.049em solid;margin-right:.03889em}.katex .anglpad{padding:0 .03889em}.katex .eqn-num:before{counter-increment:katexEqnNo;content:"(" counter(katexEqnNo) ")"}.katex .mml-eqn-num:before{counter-increment:mmlEqnNo;content:"(" counter(mmlEqnNo) ")"}.katex .mtr-glue{width:50%}.katex .cd-vert-arrow{display:inline-block;position:relative}.katex .cd-label-left{display:inline-block;position:absolute;right:calc(50% + .3em);text-align:left}.katex .cd-label-right{display:inline-block;position:absolute;left:calc(50% + .3em);text-align:right}.katex-display{display:block;margin:1em 0;text-align:center}.katex-display>.katex{display:block;text-align:center;white-space:nowrap}.katex-display>.katex>.katex-html{display:block;position:relative}.katex-display>.katex>.katex-html>.tag{position:absolute;right:0}.katex-display.leqno>.katex>.katex-html>.tag{left:0;right:auto}.katex-display.fleqn>.katex{text-align:left;padding-left:2em}body{counter-reset:katexEqnNo mmlEqnNo}.markdown-block--unstable.svelte-wjdxdt{display:contents}.streaming-code-block.svelte-wjdxdt .streaming-code-pre:where(.svelte-wjdxdt){background:transparent;padding:.5rem;margin:0;overflow-x:visible;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt p{margin-block:1rem;line-height:1.75}.markdown-content.svelte-wjdxdt .markdown-block:first-child p:first-child{margin-block-start:0}.markdown-content.svelte-wjdxdt .markdown-block:last-child p:last-child{margin-block-end:0}.markdown-content.svelte-wjdxdt :is(h1,h2,h3,h4,h5,h6):first-child{margin-top:.5rem}.markdown-content.svelte-wjdxdt h1{font-size:1.875rem;font-weight:700;line-height:1.2;margin:1.5rem 0 .75rem}.markdown-content.svelte-wjdxdt h2{font-size:1.5rem;font-weight:600;line-height:1.3;margin:1.25rem 0 .5rem}.markdown-content.svelte-wjdxdt h3{font-size:1.25rem;font-weight:600;margin:1.5rem 0 .5rem;line-height:1.4}.markdown-content.svelte-wjdxdt h4{font-size:1.125rem;font-weight:600;margin:.75rem 0 .25rem}.markdown-content.svelte-wjdxdt h5{font-size:1rem;font-weight:600;margin:.5rem 0 .25rem}.markdown-content.svelte-wjdxdt h6{font-size:.875rem;font-weight:600;margin:.5rem 0 .25rem}.markdown-content.svelte-wjdxdt strong{font-weight:600}.markdown-content.svelte-wjdxdt em{font-style:italic}.markdown-content.svelte-wjdxdt del{text-decoration:line-through;opacity:.7}.markdown-content.svelte-wjdxdt code:not(pre code){background:var(--muted);color:var(--muted-foreground);padding:.125rem .375rem;border-radius:.375rem;font-size:.875rem}.markdown-content.svelte-wjdxdt pre{display:inline;margin:0!important;overflow:hidden!important;background:var(--muted);overflow-x:auto;border-radius:1rem;border:none;line-height:1!important}.markdown-content.svelte-wjdxdt pre code{padding:0!important;display:inline!important}.markdown-content.svelte-wjdxdt code{background:transparent;color:var(--code-foreground)}.markdown-content.svelte-wjdxdt a{color:var(--primary);text-decoration:underline;text-underline-offset:2px;transition:color .2s ease;overflow-wrap:anywhere;word-break:break-all}.markdown-content.svelte-wjdxdt a:hover{color:var(--primary)}.markdown-content.svelte-wjdxdt ul{list-style-type:disc;margin-inline-start:1.5rem;margin-bottom:1rem}.markdown-content.svelte-wjdxdt ol{list-style-type:decimal;margin-inline-start:1.5rem;margin-bottom:1rem}.markdown-content.svelte-wjdxdt li{margin-bottom:.25rem;padding-inline-start:.5rem}.markdown-content.svelte-wjdxdt li::marker{color:var(--muted-foreground)}.markdown-content.svelte-wjdxdt ul ul{list-style-type:circle;margin-top:.25rem;margin-bottom:.25rem}.markdown-content.svelte-wjdxdt ol ol{list-style-type:lower-alpha;margin-top:.25rem;margin-bottom:.25rem}.markdown-content.svelte-wjdxdt .task-list-item{list-style:none;margin-inline-start:0;padding-inline-start:0}.markdown-content.svelte-wjdxdt .task-list-item-checkbox{margin-right:.5rem;margin-top:.125rem}.markdown-content.svelte-wjdxdt blockquote{border-left:4px solid var(--border);padding:.5rem 1rem;margin:1.5rem 0;font-style:italic;color:var(--muted-foreground);background:var(--muted);border-radius:0 .375rem .375rem 0}.markdown-content.svelte-wjdxdt table{width:100%;margin:1.5rem 0;border-collapse:collapse;border:1px solid var(--border);border-radius:.375rem;overflow:hidden}.markdown-content.svelte-wjdxdt th{background:hsl(var(--muted) / .3);border:1px solid var(--border);padding:.5rem .75rem;text-align:left;font-weight:600}.markdown-content.svelte-wjdxdt td{border:1px solid var(--border);padding:.5rem .75rem}.markdown-content.svelte-wjdxdt tr:nth-child(2n){background:hsl(var(--muted) / .1)}div.markdown-user-content.svelte-wjdxdt table,div.markdown-user-content.svelte-wjdxdt th,div.markdown-user-content.svelte-wjdxdt td,div.markdown-user-content.svelte-wjdxdt .table-wrapper{border-color:currentColor}.markdown-content.svelte-wjdxdt hr{border:none;border-top:1px solid var(--border);margin:1.5rem 0}.markdown-content.svelte-wjdxdt img{border-radius:.5rem;box-shadow:0 1px 3px #0000001a,0 1px 2px -1px #0000001a;margin:1.5rem 0;max-width:100%;height:auto}.markdown-content.svelte-wjdxdt .code-block-wrapper{border-radius:.75rem;overflow:hidden;border:1px solid color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d;min-height:var(--min-message-height);max-height:var(--max-message-height)}.markdown-content.svelte-wjdxdt .markdown-block:where(.svelte-wjdxdt):not(:first-child) .code-block-wrapper{margin-top:1rem}.markdown-content.svelte-wjdxdt .markdown-block:where(.svelte-wjdxdt):not(:last-child) .code-block-wrapper{margin-bottom:1rem}.markdown-content.svelte-wjdxdt.dark .code-block-wrapper{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.markdown-content.svelte-wjdxdt .code-block-scroll-container,.streaming-code-scroll-container.svelte-wjdxdt{min-height:var(--min-message-height);max-height:var(--max-message-height);overflow-y:auto;overflow-x:auto;padding:3rem 1rem 1rem;line-height:1.3}.full-height-code-blocks.svelte-wjdxdt .code-block-wrapper{max-height:none}.full-height-code-blocks.svelte-wjdxdt .code-block-scroll-container,.full-height-code-blocks.svelte-wjdxdt .streaming-code-scroll-container:where(.svelte-wjdxdt){max-height:none;overflow-y:visible}.markdown-content.svelte-wjdxdt .code-block-header{display:flex;justify-content:space-between;align-items:center;padding:.5rem 1rem 0;font-size:.875rem;position:absolute;top:0;left:0;right:0}.markdown-content.svelte-wjdxdt .code-language{color:var(--color-foreground);font-weight:500;font-family:ui-monospace,SFMono-Regular,SF Mono,Monaco,Cascadia Code,Roboto Mono,Consolas,Liberation Mono,Menlo,monospace;text-transform:uppercase;font-size:.75rem;letter-spacing:.05em}.markdown-content.svelte-wjdxdt .code-block-actions{display:flex;align-items:center;gap:.5rem}.markdown-content.svelte-wjdxdt .copy-code-btn,.markdown-content.svelte-wjdxdt .preview-code-btn,.markdown-content.svelte-wjdxdt .toggle-source-btn{display:flex;align-items:center;justify-content:center;padding:0;background:transparent;color:var(--code-foreground);cursor:pointer;transition:all .2s ease}.markdown-content.svelte-wjdxdt .copy-code-btn:hover,.markdown-content.svelte-wjdxdt .preview-code-btn:hover,.markdown-content.svelte-wjdxdt .toggle-source-btn:hover{transform:scale(1.05)}.markdown-content.svelte-wjdxdt .copy-code-btn:active,.markdown-content.svelte-wjdxdt .preview-code-btn:active,.markdown-content.svelte-wjdxdt .toggle-source-btn:active{transform:scale(.95)}.markdown-content.svelte-wjdxdt .toggle-source-btn[aria-pressed=true]{color:var(--primary)}.markdown-content.svelte-wjdxdt .code-block-wrapper pre{background:transparent;margin:0;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt .mention{color:hsl(var(--primary));font-weight:500;text-decoration:none}.markdown-content.svelte-wjdxdt .mention:hover{text-decoration:underline}.markdown-content.svelte-wjdxdt .hashtag{color:hsl(var(--primary));font-weight:500;text-decoration:none}.markdown-content.svelte-wjdxdt .hashtag:hover{text-decoration:underline}.markdown-content.svelte-wjdxdt table{transition:all .2s ease}.markdown-content.svelte-wjdxdt table:hover{box-shadow:0 4px 6px -1px #0000001a,0 2px 4px -2px #0000001a}.markdown-content.svelte-wjdxdt th:hover,.markdown-content.svelte-wjdxdt td:hover{background:var(--muted)}.markdown-user-content.svelte-wjdxdt a,.markdown-user-content.svelte-wjdxdt a:hover{color:inherit}.markdown-user-content.svelte-wjdxdt table:hover{box-shadow:none}.markdown-user-content.svelte-wjdxdt th:hover,.markdown-user-content.svelte-wjdxdt td:hover{background:inherit}.markdown-content.svelte-wjdxdt blockquote{transition:all .2s ease;position:relative}.markdown-content.svelte-wjdxdt blockquote:hover{border-left-width:6px;background:var(--muted);transform:translate(2px)}.markdown-content.svelte-wjdxdt blockquote:before{content:'"';position:absolute;top:-.5rem;left:.5rem;font-size:3rem;color:var(--muted-foreground);font-family:serif;line-height:1}.markdown-content.svelte-wjdxdt img{transition:all .3s ease;cursor:pointer}.markdown-content.svelte-wjdxdt img:hover{transform:scale(1.02);box-shadow:0 10px 15px -3px #0000001a,0 4px 6px -4px #0000001a}.markdown-content.svelte-wjdxdt .image-zoom-overlay{position:fixed;inset:0;background:#000c;display:flex;align-items:center;justify-content:center;z-index:1000;cursor:pointer}.markdown-content.svelte-wjdxdt .image-zoom-overlay img{max-width:90vw;max-height:90vh;border-radius:.5rem;box-shadow:0 25px 50px -12px #00000040}.markdown-content.svelte-wjdxdt hr{border:none;height:2px;background:linear-gradient(to right,transparent,var(--border),transparent);margin:2rem 0;position:relative}.markdown-content.svelte-wjdxdt hr:after{content:"";position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:1rem;height:1rem;background:var(--border);border-radius:50%}.markdown-content.svelte-wjdxdt .table-wrapper{overflow-x:auto;margin:1.5rem 0;border-radius:.5rem;border:1px solid var(--border)}.markdown-content.svelte-wjdxdt .table-wrapper table{margin:0;border:none}@media(max-width:640px){.markdown-content.svelte-wjdxdt h1{font-size:1.5rem}.markdown-content.svelte-wjdxdt h2{font-size:1.25rem}.markdown-content.svelte-wjdxdt h3{font-size:1.125rem}.markdown-content.svelte-wjdxdt table{font-size:.875rem}.markdown-content.svelte-wjdxdt th,.markdown-content.svelte-wjdxdt td{padding:.375rem .5rem}.markdown-content.svelte-wjdxdt .table-wrapper{margin:.5rem -1rem;border-radius:0;border-left:none;border-right:none}}@media(prefers-color-scheme:dark){.markdown-content.svelte-wjdxdt blockquote:hover{background:var(--muted)}}.markdown-content.svelte-wjdxdt .image-load-error{display:flex;align-items:center;justify-content:center;margin:1.5rem 0;padding:1.5rem;border-radius:.5rem;background:var(--muted);border:1px dashed var(--border)}.markdown-content.svelte-wjdxdt .image-error-content{display:flex;flex-direction:column;align-items:center;gap:.75rem;color:var(--muted-foreground);text-align:center}.markdown-content.svelte-wjdxdt .image-error-content svg{opacity:.5}.markdown-content.svelte-wjdxdt .image-error-text{font-size:.875rem}.markdown-content.svelte-wjdxdt .image-error-link{display:inline-flex;align-items:center;gap:.375rem;padding:.5rem 1rem;font-size:.875rem;font-weight:500;color:var(--primary);background:var(--background);border:1px solid var(--border);border-radius:.375rem;text-decoration:none;transition:all .2s ease}.markdown-content.svelte-wjdxdt .image-error-link:hover{background:var(--muted);border-color:var(--primary)}.markdown-content.svelte-wjdxdt pre.mermaid,.markdown-content.svelte-wjdxdt .svg-block{background:transparent;border:none;padding:0;text-align:center;font-family:inherit;cursor:pointer;transition:opacity .15s ease;position:relative}.markdown-content.svelte-wjdxdt .svg-block{width:100%}.markdown-content.svelte-wjdxdt pre.mermaid:not([data-mermaid-rendered]),.markdown-content.svelte-wjdxdt pre.mermaid[data-mermaid-rendered]:not(:has(svg)){display:none}.markdown-content.svelte-wjdxdt pre.svg-block:not([data-svg-rendered]){display:none}.markdown-content.svelte-wjdxdt pre.mermaid:hover,.markdown-content.svelte-wjdxdt .svg-block:hover{opacity:.85}.markdown-content.svelte-wjdxdt pre.mermaid svg{max-width:90%;margin:0 auto;height:auto;display:block;padding:3rem 1rem}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper,.markdown-content.svelte-wjdxdt .svg-block-wrapper{margin:1.5rem 0;border-radius:.75rem;overflow:hidden;border:1px solid color-mix(in oklch,var(--border) 30%,transparent);background:var(--code-background);box-shadow:0 1px 2px #0000000d;position:relative;min-height:var(--min-message-height);max-height:var(--max-message-height)}.markdown-content.svelte-wjdxdt.dark .mermaid-block-wrapper,.markdown-content.svelte-wjdxdt.dark .svg-block-wrapper{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.markdown-content.svelte-wjdxdt .mermaid-scroll-container,.markdown-content.svelte-wjdxdt .svg-scroll-container{min-height:350px;max-height:var(--max-message-height);overflow-y:auto;overflow-x:auto;display:flex;align-items:safe center;justify-content:safe center;padding:3rem 1rem 1rem}.full-height-code-blocks.svelte-wjdxdt .mermaid-block-wrapper,.full-height-code-blocks.svelte-wjdxdt .svg-block-wrapper{max-height:none}.full-height-code-blocks.svelte-wjdxdt .mermaid-scroll-container,.full-height-code-blocks.svelte-wjdxdt .svg-scroll-container{max-height:none;overflow-y:visible}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper .code-block-header,.markdown-content.svelte-wjdxdt .svg-block-wrapper .code-block-header{display:flex;justify-content:space-between;align-items:center;padding:.5rem 1rem 0;font-size:.875rem;position:absolute;top:0;left:0;right:0;z-index:2}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper .code-block-actions,.markdown-content.svelte-wjdxdt .svg-block-wrapper .code-block-actions{display:flex;align-items:center;gap:.5rem}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper pre.mermaid,.markdown-content.svelte-wjdxdt .svg-block-wrapper pre.svg-block{background:transparent;border:none;padding:0;margin:0;text-align:center}.markdown-content.svelte-wjdxdt .mermaid-block-wrapper pre.mermaid svg{width:unset!important;height:auto;display:block;padding:3rem 1rem}.markdown-content.svelte-wjdxdt .diagram-source{display:none;text-align:left}.markdown-content.svelte-wjdxdt .diagram-source pre{background:transparent;margin:0;border-radius:0;border:none;font-size:.875rem}.markdown-content.svelte-wjdxdt [data-view-mode=source] .mermaid-scroll-container,.markdown-content.svelte-wjdxdt [data-view-mode=source] .svg-scroll-container{display:none}.markdown-content.svelte-wjdxdt [data-view-mode=source] .diagram-source{display:block}.mermaid-streaming-block.svelte-wjdxdt{min-height:300px;display:flex;align-items:center;justify-content:center}.mermaid-loading-placeholder.svelte-wjdxdt{display:flex;align-items:center;justify-content:center;padding:3rem;color:var(--muted-foreground)}.mermaid-loading-text.svelte-wjdxdt{font-size:.875rem;font-style:italic}.code-preview-wrapper.svelte-hp0zxr{overscroll-behavior:contain}.code-preview-wrapper.svelte-hp0zxr pre:where(.svelte-hp0zxr){background:transparent;padding:0}.code-preview-wrapper.svelte-hp0zxr code:where(.svelte-hp0zxr){background:transparent;display:block;padding:.5rem}.dark .code-preview-wrapper.svelte-hp0zxr{border-color:color-mix(in oklch,var(--border) 20%,transparent)}.code-preview-overlay{position:fixed;inset:0;background-color:transparent;z-index:100000}.code-preview-content{position:fixed;inset:0;top:0!important;left:0!important;width:100dvw;height:100dvh;margin:0;padding:0;border:none;border-radius:0;background-color:transparent;box-shadow:none;display:block;overflow:hidden;transform:none!important;z-index:100001}.code-preview-iframe{display:block;width:100dvw;height:100dvh;border:0}.code-preview-close{position:absolute;z-index:100002}aside.svelte-1adgg5m{@media(max-width:768px){--size: 1.125rem}}@media(max-width:768px){aside.svelte-1adgg5m{&:not(.is-expanded){pointer-events:none}}aside.is-expanded.svelte-1adgg5m:before{content:"";position:fixed;inset:-.5rem -.5rem -.25rem;z-index:-1;background:var(--background);backdrop-filter:blur(1rem);pointer-events:none}}button.svelte-19ekn76{[data-slot=dropdown-menu-trigger]:not([data-state=open]){opacity:0}&:is(:where(.svelte-19ekn76):hover) [data-slot=dropdown-menu-trigger],&:focus-within [data-slot=dropdown-menu-trigger]{opacity:1}@media(max-width:768px){[data-slot=dropdown-menu-trigger]{opacity:1!important}}&.is-selection-mode [data-slot=dropdown-menu-trigger]{display:none!important}.stop-button:where(.svelte-19ekn76){.stop-icon{display:none}.loading-icon{display:block}}&:is(:where(.svelte-19ekn76):hover) .stop-button:where(.svelte-19ekn76){.stop-icon{display:block}.loading-icon{display:none}}} diff --git a/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_layout.CFd5szNz.css b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_layout.CFd5szNz.css new file mode 100644 index 0000000000000000000000000000000000000000..167f35d48b44b8a85afa1c2538a1b350e9169d41 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_layout.CFd5szNz.css @@ -0,0 +1 @@ +html[dir=ltr],[data-sonner-toaster][dir=ltr]{--toast-icon-margin-start: -3px;--toast-icon-margin-end: 4px;--toast-svg-margin-start: -1px;--toast-svg-margin-end: 0px;--toast-button-margin-start: auto;--toast-button-margin-end: 0;--toast-close-button-start: 0;--toast-close-button-end: unset;--toast-close-button-transform: translate(-35%, -35%)}html[dir=rtl],[data-sonner-toaster][dir=rtl]{--toast-icon-margin-start: 4px;--toast-icon-margin-end: -3px;--toast-svg-margin-start: 0px;--toast-svg-margin-end: -1px;--toast-button-margin-start: 0;--toast-button-margin-end: auto;--toast-close-button-start: unset;--toast-close-button-end: 0;--toast-close-button-transform: translate(35%, -35%)}[data-sonner-toaster]{position:fixed;width:var(--width);font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;--gray1: hsl(0, 0%, 99%);--gray2: hsl(0, 0%, 97.3%);--gray3: hsl(0, 0%, 95.1%);--gray4: hsl(0, 0%, 93%);--gray5: hsl(0, 0%, 90.9%);--gray6: hsl(0, 0%, 88.7%);--gray7: hsl(0, 0%, 85.8%);--gray8: hsl(0, 0%, 78%);--gray9: hsl(0, 0%, 56.1%);--gray10: hsl(0, 0%, 52.3%);--gray11: hsl(0, 0%, 43.5%);--gray12: hsl(0, 0%, 9%);--border-radius: 8px;box-sizing:border-box;padding:0;margin:0;list-style:none;outline:none;z-index:999999999;transition:transform .4s ease}@media(hover:none)and (pointer:coarse){[data-sonner-toaster][data-lifted=true]{transform:none}}[data-sonner-toaster][data-x-position=right]{right:var(--offset-right)}[data-sonner-toaster][data-x-position=left]{left:var(--offset-left)}[data-sonner-toaster][data-x-position=center]{left:50%;transform:translate(-50%)}[data-sonner-toaster][data-y-position=top]{top:var(--offset-top)}[data-sonner-toaster][data-y-position=bottom]{bottom:var(--offset-bottom)}[data-sonner-toast]{--y: translateY(100%);--lift-amount: calc(var(--lift) * var(--gap));z-index:var(--z-index);position:absolute;opacity:0;transform:var(--y);touch-action:none;transition:transform .4s,opacity .4s,height .4s,box-shadow .2s;box-sizing:border-box;outline:none;overflow-wrap:anywhere}[data-sonner-toast][data-styled=true]{padding:16px;background:var(--normal-bg);border:1px solid var(--normal-border);color:var(--normal-text);border-radius:var(--border-radius);box-shadow:0 4px 12px #0000001a;width:var(--width);font-size:13px;display:flex;align-items:center;gap:6px}[data-sonner-toast]:focus-visible{box-shadow:0 4px 12px #0000001a,0 0 0 2px #0003}[data-sonner-toast][data-y-position=top]{top:0;--y: translateY(-100%);--lift: 1;--lift-amount: calc(1 * var(--gap))}[data-sonner-toast][data-y-position=bottom]{bottom:0;--y: translateY(100%);--lift: -1;--lift-amount: calc(var(--lift) * var(--gap))}[data-sonner-toast][data-styled=true] [data-description]{font-weight:400;line-height:1.4;color:#3f3f3f}[data-rich-colors=true][data-sonner-toast][data-styled=true] [data-description]{color:inherit}[data-sonner-toaster][data-sonner-theme=dark] [data-description]{color:#e8e8e8}[data-sonner-toast][data-styled=true] [data-title]{font-weight:500;line-height:1.5;color:inherit}[data-sonner-toast][data-styled=true] [data-icon]{display:flex;height:16px;width:16px;position:relative;justify-content:flex-start;align-items:center;flex-shrink:0;margin-left:var(--toast-icon-margin-start);margin-right:var(--toast-icon-margin-end)}[data-sonner-toast][data-promise=true] [data-icon]>svg{opacity:0;transform:scale(.8);transform-origin:center;animation:sonner-fade-in .3s ease forwards}[data-sonner-toast][data-styled=true] [data-icon]>*{flex-shrink:0}[data-sonner-toast][data-styled=true] [data-icon] svg{margin-left:var(--toast-svg-margin-start);margin-right:var(--toast-svg-margin-end)}[data-sonner-toast][data-styled=true] [data-content]{display:flex;flex-direction:column;gap:2px}[data-sonner-toast][data-styled=true] [data-button]{border-radius:4px;padding-left:8px;padding-right:8px;height:24px;font-size:12px;color:var(--normal-bg);background:var(--normal-text);margin-left:var(--toast-button-margin-start);margin-right:var(--toast-button-margin-end);border:none;font-weight:500;cursor:pointer;outline:none;display:flex;align-items:center;flex-shrink:0;transition:opacity .4s,box-shadow .2s}[data-sonner-toast][data-styled=true] [data-button]:focus-visible{box-shadow:0 0 0 2px #0006}[data-sonner-toast][data-styled=true] [data-button]:first-of-type{margin-left:var(--toast-button-margin-start);margin-right:var(--toast-button-margin-end)}[data-sonner-toast][data-styled=true] [data-cancel]{color:var(--normal-text);background:#00000014}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast][data-styled=true] [data-cancel]{background:#ffffff4d}[data-sonner-toast][data-styled=true] [data-close-button]{position:absolute;left:var(--toast-close-button-start);right:var(--toast-close-button-end);top:0;height:20px;width:20px;display:flex;justify-content:center;align-items:center;padding:0;color:var(--gray12);background:var(--normal-bg);border:1px solid var(--gray4);transform:var(--toast-close-button-transform);border-radius:50%;cursor:pointer;z-index:1;transition:opacity .1s,background .2s,border-color .2s}[data-sonner-toast][data-styled=true] [data-close-button]:focus-visible{box-shadow:0 4px 12px #0000001a,0 0 0 2px #0003}[data-sonner-toast][data-styled=true] [data-disabled=true]{cursor:not-allowed}[data-sonner-toast][data-styled=true]:hover [data-close-button]:hover{background:var(--gray2);border-color:var(--gray5)}[data-sonner-toast][data-swiping=true]:before{content:"";position:absolute;left:-100%;right:-100%;height:100%;z-index:-1}[data-sonner-toast][data-y-position=top][data-swiping=true]:before{bottom:50%;transform:scaleY(3) translateY(50%)}[data-sonner-toast][data-y-position=bottom][data-swiping=true]:before{top:50%;transform:scaleY(3) translateY(-50%)}[data-sonner-toast][data-swiping=false][data-removed=true]:before{content:"";position:absolute;inset:0;transform:scaleY(2)}[data-sonner-toast][data-expanded=true]:after{content:"";position:absolute;left:0;height:calc(var(--gap) + 1px);bottom:100%;width:100%}[data-sonner-toast][data-mounted=true]{--y: translateY(0);opacity:1}[data-sonner-toast][data-expanded=false][data-front=false]{--scale: var(--toasts-before) * .05 + 1;--y: translateY(calc(var(--lift-amount) * var(--toasts-before))) scale(calc(-1 * var(--scale)));height:var(--front-toast-height)}[data-sonner-toast]>*{transition:opacity .4s}[data-sonner-toast][data-x-position=right]{right:0}[data-sonner-toast][data-x-position=left]{left:0}[data-sonner-toast][data-expanded=false][data-front=false][data-styled=true]>*{opacity:0}[data-sonner-toast][data-visible=false]{opacity:0;pointer-events:none}[data-sonner-toast][data-mounted=true][data-expanded=true]{--y: translateY(calc(var(--lift) * var(--offset)));height:var(--initial-height)}[data-sonner-toast][data-removed=true][data-front=true][data-swipe-out=false]{--y: translateY(calc(var(--lift) * -100%));opacity:0}[data-sonner-toast][data-removed=true][data-front=false][data-swipe-out=false][data-expanded=true]{--y: translateY( calc(var(--lift) * var(--offset) + var(--lift) * -100%) );opacity:0}[data-sonner-toast][data-removed=true][data-front=false][data-swipe-out=false][data-expanded=false]{--y: translateY(40%);opacity:0;transition:transform .5s,opacity .2s}[data-sonner-toast][data-removed=true][data-front=false]:before{height:calc(var(--initial-height) + 20%)}[data-sonner-toast][data-swiping=true]{transform:var(--y) translateY(var(--swipe-amount-y, 0px)) translate(var(--swipe-amount-x, 0px));transition:none}[data-sonner-toast][data-swiped=true]{user-select:none}[data-sonner-toast][data-swipe-out=true][data-y-position=bottom],[data-sonner-toast][data-swipe-out=true][data-y-position=top]{animation-duration:.2s;animation-timing-function:ease-out;animation-fill-mode:forwards}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=left]{animation-name:swipe-out-left}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=right]{animation-name:swipe-out-right}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=up]{animation-name:swipe-out-up}[data-sonner-toast][data-swipe-out=true][data-swipe-direction=down]{animation-name:swipe-out-down}@keyframes swipe-out-left{0%{transform:var(--y) translate(var(--swipe-amount-x));opacity:1}to{transform:var(--y) translate(calc(var(--swipe-amount-x) - 100%));opacity:0}}@keyframes swipe-out-right{0%{transform:var(--y) translate(var(--swipe-amount-x));opacity:1}to{transform:var(--y) translate(calc(var(--swipe-amount-x) + 100%));opacity:0}}@keyframes swipe-out-up{0%{transform:var(--y) translateY(var(--swipe-amount-y));opacity:1}to{transform:var(--y) translateY(calc(var(--swipe-amount-y) - 100%));opacity:0}}@keyframes swipe-out-down{0%{transform:var(--y) translateY(var(--swipe-amount-y));opacity:1}to{transform:var(--y) translateY(calc(var(--swipe-amount-y) + 100%));opacity:0}}@media(max-width:600px){[data-sonner-toaster]{position:fixed;right:var(--mobile-offset-right);left:var(--mobile-offset-left);width:100%}[data-sonner-toaster][dir=rtl]{left:calc(var(--mobile-offset-left) * -1)}[data-sonner-toaster] [data-sonner-toast]{left:0;right:0;width:calc(100% - var(--mobile-offset-left) * 2)}[data-sonner-toaster][data-x-position=left]{left:var(--mobile-offset-left)}[data-sonner-toaster][data-y-position=bottom]{bottom:var(--mobile-offset-bottom)}[data-sonner-toaster][data-y-position=top]{top:var(--mobile-offset-top)}[data-sonner-toaster][data-x-position=center]{left:var(--mobile-offset-left);right:var(--mobile-offset-right);transform:none}}[data-sonner-toaster][data-sonner-theme=light]{--normal-bg: #fff;--normal-border: var(--gray4);--normal-text: var(--gray12);--success-bg: hsl(143, 85%, 96%);--success-border: hsl(145, 92%, 87%);--success-text: hsl(140, 100%, 27%);--info-bg: hsl(208, 100%, 97%);--info-border: hsl(221, 91%, 93%);--info-text: hsl(210, 92%, 45%);--warning-bg: hsl(49, 100%, 97%);--warning-border: hsl(49, 91%, 84%);--warning-text: hsl(31, 92%, 45%);--error-bg: hsl(359, 100%, 97%);--error-border: hsl(359, 100%, 94%);--error-text: hsl(360, 100%, 45%)}[data-sonner-toaster][data-sonner-theme=light] [data-sonner-toast][data-invert=true]{--normal-bg: #000;--normal-border: hsl(0, 0%, 20%);--normal-text: var(--gray1)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast][data-invert=true]{--normal-bg: #fff;--normal-border: var(--gray3);--normal-text: var(--gray12)}[data-sonner-toaster][data-sonner-theme=dark]{--normal-bg: #000;--normal-bg-hover: hsl(0, 0%, 12%);--normal-border: hsl(0, 0%, 20%);--normal-border-hover: hsl(0, 0%, 25%);--normal-text: var(--gray1);--success-bg: hsl(150, 100%, 6%);--success-border: hsl(147, 100%, 12%);--success-text: hsl(150, 86%, 65%);--info-bg: hsl(215, 100%, 6%);--info-border: hsl(223, 43%, 17%);--info-text: hsl(216, 87%, 65%);--warning-bg: hsl(64, 100%, 6%);--warning-border: hsl(60, 100%, 9%);--warning-text: hsl(46, 87%, 65%);--error-bg: hsl(358, 76%, 10%);--error-border: hsl(357, 89%, 16%);--error-text: hsl(358, 100%, 81%)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast] [data-close-button]{background:var(--normal-bg);border-color:var(--normal-border);color:var(--normal-text)}[data-sonner-toaster][data-sonner-theme=dark] [data-sonner-toast] [data-close-button]:hover{background:var(--normal-bg-hover);border-color:var(--normal-border-hover)}[data-rich-colors=true][data-sonner-toast][data-type=success],[data-rich-colors=true][data-sonner-toast][data-type=success] [data-close-button]{background:var(--success-bg);border-color:var(--success-border);color:var(--success-text)}[data-rich-colors=true][data-sonner-toast][data-type=info],[data-rich-colors=true][data-sonner-toast][data-type=info] [data-close-button]{background:var(--info-bg);border-color:var(--info-border);color:var(--info-text)}[data-rich-colors=true][data-sonner-toast][data-type=warning],[data-rich-colors=true][data-sonner-toast][data-type=warning] [data-close-button]{background:var(--warning-bg);border-color:var(--warning-border);color:var(--warning-text)}[data-rich-colors=true][data-sonner-toast][data-type=error],[data-rich-colors=true][data-sonner-toast][data-type=error] [data-close-button]{background:var(--error-bg);border-color:var(--error-border);color:var(--error-text)}.sonner-loading-wrapper{--size: 16px;height:var(--size);width:var(--size);position:absolute;inset:0;z-index:10}.sonner-loading-wrapper[data-visible=false]{transform-origin:center;animation:sonner-fade-out .2s ease forwards}.sonner-spinner{position:relative;top:50%;left:50%;height:var(--size);width:var(--size)}.sonner-loading-bar{animation:sonner-spin 1.2s linear infinite;background:var(--gray11);border-radius:6px;height:8%;left:-10%;position:absolute;top:-3.9%;width:24%}.sonner-loading-bar:nth-child(1){animation-delay:-1.2s;transform:rotate(.0001deg) translate(146%)}.sonner-loading-bar:nth-child(2){animation-delay:-1.1s;transform:rotate(30deg) translate(146%)}.sonner-loading-bar:nth-child(3){animation-delay:-1s;transform:rotate(60deg) translate(146%)}.sonner-loading-bar:nth-child(4){animation-delay:-.9s;transform:rotate(90deg) translate(146%)}.sonner-loading-bar:nth-child(5){animation-delay:-.8s;transform:rotate(120deg) translate(146%)}.sonner-loading-bar:nth-child(6){animation-delay:-.7s;transform:rotate(150deg) translate(146%)}.sonner-loading-bar:nth-child(7){animation-delay:-.6s;transform:rotate(180deg) translate(146%)}.sonner-loading-bar:nth-child(8){animation-delay:-.5s;transform:rotate(210deg) translate(146%)}.sonner-loading-bar:nth-child(9){animation-delay:-.4s;transform:rotate(240deg) translate(146%)}.sonner-loading-bar:nth-child(10){animation-delay:-.3s;transform:rotate(270deg) translate(146%)}.sonner-loading-bar:nth-child(11){animation-delay:-.2s;transform:rotate(300deg) translate(146%)}.sonner-loading-bar:nth-child(12){animation-delay:-.1s;transform:rotate(330deg) translate(146%)}@keyframes sonner-fade-in{0%{opacity:0;transform:scale(.8)}to{opacity:1;transform:scale(1)}}@keyframes sonner-fade-out{0%{opacity:1;transform:scale(1)}to{opacity:0;transform:scale(.8)}}@keyframes sonner-spin{0%{opacity:1}to{opacity:.15}}@media(prefers-reduced-motion){[data-sonner-toast],[data-sonner-toast]>*,.sonner-loading-bar{transition:none!important;animation:none!important}}.sonner-loader{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);transform-origin:center;transition:opacity .2s,transform .2s}.sonner-loader[data-visible=false]{opacity:0;transform:scale(.8) translate(-50%,-50%)}@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-space-x-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial;--tw-content:"";--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0}}}@layer theme{:root,:host{--font-sans:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-mono:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--color-red-300:oklch(80.8% .114 19.571);--color-red-400:oklch(70.4% .191 22.216);--color-red-500:oklch(63.7% .237 25.331);--color-red-600:oklch(57.7% .245 27.325);--color-red-700:oklch(50.5% .213 27.518);--color-orange-50:oklch(98% .016 73.684);--color-orange-100:oklch(95.4% .038 75.164);--color-orange-200:oklch(90.1% .076 70.697);--color-orange-400:oklch(75% .183 55.934);--color-orange-600:oklch(64.6% .222 41.116);--color-orange-800:oklch(47% .157 37.304);--color-orange-900:oklch(40.8% .123 38.172);--color-orange-950:oklch(26.6% .079 36.259);--color-amber-300:oklch(87.9% .169 91.605);--color-amber-400:oklch(82.8% .189 84.429);--color-amber-500:oklch(76.9% .188 70.08);--color-amber-600:oklch(66.6% .179 58.318);--color-amber-700:oklch(55.5% .163 48.998);--color-yellow-200:oklch(94.5% .129 101.54);--color-yellow-400:oklch(85.2% .199 91.936);--color-yellow-500:oklch(79.5% .184 86.047);--color-yellow-600:oklch(68.1% .162 75.834);--color-green-50:oklch(98.2% .018 155.826);--color-green-300:oklch(87.1% .15 154.449);--color-green-400:oklch(79.2% .209 151.711);--color-green-500:oklch(72.3% .219 149.579);--color-green-600:oklch(62.7% .194 149.214);--color-green-700:oklch(52.7% .154 150.069);--color-green-950:oklch(26.6% .065 152.934);--color-cyan-50:oklch(98.4% .019 200.873);--color-cyan-400:oklch(78.9% .154 211.53);--color-cyan-600:oklch(60.9% .126 221.723);--color-cyan-950:oklch(30.2% .056 229.695);--color-blue-50:oklch(97% .014 254.604);--color-blue-200:oklch(88.2% .059 254.128);--color-blue-400:oklch(70.7% .165 254.624);--color-blue-600:oklch(54.6% .245 262.881);--color-blue-700:oklch(48.8% .243 264.376);--color-blue-950:oklch(28.2% .091 267.935);--color-purple-50:oklch(97.7% .014 308.299);--color-purple-100:oklch(94.6% .033 307.174);--color-purple-200:oklch(90.2% .063 306.703);--color-purple-300:oklch(82.7% .119 306.383);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-purple-600:oklch(55.8% .288 302.321);--color-purple-700:oklch(49.6% .265 301.924);--color-purple-800:oklch(43.8% .218 303.724);--color-purple-900:oklch(38.1% .176 304.987);--color-purple-950:oklch(29.1% .149 302.717);--color-pink-50:oklch(97.1% .014 343.198);--color-pink-400:oklch(71.8% .202 349.761);--color-pink-600:oklch(59.2% .249 .584);--color-pink-950:oklch(28.4% .109 3.907);--color-gray-400:oklch(70.7% .022 261.325);--color-gray-500:oklch(55.1% .027 264.364);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-sm:24rem;--container-md:28rem;--container-lg:32rem;--container-2xl:42rem;--container-3xl:48rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1/.75);--text-sm:.875rem;--text-sm--line-height:calc(1.25/.875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75/1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75/1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2/1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-tight:1.25;--leading-snug:1.375;--leading-relaxed:1.625;--radius-xs:.125rem;--radius-2xl:1rem;--radius-3xl:1.5rem;--radius-4xl:2rem;--ease-out:cubic-bezier(0,0,.2,1);--ease-in-out:cubic-bezier(.4,0,.2,1);--animate-spin:spin 1s linear infinite;--animate-pulse:pulse 2s cubic-bezier(.4,0,.6,1)infinite;--blur-xs:4px;--blur-sm:8px;--blur-md:12px;--blur-lg:16px;--blur-xl:24px;--blur-2xl:40px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4,0,.2,1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-foreground:var(--foreground)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){*{outline-color:color-mix(in oklab,var(--ring)50%,transparent)}}body{background-color:var(--background);color:var(--foreground);scrollbar-width:thin;scrollbar-gutter:stable;background-image:radial-gradient(at 50% 115%,#5c010959,#0000 60%),radial-gradient(at 85% -10%,oklch(25% .06 220/.18),#0000 55%)}body:before{content:"";pointer-events:none;z-index:999990;opacity:.35;background:repeating-linear-gradient(0deg,#00000038 0 1px,#0000 1px 3px),radial-gradient(#0000 55%,#0600008c);position:fixed;inset:0}body:after{content:"";pointer-events:none;z-index:999990;background:radial-gradient(circle at 50% 120%,var(--ember),transparent 70%),radial-gradient(circle at 12% 8%,oklch(78% .18 220/.12),transparent 40%);opacity:.22;mix-blend-mode:screen;position:fixed;inset:0}::selection{background:var(--flame);color:var(--background);text-shadow:0 0 8px var(--gold)}*{scrollbar-width:thin;scrollbar-color:transparent transparent}:hover{scrollbar-color:var(--flame)transparent}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:0 0;border-radius:3px;transition:background .2s}:hover::-webkit-scrollbar-thumb{background:var(--flame)}::-webkit-scrollbar-thumb:hover{background:var(--gold)}:where(code,pre,kbd,samp){font-family:var(--font-mono)}[type=text],input:where(:not([type])),[type=email],[type=url],[type=password],[type=number],[type=date],[type=datetime-local],[type=month],[type=search],[type=tel],[type=time],[type=week],[multiple],textarea,select{appearance:none;--tw-shadow:0 0 #0000;background-color:#fff;border-width:1px;border-color:#6a7282;border-radius:0;padding:.5rem .75rem;font-size:1rem;line-height:1.5rem}:is([type=text],input:where(:not([type])),[type=email],[type=url],[type=password],[type=number],[type=date],[type=datetime-local],[type=month],[type=search],[type=tel],[type=time],[type=week],[multiple],textarea,select):focus{outline-offset:2px;--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:oklch(54.6% .245 262.881);--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow);border-color:#155dfc;outline:2px solid #0000}input::placeholder,textarea::placeholder{color:#6a7282;opacity:1}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-date-and-time-value{min-height:1.5em}::-webkit-date-and-time-value{text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-year-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-month-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-day-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-hour-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-minute-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-second-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-millisecond-field{padding-top:0;padding-bottom:0}::-webkit-datetime-edit-meridiem-field{padding-top:0;padding-bottom:0}select{print-color-adjust:exact;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='oklch(55.1%25 0.027 264.364)' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e");background-position:right .5rem center;background-repeat:no-repeat;background-size:1.5em 1.5em;padding-right:2.5rem}[multiple],[size]:where(select:not([size="1"])){background-image:initial;background-position:initial;background-repeat:unset;background-size:initial;print-color-adjust:unset;padding-right:.75rem}[type=checkbox],[type=radio]{appearance:none;print-color-adjust:exact;vertical-align:middle;-webkit-user-select:none;user-select:none;color:#155dfc;--tw-shadow:0 0 #0000;background-color:#fff;background-origin:border-box;border-width:1px;border-color:#6a7282;flex-shrink:0;width:1rem;height:1rem;padding:0;display:inline-block}[type=checkbox]{border-radius:0}[type=radio]{border-radius:100%}[type=checkbox]:focus,[type=radio]:focus{outline-offset:2px;--tw-ring-inset:var(--tw-empty, );--tw-ring-offset-width:2px;--tw-ring-offset-color:#fff;--tw-ring-color:oklch(54.6% .245 262.881);--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow);outline:2px solid #0000}[type=checkbox]:checked,[type=radio]:checked{background-color:currentColor;background-position:50%;background-repeat:no-repeat;background-size:100% 100%;border-color:#0000}[type=checkbox]:checked{background-image:url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3cpath d='M12.207 4.793a1 1 0 010 1.414l-5 5a1 1 0 01-1.414 0l-2-2a1 1 0 011.414-1.414L6.5 9.086l4.293-4.293a1 1 0 011.414 0z'/%3e%3c/svg%3e")}@media(forced-colors:active){[type=checkbox]:checked{appearance:auto}}[type=radio]:checked{background-image:url("data:image/svg+xml,%3csvg viewBox='0 0 16 16' fill='white' xmlns='http://www.w3.org/2000/svg'%3e%3ccircle cx='8' cy='8' r='3'/%3e%3c/svg%3e")}@media(forced-colors:active){[type=radio]:checked{appearance:auto}}[type=checkbox]:checked:hover,[type=checkbox]:checked:focus,[type=radio]:checked:hover,[type=radio]:checked:focus{background-color:currentColor;border-color:#0000}[type=checkbox]:indeterminate{background-color:currentColor;background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 16 16'%3e%3cpath stroke='white' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M4 8h8'/%3e%3c/svg%3e");background-position:50%;background-repeat:no-repeat;background-size:100% 100%;border-color:#0000}@media(forced-colors:active){[type=checkbox]:indeterminate{appearance:auto}}[type=checkbox]:indeterminate:hover,[type=checkbox]:indeterminate:focus{background-color:currentColor;border-color:#0000}[type=file]{background:unset;border-color:inherit;font-size:unset;line-height:inherit;border-width:0;border-radius:0;padding:0}[type=file]:focus{outline:1px solid buttontext;outline:1px auto -webkit-focus-ring-color}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.\@container{container-type:inline-size}.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip:rect(0,0,0,0);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing)*0)}.inset-x-0{inset-inline:calc(var(--spacing)*0)}.inset-y-0{inset-block:calc(var(--spacing)*0)}.top-0{top:calc(var(--spacing)*0)}.top-1{top:calc(var(--spacing)*1)}.top-1\/2{top:50%}.top-2{top:calc(var(--spacing)*2)}.top-4{top:calc(var(--spacing)*4)}.top-4\.5{top:calc(var(--spacing)*4.5)}.top-10{top:calc(var(--spacing)*10)}.top-\[50\%\]{top:50%}.top-full{top:100%}.right-0{right:calc(var(--spacing)*0)}.right-1{right:calc(var(--spacing)*1)}.right-2{right:calc(var(--spacing)*2)}.right-3{right:calc(var(--spacing)*3)}.right-4{right:calc(var(--spacing)*4)}.right-8{right:calc(var(--spacing)*8)}.bottom-0{bottom:calc(var(--spacing)*0)}.bottom-1{bottom:calc(var(--spacing)*1)}.bottom-2{bottom:calc(var(--spacing)*2)}.bottom-4{bottom:calc(var(--spacing)*4)}.bottom-6{bottom:calc(var(--spacing)*6)}.bottom-8{bottom:calc(var(--spacing)*8)}.bottom-32{bottom:calc(var(--spacing)*32)}.left-0{left:calc(var(--spacing)*0)}.left-1\/2{left:50%}.left-2{left:calc(var(--spacing)*2)}.left-3{left:calc(var(--spacing)*3)}.left-4{left:calc(var(--spacing)*4)}.left-\[50\%\]{left:50%}.isolate{isolation:isolate}.z-10{z-index:10}.z-50{z-index:50}.z-9999{z-index:9999}.z-999999{z-index:999999}.z-1000000{z-index:1000000}.z-1000001{z-index:1000001}.z-\[20\]{z-index:20}.z-\[1000\]{z-index:1000}.z-\[9999\]{z-index:9999}.z-\[999999\]{z-index:999999}.z-\[var\(--layer-popover\,1000000\)\]{z-index:var(--layer-popover,1000000)}.col-start-2{grid-column-start:2}.row-span-2{grid-row:span 2/span 2}.row-start-1{grid-row-start:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.m-0{margin:calc(var(--spacing)*0)}.m-2{margin:calc(var(--spacing)*2)}.-mx-1{margin-inline:calc(var(--spacing)*-1)}.-mx-2{margin-inline:calc(var(--spacing)*-2)}.mx-1{margin-inline:calc(var(--spacing)*1)}.mx-auto{margin-inline:auto}.-my-1{margin-block:calc(var(--spacing)*-1)}.-my-2{margin-block:calc(var(--spacing)*-2)}.my-0\!{margin-block:calc(var(--spacing)*0)!important}.my-1{margin-block:calc(var(--spacing)*1)}.my-1\.5{margin-block:calc(var(--spacing)*1.5)}.my-2{margin-block:calc(var(--spacing)*2)}.my-6{margin-block:calc(var(--spacing)*6)}.prose{color:var(--tw-prose-body);max-width:65ch}.prose :where(p):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em}.prose :where([class~=lead]):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-lead);margin-top:1.2em;margin-bottom:1.2em;font-size:1.25em;line-height:1.6}.prose :where(a):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-links);font-weight:500;text-decoration:underline}.prose :where(strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-bold);font-weight:600}.prose :where(a strong):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(blockquote strong):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(thead th strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(ol):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em;padding-inline-start:1.625em;list-style-type:decimal}.prose :where(ol[type=A]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-alpha}.prose :where(ol[type=a]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-alpha}.prose :where(ol[type=A s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-alpha}.prose :where(ol[type=a s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-alpha}.prose :where(ol[type=I]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-roman}.prose :where(ol[type=i]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-roman}.prose :where(ol[type=I s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:upper-roman}.prose :where(ol[type=i s]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:lower-roman}.prose :where(ol[type="1"]):not(:where([class~=not-prose],[class~=not-prose] *)){list-style-type:decimal}.prose :where(ul):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em;padding-inline-start:1.625em;list-style-type:disc}.prose :where(ol>li):not(:where([class~=not-prose],[class~=not-prose] *))::marker{color:var(--tw-prose-counters);font-weight:400}.prose :where(ul>li):not(:where([class~=not-prose],[class~=not-prose] *))::marker{color:var(--tw-prose-bullets)}.prose :where(dt):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.25em;font-weight:600}.prose :where(hr):not(:where([class~=not-prose],[class~=not-prose] *)){border-color:var(--tw-prose-hr);border-top-width:1px;margin-top:3em;margin-bottom:3em}.prose :where(blockquote):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-quotes);border-inline-start-width:.25rem;border-inline-start-color:var(--tw-prose-quote-borders);quotes:"“""”""‘""’";margin-top:1.6em;margin-bottom:1.6em;padding-inline-start:1em;font-style:italic;font-weight:500}.prose :where(blockquote p:first-of-type):not(:where([class~=not-prose],[class~=not-prose] *)):before{content:open-quote}.prose :where(blockquote p:last-of-type):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:close-quote}.prose :where(h1):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:0;margin-bottom:.888889em;font-size:2.25em;font-weight:800;line-height:1.11111}.prose :where(h1 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:900}.prose :where(h2):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:2em;margin-bottom:1em;font-size:1.5em;font-weight:700;line-height:1.33333}.prose :where(h2 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:800}.prose :where(h3):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.6em;margin-bottom:.6em;font-size:1.25em;font-weight:600;line-height:1.6}.prose :where(h3 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:700}.prose :where(h4):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);margin-top:1.5em;margin-bottom:.5em;font-weight:600;line-height:1.5}.prose :where(h4 strong):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-weight:700}.prose :where(img):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(picture):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em;display:block}.prose :where(video):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(kbd):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-kbd);box-shadow:0 0 0 1px rgb(var(--tw-prose-kbd-shadows)/10%),0 3px rgb(var(--tw-prose-kbd-shadows)/10%);padding-top:.1875em;padding-inline-end:.375em;padding-bottom:.1875em;border-radius:.3125rem;padding-inline-start:.375em;font-family:inherit;font-size:.875em;font-weight:500}.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-code);font-size:.875em;font-weight:600}.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)):before,.prose :where(code):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:"`"}.prose :where(a code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h1 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(h2 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-size:.875em}.prose :where(h3 code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit;font-size:.9em}.prose :where(h4 code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(blockquote code):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(thead th code):not(:where([class~=not-prose],[class~=not-prose] *)){color:inherit}.prose :where(pre):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-pre-code);background-color:var(--tw-prose-pre-bg);padding-top:.857143em;padding-inline-end:1.14286em;padding-bottom:.857143em;border-radius:.375rem;margin-top:1.71429em;margin-bottom:1.71429em;padding-inline-start:1.14286em;font-size:.875em;font-weight:400;line-height:1.71429;overflow-x:auto}.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)){font-weight:inherit;color:inherit;font-size:inherit;font-family:inherit;line-height:inherit;background-color:#0000;border-width:0;border-radius:0;padding:0}.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)):before,.prose :where(pre code):not(:where([class~=not-prose],[class~=not-prose] *)):after{content:none}.prose :where(table):not(:where([class~=not-prose],[class~=not-prose] *)){table-layout:auto;width:100%;margin-top:2em;margin-bottom:2em;font-size:.875em;line-height:1.71429}.prose :where(thead):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:1px;border-bottom-color:var(--tw-prose-th-borders)}.prose :where(thead th):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-headings);vertical-align:bottom;padding-inline-end:.571429em;padding-bottom:.571429em;padding-inline-start:.571429em;font-weight:600}.prose :where(tbody tr):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:1px;border-bottom-color:var(--tw-prose-td-borders)}.prose :where(tbody tr:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){border-bottom-width:0}.prose :where(tbody td):not(:where([class~=not-prose],[class~=not-prose] *)){vertical-align:baseline}.prose :where(tfoot):not(:where([class~=not-prose],[class~=not-prose] *)){border-top-width:1px;border-top-color:var(--tw-prose-th-borders)}.prose :where(tfoot td):not(:where([class~=not-prose],[class~=not-prose] *)){vertical-align:top}.prose :where(th,td):not(:where([class~=not-prose],[class~=not-prose] *)){text-align:start}.prose :where(figure>*):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0;margin-bottom:0}.prose :where(figcaption):not(:where([class~=not-prose],[class~=not-prose] *)){color:var(--tw-prose-captions);margin-top:.857143em;font-size:.875em;line-height:1.42857}.prose{--tw-prose-body:oklch(37.3% .034 259.733);--tw-prose-headings:oklch(21% .034 264.665);--tw-prose-lead:oklch(44.6% .03 256.802);--tw-prose-links:oklch(21% .034 264.665);--tw-prose-bold:oklch(21% .034 264.665);--tw-prose-counters:oklch(55.1% .027 264.364);--tw-prose-bullets:oklch(87.2% .01 258.338);--tw-prose-hr:oklch(92.8% .006 264.531);--tw-prose-quotes:oklch(21% .034 264.665);--tw-prose-quote-borders:oklch(92.8% .006 264.531);--tw-prose-captions:oklch(55.1% .027 264.364);--tw-prose-kbd:oklch(21% .034 264.665);--tw-prose-kbd-shadows:NaN NaN NaN;--tw-prose-code:oklch(21% .034 264.665);--tw-prose-pre-code:oklch(92.8% .006 264.531);--tw-prose-pre-bg:oklch(27.8% .033 256.848);--tw-prose-th-borders:oklch(87.2% .01 258.338);--tw-prose-td-borders:oklch(92.8% .006 264.531);--tw-prose-invert-body:oklch(87.2% .01 258.338);--tw-prose-invert-headings:#fff;--tw-prose-invert-lead:oklch(70.7% .022 261.325);--tw-prose-invert-links:#fff;--tw-prose-invert-bold:#fff;--tw-prose-invert-counters:oklch(70.7% .022 261.325);--tw-prose-invert-bullets:oklch(44.6% .03 256.802);--tw-prose-invert-hr:oklch(37.3% .034 259.733);--tw-prose-invert-quotes:oklch(96.7% .003 264.542);--tw-prose-invert-quote-borders:oklch(37.3% .034 259.733);--tw-prose-invert-captions:oklch(70.7% .022 261.325);--tw-prose-invert-kbd:#fff;--tw-prose-invert-kbd-shadows:255 255 255;--tw-prose-invert-code:#fff;--tw-prose-invert-pre-code:oklch(87.2% .01 258.338);--tw-prose-invert-pre-bg:#00000080;--tw-prose-invert-th-borders:oklch(44.6% .03 256.802);--tw-prose-invert-td-borders:oklch(37.3% .034 259.733);font-size:1rem;line-height:1.75}.prose :where(picture>img):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0;margin-bottom:0}.prose :where(li):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.5em;margin-bottom:.5em}.prose :where(ol>li):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(ul>li):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:.375em}.prose :where(.prose>ul>li p):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.75em;margin-bottom:.75em}.prose :where(.prose>ul>li>p:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em}.prose :where(.prose>ul>li>p:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:1.25em}.prose :where(.prose>ol>li>p:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em}.prose :where(.prose>ol>li>p:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:1.25em}.prose :where(ul ul,ul ol,ol ul,ol ol):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.75em;margin-bottom:.75em}.prose :where(dl):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:1.25em;margin-bottom:1.25em}.prose :where(dd):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:.5em;padding-inline-start:1.625em}.prose :where(hr+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h2+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h3+*):not(:where([class~=not-prose],[class~=not-prose] *)),.prose :where(h4+*):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0}.prose :where(thead th:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:0}.prose :where(thead th:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-end:0}.prose :where(tbody td,tfoot td):not(:where([class~=not-prose],[class~=not-prose] *)){padding-top:.571429em;padding-inline-end:.571429em;padding-bottom:.571429em;padding-inline-start:.571429em}.prose :where(tbody td:first-child,tfoot td:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-start:0}.prose :where(tbody td:last-child,tfoot td:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){padding-inline-end:0}.prose :where(figure):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:2em;margin-bottom:2em}.prose :where(.prose>:first-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-top:0}.prose :where(.prose>:last-child):not(:where([class~=not-prose],[class~=not-prose] *)){margin-bottom:0}.-mt-1{margin-top:calc(var(--spacing)*-1)}.mt-0{margin-top:calc(var(--spacing)*0)}.mt-0\.5{margin-top:calc(var(--spacing)*.5)}.mt-0\.75{margin-top:calc(var(--spacing)*.75)}.mt-1{margin-top:calc(var(--spacing)*1)}.mt-1\.5{margin-top:calc(var(--spacing)*1.5)}.mt-2{margin-top:calc(var(--spacing)*2)}.mt-3{margin-top:calc(var(--spacing)*3)}.mt-4{margin-top:calc(var(--spacing)*4)}.mt-6{margin-top:calc(var(--spacing)*6)}.mt-8{margin-top:calc(var(--spacing)*8)}.mt-12{margin-top:calc(var(--spacing)*12)}.mt-auto{margin-top:auto}.-mr-1{margin-right:calc(var(--spacing)*-1)}.-mr-1\.5{margin-right:calc(var(--spacing)*-1.5)}.mr-1{margin-right:calc(var(--spacing)*1)}.mr-2{margin-right:calc(var(--spacing)*2)}.mr-auto{margin-right:auto}.mb-0\.5{margin-bottom:calc(var(--spacing)*.5)}.mb-1{margin-bottom:calc(var(--spacing)*1)}.mb-1\.5{margin-bottom:calc(var(--spacing)*1.5)}.mb-2{margin-bottom:calc(var(--spacing)*2)}.mb-3{margin-bottom:calc(var(--spacing)*3)}.mb-4{margin-bottom:calc(var(--spacing)*4)}.mb-6{margin-bottom:calc(var(--spacing)*6)}.mb-8{margin-bottom:calc(var(--spacing)*8)}.mb-10{margin-bottom:calc(var(--spacing)*10)}.mb-\[calc\(50dvh-8rem\)\]{margin-bottom:calc(50dvh - 8rem)}.ml-1{margin-left:calc(var(--spacing)*1)}.ml-2{margin-left:calc(var(--spacing)*2)}.ml-3{margin-left:calc(var(--spacing)*3)}.ml-4{margin-left:calc(var(--spacing)*4)}.ml-11{margin-left:calc(var(--spacing)*11)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-5{-webkit-line-clamp:5;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.block\!{display:block!important}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-block{display:inline-block}.inline-flex{display:inline-flex}.inline-grid{display:inline-grid}.table{display:table}.table-caption{display:table-caption}.table-cell{display:table-cell}.table-row{display:table-row}.field-sizing-content{field-sizing:content}.aspect-square{aspect-ratio:1}.size-2{width:calc(var(--spacing)*2);height:calc(var(--spacing)*2)}.size-2\.5{width:calc(var(--spacing)*2.5);height:calc(var(--spacing)*2.5)}.size-3{width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.size-3\.5{width:calc(var(--spacing)*3.5);height:calc(var(--spacing)*3.5)}.size-4{width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.size-5{width:calc(var(--spacing)*5);height:calc(var(--spacing)*5)}.size-8{width:calc(var(--spacing)*8);height:calc(var(--spacing)*8)}.size-9{width:calc(var(--spacing)*9);height:calc(var(--spacing)*9)}.size-10{width:calc(var(--spacing)*10);height:calc(var(--spacing)*10)}.size-full{width:100%;height:100%}.\!h-0{height:calc(var(--spacing)*0)!important}.\!h-4{height:calc(var(--spacing)*4)!important}.h-\(--bits-select-anchor-height\){height:var(--bits-select-anchor-height)}.h-0{height:calc(var(--spacing)*0)}.h-0\!{height:calc(var(--spacing)*0)!important}.h-0\.5{height:calc(var(--spacing)*.5)}.h-1{height:calc(var(--spacing)*1)}.h-1\.5{height:calc(var(--spacing)*1.5)}.h-2{height:calc(var(--spacing)*2)}.h-2\.5{height:calc(var(--spacing)*2.5)}.h-3{height:calc(var(--spacing)*3)}.h-3\.5{height:calc(var(--spacing)*3.5)}.h-4{height:calc(var(--spacing)*4)}.h-4\.5{height:calc(var(--spacing)*4.5)}.h-5{height:calc(var(--spacing)*5)}.h-6{height:calc(var(--spacing)*6)}.h-7{height:calc(var(--spacing)*7)}.h-8{height:calc(var(--spacing)*8)}.h-9{height:calc(var(--spacing)*9)}.h-10{height:calc(var(--spacing)*10)}.h-12{height:calc(var(--spacing)*12)}.h-16{height:calc(var(--spacing)*16)}.h-24{height:calc(var(--spacing)*24)}.h-40{height:calc(var(--spacing)*40)}.h-48{height:calc(var(--spacing)*48)}.h-100{height:calc(var(--spacing)*100)}.h-\[1\.15rem\]{height:1.15rem}.h-\[500px\]{height:500px}.h-\[calc\(100dvh-0\.5rem\)\]{height:calc(100dvh - .5rem)}.h-\[calc\(100dvh-1rem\)\]{height:calc(100dvh - 1rem)}.h-\[calc\(100dvh-2rem\)\]{height:calc(100dvh - 2rem)}.h-auto{height:auto}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.\!max-h-\[50vh\]{max-height:50vh!important}.\!max-h-\[80dvh\]{max-height:80dvh!important}.max-h-\(--bits-dropdown-menu-content-available-height\){max-height:var(--bits-dropdown-menu-content-available-height)}.max-h-\(--bits-select-content-available-height\){max-height:var(--bits-select-content-available-height)}.max-h-24{max-height:calc(var(--spacing)*24)}.max-h-32{max-height:calc(var(--spacing)*32)}.max-h-48{max-height:calc(var(--spacing)*48)}.max-h-64{max-height:calc(var(--spacing)*64)}.max-h-80{max-height:calc(var(--spacing)*80)}.max-h-96{max-height:calc(var(--spacing)*96)}.max-h-\[60vh\]{max-height:60vh}.max-h-\[70vh\]{max-height:70vh}.max-h-\[80vh\]{max-height:80vh}.max-h-\[85vh\]{max-height:85vh}.max-h-\[90vh\]{max-height:90vh}.max-h-\[100dvh\]{max-height:100dvh}.max-h-full{max-height:100%}.min-h-0{min-height:calc(var(--spacing)*0)}.min-h-4{min-height:calc(var(--spacing)*4)}.min-h-9{min-height:calc(var(--spacing)*9)}.min-h-12{min-height:calc(var(--spacing)*12)}.min-h-16{min-height:calc(var(--spacing)*16)}.min-h-22{min-height:calc(var(--spacing)*22)}.min-h-\[10rem\]{min-height:10rem}.min-h-\[60px\]{min-height:60px}.min-h-\[200px\]{min-height:200px}.min-h-\[calc\(100dvh-1rem\)\]{min-height:calc(100dvh - 1rem)}.min-h-\[calc\(100dvh-4rem\)\]{min-height:calc(100dvh - 4rem)}.min-h-fit{min-height:fit-content}.min-h-full{min-height:100%}.\!w-4{width:calc(var(--spacing)*4)!important}.w-0{width:calc(var(--spacing)*0)}.w-1{width:calc(var(--spacing)*1)}.w-1\/3{width:33.3333%}.w-2{width:calc(var(--spacing)*2)}.w-2\.5{width:calc(var(--spacing)*2.5)}.w-2\/5{width:40%}.w-3{width:calc(var(--spacing)*3)}.w-3\.5{width:calc(var(--spacing)*3.5)}.w-3\/4{width:75%}.w-4{width:calc(var(--spacing)*4)}.w-4\.5{width:calc(var(--spacing)*4.5)}.w-5{width:calc(var(--spacing)*5)}.w-5\/6{width:83.3333%}.w-6{width:calc(var(--spacing)*6)}.w-7{width:calc(var(--spacing)*7)}.w-8{width:calc(var(--spacing)*8)}.w-9{width:calc(var(--spacing)*9)}.w-10{width:calc(var(--spacing)*10)}.w-11{width:calc(var(--spacing)*11)}.w-12{width:calc(var(--spacing)*12)}.w-14{width:calc(var(--spacing)*14)}.w-16{width:calc(var(--spacing)*16)}.w-20{width:calc(var(--spacing)*20)}.w-24{width:calc(var(--spacing)*24)}.w-28{width:calc(var(--spacing)*28)}.w-32{width:calc(var(--spacing)*32)}.w-36{width:calc(var(--spacing)*36)}.w-40{width:calc(var(--spacing)*40)}.w-48{width:calc(var(--spacing)*48)}.w-52{width:calc(var(--spacing)*52)}.w-60{width:calc(var(--spacing)*60)}.w-64{width:calc(var(--spacing)*64)}.w-72{width:calc(var(--spacing)*72)}.w-80{width:calc(var(--spacing)*80)}.w-96{width:calc(var(--spacing)*96)}.w-\[10rem\]{width:10rem}.w-\[56rem\]{width:56rem}.w-\[calc\(100dvw-1rem\)\]{width:calc(100dvw - 1rem)}.w-\[calc\(100vw-2rem\)\]{width:calc(100vw - 2rem)}.w-\[var\(--bits-popover-anchor-width\)\]{width:var(--bits-popover-anchor-width)}.w-auto{width:auto}.w-fit{width:fit-content}.w-full{width:100%}.w-px{width:1px}.\!max-w-4xl{max-width:var(--container-4xl)!important}.\!max-w-\[60rem\]{max-width:60rem!important}.max-w-2xl{max-width:var(--container-2xl)}.max-w-3xl{max-width:var(--container-3xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-24{max-width:calc(var(--spacing)*24)}.max-w-36{max-width:calc(var(--spacing)*36)}.max-w-64{max-width:calc(var(--spacing)*64)}.max-w-68{max-width:calc(var(--spacing)*68)}.max-w-72{max-width:calc(var(--spacing)*72)}.max-w-\[48rem\]{max-width:48rem}.max-w-\[56rem\]{max-width:56rem}.max-w-\[80\%\]{max-width:80%}.max-w-\[80vw\]{max-width:80vw}.max-w-\[85vw\]{max-width:85vw}.max-w-\[90vw\]{max-width:90vw}.max-w-\[100vw\]{max-width:100vw}.max-w-\[150px\]{max-width:150px}.max-w-\[300px\]{max-width:300px}.max-w-\[calc\(100\%-2rem\)\]{max-width:calc(100% - 2rem)}.max-w-full{max-width:100%}.max-w-full\!{max-width:100%!important}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-none{max-width:none}.max-w-sm{max-width:var(--container-sm)}.max-w-xs{max-width:var(--container-xs)}.min-w-\(--bits-select-anchor-width\){min-width:var(--bits-select-anchor-width)}.min-w-0{min-width:calc(var(--spacing)*0)}.min-w-9{min-width:calc(var(--spacing)*9)}.min-w-\[3\.5rem\]{min-width:3.5rem}.min-w-\[8rem\]{min-width:8rem}.min-w-\[200px\]{min-width:200px}.min-w-fit{min-width:fit-content}.min-w-max{min-width:max-content}.flex-1{flex:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.caption-bottom{caption-side:bottom}.origin-\(--bits-dropdown-menu-content-transform-origin\){transform-origin:var(--bits-dropdown-menu-content-transform-origin)}.origin-\(--bits-popover-content-transform-origin\){transform-origin:var(--bits-popover-content-transform-origin)}.origin-\(--bits-select-content-transform-origin\){transform-origin:var(--bits-select-content-transform-origin)}.origin-\(--bits-tooltip-content-transform-origin\){transform-origin:var(--bits-tooltip-content-transform-origin)}.origin-\(--transform-origin\){transform-origin:var(--transform-origin)}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-x-0{--tw-translate-x:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.-translate-y-1\/2{--tw-translate-y: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-y-0{--tw-translate-y:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.scale-75{--tw-scale-x:75%;--tw-scale-y:75%;--tw-scale-z:75%;scale:var(--tw-scale-x)var(--tw-scale-y)}.rotate-45{rotate:45deg}.rotate-180{rotate:180deg}.transform{transform:var(--tw-rotate-x,)var(--tw-rotate-y,)var(--tw-rotate-z,)var(--tw-skew-x,)var(--tw-skew-y,)}.animate-in{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.\!cursor-not-allowed{cursor:not-allowed!important}.cursor-auto{cursor:auto}.cursor-default{cursor:default}.cursor-not-allowed{cursor:not-allowed}.cursor-pointer{cursor:pointer}.cursor-text{cursor:text}.touch-none{touch-action:none}.resize{resize:both}.resize-none{resize:none}.scroll-my-1{scroll-margin-block:calc(var(--spacing)*1)}.list-inside{list-style-position:inside}.list-disc{list-style-type:disc}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-\[0_1fr\]{grid-template-columns:0 1fr}.grid-cols-\[1fr_auto_1fr\]{grid-template-columns:1fr auto 1fr}.grid-rows-\[1fr_auto\]{grid-template-rows:1fr auto}.grid-rows-\[auto_auto\]{grid-template-rows:auto auto}.flex-col{flex-direction:column}.flex-col-reverse{flex-direction:column-reverse}.flex-row{flex-direction:row}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.justify-end{justify-content:flex-end}.justify-start{justify-content:flex-start}.justify-items-end{justify-items:end}.justify-items-start{justify-items:start}.\!gap-3{gap:calc(var(--spacing)*3)!important}.gap-0{gap:calc(var(--spacing)*0)}.gap-0\.5{gap:calc(var(--spacing)*.5)}.gap-0\.75{gap:calc(var(--spacing)*.75)}.gap-1{gap:calc(var(--spacing)*1)}.gap-1\.5{gap:calc(var(--spacing)*1.5)}.gap-1\.25{gap:calc(var(--spacing)*1.25)}.gap-2{gap:calc(var(--spacing)*2)}.gap-2\.5{gap:calc(var(--spacing)*2.5)}.gap-3{gap:calc(var(--spacing)*3)}.gap-3\!{gap:calc(var(--spacing)*3)!important}.gap-4{gap:calc(var(--spacing)*4)}.gap-5{gap:calc(var(--spacing)*5)}.gap-6{gap:calc(var(--spacing)*6)}.gap-10{gap:calc(var(--spacing)*10)}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*.5)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*.5)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*1)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*1)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*1.5)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*1.5)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*2)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*2)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*3)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*3)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*4)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*4)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*6)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*6)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*8)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*8)*calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-12>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing)*12)*var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing)*12)*calc(1 - var(--tw-space-y-reverse)))}:where(.-space-x-1>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*-1)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*-1)*calc(1 - var(--tw-space-x-reverse)))}:where(.space-x-2>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*2)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*2)*calc(1 - var(--tw-space-x-reverse)))}:where(.space-x-3>:not(:last-child)){--tw-space-x-reverse:0;margin-inline-start:calc(calc(var(--spacing)*3)*var(--tw-space-x-reverse));margin-inline-end:calc(calc(var(--spacing)*3)*calc(1 - var(--tw-space-x-reverse)))}.gap-y-0\.5{row-gap:calc(var(--spacing)*.5)}.self-start{align-self:flex-start}.self-stretch{align-self:stretch}.justify-self-end{justify-self:flex-end}.justify-self-end-safe{justify-self:safe flex-end}.justify-self-start{justify-self:flex-start}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-x-hidden{overflow-x:hidden}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-3xl{border-radius:var(--radius-3xl)}.rounded-4xl{border-radius:var(--radius-4xl)}.rounded-\[1\.125rem\]{border-radius:1.125rem}.rounded-\[2px\]{border-radius:2px}.rounded-\[4px\]{border-radius:4px}.rounded-\[inherit\]{border-radius:inherit}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.rounded-sm{border-radius:calc(var(--radius) - 4px)}.rounded-xl{border-radius:calc(var(--radius) + 4px)}.rounded-xs{border-radius:var(--radius-xs)}.rounded-t-lg{border-top-left-radius:var(--radius);border-top-right-radius:var(--radius)}.rounded-t-lg\!{border-top-left-radius:var(--radius)!important;border-top-right-radius:var(--radius)!important}.\!rounded-l-none{border-top-left-radius:0!important;border-bottom-left-radius:0!important}.\!rounded-r-none{border-top-right-radius:0!important;border-bottom-right-radius:0!important}.rounded-b-sm{border-bottom-right-radius:calc(var(--radius) - 4px);border-bottom-left-radius:calc(var(--radius) - 4px)}.\!border-2{border-style:var(--tw-border-style)!important;border-width:2px!important}.border{border-style:var(--tw-border-style);border-width:1px}.border-0{border-style:var(--tw-border-style);border-width:0}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-4{border-style:var(--tw-border-style);border-width:4px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-r{border-right-style:var(--tw-border-style);border-right-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-dashed{--tw-border-style:dashed!important;border-style:dashed!important}.border-dashed{--tw-border-style:dashed;border-style:dashed}.border-none{--tw-border-style:none;border-style:none}.\!border-border\/50{border-color:var(--border)!important}@supports (color:color-mix(in lab,red,red)){.\!border-border\/50{border-color:color-mix(in oklab,var(--border)50%,transparent)!important}}.border-amber-500\/40{border-color:#f99c0066}@supports (color:color-mix(in lab,red,red)){.border-amber-500\/40{border-color:color-mix(in oklab,var(--color-amber-500)40%,transparent)}}.border-blue-400\/40{border-color:#54a2ff66}@supports (color:color-mix(in lab,red,red)){.border-blue-400\/40{border-color:color-mix(in oklab,var(--color-blue-400)40%,transparent)}}.border-border,.border-border\/30{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/30{border-color:color-mix(in oklab,var(--border)30%,transparent)}}.border-border\/40{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/40{border-color:color-mix(in oklab,var(--border)40%,transparent)}}.border-border\/50{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/50{border-color:color-mix(in oklab,var(--border)50%,transparent)}}.border-border\/60{border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.border-border\/60{border-color:color-mix(in oklab,var(--border)60%,transparent)}}.border-current{border-color:currentColor}.border-destructive,.border-destructive\/40{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.border-destructive\/40{border-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.border-destructive\/50{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.border-destructive\/50{border-color:color-mix(in oklab,var(--destructive)50%,transparent)}}.border-flame,.border-flame\/30{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/30{border-color:color-mix(in oklab,var(--flame)30%,transparent)}}.border-flame\/40{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/40{border-color:color-mix(in oklab,var(--flame)40%,transparent)}}.border-flame\/50{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.border-flame\/50{border-color:color-mix(in oklab,var(--flame)50%,transparent)}}.border-green-500{border-color:var(--color-green-500)}.border-input{border-color:var(--input)}.border-muted-foreground\/20{border-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.border-muted-foreground\/20{border-color:color-mix(in oklab,var(--muted-foreground)20%,transparent)}}.border-purple-200{border-color:var(--color-purple-200)}.border-red-500\/50{border-color:#fb2c3680}@supports (color:color-mix(in lab,red,red)){.border-red-500\/50{border-color:color-mix(in oklab,var(--color-red-500)50%,transparent)}}.border-transparent{border-color:#0000}.border-white{border-color:var(--color-white)}.border-t-transparent{border-top-color:#0000}.border-l-transparent{border-left-color:#0000}.bg-accent,.bg-accent\/50{background-color:var(--accent)}@supports (color:color-mix(in lab,red,red)){.bg-accent\/50{background-color:color-mix(in oklab,var(--accent)50%,transparent)}}.bg-amber-500{background-color:var(--color-amber-500)}.bg-amber-500\/10{background-color:#f99c001a}@supports (color:color-mix(in lab,red,red)){.bg-amber-500\/10{background-color:color-mix(in oklab,var(--color-amber-500)10%,transparent)}}.bg-amber-500\/20{background-color:#f99c0033}@supports (color:color-mix(in lab,red,red)){.bg-amber-500\/20{background-color:color-mix(in oklab,var(--color-amber-500)20%,transparent)}}.bg-background,.bg-background\/5{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/5{background-color:color-mix(in oklab,var(--background)5%,transparent)}}.bg-background\/25{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/25{background-color:color-mix(in oklab,var(--background)25%,transparent)}}.bg-background\/50{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/50{background-color:color-mix(in oklab,var(--background)50%,transparent)}}.bg-background\/70{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.bg-background\/70{background-color:color-mix(in oklab,var(--background)70%,transparent)}}.bg-black\/5{background-color:#0000000d}@supports (color:color-mix(in lab,red,red)){.bg-black\/5{background-color:color-mix(in oklab,var(--color-black)5%,transparent)}}.bg-black\/50{background-color:#00000080}@supports (color:color-mix(in lab,red,red)){.bg-black\/50{background-color:color-mix(in oklab,var(--color-black)50%,transparent)}}.bg-black\/80{background-color:#000c}@supports (color:color-mix(in lab,red,red)){.bg-black\/80{background-color:color-mix(in oklab,var(--color-black)80%,transparent)}}.bg-black\/85{background-color:#000000d9}@supports (color:color-mix(in lab,red,red)){.bg-black\/85{background-color:color-mix(in oklab,var(--color-black)85%,transparent)}}.bg-blue-50{background-color:var(--color-blue-50)}.bg-blue-50\/60{background-color:#eff6ff99}@supports (color:color-mix(in lab,red,red)){.bg-blue-50\/60{background-color:color-mix(in oklab,var(--color-blue-50)60%,transparent)}}.bg-border,.bg-border\/20{background-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.bg-border\/20{background-color:color-mix(in oklab,var(--border)20%,transparent)}}.bg-border\/50{background-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.bg-border\/50{background-color:color-mix(in oklab,var(--border)50%,transparent)}}.bg-card,.bg-card\/60{background-color:var(--card)}@supports (color:color-mix(in lab,red,red)){.bg-card\/60{background-color:color-mix(in oklab,var(--card)60%,transparent)}}.bg-cyan-50{background-color:var(--color-cyan-50)}.bg-destructive,.bg-destructive\/10{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/10{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.bg-destructive\/15{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/15{background-color:color-mix(in oklab,var(--destructive)15%,transparent)}}.bg-destructive\/20{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.bg-destructive\/20{background-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.bg-flame,.bg-flame\/5{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.bg-flame\/5{background-color:color-mix(in oklab,var(--flame)5%,transparent)}}.bg-flame\/10{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.bg-flame\/10{background-color:color-mix(in oklab,var(--flame)10%,transparent)}}.bg-foreground\/5{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/5{background-color:color-mix(in oklab,var(--foreground)5%,transparent)}}.bg-foreground\/15{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/15{background-color:color-mix(in oklab,var(--foreground)15%,transparent)}}.bg-foreground\/20{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.bg-foreground\/20{background-color:color-mix(in oklab,var(--foreground)20%,transparent)}}.bg-gray-500{background-color:var(--color-gray-500)}.bg-green-50{background-color:var(--color-green-50)}.bg-green-500{background-color:var(--color-green-500)}.bg-muted{background-color:var(--muted)}.bg-muted\!{background-color:var(--muted)!important}.bg-muted-foreground\/10{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/10{background-color:color-mix(in oklab,var(--muted-foreground)10%,transparent)}}.bg-muted-foreground\/15{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/15{background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.bg-muted-foreground\/50{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.bg-muted-foreground\/50{background-color:color-mix(in oklab,var(--muted-foreground)50%,transparent)}}.bg-muted\/10{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/10{background-color:color-mix(in oklab,var(--muted)10%,transparent)}}.bg-muted\/20{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/20{background-color:color-mix(in oklab,var(--muted)20%,transparent)}}.bg-muted\/30{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/30{background-color:color-mix(in oklab,var(--muted)30%,transparent)}}.bg-muted\/40{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/40{background-color:color-mix(in oklab,var(--muted)40%,transparent)}}.bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/50{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}.bg-muted\/60{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/60{background-color:color-mix(in oklab,var(--muted)60%,transparent)}}.bg-muted\/75{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/75{background-color:color-mix(in oklab,var(--muted)75%,transparent)}}.bg-muted\/80{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.bg-muted\/80{background-color:color-mix(in oklab,var(--muted)80%,transparent)}}.bg-orange-50{background-color:var(--color-orange-50)}.bg-orange-100{background-color:var(--color-orange-100)}.bg-orange-400{background-color:var(--color-orange-400)}.bg-pink-50{background-color:var(--color-pink-50)}.bg-popover{background-color:var(--popover)}.bg-primary{background-color:var(--primary)}.bg-primary-foreground{background-color:var(--primary-foreground)}.bg-primary\/5{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.bg-primary\/5{background-color:color-mix(in oklab,var(--primary)5%,transparent)}}.bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.bg-primary\/10{background-color:color-mix(in oklab,var(--primary)10%,transparent)}}.bg-purple-50{background-color:var(--color-purple-50)}.bg-purple-200\/60{background-color:#e9d5ff99}@supports (color:color-mix(in lab,red,red)){.bg-purple-200\/60{background-color:color-mix(in oklab,var(--color-purple-200)60%,transparent)}}.bg-purple-300\/50{background-color:#d9b3ff80}@supports (color:color-mix(in lab,red,red)){.bg-purple-300\/50{background-color:color-mix(in oklab,var(--color-purple-300)50%,transparent)}}.bg-purple-500\/10{background-color:#ac4bff1a}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/10{background-color:color-mix(in oklab,var(--color-purple-500)10%,transparent)}}.bg-red-400\/10{background-color:#ff65681a}@supports (color:color-mix(in lab,red,red)){.bg-red-400\/10{background-color:color-mix(in oklab,var(--color-red-400)10%,transparent)}}.bg-red-500{background-color:var(--color-red-500)}.bg-red-500\/10{background-color:#fb2c361a}@supports (color:color-mix(in lab,red,red)){.bg-red-500\/10{background-color:color-mix(in oklab,var(--color-red-500)10%,transparent)}}.bg-secondary{background-color:var(--secondary)}.bg-transparent{background-color:#0000}.bg-transparent\!{background-color:#0000!important}.bg-yellow-200\/60{background-color:#fff08599}@supports (color:color-mix(in lab,red,red)){.bg-yellow-200\/60{background-color:color-mix(in oklab,var(--color-yellow-200)60%,transparent)}}.bg-yellow-500{background-color:var(--color-yellow-500)}.bg-yellow-500\/10{background-color:#edb2001a}@supports (color:color-mix(in lab,red,red)){.bg-yellow-500\/10{background-color:color-mix(in oklab,var(--color-yellow-500)10%,transparent)}}.bg-gradient-to-r{--tw-gradient-position:to right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.bg-gradient-to-t{--tw-gradient-position:to top in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-flame{--tw-gradient-from:var(--flame);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.from-muted{--tw-gradient-from:var(--muted);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.to-ember{--tw-gradient-to:var(--ember);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.to-transparent{--tw-gradient-to:transparent;--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position),var(--tw-gradient-from)var(--tw-gradient-from-position),var(--tw-gradient-to)var(--tw-gradient-to-position))}.bg-clip-padding{background-clip:padding-box}.fill-current{fill:currentColor}.fill-muted-foreground{fill:var(--muted-foreground)}.fill-white{fill:var(--color-white)}.stroke-muted-foreground{stroke:var(--muted-foreground)}.object-contain{object-fit:contain}.object-cover{object-fit:cover}.p-0{padding:calc(var(--spacing)*0)}.p-0\.5{padding:calc(var(--spacing)*.5)}.p-1{padding:calc(var(--spacing)*1)}.p-1\.5{padding:calc(var(--spacing)*1.5)}.p-2{padding:calc(var(--spacing)*2)}.p-2\.5{padding:calc(var(--spacing)*2.5)}.p-3{padding:calc(var(--spacing)*3)}.p-3\.5{padding:calc(var(--spacing)*3.5)}.p-4{padding:calc(var(--spacing)*4)}.p-5{padding:calc(var(--spacing)*5)}.p-6{padding:calc(var(--spacing)*6)}.p-8{padding:calc(var(--spacing)*8)}.p-12{padding:calc(var(--spacing)*12)}.p-px{padding:1px}.\!px-2{padding-inline:calc(var(--spacing)*2)!important}.px-0{padding-inline:calc(var(--spacing)*0)}.px-0\.5{padding-inline:calc(var(--spacing)*.5)}.px-1{padding-inline:calc(var(--spacing)*1)}.px-1\.5{padding-inline:calc(var(--spacing)*1.5)}.px-2{padding-inline:calc(var(--spacing)*2)}.px-2\.5{padding-inline:calc(var(--spacing)*2.5)}.px-3{padding-inline:calc(var(--spacing)*3)}.px-3\.75{padding-inline:calc(var(--spacing)*3.75)}.px-4{padding-inline:calc(var(--spacing)*4)}.px-5{padding-inline:calc(var(--spacing)*5)}.px-6{padding-inline:calc(var(--spacing)*6)}.py-0{padding-block:calc(var(--spacing)*0)}.py-0\.5{padding-block:calc(var(--spacing)*.5)}.py-0\.75{padding-block:calc(var(--spacing)*.75)}.py-1{padding-block:calc(var(--spacing)*1)}.py-1\.5{padding-block:calc(var(--spacing)*1.5)}.py-1\.75{padding-block:calc(var(--spacing)*1.75)}.py-2{padding-block:calc(var(--spacing)*2)}.py-2\.5{padding-block:calc(var(--spacing)*2.5)}.py-3{padding-block:calc(var(--spacing)*3)}.py-4{padding-block:calc(var(--spacing)*4)}.py-5{padding-block:calc(var(--spacing)*5)}.py-6{padding-block:calc(var(--spacing)*6)}.py-8{padding-block:calc(var(--spacing)*8)}.py-10{padding-block:calc(var(--spacing)*10)}.py-16{padding-block:calc(var(--spacing)*16)}.pt-0{padding-top:calc(var(--spacing)*0)}.pt-1{padding-top:calc(var(--spacing)*1)}.pt-1\.5{padding-top:calc(var(--spacing)*1.5)}.pt-2{padding-top:calc(var(--spacing)*2)}.pt-3{padding-top:calc(var(--spacing)*3)}.pt-4{padding-top:calc(var(--spacing)*4)}.pt-6{padding-top:calc(var(--spacing)*6)}.pt-10{padding-top:calc(var(--spacing)*10)}.pt-12{padding-top:calc(var(--spacing)*12)}.pt-13{padding-top:calc(var(--spacing)*13)}.pt-16{padding-top:calc(var(--spacing)*16)}.pr-1{padding-right:calc(var(--spacing)*1)}.pr-2{padding-right:calc(var(--spacing)*2)}.pr-8{padding-right:calc(var(--spacing)*8)}.pr-9{padding-right:calc(var(--spacing)*9)}.pr-10{padding-right:calc(var(--spacing)*10)}.pb-0{padding-bottom:calc(var(--spacing)*0)}.pb-0\.5{padding-bottom:calc(var(--spacing)*.5)}.pb-1{padding-bottom:calc(var(--spacing)*1)}.pb-2{padding-bottom:calc(var(--spacing)*2)}.pb-2\.25{padding-bottom:calc(var(--spacing)*2.25)}.pb-3{padding-bottom:calc(var(--spacing)*3)}.pb-4{padding-bottom:calc(var(--spacing)*4)}.pb-6{padding-bottom:calc(var(--spacing)*6)}.pb-48{padding-bottom:calc(var(--spacing)*48)}.pl-1\.5{padding-left:calc(var(--spacing)*1.5)}.pl-2{padding-left:calc(var(--spacing)*2)}.pl-4{padding-left:calc(var(--spacing)*4)}.pl-6{padding-left:calc(var(--spacing)*6)}.pl-8{padding-left:calc(var(--spacing)*8)}.pl-9{padding-left:calc(var(--spacing)*9)}.pl-16{padding-left:calc(var(--spacing)*16)}.text-center{text-align:center}.text-left{text-align:left}.align-middle{vertical-align:middle}.font-mono{font-family:var(--font-mono)}.font-sans{font-family:var(--font-sans)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-sm\/relaxed{font-size:var(--text-sm);line-height:var(--leading-relaxed)}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[12px\]{font-size:12px}.text-\[13px\]{font-size:13px}.leading-5{--tw-leading:calc(var(--spacing)*5);line-height:calc(var(--spacing)*5)}.leading-6{--tw-leading:calc(var(--spacing)*6);line-height:calc(var(--spacing)*6)}.leading-7\.5{--tw-leading:calc(var(--spacing)*7.5);line-height:calc(var(--spacing)*7.5)}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.leading-tight{--tw-leading:var(--leading-tight);line-height:var(--leading-tight)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.text-balance{text-wrap:balance}.break-words,.wrap-break-word{overflow-wrap:break-word}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-line{white-space:pre-line}.whitespace-pre-wrap{white-space:pre-wrap}.\!text-red-400{color:var(--color-red-400)!important}.text-accent-foreground{color:var(--accent-foreground)}.text-amber-400{color:var(--color-amber-400)}.text-amber-500{color:var(--color-amber-500)}.text-amber-600{color:var(--color-amber-600)}.text-blue-600{color:var(--color-blue-600)}.text-blue-700{color:var(--color-blue-700)}.text-card-foreground{color:var(--card-foreground)}.text-current{color:currentColor}.text-cyan-600{color:var(--color-cyan-600)}.text-destructive{color:var(--destructive)}.text-eye{color:var(--eye)}.text-flame{color:var(--flame)}.text-foreground,.text-foreground\/80{color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.text-foreground\/80{color:color-mix(in oklab,var(--foreground)80%,transparent)}}.text-foreground\/90{color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.text-foreground\/90{color:color-mix(in oklab,var(--foreground)90%,transparent)}}.text-gold{color:var(--gold)}.text-green-500{color:var(--color-green-500)}.text-green-600{color:var(--color-green-600)}.text-muted-foreground,.text-muted-foreground\/50{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/50{color:color-mix(in oklab,var(--muted-foreground)50%,transparent)}}.text-muted-foreground\/60{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/60{color:color-mix(in oklab,var(--muted-foreground)60%,transparent)}}.text-muted-foreground\/70{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/70{color:color-mix(in oklab,var(--muted-foreground)70%,transparent)}}.text-muted-foreground\/80{color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.text-muted-foreground\/80{color:color-mix(in oklab,var(--muted-foreground)80%,transparent)}}.text-orange-600{color:var(--color-orange-600)}.text-orange-800{color:var(--color-orange-800)}.text-pink-600{color:var(--color-pink-600)}.text-popover-foreground,.text-popover-foreground\/85{color:var(--popover-foreground)}@supports (color:color-mix(in lab,red,red)){.text-popover-foreground\/85{color:color-mix(in oklab,var(--popover-foreground)85%,transparent)}}.text-primary{color:var(--primary)}.text-primary-foreground{color:var(--primary-foreground)}.text-purple-600{color:var(--color-purple-600)}.text-purple-700{color:var(--color-purple-700)}.text-purple-900{color:var(--color-purple-900)}.text-red-400{color:var(--color-red-400)}.text-red-500{color:var(--color-red-500)}.text-red-600{color:var(--color-red-600)}.text-secondary-foreground{color:var(--secondary-foreground)}.text-transparent{color:#0000}.text-white{color:var(--color-white)}.text-white\!{color:var(--color-white)!important}.text-white\/50{color:#ffffff80}@supports (color:color-mix(in lab,red,red)){.text-white\/50{color:color-mix(in oklab,var(--color-white)50%,transparent)}}.text-white\/60{color:#fff9}@supports (color:color-mix(in lab,red,red)){.text-white\/60{color:color-mix(in oklab,var(--color-white)60%,transparent)}}.text-white\/70{color:#ffffffb3}@supports (color:color-mix(in lab,red,red)){.text-white\/70{color:color-mix(in oklab,var(--color-white)70%,transparent)}}.text-yellow-600{color:var(--color-yellow-600)}.capitalize{text-transform:capitalize}.lowercase{text-transform:lowercase}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,)var(--tw-slashed-zero,)var(--tw-numeric-figure,)var(--tw-numeric-spacing,)var(--tw-numeric-fraction,)}.no-underline{text-decoration-line:none}.underline{text-decoration-line:underline}.underline-offset-4{text-underline-offset:4px}.opacity-0{opacity:0}.opacity-30{opacity:.3}.opacity-40{opacity:.4}.opacity-50{opacity:.5}.opacity-60{opacity:.6}.opacity-70{opacity:.7}.opacity-80{opacity:.8}.opacity-100{opacity:1}.mix-blend-difference{mix-blend-mode:difference}.\!shadow-none{--tw-shadow:0 0 #0000!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a),0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_1px_2px_0_rgb\(0_0_0_\/_0\.05\)\]{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a),0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-sm{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a),0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a),0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xs{--tw-shadow:0 1px 2px 0 var(--tw-shadow-color,#0000000d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-0{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(0px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-1{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-flame\/10{--tw-shadow-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.shadow-flame\/10{--tw-shadow-color:color-mix(in oklab,color-mix(in oklab,var(--flame)10%,transparent)var(--tw-shadow-alpha),transparent)}}.ring-flame{--tw-ring-color:var(--flame)}.ring-foreground\/10{--tw-ring-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.ring-foreground\/10{--tw-ring-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.ring-muted{--tw-ring-color:var(--muted)}.ring-primary\/40{--tw-ring-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.ring-primary\/40{--tw-ring-color:color-mix(in oklab,var(--primary)40%,transparent)}}.ring-ring\/10{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.ring-ring\/10{--tw-ring-color:color-mix(in oklab,var(--ring)10%,transparent)}}.ring-offset-background{--tw-ring-offset-color:var(--background)}.outline-hidden{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.outline-hidden{outline-offset:2px;outline:2px solid #0000}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.outline-ring\/50{outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.outline-ring\/50{outline-color:color-mix(in oklab,var(--ring)50%,transparent)}}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.invert{--tw-invert:invert(100%);filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,)var(--tw-brightness,)var(--tw-contrast,)var(--tw-grayscale,)var(--tw-hue-rotate,)var(--tw-invert,)var(--tw-saturate,)var(--tw-sepia,)var(--tw-drop-shadow,)}.backdrop-blur-2xl{--tw-backdrop-blur:blur(var(--blur-2xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-lg\!{--tw-backdrop-blur:blur(var(--blur-lg))!important;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important;backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-none{--tw-backdrop-blur: ;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-none\!{--tw-backdrop-blur: !important;-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important;backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)!important}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-xl{--tw-backdrop-blur:blur(var(--blur-xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-blur-xs{--tw-backdrop-blur:blur(var(--blur-xs));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,visibility,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[color\,box-shadow\]{transition-property:color,box-shadow;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[opacity\,height\]{transition-property:opacity,height;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[width\,opacity\]{transition-property:width,opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-\[width\]{transition-property:width;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-opacity{transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-shadow{transition-property:box-shadow;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-none{transition-property:none}.duration-100{--tw-duration:.1s;transition-duration:.1s}.duration-150{--tw-duration:.15s;transition-duration:.15s}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.will-change-transform{will-change:transform}.fade-in-0{--tw-enter-opacity:0}.outline-none{--tw-outline-style:none;outline-style:none}.select-all{-webkit-user-select:all;user-select:all}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.zoom-in-95{--tw-enter-scale:.95}.running{animation-play-state:running}.group-focus-within\:opacity-100:is(:where(.group):focus-within *){opacity:1}@media(hover:hover){.group-hover\:pointer-events-auto:is(:where(.group):hover *){pointer-events:auto}.group-hover\:flex:is(:where(.group):hover *){display:flex}.group-hover\:hidden:is(:where(.group):hover *){display:none}.group-hover\:w-auto:is(:where(.group):hover *){width:auto}.group-hover\:fill-destructive:is(:where(.group):hover *){fill:var(--destructive)}.group-hover\:stroke-destructive:is(:where(.group):hover *){stroke:var(--destructive)}.group-hover\:stroke-foreground:is(:where(.group):hover *){stroke:var(--foreground)}.group-hover\:pr-6:is(:where(.group):hover *){padding-right:calc(var(--spacing)*6)}.group-hover\:opacity-100:is(:where(.group):hover *),.group-hover\/collapsible\:opacity-100:is(:where(.group\/collapsible):hover *),.group-hover\/expand\:opacity-100:is(:where(.group\/expand):hover *){opacity:1}}.group-data-\[disabled\=true\]\:pointer-events-none:is(:where(.group)[data-disabled=true] *){pointer-events:none}.group-data-\[disabled\=true\]\:opacity-50:is(:where(.group)[data-disabled=true] *){opacity:.5}.group-data-\[state\=open\]\:-rotate-180:is(:where(.group)[data-state=open] *){rotate:-180deg}.peer-disabled\:cursor-not-allowed:is(:where(.peer):disabled~*){cursor:not-allowed}.peer-disabled\:opacity-50:is(:where(.peer):disabled~*){opacity:.5}.peer-disabled\:opacity-70:is(:where(.peer):disabled~*){opacity:.7}.selection\:bg-primary ::selection{background-color:var(--primary)}.selection\:bg-primary::selection{background-color:var(--primary)}.selection\:text-primary-foreground ::selection{color:var(--primary-foreground)}.selection\:text-primary-foreground::selection{color:var(--primary-foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:-inset-x-3:after{content:var(--tw-content);inset-inline:calc(var(--spacing)*-3)}.after\:-inset-y-2:after{content:var(--tw-content);inset-block:calc(var(--spacing)*-2)}.first\:ml-4:first-child{margin-left:calc(var(--spacing)*4)}.last\:mr-4:last-child{margin-right:calc(var(--spacing)*4)}.focus-within\:border-border:focus-within{border-color:var(--border)}.focus-within\:shadow-md:focus-within{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}@media(hover:hover){.hover\:border-flame\/40:hover{border-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.hover\:border-flame\/40:hover{border-color:color-mix(in oklab,var(--flame)40%,transparent)}}.hover\:bg-accent:hover{background-color:var(--accent)}.hover\:bg-accent\!:hover{background-color:var(--accent)!important}.hover\:bg-accent\/50:hover{background-color:var(--accent)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-accent\/50:hover{background-color:color-mix(in oklab,var(--accent)50%,transparent)}}.hover\:bg-background\/45:hover{background-color:var(--background)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-background\/45:hover{background-color:color-mix(in oklab,var(--background)45%,transparent)}}.hover\:bg-card\/90:hover{background-color:var(--card)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-card\/90:hover{background-color:color-mix(in oklab,var(--card)90%,transparent)}}.hover\:bg-destructive\/10:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/10:hover{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.hover\:bg-destructive\/10\!:hover{background-color:var(--destructive)!important}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/10\!:hover{background-color:color-mix(in oklab,var(--destructive)10%,transparent)!important}}.hover\:bg-destructive\/30:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/30:hover{background-color:color-mix(in oklab,var(--destructive)30%,transparent)}}.hover\:bg-destructive\/80:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/80:hover{background-color:color-mix(in oklab,var(--destructive)80%,transparent)}}.hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab,var(--destructive)90%,transparent)}}.hover\:bg-flame\/90:hover{background-color:var(--flame)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-flame\/90:hover{background-color:color-mix(in oklab,var(--flame)90%,transparent)}}.hover\:bg-foreground\/10:hover{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-foreground\/10:hover{background-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.hover\:bg-muted:hover{background-color:var(--muted)}.hover\:bg-muted-foreground\/10:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/10:hover{background-color:color-mix(in oklab,var(--muted-foreground)10%,transparent)}}.hover\:bg-muted-foreground\/15:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/15:hover{background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.hover\:bg-muted-foreground\/20:hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted-foreground\/20:hover{background-color:color-mix(in oklab,var(--muted-foreground)20%,transparent)}}.hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted\/50:hover{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}.hover\:bg-muted\/80:hover{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-muted\/80:hover{background-color:color-mix(in oklab,var(--muted)80%,transparent)}}.hover\:bg-primary\/15:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-primary\/15:hover{background-color:color-mix(in oklab,var(--primary)15%,transparent)}}.hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.hover\:bg-primary\/90:hover{background-color:color-mix(in oklab,var(--primary)90%,transparent)}}.hover\:bg-red-400\/20:hover{background-color:#ff656833}@supports (color:color-mix(in lab,red,red)){.hover\:bg-red-400\/20:hover{background-color:color-mix(in oklab,var(--color-red-400)20%,transparent)}}.hover\:bg-red-600:hover{background-color:var(--color-red-600)}.hover\:bg-transparent:hover{background-color:#0000}.hover\:fill-destructive:hover{fill:var(--destructive)}.hover\:stroke-destructive:hover{stroke:var(--destructive)}.hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.hover\:text-destructive:hover{color:var(--destructive)}.hover\:text-foreground:hover{color:var(--foreground)}.hover\:text-gray-400:hover{color:var(--color-gray-400)}.hover\:text-red-400:hover{color:var(--color-red-400)}.hover\:text-red-600:hover{color:var(--color-red-600)}.hover\:underline:hover{text-decoration-line:underline}.hover\:opacity-80:hover{opacity:.8}.hover\:opacity-90:hover{opacity:.9}.hover\:opacity-100:hover{opacity:1}.hover\:shadow-md:hover{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a),0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}.focus\:bg-accent:focus{background-color:var(--accent)}.focus\:text-accent-foreground:focus{color:var(--accent-foreground)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-primary:focus{--tw-ring-color:var(--primary)}.focus\:ring-ring:focus{--tw-ring-color:var(--ring)}.focus\:ring-offset-2:focus{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus\:outline-hidden:focus{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.focus\:outline-hidden:focus{outline-offset:2px;outline:2px solid #0000}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.focus-visible\:ring-0:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(0px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-1:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-3:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-4:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(4px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-\[3px\]:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.focus-visible\:ring-ring:focus-visible,.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab,var(--ring)50%,transparent)}}.focus-visible\:ring-offset-0:focus-visible{--tw-ring-offset-width:0px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus-visible\:ring-offset-2:focus-visible{--tw-ring-offset-width:2px;--tw-ring-offset-shadow:var(--tw-ring-inset,)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color)}.focus-visible\:outline-hidden:focus-visible{--tw-outline-style:none;outline-style:none}@media(forced-colors:active){.focus-visible\:outline-hidden:focus-visible{outline-offset:2px;outline:2px solid #0000}}.focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.focus-visible\:outline-none:focus-visible{--tw-outline-style:none;outline-style:none}.active\:bg-accent:active{background-color:var(--accent)}.active\:bg-muted-foreground\/25:active{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.active\:bg-muted-foreground\/25:active{background-color:color-mix(in oklab,var(--muted-foreground)25%,transparent)}}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-0:disabled{opacity:0}.disabled\:opacity-50:disabled{opacity:.5}.disabled\:opacity-60:disabled{opacity:.6}.disabled\:opacity-100:disabled{opacity:1}@media(hover:hover){.disabled\:hover\:bg-transparent:disabled:hover{background-color:#0000}}.has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.has-\[\>svg\]\:grid-cols-\[calc\(var\(--spacing\)\*4\)_1fr\]:has(>svg){grid-template-columns:calc(var(--spacing)*4)1fr}.has-\[\>svg\]\:gap-x-3:has(>svg){column-gap:calc(var(--spacing)*3)}.has-\[\>svg\]\:px-2\.5:has(>svg){padding-inline:calc(var(--spacing)*2.5)}.has-\[\>svg\]\:px-3:has(>svg){padding-inline:calc(var(--spacing)*3)}.has-\[\>svg\]\:px-4:has(>svg){padding-inline:calc(var(--spacing)*4)}.aria-disabled\:pointer-events-none[aria-disabled=true]{pointer-events:none}.aria-disabled\:opacity-50[aria-disabled=true]{opacity:.5}.aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.aria-invalid\:ring-3[aria-invalid=true]{--tw-ring-shadow:var(--tw-ring-inset,)0 0 0 calc(3px + var(--tw-ring-offset-width))var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.aria-invalid\:aria-checked\:border-primary[aria-invalid=true][aria-checked=true],.data-checked\:border-primary[data-checked]{border-color:var(--primary)}.data-checked\:bg-primary[data-checked]{background-color:var(--primary)}.data-checked\:text-primary-foreground[data-checked]{color:var(--primary-foreground)}.data-closed\:animate-out[data-closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:fade-out-0[data-closed]{--tw-exit-opacity:0}.data-closed\:zoom-out-95[data-closed]{--tw-exit-scale:.95}.data-highlighted\:bg-accent[data-highlighted]{background-color:var(--accent)}.data-highlighted\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.data-multiline\:py-2\.5[data-multiline]{padding-block:calc(var(--spacing)*2.5)}.data-open\:animate-in[data-open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:fade-in-0[data-open]{--tw-enter-opacity:0}.data-open\:zoom-in-95[data-open]{--tw-enter-scale:.95}.data-\[disabled\]\:pointer-events-none[data-disabled]{pointer-events:none}.data-\[disabled\]\:opacity-50[data-disabled]{opacity:.5}.data-\[highlighted\]\:bg-accent[data-highlighted]{background-color:var(--accent)}.data-\[highlighted\]\:text-accent-foreground[data-highlighted]{color:var(--accent-foreground)}.data-\[inset\]\:pl-8[data-inset]{padding-left:calc(var(--spacing)*8)}.data-\[multiline\]\:py-2\.5[data-multiline]{padding-block:calc(var(--spacing)*2.5)}.data-\[orientation\=horizontal\]\:h-px[data-orientation=horizontal]{height:1px}.data-\[orientation\=horizontal\]\:w-full[data-orientation=horizontal]{width:100%}.data-\[orientation\=vertical\]\:h-full[data-orientation=vertical]{height:100%}.data-\[orientation\=vertical\]\:w-px[data-orientation=vertical]{width:1px}.data-\[placeholder\]\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.data-\[side\=bottom\]\:-translate-x-1\/2[data-side=bottom]{--tw-translate-x: -50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:-translate-y-\[calc\(-50\%_\+_1px\)\][data-side=bottom]{--tw-translate-y: calc((-50% + 1px)*-1) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:calc(var(--spacing)*1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--spacing)*-1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=left\]\:-translate-y-\[calc\(50\%_-_3px\)\][data-side=left]{--tw-translate-y: calc((50% - 3px)*-1) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=left\]\:slide-in-from-end-2[data-side=left]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:calc(var(--spacing)*1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:translate-x-\[calc\(50\%_\+_2px\)\][data-side=right]{--tw-translate-x: calc(50% + 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:translate-y-1\/2[data-side=right]{--tw-translate-y: 50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(ltr),[dir=ltr]){--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=right\]\:slide-in-from-start-2[data-side=right]:where(:dir(rtl),[dir=rtl]){--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=top\]\:translate-x-1\/2[data-side=top]{--tw-translate-x: 50% ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--spacing)*-1);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:translate-y-\[calc\(-50\%_\+_2px\)\][data-side=top]{--tw-translate-y: calc(-50% + 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.data-\[size\=default\]\:h-9[data-size=default]{height:calc(var(--spacing)*9)}.data-\[size\=sm\]\:h-8[data-size=sm]{height:calc(var(--spacing)*8)}:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:color-mix(in oklab,var(--destructive)90%,transparent)}}:is(.\*\:data-\[slot\=select-value\]\:line-clamp-1>*)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.\*\:data-\[slot\=select-value\]\:flex>*)[data-slot=select-value]{display:flex}:is(.\*\:data-\[slot\=select-value\]\:items-center>*)[data-slot=select-value]{align-items:center}:is(.\*\:data-\[slot\=select-value\]\:gap-2>*)[data-slot=select-value]{gap:calc(var(--spacing)*2)}.data-\[state\=checked\]\:translate-x-\[calc\(100\%-2px\)\][data-state=checked]{--tw-translate-x: calc(100% - 2px) ;translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[state\=checked\]\:border-primary[data-state=checked]{border-color:var(--primary)}.data-\[state\=checked\]\:bg-primary[data-state=checked]{background-color:var(--primary)}.data-\[state\=checked\]\:text-primary-foreground[data-state=checked]{color:var(--primary-foreground)}.data-\[state\=closed\]\:animate-out[data-state=closed]{animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-\[state\=closed\]\:duration-300[data-state=closed]{--tw-duration:.3s;transition-duration:.3s}.data-\[state\=closed\]\:fade-out-0[data-state=closed]{--tw-exit-opacity:0}.data-\[state\=closed\]\:fill-mode-forwards[data-state=closed]{--tw-animation-fill-mode:forwards;animation-fill-mode:forwards}.data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.data-\[state\=closed\]\:slide-out-to-bottom[data-state=closed]{--tw-exit-translate-y:100%}.data-\[state\=closed\]\:slide-out-to-bottom-full[data-state=closed]{--tw-exit-translate-y: 100% }.data-\[state\=closed\]\:slide-out-to-left[data-state=closed]{--tw-exit-translate-x:-100%}.data-\[state\=closed\]\:slide-out-to-right[data-state=closed]{--tw-exit-translate-x:100%}.data-\[state\=closed\]\:slide-out-to-top[data-state=closed]{--tw-exit-translate-y:-100%}.data-\[state\=open\]\:animate-in[data-state=open]{animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-\[state\=open\]\:bg-accent[data-state=open]{background-color:var(--accent)}.data-\[state\=open\]\:bg-transparent\![data-state=open]{background-color:#0000!important}.data-\[state\=open\]\:text-accent-foreground[data-state=open]{color:var(--accent-foreground)}.data-\[state\=open\]\:duration-500[data-state=open]{--tw-duration:.5s;transition-duration:.5s}.data-\[state\=open\]\:fade-in-0[data-state=open]{--tw-enter-opacity:0}.data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}.data-\[state\=open\]\:slide-in-from-bottom[data-state=open]{--tw-enter-translate-y:100%}.data-\[state\=open\]\:slide-in-from-bottom-full[data-state=open]{--tw-enter-translate-y: 100% }.data-\[state\=open\]\:slide-in-from-left[data-state=open]{--tw-enter-translate-x:-100%}.data-\[state\=open\]\:slide-in-from-right[data-state=open]{--tw-enter-translate-x:100%}.data-\[state\=open\]\:slide-in-from-top[data-state=open]{--tw-enter-translate-y:-100%}.data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.data-\[state\=unchecked\]\:translate-x-0[data-state=unchecked]{--tw-translate-x:calc(var(--spacing)*0);translate:var(--tw-translate-x)var(--tw-translate-y)}.data-\[state\=unchecked\]\:bg-input[data-state=unchecked]{background-color:var(--input)}.data-\[variant\=destructive\]\:text-destructive[data-variant=destructive]{color:var(--destructive)}.data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/10[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab,var(--destructive)10%,transparent)}}.data-\[variant\=destructive\]\:data-highlighted\:text-destructive[data-variant=destructive][data-highlighted]{color:var(--destructive)}@media not all and (min-width:40rem){.max-sm\:px-3{padding-inline:calc(var(--spacing)*3)}.max-sm\:py-2{padding-block:calc(var(--spacing)*2)}.max-sm\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}}@media(min-width:40rem){.sm\:top-\[50\%\]{top:50%}.sm\:right-auto{right:auto}.sm\:bottom-auto{bottom:auto}.sm\:left-\[50\%\]{left:50%}.sm\:mt-0{margin-top:calc(var(--spacing)*0)}.sm\:max-h-\[100vh\]{max-height:100vh}.sm\:w-auto{width:auto}.sm\:w-max{width:max-content}.sm\:max-w-2xl{max-width:var(--container-2xl)}.sm\:max-w-6xl{max-width:var(--container-6xl)}.sm\:max-w-\[calc\(100vw-2rem\)\]{max-width:calc(100vw - 2rem)}.sm\:max-w-lg{max-width:var(--container-lg)}.sm\:max-w-sm{max-width:var(--container-sm)}.sm\:translate-x-\[-50\%\]{--tw-translate-x:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.sm\:translate-y-\[-50\%\]{--tw-translate-y:-50%;translate:var(--tw-translate-x)var(--tw-translate-y)}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:justify-end{justify-content:flex-end}.sm\:rounded-lg{border-radius:var(--radius)}.sm\:text-left{text-align:left}.sm\:data-\[state\=closed\]\:slide-out-to-bottom-0[data-state=closed]{--tw-exit-translate-y: 0% }.sm\:data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.sm\:data-\[state\=open\]\:slide-in-from-bottom-0[data-state=open]{--tw-enter-translate-y: 0% }.sm\:data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}}@media(min-width:48rem){.md\:sticky{position:sticky}.md\:bottom-4{bottom:calc(var(--spacing)*4)}.md\:bottom-\[calc\(50dvh-7rem\)\]{bottom:calc(50dvh - 7rem)}.md\:left-0{left:calc(var(--spacing)*0)}.md\:col-span-2{grid-column:span 2/span 2}.md\:mt-0{margin-top:calc(var(--spacing)*0)}.md\:mt-2{margin-top:calc(var(--spacing)*2)}.md\:mb-8{margin-bottom:calc(var(--spacing)*8)}.md\:ml-2{margin-left:calc(var(--spacing)*2)}.md\:flex{display:flex}.md\:hidden{display:none}.md\:h-4{height:calc(var(--spacing)*4)}.md\:h-6{height:calc(var(--spacing)*6)}.md\:h-8{height:calc(var(--spacing)*8)}.md\:h-9{height:calc(var(--spacing)*9)}.md\:h-\[90vh\]{height:90vh}.md\:h-\[calc\(100dvh-1\.125rem\)\]{height:calc(100dvh - 1.125rem)}.md\:max-h-\[100vh\]{max-height:100vh}.md\:min-h-full{min-height:100%}.md\:w-4{width:calc(var(--spacing)*4)}.md\:w-6{width:calc(var(--spacing)*6)}.md\:w-8{width:calc(var(--spacing)*8)}.md\:w-9{width:calc(var(--spacing)*9)}.md\:w-12{width:calc(var(--spacing)*12)}.md\:w-72{width:calc(var(--spacing)*72)}.md\:w-auto{width:auto}.md\:max-w-3xl{max-width:var(--container-3xl)}.md\:max-w-32{max-width:calc(var(--spacing)*32)}.md\:max-w-\[90vw\]\!{max-width:90vw!important}.md\:max-w-\[min\(calc\(100cqw-9rem\)\,25rem\)\]{max-width:min(100cqw - 9rem,25rem)}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.md\:flex-row{flex-direction:row}.md\:items-center{align-items:center}.md\:justify-between{justify-content:space-between}.md\:gap-0{gap:calc(var(--spacing)*0)}.md\:gap-1{gap:calc(var(--spacing)*1)}.md\:gap-2{gap:calc(var(--spacing)*2)}.md\:overflow-y-auto{overflow-y:auto}.md\:rounded-2xl{border-radius:var(--radius-2xl)}.md\:rounded-3xl{border-radius:var(--radius-3xl)}.md\:bg-foreground\/5\!{background-color:var(--foreground)!important}@supports (color:color-mix(in lab,red,red)){.md\:bg-foreground\/5\!{background-color:color-mix(in oklab,var(--foreground)5%,transparent)!important}}.md\:bg-muted\/60{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.md\:bg-muted\/60{background-color:color-mix(in oklab,var(--muted)60%,transparent)}}.md\:p-4{padding:calc(var(--spacing)*4)}.md\:p-6{padding:calc(var(--spacing)*6)}.md\:p-8{padding:calc(var(--spacing)*8)}.md\:px-8{padding-inline:calc(var(--spacing)*8)}.md\:py-0{padding-block:calc(var(--spacing)*0)}.md\:py-3\!{padding-block:calc(var(--spacing)*3)!important}.md\:py-8{padding-block:calc(var(--spacing)*8)}.md\:pt-0{padding-top:calc(var(--spacing)*0)}.md\:pt-6{padding-top:calc(var(--spacing)*6)}.md\:pt-28{padding-top:calc(var(--spacing)*28)}.md\:pb-4{padding-bottom:calc(var(--spacing)*4)}.md\:pl-8{padding-left:calc(var(--spacing)*8)}.md\:text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.md\:text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.md\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.md\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.md\:backdrop-blur-xl{--tw-backdrop-blur:blur(var(--blur-xl));-webkit-backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,)var(--tw-backdrop-brightness,)var(--tw-backdrop-contrast,)var(--tw-backdrop-grayscale,)var(--tw-backdrop-hue-rotate,)var(--tw-backdrop-invert,)var(--tw-backdrop-opacity,)var(--tw-backdrop-saturate,)var(--tw-backdrop-sepia,)}.md\:transition-\[width\,padding\]{transition-property:width,padding;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}@media(hover:hover){.md\:hover\:bg-foreground\/10\!:hover{background-color:var(--foreground)!important}@supports (color:color-mix(in lab,red,red)){.md\:hover\:bg-foreground\/10\!:hover{background-color:color-mix(in oklab,var(--foreground)10%,transparent)!important}}}}@media(min-width:64rem){.lg\:col-span-2{grid-column:span 2/span 2}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}}@media(min-width:96rem){.\32xl\:bottom-\[calc\(50dvh-4rem\)\]{bottom:calc(50dvh - 4rem)}}.dark\:border:is(.dark *){border-style:var(--tw-border-style);border-width:1px}.dark\:border-border\/20:is(.dark *){border-color:var(--border)}@supports (color:color-mix(in lab,red,red)){.dark\:border-border\/20:is(.dark *){border-color:color-mix(in oklab,var(--border)20%,transparent)}}.dark\:border-input:is(.dark *){border-color:var(--input)}.dark\:border-muted:is(.dark *){border-color:var(--muted)}.dark\:border-purple-800:is(.dark *){border-color:var(--color-purple-800)}.dark\:bg-blue-950:is(.dark *){background-color:var(--color-blue-950)}.dark\:bg-blue-950\/40:is(.dark *){background-color:#16245666}@supports (color:color-mix(in lab,red,red)){.dark\:bg-blue-950\/40:is(.dark *){background-color:color-mix(in oklab,var(--color-blue-950)40%,transparent)}}.dark\:bg-cyan-950:is(.dark *){background-color:var(--color-cyan-950)}.dark\:bg-destructive\/60:is(.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-destructive\/60:is(.dark *){background-color:color-mix(in oklab,var(--destructive)60%,transparent)}}.dark\:bg-destructive\/70:is(.dark *){background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-destructive\/70:is(.dark *){background-color:color-mix(in oklab,var(--destructive)70%,transparent)}}.dark\:bg-foreground\/10:is(.dark *){background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-foreground\/10:is(.dark *){background-color:color-mix(in oklab,var(--foreground)10%,transparent)}}.dark\:bg-green-950:is(.dark *){background-color:var(--color-green-950)}.dark\:bg-input\/30:is(.dark *){background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-input\/30:is(.dark *){background-color:color-mix(in oklab,var(--input)30%,transparent)}}.dark\:bg-muted-foreground\/15:is(.dark *){background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-muted-foreground\/15:is(.dark *){background-color:color-mix(in oklab,var(--muted-foreground)15%,transparent)}}.dark\:bg-muted\/75:is(.dark *){background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-muted\/75:is(.dark *){background-color:color-mix(in oklab,var(--muted)75%,transparent)}}.dark\:bg-orange-900:is(.dark *){background-color:var(--color-orange-900)}.dark\:bg-orange-950:is(.dark *){background-color:var(--color-orange-950)}.dark\:bg-pink-950:is(.dark *){background-color:var(--color-pink-950)}.dark\:bg-primary\/8:is(.dark *){background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-primary\/8:is(.dark *){background-color:color-mix(in oklab,var(--primary)8%,transparent)}}.dark\:bg-primary\/15:is(.dark *){background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){.dark\:bg-primary\/15:is(.dark *){background-color:color-mix(in oklab,var(--primary)15%,transparent)}}.dark\:bg-purple-500\/20:is(.dark *){background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-500\/20:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-500)20%,transparent)}}.dark\:bg-purple-700\/50:is(.dark *){background-color:#8200da80}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-700\/50:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-700)50%,transparent)}}.dark\:bg-purple-800\/40:is(.dark *){background-color:#6e11b066}@supports (color:color-mix(in lab,red,red)){.dark\:bg-purple-800\/40:is(.dark *){background-color:color-mix(in oklab,var(--color-purple-800)40%,transparent)}}.dark\:bg-purple-950:is(.dark *){background-color:var(--color-purple-950)}.dark\:bg-yellow-500\/30:is(.dark *){background-color:#edb2004d}@supports (color:color-mix(in lab,red,red)){.dark\:bg-yellow-500\/30:is(.dark *){background-color:color-mix(in oklab,var(--color-yellow-500)30%,transparent)}}.dark\:text-amber-400:is(.dark *){color:var(--color-amber-400)}.dark\:text-blue-200:is(.dark *){color:var(--color-blue-200)}.dark\:text-blue-400:is(.dark *){color:var(--color-blue-400)}.dark\:text-cyan-400:is(.dark *){color:var(--color-cyan-400)}.dark\:text-green-400:is(.dark *){color:var(--color-green-400)}.dark\:text-orange-200:is(.dark *){color:var(--color-orange-200)}.dark\:text-orange-400:is(.dark *){color:var(--color-orange-400)}.dark\:text-pink-400:is(.dark *){color:var(--color-pink-400)}.dark\:text-purple-100:is(.dark *){color:var(--color-purple-100)}.dark\:text-purple-300:is(.dark *){color:var(--color-purple-300)}.dark\:text-purple-400:is(.dark *){color:var(--color-purple-400)}.dark\:text-red-400:is(.dark *){color:var(--color-red-400)}.dark\:text-secondary-foreground:is(.dark *){color:var(--secondary-foreground)}.dark\:text-yellow-400:is(.dark *){color:var(--color-yellow-400)}.dark\:text-yellow-500:is(.dark *){color:var(--color-yellow-500)}.dark\:ring-ring\/20:is(.dark *){--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.dark\:ring-ring\/20:is(.dark *){--tw-ring-color:color-mix(in oklab,var(--ring)20%,transparent)}}.dark\:outline-ring\/40:is(.dark *){outline-color:var(--ring)}@supports (color:color-mix(in lab,red,red)){.dark\:outline-ring\/40:is(.dark *){outline-color:color-mix(in oklab,var(--ring)40%,transparent)}}.dark\:focus-within\:border-border:is(.dark *):focus-within{border-color:var(--border)}@media(hover:hover){.dark\:hover\:bg-destructive\/20\!:is(.dark *):hover{background-color:var(--destructive)!important}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-destructive\/20\!:is(.dark *):hover{background-color:color-mix(in oklab,var(--destructive)20%,transparent)!important}}.dark\:hover\:bg-input\/50:is(.dark *):hover{background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-input\/50:is(.dark *):hover{background-color:color-mix(in oklab,var(--input)50%,transparent)}}.dark\:hover\:bg-muted-foreground\/25:is(.dark *):hover{background-color:var(--muted-foreground)}@supports (color:color-mix(in lab,red,red)){.dark\:hover\:bg-muted-foreground\/25:is(.dark *):hover{background-color:color-mix(in oklab,var(--muted-foreground)25%,transparent)}}}.dark\:focus-visible\:ring-destructive\/40:is(.dark *):focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:focus-visible\:ring-destructive\/40:is(.dark *):focus-visible{--tw-ring-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.dark\:aria-invalid\:border-destructive\/50:is(.dark *)[aria-invalid=true]{border-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:aria-invalid\:border-destructive\/50:is(.dark *)[aria-invalid=true]{border-color:color-mix(in oklab,var(--destructive)50%,transparent)}}.dark\:aria-invalid\:ring-destructive\/40:is(.dark *)[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:aria-invalid\:ring-destructive\/40:is(.dark *)[aria-invalid=true]{--tw-ring-color:color-mix(in oklab,var(--destructive)40%,transparent)}}.dark\:data-checked\:bg-primary:is(.dark *)[data-checked],.dark\:data-\[state\=checked\]\:bg-primary:is(.dark *)[data-state=checked]{background-color:var(--primary)}.dark\:data-\[state\=checked\]\:bg-primary-foreground:is(.dark *)[data-state=checked]{background-color:var(--primary-foreground)}.dark\:data-\[state\=unchecked\]\:bg-foreground:is(.dark *)[data-state=unchecked]{background-color:var(--foreground)}.dark\:data-\[state\=unchecked\]\:bg-input\/80:is(.dark *)[data-state=unchecked]{background-color:var(--input)}@supports (color:color-mix(in lab,red,red)){.dark\:data-\[state\=unchecked\]\:bg-input\/80:is(.dark *)[data-state=unchecked]{background-color:color-mix(in oklab,var(--input)80%,transparent)}}.dark\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/20:is(.dark *)[data-variant=destructive][data-highlighted]{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){.dark\:data-\[variant\=destructive\]\:data-highlighted\:bg-destructive\/20:is(.dark *)[data-variant=destructive][data-highlighted]{background-color:color-mix(in oklab,var(--destructive)20%,transparent)}}.\[\&_p\]\:leading-relaxed p{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.\[\&_svg\:not\(\[class\*\=\'size-\'\]\)\]\:size-8 svg:not([class*=size-]){width:calc(var(--spacing)*8);height:calc(var(--spacing)*8)}.\[\&_svg\:not\(\[class\*\=\'text-\'\]\)\]\:text-muted-foreground svg:not([class*=text-]){color:var(--muted-foreground)}.\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.\[\&\:has\(\[role\=checkbox\]\)\]\:pe-0:has([role=checkbox]){padding-inline-end:calc(var(--spacing)*0)}.\[\.border-b\]\:pb-6.border-b{padding-bottom:calc(var(--spacing)*6)}.\[\.border-t\]\:pt-6.border-t{padding-top:calc(var(--spacing)*6)}:is(.\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--spacing)*2)}:is(.data-\[variant\=destructive\]\:\*\:\[svg\]\:\!text-destructive[data-variant=destructive]>*):is(svg){color:var(--destructive)!important}.\[\&\:not\(\:first-child\)\]\:mt-1:not(:first-child){margin-top:calc(var(--spacing)*1)}.\[\&\:not\(\:first-child\)\]\:mt-2:not(:first-child){margin-top:calc(var(--spacing)*2)}.\[\&\:not\(\:first-child\)\]\:last\:mr-4:not(:first-child):last-child{margin-right:calc(var(--spacing)*4)}.\[\&\:not\(\:last-child\)\]\:first\:ml-4:not(:last-child):first-child{margin-left:calc(var(--spacing)*4)}.\[\&\>\*\]\:flex-1>*{flex:1}@media(min-width:40rem){.sm\:\[\&\>\*\]\:flex-none>*{flex:none}}.\[\&\>\*\:first-child\]\:rounded-r-none>:first-child{border-top-right-radius:0;border-bottom-right-radius:0}.\[\&\>\*\:last-child\]\:rounded-l-none>:last-child{border-top-left-radius:0;border-bottom-left-radius:0}.\[\&\>\*\:not\(\:first-child\)\:not\(\:last-child\)\]\:rounded-none>:not(:first-child):not(:last-child){border-radius:0}.\[\&\>a\]\:underline>a{text-decoration-line:underline}.\[\&\>a\]\:underline-offset-4>a{text-underline-offset:4px}.\[\&\>a\:hover\]\:text-primary>a:hover{color:var(--primary)}@media(hover:hover){.hover\:\[\&\>kbd\]\:opacity-100:hover>kbd{opacity:1}}.\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.\[\&\>svg\]\:size-3>svg{width:calc(var(--spacing)*3);height:calc(var(--spacing)*3)}.\[\&\>svg\]\:size-4>svg{width:calc(var(--spacing)*4);height:calc(var(--spacing)*4)}.\[\&\>svg\]\:translate-y-0\.5>svg{--tw-translate-y:calc(var(--spacing)*.5);translate:var(--tw-translate-x)var(--tw-translate-y)}.\[\&\>svg\]\:text-current>svg{color:currentColor}@media(hover:hover){:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:var(--muted)}@supports (color:color-mix(in lab,red,red)){:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper)>th,:is(.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover,.hover\:\[\&\,\&\>svelte-css-wrapper\]\:\[\&\>th\,td\]\:bg-muted\/50:hover>svelte-css-wrapper) td{background-color:color-mix(in oklab,var(--muted)50%,transparent)}}}.\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}@media(pointer:coarse){.\[\@media\(pointer\:coarse\)\]\:pointer-events-auto{pointer-events:auto}.\[\@media\(pointer\:coarse\)\]\:flex{display:flex}.\[\@media\(pointer\:coarse\)\]\:hidden{display:none}.\[\@media\(pointer\:coarse\)\]\:w-5{width:calc(var(--spacing)*5)}.\[\@media\(pointer\:coarse\)\]\:w-auto{width:auto}.\[\@media\(pointer\:coarse\)\]\:text-amber-500{color:var(--color-amber-500)}.\[\@media\(pointer\:coarse\)\]\:text-green-500{color:var(--color-green-500)}.\[\@media\(pointer\:coarse\)\]\:text-muted-foreground{color:var(--muted-foreground)}.\[\@media\(pointer\:coarse\)\]\:opacity-100{opacity:1}@media(hover:hover){.\[\@media\(pointer\:coarse\)\]\:hover\:text-amber-600:hover{color:var(--color-amber-600)}.\[\@media\(pointer\:coarse\)\]\:hover\:text-green-600:hover{color:var(--color-green-600)}}}@media(hover:hover){a.\[a\&\]\:hover\:bg-accent:hover{background-color:var(--accent)}a.\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-destructive\/90:hover{background-color:color-mix(in oklab,var(--destructive)90%,transparent)}}a.\[a\&\]\:hover\:bg-foreground\/25:hover{background-color:var(--foreground)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-foreground\/25:hover{background-color:color-mix(in oklab,var(--foreground)25%,transparent)}}a.\[a\&\]\:hover\:bg-primary\/90:hover{background-color:var(--primary)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-primary\/90:hover{background-color:color-mix(in oklab,var(--primary)90%,transparent)}}a.\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab,red,red)){a.\[a\&\]\:hover\:bg-secondary\/90:hover{background-color:color-mix(in oklab,var(--secondary)90%,transparent)}}a.\[a\&\]\:hover\:text-accent-foreground:hover{color:var(--accent-foreground)}}.scrollbar-hide::-webkit-scrollbar{display:none}.scrollbar-hide{-ms-overflow-style:none;scrollbar-width:none}.neon-flame{box-shadow:0 0 5px var(--flame),0 0 10px var(--flame),0 0 20px var(--ember),0 0 40px var(--ember)}.neon-ember{box-shadow:0 0 5px var(--ember),0 0 10px var(--ember),0 0 20px var(--ember)}.neon-gold{box-shadow:0 0 5px var(--gold),0 0 10px var(--gold),0 0 20px var(--flame)}.neon-eye{box-shadow:0 0 5px var(--eye),0 0 10px var(--eye),0 0 20px var(--eye)}.neon-cyan{box-shadow:0 0 5px var(--flame),0 0 10px var(--flame),0 0 20px var(--flame)}.neon-magenta{box-shadow:0 0 5px var(--ember),0 0 10px var(--ember),0 0 20px var(--ember)}.neon-purple{box-shadow:0 0 5px var(--gold),0 0 10px var(--gold),0 0 20px var(--gold)}.text-glow-fire{text-shadow:0 0 10px var(--flame),0 0 20px var(--ember),0 0 40px var(--ember)}.text-glow-gold{text-shadow:0 0 10px var(--gold),0 0 20px var(--flame)}.text-glow-eye{text-shadow:0 0 10px var(--eye),0 0 20px var(--eye)}.text-glow-cyan{text-shadow:0 0 10px var(--flame),0 0 20px var(--flame)}.text-glow-magenta{text-shadow:0 0 10px var(--ember),0 0 20px var(--ember)}.fire-text{background-image:linear-gradient(90deg,var(--gold),var(--flame),var(--ember),var(--gold));color:#0000;filter:drop-shadow(0 0 8px var(--flame));background-size:200%;-webkit-background-clip:text;background-clip:text;animation:4s linear infinite gradient-x}.cyber-grid{background-image:linear-gradient(oklch(62% .28 25/.12) 1px,#0000 1px),linear-gradient(90deg,oklch(62% .28 25/.12) 1px,#0000 1px);background-size:32px 32px}.rune-card{-webkit-backdrop-filter:blur(8px);backdrop-filter:blur(8px);background:#21050599;border:1px solid oklch(72% .28 45/.6);animation:4s linear infinite flicker;box-shadow:0 0 12px oklch(62% .28 25/.5),inset 0 0 12px oklch(72% .28 45/.25)}.sym-omega:before,.sym-sigma:before,.sym-fehu:before,.sym-perthro:before{color:var(--flame);text-shadow:0 0 8px var(--ember),0 0 16px var(--flame);margin-right:.4em;animation:3.5s linear infinite flicker;display:inline-block}.sym-omega:before{content:var(--rune-omega)}.sym-sigma:before{content:var(--rune-sigma)}.sym-fehu:before{content:var(--rune-fehu)}.sym-perthro:before{content:var(--rune-perthro)}.brand-omega:before{content:var(--brand-omega)}.brand-llama:after{content:var(--brand-llama)}.brand-algmor:after{content:var(--brand-algmor)}.brand-omega:before,.brand-llama:after,.brand-algmor:after{font-family:var(--font-mono);letter-spacing:.15em;color:var(--gold);text-shadow:0 0 6px var(--flame),0 0 18px var(--ember)}.glitch{position:relative}.glitch:before,.glitch:after{content:attr(data-text);pointer-events:none;position:absolute;inset:0}.glitch:before{color:var(--ember);clip-path:inset(0 0 55%);opacity:.8;animation:2.7s linear infinite flicker;transform:translate(-2px,-1px)}.glitch:after{color:var(--eye);clip-path:inset(45% 0 0);opacity:.8;animation:3.3s linear infinite reverse flicker;transform:translate(2px,1px)}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}:root{--radius:.625rem;--brand-omega:"ΩFFFΣLLIa";--brand-llama:"llama.cpp";--brand-algmor:"AlgMor24";--rune-omega:"Ω";--rune-sigma:"Σ";--rune-fehu:"ᚠ";--rune-perthro:"ᛈ";--background:oklch(96% .02 80);--foreground:oklch(20% .06 25);--card:oklch(98% .015 80);--card-foreground:oklch(20% .06 25);--popover:oklch(98% .015 80);--popover-foreground:oklch(20% .06 25);--primary:oklch(62% .22 45);--primary-foreground:oklch(98% .02 80);--secondary:oklch(55% .24 25);--secondary-foreground:oklch(98% .02 80);--muted:oklch(90% .03 80);--muted-foreground:oklch(50% .08 25);--accent:oklch(60% .2 80);--accent-foreground:oklch(98% .02 80);--destructive:oklch(55% .26 25);--border:oklch(82% .06 45);--input:oklch(86% .05 45);--ring:oklch(62% .22 45);--flame:oklch(62% .22 45);--ember:oklch(55% .24 25);--gold:oklch(70% .16 85);--eye:oklch(60% .12 220);--chart-1:oklch(62% .22 45);--chart-2:oklch(55% .24 25);--chart-3:oklch(70% .16 85);--chart-4:oklch(60% .12 220);--chart-5:oklch(45% .2 25);--sidebar:oklch(97% .015 80);--sidebar-foreground:oklch(20% .06 25);--sidebar-primary:oklch(62% .22 45);--sidebar-primary-foreground:oklch(98% .02 80);--sidebar-accent:oklch(92% .04 80);--sidebar-accent-foreground:oklch(20% .06 25);--sidebar-border:oklch(85% .05 45);--sidebar-ring:oklch(62% .22 45);--code-background:oklch(14% .03 25);--code-foreground:oklch(80% .2 80);--font-mono:ui-monospace,SFMono-Regular,"SF Mono",Monaco,"Cascadia Code","Roboto Mono",Consolas,"Liberation Mono",Menlo,monospace;--layer-popover:1000000;--chat-form-area-height:8rem;--chat-form-area-offset:2rem;--chat-form-padding-top:6rem;--max-message-height:max(24rem,min(80dvh,calc(100dvh - var(--chat-form-area-height) - 12rem)))}@media(min-width:640px){:root{--chat-form-area-height:24rem;--chat-form-area-offset:12rem;--chat-form-padding-top:6rem}}.dark{--background:oklch(13% .03 25);--foreground:oklch(96% .02 80);--card:oklch(17% .04 25);--card-foreground:oklch(96% .02 80);--popover:oklch(17% .04 25);--popover-foreground:oklch(96% .02 80);--primary:oklch(72% .28 45);--primary-foreground:oklch(12% .03 25);--secondary:oklch(62% .28 25);--secondary-foreground:oklch(98% .02 80);--muted:oklch(26% .05 25);--muted-foreground:oklch(70% .08 45);--accent:oklch(80% .22 85);--accent-foreground:oklch(15% .04 80);--destructive:oklch(65% .28 25);--border:oklch(38% .1 25);--input:oklch(22% .05 25);--ring:oklch(72% .28 45);--flame:oklch(72% .28 45);--ember:oklch(62% .28 25);--gold:oklch(85% .2 90);--eye:oklch(78% .18 220);--chart-1:oklch(72% .28 45);--chart-2:oklch(62% .28 25);--chart-3:oklch(85% .2 90);--chart-4:oklch(78% .18 220);--chart-5:oklch(50% .25 25);--sidebar:oklch(11% .03 25);--sidebar-foreground:oklch(96% .02 80);--sidebar-primary:oklch(72% .28 45);--sidebar-primary-foreground:oklch(12% .03 25);--sidebar-accent:oklch(24% .07 25);--sidebar-accent-foreground:oklch(96% .02 80);--sidebar-border:oklch(30% .08 25);--sidebar-ring:oklch(72% .28 45);--code-background:oklch(11% .03 25);--code-foreground:oklch(85% .2 90)}@keyframes flicker{0%,to{opacity:1}6%{opacity:.85}9%{opacity:1}38%{opacity:1}40%{opacity:.5}42%{opacity:1}71%{opacity:.75}73%{opacity:1}}@keyframes ember-rise{0%{opacity:0;transform:translateY(0)scale(1)}8%{opacity:1}to{opacity:0;transform:translateY(-90vh)scale(.3)}}@keyframes gradient-x{0%,to{background-position:0%}50%{background-position:100%}}@keyframes pulse-fire{0%,to{box-shadow:0 0 6px var(--ember),0 0 14px var(--flame),0 0 28px var(--flame)}50%{box-shadow:0 0 12px var(--gold),0 0 26px var(--flame),0 0 48px var(--ember)}}@keyframes scan{0%{transform:translateY(-100%)}to{transform:translateY(100vh)}}.mermaidTooltip{display:none!important}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-space-x-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}} diff --git a/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_page.CV-KWLNP.css b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_page.CV-KWLNP.css new file mode 100644 index 0000000000000000000000000000000000000000..527a504e82f0faa8bfc0b7c29132c05958af99bf --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/_page.CV-KWLNP.css @@ -0,0 +1 @@ +[data-select-viewport],[data-combobox-viewport]{scrollbar-width:none!important;-ms-overflow-style:none!important;-webkit-overflow-scrolling:touch!important}[data-combobox-viewport]::-webkit-scrollbar{display:none!important}[data-select-viewport]::-webkit-scrollbar{display:none!important} diff --git a/tools/ui/.svelte-kit/output/server/_app/immutable/assets/dialog-description.bHHIbcsu.css b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/dialog-description.bHHIbcsu.css new file mode 100644 index 0000000000000000000000000000000000000000..7af15d09c231b9a04378049780d25742ce8d78ca --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/_app/immutable/assets/dialog-description.bHHIbcsu.css @@ -0,0 +1 @@ +[data-scroll-area-viewport]{scrollbar-width:none!important;-ms-overflow-style:none!important;-webkit-overflow-scrolling:touch!important}[data-scroll-area-viewport]::-webkit-scrollbar{display:none!important}:where([data-scroll-area-viewport]){display:flex;flex-direction:column;align-items:stretch}:where([data-scroll-area-content]){flex-grow:1} diff --git a/tools/ui/.svelte-kit/output/server/chunks/ActionIcon.js b/tools/ui/.svelte-kit/output/server/chunks/ActionIcon.js new file mode 100644 index 0000000000000000000000000000000000000000..609dbfc2774629112e13907978b7eb822754f7b5 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/ActionIcon.js @@ -0,0 +1 @@ +import{d as C,s as I,j as O,l as R,c as j}from"./root.js";import{G as y}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";import{R as f,T as m,a as n}from"./index3.js";import{bh as B}from"./uuid.js";function q(b,g){b.component(o=>{let{ariaLabel:T,class:_="",disabled:l=!1,href:u="",icon:c,iconSize:k="h-3 w-3",onclick:v,size:w="sm",stopPropagationOnClick:P=!1,tooltip:a,tooltipSide:S=B.TOP,variant:x="ghost"}=g,z=0;const A=C(()=>!!a&&z>768);function h(t,p={}){y(t,I([p,{href:u,variant:x,size:w,disabled:l,onclick:s=>{P&&s.stopPropagation(),v?.(s)},class:`h-6 w-6 p-0 ${O(_)} flex hover:bg-transparent data-[state=open]:bg-transparent!`,"aria-label":T||a,children:s=>{if(c){s.push("");const i=c;i?(s.push(""),i(s,{class:k}),s.push("")):(s.push(""),s.push(""))}else s.push("");s.push("")},$$slots:{default:!0}}]))}A()?(o.push(""),f?(o.push(""),f(o,{children:t=>{{let p=function(s,{props:i}){l?(s.push(""),s.push(``),h(s,{}),s.push("")):(s.push(""),h(s,i)),s.push("")};m?(t.push(""),m(t,{child:p,$$slots:{child:!0}}),t.push("")):(t.push(""),t.push(""))}t.push(" "),n?(t.push(""),n(t,{side:S,children:p=>{p.push(`

      ${R(a)}

      `)},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push(""))},$$slots:{default:!0}}),o.push("")):(o.push(""),o.push(""))):(o.push(""),h(o,{href:u})),o.push("")})}export{q as A}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/DialogConfirmation.js b/tools/ui/.svelte-kit/output/server/chunks/DialogConfirmation.js new file mode 100644 index 0000000000000000000000000000000000000000..9c61caf1acf1b98dd3cd15ce0af1f3b210c34a6a --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/DialogConfirmation.js @@ -0,0 +1 @@ +import{s as M,a as O,l as a}from"./root.js";import{I as d}from"./uuid.js";import{R as C,A as w,b as x,c as y,d as b,e as K,f as k}from"./index.js";import{K as H}from"./keyboard.enums.js";import{A as D}from"./alert-dialog-cancel.js";function B(h){var p=String(h??""),l="";return l+p+""}function F(h,p){let{$$slots:l,$$events:c,...i}=p;d(h,M([{name:"download"},i,{iconNode:[["path",{d:"M12 15V3"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"}],["path",{d:"m7 10 5 5 5-5"}]]}]))}function G(h,p){h.component(l=>{let{cancelText:c="Cancel",children:i,confirmText:f="Confirm",description:I,icon:m,onCancel:n,onConfirm:_,onKeydown:N,open:g=void 0,title:R,variant:v="default"}=p;function T(u){u.key===H.ENTER&&(u.preventDefault(),_()),N?.(u)}function E(u){u||n()}C?(l.push(""),C(l,{open:g,onOpenChange:E,children:u=>{w?(u.push(""),w(u,{onkeydown:T,children:t=>{x?(t.push(""),x(t,{children:s=>{y?(s.push(""),y(s,{class:"flex items-center gap-2",children:o=>{if(m){o.push("");const A=m;A?(o.push(""),A(o,{class:`h-5 w-5 ${v==="destructive"?"text-destructive":""}`}),o.push("")):(o.push(""),o.push(""))}else o.push("");o.push(` ${a(R)}`)},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push("")),s.push(" "),b?(s.push(""),b(s,{children:o=>{o.push(`${a(I)}`)},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push("")),t.push(" "),i?(t.push(""),i(t),t.push("")):t.push(""),t.push(" "),K?(t.push(""),K(t,{children:s=>{D?(s.push(""),D(s,{onclick:n,children:o=>{o.push(`${a(c)}`)},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push("")),s.push(" "),k?(s.push(""),k(s,{onclick:_,class:v==="destructive"?"bg-destructive text-white hover:bg-destructive/80":"",children:o=>{o.push(`${a(f)}`)},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push(""))},$$slots:{default:!0}}),u.push("")):(u.push(""),u.push(""))},$$slots:{default:!0}}),l.push("")):(l.push(""),l.push("")),O(p,{open:g})})}export{G as D,F as a,B as h}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/DialogModelNotAvailable.js b/tools/ui/.svelte-kit/output/server/chunks/DialogModelNotAvailable.js new file mode 100644 index 0000000000000000000000000000000000000000..d21e0e6e605105583f56598e28c46d872d565fd3 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/DialogModelNotAvailable.js @@ -0,0 +1 @@ +import{a as w,l as c,g as C,j as k}from"./root.js";import"@sveltejs/kit/internal";import"./url.js";import"./utils2.js";import"@sveltejs/kit/internal/server";import"./exports.js";import{I as D}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";import{R as m,A as f,b as e,c as g,d as n,e as d,f as b}from"./index.js";import{aD as N}from"./uuid.js";import{A as S}from"./arrow-right.js";function U(x,p){x.component(a=>{let{availableModels:i=[],modelName:_,onOpenChange:v,open:u=void 0}=p;function h(l){u=l,v?.(l)}m?(a.push(""),m(a,{open:u,onOpenChange:h,children:l=>{f?(l.push(""),f(l,{class:"max-w-lg",children:t=>{if(e?(t.push(""),e(t,{children:s=>{g?(s.push(""),g(s,{class:"flex items-center gap-2",children:o=>{N(o,{class:"h-5 w-5 text-amber-500"}),o.push(" Model Not Available")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push("")),s.push(" "),n?(s.push(""),n(s,{children:o=>{o.push("The requested model could not be found. Select an available model to continue.")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push("")),t.push(`

      Requested: ${c(_)}

      `),i.length>0){t.push(""),t.push('

      Select an available model:

      ');const s=C(i);for(let o=0,y=s.length;o${c(A)} `),S(t,{class:`${k(D)} shrink-0 text-muted-foreground opacity-0 transition-opacity group-hover:opacity-100`}),t.push("")}t.push("
      ")}else t.push("");t.push("
      "),d?(t.push(""),d(t,{children:s=>{b?(s.push(""),b(s,{onclick:()=>h(!1),children:o=>{o.push("Cancel")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push(""))},$$slots:{default:!0}}),l.push("")):(l.push(""),l.push(""))},$$slots:{default:!0}}),a.push("")):(a.push(""),a.push("")),w(p,{open:u})})}export{U as D}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js b/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js new file mode 100644 index 0000000000000000000000000000000000000000..1b7fdf5455e8225831d537a6937ff1fd63861c23 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js @@ -0,0 +1,15 @@ +import{A as pn,B as Ne,C as oe,c as B,e as it,a as R,d as b,v as gn,n as re,m as mn,D as vn,w as At,E as bn,o as P,p as Gt,s as U,F as yn}from"./root.js";import{tv as ct}from"tailwind-variants";import{clsx as Et}from"clsx";import"@sveltejs/kit/internal";import"./url.js";import"./utils2.js";import"@sveltejs/kit/internal/server";import{w as wn}from"./exports.js";import{bg as Cn,av as Oe,I as En,bz as St,cm as Sn,a8 as K,ap as V,ag as bt,cn as ie,aj as j,$ as Tn,Y as _t,k as $,M as An,d as Mn,B as v,bk as ae,a7 as xn,co as yt}from"./uuid.js";import In from"style-to-object";import"@sveltejs/kit";import kn from"dexie";import{unzipSync as Nn,strFromU8 as ce,strToU8 as On,zipSync as Pn}from"fflate";import{isTabbable as Wt,tabbable as Pe,isFocusable as _e,focusable as Fe}from"tabbable";import{visit as _n}from"unist-util-visit";import{twMerge as Fn}from"tailwind-merge";function Br(n){pn.r.on_destroy(n)}function Ln(){Ne("mount")}function Dn(){Ne("unmount")}async function Rn(){}function Bn(){const{set:n,subscribe:t}=wn(!1);return{subscribe:t,check:async()=>!1}}const Un=oe.toString().includes("$$")||/function \w+\(\) \{\}/.test(oe.toString()),Gn="a:";Un&&new URL(Gn);const Wn={updated:Bn()};function H(n,t={}){throw new Error("Cannot call goto(...) on the server")}Wn.updated.check;function G(...n){return Fn(Et(n))}const ue=ct({base:"focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex shrink-0 items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium outline-none transition-all focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg:not([class*='size-'])]:size-4 [&_svg]:pointer-events-none [&_svg]:shrink-0",defaultVariants:{size:"default",variant:"default"},variants:{size:{default:"h-9 px-4 py-2 has-[>svg]:px-3",icon:"size-9","icon-lg":"size-10","icon-sm":"size-5 rounded-sm",lg:"h-10 rounded-lg px-6 has-[>svg]:px-4",sm:"h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5"},variant:{default:"bg-primary text-primary-foreground shadow-sm hover:bg-primary/90",destructive:"bg-destructive shadow-sm hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60 text-white!",ghost:"hover:text-accent-foreground hover:bg-muted-foreground/10 backdrop-blur-sm",link:"text-primary underline-offset-4 hover:underline",outline:"shadow-sm hover:text-accent-foreground hover:bg-muted-foreground/10 backdrop-blur-sm dark:border-input border",secondary:"bg-background dark:bg-muted-foreground/15 dark:text-secondary-foreground shadow-sm text-foreground hover:bg-muted-foreground/20 dark:hover:bg-muted-foreground/25"}}});function Ur(n,t){n.component(e=>{let{children:s,class:o,disabled:r,href:i=void 0,ref:a=null,size:c="default",type:u="button",variant:h="default",$$slots:l,$$events:p,...g}=t;i?(e.push(""),e.push(``),s?.(e),e.push("")):(e.push(""),e.push(``),s?.(e),e.push("")),e.push(""),R(t,{ref:a})})}function Kn(n){return typeof n=="function"}function ut(n){return n!==null&&typeof n=="object"}const Hn=["string","number","bigint","boolean"];function Lt(n){return n==null||Hn.includes(typeof n)?!0:Array.isArray(n)?n.every(t=>Lt(t)):typeof n=="object"?Object.getPrototypeOf(n)===Object.prototype:!1}const Y=Symbol("box"),It=Symbol("is-writable");function m(n,t){const e=b(n);return t?{[Y]:!0,[It]:!0,get current(){return e()},set current(s){t(s)}}:{[Y]:!0,get current(){return n()}}}function lt(n){return ut(n)&&Y in n}function Kt(n){return lt(n)&&It in n}function zn(n){return lt(n)?n:Kn(n)?m(n):Le(n)}function Vn(n){return Object.entries(n).reduce((t,[e,s])=>lt(s)?(Kt(s)?Object.defineProperty(t,e,{get(){return s.current},set(o){s.current=o}}):Object.defineProperty(t,e,{get(){return s.current}}),t):Object.assign(t,{[e]:s}),{})}function jn(n){return Kt(n)?{[Y]:!0,get current(){return n.current}}:n}function Le(n){let t=n;return{[Y]:!0,[It]:!0,get current(){return t},set current(e){t=e}}}function W(n){let t=n;return{[Y]:!0,[It]:!0,get current(){return t},set current(e){t=e}}}W.from=zn;W.with=m;W.flatten=Vn;W.readonly=jn;W.isBox=lt;W.isWritableBox=Kt;function De(...n){return function(t){for(const e of n)if(e){if(t.defaultPrevented)return;typeof e=="function"?e.call(this,t):e.current?.call(this,t)}}}const Yn=/\d/,Xn=["-","_","/","."];function Jn(n=""){if(!Yn.test(n))return n!==n.toLowerCase()}function qn(n){const t=[];let e="",s,o;for(const r of n){const i=Xn.includes(r);if(i===!0){t.push(e),e="",s=void 0;continue}const a=Jn(r);if(o===!1){if(s===!1&&a===!0){t.push(e),e=r,s=a;continue}if(s===!0&&a===!1&&e.length>1){const c=e.at(-1);t.push(e.slice(0,Math.max(0,e.length-1))),e=c+r,s=a;continue}}e+=r,s=a,o=i}return t.push(e),t}function Re(n){return n?qn(n).map(t=>Qn(t)).join(""):""}function Zn(n){return $n(Re(n||""))}function Qn(n){return n?n[0].toUpperCase()+n.slice(1):""}function $n(n){return n?n[0].toLowerCase()+n.slice(1):""}function wt(n){if(!n)return{};const t={};function e(s,o){if(s.startsWith("-moz-")||s.startsWith("-webkit-")||s.startsWith("-ms-")||s.startsWith("-o-")){t[Re(s)]=o;return}if(s.startsWith("--")){t[s]=o;return}t[Zn(s)]=o}return In(n,e),t}function st(...n){return(...t)=>{for(const e of n)typeof e=="function"&&e(...t)}}function ts(n,t){const e=RegExp(n,"g");return s=>{if(typeof s!="string")throw new TypeError(`expected an argument of type string, but got ${typeof s}`);return s.match(e)?s.replace(e,t):s}}const es=ts(/[A-Z]/,n=>`-${n.toLowerCase()}`);function ns(n){if(!n||typeof n!="object"||Array.isArray(n))throw new TypeError(`expected an argument of type object, but got ${typeof n}`);return Object.keys(n).map(t=>`${es(t)}: ${n[t]};`).join(` +`)}function ss(n={}){return ns(n).replace(` +`," ")}const os=["onabort","onanimationcancel","onanimationend","onanimationiteration","onanimationstart","onauxclick","onbeforeinput","onbeforetoggle","onblur","oncancel","oncanplay","oncanplaythrough","onchange","onclick","onclose","oncompositionend","oncompositionstart","oncompositionupdate","oncontextlost","oncontextmenu","oncontextrestored","oncopy","oncuechange","oncut","ondblclick","ondrag","ondragend","ondragenter","ondragleave","ondragover","ondragstart","ondrop","ondurationchange","onemptied","onended","onerror","onfocus","onfocusin","onfocusout","onformdata","ongotpointercapture","oninput","oninvalid","onkeydown","onkeypress","onkeyup","onload","onloadeddata","onloadedmetadata","onloadstart","onlostpointercapture","onmousedown","onmouseenter","onmouseleave","onmousemove","onmouseout","onmouseover","onmouseup","onpaste","onpause","onplay","onplaying","onpointercancel","onpointerdown","onpointerenter","onpointerleave","onpointermove","onpointerout","onpointerover","onpointerup","onprogress","onratechange","onreset","onresize","onscroll","onscrollend","onsecuritypolicyviolation","onseeked","onseeking","onselect","onselectionchange","onselectstart","onslotchange","onstalled","onsubmit","onsuspend","ontimeupdate","ontoggle","ontouchcancel","ontouchend","ontouchmove","ontouchstart","ontransitioncancel","ontransitionend","ontransitionrun","ontransitionstart","onvolumechange","onwaiting","onwebkitanimationend","onwebkitanimationiteration","onwebkitanimationstart","onwebkittransitionend","onwheel"],rs=new Set(os);function is(n){return rs.has(n)}function F(...n){const t={...n[0]};for(let e=1;ethis.element.current?this.element.current.getRootNode()??document:document);get root(){return this.#t()}set root(t){return this.#t(t)}constructor(t){typeof t=="function"?this.element=m(t):this.element=t}getDocument=()=>q(this.root);getWindow=()=>this.getDocument().defaultView??window;getActiveElement=()=>ys(this.root);isActiveElement=t=>t===this.getActiveElement();getElementById(t){return this.root.getElementById(t)}querySelector=t=>this.root?this.root.querySelector(t):null;querySelectorAll=t=>this.root?this.root.querySelectorAll(t):[];setTimeout=(t,e)=>this.getWindow().setTimeout(t,e);clearTimeout=t=>this.getWindow().clearTimeout(t)}function ws(){return Symbol(vn)}function I(n,t){return{[ws()]:e=>lt(n)?(n.current=e,At(()=>t?.(e)),()=>{"isConnected"in e&&e.isConnected||(n.current=null,t?.(null))}):(n(e),At(()=>t?.(e)),()=>{"isConnected"in e&&e.isConnected||(n(null),t?.(null))})}}function zt(n){return n?"true":"false"}function Gr(n){return n?"true":void 0}function X(n){return n?"":void 0}function Wr(n){return n?!0:void 0}function kt(n){return n?"open":"closed"}function Kr(n){return n?"checked":"unchecked"}function Vt(n){return n==="starting"?{"data-starting-style":""}:n==="ending"?{"data-ending-style":""}:{}}function Hr(n,t){return t?"mixed":n?"true":"false"}class Cs{#t;#e;attrs;constructor(t){this.#t=t.getVariant?t.getVariant():null,this.#e=this.#t?`data-${this.#t}-`:`data-${t.component}-`,this.getAttr=this.getAttr.bind(this),this.selector=this.selector.bind(this),this.attrs=Object.fromEntries(t.parts.map(e=>[e,this.getAttr(e)]))}getAttr(t,e){return e?`data-${e}-${t}`:`${this.#e}${t}`}selector(t,e){return`[${this.getAttr(t,e)}]`}}function We(n){const t=new Cs(n);return{...t.attrs,selector:t.selector,getAttr:t.getAttr}}const at="ArrowDown",ht="ArrowLeft",ft="ArrowRight",Mt="ArrowUp",Ke="End",Nt="Enter",Es="Escape",He="Home",Ss="PageDown",Ts="PageUp",Z=" ",As="Tab";function Ms(n){return window.getComputedStyle(n).getPropertyValue("direction")}function xs(n="ltr",t="horizontal"){return{horizontal:n==="rtl"?ht:ft,vertical:at}[t]}function Is(n="ltr",t="horizontal"){return{horizontal:n==="rtl"?ft:ht,vertical:Mt}[t]}function ks(n="ltr",t="horizontal"){return["ltr","rtl"].includes(n)||(n="ltr"),["horizontal","vertical"].includes(t)||(t="horizontal"),{nextKey:xs(n,t),prevKey:Is(n,t)}}const ze=typeof document<"u",Ns=Os();function Os(){return ze&&window?.navigator?.userAgent&&(/iP(ad|hone|od)/.test(window.navigator.userAgent)||window?.navigator?.maxTouchPoints>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function L(n){return n instanceof HTMLElement}function ot(n){return n instanceof Element}function Ve(n){return n instanceof Element||n instanceof SVGElement}function zr(n){return n.pointerType==="touch"}function Vr(n){return n.matches(":focus-visible")}function jr(n){return n!==null}function Ps(n){return n instanceof HTMLInputElement&&"select"in n}class _s{#t;#e=W(null);constructor(t){this.#t=t}getCandidateNodes(){return[]}focusFirstCandidate(){const t=this.getCandidateNodes();t.length&&t[0]?.focus()}handleKeydown(t,e,s=!1){const o=this.#t.rootNode.current;if(!o||!t)return;const r=this.getCandidateNodes();if(!r.length)return;const i=r.indexOf(t),a=Ms(o),{nextKey:c,prevKey:u}=ks(a,this.#t.orientation.current),h=this.#t.loop.current,l={[c]:i+1,[u]:i-1,[He]:0,[Ke]:r.length-1};if(s){const w=c===at?ft:at,C=u===Mt?ht:Mt;l[w]=i+1,l[C]=i-1}let p=l[e.key];if(p===void 0)return;e.preventDefault(),p<0&&h?p=r.length-1:p===r.length&&h&&(p=0);const g=r[p];if(g)return g.focus(),this.#e.current=g.id,this.#t.onCandidateFocus?.(g),g}getTabIndex(t){const e=this.getCandidateNodes(),s=this.#e.current!==null;return t&&!s&&e[0]===t?(this.#e.current=t.id,0):t?.id===this.#e.current?0:-1}setCurrentTabStopId(t){this.#e.current=t}focusCurrentTabStop(){const t=this.#e.current;if(!t)return;const e=this.#t.rootNode.current?.querySelector(`#${t}`);!e||!L(e)||e.focus()}}class Fs{#t;#e=null;#n=null;#s=0;constructor(t){this.#t=t}#o(){this.#e!==null&&(window.cancelAnimationFrame(this.#e),this.#e=null),this.#n?.disconnect(),this.#n=null,this.#s++}run(t){this.#o();const e=this.#t.ref.current;if(!e)return;if(typeof e.getAnimations!="function"){this.#i(t);return}const s=this.#s,o=()=>{s===this.#s&&this.#i(t)},r=()=>{if(s!==this.#s)return;const a=e.getAnimations();if(a.length===0){o();return}Promise.all(a.map(c=>c.finished)).then(()=>{o()}).catch(()=>{if(s!==this.#s)return;if(e.getAnimations().some(h=>h.pending||h.playState!=="finished")){r();return}o()})},i=()=>{this.#e=window.requestAnimationFrame(()=>{this.#e=null,r()})};if(!this.#t.afterTick.current){i();return}this.#e=window.requestAnimationFrame(()=>{this.#e=null;const a="data-starting-style";if(!e.hasAttribute(a)){i();return}this.#n=new MutationObserver(()=>{s===this.#s&&(e.hasAttribute(a)||(this.#n?.disconnect(),this.#n=null,i()))}),this.#n.observe(e,{attributes:!0,attributeFilter:[a]})})}#i(t){const e=()=>{t()};this.#t.afterTick?O(e):e()}}class Rt{#t;#e;#n;#s=!1;#o=void 0;#i=!1;#r=null;constructor(t){this.#t=t,this.#s=t.open.current,this.#e=t.enabled??!0,this.#n=new Fs({ref:this.#t.ref,afterTick:this.#t.open}),A(()=>this.#t.open.current,e=>{if(!this.#i){this.#i=!0;return}if(this.#a(),!e&&this.#t.shouldSkipExitAnimation?.()){this.#s=!1,this.#o=void 0,this.#t.onComplete?.();return}if(e&&(this.#s=!0),this.#o=e?"starting":"ending",e&&(this.#r=window.requestAnimationFrame(()=>{this.#r=null,this.#t.open.current&&(this.#o=void 0)})),!this.#e){e||(this.#s=!1),this.#o=void 0,this.#t.onComplete?.();return}this.#n.run(()=>{e===this.#t.open.current&&(this.#t.open.current||(this.#s=!1),this.#o=void 0,this.#t.onComplete?.())})})}get shouldRender(){return this.#s}get transitionStatus(){return this.#o}#a(){this.#r!==null&&(window.cancelAnimationFrame(this.#r),this.#r=null)}}function E(){}function jt(n,t){return`bits-${n}`}const Ls=We({component:"dialog",parts:["content","trigger","overlay","title","description","close","cancel","action"]}),D=new dt("Dialog.Root | AlertDialog.Root");class je{static create(t){const e=D.getOr(null);return D.set(new je(t,e))}opts;triggerNode=null;contentNode=null;overlayNode=null;descriptionNode=null;contentId=void 0;titleId=void 0;triggerId=void 0;descriptionId=void 0;cancelNode=null;nestedOpenCount=0;depth;parent;contentPresence;overlayPresence;constructor(t,e){this.opts=t,this.parent=e,this.depth=e?e.depth+1:0,this.handleOpen=this.handleOpen.bind(this),this.handleClose=this.handleClose.bind(this),this.contentPresence=new Rt({ref:m(()=>this.contentNode),open:this.opts.open,enabled:!0,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)}}),this.overlayPresence=new Rt({ref:m(()=>this.overlayNode),open:this.opts.open,enabled:!0}),A(()=>this.opts.open.current,s=>{this.parent&&(s?this.parent.incrementNested():this.parent.decrementNested())},{lazy:!0})}handleOpen(){this.opts.open.current||(this.opts.open.current=!0)}handleClose(){this.opts.open.current&&(this.opts.open.current=!1)}getBitsAttr=t=>Ls.getAttr(t,this.opts.variant.current);incrementNested(){this.nestedOpenCount++,this.parent?.incrementNested()}decrementNested(){this.nestedOpenCount!==0&&(this.nestedOpenCount--,this.parent?.decrementNested())}#t=b(()=>({"data-state":kt(this.opts.open.current)}));get sharedProps(){return this.#t()}set sharedProps(t){return this.#t(t)}}class Yt{static create(t){return new Yt(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this)}onclick(t){this.opts.disabled.current||t.button>0||this.root.handleClose()}onkeydown(t){this.opts.disabled.current||(t.key===Z||t.key===Nt)&&(t.preventDefault(),this.root.handleClose())}#t=b(()=>({id:this.opts.id.current,[this.root.getBitsAttr(this.opts.variant.current)]:"",onclick:this.onclick,onkeydown:this.onkeydown,disabled:this.opts.disabled.current?!0:void 0,tabindex:0,...this.root.sharedProps,...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}class Ye{static create(t){return new Ye(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref)}#t=b(()=>({id:this.opts.id.current,[this.root.getBitsAttr("action")]:"",...this.root.sharedProps,...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}class Xe{static create(t){return new Xe(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.root.titleId=this.opts.id.current,this.attachment=I(this.opts.ref),A.pre(()=>this.opts.id.current,s=>{this.root.titleId=s})}#t=b(()=>({id:this.opts.id.current,role:"heading","aria-level":this.opts.level.current,[this.root.getBitsAttr("title")]:"",...this.root.sharedProps,...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}class Je{static create(t){return new Je(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.root.descriptionId=this.opts.id.current,this.attachment=I(this.opts.ref,s=>{this.root.descriptionNode=s}),A.pre(()=>this.opts.id.current,s=>{this.root.descriptionId=s})}#t=b(()=>({id:this.opts.id.current,[this.root.getBitsAttr("description")]:"",...this.root.sharedProps,...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}class Xt{static create(t){return new Xt(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref,s=>{this.root.contentNode=s,this.root.contentId=s?.id})}#t=b(()=>({open:this.root.opts.open.current}));get snippetProps(){return this.#t()}set snippetProps(t){return this.#t(t)}#e=b(()=>({id:this.opts.id.current,role:this.root.opts.variant.current==="alert-dialog"?"alertdialog":"dialog","aria-modal":"true","aria-describedby":this.root.descriptionId,"aria-labelledby":this.root.titleId,[this.root.getBitsAttr("content")]:"",style:{pointerEvents:"auto",outline:this.root.opts.variant.current==="alert-dialog"?"none":void 0,"--bits-dialog-depth":this.root.depth,"--bits-dialog-nested-count":this.root.nestedOpenCount,contain:"layout style"},tabindex:this.root.opts.variant.current==="alert-dialog"?-1:void 0,"data-nested-open":X(this.root.nestedOpenCount>0),"data-nested":X(this.root.parent!==null),...Vt(this.root.contentPresence.transitionStatus),...this.root.sharedProps,...this.attachment}));get props(){return this.#e()}set props(t){return this.#e(t)}get shouldRender(){return this.root.contentPresence.shouldRender}}class Jt{static create(t){return new Jt(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref,s=>this.root.overlayNode=s)}#t=b(()=>({open:this.root.opts.open.current}));get snippetProps(){return this.#t()}set snippetProps(t){return this.#t(t)}#e=b(()=>({id:this.opts.id.current,[this.root.getBitsAttr("overlay")]:"",style:{pointerEvents:"auto","--bits-dialog-depth":this.root.depth,"--bits-dialog-nested-count":this.root.nestedOpenCount},"data-nested-open":X(this.root.nestedOpenCount>0),"data-nested":X(this.root.parent!==null),...Vt(this.root.overlayPresence.transitionStatus),...this.root.sharedProps,...this.attachment}));get props(){return this.#e()}set props(t){return this.#e(t)}get shouldRender(){return this.root.overlayPresence.shouldRender}}class qe{static create(t){return new qe(t,D.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref,s=>this.root.cancelNode=s),this.onclick=this.onclick.bind(this),this.onkeydown=this.onkeydown.bind(this)}onclick(t){this.opts.disabled.current||t.button>0||this.root.handleClose()}onkeydown(t){this.opts.disabled.current||(t.key===Z||t.key===Nt)&&(t.preventDefault(),this.root.handleClose())}#t=b(()=>({id:this.opts.id.current,[this.root.getBitsAttr("cancel")]:"",onclick:this.onclick,onkeydown:this.onkeydown,tabindex:0,...this.root.sharedProps,...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}const Ds=new dt("BitsConfig");function Rs(){const n=new Bs(null,{});return Ds.getOr(n).opts}class Bs{opts;constructor(t,e){const s=Us(t,e);this.opts={defaultPortalTo:s(o=>o.defaultPortalTo),defaultLocale:s(o=>o.defaultLocale)}}}function Us(n,t){return e=>m(()=>{const o=e(t)?.current;if(o!==void 0)return o;if(n!==null)return e(n.opts)?.current})}function Gs(n,t){return e=>{const s=Rs();return m(()=>{const o=e();if(o!==void 0)return o;const r=n(s).current;return r!==void 0?r:t})}}const Ws=Gs(n=>n.defaultPortalTo,"body");function le(n,t){n.component(e=>{let{to:s,children:o,disabled:r}=t;const i=Ws(()=>s);bn();let a=b(c);function c(){if(!ze||r)return null;let l=null;return typeof i.current=="string"?l=document.querySelector(i.current):l=i.current,l}let u;function h(){u&&(Dn(),u=null)}A([()=>a(),()=>r],([l,p])=>{if(!l||p){h();return}return u=Ln(),()=>{h()}}),r?(e.push(""),o?.(e),e.push("")):e.push(""),e.push("")})}class Ks{eventName;options;constructor(t,e={bubbles:!0,cancelable:!0}){this.eventName=t,this.options=e}createEvent(t){return new CustomEvent(this.eventName,{...this.options,detail:t})}dispatch(t,e){const s=this.createEvent(e);return t.dispatchEvent(s),s}listen(t,e,s){const o=r=>{e(r)};return P(t,this.eventName,o,s)}}function de(n,t=500){let e=null;const s=(...o)=>{e!==null&&clearTimeout(e),e=setTimeout(()=>{n(...o)},t)};return s.destroy=()=>{e!==null&&(clearTimeout(e),e=null)},s}function Ze(n,t){return n===t||n.contains(t)}function Hs(n){return n?.ownerDocument??document}function zs(n,t){const{clientX:e,clientY:s}=n,o=t.getBoundingClientRect();return eo.right||so.bottom}const Bt=[Nt,Z],Vs=[at,Ts,He],Qe=[Mt,Ss,Ke],js=[...Vs,...Qe],Ys={ltr:[...Bt,ft],rtl:[...Bt,ht]},Yr={ltr:[ht],rtl:[ft]};function N(n){return n.pointerType==="mouse"}function Xs(n,{select:t=!1}={}){if(!n||!n.focus)return;const e=q(n);if(e.activeElement===n)return;const s=e.activeElement;n.focus({preventScroll:!0}),n!==s&&Ps(n)&&t&&n.select()}function Js(n,{select:t=!1}={},e){const s=e();for(const o of n)if(Xs(o,{select:t}),e()!==s)return!0}function Xr(n){const t=[],s=q(n).createTreeWalker(n,NodeFilter.SHOW_ELEMENT,{acceptNode:o=>{const r=o.tagName==="INPUT"&&o.type==="hidden";return o.disabled||o.hidden||r?NodeFilter.FILTER_SKIP:o.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;s.nextNode();)t.push(s.currentNode);return t}let he=!1;class qs{static _refs=0;static _cleanup;constructor(){}get current(){return he}set current(t){he=t}}function rt(){return{getShadowRoot:!0,displayCheck:typeof ResizeObserver=="function"&&ResizeObserver.toString().includes("[native code]")?"full":"none"}}function Zs(n,t){if(!Wt(n,rt()))return Qs(n,t);const e=q(n),s=Pe(e.body,rt());t==="prev"&&s.reverse();const o=s.indexOf(n);return o===-1?e.body:s.slice(o+1)[0]}function Qs(n,t){const e=q(n);if(!_e(n,rt()))return e.body;const s=Fe(e.body,rt());t==="prev"&&s.reverse();const o=s.indexOf(n);return o===-1?e.body:s.slice(o+1).find(i=>Wt(i,rt()))??e.body}function Jr(n,t,e=!0){if(!(n.length===0||t<0||t>=n.length))return n.length===1&&t===0?n[0]:t===n.length-1?e?n[0]:void 0:n[t+1]}function qr(n,t,e=!0){if(!(n.length===0||t<0||t>=n.length))return n.length===1&&t===0?n[0]:t===0?e?n[n.length-1]:void 0:n[t-1]}function Zr(n,t,e,s=!0){if(n.length===0||t<0||t>=n.length)return;let o=t+e;return s?o=(o%n.length+n.length)%n.length:o=Math.max(0,Math.min(o,n.length-1)),n[o]}function Qr(n,t,e,s=!0){if(n.length===0||t<0||t>=n.length)return;let o=t-e;return s?o=(o%n.length+n.length)%n.length:o=Math.max(0,Math.min(o,n.length-1)),n[o]}function $e(n,t,e){const s=t.toLowerCase();if(s.endsWith(" ")){const l=s.slice(0,-1);if(n.filter(C=>C.toLowerCase().startsWith(l)).length<=1)return $e(n,l,e);const g=e?.toLowerCase();if(g&&g.startsWith(l)&&g.charAt(l.length)===" "&&t.trim()===l)return e;const w=n.filter(C=>C.toLowerCase().startsWith(s));if(w.length>0){const C=e?n.indexOf(e):-1;return fe(w,Math.max(C,0)).find(Ot=>Ot!==e)||e}}const r=t.length>1&&Array.from(t).every(l=>l===t[0])?t[0]:t,i=r.toLowerCase(),a=e?n.indexOf(e):-1;let c=fe(n,Math.max(a,0));r.length===1&&(c=c.filter(l=>l!==e));const h=c.find(l=>l?.toLowerCase().startsWith(i));return h!==e?h:void 0}function fe(n,t){return n.map((e,s)=>n[(t+s)%n.length])}const $s={afterMs:1e4,onChange:E};function to(n,t){const{afterMs:e,onChange:s,getWindow:o}={...$s,...t};let r=null,i=n;function a(){return o().setTimeout(()=>{i=n,s?.(n)},e)}return m(()=>i,c=>{i=c,s?.(c),r&&o().clearTimeout(r),r=a()})}class eo{#t;#e;#n=b(()=>this.#t.onMatch?this.#t.onMatch:t=>t.focus());#s=b(()=>this.#t.getCurrentItem?this.#t.getCurrentItem:this.#t.getActiveElement);constructor(t){this.#t=t,this.#e=to("",{afterMs:1e3,getWindow:t.getWindow}),this.handleTypeaheadSearch=this.handleTypeaheadSearch.bind(this),this.resetTypeahead=this.resetTypeahead.bind(this)}handleTypeaheadSearch(t,e){if(!e.length)return;this.#e.current=this.#e.current+t;const s=this.#s()(),o=e.find(c=>c===s)?.textContent?.trim()??"",r=e.map(c=>c.textContent?.trim()??""),i=$e(r,this.#e.current,o),a=e.find(c=>c.textContent?.trim()===i);return a&&this.#n()(a),a}resetTypeahead(){this.#e.current=""}get search(){return this.#e.current}}const no="data-context-menu-trigger",so="data-context-menu-content",tn=new dt("Menu.Root"),J=new dt("Menu.Root | Menu.Sub"),qt=new dt("Menu.Content"),en=new Ks("bitsmenuopen",{bubbles:!1,cancelable:!0}),oo=We({component:"menu",parts:["trigger","content","sub-trigger","item","group","group-heading","checkbox-group","checkbox-item","radio-group","radio-item","separator","sub-content","arrow"]});class ro{#t;#e=null;#n=null;#s=!1;#o=null;#i=null;#r=null;#a=null;constructor(t){this.#t=t,A([t.triggerNode,t.contentNode,t.enabled],([e,s,o])=>{if(this.#b(),!e||!s||!o)return;const r=l=>{N(l)&&(this.#a={x:l.clientX,y:l.clientY},this.#s||this.#l(l,"content"))},i=l=>{N(l)&&this.#v(l,"content")},a=l=>{N(l)&&(this.#s||this.#l(l,"trigger"))},c=l=>{if(N(l)){if(ot(l.relatedTarget)){const p=this.#t.subContentSelector(),g=l.relatedTarget.closest(p);if(g&&g!==s&&g.id&&!!s.querySelector(`[aria-controls="${g.id}"]`))return}this.#v(l,"trigger")}},u=l=>{N(l)&&this.#h()},h=l=>{N(l)&&this.#h()};return e.addEventListener("pointermove",r),e.addEventListener("pointerleave",i),e.addEventListener("pointerenter",u),s.addEventListener("pointermove",a),s.addEventListener("pointerleave",c),s.addEventListener("pointerenter",h),()=>{e.removeEventListener("pointermove",r),e.removeEventListener("pointerleave",i),e.removeEventListener("pointerenter",u),s.removeEventListener("pointermove",a),s.removeEventListener("pointerleave",c),s.removeEventListener("pointerenter",h),this.#b()}})}#p(){const t=this.#t.parentContentNode();return t?t.getBoundingClientRect():this.#t.triggerNode()?.getBoundingClientRect()??null}#c(t,e){const s=this.#t.triggerNode(),o=this.#t.contentNode();if(!s||!o)return null;const r=s.getBoundingClientRect(),i=o.getBoundingClientRect(),a=ao(r,i);let c,u,h;return e==="content"?(c=this.#s?this.#i??t:t,u=i):(c=this.#a??t,u=this.#p()??r,h=i),this.#i=c,{corridor:co(r,i,a),intent:uo(c,u,a,e,h),targetRect:u,side:a}}#u(t,e,s){return pe(t,e)||pe(t,s)}#l(t,e){const s={x:t.clientX,y:t.clientY};this.#c(s,e)&&(this.#o=e,this.#r=s)}#v(t,e){if(!this.#t.enabled())return;const s=this.#t.triggerNode(),o=this.#t.contentNode();if(!s||!o)return;const r=t.relatedTarget;if(ot(r)&&(e==="content"&&o.contains(r)||e==="trigger"&&s.contains(r)))return;const i={x:t.clientX,y:t.clientY},a=this.#c(i,e);if(a){if(!ge(i,a.targetRect)&&!this.#u(i,a.corridor,a.intent)){this.#S();return}this.#s=!0,this.#o=e,this.#r=i,this.#t.setIsPointerInTransit(!0),this.#T(),this.#E()}}#d=null;#h(){if(!this.#s)return;const t=this.#o==="trigger";this.#C(),this.#m(),this.#s=!1,this.#S(),t?(this.#g(),this.#d=setTimeout(()=>{this.#d=null,this.#t.setIsPointerInTransit(!1)},100)):this.#t.setIsPointerInTransit(!1)}#g(){this.#d!==null&&(clearTimeout(this.#d),this.#d=null)}#f(){const t=this.#r;this.#C(),this.#m(),this.#g(),this.#s=!1,this.#t.setIsPointerInTransit(!1),this.#S(),this.#t.onIntentExit(t)}#b(){this.#C(),this.#m(),this.#g(),this.#s&&this.#t.setIsPointerInTransit(!1),this.#s=!1,this.#o=null,this.#i=null,this.#r=null,this.#a=null}#w(t){const e=this.#t.contentNode();if(!e)return!1;const o=e.ownerDocument.elementFromPoint(t.x,t.y);if(!o)return!1;const r=this.#t.subContentSelector(),i=o.closest(r);return!i||i===e?!1:i.id?!!e.querySelector(`[aria-controls="${i.id}"]`):!1}#y=t=>{if(!this.#s||!this.#o||!N(t))return;const e=this.#t.triggerNode(),s=this.#t.contentNode();if(!e||!s){this.#f();return}this.#m();const o={x:t.clientX,y:t.clientY};this.#r=o;const r=e.getBoundingClientRect(),i=s.getBoundingClientRect();if(this.#o==="content"&&ge(o,i)){this.#h();return}if(this.#o==="trigger"&&io(o,r,4)){this.#h();return}if(this.#w(o)){this.#E();return}const a=this.#c(o,this.#o);if(!a){this.#f();return}if(this.#u(o,a.corridor,a.intent)){this.#E();return}this.#f()};#T(){if(this.#e)return;const t=q(this.#t.triggerNode()??this.#t.contentNode());t&&(t.addEventListener("pointermove",this.#y,!0),this.#e=()=>{t.removeEventListener("pointermove",this.#y,!0),this.#e=null})}#C(){this.#e?.()}#E(){this.#m(),this.#n=setTimeout(()=>{this.#n=null,this.#s&&this.#f()},500)}#m(){this.#n!==null&&(clearTimeout(this.#n),this.#n=null)}#S(){this.#o=null,this.#i=null,this.#r=null}}function pe(n,t){const{x:e,y:s}=n;let o=!1;for(let r=0,i=t.length-1;rs!=h>s&&e<(u-a)*(s-c)/(h-c)+a&&(o=!o)}return o}function ge(n,t){return n.x>=t.left&&n.x<=t.right&&n.y>=t.top&&n.y<=t.bottom}function io(n,t,e){return n.x>=t.left+e&&n.x<=t.right-e&&n.y>=t.top+e&&n.y<=t.bottom-e}function ao(n,t){const e=n.left+n.width/2,s=n.top+n.height/2,o=t.left+t.width/2,r=t.top+t.height/2,i=o-e,a=r-s;return Math.abs(i)>Math.abs(a)?i>0?"right":"left":a>0?"bottom":"top"}function co(n,t,e){switch(e){case"top":return[{x:Math.min(n.left,t.left)-2,y:n.top},{x:Math.min(n.left,t.left)-2,y:t.bottom},{x:Math.max(n.right,t.right)+2,y:t.bottom},{x:Math.max(n.right,t.right)+2,y:n.top}];case"bottom":return[{x:Math.min(n.left,t.left)-2,y:n.bottom},{x:Math.min(n.left,t.left)-2,y:t.top},{x:Math.max(n.right,t.right)+2,y:t.top},{x:Math.max(n.right,t.right)+2,y:n.bottom}];case"left":return[{x:n.left,y:Math.min(n.top,t.top)-2},{x:t.right,y:Math.min(n.top,t.top)-2},{x:t.right,y:Math.max(n.bottom,t.bottom)+2},{x:n.left,y:Math.max(n.bottom,t.bottom)+2}];case"right":return[{x:n.right,y:Math.min(n.top,t.top)-2},{x:t.left,y:Math.min(n.top,t.top)-2},{x:t.left,y:Math.max(n.bottom,t.bottom)+2},{x:n.right,y:Math.max(n.bottom,t.bottom)+2}]}}function uo(n,t,e,s,o){const i=s==="trigger"?lo(e):e,a=o?Math.min(t.top,o.top)-8:t.top-8,c=o?Math.max(t.bottom,o.bottom)+8:t.bottom+8,u=o?Math.min(t.left,o.left)-8:t.left-8,h=o?Math.max(t.right,o.right)+8:t.right+8;switch(i){case"right":return[n,{x:t.left,y:a},{x:t.left,y:c}];case"left":return[n,{x:t.right,y:a},{x:t.right,y:c}];case"bottom":return[n,{x:u,y:t.top},{x:h,y:t.top}];case"top":return[n,{x:u,y:t.bottom},{x:h,y:t.bottom}]}}function lo(n){switch(n){case"top":return"bottom";case"bottom":return"top";case"left":return"right";case"right":return"left"}}class nn{static create(t){const e=new nn(t);return tn.set(e)}opts;isUsingKeyboard=new qs;ignoreCloseAutoFocus=!1;isPointerInTransit=!1;constructor(t){this.opts=t}getBitsAttr=t=>oo.getAttr(t,this.opts.variant.current)}class Zt{static create(t,e){return J.set(new Zt(t,e,null))}opts;root;parentMenu;contentId=m(()=>"");contentNode=null;contentPresence;triggerNode=null;constructor(t,e,s){this.opts=t,this.root=e,this.parentMenu=s,this.contentPresence=new Rt({ref:m(()=>this.contentNode),open:this.opts.open,onComplete:()=>{this.opts.onOpenChangeComplete.current(this.opts.open.current)},shouldSkipExitAnimation:()=>this.root.opts.variant.current!=="menubar"||this.parentMenu!==null?!1:this.root.opts.shouldSkipExitAnimation?.()??!1}),s&&A(()=>s.opts.open.current,()=>{s.opts.open.current||(this.opts.open.current=!1)})}toggleOpen(){this.opts.open.current=!this.opts.open.current}onOpen(){this.opts.open.current=!0}onClose(){this.opts.open.current=!1}}class sn{static create(t){return qt.set(new sn(t,J.get()))}opts;parentMenu;rovingFocusGroup;domContext;attachment;search="";#t=0;#e;mounted=!1;#n;constructor(t,e){this.opts=t,this.parentMenu=e,this.domContext=new Ht(t.ref),this.attachment=I(this.opts.ref,s=>{this.parentMenu.contentNode!==s&&(this.parentMenu.contentNode=s)}),e.contentId=t.id,this.#n=t.isSub??!1,this.onkeydown=this.onkeydown.bind(this),this.onblur=this.onblur.bind(this),this.onfocus=this.onfocus.bind(this),this.handleInteractOutside=this.handleInteractOutside.bind(this),new ro({contentNode:()=>this.parentMenu.contentNode,triggerNode:()=>this.parentMenu.triggerNode,parentContentNode:()=>this.parentMenu.parentMenu?.contentNode??null,subContentSelector:()=>`[${this.parentMenu.root.getBitsAttr("sub-content")}]`,enabled:()=>this.parentMenu.opts.open.current&&!!this.parentMenu.triggerNode?.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger")),onIntentExit:s=>{this.parentMenu.opts.open.current=!1,this.#i(s)},setIsPointerInTransit:s=>{this.parentMenu.root.isPointerInTransit=s}}),this.#e=new eo({getActiveElement:()=>this.domContext.getActiveElement(),getWindow:()=>this.domContext.getWindow()}).handleTypeaheadSearch,this.rovingFocusGroup=new _s({rootNode:m(()=>this.parentMenu.contentNode),candidateAttr:this.parentMenu.root.getBitsAttr("item"),loop:this.opts.loop,orientation:m(()=>"vertical")}),A(()=>this.parentMenu.contentNode,s=>{if(!s)return;const o=()=>{O(()=>{this.parentMenu.root.isUsingKeyboard.current&&this.rovingFocusGroup.focusFirstCandidate()})};return en.listen(s,o)})}#s(){const t=this.parentMenu.contentNode;return t?Array.from(t.querySelectorAll(`[${this.parentMenu.root.getBitsAttr("item")}]:not([data-disabled])`)):[]}#o(){return this.parentMenu.root.isPointerInTransit}#i(t){if(!t)return;const e=this.parentMenu.parentMenu?.contentNode;if(!e)return;const s=this.domContext.getDocument().elementFromPoint(t.x,t.y);if(!ot(s))return;const o=s.closest(`[${this.parentMenu.root.getBitsAttr("sub-trigger")}]`);!o||!e.contains(o)||o!==this.parentMenu.triggerNode&&o.dispatchEvent(new PointerEvent("pointermove",{bubbles:!0,cancelable:!0,pointerType:"mouse",clientX:t.x,clientY:t.y}))}onCloseAutoFocus=t=>{if(this.opts.onCloseAutoFocus.current?.(t),!(t.defaultPrevented||this.#n)){if(this.parentMenu.root.ignoreCloseAutoFocus){t.preventDefault();return}this.parentMenu.triggerNode&&Wt(this.parentMenu.triggerNode)&&(t.preventDefault(),this.parentMenu.triggerNode.focus())}};handleTabKeyDown(t){let e=this.parentMenu;for(;e.parentMenu!==null;)e=e.parentMenu;if(!e.triggerNode)return;t.preventDefault();const s=Zs(e.triggerNode,t.shiftKey?"prev":"next");s?(this.parentMenu.root.ignoreCloseAutoFocus=!0,e.onClose(),O(()=>{s.focus(),O(()=>{this.parentMenu.root.ignoreCloseAutoFocus=!1})})):this.domContext.getDocument().body.focus()}onkeydown(t){if(t.defaultPrevented)return;if(t.key===As){this.handleTabKeyDown(t);return}const e=t.target,s=t.currentTarget;if(!L(e)||!L(s))return;const o=e.closest(`[${this.parentMenu.root.getBitsAttr("content")}]`)?.id===this.parentMenu.contentId.current,r=t.ctrlKey||t.altKey||t.metaKey,i=t.key.length===1;if(this.rovingFocusGroup.handleKeydown(e,t)||t.code==="Space")return;const c=this.#s();o&&!r&&i&&this.#e(t.key,c),t.target?.id===this.parentMenu.contentId.current&&js.includes(t.key)&&(t.preventDefault(),Qe.includes(t.key)&&c.reverse(),Js(c,{select:!1},()=>this.domContext.getActiveElement()))}onblur(t){ot(t.currentTarget)&&ot(t.target)&&(t.currentTarget.contains?.(t.target)||(this.domContext.getWindow().clearTimeout(this.#t),this.search=""))}onfocus(t){this.parentMenu.root.isUsingKeyboard.current&&O(()=>this.rovingFocusGroup.focusFirstCandidate())}onItemEnter(){return this.#o()}onItemLeave(t){if(t.currentTarget.hasAttribute(this.parentMenu.root.getBitsAttr("sub-trigger"))||this.#o()||this.parentMenu.root.isUsingKeyboard.current)return;this.parentMenu.contentNode?.focus({preventScroll:!0}),this.rovingFocusGroup.setCurrentTabStopId("")}onTriggerLeave(){return!!this.#o()}handleInteractOutside(t){if(!Ve(t.target))return;const e=this.parentMenu.triggerNode?.id;if(t.target.id===e){t.preventDefault();return}if(t.target.closest(`#${e}`)){t.preventDefault();return}this.parentMenu.root.ignoreCloseAutoFocus=!0,O(()=>{this.parentMenu.root.ignoreCloseAutoFocus=!1})}get shouldRender(){return this.parentMenu.contentPresence.shouldRender}#r=b(()=>({open:this.parentMenu.opts.open.current}));get snippetProps(){return this.#r()}set snippetProps(t){return this.#r(t)}#a=b(()=>({id:this.opts.id.current,role:"menu","aria-orientation":"vertical",[this.parentMenu.root.getBitsAttr("content")]:"","data-state":kt(this.parentMenu.opts.open.current),...Vt(this.parentMenu.contentPresence.transitionStatus),onkeydown:this.onkeydown,onblur:this.onblur,onfocus:this.onfocus,dir:this.parentMenu.root.opts.dir.current,style:{pointerEvents:"auto",contain:"layout style"},...this.attachment}));get props(){return this.#a()}set props(t){return this.#a(t)}popperProps={onCloseAutoFocus:t=>this.onCloseAutoFocus(t)}}class on{opts;content;attachment;#t=!1;constructor(t,e){this.opts=t,this.content=e,this.attachment=I(this.opts.ref),this.onpointermove=this.onpointermove.bind(this),this.onpointerleave=this.onpointerleave.bind(this),this.onfocus=this.onfocus.bind(this),this.onblur=this.onblur.bind(this)}onpointermove(t){if(!t.defaultPrevented&&N(t))if(this.opts.disabled.current)this.content.onItemLeave(t);else{if(this.content.onItemEnter())return;const s=t.currentTarget;if(!L(s))return;s.focus({preventScroll:!0})}}onpointerleave(t){t.defaultPrevented||N(t)&&this.content.onItemLeave(t)}onfocus(t){O(()=>{t.defaultPrevented||this.opts.disabled.current||(this.#t=!0)})}onblur(t){O(()=>{t.defaultPrevented||(this.#t=!1)})}#e=b(()=>({id:this.opts.id.current,tabindex:-1,role:"menuitem","aria-disabled":zt(this.opts.disabled.current),"data-disabled":X(this.opts.disabled.current),"data-highlighted":this.#t?"":void 0,[this.content.parentMenu.root.getBitsAttr("item")]:"",onpointermove:this.onpointermove,onpointerleave:this.onpointerleave,onfocus:this.onfocus,onblur:this.onblur,...this.attachment}));get props(){return this.#e()}set props(t){return this.#e(t)}}class rn{static create(t){const e=new on(t,qt.get());return new rn(t,e)}opts;item;root;#t=!1;constructor(t,e){this.opts=t,this.item=e,this.root=e.content.parentMenu.root,this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this),this.onpointerdown=this.onpointerdown.bind(this),this.onpointerup=this.onpointerup.bind(this)}#e(){if(this.item.opts.disabled.current)return;const t=new CustomEvent("menuitemselect",{bubbles:!0,cancelable:!0});if(this.opts.onSelect.current(t),t.defaultPrevented){this.item.content.parentMenu.root.isUsingKeyboard.current=!1;return}this.opts.closeOnSelect.current&&this.item.content.parentMenu.root.opts.onClose()}onkeydown(t){const e=this.item.content.search!=="";if(!(this.item.opts.disabled.current||e&&t.key===Z)&&Bt.includes(t.key)){if(!L(t.currentTarget))return;t.currentTarget.click(),t.preventDefault()}}onclick(t){this.item.opts.disabled.current||this.#e()}onpointerup(t){if(!t.defaultPrevented&&!this.#t){if(!L(t.currentTarget))return;t.currentTarget?.click()}}onpointerdown(t){this.#t=!0}#n=b(()=>F(this.item.props,{onclick:this.onclick,onpointerdown:this.onpointerdown,onpointerup:this.onpointerup,onkeydown:this.onkeydown}));get props(){return this.#n()}set props(t){return this.#n(t)}}class an{static create(t){const e=qt.get(),s=new on(t,e),o=J.get();return new an(t,s,e,o)}opts;item;content;submenu;attachment;#t=null;constructor(t,e,s,o){this.opts=t,this.item=e,this.content=s,this.submenu=o,this.attachment=I(this.opts.ref,r=>this.submenu.triggerNode=r),this.onpointerleave=this.onpointerleave.bind(this),this.onpointermove=this.onpointermove.bind(this),this.onkeydown=this.onkeydown.bind(this),this.onclick=this.onclick.bind(this)}#e(){this.#t!==null&&(this.content.domContext.getWindow().clearTimeout(this.#t),this.#t=null)}onpointermove(t){if(N(t)){if(this.submenu.root.isPointerInTransit){this.#t!==null&&this.#e();return}if(!this.item.opts.disabled.current&&!this.submenu.opts.open.current&&!this.#t){const e=this.opts.openDelay.current;if(e<=0){this.submenu.onOpen();return}this.#t=this.content.domContext.setTimeout(()=>{if(this.submenu.root.isPointerInTransit){this.#e();return}this.submenu.onOpen(),this.#e()},e)}}}onpointerleave(t){N(t)&&this.#e()}onkeydown(t){const e=this.content.search!=="";this.item.opts.disabled.current||e&&t.key===Z||Ys[this.submenu.root.opts.dir.current].includes(t.key)&&(t.currentTarget.click(),t.preventDefault())}onclick(t){if(this.item.opts.disabled.current||!L(t.currentTarget))return;t.currentTarget.focus();const e=new CustomEvent("menusubtriggerselect",{bubbles:!0,cancelable:!0});this.opts.onSelect.current(e),this.submenu.opts.open.current||(this.submenu.onOpen(),O(()=>{const s=this.submenu.contentNode;s&&en.dispatch(s)}))}#n=b(()=>F({"aria-haspopup":"menu","aria-expanded":zt(this.submenu.opts.open.current),"data-state":kt(this.submenu.opts.open.current),"aria-controls":this.submenu.opts.open.current?this.submenu.contentId.current:void 0,[this.submenu.root.getBitsAttr("sub-trigger")]:"",onclick:this.onclick,onpointermove:this.onpointermove,onpointerleave:this.onpointerleave,onkeydown:this.onkeydown,...this.attachment},this.item.props));get props(){return this.#n()}set props(t){return this.#n(t)}}class cn{static create(t){return new cn(t,tn.get())}opts;root;attachment;constructor(t,e){this.opts=t,this.root=e,this.attachment=I(this.opts.ref)}#t=b(()=>({id:this.opts.id.current,role:"group",[this.root.getBitsAttr("separator")]:"",...this.attachment}));get props(){return this.#t()}set props(t){return this.#t(t)}}class un{static create(t){return new un(t,J.get())}opts;parentMenu;attachment;constructor(t,e){this.opts=t,this.parentMenu=e,this.attachment=I(this.opts.ref,s=>this.parentMenu.triggerNode=s)}onclick=t=>{this.opts.disabled.current||t.detail!==0||(this.parentMenu.toggleOpen(),t.preventDefault())};onpointerdown=t=>{if(!this.opts.disabled.current){if(t.pointerType==="touch")return t.preventDefault();t.button===0&&t.ctrlKey===!1&&(this.parentMenu.toggleOpen(),this.parentMenu.opts.open.current||t.preventDefault())}};onpointerup=t=>{this.opts.disabled.current||t.pointerType==="touch"&&(t.preventDefault(),this.parentMenu.toggleOpen())};onkeydown=t=>{if(!this.opts.disabled.current){if(t.key===Z||t.key===Nt){this.parentMenu.toggleOpen(),t.preventDefault();return}t.key===at&&(this.parentMenu.onOpen(),t.preventDefault())}};#t=b(()=>{if(this.parentMenu.opts.open.current&&this.parentMenu.contentId.current)return this.parentMenu.contentId.current});#e=b(()=>({id:this.opts.id.current,disabled:this.opts.disabled.current,"aria-haspopup":"menu","aria-expanded":zt(this.parentMenu.opts.open.current),"aria-controls":this.#t(),"data-disabled":X(this.opts.disabled.current),"data-state":kt(this.parentMenu.opts.open.current),[this.parentMenu.root.getBitsAttr("trigger")]:"",onclick:this.onclick,onpointerdown:this.onpointerdown,onpointerup:this.onpointerup,onkeydown:this.onkeydown,...this.attachment}));get props(){return this.#e()}set props(t){return this.#e(t)}}class $r{static create(t){const e=J.get();return J.set(new Zt(t,e.root,e))}}globalThis.bitsDismissableLayers??=new Map;class Qt{static create(t){return new Qt(t)}opts;#t;#e;#n={pointerdown:!1};#s=!1;#o=!1;#i=void 0;#r;#a=E;constructor(t){this.opts=t,this.#e=t.interactOutsideBehavior,this.#t=t.onInteractOutside,this.#r=t.onFocusOutside;let e=E;const s=()=>{this.#f(),globalThis.bitsDismissableLayers.delete(this),this.#l.destroy(),e()};A([()=>this.opts.enabled.current,()=>this.opts.ref.current],()=>{if(!(!this.opts.enabled.current||!this.opts.ref.current))return ds(1,()=>{this.opts.ref.current&&(globalThis.bitsDismissableLayers.set(this,this.#e),e(),e=this.#c())}),s})}#p=t=>{t.defaultPrevented||this.opts.ref.current&&O(()=>{!this.opts.ref.current||this.#g(t.target)||t.target&&!this.#o&&this.#r.current?.(t)})};#c(){return st(P(this.#i,"pointerdown",st(this.#v,this.#h),{capture:!0}),P(this.#i,"pointerdown",st(this.#d,this.#l)),P(this.#i,"focusin",this.#p))}#u=t=>{let e=t;e.defaultPrevented&&(e=me(t)),this.#t.current(t)};#l=de(t=>{if(!this.opts.ref.current){this.#a();return}const e=this.opts.isValidEvent.current(t,this.opts.ref.current)||po(t,this.opts.ref.current);if(!this.#s||this.#b()||!e){this.#a();return}let s=t;if(s.defaultPrevented&&(s=me(s)),this.#e.current!=="close"&&this.#e.current!=="defer-otherwise-close"){this.#a();return}t.pointerType==="touch"?(this.#a(),this.#a=P(this.#i,"click",this.#u,{once:!0})):this.#t.current(s)},10);#v=t=>{this.#n[t.type]=!0};#d=t=>{this.#n[t.type]=!1};#h=()=>{this.opts.ref.current&&(this.#s=fo(this.opts.ref.current))};#g=t=>this.opts.ref.current?Ze(this.opts.ref.current,t):!1;#f=de(()=>{for(const t in this.#n)this.#n[t]=!1;this.#s=!1},20);#b(){return Object.values(this.#n).some(Boolean)}#w=()=>{this.#o=!0};#y=()=>{this.#o=!1};props={onfocuscapture:this.#w,onblurcapture:this.#y}}function ho(n=[...globalThis.bitsDismissableLayers]){return n.findLast(([t,{current:e}])=>e==="close"||e==="ignore")}function fo(n){const t=[...globalThis.bitsDismissableLayers],e=ho(t);if(e)return e[0].opts.ref.current===n;const[s]=t[0];return s.opts.ref.current===n}function po(n,t){const e=n.target;if(!Ve(e))return!1;const s=!!e.closest(`[${no}]`),o=!!t.closest(`[${so}]`);return"button"in n&&n.button>0&&!s?!1:"button"in n&&n.button===0&&s&&o?!0:s&&o?!1:Hs(e).documentElement.contains(e)&&!Ze(t,e)&&zs(n,t)}function me(n){const t=n.currentTarget,e=n.target;let s;n instanceof PointerEvent?s=new PointerEvent(n.type,n):s=new PointerEvent("pointerdown",n);let o=!1;return new Proxy(s,{get:(i,a)=>a==="currentTarget"?t:a==="target"?e:a==="preventDefault"?()=>{o=!0,typeof i.preventDefault=="function"&&i.preventDefault()}:a==="defaultPrevented"?o:a in i?i[a]:n[a]})}function go(n,t){n.component(e=>{let{interactOutsideBehavior:s="close",onInteractOutside:o=E,onFocusOutside:r=E,id:i,children:a,enabled:c,isValidEvent:u=()=>!1,ref:h}=t;const l=Qt.create({id:m(()=>i),interactOutsideBehavior:m(()=>s),onInteractOutside:m(()=>o),enabled:m(()=>c),onFocusOutside:m(()=>r),isValidEvent:m(()=>u),ref:h});a?.(e,{props:l.props}),e.push("")})}globalThis.bitsEscapeLayers??=new Map;class $t{static create(t){return new $t(t)}opts;domContext;constructor(t){this.opts=t,this.domContext=new Ht(this.opts.ref);let e=E;A(()=>t.enabled.current,s=>(s&&(globalThis.bitsEscapeLayers.set(this,t.escapeKeydownBehavior),e=this.#t()),()=>{e(),globalThis.bitsEscapeLayers.delete(this)}))}#t=()=>P(this.domContext.getDocument(),"keydown",this.#e,{passive:!1});#e=t=>{if(t.key!==Es||!mo(this))return;const e=new KeyboardEvent(t.type,t);t.preventDefault();const s=this.opts.escapeKeydownBehavior.current;s!=="close"&&s!=="defer-otherwise-close"||this.opts.onEscapeKeydown.current(e)}}function mo(n){const t=[...globalThis.bitsEscapeLayers],e=t.findLast(([o,{current:r}])=>r==="close"||r==="ignore");if(e)return e[0]===n;const[s]=t[0];return s===n}function vo(n,t){n.component(e=>{let{escapeKeydownBehavior:s="close",onEscapeKeydown:o=E,children:r,enabled:i,ref:a}=t;$t.create({escapeKeydownBehavior:m(()=>s),onEscapeKeydown:m(()=>o),enabled:m(()=>i),ref:a}),r?.(e),e.push("")})}class te{static instance;#t=Le([]);#e=new WeakMap;#n=new WeakMap;static getInstance(){return this.instance||(this.instance=new te),this.instance}register(t){const e=this.getActive();e&&e!==t&&e.pause();const s=document.activeElement;s&&s!==document.body&&this.#n.set(t,s),this.#t.current=this.#t.current.filter(o=>o!==t),this.#t.current.unshift(t)}unregister(t){this.#t.current=this.#t.current.filter(s=>s!==t);const e=this.getActive();e&&e.resume()}getActive(){return this.#t.current[0]}setFocusMemory(t,e){this.#e.set(t,e)}getFocusMemory(t){return this.#e.get(t)}isActiveScope(t){return this.getActive()===t}setPreFocusMemory(t,e){this.#n.set(t,e)}getPreFocusMemory(t){return this.#n.get(t)}clearPreFocusMemory(t){this.#n.delete(t)}}class ee{#t=!1;#e=null;#n=te.getInstance();#s=[];#o;constructor(t){this.#o=t}get paused(){return this.#t}pause(){this.#t=!0}resume(){this.#t=!1}#i(){for(const t of this.#s)t();this.#s=[]}mount(t){this.#e&&this.unmount(),this.#e=t,this.#n.register(this),this.#p(),this.#r()}unmount(){this.#e&&(this.#i(),this.#a(),this.#n.unregister(this),this.#n.clearPreFocusMemory(this),this.#e=null)}#r(){if(!this.#e)return;const t=new CustomEvent("focusScope.onOpenAutoFocus",{bubbles:!1,cancelable:!0});this.#o.onOpenAutoFocus.current(t),t.defaultPrevented||requestAnimationFrame(()=>{if(!this.#e)return;const e=this.#u();e?(e.focus(),this.#n.setFocusMemory(this,e)):this.#e.focus()})}#a(){const t=new CustomEvent("focusScope.onCloseAutoFocus",{bubbles:!1,cancelable:!0});if(this.#o.onCloseAutoFocus.current?.(t),!t.defaultPrevented){const e=this.#n.getPreFocusMemory(this);if(e&&document.contains(e))try{e.focus()}catch{document.body.focus()}}}#p(){if(!this.#e||!this.#o.trap.current)return;const t=this.#e,e=t.ownerDocument,s=i=>{if(this.#t||!this.#n.isActiveScope(this))return;const a=i.target;if(!a)return;if(t.contains(a))this.#n.setFocusMemory(this,a);else{const u=this.#n.getFocusMemory(this);if(u&&t.contains(u)&&_e(u))i.preventDefault(),u.focus();else{const h=this.#u(),l=this.#l()[0];(h||l||t).focus()}}},o=i=>{if(!this.#o.loop||this.#t||i.key!=="Tab"||!this.#n.isActiveScope(this))return;const a=this.#c();if(a.length===0)return;const c=a[0],u=a[a.length-1];!i.shiftKey&&e.activeElement===u?(i.preventDefault(),c.focus()):i.shiftKey&&e.activeElement===c&&(i.preventDefault(),u.focus())};this.#s.push(P(e,"focusin",s,{capture:!0}),P(t,"keydown",o));const r=new MutationObserver(()=>{const i=this.#n.getFocusMemory(this);if(i&&!t.contains(i)){const a=this.#u(),c=this.#l()[0],u=a||c;u?(u.focus(),this.#n.setFocusMemory(this,u)):t.focus()}});r.observe(t,{childList:!0,subtree:!0}),this.#s.push(()=>r.disconnect())}#c(){return this.#e?Pe(this.#e,{includeContainer:!1,getShadowRoot:!0}):[]}#u(){return this.#c()[0]||null}#l(){return this.#e?Fe(this.#e,{includeContainer:!1,getShadowRoot:!0}):[]}static use(t){let e=null;return A([()=>t.ref.current,()=>t.enabled.current],([s,o])=>{s&&o?(e||(e=new ee(t)),e.mount(s)):e&&(e.unmount(),e=null)}),{get props(){return{tabindex:-1}}}}}function bo(n,t){n.component(e=>{let{enabled:s=!1,trapFocus:o=!1,loop:r=!1,onCloseAutoFocus:i=E,onOpenAutoFocus:a=E,focusScope:c,ref:u}=t;const h=ee.use({enabled:m(()=>s),trap:m(()=>o),loop:r,onCloseAutoFocus:m(()=>i),onOpenAutoFocus:m(()=>a),ref:u});c?.(e,{props:h.props}),e.push("")})}const ve=()=>{};globalThis.bitsTextSelectionLayers??=new Map;class ne{static create(t){return new ne(t)}opts;domContext;#t=E;#e=!1;#n=ve;#s=ve;constructor(t){this.opts=t,this.domContext=new Ht(t.ref);let e=E;A(()=>[this.opts.enabled.current,this.opts.onPointerDown.current,this.opts.onPointerUp.current],([s,o,r])=>(this.#e=s,this.#n=o,this.#s=r,s&&(globalThis.bitsTextSelectionLayers.set(this,this.opts.enabled),e(),e=this.#o()),()=>{this.#e=!1,e(),this.#a(),globalThis.bitsTextSelectionLayers.delete(this)}))}#o(){return st(P(this.domContext.getDocument(),"pointerdown",this.#r),P(this.domContext.getDocument(),"pointerup",De(this.#a,this.#i)))}#i=t=>{this.#s(t)};#r=t=>{const e=this.opts.ref.current,s=t.target;!L(e)||!L(s)||!this.#e||!wo(this)||!vs(e,s)||(this.#n(t),!t.defaultPrevented&&(this.#t=yo(e,this.domContext.getDocument().body)))};#a=()=>{this.#t(),this.#t=E}}const be=n=>n.style.userSelect||n.style.webkitUserSelect;function yo(n,t){const e=be(t),s=be(n);return Ct(t,"none"),Ct(n,"text"),()=>{Ct(t,e),Ct(n,s)}}function Ct(n,t){n.style.userSelect=t,n.style.webkitUserSelect=t}function wo(n){const t=[...globalThis.bitsTextSelectionLayers];if(!t.length)return!1;const e=t.at(-1);return e?e[0]===n:!1}function Co(n,t){n.component(e=>{let{preventOverflowTextSelection:s=!0,onPointerDown:o=E,onPointerUp:r=E,id:i,children:a,enabled:c,ref:u}=t;ne.create({id:m(()=>i),onPointerDown:m(()=>o),onPointerUp:m(()=>r),enabled:m(()=>c&&s),ref:u}),a?.(e),e.push("")})}globalThis.bitsIdCounter??={current:0};function Eo(n="bits"){return globalThis.bitsIdCounter.current++,`${n}-${globalThis.bitsIdCounter.current}`}class So{#t;#e=0;#n;#s;constructor(t){this.#t=t}#o(){this.#e-=1,this.#s&&this.#e<=0&&(this.#s(),this.#n=void 0,this.#s=void 0)}get(...t){return this.#e+=1,this.#n===void 0&&(this.#s=()=>{}),this.#n}}const Tt=new Oe;let ye=null,tt=null,et=!1;const we=m(()=>{for(const n of Tt.values())if(n)return!0;return!1});let Ft=null;const To=new So(()=>{function n(){}function t(){tt!==null&&(window.clearTimeout(tt),tt=null)}function e(o,r){t(),et=!0,Ft=Date.now();const i=Ft,a=()=>{tt=null,Ft===i&&(Mo(Tt)?et=!1:(et=!1,r()))},c=o===null?24:o;tt=window.setTimeout(a,c)}function s(){ye===null&&Tt.size===0&&!et&&(ye=document.body.getAttribute("style"))}return A(()=>we.current,()=>{if(!we.current)return;s(),et=!1;const o=getComputedStyle(document.documentElement),r=getComputedStyle(document.body),i=o.scrollbarGutter?.includes("stable")||r.scrollbarGutter?.includes("stable"),a=window.innerWidth-document.documentElement.clientWidth,u={padding:Number.parseInt(r.paddingRight??"0",10)+a,margin:Number.parseInt(r.marginRight??"0",10)};a>0&&!i&&(document.body.style.paddingRight=`${u.padding}px`,document.body.style.marginRight=`${u.margin}px`,document.body.style.setProperty("--scrollbar-width",`${a}px`)),document.body.style.overflow="hidden",Ns&&P(document,"touchmove",h=>{h.target===document.documentElement&&(h.touches.length>1||h.preventDefault())},{passive:!1}),O(()=>{document.body.style.pointerEvents="none",document.body.style.overflow="hidden"})}),{get lockMap(){return Tt},resetBodyStyle:n,scheduleCleanupIfNoNewLocks:e,cancelPendingCleanup:t,ensureInitialStyleCaptured:s}});class Ao{#t=Eo();#e;#n=()=>null;#s;locked;constructor(t,e=()=>null){this.#e=t,this.#n=e,this.#s=To.get(),this.#s&&(this.#s.cancelPendingCleanup(),this.#s.ensureInitialStyleCaptured(),this.#s.lockMap.set(this.#t,this.#e??!1),this.locked=m(()=>this.#s.lockMap.get(this.#t)??!1,s=>this.#s.lockMap.set(this.#t,s)))}}function Mo(n){for(const[t,e]of n)if(e)return!0;return!1}function Ce(n,t){n.component(e=>{let{preventScroll:s=!0,restoreScrollDelay:o=null}=t;s&&new Ao(s,()=>o)})}function Ee(n,t){n.component(e=>{const s=Gt(e);let{id:o=jt(s),forceMount:r=!1,child:i,children:a,ref:c=null,$$slots:u,$$events:h,...l}=t;const p=Jt.create({id:m(()=>o),ref:m(()=>c,w=>c=w)}),g=b(()=>F(l,p.props));p.shouldRender||r?(e.push(""),i?(e.push(""),i(e,{props:F(g()),...p.snippetProps}),e.push("")):(e.push(""),e.push(``),a?.(e,p.snippetProps),e.push("")),e.push("")):e.push(""),e.push(""),R(t,{ref:c})})}function Se(n,t){n.component(e=>{const s=Gt(e);let{children:o,child:r,id:i=jt(s),ref:a=null,disabled:c=!1,$$slots:u,$$events:h,...l}=t;const p=Yt.create({variant:m(()=>"close"),id:m(()=>i),ref:m(()=>a,w=>a=w),disabled:m(()=>!!c)}),g=b(()=>F(l,p.props));r?(e.push(""),r(e,{props:g()}),e.push("")):(e.push(""),e.push(``),o?.(e),e.push("")),e.push(""),R(t,{ref:a})})}function Te(n,t){n.component(e=>{const s=Gt(e);let{id:o=jt(s),children:r,child:i,ref:a=null,forceMount:c=!1,onCloseAutoFocus:u=E,onOpenAutoFocus:h=E,onEscapeKeydown:l=E,onInteractOutside:p=E,trapFocus:g=!0,preventScroll:w=!0,restoreScrollDelay:C=null,$$slots:S,$$events:gt,...Ot}=t;const T=Xt.create({id:m(()=>o),ref:m(()=>a,Pt=>a=Pt)}),Q=b(()=>F(Ot,T.props));if(T.shouldRender||c){e.push("");{let Pt=function(fn,{props:se}){vo(fn,U([Q(),{enabled:T.root.opts.open.current,ref:T.opts.ref,onEscapeKeydown:mt=>{l(mt),!mt.defaultPrevented&&T.root.handleClose()},children:mt=>{go(mt,U([Q(),{ref:T.opts.ref,enabled:T.root.opts.open.current,onInteractOutside:vt=>{p(vt),!vt.defaultPrevented&&T.root.handleClose()},children:vt=>{Co(vt,U([Q(),{ref:T.opts.ref,enabled:T.root.opts.open.current,children:M=>{i?(M.push(""),T.root.opts.open.current?(M.push(""),Ce(M,{preventScroll:w,restoreScrollDelay:C})):M.push(""),M.push(" "),i(M,{props:F(Q(),se),...T.snippetProps}),M.push("")):(M.push(""),Ce(M,{preventScroll:w}),M.push(` `),r?.(M),M.push("")),M.push("")},$$slots:{default:!0}}]))},$$slots:{default:!0}}]))},$$slots:{default:!0}}]))};bo(e,{ref:T.opts.ref,loop:!0,trapFocus:g,enabled:T.root.opts.open.current,onOpenAutoFocus:h,onCloseAutoFocus:u,focusScope:Pt})}}else e.push("");e.push(""),R(t,{ref:a})})}var xo=(n=>(n.GENERATION="generation",n.READING="reading",n.TOOLS="tools",n.SUMMARY="summary",n))(xo||{}),Io=(n=>(n.SWITCHABLE="switchable",n.READING="reading",n.GENERATION="generation",n))(Io||{}),ko=(n=>(n.STREAMING="streaming",n.RESUMING="resuming",n.LOST="lost",n))(ko||{}),No=(n=>(n.NONE="none",n.AUTO="auto",n))(No||{}),_=(n=>(n.USER="user",n.ASSISTANT="assistant",n.SYSTEM="system",n.TOOL="tool",n))(_||{}),Oo=(n=>(n.ROOT="root",n.TEXT="text",n.THINK="think",n.SYSTEM="system",n))(Oo||{}),Po=(n=>(n.TEXT="text",n.IMAGE_URL="image_url",n.INPUT_AUDIO="input_audio",n.INPUT_VIDEO="input_video",n))(Po||{}),_o=(n=>(n.TIMEOUT="timeout",n.SERVER="server",n))(_o||{}),Fo=(n=>(n.EXPORT="export",n.IMPORT="import",n))(Fo||{}),Lo=(n=>(n.TEXT="text",n.PAGES="pages",n))(Lo||{}),Do=(n=>(n.PROMPT="prompt",n.CWD="cwd",n.MODEL="model",n))(Do||{}),Ro=(n=>(n.FILE="file",n.DIRECTORY="directory",n))(Ro||{}),z=(n=>(n.SESSION="session",n.MESSAGE="message",n))(z||{});function Bo(n,t){let{$$slots:e,$$events:s,...o}=t;En(n,U([{name:"x"},o,{iconNode:[["path",{d:"M18 6 6 18"}],["path",{d:"m6 6 12 12"}]]}]))}const Uo="border border-border/30 focus-within:border-border dark:border-border/20 dark:focus-within:border-border",ti=` + bg-muted/60 dark:bg-muted/75 + ${Uo} + shadow-sm + outline-none + text-foreground +`,Go=` + bg-background + border border-border/30 dark:border-border/20 + shadow-sm backdrop-blur-lg! + rounded-t-lg! +`,ei="max-h-80",ni='[data-slot="input-area"] textarea, [data-slot="input-area"] [contenteditable="true"]',si="h-4 w-4",oi="h-4 w-4 animate-spin",f={conversations:"conversations",messages:"messages"},Ae={conversations:"id, lastModified, currNode, name",messages:"id, convId, type, role, timestamp, parent, children"},Wo={[f.conversations]:Ae.conversations,[f.messages]:Ae.messages},Ko=[80,75],Ho="mermaid",zo="mermaid",Vo="svg-block",jo="svg",Yo="xml",Xo="e.id===t)}function Ut(n,t,e=!1){const s=[],o=new Map;for(const a of n)o.set(a.id,a);let r=o.get(t);if(!r){let a=-1;for(const c of n)c.timestamp>a&&(r=c,a=c.timestamp)}let i=r;for(;i&&((i.type!=="root"||e)&&s.push(i),i.parent!==null);)i=o.get(i.parent);return s.sort((a,c)=>a.role===_.SYSTEM&&c.role!==_.SYSTEM?-1:a.role!==_.SYSTEM&&c.role===_.SYSTEM?1:a.timestamp-c.timestamp),s}function ln(n,t){let e=n.get(t);for(;e&&e.children.length>0;){const s=e.children[e.children.length-1];e=n.get(s)}return e?.id??t}function rr(n,t){const e=new Map(n.map(s=>[s.id,s]));return ln(e,t)}function ir(n,t){const e=new Map;for(const r of n)e.set(r.id,r);const s=[],o=[t];for(;o.length>0;){const r=o.shift(),i=e.get(r);if(i)for(const a of i.children)s.push(a),o.push(a)}return s}function ar(n,t){const e=n.get(t);if(!e)return null;if(e.parent===null)return{currentIndex:0,message:e,siblingIds:[t],totalSiblings:1};const s=n.get(e.parent);if(!s)return{currentIndex:0,message:e,siblingIds:[t],totalSiblings:1};const o=s.children,r=o.map(a=>ln(n,a));return{currentIndex:o.indexOf(t),message:e,siblingIds:r,totalSiblings:o.length}}function ii(n){const t=new Map(n.map(s=>[s.id,s])),e=new Map;for(const s of n){const o=ar(t,s.id);o&&e.set(s.id,o)}return e}function ai(...n){return n.filter(Boolean).join(" ")}const cr=typeof document<"u";let xe=0;class ur{toasts=[];heights=[];#t=t=>{const e=this.toasts.findIndex(s=>s.id===t);return e===-1?null:e};addToast=t=>{cr&&this.toasts.unshift(t)};updateToast=({id:t,data:e,type:s,message:o})=>{const r=this.toasts.findIndex(a=>a.id===t),i=this.toasts[r];this.toasts[r]={...i,...e,id:t,title:o,type:s,updated:!0}};create=t=>{const{message:e,...s}=t,o=typeof t?.id=="number"||t.id&&t.id?.length>0?t.id:xe++,r=t.dismissible!==void 0?t.dismissible:t.dismissable!==void 0?t.dismissable:!0,i=t.type===void 0?"default":t.type;return At(()=>{this.toasts.find(c=>c.id===o)?this.updateToast({id:o,data:t,type:i,message:e,dismissible:r}):this.addToast({...s,id:o,title:e,dismissible:r,type:i})}),o};dismiss=t=>(At(()=>{if(t===void 0){this.toasts=this.toasts.map(s=>({...s,dismiss:!0}));return}const e=this.toasts.findIndex(s=>s.id===t);this.toasts[e]&&(this.toasts[e]={...this.toasts[e],dismiss:!0})}),t);remove=t=>{if(t===void 0){this.toasts=[];return}const e=this.#t(t);if(e!==null)return this.toasts.splice(e,1),t};message=(t,e)=>this.create({...e,type:"default",message:t});error=(t,e)=>this.create({...e,type:"error",message:t});success=(t,e)=>this.create({...e,type:"success",message:t});info=(t,e)=>this.create({...e,type:"info",message:t});warning=(t,e)=>this.create({...e,type:"warning",message:t});loading=(t,e)=>this.create({...e,type:"loading",message:t});promise=(t,e)=>{if(!e)return;let s;e.loading!==void 0&&(s=this.create({...e,promise:t,type:"loading",message:typeof e.loading=="string"?e.loading:e.loading()}));const o=t instanceof Promise?t:t();let r=s!==void 0;return o.then(i=>{if(typeof i=="object"&&i&&"ok"in i&&typeof i.ok=="boolean"&&!i.ok){r=!1;const a=lr(i);this.create({id:s,type:"error",message:a})}else if(e.success!==void 0){r=!1;const a=typeof e.success=="function"?e.success(i):e.success;this.create({id:s,type:"success",message:a})}}).catch(i=>{if(e.error!==void 0){r=!1;const a=typeof e.error=="function"?e.error(i):e.error;this.create({id:s,type:"error",message:a})}}).finally(()=>{r&&(this.dismiss(s),s=void 0),e.finally?.()}),s};custom=(t,e)=>{const s=e?.id||xe++;return this.create({component:t,id:s,...e}),s};removeHeight=t=>{this.heights=this.heights.filter(e=>e.toastId!==t)};setHeight=t=>{const e=this.#t(t.toastId);if(e===null){this.heights.push(t);return}this.heights[e]=t};reset=()=>{this.toasts=[],this.heights=[]}}function lr(n){return n&&typeof n=="object"&&"status"in n?`HTTP error! Status: ${n.status}`:`Error! ${n}`}const x=new ur;function dr(n,t){return x.create({message:n,...t})}class ci{#t=b(()=>x.toasts.filter(t=>!t.dismiss));get toasts(){return this.#t()}}const hr=dr,k=Object.assign(hr,{success:x.success,info:x.info,warning:x.warning,error:x.error,custom:x.custom,message:x.message,promise:x.promise,dismiss:x.dismiss,loading:x.loading,getActiveToasts:()=>x.toasts.filter(n=>!n.dismiss)});function ui(n,t=150){return n.length>t?n.slice(0,t)+"...":n}function fr(n,t=!1){if(t){const e=n.split(St).find(s=>s.trim().length>0);return e?e.trim():n.trim()}return n.trim()}class pr extends kn{[f.conversations];[f.messages];constructor(){super(Sn),this.version(1).stores(Wo)}}const d=new pr;class y{static async createConversation(t,e){const s={currNode:"",id:K(),lastModified:Date.now(),name:t,...e};return await d[f.conversations].add(s),s}static async createMessageBranch(t,e){return await d.transaction("rw",[d[f.conversations],d[f.messages]],async()=>{if(e!==null&&!await d[f.messages].get(e))throw new Error(`Parent message ${e} not found`);const s={...t,children:[],id:K(),parent:e,toolCalls:t.toolCalls??""};if(await d[f.messages].add(s),e!==null){const o=await d[f.messages].get(e);o&&await d[f.messages].update(e,{children:[...o.children,s.id]})}return await this.updateConversation(t.convId,{currNode:s.id}),s})}static async createRootMessage(t){const e={children:[],content:"",convId:t,id:K(),parent:null,role:_.SYSTEM,timestamp:Date.now(),toolCalls:"",type:"root"};return await d[f.messages].add(e),e.id}static async createSystemMessage(t,e,s){const o=e.trim();if(!o)throw new Error("Cannot create system message with empty content");return await d.transaction("rw",d[f.messages],async()=>{const r=await d[f.messages].get(s);if(!r)throw new Error(`Parent message ${s} not found`);const i={children:[],content:o,convId:t,id:K(),parent:s,role:_.SYSTEM,timestamp:Date.now(),type:_.SYSTEM};return await d[f.messages].add(i),await d[f.messages].update(s,{children:[...r.children,i.id]}),i})}static async deleteConversation(t,e){await d.transaction("rw",[d[f.conversations],d[f.messages]],async()=>{if(e?.deleteWithForks){const s=[],o=[t];for(;o.length>0;){const r=o.pop(),i=await d[f.conversations].filter(a=>a.forkedFromConversationId===r).toArray();for(const a of i)s.push(a.id),o.push(a.id)}for(const r of s)await d[f.conversations].delete(r),await d[f.messages].where("convId").equals(r).delete()}else await this.reparentDirectChildren(t);await d[f.conversations].delete(t),await d[f.messages].where("convId").equals(t).delete()})}static async reparentDirectChildren(t,e=new Set,s){const o=s?.get(t)??await d[f.conversations].get(t);if(!o)return;let r=o.forkedFromConversationId;const i=new Set([t]);for(;r&&e.has(r);){if(i.has(r)){r=void 0;break}i.add(r);const u=s?.get(r)??await d[f.conversations].get(r);if(!u){r=void 0;break}r=u.forkedFromConversationId}const a=await d[f.conversations].filter(u=>u.forkedFromConversationId===t).toArray(),c=[];for(const u of a)e.has(u.id)||c.push({...u,forkedFromConversationId:r});c.length!==0&&await d[f.conversations].bulkPut(c)}static async bulkDeleteConversations(t){const e=t.filter(o=>typeof o=="string"&&o.length>0);if(e.length===0)return;const s=new Set(e);await d.transaction("rw",[d[f.conversations],d[f.messages]],async()=>{const o=new Map;let r=[...e];const i=new Set(r);for(;r.length>0;){const a=await d[f.conversations].bulkGet(r);r=[];for(let c=0;c{const e=await d[f.messages].get(t);if(e){if(e.parent){const s=await d[f.messages].get(e.parent);s&&(s.children=s.children.filter(o=>o!==t),await d[f.messages].put(s))}await d[f.messages].delete(t)}})}static async deleteMessageCascading(t,e){return await d.transaction("rw",d[f.messages],async()=>{const s=await d[f.messages].where("convId").equals(t).toArray(),o=ir(s,e),r=[e,...o],i=await d[f.messages].get(e);if(i&&i.parent){const a=await d[f.messages].get(i.parent);a&&(a.children=a.children.filter(c=>c!==e),await d[f.messages].put(a))}return await d[f.messages].bulkDelete(r),r})}static async getAllConversations(){return await d[f.conversations].orderBy("lastModified").reverse().toArray()}static async getConversation(t){return await d[f.conversations].get(t)}static async getConversationMessages(t){return await d[f.messages].where("convId").equals(t).sortBy("timestamp")}static async getConversationsWithMessages(t){const e=new Map,s=t.filter(a=>typeof a=="string"&&a.length>0);if(s.length===0)return e;const[o,r]=await Promise.all([d[f.conversations].bulkGet(s),d[f.messages].where("convId").anyOf(s).toArray()]),i=new Map;for(const a of r){const c=i.get(a.convId);c?c.push(a):i.set(a.convId,[a])}for(let a=0;ah.timestamp-l.timestamp);e.set(c.id,{conv:c,messages:u})}return e}static async updateConversation(t,e){await d[f.conversations].update(t,e)}static async toggleConversationPin(t){const e=await d[f.conversations].get(t);if(!e)throw new Error(`Conversation ${t} not found`);const s=!e.pinned;return await this.updateConversation(t,{pinned:s}),s}static async bulkToggleConversationPins(t){const e=t.filter(o=>typeof o=="string"&&o.length>0),s=new Map;return e.length===0||await d.transaction("rw",d[f.conversations],async()=>{const o=await d[f.conversations].bulkGet(e),r=[];for(let i=0;i{for(const o of t){const{conv:r,messages:i}=o;if(await d[f.conversations].get(r.id)){s.push(r);continue}await d[f.conversations].add(r);for(const c of i)await d[f.messages].put(c);e.push(r)}return{imported:e,skipped:s}})}static async forkConversation(t,e,s){return await d.transaction("rw",[d[f.conversations],d[f.messages]],async()=>{const o=await d[f.conversations].get(t);if(!o)throw new Error(`Source conversation ${t} not found`);const r=await d[f.messages].where("convId").equals(t).toArray(),i=Ut(r,e,!0);if(i.length===0)throw new Error(`Could not resolve message path to ${e}`);const a=new Map;for(const p of i)a.set(p.id,K());const c=K(),u=i.map(p=>{const g=a.get(p.id),w=p.parent?a.get(p.parent)??null:null,C=p.children.filter(S=>a.has(S)).map(S=>a.get(S));return{...p,children:C,convId:c,extra:s.includeAttachments?p.extra:void 0,id:g,parent:w}}),l={currNode:u[u.length-1].id,cwd:o.cwd,forkedFromConversationId:t,id:c,lastModified:Date.now(),mcpServerOverrides:o.mcpServerOverrides?o.mcpServerOverrides.map(p=>({enabled:p.enabled,serverId:p.serverId})):void 0,name:s.name};await d[f.conversations].add(l);for(const p of u)await d[f.messages].add(p);return l})}}class Ie{static chat(t){return`${V.CHAT}/${t}`}static settings(t){return`${V.SETTINGS}/${t}`}}class xt{conversations=[];activeConversation=null;activeMessages=[];isInitialized=!1;pendingReasoningEffort=xt.loadReasoningEffortDefault();pendingCwd=null;static loadReasoningEffortDefault(){if(typeof globalThis.localStorage>"u")return bt.DEFAULT;try{return localStorage.getItem(ie)||bt.DEFAULT}catch{return bt.DEFAULT}}saveReasoningEffortDefaults(){typeof globalThis.localStorage>"u"||localStorage.setItem(ie,this.pendingReasoningEffort)}messageUpdateCallback=null;initPromise=null;init(){return Promise.resolve()}async initialize(){return this.init()}registerMessageUpdateCallback(t){this.messageUpdateCallback=t}addMessageToActive(t){this.activeMessages.push(t)}updateMessageAtIndex(t,e){const s=t===-1?void 0:this.activeMessages[t];if(!s)return;const o=s;for(const[r,i]of Object.entries(e))o[r]!==i&&(o[r]=i)}findMessageIndex(t){return this.activeMessages.findIndex(e=>e.id===t)}sliceActiveMessages(t){this.activeMessages=this.activeMessages.slice(0,t)}removeMessageAtIndex(t){if(t!==-1)return this.activeMessages.splice(t,1)[0]}async loadConversations(){const t=await y.getAllConversations();this.conversations=t}async createConversation(t){const e=t||`Chat ${new Date().toLocaleString()}`,s=await y.createConversation(e,{cwd:this.pendingCwd??void 0,reasoningEffort:this.pendingReasoningEffort});return this.pendingCwd=null,this.conversations=[s,...this.conversations],this.activeConversation=s,this.activeMessages=[],await H(Ie.chat(s.id)),s.id}async loadConversation(t){try{const e=await y.getConversation(t);if(!e)return!1;if(this.pendingCwd=null,this.activeConversation=e,e.currNode){const s=await y.getConversationMessages(t),o=Ut(s,e.currNode,!1);this.activeMessages=o}else{const s=await y.getConversationMessages(t);this.activeMessages=s}return!0}catch(e){return console.error("Failed to load conversation:",e),!1}}clearActiveConversation(){this.activeConversation=null,this.activeMessages=[],this.pendingReasoningEffort=xt.loadReasoningEffortDefault(),this.pendingCwd=null}async deleteConversation(t,e){try{if(await y.deleteConversation(t,e),e?.deleteWithForks){const s=new j([t]),o=[t];for(;o.length>0;){const r=o.pop();for(const i of this.conversations)i.forkedFromConversationId===r&&!s.has(i.id)&&(s.add(i.id),o.push(i.id))}this.conversations=this.conversations.filter(r=>!s.has(r.id)),this.activeConversation&&s.has(this.activeConversation.id)&&(this.clearActiveConversation(),await H(V.NEW_CHAT))}else{const o=this.conversations.find(r=>r.id===t)?.forkedFromConversationId;this.conversations=this.conversations.filter(r=>r.id!==t).map(r=>r.forkedFromConversationId===t?{...r,forkedFromConversationId:o}:r),this.activeConversation?.id===t&&(this.clearActiveConversation(),await H(V.NEW_CHAT))}}catch(s){console.error("Failed to delete conversation:",s)}}async deleteAll(){try{const t=await y.getAllConversations();await y.bulkDeleteConversations(t.map(e=>e.id)),this.clearActiveConversation(),this.conversations=[],k.success("All conversations deleted"),await H(V.NEW_CHAT)}catch(t){console.error("Failed to delete all conversations:",t),k.error("Failed to delete conversations")}}async bulkDeleteConversations(t){if(t.length!==0)try{const e=new j(t),s=[...t];for(;s.length>0;){const r=s.pop();for(const i of this.conversations)i.forkedFromConversationId===r&&!e.has(i.id)&&(e.add(i.id),s.push(i.id))}const o=this.activeConversation!==null&&e.has(this.activeConversation.id);await y.bulkDeleteConversations([...e]),this.conversations=this.conversations.filter(r=>!e.has(r.id)),o&&(this.clearActiveConversation(),await H(V.NEW_CHAT)),k.success(e.size===1?"Conversation deleted":`${e.size} conversations deleted`)}catch(e){console.error("Failed to bulk delete conversations:",e),k.error("Failed to delete conversations")}}async bulkToggleConversationPin(t){if(t.length!==0)try{const e=await y.bulkToggleConversationPins(t),s=this.activeConversation?.id;s&&e.has(s)&&(this.activeConversation={...this.activeConversation,pinned:e.get(s)});for(let o=0;or.timestamp>o.timestamp?r:o).id,s=Ut(t,e,!1);this.activeMessages=s}async getConversationMessages(t){return await y.getConversationMessages(t)}async updateConversationName(t,e){try{await y.updateConversation(t,{name:e});const s=this.conversations.findIndex(o=>o.id===t);s!==-1&&(this.conversations[s].name=e),this.activeConversation?.id===t&&(this.activeConversation={...this.activeConversation,name:e})}catch(s){console.error("Failed to update conversation name:",s)}}async toggleConversationPin(t){try{const e=await y.toggleConversationPin(t),s=this.conversations.findIndex(o=>o.id===t);return s!==-1&&(this.conversations[s].pinned=e),this.activeConversation?.id===t&&(this.activeConversation={...this.activeConversation,pinned:e}),e}catch(e){return console.error("Failed to toggle conversation pin:",e),!1}}updateConversationTimestamp(t){const e=t??this.activeConversation?.id;if(!e)return;const s=Date.now(),o=this.conversations.findIndex(r=>r.id===e);if(o!==-1){this.conversations[o].lastModified=s;const r=this.conversations.splice(o,1)[0];this.conversations=[r,...this.conversations]}this.activeConversation?.id===e&&(this.activeConversation={...this.activeConversation,lastModified:s}),y.updateConversation(e,{lastModified:s}).catch(r=>console.error("Failed to update conversation timestamp:",r))}async updateCurrentNode(t){this.activeConversation&&(await y.updateCurrentNode(this.activeConversation.id,t),this.activeConversation={...this.activeConversation,currNode:t})}async navigateToSibling(t){if(!this.activeConversation)return;const e=await y.getConversationMessages(this.activeConversation.id),s=e.find(i=>i.type==="root"&&i.parent===null),o=this.activeMessages.find(i=>i.role===_.USER&&i.parent===s?.id),r=rr(e,t);if(await y.updateCurrentNode(this.activeConversation.id,r),this.activeConversation={...this.activeConversation,currNode:r},await this.refreshActiveMessages(),s&&this.activeMessages.length>0){const i=this.activeMessages.find(a=>a.role===_.USER&&a.parent===s.id);i&&i.content.trim()&&(!o||i.id!==o.id||i.content.trim()!==o.content.trim())&&await this.updateConversationName(this.activeConversation.id,fr(i.content,!!Tn().titleGenerationUseFirstLine))}}#t(t){const e=_t.getServers().find(s=>s.id===t);if(e)return{enabled:e.enabled,serverId:t}}getMcpServerOverride(t){const e=this.activeConversation?.mcpServerOverrides?.find(s=>s.serverId===t);return e||this.#t(t)}getAllMcpServerOverrides(){const t=this.activeConversation?.mcpServerOverrides;return _t.getServers().map(e=>({enabled:t?.find(o=>o.serverId===e.id)?.enabled??e.enabled,serverId:e.id}))}isMcpServerEnabledForChat(t){return this.getMcpServerOverride(t)?.enabled??!1}async setMcpServerOverride(t,e){if(!this.activeConversation){e!==void 0&&_t.updateServer(t,{enabled:e});return}const s=(this.activeConversation.mcpServerOverrides||[]).map(i=>({enabled:i.enabled,serverId:i.serverId}));let o;if(e===void 0)o=s.filter(i=>i.serverId!==t);else{const i=s.findIndex(a=>a.serverId===t);i>=0?(o=[...s],o[i]={enabled:e,serverId:t}):o=[...s,{enabled:e,serverId:t}]}await y.updateConversation(this.activeConversation.id,{mcpServerOverrides:o.length>0?o:void 0}),this.activeConversation={...this.activeConversation,mcpServerOverrides:o.length>0?o:void 0};const r=this.conversations.findIndex(i=>i.id===this.activeConversation.id);r!==-1&&(this.conversations[r].mcpServerOverrides=o.length>0?o:void 0)}async toggleMcpServerForChat(t){const e=this.isMcpServerEnabledForChat(t);await this.setMcpServerOverride(t,!e)}async removeMcpServerOverride(t){await this.setMcpServerOverride(t,void 0)}getReasoningEffort(){if(this.activeConversation){if(this.activeConversation.reasoningEffort!==void 0)return this.activeConversation.reasoningEffort;if(this.activeConversation.thinkingEnabled===!1)return bt.OFF}return this.pendingReasoningEffort}async setReasoningEffort(t){if(!this.activeConversation){this.pendingReasoningEffort=t,this.saveReasoningEffortDefaults();return}this.activeConversation={...this.activeConversation,reasoningEffort:t},await y.updateConversation(this.activeConversation.id,{reasoningEffort:t});const e=this.conversations.findIndex(s=>s.id===this.activeConversation.id);e!==-1&&(this.conversations[e].reasoningEffort=t)}async setCwd(t){const e=t?.trim()||void 0;if(!this.activeConversation){this.pendingCwd=e??null;return}this.activeConversation={...this.activeConversation,cwd:e},await y.updateConversation(this.activeConversation.id,{cwd:e});const s=this.conversations.findIndex(o=>o.id===this.activeConversation.id);s!==-1&&(this.conversations[s].cwd=e,this.conversations=[...this.conversations]),this.pendingCwd=null}async forkConversation(t,e){if(!this.activeConversation)return null;try{const s=await y.forkConversation(this.activeConversation.id,t,e);return this.conversations=[s,...this.conversations],await H(Ie.chat(s.id)),k.success("Conversation forked"),s.id}catch(s){return console.error("Failed to fork conversation:",s),k.error("Failed to fork conversation"),null}}generateConversationFilename(t,e){const o=(t.name??"").trim().toLowerCase().replace($o,tr).replace(er,"_").substring(0,qo),a=(e?.length?new Date(Math.max(...e.map(u=>u.timestamp))):new Date).toISOString().slice(0,Zo).replace(Me,nr).replaceAll(sr,or),c=t.id?.slice(0,Jo)??"";return`${a}_conv_${c}_${o}${$.JSONL}`}serializeSessionToJsonl(t){const{conv:e,messages:s}=t,o=JSON.stringify({harness:Qo,type:z.SESSION,...e}),r=s.map(i=>{const{toolCalls:a,...c}=i,u=a?{...c,toolCalls:JSON.parse(a)}:c;return JSON.stringify({message:u,type:z.MESSAGE})});return[o,...r].join(St)}parseSessionsJsonl(t){const e=[];let s=null;for(const o of t.split(St)){const r=o.trim();if(!r)continue;const i=JSON.parse(r);if(i.type===z.SESSION){const a={...i};delete a.type,delete a.harness,s={conv:a,messages:[]},e.push(s)}else if(i.type===z.MESSAGE){if(!s)throw new Error("Invalid JSONL: message record before any session record");const a=i.message;a.toolCalls!==void 0&&typeof a.toolCalls!="string"&&(a.toolCalls=JSON.stringify(a.toolCalls)),s.messages.push(a)}}return e}isSessionsJsonl(t){const e=t.trimStart(),s=e.indexOf(St),o=s===-1?e:e.slice(0,s);try{return JSON.parse(o).type===z.SESSION}catch{return!1}}async parseImportFile(t){const e=new Uint8Array(await t.arrayBuffer());if(Ko.every((r,i)=>e[i]===r)){const r=Nn(e),i=[];for(const[a,c]of Object.entries(r))a.toLowerCase().endsWith($.JSONL)&&i.push(...this.parseSessionsJsonl(ce(c)));return i}const s=ce(e);if(this.isSessionsJsonl(s))return this.parseSessionsJsonl(s);const o=JSON.parse(s);if(Array.isArray(o))return o;if(o&&typeof o=="object"&&"conv"in o&&"messages"in o)return[o];throw new Error("Invalid file format: expected array of conversations or single conversation object")}downloadConversationFile(t,e){const{conv:s,messages:o}=t;if(!s){console.error("Invalid data: missing conversation");return}const r=e??this.generateConversationFilename(s,o),i=this.serializeSessionToJsonl(t),a=new Blob([i],{type:An.JSONL});this.triggerDownload(a,r)}downloadConversationsArchive(t){if(t.length===0){console.error("Invalid data: no conversations to export");return}const e=new j,s={};for(const a of t){const c=this.generateConversationFilename(a.conv,a.messages);let u=c,h=1;for(;e.has(u);)u=c.replace(new RegExp(`${$.JSONL}$`),`_${h++}${$.JSONL}`);e.add(u),s[u]=On(this.serializeSessionToJsonl(a))}const o=`${new Date().toISOString().split(Me)[0]}_conversations${$.ZIP}`,r=Pn(s),i=new Blob([r],{type:Mn.ZIP});this.triggerDownload(i,o)}triggerDownload(t,e){const s=URL.createObjectURL(t),o=document.createElement("a");o.href=s,o.download=e,document.body.appendChild(o),o.click(),document.body.removeChild(o),URL.revokeObjectURL(s)}async downloadConversation(t){const e=this.activeConversation?.id===t?this.activeConversation:await y.getConversation(t);if(!e)return;const s=await y.getConversationMessages(t);this.downloadConversationFile({conv:e,messages:s})}async importConversationsData(t){const e=await y.importConversations(t);return await this.loadConversations(),e}}const pt=new xt,li=()=>pt.conversations,di=()=>pt.activeConversation,hi=()=>pt.activeMessages,fi=()=>pt.pendingCwd,ke=(n,t)=>n.pinned&&!t.pinned?-1:!n.pinned&&t.pinned?1:t.lastModified-n.lastModified;function pi(n){const t=new Oe,e=new j;for(const a of n)if(a.forkedFromConversationId){e.add(a.id);const c=t.get(a.forkedFromConversationId)||[];c.push(a),t.set(a.forkedFromConversationId,c)}const s=[],o=new j;function r(a,c){o.add(a.id),s.push({conversation:a,depth:c});const u=t.get(a.id);if(u){u.sort(ke);for(const h of u)r(h,c+1)}}const i=n.filter(a=>!e.has(a.id)).sort(ke);for(const a of i)r(a,0);for(const a of n)o.has(a.id)||r(a,1);return s}const gr=ct({base:"relative grid w-full grid-cols-[0_1fr] items-start gap-y-0.5 rounded-lg border px-4 py-3 text-sm has-[>svg]:grid-cols-[calc(var(--spacing)*4)_1fr] has-[>svg]:gap-x-3 [&>svg]:size-4 [&>svg]:translate-y-0.5 [&>svg]:text-current",defaultVariants:{variant:"default"},variants:{variant:{default:"bg-card text-card-foreground",destructive:"text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current"}}});function gi(n,t){n.component(e=>{let{children:s,class:o,ref:r=null,variant:i="default",$$slots:a,$$events:c,...u}=t;e.push(``),s?.(e),e.push(""),R(t,{ref:r})})}const nt=[{id:"coder",name:"Code Architect",title:"Full-Stack Software Engineer & Architect",description:"Autonomously explores codebases, creates files, refactors with surgical edits, runs tests, and debugs.",icon:"Code",badge:"DEV EXPERT",color:"var(--flame, #ff5400)",temperature:.2,maxTurns:25,tools:[v.READ_FILE,v.WRITE_FILE,v.EDIT_FILE,v.FILE_GLOB_SEARCH,v.GREP_SEARCH,v.EXEC_SHELL_COMMAND,v.RUN_JAVASCRIPT],systemPrompt:"You are an expert autonomous Full-Stack Software Engineer and Code Architect. Use your tools (read_file, write_file, edit_file, file_glob_search, grep_search, exec_shell_command) proactively to inspect, implement, refactor, and test code. Always explore relevant files before editing and verify changes."},{id:"devops",name:"DevOps & SysOps",title:"Linux System & Automation Specialist",description:"Executes shell commands, configures build pipelines, inspects system metrics, and automates workflows.",icon:"Terminal",badge:"AUTOMATION",color:"var(--ember, #ff2a00)",temperature:.1,maxTurns:20,tools:[v.EXEC_SHELL_COMMAND,v.GET_INFO,v.GET_DATETIME,v.READ_FILE,v.WRITE_FILE],systemPrompt:"You are a DevOps and Linux System Automation specialist. You have full access to execute shell commands and inspect the runtime environment. Always verify command output, provide concise operational summaries, and automate tasks efficiently."},{id:"researcher",name:"Deep Research",title:"Web & Repository Explorer",description:"Gathers live technical documentation, crawls repositories, fetches live data via MCP, and synthesizes reports.",icon:"Globe",badge:"RESEARCH",color:"var(--eye, #00e5ff)",temperature:.4,maxTurns:15,tools:[v.READ_FILE,v.FILE_GLOB_SEARCH,v.GREP_SEARCH,v.GET_INFO,v.GET_DATETIME],systemPrompt:"You are a Deep Research and Technical Discovery Agent. Your goal is to gather complete, up-to-date facts, explore repositories, examine documentation, and produce clear, comprehensive, and citation-backed synthesis."},{id:"math-data",name:"Math & Data Analyst",title:"Symbolic Computing & Data Scientist",description:"Solves complex symbolic mathematics, calculates exact formulas with Nerdamer, and parses tabular data.",icon:"Calculator",badge:"ANALYTICS",color:"var(--gold, #ffb703)",temperature:.1,maxTurns:15,tools:[v.RUN_JAVASCRIPT,v.READ_FILE,v.WRITE_FILE,v.GET_DATETIME],systemPrompt:"You are a Mathematical and Data Science Computing Agent. Use the JavaScript sandbox and Nerdamer symbolic engine to compute exact algebraic calculations, matrix operations, and parse data without hallucinations."},{id:"general",name:"Universal Agent",title:"All-Round Autonomous AI",description:"General-purpose agent with all tools unlocked for multi-step reasoning and full system assistance.",icon:"Sparkles",badge:"ALL TOOLS",color:"var(--flame, #ff5400)",temperature:.5,maxTurns:20,tools:[v.READ_FILE,v.WRITE_FILE,v.EDIT_FILE,v.FILE_GLOB_SEARCH,v.GREP_SEARCH,v.EXEC_SHELL_COMMAND,v.GET_DATETIME,v.GET_INFO,v.RUN_JAVASCRIPT],systemPrompt:"You are a versatile, highly capable Autonomous AI Agent with full access to filesystem, shell, and computing tools. Think step-by-step and use tools to achieve the user goal."}];class mr{_activeAgentId=nt[0].id;_autoApprove=!0;constructor(){}get profiles(){return nt}get activeAgentId(){return this._activeAgentId}get activeAgent(){return nt.find(t=>t.id===this._activeAgentId)??nt[0]}get autoApprove(){return this._autoApprove}setActiveAgent(t){if(nt.some(e=>e.id===t)){this._activeAgentId=t;const e=this.activeAgent;ae("agenticMaxTurns",e.maxTurns),ae("temperature",e.temperature)}}setAutoApprove(t){this._autoApprove=t}async launchChatWithAgent(t){this.setActiveAgent(t.id);for(const e of t.tools)xn.setToolEnabled(e,!0);await pt.createConversation(t.name)}}const mi=new mr;class vr{_tools=new j;constructor(){try{const t=localStorage.getItem(yt);if(t)for(const e of JSON.parse(t))typeof e=="string"&&this._tools.add(e)}catch(t){console.error(`Failed to load permissions from localStorage ("${yt}"):`,t)}}get tools(){return this._tools}hasTool(t){return this._tools.has(t)}allowTool(t){this._tools.add(t),this._persist()}allowTools(t){for(const e of t)this._tools.add(e);this._persist()}revokeTool(t){this._tools.delete(t),this._persist()}_persist(){try{localStorage.setItem(yt,JSON.stringify([...this._tools]))}catch(t){console.error(`Failed to persist to localStorage ("${yt}"):`,t)}}}const vi=new vr;function br(n,t){n.component(e=>{let{class:s,ref:o=null,$$slots:r,$$events:i,...a}=t,c=!0,u;function h(l){Ee?(l.push(""),Ee(l,U([{"data-slot":"sheet-overlay",class:G("fixed inset-0 z-50 bg-black/50 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:fill-mode-forwards data-[state=open]:animate-in data-[state=open]:fade-in-0",s)},a,{get ref(){return o},set ref(p){o=p,c=!1}}])),l.push("")):(l.push(""),l.push(""))}do c=!0,u=e.copy(),h(u);while(!c);e.subsume(u),R(t,{ref:o})})}const yr=ct({base:`border-border/30 dark:border-border/20 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fill-mode-forwards fixed z-50 flex flex-col gap-4 shadow-sm transition ease-in-out data-[state=closed]:duration-300 data-[state=open]:duration-500 ${Go}`,defaultVariants:{side:"right"},variants:{side:{bottom:"data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom inset-x-0 bottom-0 h-auto border-t",left:"data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left inset-y-0 left-0 h-full w-3/4 border-r sm:max-w-sm",right:"data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right inset-y-0 right-0 h-full w-3/4 border-l sm:max-w-sm",top:"data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top inset-x-0 top-0 h-auto border-b"}}});function bi(n,t){n.component(e=>{let{children:s,class:o,portalProps:r,ref:i=null,side:a="right",$$slots:c,$$events:u,...h}=t,l=!0,p;function g(w){le?(w.push(""),le(w,U([r,{children:C=>{br(C,{}),C.push(" "),Te?(C.push(""),Te(C,U([{"data-slot":"sheet-content",class:G(yr({side:a}),o)},h,{get ref(){return i},set ref(S){i=S,l=!1},children:S=>{s?.(S),S.push(" "),Se?(S.push(""),Se(S,{class:"absolute top-4 right-4 rounded-xs opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:outline-hidden disabled:pointer-events-none",children:gt=>{Bo(gt,{class:"size-4"}),gt.push(' Close')},$$slots:{default:!0}}),S.push("")):(S.push(""),S.push(""))},$$slots:{default:!0}}])),C.push("")):(C.push(""),C.push(""))},$$slots:{default:!0}}])),w.push("")):(w.push(""),w.push(""))}do l=!0,p=e.copy(),g(p);while(!l);e.subsume(p),R(t,{ref:i})})}const wr=ct({base:"focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex w-fit shrink-0 items-center justify-center gap-1 overflow-hidden whitespace-nowrap rounded-md border px-2 py-0.5 text-xs font-medium transition-[color,box-shadow] focus-visible:ring-[3px] [&>svg]:pointer-events-none [&>svg]:size-3",defaultVariants:{variant:"default"},variants:{variant:{default:"bg-primary text-primary-foreground [a&]:hover:bg-primary/90 border-transparent",destructive:"bg-destructive [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/70 border-transparent text-white",outline:"text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground",secondary:"bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90 border-transparent",tertiary:"bg-foreground/15 dark:bg-foreground/10 text-foreground [a&]:hover:bg-foreground/25 border-transparent"}}});function yi(n,t){n.component(e=>{let{children:s,class:o,href:r,ref:i=null,variant:a="default",$$slots:c,$$events:u,...h}=t;yn(e,r?"a":"span",()=>{e.push(`${B({"data-slot":"badge",href:r,class:it(G(wr({variant:a}),o,"backdrop-blur-sm")),...h})}`)},()=>{s?.(e),e.push("")}),R(t,{ref:i})})}function dn(n){return n.type==="text"?n.value:n.type==="element"?(n.children??[]).map(dn).join(""):""}function hn(n,t,e){const s=(Array.isArray(n)?n:[n]).map(o=>`language-${o}`);return()=>o=>{_n(o,"element",(r,i,a)=>{if(r.tagName!=="pre"||!a||i===void 0)return;const c=r.children.find(g=>g.type==="element"&&g.tagName==="code");if(!c)return;const u=c.properties?.className;if(!Array.isArray(u)||!u.some(g=>typeof g=="string"&&s.includes(g)))return;const l=c.children.map(dn).join("").trim();if(!l||e&&!e(l))return;const p={children:[{type:"text",value:l}],data:{sourceCode:c},properties:{className:[t]},tagName:"pre",type:"element"};a.children[i]=p})}}hn(zo,Ho);hn([jo,Yo],Vo,n=>n.startsWith(Xo));const Cr=ct({base:"mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0",defaultVariants:{variant:"default"},variants:{variant:{default:"bg-transparent",icon:"bg-muted text-foreground flex size-8 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-4"}}});function wi(n,t){n.component(e=>{let{children:s,class:o,ref:r=null,variant:i="default",$$slots:a,$$events:c,...u}=t;e.push(``),s?.(e),e.push(""),R(t,{ref:r})})}export{ei as $,k as A,ui as B,dt as C,Ht as D,Nt as E,Ro as F,Ur as G,G as H,si as I,Lo as J,gi as K,hi as L,$r as M,_ as N,ti as O,Rt as P,Po as Q,pt as R,Yr as S,di as T,fi as U,le as V,ue as W,Bo as X,bi as Y,H as Z,yi as _,rn as a,vo as a$,ii as a0,y as a1,oi as a2,xo as a3,Io as a4,_o as a5,Br as a6,ko as a7,Ee as a8,Te as a9,Le as aA,to as aB,$e as aC,O as aD,eo as aE,Mt as aF,at as aG,As as aH,Ts as aI,He as aJ,Ss as aK,Ke as aL,Jr as aM,qr as aN,Zr as aO,Qr as aP,Ns as aQ,Gr as aR,_s as aS,Fo as aT,Fs as aU,je as aV,qe as aW,Xe as aX,Ye as aY,Xt as aZ,bo as a_,Se as aa,ni as ab,ai as ac,x as ad,ci as ae,pi as af,li as ag,mi as ah,wi as ai,Rn as aj,Uo as ak,X as al,Kr as am,Hr as an,Wr as ao,Ie as ap,No as aq,vi as ar,Oo as as,ri as at,fr as au,Ut as av,ir as aw,rr as ax,Eo as ay,q as az,m as b,go as b0,Co as b1,Ce as b2,Je as b3,ss as b4,as as b5,wt as b6,jr as b7,zn as b8,bs as b9,jt as c,cn as d,sn as e,en as f,an as g,I as h,L as i,zr as j,Z as k,kt as l,F as m,E as n,zt as o,ot as p,Vt as q,We as r,nn as s,Zt as t,un as u,Vr as v,A as w,Xr as x,ds as y,Do as z}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationSearchResults.js b/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationSearchResults.js new file mode 100644 index 0000000000000000000000000000000000000000..0ba7da8bc0850661210abb10eb7b73a6c4f8277b --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/SidebarNavigationSearchResults.js @@ -0,0 +1 @@ +import{h as _,k,i as L,j as y,c as F,d as c,g as j,l as G}from"./root.js";import{ap as Q,I as H,af as O}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";import{R as d,T as g,a as v}from"./index3.js";import"./uuid.js";import{Q as P,G as q,L as K,S as U,T as z}from"./chat.svelte.js";import"./url.js";import"@sveltejs/kit/internal/server";import"style-to-object";import"clsx";import"@sveltejs/kit";import"@modelcontextprotocol/sdk/client";import"@modelcontextprotocol/sdk/client/sse.js";import"@modelcontextprotocol/sdk/client/streamableHttp.js";import"@modelcontextprotocol/sdk/client/websocket.js";import"@sveltejs/kit/internal";import"./utils2.js";import"./exports.js";import"dexie";import{a as B}from"./checkbox.js";import{T as J}from"./TruncatedText.js";import"pdfjs-dist";import"dompurify";function V(x,S){x.component(o=>{let{conversation:l,depth:n=0,isActive:m=!1,isSelected:e=!1,isSelectionMode:f=!1,onDelete:T,onEdit:C,onEnterSelectionMode:D,onRowMouseDown:I,onSelect:M,onSelectionClick:E,onStop:N,onToggleSelect:R}=S,b=c(()=>z().includes(l.id)),p=!0,u;function w(t){t.push(`
      `),f?(t.push(""),t.push(`")):t.push(""),t.push(" "),n>0?(t.push(""),d?(t.push(""),d(t,{children:s=>{{let i=function(h,{props:a}){h.push(``),q(h,{class:"h-3.5 w-3.5"}),h.push("")};g?(s.push(""),g(s,{child:i,$$slots:{child:!0}}),s.push("")):(s.push(""),s.push(""))}s.push(" "),v?(s.push(""),v(s,{children:i=>{i.push("

      See parent conversation

      ")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push(""))):t.push(""),t.push(" "),b()?(t.push(""),d?(t.push(""),d(t,{children:s=>{g?(s.push(""),g(s,{children:i=>{i.push(``),K(i,{class:"loading-icon h-3.5 w-3.5 animate-spin"}),i.push(" "),U(i,{class:"stop-icon hidden h-3 w-3 fill-current text-destructive"}),i.push("
      ")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push("")),s.push(" "),v?(s.push(""),v(s,{children:i=>{i.push("

      Stop generation

      ")},$$slots:{default:!0}}),s.push("")):(s.push(""),s.push(""))},$$slots:{default:!0}}),t.push("")):(t.push(""),t.push(""))):t.push(""),t.push(" "),J(t,{text:l.name,class:"text-sm font-medium",showTooltip:!1}),t.push(" "),t.push(""),t.push("")}do p=!0,u=o.copy(),w(u);while(!p);o.subsume(u)})}function vt(x,S){x.component(o=>{let{class:l="",currentChatId:n,filteredConversations:m,isSelectionMode:e=!1,onDelete:f,onEdit:T,onEnterSelectionMode:C,onRowMouseDown:D,onSelect:I,onSelectionClick:M,onStop:E,onToggleSelect:N,searchQuery:R,selectedIds:b=new Set}=S,p=c(()=>O(m));const u=c(()=>R.trim().length>0),w=c(()=>u()&&m.length>0),t=c(()=>u()?"No results found":"Start typing to see results");o.push(``),w()?(o.push(""),o.push('
      Search results
      ')):o.push(""),o.push('
        ');const s=j(p());for(let i=0,h=s.length;i'),V(o,{conversation:{currNode:a.currNode,forkedFromConversationId:a.forkedFromConversationId,id:a.id,lastModified:a.lastModified,name:a.name,pinned:a.pinned},depth:A,isActive:n===a.id,isSelectionMode:e,isSelected:b.has(a.id),onSelect:I,onEdit:T,onDelete:f,onStop:E,onToggleSelect:N,onEnterSelectionMode:C,onSelectionClick:M,onRowMouseDown:D}),o.push("")}o.push(" "),p().length===0?(o.push(""),o.push(`

      • ${G(t())}

        • `)):o.push(""),o.push("
      ")})}export{vt as S,V as a}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/TruncatedText.js b/tools/ui/.svelte-kit/output/server/chunks/TruncatedText.js new file mode 100644 index 0000000000000000000000000000000000000000..28965ac794e31b757f321b1f981e259969d459f7 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/TruncatedText.js @@ -0,0 +1 @@ +import{h as t,e as o,i,l as n,j as d}from"./root.js";import"clsx";function f(e,a){let{class:s="",style:l=""}=a;e.push(``)}function b(e,a){e.component(s=>{let{class:l="",showTooltip:c=!0,text:r}=a;s.push(""),s.push(`${n(r)}`),s.push("")})}export{f as M,b as T}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/_virtual_nerdamer.js b/tools/ui/.svelte-kit/output/server/chunks/_virtual_nerdamer.js new file mode 100644 index 0000000000000000000000000000000000000000..da1c6303ea3062c0b97df061a074c49dc1c3ee6f --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/_virtual_nerdamer.js @@ -0,0 +1 @@ +const e='"use strict";var nerdamer=(()=>{var f0=(r,t)=>()=>{try{return t||r((t={exports:{}}).exports,t),t.exports}catch(e){throw t=0,e}};var qn=f0((zi,H0)=>{"use strict";var kt=(function(r){"use strict";var t=1e7,e=7,o=9007199254740992,g=me(o),E="0123456789abcdefghijklmnopqrstuvwxyz",L=typeof BigInt=="function";function A(m,f,$,w){return typeof m>"u"?A[0]:typeof f<"u"?+f==10&&!$?_(m):Xe(m,f,$,w):_(m)}function k(m,f){this.value=m,this.sign=f,this.isSmall=!1}k.prototype=Object.create(A.prototype);function G(m){this.value=m,this.sign=m<0,this.isSmall=!0}G.prototype=Object.create(A.prototype);function V(m){this.value=m}V.prototype=Object.create(A.prototype);function J(m){return-o0?Math.floor(m):Math.ceil(m)}function Me(m,f){var $=m.length,w=f.length,U=new Array($),B=0,Z=t,Y,ie;for(ie=0;ie=Z?1:0,U[ie]=Y-B*Z;for(;ie<$;)Y=m[ie]+B,B=Y===Z?1:0,U[ie++]=Y-B*Z;return B>0&&U.push(B),U}function a(m,f){return m.length>=f.length?Me(m,f):Me(f,m)}function ue(m,f){var $=m.length,w=new Array($),U=t,B,Z;for(Z=0;Z<$;Z++)B=m[Z]-U+f,f=Math.floor(B/U),w[Z]=B-f*U,f+=1;for(;f>0;)w[Z++]=f%U,f=Math.floor(f/U);return w}k.prototype.add=function(m){var f=_(m);if(this.sign!==f.sign)return this.subtract(f.negate());var $=this.value,w=f.value;return f.isSmall?new k(ue($,Math.abs(w)),this.sign):new k(a($,w),this.sign)},k.prototype.plus=k.prototype.add,G.prototype.add=function(m){var f=_(m),$=this.value;if($<0!==f.sign)return this.subtract(f.negate());var w=f.value;if(f.isSmall){if(J($+w))return new G($+w);w=me(Math.abs(w))}return new k(ue(w,Math.abs($)),$<0)},G.prototype.plus=G.prototype.add,V.prototype.add=function(m){return new V(this.value+_(m).value)},V.prototype.plus=V.prototype.add;function ve(m,f){var $=m.length,w=f.length,U=new Array($),B=0,Z=t,Y,ie;for(Y=0;Y=0?w=ve(m,f):(w=ve(f,m),$=!$),w=Ae(w),typeof w=="number"?($&&(w=-w),new G(w)):new k(w,$)}function ye(m,f,$){var w=m.length,U=new Array(w),B=-f,Z=t,Y,ie;for(Y=0;Y=0)},G.prototype.minus=G.prototype.subtract,V.prototype.subtract=function(m){return new V(this.value-_(m).value)},V.prototype.minus=V.prototype.subtract,k.prototype.negate=function(){return new k(this.value,!this.sign)},G.prototype.negate=function(){var m=this.sign,f=new G(-this.value);return f.sign=!m,f},V.prototype.negate=function(){return new V(-this.value)},k.prototype.abs=function(){return new k(this.value,!1)},G.prototype.abs=function(){return new G(Math.abs(this.value))},V.prototype.abs=function(){return new V(this.value>=0?this.value:-this.value)};function Ie(m,f){var $=m.length,w=f.length,U=$+w,B=Te(U),Z=t,Y,ie,oe,ne,le;for(oe=0;oe<$;++oe){ne=m[oe];for(var ge=0;ge0;)w[Y++]=B%U,B=Math.floor(B/U);return w}function be(m,f){for(var $=[];f-- >0;)$.push(0);return $.concat(m)}function we(m,f){var $=Math.max(m.length,f.length);if($<=30)return Ie(m,f);$=Math.ceil($/2);var w=m.slice($),U=m.slice(0,$),B=f.slice($),Z=f.slice(0,$),Y=we(U,Z),ie=we(w,B),oe=we(a(U,w),a(Z,B)),ne=a(a(Y,be(ve(ve(oe,Y),ie),$)),be(ie,2*$));return $e(ne),ne}function fe(m,f){return-.012*m-.012*f+15e-6*m*f>0}k.prototype.multiply=function(m){var f=_(m),$=this.value,w=f.value,U=this.sign!==f.sign,B;if(f.isSmall){if(w===0)return A[0];if(w===1)return this;if(w===-1)return this.negate();if(B=Math.abs(w),B=0;le--){for(ne=U-1,ie[le+w]!==Z&&(ne=Math.floor((ie[le+w]*U+ie[le+w-1])/Z)),ge=0,ke=0,We=oe.length,Le=0;Lew&&(oe=(oe+1)*Z),Y=Math.ceil(oe/ne);do{if(le=he(f,Y),N(le,B)<=0)break;Y--}while(Y);U.push(Y),B=ve(B,le)}return U.reverse(),[Ae(U),Ae(B)]}function p(m,f){var $=m.length,w=Te($),U=t,B,Z,Y,ie;for(Y=0,B=$-1;B>=0;--B)ie=Y*U+m[B],Z=Ee(ie/f),Y=ie-Z*f,w[B]=Z|0;return[w,Y|0]}function h(m,f){var $,w=_(f);if(L)return[new V(m.value/w.value),new V(m.value%w.value)];var U=m.value,B=w.value,Z;if(B===0)throw new Error("Cannot divide by zero");if(m.isSmall)return w.isSmall?[new G(Ee(U/B)),new G(U%B)]:[A[0],m];if(w.isSmall){if(B===1)return[m,A[0]];if(B==-1)return[m.negate(),A[0]];var Y=Math.abs(B);if(Yf.length?1:-1;for(var $=m.length-1;$>=0;$--)if(m[$]!==f[$])return m[$]>f[$]?1:-1;return 0}k.prototype.compareAbs=function(m){var f=_(m),$=this.value,w=f.value;return f.isSmall?1:N($,w)},G.prototype.compareAbs=function(m){var f=_(m),$=Math.abs(this.value),w=f.value;return f.isSmall?(w=Math.abs(w),$===w?0:$>w?1:-1):-1},V.prototype.compareAbs=function(m){var f=this.value,$=_(m).value;return f=f>=0?f:-f,$=$>=0?$:-$,f===$?0:f>$?1:-1},k.prototype.compare=function(m){if(m===1/0)return-1;if(m===-1/0)return 1;var f=_(m),$=this.value,w=f.value;return this.sign!==f.sign?f.sign?1:-1:f.isSmall?this.sign?-1:1:N($,w)*(this.sign?-1:1)},k.prototype.compareTo=k.prototype.compare,G.prototype.compare=function(m){if(m===1/0)return-1;if(m===-1/0)return 1;var f=_(m),$=this.value,w=f.value;return f.isSmall?$==w?0:$>w?1:-1:$<0!==f.sign?$<0?-1:1:$<0?1:-1},G.prototype.compareTo=G.prototype.compare,V.prototype.compare=function(m){if(m===1/0)return-1;if(m===-1/0)return 1;var f=this.value,$=_(m).value;return f===$?0:f>$?1:-1},V.prototype.compareTo=V.prototype.compare,k.prototype.equals=function(m){return this.compare(m)===0},V.prototype.eq=V.prototype.equals=G.prototype.eq=G.prototype.equals=k.prototype.eq=k.prototype.equals,k.prototype.notEquals=function(m){return this.compare(m)!==0},V.prototype.neq=V.prototype.notEquals=G.prototype.neq=G.prototype.notEquals=k.prototype.neq=k.prototype.notEquals,k.prototype.greater=function(m){return this.compare(m)>0},V.prototype.gt=V.prototype.greater=G.prototype.gt=G.prototype.greater=k.prototype.gt=k.prototype.greater,k.prototype.lesser=function(m){return this.compare(m)<0},V.prototype.lt=V.prototype.lesser=G.prototype.lt=G.prototype.lesser=k.prototype.lt=k.prototype.lesser,k.prototype.greaterOrEquals=function(m){return this.compare(m)>=0},V.prototype.geq=V.prototype.greaterOrEquals=G.prototype.geq=G.prototype.greaterOrEquals=k.prototype.geq=k.prototype.greaterOrEquals,k.prototype.lesserOrEquals=function(m){return this.compare(m)<=0},V.prototype.leq=V.prototype.lesserOrEquals=G.prototype.leq=G.prototype.lesserOrEquals=k.prototype.leq=k.prototype.lesserOrEquals,k.prototype.isEven=function(){return(this.value[0]&1)===0},G.prototype.isEven=function(){return(this.value&1)===0},V.prototype.isEven=function(){return(this.value&BigInt(1))===BigInt(0)},k.prototype.isOdd=function(){return(this.value[0]&1)===1},G.prototype.isOdd=function(){return(this.value&1)===1},V.prototype.isOdd=function(){return(this.value&BigInt(1))===BigInt(1)},k.prototype.isPositive=function(){return!this.sign},G.prototype.isPositive=function(){return this.value>0},V.prototype.isPositive=G.prototype.isPositive,k.prototype.isNegative=function(){return this.sign},G.prototype.isNegative=function(){return this.value<0},V.prototype.isNegative=G.prototype.isNegative,k.prototype.isUnit=function(){return!1},G.prototype.isUnit=function(){return Math.abs(this.value)===1},V.prototype.isUnit=function(){return this.abs().value===BigInt(1)},k.prototype.isZero=function(){return!1},G.prototype.isZero=function(){return this.value===0},V.prototype.isZero=function(){return this.value===BigInt(0)},k.prototype.isDivisibleBy=function(m){var f=_(m);return f.isZero()?!1:f.isUnit()?!0:f.compareAbs(2)===0?this.isEven():this.mod(f).isZero()},V.prototype.isDivisibleBy=G.prototype.isDivisibleBy=k.prototype.isDivisibleBy;function q(m){var f=m.abs();if(f.isUnit())return!1;if(f.equals(2)||f.equals(3)||f.equals(5))return!0;if(f.isEven()||f.isDivisibleBy(3)||f.isDivisibleBy(5))return!1;if(f.lesser(49))return!0}function P(m,f){for(var $=m.prev(),w=$,U=0,B,Z,Y,ie;w.isEven();)w=w.divide(2),U++;e:for(Y=0;Y-o?new G(m-1):new k(g,!0)},V.prototype.prev=function(){return new V(this.value-BigInt(1))};for(var D=[1];2*D[D.length-1]<=t;)D.push(2*D[D.length-1]);var K=D.length,z=D[K-1];function te(m){return Math.abs(m)<=t}k.prototype.shiftLeft=function(m){var f=_(m).toJSNumber();if(!te(f))throw new Error(String(f)+" is too large for shifting.");if(f<0)return this.shiftRight(-f);var $=this;if($.isZero())return $;for(;f>=K;)$=$.multiply(z),f-=K-1;return $.multiply(D[f])},V.prototype.shiftLeft=G.prototype.shiftLeft=k.prototype.shiftLeft,k.prototype.shiftRight=function(m){var f,$=_(m).toJSNumber();if(!te($))throw new Error(String($)+" is too large for shifting.");if($<0)return this.shiftLeft(-$);for(var w=this;$>=K;){if(w.isZero()||w.isNegative()&&w.isUnit())return w;f=h(w,z),w=f[1].isNegative()?f[0].prev():f[0],$-=K-1}return f=h(w,D[$]),f[1].isNegative()?f[0].prev():f[0]},V.prototype.shiftRight=G.prototype.shiftRight=k.prototype.shiftRight;function ce(m,f,$){f=_(f);for(var w=m.isNegative(),U=f.isNegative(),B=w?m.not():m,Z=U?f.not():f,Y=0,ie=0,oe=null,ne=null,le=[];!B.isZero()||!Z.isZero();)oe=h(B,z),Y=oe[1].toJSNumber(),w&&(Y=z-1-Y),ne=h(Z,z),ie=ne[1].toJSNumber(),U&&(ie=z-1-ie),B=oe[0],Z=ne[0],le.push($(Y,ie));for(var ge=$(w?1:0,U?1:0)!==0?kt(-1):kt(0),ke=le.length-1;ke>=0;ke-=1)ge=ge.multiply(z).add(kt(le[ke]));return ge}k.prototype.not=function(){return this.negate().prev()},V.prototype.not=G.prototype.not=k.prototype.not,k.prototype.and=function(m){return ce(this,m,function(f,$){return f&$})},V.prototype.and=G.prototype.and=k.prototype.and,k.prototype.or=function(m){return ce(this,m,function(f,$){return f|$})},V.prototype.or=G.prototype.or=k.prototype.or,k.prototype.xor=function(m){return ce(this,m,function(f,$){return f^$})},V.prototype.xor=G.prototype.xor=k.prototype.xor;var de=1<<30,Se=(t&-t)*(t&-t)|de;function xe(m){var f=m.value,$=typeof f=="number"?f|de:typeof f=="bigint"?f|BigInt(de):f[0]+f[1]*t|Se;return $&-$}function Re(m,f){if(f.compareTo(m)<=0){var $=Re(m,f.square(f)),w=$.p,U=$.e,B=w.multiply(f);return B.compareTo(m)<=0?{p:B,e:U*2+1}:{p:w,e:U*2}}return{p:kt(1),e:0}}k.prototype.bitLength=function(){var m=this;return m.compareTo(kt(0))<0&&(m=m.negate().subtract(kt(1))),m.compareTo(kt(0))===0?kt(0):kt(Re(m,kt(2)).e).add(kt(1))},V.prototype.bitLength=G.prototype.bitLength=k.prototype.bitLength;function He(m,f){return m=_(m),f=_(f),m.greater(f)?m:f}function et(m,f){return m=_(m),f=_(f),m.lesser(f)?m:f}function Oe(m,f){if(m=_(m).abs(),f=_(f).abs(),m.equals(f))return m;if(m.isZero())return f;if(f.isZero())return m;for(var $=A[1],w,U;m.isEven()&&f.isEven();)w=et(xe(m),xe(f)),m=m.divide(w),f=f.divide(w),$=$.multiply(w);for(;m.isEven();)m=m.divide(xe(m));do{for(;f.isEven();)f=f.divide(xe(f));m.greater(f)&&(U=f,f=m,m=U),f=f.subtract(m)}while(!f.isZero());return $.isUnit()?m:m.multiply($)}function Fe(m,f){return m=_(m).abs(),f=_(f).abs(),m.divide(Oe(m,f)).multiply(f)}function De(m,f,$){m=_(m),f=_(f);var w=$||Math.random,U=et(m,f),B=He(m,f),Z=B.subtract(U).add(1);if(Z.isSmall)return U.add(Math.floor(w()*Z));for(var Y=H(Z,t).value,ie=[],oe=!0,ne=0;ne=Z){if(ie==="1"&&Z===1)continue;throw new Error(ie+" is not a valid digit in base "+f+".")}}f=_(f);var oe=[],ne=m[0]==="-";for(B=ne?1:0;B"&&B=0;B--)w=w.add(m[B].times(U)),U=U.times(f);return $?w.negate():w}function Q(m,f){return f=f||E,m"}function H(m,f){if(f=kt(f),f.isZero()){if(m.isZero())return{value:[0],isNegative:!1};throw new Error("Cannot convert nonzero numbers to base 0.")}if(f.equals(-1)){if(m.isZero())return{value:[0],isNegative:!1};if(m.isNegative())return{value:[].concat.apply([],Array.apply(null,Array(-m.toJSNumber())).map(Array.prototype.valueOf,[1,0])),isNegative:!1};var $=Array.apply(null,Array(m.toJSNumber()-1)).map(Array.prototype.valueOf,[0,1]);return $.unshift([1]),{value:[].concat.apply([],$),isNegative:!1}}var w=!1;if(m.isNegative()&&f.isPositive()&&(w=!0,m=m.abs()),f.isUnit())return m.isZero()?{value:[0],isNegative:!1}:{value:Array.apply(null,Array(m.toJSNumber())).map(Number.prototype.valueOf,1),isNegative:w};for(var U=[],B=m,Z;B.isNegative()||B.compareAbs(f)>=0;){Z=B.divmod(f),B=Z.quotient;var Y=Z.remainder;Y.isNegative()&&(Y=f.minus(Y).abs(),B=B.next()),U.push(Y.toJSNumber())}return U.push(B.toJSNumber()),{value:U.reverse(),isNegative:w}}function X(m,f,$){var w=H(m,f);return(w.isNegative?"-":"")+w.value.map(function(U){return Q(U,$)}).join("")}k.prototype.toArray=function(m){return H(this,m)},G.prototype.toArray=function(m){return H(this,m)},V.prototype.toArray=function(m){return H(this,m)},k.prototype.toString=function(m,f){if(m===r&&(m=10),m!==10||f)return X(this,m,f);for(var $=this.value,w=$.length,U=String($[--w]),B="0000000",Z;--w>=0;)Z=String($[w]),U+=B.slice(Z.length)+Z;var Y=this.sign?"-":"";return Y+U},G.prototype.toString=function(m,f){return m===r&&(m=10),m!=10||f?X(this,m,f):String(this.value)},V.prototype.toString=G.prototype.toString,V.prototype.toJSON=k.prototype.toJSON=G.prototype.toJSON=function(){return this.toString()},k.prototype.valueOf=function(){return parseInt(this.toString(),10)},k.prototype.toJSNumber=k.prototype.valueOf,G.prototype.valueOf=function(){return this.value},G.prototype.toJSNumber=G.prototype.valueOf,V.prototype.valueOf=V.prototype.toJSNumber=function(){return parseInt(this.toString(),10)};function F(m){if(J(+m)){var f=+m;if(f===Ee(f))return L?new V(BigInt(f)):new G(f);throw new Error("Invalid integer: "+m)}var $=m[0]==="-";$&&(m=m.slice(1));var w=m.split(/e/i);if(w.length>2)throw new Error("Invalid integer: "+w.join("e"));if(w.length===2){var U=w[1];if(U[0]==="+"&&(U=U.slice(1)),U=+U,U!==Ee(U)||!J(U))throw new Error("Invalid integer: "+U+" is not a valid exponent.");var B=w[0],Z=B.indexOf(".");if(Z>=0&&(U-=B.length-Z-1,B=B.slice(0,Z)+B.slice(Z+1)),U<0)throw new Error("Cannot include negative exponent part for integers");B+=new Array(U+1).join("0"),m=B}var Y=/^([0-9][0-9]*)$/.test(m);if(!Y)throw new Error("Invalid integer: "+m);if(L)return new V(BigInt($?"-"+m:m));for(var ie=[],oe=m.length,ne=e,le=oe-ne;oe>0;)ie.push(+m.slice(le,oe)),le-=ne,le<0&&(le=0),oe-=ne;return $e(ie),new k(ie,$)}function ee(m){if(L)return new V(BigInt(m));if(J(m)){if(m!==Ee(m))throw new Error(m+" is not an integer.");return new G(m)}return F(m.toString())}function _(m){return typeof m=="number"?ee(m):typeof m=="string"?F(m):typeof m=="bigint"?new V(m):m}for(var x=0;x<1e3;x++)A[x]=_(x),x>0&&(A[-x]=_(-x));return A.one=A[1],A.zero=A[0],A.minusOne=A[-1],A.max=He,A.min=et,A.gcd=Oe,A.lcm=Fe,A.isInstance=function(m){return m instanceof k||m instanceof G||m instanceof V},A.randBetween=De,A.fromArray=function(m,f,$){return Be(m.map(_),_(f||10),$)},A})();typeof H0<"u"&&H0.hasOwnProperty("exports")&&(H0.exports=kt);typeof define=="function"&&define.amd&&define(function(){return kt})});var Rn=f0((Tn,j0)=>{"use strict";(function(r){"use strict";var t=9e15,e=1e9,o="0123456789abcdef",g="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",E="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",L={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-t,maxE:t,crypto:!1},A,k,G,V,J=!0,me="[DecimalError] ",Ae=me+"Invalid argument: ",$e=me+"Precision limit exceeded",Te=me+"crypto unavailable",Ee="[object Decimal]",Me=Math.floor,a=Math.pow,ue=/^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,ve=/^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,Ne=/^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,ye=/^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,Ie=1e7,he=7,be=9007199254740991,we=g.length-1,fe=E.length-1,s={toStringTag:Ee};s.absoluteValue=s.abs=function(){var u=new this.constructor(this);return u.s<0&&(u.s=1),q(u)},s.ceil=function(){return q(new this.constructor(this),this.e+1,2)},s.clampedTo=s.clamp=function(u,y){var b,C=this,R=C.constructor;if(u=new R(u),y=new R(y),!u.s||!y.s)return new R(NaN);if(u.gt(y))throw Error(Ae+y);return b=C.cmp(u),b<0?u:C.cmp(y)>0?y:new R(C)},s.comparedTo=s.cmp=function(u){var y,b,C,R,n=this,i=n.d,l=(u=new n.constructor(u)).d,v=n.s,d=u.s;if(!i||!l)return!v||!d?NaN:v!==d?v:i===l?0:!i^v<0?1:-1;if(!i[0]||!l[0])return i[0]?v:l[0]?-d:0;if(v!==d)return v;if(n.e!==u.e)return n.e>u.e^v<0?1:-1;for(C=i.length,R=l.length,y=0,b=Cl[y]^v<0?1:-1;return C===R?0:C>R^v<0?1:-1},s.cosine=s.cos=function(){var u,y,b=this,C=b.constructor;return b.d?b.d[0]?(u=C.precision,y=C.rounding,C.precision=u+Math.max(b.e,b.sd())+he,C.rounding=1,b=h(C,Q(C,b)),C.precision=u,C.rounding=y,q(V==2||V==3?b.neg():b,u,y,!0)):new C(1):new C(NaN)},s.cubeRoot=s.cbrt=function(){var u,y,b,C,R,n,i,l,v,d,T=this,M=T.constructor;if(!T.isFinite()||T.isZero())return new M(T);for(J=!1,n=T.s*a(T.s*T,1/3),!n||Math.abs(n)==1/0?(b=c(T.d),u=T.e,(n=(u-b.length+1)%3)&&(b+=n==1||n==-2?"0":"00"),n=a(b,1/3),u=Me((u+1)/3)-(u%3==(u<0?-1:2)),n==1/0?b="5e"+u:(b=n.toExponential(),b=b.slice(0,b.indexOf("e")+1)+u),C=new M(b),C.s=T.s):C=new M(n.toString()),i=(u=M.precision)+3;;)if(l=C,v=l.times(l).times(l),d=v.plus(T),C=N(d.plus(T).times(l),d.plus(v),i+2,1),c(l.d).slice(0,i)===(b=c(C.d)).slice(0,i))if(b=b.slice(i-3,i+1),b=="9999"||!R&&b=="4999"){if(!R&&(q(l,u+1,0),l.times(l).times(l).eq(T))){C=l;break}i+=4,R=1}else{(!+b||!+b.slice(1)&&b.charAt(0)=="5")&&(q(C,u+1,1),y=!C.times(C).times(C).eq(T));break}return J=!0,q(C,u,M.rounding,y)},s.decimalPlaces=s.dp=function(){var u,y=this.d,b=NaN;if(y){if(u=y.length-1,b=(u-Me(this.e/he))*he,u=y[u],u)for(;u%10==0;u/=10)b--;b<0&&(b=0)}return b},s.dividedBy=s.div=function(u){return N(this,new this.constructor(u))},s.dividedToIntegerBy=s.divToInt=function(u){var y=this,b=y.constructor;return q(N(y,new b(u),0,1,1),b.precision,b.rounding)},s.equals=s.eq=function(u){return this.cmp(u)===0},s.floor=function(){return q(new this.constructor(this),this.e+1,3)},s.greaterThan=s.gt=function(u){return this.cmp(u)>0},s.greaterThanOrEqualTo=s.gte=function(u){var y=this.cmp(u);return y==1||y===0},s.hyperbolicCosine=s.cosh=function(){var u,y,b,C,R,n=this,i=n.constructor,l=new i(1);if(!n.isFinite())return new i(n.s?1/0:NaN);if(n.isZero())return l;b=i.precision,C=i.rounding,i.precision=b+Math.max(n.e,n.sd())+4,i.rounding=1,R=n.d.length,R<32?(u=Math.ceil(R/3),y=(1/Be(4,u)).toString()):(u=16,y="2.3283064365386962890625e-10"),n=Xe(i,1,n.times(y),new i(1),!0);for(var v,d=u,T=new i(8);d--;)v=n.times(n),n=l.minus(v.times(T.minus(v.times(T))));return q(n,i.precision=b,i.rounding=C,!0)},s.hyperbolicSine=s.sinh=function(){var u,y,b,C,R=this,n=R.constructor;if(!R.isFinite()||R.isZero())return new n(R);if(y=n.precision,b=n.rounding,n.precision=y+Math.max(R.e,R.sd())+4,n.rounding=1,C=R.d.length,C<3)R=Xe(n,2,R,R,!0);else{u=1.4*Math.sqrt(C),u=u>16?16:u|0,R=R.times(1/Be(5,u)),R=Xe(n,2,R,R,!0);for(var i,l=new n(5),v=new n(16),d=new n(20);u--;)i=R.times(R),R=R.times(l.plus(i.times(v.times(i).plus(d))))}return n.precision=y,n.rounding=b,q(R,y,b,!0)},s.hyperbolicTangent=s.tanh=function(){var u,y,b=this,C=b.constructor;return b.isFinite()?b.isZero()?new C(b):(u=C.precision,y=C.rounding,C.precision=u+7,C.rounding=1,N(b.sinh(),b.cosh(),C.precision=u,C.rounding=y)):new C(b.s)},s.inverseCosine=s.acos=function(){var u=this,y=u.constructor,b=u.abs().cmp(1),C=y.precision,R=y.rounding;return b!==-1?b===0?u.isNeg()?z(y,C,R):new y(0):new y(NaN):u.isZero()?z(y,C+4,R).times(.5):(y.precision=C+6,y.rounding=1,u=new y(1).minus(u).div(u.plus(1)).sqrt().atan(),y.precision=C,y.rounding=R,u.times(2))},s.inverseHyperbolicCosine=s.acosh=function(){var u,y,b=this,C=b.constructor;return b.lte(1)?new C(b.eq(1)?0:NaN):b.isFinite()?(u=C.precision,y=C.rounding,C.precision=u+Math.max(Math.abs(b.e),b.sd())+4,C.rounding=1,J=!1,b=b.times(b).minus(1).sqrt().plus(b),J=!0,C.precision=u,C.rounding=y,b.ln()):new C(b)},s.inverseHyperbolicSine=s.asinh=function(){var u,y,b=this,C=b.constructor;return!b.isFinite()||b.isZero()?new C(b):(u=C.precision,y=C.rounding,C.precision=u+2*Math.max(Math.abs(b.e),b.sd())+6,C.rounding=1,J=!1,b=b.times(b).plus(1).sqrt().plus(b),J=!0,C.precision=u,C.rounding=y,b.ln())},s.inverseHyperbolicTangent=s.atanh=function(){var u,y,b,C,R=this,n=R.constructor;return R.isFinite()?R.e>=0?new n(R.abs().eq(1)?R.s/0:R.isZero()?R:NaN):(u=n.precision,y=n.rounding,C=R.sd(),Math.max(C,u)<2*-R.e-1?q(new n(R),u,y,!0):(n.precision=b=C-R.e,R=N(R.plus(1),new n(1).minus(R),b+u,1),n.precision=u+4,n.rounding=1,R=R.ln(),n.precision=u,n.rounding=y,R.times(.5))):new n(NaN)},s.inverseSine=s.asin=function(){var u,y,b,C,R=this,n=R.constructor;return R.isZero()?new n(R):(y=R.abs().cmp(1),b=n.precision,C=n.rounding,y!==-1?y===0?(u=z(n,b+4,C).times(.5),u.s=R.s,u):new n(NaN):(n.precision=b+6,n.rounding=1,R=R.div(new n(1).minus(R.times(R)).sqrt().plus(1)).atan(),n.precision=b,n.rounding=C,R.times(2)))},s.inverseTangent=s.atan=function(){var u,y,b,C,R,n,i,l,v,d=this,T=d.constructor,M=T.precision,I=T.rounding;if(d.isFinite()){if(d.isZero())return new T(d);if(d.abs().eq(1)&&M+4<=fe)return i=z(T,M+4,I).times(.25),i.s=d.s,i}else{if(!d.s)return new T(NaN);if(M+4<=fe)return i=z(T,M+4,I).times(.5),i.s=d.s,i}for(T.precision=l=M+10,T.rounding=1,b=Math.min(28,l/he+2|0),u=b;u;--u)d=d.div(d.times(d).plus(1).sqrt().plus(1));for(J=!1,y=Math.ceil(l/he),C=1,v=d.times(d),i=new T(d),R=d;u!==-1;)if(R=R.times(v),n=i.minus(R.div(C+=2)),R=R.times(v),i=n.plus(R.div(C+=2)),i.d[y]!==void 0)for(u=y;i.d[u]===n.d[u]&&u--;);return b&&(i=i.times(2<this.d.length-2},s.isNaN=function(){return!this.s},s.isNegative=s.isNeg=function(){return this.s<0},s.isPositive=s.isPos=function(){return this.s>0},s.isZero=function(){return!!this.d&&this.d[0]===0},s.lessThan=s.lt=function(u){return this.cmp(u)<0},s.lessThanOrEqualTo=s.lte=function(u){return this.cmp(u)<1},s.logarithm=s.log=function(u){var y,b,C,R,n,i,l,v,d=this,T=d.constructor,M=T.precision,I=T.rounding,j=5;if(u==null)u=new T(10),y=!0;else{if(u=new T(u),b=u.d,u.s<0||!b||!b[0]||u.eq(1))return new T(NaN);y=u.eq(10)}if(b=d.d,d.s<0||!b||!b[0]||d.eq(1))return new T(b&&!b[0]?-1/0:d.s!=1?NaN:b?0:1/0);if(y)if(b.length>1)n=!0;else{for(R=b[0];R%10===0;)R/=10;n=R!==1}if(J=!1,l=M+j,i=He(d,l),C=y?K(T,l+10):He(u,l),v=N(i,C,l,1),O(v.d,R=M,I))do if(l+=10,i=He(d,l),C=y?K(T,l+10):He(u,l),v=N(i,C,l,1),!n){+c(v.d).slice(R+1,R+15)+1==1e14&&(v=q(v,M+1,0));break}while(O(v.d,R+=10,I));return J=!0,q(v,M,I)},s.minus=s.sub=function(u){var y,b,C,R,n,i,l,v,d,T,M,I,j=this,se=j.constructor;if(u=new se(u),!j.d||!u.d)return!j.s||!u.s?u=new se(NaN):j.d?u.s=-u.s:u=new se(u.d||j.s!==u.s?j:NaN),u;if(j.s!=u.s)return u.s=-u.s,j.plus(u);if(d=j.d,I=u.d,l=se.precision,v=se.rounding,!d[0]||!I[0]){if(I[0])u.s=-u.s;else if(d[0])u=new se(j);else return new se(v===3?-0:0);return J?q(u,l,v):u}if(b=Me(u.e/he),T=Me(j.e/he),d=d.slice(),n=T-b,n){for(M=n<0,M?(y=d,n=-n,i=I.length):(y=I,b=T,i=d.length),C=Math.max(Math.ceil(l/he),i)+2,n>C&&(n=C,y.length=1),y.reverse(),C=n;C--;)y.push(0);y.reverse()}else{for(C=d.length,i=I.length,M=C0;--C)d[i++]=0;for(C=I.length;C>n;){if(d[--C]i?n+1:i+1,R>i&&(R=i,b.length=1),b.reverse();R--;)b.push(0);b.reverse()}for(i=d.length,R=T.length,i-R<0&&(R=i,b=T,T=d,d=b),y=0;R;)y=(d[--R]=d[R]+T[R]+y)/Ie|0,d[R]%=Ie;for(y&&(d.unshift(y),++C),i=d.length;d[--i]==0;)d.pop();return u.d=d,u.e=D(d,C),J?q(u,l,v):u},s.precision=s.sd=function(u){var y,b=this;if(u!==void 0&&u!==!!u&&u!==1&&u!==0)throw Error(Ae+u);return b.d?(y=te(b.d),u&&b.e+1>y&&(y=b.e+1)):y=NaN,y},s.round=function(){var u=this,y=u.constructor;return q(new y(u),u.e+1,y.rounding)},s.sine=s.sin=function(){var u,y,b=this,C=b.constructor;return b.isFinite()?b.isZero()?new C(b):(u=C.precision,y=C.rounding,C.precision=u+Math.max(b.e,b.sd())+he,C.rounding=1,b=De(C,Q(C,b)),C.precision=u,C.rounding=y,q(V>2?b.neg():b,u,y,!0)):new C(NaN)},s.squareRoot=s.sqrt=function(){var u,y,b,C,R,n,i=this,l=i.d,v=i.e,d=i.s,T=i.constructor;if(d!==1||!l||!l[0])return new T(!d||d<0&&(!l||l[0])?NaN:l?i:1/0);for(J=!1,d=Math.sqrt(+i),d==0||d==1/0?(y=c(l),(y.length+v)%2==0&&(y+="0"),d=Math.sqrt(y),v=Me((v+1)/2)-(v<0||v%2),d==1/0?y="5e"+v:(y=d.toExponential(),y=y.slice(0,y.indexOf("e")+1)+v),C=new T(y)):C=new T(d.toString()),b=(v=T.precision)+3;;)if(n=C,C=n.plus(N(i,n,b+2,1)).times(.5),c(n.d).slice(0,b)===(y=c(C.d)).slice(0,b))if(y=y.slice(b-3,b+1),y=="9999"||!R&&y=="4999"){if(!R&&(q(n,v+1,0),n.times(n).eq(i))){C=n;break}b+=4,R=1}else{(!+y||!+y.slice(1)&&y.charAt(0)=="5")&&(q(C,v+1,1),u=!C.times(C).eq(i));break}return J=!0,q(C,v,T.rounding,u)},s.tangent=s.tan=function(){var u,y,b=this,C=b.constructor;return b.isFinite()?b.isZero()?new C(b):(u=C.precision,y=C.rounding,C.precision=u+10,C.rounding=1,b=b.sin(),b.s=1,b=N(b,new C(1).minus(b.times(b)).sqrt(),u+10,0),C.precision=u,C.rounding=y,q(V==2||V==4?b.neg():b,u,y,!0)):new C(NaN)},s.times=s.mul=function(u){var y,b,C,R,n,i,l,v,d,T=this,M=T.constructor,I=T.d,j=(u=new M(u)).d;if(u.s*=T.s,!I||!I[0]||!j||!j[0])return new M(!u.s||I&&!I[0]&&!j||j&&!j[0]&&!I?NaN:!I||!j?u.s/0:u.s*0);for(b=Me(T.e/he)+Me(u.e/he),v=I.length,d=j.length,v=0;){for(y=0,R=v+C;R>C;)l=n[R]+j[C]*I[R-C-1]+y,n[R--]=l%Ie|0,y=l/Ie|0;n[R]=(n[R]+y)%Ie|0}for(;!n[--i];)n.pop();return y?++b:n.shift(),u.d=n,u.e=D(n,b),J?q(u,M.precision,M.rounding):u},s.toBinary=function(u,y){return H(this,2,u,y)},s.toDecimalPlaces=s.toDP=function(u,y){var b=this,C=b.constructor;return b=new C(b),u===void 0?b:(S(u,0,e),y===void 0?y=C.rounding:S(y,0,8),q(b,u+b.e+1,y))},s.toExponential=function(u,y){var b,C=this,R=C.constructor;return u===void 0?b=P(C,!0):(S(u,0,e),y===void 0?y=R.rounding:S(y,0,8),C=q(new R(C),u+1,y),b=P(C,!0,u+1)),C.isNeg()&&!C.isZero()?"-"+b:b},s.toFixed=function(u,y){var b,C,R=this,n=R.constructor;return u===void 0?b=P(R):(S(u,0,e),y===void 0?y=n.rounding:S(y,0,8),C=q(new n(R),u+R.e+1,y),b=P(C,!1,u+C.e+1)),R.isNeg()&&!R.isZero()?"-"+b:b},s.toFraction=function(u){var y,b,C,R,n,i,l,v,d,T,M,I,j=this,se=j.d,ae=j.constructor;if(!se)return new ae(j);if(d=b=new ae(1),C=v=new ae(0),y=new ae(C),n=y.e=te(se)-j.e-1,i=n%he,y.d[0]=a(10,i<0?he+i:i),u==null)u=n>0?y:d;else{if(l=new ae(u),!l.isInt()||l.lt(d))throw Error(Ae+l);u=l.gt(y)?n>0?y:d:l}for(J=!1,l=new ae(c(se)),T=ae.precision,ae.precision=n=se.length*he*2;M=N(l,y,0,1,1),R=b.plus(M.times(C)),R.cmp(u)!=1;)b=C,C=R,R=d,d=v.plus(M.times(R)),v=R,R=y,y=l.minus(M.times(R)),l=R;return R=N(u.minus(b),C,0,1,1),v=v.plus(R.times(d)),b=b.plus(R.times(C)),v.s=d.s=j.s,I=N(d,C,n,1).minus(j).abs().cmp(N(v,b,n,1).minus(j).abs())<1?[d,C]:[v,b],ae.precision=T,J=!0,I},s.toHexadecimal=s.toHex=function(u,y){return H(this,16,u,y)},s.toNearest=function(u,y){var b=this,C=b.constructor;if(b=new C(b),u==null){if(!b.d)return b;u=new C(1),y=C.rounding}else{if(u=new C(u),y===void 0?y=C.rounding:S(y,0,8),!b.d)return u.s?b:u;if(!u.d)return u.s&&(u.s=b.s),u}return u.d[0]?(J=!1,b=N(b,u,0,y,1).times(u),J=!0,q(b)):(u.s=b.s,b=u),b},s.toNumber=function(){return+this},s.toOctal=function(u,y){return H(this,8,u,y)},s.toPower=s.pow=function(u){var y,b,C,R,n,i,l=this,v=l.constructor,d=+(u=new v(u));if(!l.d||!u.d||!l.d[0]||!u.d[0])return new v(a(+l,d));if(l=new v(l),l.eq(1))return l;if(C=v.precision,n=v.rounding,u.eq(1))return q(l,C,n);if(y=Me(u.e/he),y>=u.d.length-1&&(b=d<0?-d:d)<=be)return R=de(v,l,b,C),u.s<0?new v(1).div(R):q(R,C,n);if(i=l.s,i<0){if(yv.maxE+1||y0?i/0:0):(J=!1,v.rounding=l.s=1,b=Math.min(12,(y+"").length),R=Re(u.times(He(l,C+b)),C),R.d&&(R=q(R,C+5,1),O(R.d,C,n)&&(y=C+10,R=q(Re(u.times(He(l,y+b)),y),y+5,1),+c(R.d).slice(C+1,C+15)+1==1e14&&(R=q(R,C+1,0)))),R.s=i,J=!0,v.rounding=n,q(R,C,n))},s.toPrecision=function(u,y){var b,C=this,R=C.constructor;return u===void 0?b=P(C,C.e<=R.toExpNeg||C.e>=R.toExpPos):(S(u,1,e),y===void 0?y=R.rounding:S(y,0,8),C=q(new R(C),u,y),b=P(C,u<=C.e||C.e<=R.toExpNeg,u)),C.isNeg()&&!C.isZero()?"-"+b:b},s.toSignificantDigits=s.toSD=function(u,y){var b=this,C=b.constructor;return u===void 0?(u=C.precision,y=C.rounding):(S(u,1,e),y===void 0?y=C.rounding:S(y,0,8)),q(new C(b),u,y)},s.toString=function(){var u=this,y=u.constructor,b=P(u,u.e<=y.toExpNeg||u.e>=y.toExpPos);return u.isNeg()&&!u.isZero()?"-"+b:b},s.truncated=s.trunc=function(){return q(new this.constructor(this),this.e+1,1)},s.valueOf=s.toJSON=function(){var u=this,y=u.constructor,b=P(u,u.e<=y.toExpNeg||u.e>=y.toExpPos);return u.isNeg()?"-"+b:b};function c(u){var y,b,C,R=u.length-1,n="",i=u[0];if(R>0){for(n+=i,y=1;yb)throw Error(Ae+u)}function O(u,y,b,C){var R,n,i,l;for(n=u[0];n>=10;n/=10)--y;return--y<0?(y+=he,R=0):(R=Math.ceil((y+1)/he),y%=he),n=a(10,he-y),l=u[R]%n|0,C==null?y<3?(y==0?l=l/100|0:y==1&&(l=l/10|0),i=b<4&&l==99999||b>3&&l==49999||l==5e4||l==0):i=(b<4&&l+1==n||b>3&&l+1==n/2)&&(u[R+1]/n/100|0)==a(10,y-2)-1||(l==n/2||l==0)&&(u[R+1]/n/100|0)==0:y<4?(y==0?l=l/1e3|0:y==1?l=l/100|0:y==2&&(l=l/10|0),i=(C||b<4)&&l==9999||!C&&b>3&&l==4999):i=((C||b<4)&&l+1==n||!C&&b>3&&l+1==n/2)&&(u[R+1]/n/1e3|0)==a(10,y-3)-1,i}function p(u,y,b){for(var C,R=[0],n,i=0,l=u.length;ib-1&&(R[C+1]===void 0&&(R[C+1]=0),R[C+1]+=R[C]/b|0,R[C]%=b)}return R.reverse()}function h(u,y){var b,C,R;if(y.isZero())return y;C=y.d.length,C<32?(b=Math.ceil(C/3),R=(1/Be(4,b)).toString()):(b=16,R="2.3283064365386962890625e-10"),u.precision+=b,y=Xe(u,1,y.times(R),new u(1));for(var n=b;n--;){var i=y.times(y);y=i.times(i).minus(i).times(8).plus(1)}return u.precision-=b,y}var N=(function(){function u(C,R,n){var i,l=0,v=C.length;for(C=C.slice();v--;)i=C[v]*R+l,C[v]=i%n|0,l=i/n|0;return l&&C.unshift(l),C}function y(C,R,n,i){var l,v;if(n!=i)v=n>i?1:-1;else for(l=v=0;lR[l]?1:-1;break}return v}function b(C,R,n,i){for(var l=0;n--;)C[n]-=l,l=C[n]1;)C.shift()}return function(C,R,n,i,l,v){var d,T,M,I,j,se,ae,qe,Pe,Ce,Ge,st,Ct,Je,Ue,Ke,ze,Ye,at,dt,ht=C.constructor,nt=C.s==R.s?1:-1,it=C.d,rt=R.d;if(!it||!it[0]||!rt||!rt[0])return new ht(!C.s||!R.s||(it?rt&&it[0]==rt[0]:!rt)?NaN:it&&it[0]==0||!rt?nt*0:nt/0);for(v?(j=1,T=C.e-R.e):(v=Ie,j=he,T=Me(C.e/j)-Me(R.e/j)),at=rt.length,ze=it.length,Pe=new ht(nt),Ce=Pe.d=[],M=0;rt[M]==(it[M]||0);M++);if(rt[M]>(it[M]||0)&&T--,n==null?(Je=n=ht.precision,i=ht.rounding):l?Je=n+(C.e-R.e)+1:Je=n,Je<0)Ce.push(1),se=!0;else{if(Je=Je/j+2|0,M=0,at==1){for(I=0,rt=rt[0],Je++;(M1&&(rt=u(rt,I,v),it=u(it,I,v),at=rt.length,ze=it.length),Ke=at,Ge=it.slice(0,at),st=Ge.length;st=v/2&&++Ye;do I=0,d=y(rt,Ge,at,st),d<0?(Ct=Ge[0],at!=st&&(Ct=Ct*v+(Ge[1]||0)),I=Ct/Ye|0,I>1?(I>=v&&(I=v-1),ae=u(rt,I,v),qe=ae.length,st=Ge.length,d=y(ae,Ge,qe,st),d==1&&(I--,b(ae,at=10;I/=10)M++;Pe.e=M+T*j-1,q(Pe,l?n+Pe.e+1:n,i,se)}return Pe}})();function q(u,y,b,C){var R,n,i,l,v,d,T,M,I,j=u.constructor;e:if(y!=null){if(M=u.d,!M)return u;for(R=1,l=M[0];l>=10;l/=10)R++;if(n=y-R,n<0)n+=he,i=y,T=M[I=0],v=T/a(10,R-i-1)%10|0;else if(I=Math.ceil((n+1)/he),l=M.length,I>=l)if(C){for(;l++<=I;)M.push(0);T=v=0,R=1,n%=he,i=n-he+1}else break e;else{for(T=l=M[I],R=1;l>=10;l/=10)R++;n%=he,i=n-he+R,v=i<0?0:T/a(10,R-i-1)%10|0}if(C=C||y<0||M[I+1]!==void 0||(i<0?T:T%a(10,R-i-1)),d=b<4?(v||C)&&(b==0||b==(u.s<0?3:2)):v>5||v==5&&(b==4||C||b==6&&(n>0?i>0?T/a(10,R-i):0:M[I-1])%10&1||b==(u.s<0?8:7)),y<1||!M[0])return M.length=0,d?(y-=u.e+1,M[0]=a(10,(he-y%he)%he),u.e=-y||0):M[0]=u.e=0,u;if(n==0?(M.length=I,l=1,I--):(M.length=I+1,l=a(10,he-n),M[I]=i>0?(T/a(10,R-i)%a(10,i)|0)*l:0),d)for(;;)if(I==0){for(n=1,i=M[0];i>=10;i/=10)n++;for(i=M[0]+=l,l=1;i>=10;i/=10)l++;n!=l&&(u.e++,M[0]==Ie&&(M[0]=1));break}else{if(M[I]+=l,M[I]!=Ie)break;M[I--]=0,l=1}for(n=M.length;M[--n]===0;)M.pop()}return J&&(u.e>j.maxE?(u.d=null,u.e=NaN):u.e0?n=n.charAt(0)+"."+n.slice(1)+ce(C):i>1&&(n=n.charAt(0)+"."+n.slice(1)),n=n+(u.e<0?"e":"e+")+u.e):R<0?(n="0."+ce(-R-1)+n,b&&(C=b-i)>0&&(n+=ce(C))):R>=i?(n+=ce(R+1-i),b&&(C=b-R-1)>0&&(n=n+"."+ce(C))):((C=R+1)0&&(R+1===i&&(n+="."),n+=ce(C))),n}function D(u,y){var b=u[0];for(y*=he;b>=10;b/=10)y++;return y}function K(u,y,b){if(y>we)throw J=!0,b&&(u.precision=b),Error($e);return q(new u(g),y,1,!0)}function z(u,y,b){if(y>fe)throw Error($e);return q(new u(E),y,b,!0)}function te(u){var y=u.length-1,b=y*he+1;if(y=u[y],y){for(;y%10==0;y/=10)b--;for(y=u[0];y>=10;y/=10)b++}return b}function ce(u){for(var y="";u--;)y+="0";return y}function de(u,y,b,C){var R,n=new u(1),i=Math.ceil(C/he+4);for(J=!1;;){if(b%2&&(n=n.times(y),X(n.d,i)&&(R=!0)),b=Me(b/2),b===0){b=n.d.length-1,R&&n.d[b]===0&&++n.d[b];break}y=y.times(y),X(y.d,i)}return J=!0,n}function Se(u){return u.d[u.d.length-1]&1}function xe(u,y,b){for(var C,R,n=new u(y[0]),i=0;++i17)return new I(u.d?u.d[0]?u.s<0?0:1/0:1:u.s?u.s<0?0:u:NaN);for(y==null?(J=!1,v=se):v=y,l=new I(.03125);u.e>-2;)u=u.times(l),M+=5;for(C=Math.log(a(2,M))/Math.LN10*2+5|0,v+=C,b=n=i=new I(1),I.precision=v;;){if(n=q(n.times(u),v,1),b=b.times(++T),l=i.plus(N(n,b,v,1)),c(l.d).slice(0,v)===c(i.d).slice(0,v)){for(R=M;R--;)i=q(i.times(i),v,1);if(y==null)if(d<3&&O(i.d,v-C,j,d))I.precision=v+=10,b=n=l=new I(1),T=0,d++;else return q(i,I.precision=se,j,J=!0);else return I.precision=se,i}i=l}}function He(u,y){var b,C,R,n,i,l,v,d,T,M,I,j=1,se=10,ae=u,qe=ae.d,Pe=ae.constructor,Ce=Pe.rounding,Ge=Pe.precision;if(ae.s<0||!qe||!qe[0]||!ae.e&&qe[0]==1&&qe.length==1)return new Pe(qe&&!qe[0]?-1/0:ae.s!=1?NaN:qe?0:ae);if(y==null?(J=!1,T=Ge):T=y,Pe.precision=T+=se,b=c(qe),C=b.charAt(0),Math.abs(n=ae.e)<15e14){for(;C<7&&C!=1||C==1&&b.charAt(1)>3;)ae=ae.times(u),b=c(ae.d),C=b.charAt(0),j++;n=ae.e,C>1?(ae=new Pe("0."+b),n++):ae=new Pe(C+"."+b.slice(1))}else return d=K(Pe,T+2,Ge).times(n+""),ae=He(new Pe(C+"."+b.slice(1)),T-se).plus(d),Pe.precision=Ge,y==null?q(ae,Ge,Ce,J=!0):ae;for(M=ae,v=i=ae=N(ae.minus(1),ae.plus(1),T,1),I=q(ae.times(ae),T,1),R=3;;){if(i=q(i.times(I),T,1),d=v.plus(N(i,new Pe(R),T,1)),c(d.d).slice(0,T)===c(v.d).slice(0,T))if(v=v.times(2),n!==0&&(v=v.plus(K(Pe,T+2,Ge).times(n+""))),v=N(v,new Pe(j),T,1),y==null)if(O(v.d,T-se,Ce,l))Pe.precision=T+=se,d=i=ae=N(M.minus(1),M.plus(1),T,1),I=q(ae.times(ae),T,1),R=l=1;else return q(v,Pe.precision=Ge,Ce,J=!0);else return Pe.precision=Ge,v;v=d,R+=2}}function et(u){return String(u.s*u.s/0)}function Oe(u,y){var b,C,R;for((b=y.indexOf("."))>-1&&(y=y.replace(".","")),(C=y.search(/e/i))>0?(b<0&&(b=C),b+=+y.slice(C+1),y=y.substring(0,C)):b<0&&(b=y.length),C=0;y.charCodeAt(C)===48;C++);for(R=y.length;y.charCodeAt(R-1)===48;--R);if(y=y.slice(C,R),y){if(R-=C,u.e=b=b-C-1,u.d=[],C=(b+1)%he,b<0&&(C+=he),Cu.constructor.maxE?(u.d=null,u.e=NaN):u.e-1){if(y=y.replace(/(\\d)_(?=\\d)/g,"$1"),ye.test(y))return Oe(u,y)}else if(y==="Infinity"||y==="NaN")return+y||(u.s=NaN),u.e=NaN,u.d=null,u;if(ve.test(y))b=16,y=y.toLowerCase();else if(ue.test(y))b=2;else if(Ne.test(y))b=8;else throw Error(Ae+y);for(n=y.search(/p/i),n>0?(v=+y.slice(n+1),y=y.substring(2,n)):y=y.slice(2),n=y.indexOf("."),i=n>=0,C=u.constructor,i&&(y=y.replace(".",""),l=y.length,n=l-n,R=de(C,new C(b),n,n*2)),d=p(y,b,Ie),T=d.length-1,n=T;d[n]===0;--n)d.pop();return n<0?new C(u.s*0):(u.e=D(d,T),u.d=d,J=!1,i&&(u=N(u,R,l*4)),v&&(u=u.times(Math.abs(v)<54?a(2,v):A.pow(2,v))),J=!0,u)}function De(u,y){var b,C=y.d.length;if(C<3)return y.isZero()?y:Xe(u,2,y,y);b=1.4*Math.sqrt(C),b=b>16?16:b|0,y=y.times(1/Be(5,b)),y=Xe(u,2,y,y);for(var R,n=new u(5),i=new u(16),l=new u(20);b--;)R=y.times(y),y=y.times(n.plus(R.times(i.times(R).minus(l))));return y}function Xe(u,y,b,C,R){var n,i,l,v,d=1,T=u.precision,M=Math.ceil(T/he);for(J=!1,v=b.times(b),l=new u(C);;){if(i=N(l.times(v),new u(y++*y++),T,1),l=R?C.plus(i):C.minus(i),C=N(i.times(v),new u(y++*y++),T,1),i=l.plus(C),i.d[M]!==void 0){for(n=M;i.d[n]===l.d[n]&&n--;);if(n==-1)break}n=l,l=C,C=i,i=n,d++}return J=!0,i.d.length=M+1,i}function Be(u,y){for(var b=u;--y;)b*=u;return b}function Q(u,y){var b,C=y.s<0,R=z(u,u.precision,1),n=R.times(.5);if(y=y.abs(),y.lte(n))return V=C?4:1,y;if(b=y.divToInt(R),b.isZero())V=C?3:2;else{if(y=y.minus(b.times(R)),y.lte(n))return V=Se(b)?C?2:3:C?4:1,y;V=Se(b)?C?1:4:C?3:2}return y.minus(R).abs()}function H(u,y,b,C){var R,n,i,l,v,d,T,M,I,j=u.constructor,se=b!==void 0;if(se?(S(b,1,e),C===void 0?C=j.rounding:S(C,0,8)):(b=j.precision,C=j.rounding),!u.isFinite())T=et(u);else{for(T=P(u),i=T.indexOf("."),se?(R=2,y==16?b=b*4-3:y==8&&(b=b*3-2)):R=y,i>=0&&(T=T.replace(".",""),I=new j(1),I.e=T.length-i,I.d=p(P(I),10,R),I.e=I.d.length),M=p(T,10,R),n=v=M.length;M[--v]==0;)M.pop();if(!M[0])T=se?"0p+0":"0";else{if(i<0?n--:(u=new j(u),u.d=M,u.e=n,u=N(u,I,b,C,0,R),M=u.d,n=u.e,d=k),i=M[b],l=R/2,d=d||M[b+1]!==void 0,d=C<4?(i!==void 0||d)&&(C===0||C===(u.s<0?3:2)):i>l||i===l&&(C===4||d||C===6&&M[b-1]&1||C===(u.s<0?8:7)),M.length=b,d)for(;++M[--b]>R-1;)M[b]=0,b||(++n,M.unshift(1));for(v=M.length;!M[v-1];--v);for(i=0,T="";i1)if(y==16||y==8){for(i=y==16?4:3,--v;v%i;v++)T+="0";for(M=p(T,R,y),v=M.length;!M[v-1];--v);for(i=1,T="1.";iv)for(n-=v;n--;)T+="0";else ny)return u.length=y,!0}function F(u){return new this(u).abs()}function ee(u){return new this(u).acos()}function _(u){return new this(u).acosh()}function x(u,y){return new this(u).plus(y)}function m(u){return new this(u).asin()}function f(u){return new this(u).asinh()}function $(u){return new this(u).atan()}function w(u){return new this(u).atanh()}function U(u,y){u=new this(u),y=new this(y);var b,C=this.precision,R=this.rounding,n=C+4;return!u.s||!y.s?b=new this(NaN):!u.d&&!y.d?(b=z(this,n,1).times(y.s>0?.25:.75),b.s=u.s):!y.d||u.isZero()?(b=y.s<0?z(this,C,R):new this(0),b.s=u.s):!u.d||y.isZero()?(b=z(this,n,1).times(.5),b.s=u.s):y.s<0?(this.precision=n,this.rounding=1,b=this.atan(N(u,y,n,1)),y=z(this,n,1),this.precision=C,this.rounding=R,b=u.s<0?b.minus(y):b.plus(y)):b=this.atan(N(u,y,n,1)),b}function B(u){return new this(u).cbrt()}function Z(u){return q(u=new this(u),u.e+1,2)}function Y(u,y,b){return new this(u).clamp(y,b)}function ie(u){if(!u||typeof u!="object")throw Error(me+"Object expected");var y,b,C,R=u.defaults===!0,n=["precision",1,e,"rounding",0,8,"toExpNeg",-t,0,"toExpPos",0,t,"maxE",0,t,"minE",-t,0,"modulo",0,9];for(y=0;y=n[y+1]&&C<=n[y+2])this[b]=C;else throw Error(Ae+b+": "+C);if(b="crypto",R&&(this[b]=L[b]),(C=u[b])!==void 0)if(C===!0||C===!1||C===0||C===1)if(C)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[b]=!0;else throw Error(Te);else this[b]=!1;else throw Error(Ae+b+": "+C);return this}function oe(u){return new this(u).cos()}function ne(u){return new this(u).cosh()}function le(u){var y,b,C;function R(n){var i,l,v,d=this;if(!(d instanceof R))return new R(n);if(d.constructor=R,Qe(n)){d.s=n.s,J?!n.d||n.e>R.maxE?(d.e=NaN,d.d=null):n.e=10;l/=10)i++;J?i>R.maxE?(d.e=NaN,d.d=null):i=429e7?y[n]=crypto.getRandomValues(new Uint32Array(1))[0]:l[n++]=R%1e7;else if(crypto.randomBytes){for(y=crypto.randomBytes(C*=4);n=214e7?crypto.randomBytes(4).copy(y,n):(l.push(R%1e7),n+=4);n=C/4}else throw Error(Te);else for(;n=10;R/=10)C++;C{"use strict";var Ln=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083],Un={};for(let r of Ln)Un[r]=!0;var g1="3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196",m1="2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642742746639193200305992181741359662904357290033429526059563073813232862794349076323382988075319525101901",d1=["-253631954333118718762629409109262279926288908775918712466601196032/39970093576053625963957478139049824030906352922262642968060706375","0","24553090145869607172412918483124184864289170814122579923404694986469653261608528681589949629750677407356463601998534945057511664951799678336/35422621391945757431676178435630229283255250779216421054188228659061954317501699707236864189383591478024245495110561124597124995986978302375","369017335340917140706044240090243368728616279239227943871048759140274862131699550043150713059889196223917527172547/335894053932612728969975338549993764554481173661218585876475837409922537622385232776657791604345125227005476864000","24606853025626737903121303930100462245506322607985779603220820323211395607931699126390918477501325805513849611930008427268176602460462988972957593458726734897129954728102144/17750092415977639787139561330326170936321452137635322313122938207611787444311735251389066106937796085669460151963285086542745859461943369606018450213014148175716400146484375","399073568781976806715759409052286641738926636328983929439450824555613704676637191564699164303012247386095942144825603522401740680808466858044/247958349743620302021733249049411604982786755454514947379317600613433680222511897950658049325685140346169718465773927872179874971908848116625","1468102989495846944084741146947295378041808701256909016224309866143294556551407470861354311593351276612463858816796714569499021375899793849136855085849133702029337910502448189055357182595424959360/819363879309286303497217527375463120404739098260200279520788950777458900438307356738082930586032462601215802636320993648007907724899611296693997216938989854861043298494990214825163523387600982777","5896704855274661767824574093605344871722790278354431422729640950821239030785642943033153793245906863203822369276271050164634206965056233097479117980782641839669/3030306850569309344013726745100070601277982132543905537366562638553198167007159067544789592089960911065181606283478843359856123992707598685058297067179343872000","76631772943534985713873427262830314617912556928476573358548256872141516989538374761909611879922349479420014771499018155447198112155515453671128814488139633810493264352294560043912066253026059140653027326566801398784/36852092933388988649396042883218509607503204211148493545892849595498822817623842579026942621098851631842754395231561679671400197056377380063233740202370686144673585955581403046886083948450136247134308381940165804875","3159076083816399509754948610929467278257473888282947311280653574634802580912280940686954763313882823327077171624015737719617373932318151594325834524000275847475866299387913048/1437757485694188822758304467756419845842037623148461107362957994816554782989250555362514354661961482939226272309026092009962414616417412938087494467254146002233028411865234375","22266067259907364984531611601870291368272674573653403965630628996687370994139884833897773468149149664829922302484782423514167405397665098388400450149078982462318781750661005833037235183394221496186539779712428265837926417581952/9670030144664428565128962309657100138096047028794689249320859276197340398920725569428532293373676415359965773460364494998334259893079003125373872108770534788283842907318071170285038777091588292539102269617376180390982915567375","14604654564989239958569331443385369522850975185358647132770022716433280072271007767111036877803328768910274400515590151934676819262085211828028638417329558229123989556376108454497813055/6090614019162516693013973409650613208227889078878781039105047015752493519149314227721984436973374032279421344818329285207124280297611253861173835238379831004010748379874393292231671808","1901241885407696031217292877862925220917660047127261026827869027159993239567933534052663335498281439239753018507182016153657409777749792228538380379703411298411623469292891476969894084838876001545818141543890273256985768690847587711270930688/765116019778838839812655402103512685695769161212360553099732689795578904762091216998790589926057819838537805856579109910198553330075924857419395160755642371550113347465300208422126945265887065434116781678702741657275181694851670325469434625","139459806786604751793737926146840623607010208216289543036026206208962059593900745886202214788747453279179283344350478734275973878932538430194363355795823581315329311220701640235653288975569812161436/54371368534412517053056101353618694718215711767266376573138772968257303578467926450212293233332401067673270853953399269852376592855992724934941173346260129257754416412476202526978443681584633116375","1045669091124493070709683241190022970908640501171378776604126771144008324358233819560649021940145166254659028524319517244711645162132513416238958170819347361185944945680269442845829390112062101255500836072082817820950448463314034677353723256969344/396228259004446234921310936915931611736815598535963504660076315228798989932959459406702091180060429080345146735173591749448509810270759531977278642135591672189002006272326131885315743181289970885337574780897529347356567086535505950450897216796875","9912919238915437302006264477931031611447467070103973106567538528951878797932559935860738745374437522819124347510590800370471910492338584284092534264608801221235029062881964101996762011296996851893455828946521/3660537472668264151218961634689665210933936249986285290553357254224360417386515311493310199319523687171757653216994741150377508234317025158302057758196429623723072084157928224798322861732880034847243894784000","9263710175433181746575186369318246002919895649622127410824041370079225200282403368319370743363303164313395723904510539050157032684710468364067204876434546848634842333436957245275217583248805993142227630297924119330553308466662488683624783307023014909360640/3341177182697517248552428837661919299725031035849865632511882688786226888137634168024976033652753689210700218163621739078534353578510364301481093730054725078138658805025014615651043313990684347632166030359086885561104034510990826655289288319840595753002771","5116082230713622171832327542439052727465114322479570603905499496221224653983960598946033081212909066917137546065542953865612718836914393275681318667667521726785633638189373998191090501201427906618075889744489190209584/1805752553736060443820406101277706970767657006346276183748749630179442318063568286372320188433843729960294965366346522303898609655762491623098453269916163621089005711823488749297418113474056676109581110715068124438875","246569125619713282434448566970352231845414317018379160824176638351574938993535464763890962336882760882398479702237564384291290459961036068916857265499633061660562532011248501476114401629839742058389195725393702000011860799793778295606988057303225493814005789533570432/85307063020836305797178273029353623060860009152114361453434032434699636078115114412588719432277441055049132559782203988387794711585368296817222565434951256788867244687081233632650953850383220864394261763844194948389861147622944651546912394593164406926489862036343375","133672026303452911046163998480860917119290576658330909785707604886881155606725822685088929236266583416708668502760907677019598002175122453170574729028452721476464728566191464897928696630979863154661704374206171469014225143/45398130975270785045482567762871405072140548998125471025451666500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","6041693953360002800224091673336562508913199995987479264605216252220579740134601435770085920869376641180763419907442721705887169884230643795126568815123647603047739799302562095542459344811429882053086550900803768964612193941424128649976704727183797495759082741166938351872/2016766992122395667828553277997478570503475626107286343497917705446132017125079612756035254750822860815515899557855166824523851779156336235294914777307802256439645525835223691751931866188957324792276149549076500784191791380803500156776088683900346065830066370370083309875","705868391597244582764749229356331441978820024796066870551110486625729826111158236686696326058778874201639006234449557592353247542995871491078308187261304930042019640830629526023972693107193897009168955674240659026247094657679060/231848642748474339277532000336338632910990823562381469441716922006107433404523316252618490265927265734670539384485699132080062215196462178933963957679882342083893417545858074378754089719547920901917516016346211301054206383643383","101832160604157943093944673541651013907278188571533075311673249923948856034633446617630054761681006062910980371900782781226979391765818325065031889334563981235894369036439929651260587335544056975715076598739977065390678221999918899003881778449092038750712969437519295878491018112/32944277910571666002449086492515464541550138004002141571670657643770713783329063548790202120805341989608877739811787937782240802963962520261844114327432160788193314874913687387269408387417806176202979244637915812905426565263196954203487934225589622864145960079736633434831996625","10655703119271468913597640479490594180964700448340778168715956712130636958373270202484276402718566314881119559090842449610957974112230306343486091910217340665146602598568991520563987490686996746558858366002301982443029430290679385551/3398412687366638541233365137084722368200311117891192348532156645374786104142009695796409107380345795998400850838706661851176885183144928701608654514812261697598380070746520197171576610572921007069104300695592751543563472456384512000","1903039332876763837419920240543738799531131775028971323439870868730321221615515008394327723508670975623498588291298064320786970626232668956372004004897872810230178526101184611242511193415796638694370503100219710864543168952682617801833318493436174387568067811938490953495819438108686336/598806534367503338307287246320963280558134937382149405305466709787179429317914803617527827862441615350396864359976273212272586892074799651088317544101755361439294687323233086696182687664637422796995789967075271448560870681210580691574924544896656175563265378514188341796398162841796875","525573915563826130963525826191411949262846916750432019596028344808298471293378917508549164993368392834023782480702893643486699787870059946429810070222126260200026332874480239090370088123833491499400991181659445914352500247596757005142623368/163278727324937389095822405034435687776345799835442022795533783889356344755225815267819508608559076191292900367982490827396869405536484846115955581043091229202052407483776587687967125885665493681707461345895999542381476164157058393971431375","9263815657177858787273494705338516861045771674838057329170239610953039987023429736752079544014780707408666628475997291124805562998227296677616204140605356257712022384368492575381355563976330347792504605666631512343447560301417325154003481040250148561839861837778597346623630046623751094400/2843321709948499955095590862256744532227698001408929142548057792217790532624003190447363578048562448168721539177458065482170148482375585867230123873178100117094533143052886527452665480614620123764036974180917207421482431983407742154634391264619615289225747664532332469783301704643254076601","407959339726114455622180187758753007349209016396248763075759257357925636039752474207685682218422721827857994768023399625060206708378433960993946156803948655098667156937949174400873748557248801874735834957795040139401560494087476967548060208243867/123780218751812156744401121690996305978134694678934447237402511116731459214498784497436358160964198336874043702652746834763131444030185151143987331404604087778514863973633941401826334750268416015224906056576641018962863645043976537664227639296000","2547676391598917379516698439971914695230548782904479778605691338364453606537643088857116141939170899135026552016969320061900926954008522781162186995856580955090548471448276736878300717869625651893741316530109438876067419826217901657017506157997588944233677467357220316084583383623602865379325184/764562034757392298786420374672266498815021229519853724850874576419885380830752931701831256959159800764672605004880389358601658343203513177084389490286723240185146570925957286083025676875197029662038213216541352875570101363668917766225709569356861275434470568767077844675593176178611021135573625","186545352286463730559933346565311535598243666022232037054735807289501173444103692309735768703898330430135399033529355360391658728987379385732098960609744313878477967971557204207043802935782878745271859468248704012618254203101767841517569443555143252/55399179641621656233589820996143825959365789093262978988289445625153099592463372579496245442338653053662134699646413817866770218574795378644415019944304868289119443774932782235638737888469746745621382139263856603239588594078668393194675445556640625","664884440164786473344854955309049113269357314957985265728106924238588705533437169796551912202931185746193155801905841712503407258166135075966280435780812714252670362202091663287095423712596462690753468682634261029392794173636943978404002804413009590005984736612421172979101972556772005594499779860608/195485517776407145286424460448995460754674039560651791192647586550615878988380153730602665795647187884543361218962125172808792176382956599256188706636727418572541254480798303566840010217729386905041217793614214518363859058348249961790104618910877813067510758225302884815410347238200133693756493703875","2614957283934314904315471338485451166053664494383241929385424599389309215073267052860464009981063483440201193771607520572077231889699858482582363845275452280606276949653970992719332472370351170732899676316967244504534154616036371979031399425846100527685/761493664432749089312665480773496290658029971027686543404885407644062485746072719559288231362060149626237939029641098328278650939665665969011529293869562636656650999759724704272743235210867676873525147820749560155294022488994426729939894753293900972032","124843380518493746761140367283007507854364503961156704095198010255465940085534099747297600085903814014415830785663764373057896014399822131175202342399536439284123918855893825207202244831315575594886675813256448846863723093240955901916229136393454605455444105444987028391748121054399538064686074523506176/36022228212051654395480210378626648518430280334458144892889271272122662467638331091863215146548048144675657239846337165813938424387499358852301016926312083940212100001220180762189978024821166744964908871443681332664798940660421469519997746775275873085770018269706847741064037876137315001228315806659875","827992369063043155578730871896750570951766628472810506926098505028264552046829097082095665194000002802661600196840639204300804225352337632259980703832713031790922485730615305441309917696044954289187837653933158950774246017223571461858939407386087081525130831392/236805932823686534991153393869288530368011574665859226704279685567723830696754821658770176385138917722808377962346690757191122309876922069867472518117628639913077442806147910884267694879089753138429767401700283014143248445966474839193628309668702223994071394625","17347276886878323736540051321582548724378497839789943634071026331001588645519865992773157565595886250230140452154269197770615097377486013097979087647774513500701793885978192218455687078883766086309728287172567466406449372659680040183273634701092561727514713494914793425407149186041796935055187281744386432/4919325621804683623339606849970832094714371903709195539440424738973575902329797546592497378000858196173718145883783709223158260700365224756081275272021856393735663399552166737690038832550853145831185979094979556715294990257315369124065787473707136464772247917156232366320267601622617803514003753662109375","137984231830526866236186357461458917020538108058615632801298091031540729111527734872044790487396302545910108285921421417358113055522725197998483383380192391312304647004240060970929072498293210057120617332323445379424867965764749534125081131327565507524502163460761/38810445792642817561168950890315210470940006613819790543653745327778579787694809782601777514116858514049585074667085399925278459138508514838268321349069481334967221455722811414399738756151414906092225265355449011152267068726417045644222323488445626292574879744000","746567120547823334914136339633766098626636643449144032626270358619125402826113269699709721071135471625588981126637674402048519990010499180844665151971356149292818375448504122545400227696621572263621729512461528550588108384619064912224884465737417596190735966915167530332762203074440688676123756162572829692160/208334337057923929636884170505570363171441147899816815785150954417598643614152856767186132467069365605496210036171429712485182162940460120834349006784956522600679357307849981862006710239311750261522832996877712350330290831638640913932265004107623954913155144975252743257846945609734368518424172846119306643431","64649371728330695076928013661001819989330953381731372450140483779536126948957993261299287753791770622512248630224724990234903928056275080682537641377393210728546364176267034339221558641084730052304770498929958838997239635790469536857863963589118888238069738647239076/17903951498200212327802847425913723358452100686246224008745414214690047078122925247086521362329833307849817944645647750649290248110509395628305970523384831671737569872597295947593410067364379687588919135621621162007748635920864926867870502568935739725312687094047375","2454918942158003099688922026016393688092399295166304634317616773083386087532869193458590448918958337530406410803840837646465522656670050113548208618655070231274778592766244282964463702354872753657766121825196898916725498553882689210280080206627916046484942827487726300822318764058084323314109595329304407466188383616/674880185931325925966586583820010578979699141814417326552629206140252348822939845006845669570885271576698771404162512001549922909048916000017837898649100825976232784446638776021483802989797501705685620612986771521390439936066527738682396560462899753657942715306792783283782238662155922082005591512296007820682995125","74018558041066162916454010680594042518462756234254788158141115244349044958441521749277686851928706433556285971088455226217644009628399441967508838553345152310730562224910795446341601049647392069373970101491741830623078126344928804029524181578945586663110848142571149861/20204153620006780689923328634586091101021423979622170579036140596085566172775051595588438592742563923428900864000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","2127032036758045513335690185608563023954009095206088224487365541995326714285119384743928987635752931664240752323937321097955456543854943206092931247498833001499955456190701695430459583885125382086777607021670447795321669948733328973350279846928613949120929250312666393359442423066212311060931469017737106028339882830848/576612418511902928757340062840968526862381326698309578771238715462180282212422302261044980131594522407066369222998903808960617461164985318633518680304995784614308979881735537678182134128319596636920719106506829571072447362052319438091347699720147003209417806230149598345068078717948025207635448205253184540936478445125","35289653975561083576641954928762116897061274899517309102784750384002335187117263273488751066569234386120759866204372398611196356888479036949053282301027789530999737306501029700128744408015642211359442183943916106790666114870974212159410284751571905275610921784716184508440/9503006066880728386808143045924119024212377150217533250562188228062174064693375135306438120385877320162710918716613546077156389583384656340709638430674364232343609717735574035535102953482366914421205216675248471695111720986346092738728929878538430662191272737183832556131","102633551023964794485575491065909467125458972250222581133681080524371507544152979467328048718122409841060527545925136196267751819689935599599321090571687632103850847605493223603751038996548520557330016046032671961857623066292962260173840972332108111505971231021442896036760967107060309991355545554631003681544611731245475968/27459658121882266328752886605529964804078316737648012166874496015808620265471203512606463219297059547428855195782384236337998738233668399173746663289852416697917397644234441300570212555870401420579737973722145663287124151049692290432756231390864184491891697469874600345958989433125942336757049639797225309327019275689074625","10034393558388390065766795008210457368713365491566387292163814915435906649268119060550511145023450790393353937124495488860451123302412204483570913557762460385297770427946219119911920640306914453207097103853766023934602534502476962159682750262143380527529536498215384467975023/2667919902603322771586358077760621955455470781865624844984169443739075976572061827709528710108877015489050369589117491611045518221354793418884447632063538994046714401229510497599783726376490260140723032102883617341970952663947646017489439179953454964374887388652792446976000","248528145263843375390386172800048509380966183384567983242213959113927668429802237067505890436957693495616107089384741585283620097982859345081736730899912519273262934785992235852866637878831878448348444611412764161078458068549719800733237024285525816723480868704742804077255242682077291713092790250511567621735004237450946304/65676865669148624809340872151906045781446981664561196686217551358486802274698228825404698950974939545099727242259547145392352658637333562345477931951890984276718673618736565926663528625796412420753961231404680876558659735251469326707567479071881966875336951133475135427640218972722939427821842173216282390058040618896484375","7805448718805635696495809414501206964843262114470109146341305656318015059743127114324245035489577134938579856003956861881125856595981500593426840968087618241785931128978516340812066502964561231235073012672356530509663384739132686548934288703179479011016719045530855033205271548/2050525178024039744126592505352202216905491833360272553169520915020715464206141942151086176509423406413311520838568324134077402841030113427309725873344806030836314500267104070131451720947531994814710189000076651895520222646974590481497382830325485174899169093049299764813276375","3355325071293197839434119105039673324264765809771192815982246040415580387729382404624613875653005261578877047405365032178619450963731719777167015959920645055600439987161800547901539269321100559393048973255388860193948274255340335876890491746900991668165565729269698196233805991206691196045182214641935483083662356666996922240/876402579119117579582569839757462461050855174353108858954282915644790659429341853404829661899850841645529640454766173209897510988090318303454542547519850473808789222552969933222203420847859171250332350076509996295844203965564448154484566493395403967626596213792922784509892086361572955175655987334882030766001799867659814117","218871061991045868372866381545267589365410350294028138778572466235486397478028823720846191998825628156716190463263492304639890659254282445466806224943413446008645087186307985343574807361972238230520975439736199291019544576443791916302825193643774360055545186783819367378492631806297/56849560726416896431557940314760680962653658127458002233782028041537121216487790008085876994020812492987733987414743604239935223783349870516284048368761617736127892160849065895223288023531930411718807065209903593668117085505482007061969339237404945180379460053180570404846043136000","5008685108365226931582937964451700746853986170633433728409171904803795018146152804690759530990140552460596075588463394200510044617816085275660078502126507209302951286606953039953843685800941558212440519542602092919776366067720586295390886070120828199562643208637974347390938772070049344991272621102622931576339988103674070876518912/1293888539680354282541277646947380627241979967611883341823378331667976045287311988103163380651334828012840330710760757271860219584371109472132211215957402251594055009937397184768184517621978947384029376766290498101728971145633139541827544539988344772578184316843734267915665730981857376872622787627370859411909330227080697966353375","15388340113525711660227566446101909585796746979396093776960989868457211684028149502578116456785221720682202816140911944661051001675127262774824593420825587319436537346311831003212424497488485098543512314062112948777572038731823948224734505930748371522309451168088057190162878224801232/3954220582960831691377435160890656173654063611768428458807273708040518769541211737927975894584024448193835165167801976423275767590502552964407494549049777006346189436817215329891530811451811864579644894987864267389290848598289794977382504890216219362031324635609053075313568115234375","5099039333987561374222193551155323470675617979816941646196895589439391685938046865391119484510329634015275893520725135141878751153360264368353595348921951280561029028912953500944814771064409611917475818956659775131751121312316084465321917769679881052144364834485866477379437705913911371481828140817759401117780199246301705600020671104/1303503600297679371136943454060319958680553228879031326679449263682048703103464872914972900105569835004878963701599765030590097739639045890060548760692125546754294514068052902543220382104483822438283040090444827980927544440984823535260277595466339403795403200720622852069244768910603820007632395190204569927612348189089161551951106625","4902837141334073026145827027361937996261324349722726869116185158777439337041263482852376194988371853413467559557923410949898048139830183335197992754748294810838187068126867611615800383834975563313220497573778480109264178673389149671194149749735833378557143135481387904961537942569904075/1247045310545991266291285730016853118981099516935251861146038369985109288084420528171217942065832292739130145780833406014673689119563698528225048800794718789218267628507713621235056538202070171596177775095071513194885568843375526804796016261173388452184505503341132236719484809714335744","38114743522716832107917466438257616720476488812538316101658139632867788464381862291240727309611460187159930652186486096300862388591521625093237019662273764387591494074792574929490381910446287947994150655077877204446864004067956087975012773988833339521775463977233068498404144221045837190392670308437391686081418318624745039402145439223552/9647001083383999453668111809775451078976046488746916070976218645431946648087171586252172936600115032316383427265217993193444199863138429602138841976586190525451324093772097241349417938578878934577091671046050326087898259692917931230974174799815198493279413438192301437068820185757869608523761456160341754512329264442115351926967120404125","573695055225225727008803730767518906490704995929177617646275646884555707960986625481944101622708415415988844740028718027554452662358957933526173824325955904005404113684003841990198157072540659184995738719040024647370869010473254071681533880576462368600901824622431045529064651675640055917092/144509482511118816399089096021290587489594541280398871255876563615464628718527634679330291741479135415168539765887291789615790513527330600394937614433502341116068305347468133950204152174094704092402978083370792135432486240914953928188835819767755172666693219213868545854371103120604946200875","23876960329653589647925126180903391687666378233201794403339630995420215267415575142266707357255726330536094448314199602616026935251126469221925945960901748679919435908556550271504767784553484434363646489174587463466333864577705745452492395785557425904735048180164697040313528831173448025400634629163795223739061661461986923675833880378496/5986312408594306954013526197465608559068621248896320652512228238115589875514604632230098997609482248000888567135685167138762172475788060284232459813998201719590208742091697294562538265829954186149162974972471533202880368317237508987477069872431064075005305838801862900501819963793062041081601844759452202282545840716920793056488037109375","58168289917567723171226992383559866214094157894992327555495441698028867727845766488121900626912848698952863438654895252811583144479300382761129433911280049009362667380001406579175563745824368613319103673817094498117944856004415812877213722455299491145649879676787079744410765053845551958756701/14517067289347903655500020160671113450349743650636953726251191692074385521975132268313263723831804150872238173602847065423463131917373356798750100313145228608894881457107689499956903046984443545789053438946050974567665049237414588435796381674590098629779384355275820782532479708807512981504000","728621890568281859295409481422447012528302594365693410763821707074444799793690738137592101239862736313347273167450056625929591960610208335290882047413011571781161008296084630072829079783328937418641417642857196346026366370059522990813537731394823630207433267854616768658990289454635793326766697884798538576055949457122067828153655416688640/181030730759516991863708593747964787874073354051675597050399087612142539517308720603687322924426591889179726492403913356461908748733972707460063017057809060190437917851790767968877215795679844983288935075688219234885360839984681619084834228226744165610073685719017596630302462070188937998558312507638434329299017584329479516410907786681093","86855946923438322218622470067224691860808273886184997065663554841573982963995340977083049132518812923329423480393306918856650577072525633920456721265953575424233701929892019410099166322511413146891121248381648145391642571638857576890568882512129960291171866772665863159474602604647289052079991768/21485753507365901947528588896402264670781310878547726104482740647554738151100954835784115119035980523529677083504495839730499664052882400915208251594384038810917282207449860876251558307288700200910747338758723324686939379138206117634546981163355060740270734146780942696291669461182599512320099625","2158989152301022938148680102142188531448821359505188055264665167313418619665693092337665573150374231484840948447637297247277576415460889296724813940128955070240137590073233263168835678714131062764247434144994737610229909964847568491446606012581370840699582055341626266533733744293929658949697805855362114229666626620766245630122333733703618176/531794915405164005613733454597931482878479882704956110685223892325074211694837836221759995948610212818642789132749082430059593652854659130217225506942675608692701447738732031302987802196501895840510235161825501235133794449421919927396142470196961877376701957829921152848178076410141813926924749057304222282687697297216661687583257901415465125","139432548574396829074586704387656697097760057897628994548358619815052936481650396157428747411173567801047221928593253479330480454469358220685854351236980383914223693722868233819483137401339800304943891968050399345430243790898955416907228948287367356990263740207046902209563417267686591994743547621/34201151688775214071963206765436083445901621442002061707492082843232231754829227303539041286301398668437202547003300396162741375435703188500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","11008517174872833286150985180322584448162884832099344969609291070844193524816852920942383850580217443209402836100467940651581092350600329145627967515818684442171571156446321228596914355704205623857871497315955269266498229823278800717909321269179839084452384509142712677235552103459737790674103994445173074670347080506698168482564009465276165824768/2689223396936080856855299215659204161946704205931885125148201643087176556822542895325191478283706585400237901215485150928036895428721912118467760766508162631903585126377676412573187912443878232521444786090510891599171741773242011017926658231638022943018461086517502584854390836347781674626615709751386455292026775663545470794167629144456268750125","16108638074211260588800537540680707641986073914251424878121255234668558067988171568946079848860335948991834525552515669040163026131919804987340113244760738846884911038097907756220945883750502673899084880578229601870882631165510396775126850307838505063922101682333806284668762825609556049426829531780/3919363961344261777100658318137884299575193089462944554282218278496298610828757650104922583359642384253066896538203596057302203635134833545580869871333892935330950583664400555463557735723364497947986885146043017010159347046389604172186788902608216894094289769850517098027486468084407618748895626853","34420755849180279597302103726180110022640946692592540634353734157479505420320000324260530767186132260970572450489530034440214259559325114511265075416512316229177952140217732655405289808326341696986755141965043719344169685611217958619102774617224847284122901023774956887687026904767714958090256282893003000752947427857703259704682455375442735857024/8342030311716679826889917494957593165464748884572298173556257652389845294530325764837124998293398445804458613956489096007564811101361266196542129764287084823604897187311540561857741285793447174119667215803837719660675298308873496219385226998078648428368061868944322478384684509466965129972030932418920415308276430355882329457342937549162000252625","345888075261020004071220843714060353763382280664960929903544964118831237876694384053904571498830068831026644303797377762345709976595360421502594656308937649239978525713471393570536680412814805076323426256584504251728507416368609420882442293831684681071553766603478479006495757222912500012444787804577811/83505703731469734628961395063481893801938371516752417759131774530720075262459158384433785006689548434701904106312038822969658455364219435022841597243178757423598248565463985786213156556523685666430799283870548238467817226915680747412191245046634279766450629886904716776719219698922088211154187845632000","1061717830619177527082296723099890392273896386613997004874669053445943252046748251883532634529759169500795452576392700472771365240996842610207274128102329096619028487369622001737128463631016494371635687841733644339636164570819431573829173533941056258744442930643735587780907310433371453992062647737259587563398111688659657406089003293576961475848704/255359631537215747979895955806995352799574790340218399351168178555478073997876110889483456972687438702262017800167048243754141722496276537685853311434069991222324039005160057724073156957530106623908696241268268096879569794431919729620178375212905203484165745866913773304319069321426245521467122472046370356725530914587807274074293673038482666015625","274122944106300296738399632684955400761495830361663966466225652918683099779465438024846903286816813856490888796372134557295699980528187779624865098445756013563535339056233912394908544185885547842235097677765325396255649207317018754967666450708249125316192200151505568416495274671679500594656671785202496/65687592621976546250581560102201535533608158256953087745856906437400149205693427285162333502528793675585022025602144243543064185647792948495372442630333800126269123531636800213405254045262127593759539706750242430153456891792533267948231185296091297979933562727112487057234422009426868531651634706262125","7842680480716516803148821198697967237136721860017131244266974996267074742248599085253569637183007740566941125452215834642683053334607896723447140851344501084122965014242091312411884985569341166545074688756440728922408743841592658677792796881188604773469108807869960161395759837407978596679911066586626885830991556090978327508459276025943279064965688960/1872528612245648675720382138045071131304652050696842872529163720558126655075937845539792108048310219395746259570506175902206215101518698490144716531697689534559827422735649881381597761684154409796315455445459537515308174919488497154409643876490472215352056502193150125644288086294418253309947229151074464928874881827227706992859640236086417889990541889","5300824422251242070074569186825929119848111723012841627275830216301188228660779008353049603527567784119877706984722171178137272986345560485784907345500893648715341273841147320288851034078863843374665850852481747000237834238703248634174397792745914847774297223176674917912406659831206869442510948965571661/1261140476013707338477604677428573831791396352814802149994640617701773078174882455512668089072441176857892331468691160991310474734143842336092636848492066592397892638052212250229129355009939118431643425836944282456647571558383755315238500832868535816144280088644939696339160092963629012001958205063168000","2220223718762215584659309059880106334425515875615107369399767892051551634000614327272260081056973863669004224981561870246078120862256383581012183852291444462730018546753183156982897386563561418424093883164027305254176874653780425452987066512563140531367766900610414277825262239199580925879453806414860409441845631158680721091621460775043562065815179617536/526383206607841251253861841374779803798480623722760367843070466043030228662340154304405180907941079883976168609082254331465595267209149963786388600028701073430773581228212441424400748220833542964971495005714483235359479470452593264280645360131482713147116366500300066771223383007216182988263355451923333319170174755334598973202740108032097242475554128875","521891797109626296684891455959263713257353500867652268541535940159815152120871142196535233326890353914761242025931373491906127275561002910157909306979093246574207104081108188995072105948138299097848175016082947174156278439986705241571619793059501724269644447572323501261424770743329858038040685313621446524/123310256826873923765604825413207481739886340225713108649758575106598510022338480189649787216845041382860899099250547657534972156328080736149239332330143771138115695598493059325064119176038137294863053148618656356436332991079150723235214278848602671333076219529535123842212129829931654967367649078369140625","66086044538329677372986118727999622900471937619891337714357792768200341519193500393739322894033303245376225584865369486696276607060432449792893028061817203932068085863800494054274423512956136695211796751845295921015953538329385253280866669403169919614982155350899648626481405781514434761541281229159396787287553493046927448595964103589100429722948913403008/15562137339474350565671240515273666798063901504051979980452491653975250630723677279081058884163396938548780856293034775459223871281049026140999055923743471466471830572672766633086347312178711643724485955576579988182546105048041649947277672869613992334541438784737993706482731696809943027528882927942967419447250586964258807454003775693567366165507144866375","335377615394100148751647837967017467711612297170079949298328061159559939969228226474615711044891085626519877634842694983669611974807129333052471799687426665556738316626171408219730853872410792831871526174987402129691897433888027072807302411474690613948951673562473758814664346259109886876538510453475290967835/78715592752271462306588358880337347638000605031000575876214116610339827495261512281635361568951675037834544811575026718101166562072917855004822606752296233435017284127594847656529606648345533195437635894948829857913798336356647286032372695130461573940500785137424365840081503133157308796505622439791698116608","20090879701618729602554170716780970848925039917987945471322994867171660307998603515745066411687983450400412739285577269751603921163835619296822801840348319742203974023505186187060251544248644338412667631232247108675504629538319425769464277309915502144443973397371136256151336255138506001292355330875114245901820438821732843540725116728866301271466614762497024/4700223519410528857298732096729483544820841497820611795617923063440946097326817340637303431283005509904481323205480729806879570430868897342398783028649633951362398196137429076844504529051072393709154483678349272930361110568616112723747726853614661953537957117231900032044221535502745676310313569997665352252492568100075191900969170979460298189170486601502625","2904778979985524171206573028445379872240558084236464200857594814631031581387804621371822074061289363372523364167184697785570324832815972970658633551879143187709707164796663015180877412717910872234647704536817108676736661804878068078543241390828229923424191204586313620612539678930999769543756218765870513049986792/677408099044823641581658869221044375312077929976719183424865834811543737800956896926637625166844372424044003929341361734886232742770909683021563822987505236295727478159938135467975522336774471915167606673489722102077041330652185811196423400701795791669780695158730756241178262962515917389382302757366325768069625","31270155809329751863885224732454397292230969002004953832354065319735530624996254695453061851449600345977646455072512400760539747054003851289540339425848681804190284451253462663731135337775088379954403740058084949675460445909826322297817535400604180338201322667139062500269285493417563095365899631360901732684124930296643108551710704785906431324876072470231424/7269578038000504017073007978844992319987411732848567116655821196644382777088703228960020894756722675887473977480537577509061256138261063926845643360849217556370868752909531088361229374467207196928745673402380473721018157327193509586295879051411183657185176812738231456253321187419224704301236205478184115996135940848503487199394612616742961108684539794921875","432538822079707760382094121020421735679118830363764570640789368235407853152380328891350816400541189148550353337874309885334920995713154225799660601389784410911658967499100610376065640785585342035058364676314084595283850213942576431310823836792440218271879354669291052589804956435743500204185107215929849054782893113/100246574739326291035824954677502591279343311051719151327066341370995390423713403739043396503785261917771859220535505691760472395306543276314938287868734009582906895763073519374099272340577921671298878837400921045252035507925021904954445172372479744465666760762909731237634082051855588025732494461939980856983552000","1914333673689206389116942789116917579088664511118582610293383428712902211612554212779880638065888518488492298586641997844141510832940409501694726851666478650414191249534733087933879981733561565249818572204932715347752949087800778646065986244657260832234479202201129845117955957242616947361016603702640821256099895469088229339240402478576285854783063612307200/442333801076281757298117784528962837115323835962460661601905131618341609371649347131724700192551574625400701487125984359494804828935577124602622582550626336986871791407398609915208114339012374456785705161994343348351473385887949809051796407340988735853810174589261300681030826392672282630613354461927208579993042968520650313621522933214063366558703422757071","5704691626402072213006354545292364761246893919997531024861408248746241619817955824682639582830486790618668221530365426203424888737658778881721063941495350237419723855000515747725926735319471480027293210991869255971365522170749568996651406002311020883635577590045650037569906001924971041810547543163363976464780729932/1314240362076792592671773873754757443276256223533339004339330559325754574023619698171225777585408160438834449576526997055649849875516310105297894855264038450585295422343454458568152668980131977005808840141079502436391909349182185596381509091427752151860204235071122788499996991078935216686010888734471173124487937875","451219364084386208718456142329444023337343409261545444643031014769484085278440612677813682892926852469540118625738238137458321112005189595703619178533263706811689687213128887082197330137502064260105387500552856851972124172206996205919556553246133218441769325133725631665593372188755090094541462474970525820334385058333756591222492801647110594428922046641945259392/103648250172203340865458115839764297558925693061798169434516001775068769911768281084188883278842546791612199025413573394167639925287068809631958006622842716869211374513136766899877504136929177267362862319748507372147243911522667591375015611312165464514308451222180272935398828092646393830572838772085366567154646425598388620105539619174837489536378605144891769625","1591076564577634575701791393842535460875733974464805197283632670013516183281542903377750304419996681222758401497321278555686661981435637461350320471258386388843198706277657208526372100698700615835733712519332548607115875288787602084336341594576426630670911478276101702119972195558314357975365863803265163991961173/364433108410193393847203348728981296285742202617988970384277162225847256295865554341611171460436362780497179090329831885853324392923449579538286804729856000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","5307507148709435807261229345132535134848030343901300324623409721698217134932866488937772986386501538026693956121121771089740095760486362654754229904633476234090792827930433598453200536551779789049352131005222659995845427680686677324963223653949277037520711609343166926627713758990384011274777087968799793410506391884872456420041494598273703914689586637995139580794368/1212244290381524115082005575105703496583315188540177702780216570265159923654197746388568151706509243638302707511238539845531608313334248788980188054651601536067740709977678222790481348003085034888244447626347312094586389347535167903408519024105748523384932942441843118813819781347089702286481924493361058339731949844620763272778960860509570622673048786968660129650125","3046577098843580578619955603029073328361298436129791931304665777036152915858575282362742008136721284817899542475666054101957899858138590963789072530710775790433466847100422875906866496318804986202089528198912098377828580031852152997907433335176267300286466072997014023120087988748396598176622765923059385876855303940720/693911859077752895978833241338902695755528613729508555938416419864772385336777924892434701804078893822446727762077537955240605927550548046309823051841326355655848406646248595628715185413852040295631448250459076043816328082561248420925930431777502622148019371383254316636979070731427737764160145097293260938978413488819","155310926743873343426312607182060072939030765297630534544899230213054714482456829198485999782086944271490229412707980997432528653509945301574794242118433868747172279224118534460563400440670015323324602117517342201640016853927923976796453577048995243600967202462466681112804476672348206491490513419336308575442086511015101999847896197546900512764233674747415844045184/35278162986589659300679088538176070649273991865663041616088851923111175518405117391134863644540911005782372831496121355954470744169969774540892096320978686548284501139861783292226140413769665461494668479430833892857992401391262903582109993838728281915806394747833588629467613308837196269424421131934859079260185052081536487462257809987002198437182539441349474426375","46729591025621874782758519074451728476386657576036360734358719976400940301493939192083339293779149127132651616972817165172116269307276487158069293114860391502484125554406945249728802484128756924044633825692779783425628292959170597009935305429239702926898931975023598456207165067568919757902764815108751735753431153581849/10585868084079030838651390738371141142245086465033459640458366146849314274285871375459898014414833295804139979016362796357043372316321872357817727821559232353993714062535883074661734509440994664726425399880995133711038483607773782532430879196405793694658185175583691180757783597895616920432527125993118171361116684288000","3736372348124144720852190769710129461145889011598636925228657393934132828633132357232883470466940330848177425542748100211498184494252714616379450272611850068867816250209867530921278645286769418080018709947826876461419654782341309127709703626401211996255743831998918894661053669189312375159058718767082163156988766821194002596331826150321864927832618126580509732359424/844176851007504003627016945212023239308348428094023437269532743221937069345682900884618378849283002998220513307273333096775669556093005637615012750733216460458689282791632437851364674879152695438589692227159038555722539345972833161146108367329370564838671791241431125003401861887477969954740544092178721327724620450947646209914621007186497081420384347438812255859375","1258774755828991281578968023382624723772927642002016270484090409043454336040857926581316994594109169123354553321469500848146015719851609220423736153365139804086413284787598253618361769125996755159571523632747129480387254164008968993734442164892486441152227433281625391753702577143985047832519062595123255569172968685060844/283659859661671181526547833415653453506477950678651675193210969173130116121017723360258249430884213011988678011357458727603413521688184521573094783291496368005697481333739504490647194454695504722542014845706216224432373442438242355188461951883454664693262684873988061018976711201351382163527093784753398257094429403691625","84932063355292829988908961192574710493098897148701473172754949846455626381329456661808566365329266898990829247446356970454502007127269708487563279536825277374133681167235811080298134899629580318813382668399644553111080625918213250223197440426147821225593304993621451053135332451997633132772608233430131400186571793929377129211228689703376067763625568623535588709576320/19089978133324852910950469658566458037096027722326716800113107848115231563787455584278193954518442601810776347091253561956877155673550458955562102935555510392954425196165785410319126098393353878286400877305164869548380670204577544630353859009177051698096136470072137579698473017257397949994722015089768745013713383769765609613514021200888647472804720456494757423299627","802638881530832431828249604040579750916118423833791608589560402449036920165704012070349537114920882938466635598602387718300074733476150548724726460209016834416094317724261857969955414000155807312852092720310159572547644569797512233899495300028159721348599816083166712365215075728968005941610056018023633235372936903015771583/179951197386119079732438617407921535065140503043429174394605652913879982486051627760652197484142547447000508189455126493868229565647284332735552462525598465192073558793335913005459266977086104359621022691931002488052727597513413492393525660272900161375677499228252863529934576881596384036401784035248649026076581302370304000","25208742399375362881099811032135575360109715964024747212026245529087599633280142314962581193303683759605084995818253124445773115574470717199218828756449187055537877478033129862600982068782249943150019637186466260707552416433010545437321814115233841687700051830170191107127799355485920046505591193770164750886037885397478191534797655616745528343172318318678405576430544896/5637713398995569614196397857525646325234056219513202928587580534159596897880731043336790273040813044077153051260989730372846713618900145444802234629922717464041261370803598799826604841654608724727320798324006129524610666235998113655193642594744544226880944882342204407750193512869672849910003246504052298022468012594459974209940607450480609190841893267203392880360823875","732332637178584560220688900268566130246820235956768724845747830959547501950765063982943061181526237061809052444110437930100210105274824607344902764184151030827266142225894655531497849161692760385938786736436977268616029862577293984376170905024712952813234949508186306774257035535805330366742322777611063402455261391021097128/163377988152179636922409938163005948596822656868040662831003991395905185823836089887990201522673196719628247106777881741843786365701135555917263285268753605514812568258179391272113405920369587922702002732667842511108732068683407168090725712401954314293193572654347237716691784386690948494003094992876867763698101043701171875","22391374854299462107923583267570593886002658786775211597896252879708753450794332301142909715845151746786016535157797023153041007263258732991465037648536702217273897876864351559736449481285518249846264600935543582562018874574655740660800634883403597181876364712521253650744197321080655028374602772696770227741610874399454362583980465225235674816785988164157351243193265401728/4983275997188967758382167867656806681565521964135131710678447245984239733544941881418957694612909599261843693554043504855207170782744518943778096768859337980470219783210191765678908537645270392500777411134164918803949155037581108678968701961544979451081836872425574123683574475790997414488641534074873248802450108535183413970057319247033379016606809226547805269752123746375","21252344995592269775107236774689012760750850598567799560343535731251766780016530978663079386453430272698006977668063208502408607227544322945446079708000304179073184745623740466334127867464883762843346619853325415963062181018736410570113171387891518398846617197097407612852037905687899800932343156979591740310928257766081697645/4718515378484509142377558412184183991357747235892194234377932213613746008373918923611236346330189287336493794499188640380975364991548794341177060325509698404571318037298112293926833877103554546466055612498927474225619680186119313129604319096374924037870803554153458104225741255753314955115645304948564151765516183663634546688","76703085666560609319365659209445044957052359500745196718269665234646121134787807938680787341023203786904308047981099228357850016602203539979246579454229078497537148799349353250167621935384193502383187510928609818011142642954550330069991570983902841318203794113898871515702445720207144863877026526025447819537396146822201819435536435835285098485990260677737192230985069824/16989892821104122916312992616665764943723222199277412857053896319814438961475117951904867066845412639236790762432996309717924037467863024360211163971190006272168845197000304328480920483651558672879967350982199768255256753110375467976246339260326422891913564151453729285191351273342206198366624882195135056176502724912849575385576554208844814085228696838834665339811027625","40153831166521391225489894857551838468150576827129133168972859441122728710165233865309084872159583787083130713473702296122465319276461991457173085312407612757280915853584698420083436946976844240063731333638150599017886937783470942007376523947840104246927580254612991191040951001539641947153847776050138532219595746056076776809812/8873576113581065493273519627544307418139908640325227196912114520903505426722086265723900326735989771660987609604507503750212298754414472822477243293638486047313990878348820573874809636084574108909615044524663712495422565151340037564156235745628465172219286664653343193162657374410926171153516871765680561505768223660055617934625","200736374277835272485186523480177159453030082779872429648449412313247640312479214261681899286513818912991945046297334418102711629933437654377760028476767482162031641781499114859553677502002901248124750539270235098492377826240319766677856465093871367817683734079621359186477306173620331748496369122143019303740252461824523590096923561928354020960176605008889579578495073283712/44259440065125442964014453739391594153290923937737136823355312892557975399035370631521014554980129291582486968083228888083079118116286312583989433037097397252506140224404130371160608365777625538148303917306340620019882928744151294738308047800711028158277500317134537540772759486365658024194428796846364486187105343266398338060080611643110071184992193593643605709075927734375","488459049325494693259159444507437983381645757291858092983371672334043029615965882574409808932509285079401239403272414271652617474184321852388397021836909585659327974611273820676128650810907598106588433939541654215766888212287311943387232664417347883717203611092450971786083806323404432266197250919880225892099146722474124874256523/107455855466267410923480140898552598306699341366032095904938430084768624148829473848763761936703072253841751966906142283640379336131083461646777390874405323298406517250231389493084918065243079819898691146841695350589992171102939046740169198394671965069747042621265775948217054519855346617967866614303497258042439052681849864192000","8430374068596413768975326329313648683222744787097373111477788794692418932056901235174019333392845529821722488982447683794746518712070635063397464904489452840169472596494433874412726723065560358405027764015273789053064830528919091414531400589850704395887250756457780868677553068164933299802944396576360356896758745030955907258232257358056931680617626606715393885378887657377280/1850480358582748412767893656294669486390769246349349706200869446679212812264400876685764762211659843658541567071977813110496329850010288179702589501255367345935389050373021591572539260951149696801665953123597521983257852207280970577287472932167362521740230973547070264273850381896786822127290397075758780174083415923482640313277341120938690594859118603017930500014640169211239","58273615882491925540881784328370957720539797010816130007322211512070634295154626813477498607761260613353633996451797686143131893884559909668805628269959901044961666535533876340116728982072626875010391195372759135469446048394835148654407846242721443845351855234347422256700864370273092971804207514736924787577569355949601385705517152/12763172138328432984573837529764902730448666594097466544652830703737195804747682450548488162227364538052585484418491914323658215406327363805353540266048943197822838925184942600367647278764952826664684839953902567694832690683467635727409976388280092262839126779730168889686628630302519063225007497707028600865624133968363921915016625","2685278694947152969468407055109959900160804835228466214479525891103128459065131221736713585038130737099067040196326815283171857977706979990467444622550497565521863441617001097354649972660183038850033950647594754644997436624623325003537308428828750008305464174443210079059253920383411910911594636045517662796811001285984447671371943267419151220518726940455756833040934506414133888/586864816044968996825907488721678304211296267371936463272955488077666796280028127333229453342355554450708284934221461946991556216095213627059047984199091625921432110913096253352065238765240063555347292393427726758010888546427415276046238297382474708612526770055488323003698641493939145624184943388159614111350839555141202024991876221874110644879676602924730506882384603409121625","27700345710264347957758638741952394530538598225904772664391173119594616680996031886665218221392453628824570256438960349220263575741495285780845399187013582169907518462437966962923592601721119258663490655013419675469864809004562272799012227293974254329929404036071055528766397079743200179924243479370594973626764330855493789112414191/6040997839051213541001279276287478343874107660287651711609067205111574718442229224212245187655300348484144001298428958025052162253854676210451657425437588244676589965820312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","80160269787574270953020489212619791839643207793889009503234879683494928396231769167082355143564723274576166638869430572977442020236299319718643894871736539109822173538266278165276591962215927816541165548699380129014840956895931285215480350321259054359835472320394089646764361802445068798451796525897304221529850133401768027469126408090577121172238802281079916258951770135485696/17444957084936455555074876721808241311651668802091828589911310253709517226715880722948267977560381436307152342821304525073651379763144281678911047276389231713860392794975453518107055568765009486973017341479560154792340888780337029481646046233967923289468141293699236815196553819373828280398488966665994092877680860643266914861837639322607761804740256920429518434353839878280875","2352816897072623416220002134476921108405735955266703519252095150412419264317091785317803024028565851487861978477208755211589867803009700996828082850796103789009194767813611798769297617674631277847910238088040257037678126316866517601388289837575778165301828137259948173292658462765645645868094197736382683775415645307647043205988394700/510973411316690313485681833991645423802776865720580280058344111363363091616558230182669376841383375321912553771027107891991318313938505988903735114191313214327683449514676737796942389784957658395806951715454372568523597420866050825822028817422805046287798054682484158011143949412956697442991898914560191411624040490122951328364833797","6403295584873165688372907494046202150046769667837790834896334486679541887567517050446119511695248926941383207478170182650927368177009669717288184903306689332746127845953193587519575304974203099873732502605739219028995266139383163062837007982999189114810534856227848568800302527760100163350814120545587074865568436789021082619398126713943637898657861949091545516403987546145915409024/1387794272010111535893205703999712437783041553900341112488641528986385462810448493444968969845352401058333929711237978223214186693177251566069419805757440174840170213159651962686467523533938145629444468366235554597245713128812532716616087753947246800626006504878203666972651384731498770435755225220796872155249202960801768048854869001310722927230237083418017482134588865244642658875","82993247683514419570466529457059660634483860665557779709153549045427987672829778520201315148149878525274005978368939092115193636113741972236218502664881450367443614971109677363668874484696543982239492409231870942414193419634675024621942196087473557914167832058111113476295926250739099284241826553737074679953551191767148712684157318697/17950946423927357725787689855263532224005643859095168852729513034456208872420513601894508438640531171097082516559962755244698695622824386001219435651555513795509616906355363573638916895074349491513539093024980575852693293474288638209680085037286354050958859425647536735341886663074581909148323105020337857959651624760873736590065664000","584891611376763781852144397260140844977346305541197362434227194779766612939978629636198589818106137319267243431810481928639442343946346034433828599323416877248326356345631611148749005937144684862502198147087702668524450709118588741606955966569427636630159793409544653944608958808602551061186799401212712216156799273254257486955348236914237644151956226336750212957092204830385441792/126256710861549838395499078249922986417488985866522660521294610280820007499099176190820291214370699289977888813109514854178180265382471972583921477022411657285850911270389720508719377071949050253246021921916685716353393018411683757067093259101151481189635423399611625009617884983318141463140199839724797412514785751549277231259345923662499623640886881048572831787168979644775390625","4743054867460856425399742072925732465660626340183690464743217147109403130730445842673866624947360862438925194786600531200056131309608642363389833474026007798643235346104937733349791667694862514383520689594596660275306247615314272223660862212527346572811422915223417783887717426641317921972456913534338708745549252254865615725859881457906376/1021840037832289788284691535543138164288462770384961802287250236519983887262771944174557087207566030730743075334169628971336358708580124427857321953981475719503574867471090607795242192417162791762511940848493176847925838738242153177311649130718886794249673254183907621449520415060660496225939963471753122766421338241291756892571824984344625","3784664074155769467702999785016514468281913375341134899878893061325465790589101335015569840325786070795267055386681356241209412947116340524588831510768864231937929260236754881829005065056310226407358204278658699999612596866156294195316867934035877283950841910726224355461522065773816109849107487214275801829843762482082803559183694631856772777313673086715631547326400170962722842240/813783281473223559981291694175087508812520505931454895884442580280342455516154674683217348039336712901850738745276445107477919518905155156380620466135946654952837573797479076027688866326359448543065305071605591497778941561986579230698384305536224430794233462949056326864499827444363206162251104552740175503996670997705423888382328014210171324376593090187604268086334796245552762333","1946671258536842642381655747294621776070051525209940130115769153666368932042152311477746728678182920842238801763565726086459485050237860693394471644023999467670017470376746609892484192072297938254898880354014176373253875722410186683852253828299669530022166361304397631667133689128358365296701757782382475692465977794960109690362462330857/417774039698408581013003883929127512062321623871486379101498968145670269174833505080260389860863417408848209525427705249526516766731427603641806256289098209429110794311660844125377702016056984573671024035213045475132134896835814746425864304907974005950155657789157496389234919107772201305672421982198984613601511388413381215220924416000","328578487723377153600821813410631465225159589727320893988991729306688663770697528156625398176929288628930496338036815910669579019719633124832162035588583242320537435554101841406566009219059042888412893352417446437227440076869427577701706713564212185163005644118869496869980925214424591264870388237079776503547314587137721633918824664946974571838634860386893404364499977966899068777016064/70382695927096628347637455030970644630942872888311870124896575877585692281624151103204551947776906510366521972834357031777287506848887607457751667816514216907338309372900327919413372044625602555866294337672022362865161523684052940126509854895320132828009551012639156341878073682501185688461720664801829933689280752623773789373199210473995823367199793407048741191786377993390965297664875","2617201476921368517857942326432090876874414269689140439151907982631768946799200744678055980827789859579196832718849393046147656447672531861353456343821196812881882023188898815179947651274131166835133965629115749368441605680383605331300030886676081418867305170012032824011912531673468215561506423833911621270680104083533917562622600478548/559567121085534865189976875600841717161617153776904752351231210970240323460800785728739412474960421770806162360125774000625035522428160837855944215417821324758873127567654244465281354654299068546570789547691342609793050301258532586131013585959164719533123826201937801986942606844854123769532447570107525081084531848318874835968017578125","636225736038986537559880265988431731529837451289737542395494683393492040808565905376235074534207026537145408562785279823547657299565440309510931336394031904920056464959974743525662459433889398003683078967642651812081450227654478095420306880762753401111260630654049389197602389949892636943971690212484981672010398108426002137114819838399222096538921225458913266993881960732663394566024064/135776510176793971074115131648637508758953050390591773574951317807919051619690313331192027871176160424663811116849856489187562728496099757910540362703888937768555824513740118941387831822900198029266206334350448626733139136083404404120210893986654422850183837974770675600952078956326317698998103770833069712616832650406225828969036781514645731022616236082175582937900731419575337473384125","266695771933124633677367149389643417608461366874310588884377151539325854547826373711099517873721616543570605935954334944030816383858485296542260152894035979141266909050267414072982042090341712035518685997484257326212454742816979806460287972757626105526907510197321350895873473656215941034605746494172316089636216915825022339855304925515685/56811706665210352283362623728191218698295056176625217939528332247537278605113496147630185544004654583441448319260578659922931798845493756189402805173037491645434052737405379674607517658118427614090338938517963215812444779184193933749520313676564187507594274551791388039139409235056119788261689087831209441779870873305232021728002651979776","3511806683161697708497547617957719390189982761002154386881580160856792742952365159764830433511949678304281539875366378131195670004345568047690216126001067194904446295336734931691743477531830892015690816210752795806120303198745685394015161323982229908105397857791180342330098240702332072396030780386362735967021055250450666535422528637737695053315137238368787607412459874094164027214953984/746741569878639983491390741637813989978804202898438708743258000150996080386381281307609038830698579358879333079215327202911977568726258527646560497079622703052765164031089590965199628534477381843079892123440214378949632707668935001371616475282883095939750704292616758568964786737752325652839226013335092148777788733453702438432279149298482004122593243860829060557386699231448957232420125","499543951252504651717279461487337168721376180441322735807713499521878076780205427598086756686061009718016175215146305489885835839673419698751530207404115002383180054704927695269921072232395828258826213554806570423602966743337801741633869267620843626804016742412046844770601322513184123515405692795346790813502805238635003099976693786012816/106032986203682550514602969462803214831559442358811656484036951559991322084935692953211120289352600484987931812632505499612220494311324679562152078883141464406938524087376964935494245010636163705698220308243980789514815579319533341929989455211613890905485981353837321342730307819060825125980500975023479813757024395422041501208805339176375","8540849722242122835873311629952985285477986765819584558233324868363310302206006773828897816547299245727087876984857726652932481899766510637403577175623031467933486823994040576431755172220921921877192006685053572215922347418846423419683723609799729359551828522978186208983138345476801247634773975311405913274552616037005854836040162212761099347518242200807692224460514057530656658616850816/1809694575992816440924165741094996511361288430727981159314194000585536832192004274726651828760263522962868944612215633976203596150606503849595633388319338251977160257979846235995654357082321611719654136058257458753105122024859078420173515189641515736029725847315662215778251370398007468665986604529263071981040014321717598469319370651877296085250322599247141397427185438573360443115234375","51377057693118720457387330519321684810411289582445982078756989158447711080414032055843805733348558621949380554029375294451303430269197115810494758213980833379214402452992657502777067850631862453239349835215260705131864911194740832694498014048717871429797341104227759557199716944554347879767916801106279081864127192611546757627038037780244683/10867246748205139797826516105458406878398263495890048637741584969144406206902037615496936724683237700974333817527350121106320991054058406504571347680049945745432432384570515723033245430148177097144850158758462968940525568041926860856763884474605057056550146491001458649244094211354153171337463406192651150028767064600270112838159624568832000","2517199821548153657910904242290029026229621935918771922146425373057248090467388430999870036608278542449661971830076845113363443421757278612394167195431759807908413353743377586893872930828548256216510734912027450642648789925142482023713336937258932978503310551945630359646777080073329099268529064437120002567758664419443374110941824106727218341795100740316967386497091058915066147604481280/531524260324016969370728057738851340792702640911631807178654723224511108065633433027773388768889035083734041289308124943130099580765995149865288328550751289346866467755881013217287175392101334538392596956248952430438673292186779006015549928829953979591250274457658042926539541422697852390294886719770034058916886894408015624288115732154492554105512936468520265305162358665491880968652687","937159485027553069020805864547349554547661693803137696125140510201297417077233061462068930061915381468160677500445535971818609631674361074587732183297775728389124966713749450996643183965795829780345678634356741756033039293590264355732129789110416943789326482663579413229893878422643110852069225671783017610387570935863228248464396615988222968188/197552642195166614912991396771845374656891854357948006221100585931656016640982345159207601253599235265353060942313995345483862152489766993442419668492877390774016299878943454249209917002169480134131612530977452579520564400124908392339263545911443803619972765231094502745980083350567509014991735227390978850048088378721210219321877150756855372125","5119346675109082499980756672052066247676641510661024682574296075659671743397880591881419516307292610449161239233139088348510165442597278965718490070997173182184417648987611422446347235659085092530927312760229499083348217392125906851921500360553758600756698605047197529446594606336369425040236883171542367713951500007600355406492128741649090501989105696576697387613035366083536629358444229248/1077349190930018641197987339365056771667455373500846354778079878558146320193384166982231171317419356136237346389570422332278447217033773023556383420372685049620361481309067017697564760747047839930422553324681218253359586320952896352245366885171583221864112040038531116947187482413031483309534553461613717398523132176948321964066833901215878133594739833910960843185464241840039390204295097875","58469980853327028628854378052548435225264353747414624620847476036979290604604988637469977624105451959796142112200285366199247075503424204044884512269071061176877225315884188402954249683107639777479663275428465242905314418930053869461904934138752031124685541853599407727446896558064252696813370692668496452783003306386669962110734257851955001481/12284458784412533668960387046583440199646081362484321078872891438551639470826582933879934711861551014258493898870867541349962531447724393381011633785884743889445407749238183080941846528000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","632694338036291086868292541736272151517212971647680989553388199374739841494700315711180961760384484042159533979873604395621016272772109619401112452105475906812313548587880899058905419220497456502543971131226430775692744506047039958551641270070996110661036371362526401525207493270590999387476275629412687473362310414634469788979236895300129227082421021999210841384596617452097273320509348159488/132710874087075221626157136110978536488168313127228703025408943153782802265472978945703742152954881438058373686972477195846162708986982742647038014147903817539418442869011995988024638278746664230046452545499722614320284478925059527086663455478374200352375121910000967044366831275681254530914306064535110528723482282501358749001657608122307686482720926189537227492041135055090784059994118192625","2022422468242151190347511883185841333968390991430363660248687284021524206079162212007263606819387821055183192871951076644707111802972354128011904720586729919826758651167984507804867954970064938022106484656560866447290934136610214175516487579122328055482392137619829739560923807880779865442016530712986750711199998190148885726144596663143651240/423528009127070458603837580844559347493775236970253513203186912091140251858605354218715508091394564000304400858761758838182654201653901408046974668599216804223721114331085507752600832390227068985693006017591304916519540245902645712532993889000048992026931475754508248265356181099817467608863068068953756055334213584649136541490530849577363647","150542201776735231618709653388506394887777837646651406023174643241783006776019388336318216053045300417086929061565868663031237502137150880313922488106751241006715449458736723129545400133450376339156062387859536289694727635468338235084533552501618659272047966040838509286942825414463511175531001410923014751124732748099355476332649458471135027773371541572374016038525336728276024676601778299264/31475618522527975728853391146702172347290819252268551219771201846701658848754300838383637247014705706066050673096278897933831272607774110183488615338021656923433335661890414740664480671162459271850877855521869741833030384682549648626038314686632195158507693321505500888988183270276134667071014075017317692121986144742473139078857816578133693776368882596780120407949076129685719314703426278875","162664351499283182546788129866259011542529017155637405328005084357078048074065548349602626724265307733005745244338982661090506394708170105916177679714664432754153795772811389612700051002336719842784098507498286260450939289109123759859710248621544296008356071415713931721102824434964336667980062728653562369697289761913925215639430496443820411811651/33956433298509232632327667206936379248172049619640091186698677954874297837764235300806836350019565970550533206216590639008637925266405524715041372407701947953283803854153876844320283735281209725651036513491246238622967031979233265136280687995181375582844780830517825595245506321879177965868747546127685256867456319112247572348416655367667187712000","27228583713734183629451808889147559240254570554044667607519238865891084165382075658707675405673276615039702916443152954157535195508033284355580742761569101934821088036084480297442018005972653124248838420021440899368869744141698556359295489470499243402799483082406238128875386939389123336303631993557844565927960009744780823166462314116039469622216263221278402673028225214534859076857413557466368/5675134787340359276387085910732530678163604187009567576895331134521132071092293139167824957253050637085885426100206370974479279292804959049999647539684766632278449357893560561608633329561385765035738071726214510832066885156767060324427330401967034889966727638276371320401053302413136551142103678412692111973028587922399670456670380189570979581674699102934733563330382821732200682163238525390625","1340937726818688387636018677960518622106989311577445614347061615417831160296369500704524022869612973331444242000788110133157689786976834913297544087249593601420972111789552905846168933014570399562460789075871112224533723259660967481288525220689577290386781169316008987012566216235876842757183233207943071523447855623001920854571597886491163165150556/279054368814522483241446594911968519760869180429079780837994812436395792594449929617293503975169489945136244602350941695478861584261665582123038340824700224583170270427163469762789603657025958695551448477050958557681299495041994050951692916032501884523150972841782658389836059236040091605838583126400660344344601879969354053137568588338096589095875","8910951660339249479517731530773509037034977353457185453617569046885132434552771722727442649095007828468878374139001808825741829728375370140505088133244952288239619141544661695065318568074863317054989982620944602245967155400712702259180443238473885690297281525960618905625084639870407113029712510345262279507055197024677292523214467306898573956604928730377318210588837126450942086527893437954864000/1851573255256476362977604759655284263358595254392797078730401113550522214182030016660458780180636930591149034499142464357511158868625309442843792189394292787657774627425816694628839987456477799348874853555586931850788645677998004186437300173080088839930384424797706381282430208961565555953254145002318893188197561315855286173276564036402546798318351229978103276843822345004757661005876638005274037","84997663352987536417038496128111159210386455419431137931308301989414462311135708114322046234708053448098538629166672456703651524480738219822858469100454933583774404032968304328859365484249897913676382909050450855222567147661842184538302991526635974158862033287154321908483007506326807469239745851379559259262425675035790574846229470041596801343087041/17634687575122715507915388096857069366146981156897230620371714518707518105157483283253374797127075689236298114335734874553183291806268149747826050838089931351158483980735336772879045027213982661634865556129548356487722537193914986994283729746578044621115589195066212043187229606921062007047940293972381121200723292297716621231320254309060321476608000","1648849257486312935416274009474520589799750757877252390543329851029437452988499485179026845292068377957697884739052491455807688429630524210823560524122596610276957537756142278585091315141096146341773982302888007751632401090642472506538817998043326415693840862261701364114923327286462650797963969289743571514890723145251583881752876340628073395708716735192690808352188867334842743895738955762067968/341580411902962140529547622267381834425264893226447658723654120920549166416114849731588552578626041597847002946105459812230979900480135423787717825697955152193526724029890829615845314765605770060975538542976523177976182401820926854406945392167140347444433885786340415437006775075196031433365827874254477351374236932624514469241634422312990555534789607377023339236417434574755566856489013828206625","4899626659231633406569362199187192352933567344960498139854460545644210119722856870634652562532083546344965166340063297647520613455037240144734014575196764021102614748218834054157165781057405100578668000290493431869797883155764963238760612333048336953434663867580862692267574574465371615023999531030446250351305046572267686566999209229202587258144318592/1013522377571209303732207048597964555261512342860326827024786500686692475697570284120359840724596444209277948648863014479460188496587721578075151793081823795161404110811480269106846359964436993190293615381593756076515012514100289406862487971220020752628653845345780766244842386136740768474703009091552043945843632199999007070800871588289737701416015625","362903847358088423032098939589019598036593525722040887883164115981767777873860799955715587436566233010543937498922435963385091400670303956612881974450548904906949032005878241638546734597308786514086678561900713741746905742866635779432216761799371793260025549698865319760786921444505323758235164807966277024031605673481480590193724980659448692487108892154809490199414370023696404259691299614147712/74959603173756091922435708504751461448318819548943586676159545028063979695880930926805574951275602951047845904770828900645717477098988124553474616764040938121171776556999069351772286262529729056288451037717198273521810585868307402693261479298923209587143468206907278220909447483738730657438961435587752873879244136801168836767273934997417156543866722171766794171623224855358640156858606843576125","8521348154958613550574095745596657249924328336262127244827955886474742319277424381360677655239017583606851483318951440691757875270001283229585075137091617073509041644097526047127618954293881264113694362598157456878784814696577083997902588926421675843291157049153701100218784481406086810264243143337016042301806376864424632290226377881206765051896745/1757584673254145109614914862134217345456065873908262753169404848658913774363650863904627183104777337461445063704655164325930891269843669860409763569362863600932267319335889540453302785099532688264425988677082044905948179153286276609910158854349711054144968131934713419772852663860893241364433872853338630216232313607969790083448433666334742108176384","1802461420562646993856730082999823508145602238125054717836501201545920604020389361370931345491160549787411668288359013059160331370751496329806488246135100776263777863399096485894306306621852596694700845918608199329091852956315870664531614358379176680326508877329862713333336188556181470928613423972314983964578645688876556351433429494008513812136152576866650152623510296911708111085518974142728903424/371238439252064016214448115231139360835481920731625321084601566992497057371416121407293286027832357816257507287295719261141426130159269433199862002841433235955835172774430690352481806933860390015899973299268361513643524088242973968537595085600335021120523852420135081643310663869327371821064862449426404044951571585406092523478861879148545678639697679215289523234342337347529225543852787599016265125","88795280670112240977945082069219541902481768504536167808816453021962616596410396813316064685579412429940019071114917828928080181638058444302439626425155946562362550070187433083541414569447612195370911498321149367969974762244140788494955146280201020345849385865084095189982291190135293114489407801749533448443222584092575861096946605418438181411489276/18262596223069549313969288693970246663726147886364354584825624311486557881239003216971630599389642752648815377795018130449384513824927138566203714891090017787258920529990523519479383032564209629983810866231367438270859421572641494420831435563580050954867101292568399107965982704216434467243223964964535464624988344342084084237484262612100980519602625","752911409358158070688133336918078236438086521781731735123294741731669530734909563155732092406099003582749182967246236657021875488130304108082404134004381196925042617909108654109138702993903561036987511410396567636331465803949049946947888490287210013788802287247422993384874670368649616782837096233384279817294778916419067404863458318451722971117669642134894906235066332205740872938406767767019265664/154635332883086377656813458754577288834216641577439356891585125701020579768315520324293435008561626926046988056302745604248220408154454267643222328696606367409715369481567213640103076112146615938180089303294709009813772509602954514391675152597458428326644988225555987883250642389550531163153338541870029415077982539614784206119074702022117790679351778993541426110436276530890609137713909149169921875","15286089077439918584953144558775765002061832952090847117286473868694909713791678395221438112006475047633028543501632631679316850512797978594476229228325228403849089079675681042224057234415951253954044235099139983386056610384489202589484570852048157272551098909455253037561994944665563291526597323199530997923272894119350512727802414680772513760081360291/3135161418037836259442831302977219750614726139657718770206960776514822107155928800694375522572523712277389679035632531727155957120566617736817225541673148354829212969778664144907503411589126111888917929495106029890532891919001138770210977012708107496187227751496980000137223047079127096028939624830654227758737339725345681745847598157538483308068864000","17723482381737693269787076798246423310802126092500438681864673375704464394105734049099094818738115345706100191580982712146882034618103161268453808819471603805345990162762722549964406042295355916458624836894291267553138041035528315839108252422478610879301656207772491548742981990469454529537049123948604931661837539943536878260665617524824604291547373872716194154198824107266275716083848262625068958720/3630091565725887087605600771358216927099748013831912080380983545872077197366172619225751217619097657405660172801849926220948413919823038425519006413005998509677472226729295278652284861834178791332630676772284971762683579047508016687969040658592436230062049051143001484384767836353233324570686249824980508520186643477313941054900197268584495128610811273834192099099592687485176400539748616360799518357","39160514032490258389003214587901781721548011632821053230881239001436341012396166857515197251499460842954863342641015306304854226194551189224721257664420778416733889030680295206179109679627522113592373938602737416822981698362363553492610842201005420727750505681358595340127099855823746410663750133019743170700888375554918213182862789028531284364877435896/8009919337434786244380818390213546866794958389603666737562053423775386173149395943310276429895991903753441584557917565343673605019989336264748588735390182130334278887642569515202100870042209261561001627386525182096090194076839370589780431326097965428311786635366819094633651297179987340498215947144870164066409654464551017761658775207392803825996394875","18188388167811476762477659006849121912679763597132233588170406666718758511478154418948855160838212151370453213943784067796172102916618102024199200086478021533171984254799008541948973652219533819511807681148179806051835318645591102296256347927018942348574774821478499092054497390790734798143983945096982240517058861467440217558586822663985584775920517755909444876443211404222400335500608733284461685888/3715278241795087610941547133490827711133909145414878217965273061493740719983191775105550559905283733134189195190321643965858771461560130864714477448011225816210219450040558581571206711791272284197614810026220745160693898421068168630870850392739817340370146186703867097982858560347971281142766235850971837330222970900661653800041795020382847588362774677568059355238174402415384788280852059532958121625","46353430636874284402376008361176880938798775506236714098123916668545331718677407145199311191108199195405139575147933283523305343027297808443653460575141799729554209181454676876263582758919969948546918471128299522715691694855904535448703118221685887195383025133924852224568922999317583667985459047407473419196367812949579858081181660610155317911318937349/9455890179897829052705408931064120820559254220394152447502395298827357144081378513080398823188243663943177539817982481713456798757563952162598464929784370305696420245648035222083207596797327498500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","13607414211126412689435920170832779523235279308039712294681570127241403406455725064605210473923965685858012114332021572088551127762628892611459785625407107300355287623761046438724706918300976102581928643740596336865698485838431972050267114940079353996100620311097561405192365496385584164725035842307146351211183443267583872067352881387294766804298681841402861626441205037637282007810811602289501477350144/2772205947240095684743358245950494400934136973845543049938212403703005150954425087866758842625041409060217562878157900197951382737615822655863548356735553650755342108183641353142157728364469706919993519071329069805875834057743793434164720370026073143626055293058601124362130539040404491770346043977106988100969901297669523170508321703496903672333781306743488573086901583022550356345156457496396749797875","23264350093315690507131500726914401771633259602904894387312742275462601574788485574913195967854009886824436237740789910851843045306673524324611130536719802717912615609109285261163220007241492964833933975789257681755002054890453747803418465119567389315754801791950553304034666399677630030683759466627797123971742061866928213780452325847848901682792886840980/4733430508316851445525799359992627142007028326865116523033957869609125212251136452396410236930025876982265915963089597825393317909648054808274488356887197933393799241941120691826916741647173843634076299630884655997401370400734954098249519111198509015387869462198674657171808841005212058822254513429836457539629035675822719720295352508916898476137111981397","538960934807826161927564251064896730663918579817797131801326848839524373936888402762331254883505157846659830555799909822861853145306547699817986010353774500545305596630924815657016569444824389893996399550343022444937690798126189162954188680257730893424775303801562327757655350002001080811866451425665301674688928515041429654624970707803336800125648742168380676815769457467038849213225206824671025803392/109517448833211208909213522579666376007937648875042608355810687327424621469323788799169718267715808580775296460944943658428295481347915131091297305260674731651980547668762317138753250458639043477453950774629862540017034566407286963562574188172753764978963685535201028286359818524519980885827473904574840285411260037264057197155527809916623487144493019982419606308144576939532055057697567269576800542875","24451481554350251656598350124163983489544445991992661049829014268366250968046589127810466483349378560701491445658725080497078590986743512397927747885285095846398852574219367580068049729894667374214861939897557930527646930793431512683750733092448862551580494245486308114129295467976874843852138144539250235632985676953662288536669286915983261820949386845806781/4962240683851186225340479316959605207278948397833849899236383273145853045488131674290332609876751222112917095096150531825255611911377071887145019702433883343849119017643117746273523770961304609989779231048095665388209125939879595509516490230961558353074751312876252070889983946768175488341370453053495319823381943793679003096504200440997908071027962806272000","166591964685609920525429719961758335887941461052357297159523350448241484106515158310298216150030768812873781356326923214637847449893575074813991141092681107583183275003570804134461187213143832123628701876041315736048451374824101256980832991214945762266748755723551899001458245164317581617731332466039757786839492869211248064662857987111284518155462148044812626055842061283907063784492325693994911811072/33765943466859756347231737285768516240749714264564410814839966011490233598006227246396923594069488496368994857718734549787000213944990695920130591750377483911116845697231074543526982580529937081378303555262933800375576494067959129682770065443667091668104132884375840812635624862495548888467575848428463895756394050252457592540570490061561616914443009224917652440212112452400106121785938739776611328125","142464729519206642943985715465196065680101634264787375740459792619754842396453535646509170066091478069799080172299369994438836484938378991283020978342879057271045033903518255546705211647900945143546293360496661466657600494787228476009216508124736254967761901224547269496682078470378676865981855568197705507111970901389105723589666709580851611656838285777566736/28839643075889294346635430272525349651555039807615358795334663734940126053968249608601725991946342449660829847322517564370606746964714098508298705743689729306507554363954348780144675937510900983622836770223945538844314468550644543502501484521561567788992156632892028591678742014134130878101553633195551605796158103033794695984958987367799607407626319024034625","380457154857422076784416625436182734840012277442496600178664323821064977485271288502806124740204295811759917468598315932331219906040253463960961995849761235911145436552991677050565022181516596464968316292789048809559129516930574340710998611088996508613850407294743457197519091160170604426002924022923388338999324182261954685794522778833029950214443271526469607532589775916381786492089432407550224137344640/76922142291839859196033215395526448408989799722090330866256930898223012427332209054699494033511478050536463051459450844520020426942553107946282832072826069342120835351421637970462054707566481086202287686453371483126873188020538661871147778312986131920021929455276187425940666580158173676284545586944833678819622895550345083175685846944633982680908505900099388037050135210936852210263717185637166725605577","79999800708369666670693340813609265988600461251844239982904928629083975986385235816587497657678297663151298709076884516168798694292862559083730259839524968813932151813233366175091317046758260934357096757322369138747731224414176608247605314668045838769433811781490030635374856042786947109101585097035794969502111354126773165391577217071956928171336060247633607/16154850265413610119312596299635391433380319311682208755390341659152160578366244774029302281068833963848811596545791104919556346810193385001196395489740571188884873246131813864782581356887110499639544662322008824704830818136660544673293865921754569356583698951612797219776290835161780326945625621758204931298948625885081325268123344406261740843197232316416000","26517014004241498798848003208133111307300592620947908933072661812816683085261359696887064436611747292468717739609776825664344064024535028242737616786238200200498291226984541942836459188328346609549239724653950302145388877472274074665166631509490297630344351573245265440164082334092997307729007429218385933622623935704482371360985836659823269511115937443161532987660855490906546130131716829909388620539153152/5348257529530073524280989257577050878033239486885664777340947102417077875628238501791711336803418503616042922880218860266611595594400020206192599559925169589023339295256084579966533260861249529670141854632965231468533448709363477120437277477668173149958267956654411822360053335695956270719680086524322530514249891157439878407417971839744392044064720476417844056346174795601710447583861127956455406902139625","71197348290771978405602732839537012310626009318133570890482364371056186523989330157966045289127980687764218363064941391483781008265266963537623770685390148810455244349859354857421474277963009857011653865476081389968122418691934354122230780300833008753686234433642072919923583176333668289998661499146617277981691372057042930131717336250309680764289256080895092/14342680993892886303954853579883363225921109635079605392320944523109187641283117181461662846411912306480691901515655220490850586434947504504317080144378185989596578890875561336496479576651516902048606328604696610314441229321219627021610788398730173161473456954861916116391687748151443335513249810808309201830214153565966339609616397865465842187404632568359375","342401018754023891059352629509715357053454506037284788725127073168445189422181540408896452651232759821766616850264122591225331120588918865882061344322996688880669665450231982002597398732201789017495427566260651180470635467002453249479483900268320570004293679361696197905823690145326531180324429318916092471863347575533714871355651558610515931373080997536792242278529575700808878786732127630024064418468916608/68894647682461956089382461406499759613691148650738957016015844830333168307020284281532026442272618372290646283794122772122665531108484704223311663270836645399554940741928358317884620420886609705267248656765357348477857852684140561714900614303731786621656041881975328169543884661780531057279582784036689401206706069028229798913082362331334839997133771880514515972024899408556517159759907883793675672065360125","190286571838805495686895463752492174798162827967490343625540320679760700551286395956241059969689020885714190883323266375067607282890063444652926151862650426323339187596278760962390404656342309737428214493422028545912504503974763216230927196187743439226243880933947417760147785405444976177822143722569696182520826218120595298059020305548681823408268556482981325/38242608291912408815838081993045123864617058390583394828737640036167893859507494091864963383596867701436244007905770284939991912884465101575490548813894148831966132970730263562113961685364216989999844961688441914455435934703797359360780356482629495214859917249465567846934284121032247250332634283689409883499295469118485912489058982596725212975311140618764288","15345379701153714436938289567639102307887273898834051456693981514956329731572600026866162286097662958712922836383881840211072389867463987895894067288699955858337488812343674818565432780224654423872618380928462939482247900055572079914753652915184313685270722583926261499687728814560680092231526501970431280783177357735398580700300402036873780385926225005561766822479878280891130232036389707452005183370152749056/3080426623087819678602049171756961824196425548529619576972793653585089380165862889092832375934535464160425580449193072125955685099151500755278763306599307218302635233595329082702148677300945556130106197481236122437978375963261172524503625593066102601042060541617791008722569799735202779005407381267021641545644264334109052258081225159748043792288699674153722046659880085850980843460715080965607434114275256125","36443601662144279337033484452272105547257065463167427418525882851507989449375452076227652634440476502702584889057376829320548464677623038648843251719168810701744338735202853412651160681259533015293997501525430222870696235141468274274064390273214484922080219643095978640300874086585386991338440415203863901714217818222666715642467237183267303214471854472286478344/7307237990148312451155090506264642657872224684879860008436735430879314349554023096366846856470375025555139219961666754780864835035902856314981482268319886395881809659368275720375576152008289949085453326722156553603358879420820012964006978808113307340321824660484441618487292138631579616351777191144073820686595597986548374588839763719082323114663844043046087375","1575294930860663922843149113097927168024893739962464327016763741314068438447271326302129681931564068796631337571133444163024224071270063174829664848259482066723104251718808936762938249028582992557822551950212098797718627418782376027133576209718376784834456568694813577764300716139817031545408608110880973380162736536313173329973171844528083756524804574267826691156368696436273087171467254161930265910972517504/315498546654512047637461608750018349421492986465373840347519942494904200733840189483934245529561231604050629653992944140351106887747105945984325466452136415067807666316202346895657914393512001212656936450425268507235863153258769360296536050028695266363553141327896064944506216017933135251875087069031098099192325817395958019524956320840925176589616439477134480262100237057953933117460110224783420562744140625","7692057599553133417225997786980128299372439542315125030077404519679450372805989755158000864378924877036225189784045171045139667691524763609840822628706422918926410377185494048355128046783294954373197082851501927410350313585640237550107070936498164597231431242858771457898152684298047446530220873884022213114819556822050178579707210264243087257050468000092842761/1538814487241112760739561704846381585063002784795057066438330325566843108114787083741788078680861495340026117682606689156065008672344707615420501964123121620401073675430690541617930520947170306763541251152854304975131871537939618684186766168376514664494488691311397307418298556185724993104760692216619178358268934740746932420562664234738576394742559349407744000","15190836470550557926140012263310230378455340797095100474720776113765300081463960235506950799869073894127884189857505951314428810423734978025409205413789025720642609035117121385453856877706229778165533034683130064865256448444765902482146676668197546098809055341050873494446231793312407516463576380102073171090898973046611572020564659042146465345334273595086941562425006763960197801018796906114925005810069684480/3035556598829526968124942916297025416522606357010637652635799096498208643970273828496655227572100159414352020909846298817521082538898702393916708804775798552206401718323929157863173504795127180177622667376867235806208021329981136637175570409791442328468473111768140746895005561471574356889047981458002257872092408771959478275534098789982899056118498417649167444480913552548249005268380838457505944462494874581","2923754549090941424546974281011770689534961442264350984393235983189168024079617848190236639328676436485460311093391982825027512234467853098757486086492333410753919927528867817406389678461354257841007722472106464785557179844602277350411593959136520732862935740433163383885526249897183805981219416420390137516812715245569037561966929572448247077578419534651990827044/583599691615378545100950777601104007812792435102945248411439102112424251478512952087517463400054567832353967731887062349496616445419782499817548928078665212077449420216892583997505908858360011413290038645573504472422610780073975450391707084016931661068694024023083417126286468909117254531307085545768412513447197205482285022417611018126886491416133665625891075125","441922815213568908489589193556560586318864326425397702047965372289295962228254658331201274291697626694859414786292266008476137667843874780506886929181835469302142365772763129838217316953835831059616268288399119642314758261677639945004547833810080700127847214666763863338091523753898362699222880772298183760217731228628442782431573977490761665091005756534420789258276075174436091798475838370152192077494553263232/88113527373573049332749294663402406454524640221866407165839162576979477138694653404281889227416977618913249275712917582743426231744980461918772793673202077716234026090308791893409200158969108910565467273725064769890443408324386897017825489615600787634985397885230455168591240328585041836771921929567914891379235573982442311269392541694564675053636078990836491104116280492254795616055818375774141667319774630875","91197133767962483852278456285591810579974783077874307589555559715577599604626819245000672929518645004771085106770784762994476973842713035791487204122653245797126906189270204029735872508462106527240320932458036231707311992868347221176460407003487373754014365881209649632547685657666691589606571865740595829983849941049450471212387808617247938941417000965198123059467/18163679611214677813643455199979098261849405189805364986036911945012016248297645596270602508015864371788974684317239728239847888960155365342460843559658233069613218442910226128113196984801126248862273503232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","733396724434554481470656964167233690851279923085197144879644750437402627936723531635898542414136943003236478432848965516925891956615111678444586384493883113385335463639674699443808084827715994137410743992130712903997815471369201406683862985677774155704267039224546352414417632475628136460919900347977754644214725932476856018335195927604771408949980634142255497812566866795799230501026066145434755838336990365184/145912495644159810313026420025053989609942265686388630266226856650796088768164358961644113076809511566125145395699271530802891523741636707532676065833327082092521989958971154798465784847092870457944857590623097781956884297103961713362268264159015928554707158239398721416218953003215109202771651993622244788505649098445109438104466256408060944298437033058380804126574878377874459371251056800895394904459469832875","167606423853658713615749101123336326908381619586838606922565378505211386185130407423587264776519589295420758009764678759213587906216543160801059029133457062067529468464636376639307690657945597847080706144898920305379653754920571797771178341550808041652360635584401789901525709166172283390177673009483341826911179861584213314395893323035527116283758445038413646757280/33310364848744488727470761889861069993071965180756187311178124887286133554324042422503263994717993129539448310743598138364172889305532401505890384806078790034557049074169245078416704866867380089103064821732673967120808611636618526737138435792818828990403374766228037003927569643972203993263329403469747342204808360947840103843317533210523853631711601450617095736473","22466735478643771803624909352181817912387732117378538284107485621001246177152644141853604633676939694208131243081227668237716194316732125445041260568403752325416203858329469477774720998849334961751541191761521224644520742691981372782009394826739249604257098248751626957528543558542443122470657230835176462612530464044652140581367666271771882198747182114685116336512604038833327707163107207664705120728068987996560512/4460342260599110071819142535903990817893424192972341872394014748315090430999224107274777695306032783105944721337053156074851240201179902835353097683269298594190456286888326067932777720561181760369783486872666974623910515795208353605697065447942804414120030678603538761538385793829787734830129764152263691296719726909633580318897787729004972323599773548689272008712427926734258913271101899780538635213826239542884125","1972862002066252798837977155272535342727415329632252213508267781390870646909686724955861608046325765650407340102472833428905279473185818898693854344138403744757857928883601637909604082588338869612221777263582365745419719805587946558326048087138197694016224613118304623864709183681172362693106460535117459192992832969130895829916210933710820035479169562970982784580861/391262854245936198649509275719624152305206807261382621390946060636032376057385723427601113233050260359684153963520782285097664628279596618521963444574543409076428660874564026651742234728997339844161514273669735686516761239076529088145208958938384732800586298943281728435207452253170935715239392534815683367114290676180839217919539381651841151674859715992309727232000","25408691426286653276004556426513401767718328640048945917745783225459709487487356095164164652218100925888847689099153320777389381851598236046402124684511968385325107497047025485302333503075085562533472482645023963717347867696861885363417595298751490212495932766872748125111115039311507374363000062513977436921772096443948159289707996749061007112458126301618769295162649600673247799961118662602756889448152517364992/5033870770817104909025512331238419776407331281944565644457345507262881100618908405924951559853352841154730802006750688581603270849880756026262217651685813584900300357685874044482329601894134443542753690048962260914642678445058891387041919581376195543193199307524572671344323361282633828144708683536721118910549933336800461248338059209853766305058943888965279863852107507075916981165164543199352920055389404296875","616565940481577765011174617619124841631603944267256178093555235591208387588894068005162766513720546626399308168923904625210748051788652328072241494243040185611373035059619136712559505023703153194815611268503291295059648269772663939137446253437248541496631852986499688052678961495116210133458596866684413931188348798244969797973846568160999564540652111599082181871436/122025682149627484528651507368051367620578469392233875493556828623437869650284356703295836998178256875766319508797903923638967073687991229708051285605187358616531926112736402511567721889845693991963610192161413692928378708223712791930113386840109729368772998347036090902364801014045328348830748307179590755723160142468563977011700764517880467116766150322736003147125","979882056834583241477188686550561625289337025747787132773853690143359657519481397575561812727394470125172272246774578404543257210124412718725081536309818383310896102958167337333430555168671327992395916735022711297435263157670501117734412587691271084981140167017421900852550822579410636184333142944411060788723653596377015359036101170054828623669169047118551010102258802465554033173968468183492058271365801755986560/193732066620504775981759812703028757608600125742477178751189607602983198559778039141192492589734277739017909889924488699372940787977794555519474807920198944109549023547259912324279741006975129518191081373554817584214941629021088206977532599055014150433581544599721903881284581257812850697423350805715586436114842183295730680490110793225514602133304729484547181740290534056445482186430729398701311563285494964645419","1138059441890428903336718712159907364975959482163004276901676063186939296217569849990951930955270849692775077813359573394435924934540269310629731801376134549169322946310756738187834128956671195358413024062230774111935109203207768898525882417078119314003162592087920755572050993355843681931139257303484526223461840939880759908449181135029327442039666513325916729112853/224777393704985303260433439401503507705148576727364388720387174977154204629336985298082893443205223017966145098064861566754244624732671470935725326043491911142467178027013112527668183783450932992534517827863293825061296257420183669383719043873666284378647952385401303733274771042385666436214517205678674213118374889121542369996042313879258622144464565403138392064000","614262617634904509410555695398092190166323289787703954329113412647342230855826568873946233136303566178604275296873234926652080462259552775254755109931312516616838091852915397846984381183732773411263828600108443070778861986849272794442105107285234729077818614332155890946804257724112143631642663084660012362691100872465148864413343598067567142977134846266425075195546265101720326272502009234689388355365794889444257557504/121200854655310345878069155190734381476914416893031941761756379148622591310152793328910334357724762079139509813381997287954319983165971628429295803162563856219211627796200599196263868781937234015821367575512548522790158101892507996780675863234181700253545912643548466256938936835469646114659598727592390628209362096738343417775009361678599075671154405137663077798419897932404104579113056038271753988669813988076515476125","106893445531995430131837569895703697604978445859412739331042151546083234373443601923983714252801103551874986033841637079479794895452077803182698291822629713500021995241940133037200268381793282318691568234728329378829301282121562652452936297422136961147432559766896143081059518238234777055931999714973999553456547746825617168005650221542417216291412324174772893635832/21070287546583154895102927029203125577385528350171457634203261197137238923923245382493868134869009844094435068284335909266152042903157700510534904847257436666980671067329084409346149729385625108233234542133838924281113454526471855573271066865534480974484196644173270141056470857666632902827625475719738076524047736123182255306429677688129231682978570461273193359375","1112742798776748551928744983308584493817112400536084744850969025063360679785378789764875076529575583792571198510306186417773101346425704969671256564494135750783642910394213727189639661184379341961737135764570942961692159177189753139209638929302928699705042832922774012622017270172331722295881412111812933593370743210214549038212395941675257558442878012136484052827439007483777859391215222647499741572327725689840850048/219121905514652575155579185322367175400669386131891843382447432851122462422992147756333729893028362013318264155489537138133372703295804002840920402482110260590055749843170064921843460498824128274420925357547023876488939786863662801268798987685503391058250902634999352652063668663245829496836853509616873246554292796823779397317819134891873583857621623143253788854530146303641400986028503534408870194989478421253057625","983995170259637497940121707857673268620603982844439610076334749792119502557380361624096960070148627663305171311646851566811683351232268240169848810658089698606409195744471343416197434926513684882439596141368794175162315633192028977211909698595778839497844847281262559899914504080092844816319298286511436690429175757804604673752838786852277255064434365401871903307643705/193579499709739777577893639665643417521924510242119561765932078835121983190401762561436208758210519231103767232899529457440602166918701550386152070813526760823513884391055054076485295945972185402977095815609448651316824455250005505410192101148149284756928250258632031981439345164037318129987999546683113483700660879431801728391911161900686707231543216283304182063038464","30691013076836380319652884848585431917439358375118437035944950498156836885409110087616602043242747413728866747975631727566613593257623099549583001362246649928075859944695060947434885707102684568632559339383409378997568182445019183928058902445738702610436187907199482604867148445903921474846103586253320950728989228898324829144701782792767763794895137313050381112872972806712570559942583906619373159053654481250809168128/6031936190594376585238407905469035598668211679521553144958053099463931217856780171872253258738635531385711702176347575597387389685526098889278278029314982721284691198967204664771178761416891317672705719303088746953644978471289001577698554025410820041497108311270431130911021653860874238212040640737171103823631718483572464361276703378587106311153455557896527384426327053165214814954154328483257657424873929502112904625","33633002641218571027682690377239300567277297301791434890431645909447040830457253186262970747405514897340315490970846553666201190386457221846694126637998462873786334837901001833771510353365825087187582807843940479192544772559118293851131234910638705258664901225494129023244916125545283621607920983287799648992632814461828998517949449887522866259724675318233522060729654796/6603800575190864815125307817934327053530311915572323544225173935830559756077637251538096164499112411672913910767032482188570876526606118068929913515497400397562722669603861813453418621246538114872330536044519242663538662076583511078523573320035084744399535581216815034837553165853576616422592790103728141443697362408727056813977234078214386771115586436985105038873998875","9090550743395453237608373761422705922989356346696677314277463900103283296889488490217663400349361962695279888433677856471792856853109469433355422802663947305503479561493033851081993247556828544308258821557994512133708656174864544457143793106703578476914924328960109390350040954158797845288786321215010324565010420734044059968931558099077932776525974187717655105951506223649947806568984848883258144616897526257038550656/1783219994432430133950472014582130883873515063182143523712063859964133099770763874744121895885645346884371273930727450069430704145915261127061538288702855011220545530326588799412076879985026006593893648911637986337776174555198865379578424838210466703683642106934154603710587408512357351455891557594977191641529451749437270208258072920514602243985184744955476557012910446023911358037761232253615162335336208343505859375","396226087129511787616470716244996965529391571019620342657409150252952330537366537352182763477820160355931003174946109480036915624974500187179367618457008802667089004678925595775249725629495848146669773574395699032785024522882892752987825063933573399691764866816284097232869198405981830106568826923407996367321353003569052419999880089180418759265274331299787468134974811/77651132902382550540201641628906752945078964002822585000619340261128555048628863996784740469908853602590877726845475670110127527874088625214912598995012971630852593597027649154487264595100300180591016581254965295280089902497540043916128232871685159131211213497239568483141031137909208031392464815187505714066235868748950184065923236670418822911614780061752905170944000","1288523130900767412477856952035690867153496584747510253984686336382980221603917538996138294311274357713893956725672062832264871415025750136690143411884111580335458539824573239771267043414225271729141508235839982033182605445173050590151912297720800168687369852280323356691345317649445843078291369394324862039143247087442309135074453265658730028145500871559458519282433012494054724678302957276371418936282902434203225600/252284450515080370603949213084529993395050575951188044032908270470514999880554862449223347761507020354321422785760279154913310488296485989979706208254206974075438570521939826124860483842758137231373182496438568202110337751291106165654945352183167578675508602832478752400011567482434301614269579368882858973850914513870297071866544875650189106576672289734326492492059816669288907018095832842249738081022227281715919357","559506782175368748187145067236900803925823792088293851453005882621173124590368101213652371965740365119375069053747415415684193092607523211636912074219215053809881814859129515591479780669511533619258835199715146655774919418434080807837587396115955105126806762961292429904380132116986984435528307613054828929294602185927322238461491059740342387266084431988727321711184308176/109446188216864405154936682374609448082436347600301765944233278303643744736544109262794383069197271409398615846380701459882784547857821831816863216080069944818453908760476475874319791512782445408136169878207358663250499628002971644430164185578966399908622640732411885568638054229180673755690889471388585521113862492432946110902070139679164884208988489955874131206343597375","365842109776085256207829452385781129402656684569922320812625438296958174120084800064669048017227033185969596458778213306152397766619692644694641677223213185977626940193107608138827771259334379895020377700759789774994800008933137569543592829220611543060189849601828342989023692876182148818363689293009174358168826340010491728715549904988196347316703985894355217235339548078187164176255405596310602921647203428200269666176/71497266937783826306774367225149833789788300609530680399994804704196212252148324552193149332755057982662844988588678159610516634667597707204818296457616315484973288944637139939912166034691155272078609876888919170894915224022982785138928008133003473320018151370486895637936102520353951511525996197267572355782608352075229547764732602557133494648237258900273354364050662921889937355682486287799239363976556848320046933875","59378684894605773397070783936113244261297966863668546282887298999811950599772732377979382620766180662159460666220894896896564357533604962977968843474062092083279165837424210591042655271577974272394203253875965589611493384384257117088518521598379301169916060951350650621757237206805037261878212424267780312614942173870651684587166691539909068452932891649554575072205080763/11593916877920131260484148322810317629326850763057953025674154928920977965095141485536566217873796019006709247938019404840440511433467040918770165456925609124166970862430104329357419669175323763143377917913760028500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","440706629842402075137926797732405268015915199334341565218443748798479563505125605478061664327658137598204192554352688830679475840386882350034150077506804799859586772904929402683276898098601814091430598259347980573084686932949502809068565420937301632494387691284902026088950093888426872222813857928092871267130505744095697172494119689779474840037266295586359244899477781345249657455186847452249040895151288114085352974933708544/85971876318334010542313048056773419567285701852816309711738644074302467763075671531248793080425349570584102078764464196653843973936119037322000695949209283327606280423406302517302874806092835694196353778161663338667091195199032831587897410329509487165187753418615356836636352319310103639079123698118997500068644500893282438137614420288839230827096109835206605385673197123994357393257304049093683934224826006704198171592304125","13220371178312284248107863849287558696210741535280184003301555188086761767176560823174196915070378763091889333203635784037294769747641959860810039816533609140662043493962707445564057197150603226797446933532133956054671103942520142568674339411250001585991743608723150284270101326419464088290151483823061613403673956918458456165552482913079283537536214967294211244361353060/2576683013797055224377707713704899315377379548630511095136568220145808780162671473907260623503552385384482723173913562423316997528913651044277418227616447815609873991028073011738113927961824632868956802271260292075825561646156680740323686126811928372672670917332613490241615850953660246271541592056143611581223295045062157404996958100136358649109693659623847024011265147","1538372578072246705266078247950089219881197139399081643650271348770110178217959856819170325400476655944115553238940541695152110949081675985299189913515975242840473616169775880272489805123124548256666658584129873597192213080038937409046114908719298170078476325423466734429870048697383304265342125425087105698152643145531760853127801123272389134514333752173173161562273487752064850461823726948588221913540799816489566883798912/299566102446745552813544808169323270315327122249327394279467999308669285416179486075255023523726449428151807672528368606071047812907935426406886253284580296349349558797128593446316786243666290649442956134448480598303527795996222703837663605600624271807461605295956674925277658331760000117761013381199880905748188151556184620779667670278558839116983636972680749836497346863752662521197700717702790359162307617024566689271625","281696937222363685333688097915539146272117417024070728031063821781398985795813333650547982965341298894634762289669256129805545549280355643122501181852136332529515756074502902204877664395456278205770206019663082511098956468724829475220996427130295010430751942126263620206886404244432409164651524408198286831329682605959881993845189585640874220032515465014097345759490750307207/54806274927935495596891312029173862473687610099325998583092091915101265393157631244775387832621032230434007486602816972765210205596482942091518459849775458089575743699797096697542306049628939919466378189656065461708686421130956996965004776108499273871055615413566043083634090083096967567965373203683231171594922347812966905149873265654962896456451681332216735396249206784000","228506238533410805238253122961471637501498406104430046727793420497895852412513560203475440156216063574654372726194215013407325207763369075250819386897086702757125418327084312933061738392406321003231853349865003322697360659712771167066453430309997639548320673279964210730701373707765051246595806673865646607841876463608039111252607452843372970797479959213447237540830563469297144446069689149549515457318899981763489792/44418759813188470246596822974281932219088697005123285598909329328419879212164564561558656547678211265529803086702843380128457744445765859393426675396393053094588240457569380155526179040891009717323059641035189017918495485630657360525410506453554255734005459614858972904374739673834145083512160883402151636664208253116362089211658645312778404886460203600762546810897889629330022309705583438699250109493732452392578125","2396110297187570506257836426251930521245117960980667897194680897478996322590925380310917400763581787981992131769075961259393685331523600287377841990678117113566991100720996059187144934569703045966210306282348527729533806882408323961336166190162075154579344185244957673138372347997134388801085788353482276257401005734929059700346687783400772331280644647089520646562669857652648/465370154262863030800729180763091967573522779260407615567563274096037297593764955820626213827962697601334935773802201919483657310282236100250543992334865461800976838791035335861420892967699843608855185710753433852279737724446294443337363478679601049432404435672469098850676302728116369979460222148206944323730586138087862719386327396334468302608499235112520318322763857676375","1188272888075247520453568790651819187486389546755745961952033150576243575862120569399808467067800830890874391487822723879717525264875722720416173276963170672622214121308038530968291758445510982186014289745026439477197148445087614813262170975056866881909056450023324743409114115141145340480846088869807540798073417035168139476153897066325127540609756310068558610112731607522096096821938163134080426356894899245575410494080/230586762395914863625709048789913840511134004337945700368117795195769576856434588144361459740833007125516905017415184787078710001969815416281381427387949263792200577791644278234661952852149216540491852757174842146376788280677956350901082838474705227642420261641783722891948710833898248566893322144435457967452449965772543077421407816225704952270697016152452032506898311260979594550143344971416786595888053149375287120733","1072184299258468249004114536023934869518152618369895613271618698908405514630154819453979477077738526673716264830106745031385951736108376866253955319711026042389282009348594845497252059906901748860111986811345742998968284077119165082435598381810306691078037018432766116865792677955520465319184311529667642995217214507658693259694586107847099911341219913576038605872218680562047/207882129535607118520818565811162643811811563516006836924341123976848022970024793004700710992938987476728640943834012473687892481059618823520721737479364352887178017866425027953255856440099446112508663603319745066750522936408781591578321031173620445865113295407603090322283539974563690157418931060565698315406021569491751612761888641141446406531645379264720684248398299136000","158094023904374464057702010126993231151433474361820266584020400101533651587072432728050776506672527718975042616651177034635188178967462982926261516748842073587981953038445977514446838733557926696939591069712397947055261777416704028506441173540338327591514650398349069348381309688677335132100441905603664282735310299686268721634369502296867409514777359935022301425165750780988231639828675424239931533849896744198012747670272/30626384366513923671063955469537776291182594080083494737341604579575446319190916924682809546024369330706012653799783122328775875399363759308193432327358837772825609356553955350401725689682838701996446404559005896479618311357573203081153855961484398360670837599853294627153740224543175497655414585918231215639906924313779933211774291565425360415684556655021031131349317390382320286092667852173815259422737956767922154798375","12216278924286401897470540169822542417611356797676160128176706721343511598951866107858729405615631246003458062949723290192242594609994613705183460814797527214549142043573863947658832694800184691222426521703728394203722420336773310908687071670107794543022567943478843065246011544888390757810534211554666736239506503613750756246364621509359804902243487113673014588325806249988332/2364584127734680580481708368927921125934330000162935118371174269642831409084634375654239735054363928748162229294829526339927907778510530444646754603322373712788147193691037688552857183116332292048731726305451516954679277320777955342295564000586923227775208580772868590742136150431152495718132142742153643081187691849828217592954519485869135930755646768375299870967864990234375","578939195017447864385837341975558679292903716580114421030538728778491606282153588930983966100514147976321305616196463174070345884292672842497715966933722088536619333912687108737657068701352918582656105418491672377271304970407730786932913490869797471081081431072836814581099271832696990064828717287258860166842791984158634684078346453202928137987930328826212011774670396356151265781053547412633310327737900786639842674288716416/111966291649651600701875186827360807558960817589719096407887999108024557254221008849510152469119211567152616745769256123968832250104006560061907741567034087109512483357851919402017950812795426393415409198268246337542639470834168040295134130657073201020340432236723824670803498949071870597039309004562024033656488150406105175401372709011082725359382691270659245312133919518760328422827067578306005644825927050994860723405473375","8041514821545833865350873212853873042112343327573364523948780030849543753072688526717886590013028227714585965095216381829914996539132359247488639692828639170075726301411777307168737667077730792892326979446426349813642680537699905651125068091362135055902152994216233622733424128982011248923051410141033146604688083721413402395290842738021365861670415833356403364696759583009635/1553937833499559104910551811592138833189892464446761247731330672284191313590708439680460540329836344767557599746234213006493842842879398684745864919973051635127080738612248150108793397855113122368507483429209127035263504194847798809612278864438287815470711036548695032421148125849669175729331459149833945183228413961985381338162155596008680906676498435954178226973272371625984","12059659399309169167301353842123191409306995788633965680414620302285606896146667751472818541537183787935352700725982053536032930866708413010971856856768384974849695774437178790890015242323873769697407411558706626105140596160049735605389301414460825674631122462760014451298494875244754354054447697502521388381253293175367558014453865905104467382184997528879171136492277222127399012368677604910497789360212571238146627048080568400384/2328494054002703067219004484782931471919751585969487160602269605916676223315055450845942763690581877771159615428854802721943114463834992106300185328876910271612375509166975628540839858771078495267566008071532876816826751069408153323840515037497664871689085370699991860738368371510578076683395101062439493831773194498579620513073693022191702398601471237166387045790480861932005012807234071429628725981935147069738988682858417182625","683009426705008850682549700382901603742691705123356866338951397347368059105140826655486518416578697931244347554322654428162554903861783227680935341690740579867651545205562690172425016836559678937794312287639193745517811234257062356826622207475918293015140472942579713388671782202262396642735640315948612572908444501108579457520714632371056288874351015666995549139003946314085696/131769214246522869780429817236150406548549044658474416909806179734873399109656411633488099249198882165279745627038984487365589625562901914030850178330133080409420340227179447548044572594184601425691821617928130423410997853384425373999967759499571890326740433081063424903098252502791477854302204200941376983295622430177445507316706609802292121282957519571162158620971952084486375","1418116259749091420309271913909337143756589314597557128553117870573928055109322864794169592355058370891251425125187770724828108988587888087023982451205475980371440423992838481547236638456717520835668859093413956339261802305597694403381021863258753441889536361061407579332570493634254542013337999844407181346815549594836374497512447969751514466481466717590255369810506813543577735080228718660747940956248427356785784199073569408/273368882980516556922532339653303822104510203916024760371844491705599093435133738774975538364241630079468712981056336655766117378160822393876348755370711942273876284944422610974149712212944211513462921649872232656449940987552227525504529710373144228818606127541937831103642415534318303187393593236209298242574677293352798419428712873685798636474667204083938875672934235816396371477146089168375198141802684403955936431884765625","546411077581845999248238069684194831621691193366466972898628141511422317954477211865167402284211971296286346492698354214043840080181702652132835681239302798339667835439189275457116051279366194551632712819028177402221815140045210690908631767786711675029194359998826252332434573121740830827417293557234891406021102083555472155479148332697839972702631641910213821827820374586459319/105246945889799140338072754365901705544530661781295362563214285953881890233987516230568663143342952799036341701952267011236663118111226623815975847494372076420199418712941018288738590264475520229651370015377608638075866459684692488079223686296541020897904588347083045723167762682959422858996673894180805702299907478685374065593161226849447131100462022089783265346597553176576000","2398330640958841474772606439916070050977544535580605737383995160447105736276950196885906408317628083110923322157113892928963237845914017845444295040924101784423382681801754191301860383927129006953354739240926643562987838836997453985855576402628166875869041032631651591871962852884189548538272285387092843044669499688035134181859376665409767886188304314888753894905317929877238322615838524354191263502347881033855441181420399360/461588070868590122892265681879734295007029130965626060552783760068897000195207878227714842617470320231527222074701444349530952699708435668339712860464533455345665068841333232359698449088497137068713309811942968433868609329301082001752617420002377892756821532220676085014874112083615054550278903960627185675459015343606391094523511117705747842645927349130302549554534056269331809016770715819934970200483161548527932617036185253","6041015879424725383006424536130409209607854044642113747266098198777011981328765528361630516108680392500990580908509403483891763219659726090675140672989657743882183951954294745396417829943469201306594018454995862321821016087416840247422350906412007336103086620396467456181771583200365740253389107968122850063607085957109965406634738740996318415514360956028575560979203447735121436/1161752799109428422288020947061281540989708937450568100764830251908850596717606701047413407636907934320789870175907792017513896999208892282137299070761467096211814586909598705615312819596495636017728313513520193786266452836805291464826226833593878504804389728477191170027729963773716267868284479768397603444919008915279522376004326398403851684761808785381609370767169521034383625","13240077436443988749179508462267267187169441948722358165090554769250505713747934643200804819418670147225695324432684266924694524337920816452346599774452681831320005286326986675907899608537972384924882996757503264622991355949039882526389342174307168805166215838138277557052303430492669193939212362638263582899713198716541723383138016564027766560215944409353427176135895982596327685665844815618402881202645610620284792793420780517248/2544223084468158291883698813309541801455311468982232546872485444308211415529998472787377800559884210837213042932180479090277285630234238711851480232520137856848809986631784843528381778520727465146661792797924458540957133423665746229799675650290296217658444899605236550972043549278128087645211909479009099766619355677984218929672461506691980442071860591767266913041147587815452007726513853820116629482732060593116624596368806566625","1953999166296955830935495158735359200362904181792947794529339487489730042568305997099959302322956898299616194932283060554261566410988618045107398092345476532371402134206635235570281738377188438407703089325315446371127042537576093536896282955524842632708645655481028161471313608974238110718242273935956977555610147714316158486553633871312187084618154014921190595222799283957140353/375191165084882521037046014569185165885459082629136124177286500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"];typeof ln<"u"&&(ln.exports={PRIMES:Ln,PRIMES_SET:Un,LONG_PI:g1,LONG_E:m1,BIG_LOG_CACHE:d1})});var T0=f0((Qi,vn)=>{"use strict";var Nn=typeof globalThis.nerdamerBigInt>"u"?qn():globalThis.nerdamerBigInt,rn=typeof globalThis.nerdamerBigDecimal>"u"?Rn():globalThis.nerdamerBigDecimal;rn.set({precision:250});var x0=typeof globalThis.nerdamerConstants>"u"?xn():globalThis.nerdamerConstants,w1={},S1=[],v1={},N1=[],y1=[],E1=[],sn={Settings:null,Math2:null},re={ext:{bigInt:Nn,bigDec:rn,PRIMES:x0.PRIMES,PRIMES_SET:x0.PRIMES_SET,LONG_PI:x0.LONG_PI,LONG_E:x0.LONG_E,BIG_LOG_CACHE:x0.BIG_LOG_CACHE},groups:{N:1,P:2,S:3,EX:4,FN:5,PL:6,CB:7,CP:8},fnNames:{SQRT:"sqrt",ABS:"abs",FACTORIAL:"factorial",DOUBLEFACTORIAL:"dfactorial",PARENTHESIS:"parens",LOG:"log",CONST_HASH:"#"},get settings(){return sn.Settings},state:{get EXPRESSIONS(){return S1},get VARS(){return v1},CONSTANTS:{},get RESERVED(){return N1},get WARNINGS(){return y1},get USER_FUNCTIONS(){return E1},get CUSTOM_OPERATORS(){return w1}},classes:{Frac:null,Fraction:null,NerdamerSymbol:null,Vector:null,Matrix:null,Expression:null,Collection:null,NerdamerSet:null,Scientific:null,Parser:null,LaTeX:null,Math2:null,Build:null},utils:{get isSymbol(){return gt},get isVector(){return vt},get isMatrix(){return St},get isExpression(){return r1},get isNumericSymbol(){return q0},get isFraction(){return _n},get isArray(){return Dt},get isInt(){return mt},get text(){return Xt},get variables(){return n0},get scientificToDecimal(){return F0},get err(){return Pt},get block(){return Bt},get evaluate(){return Nt},get reserveNames(){return k0},get nround(){return m0},get remove(){return d0},get _setFunction(){return On},get _clearFunctions(){return $i},symfunction:null,callfunction:null},exceptions:null,parser:null,core:null,libExports:null,version:"1.1.16"},M1={N:re.groups.N,P:re.groups.P,S:re.groups.S,EX:re.groups.EX,FN:re.groups.FN,PL:re.groups.PL,CB:re.groups.CB,CP:re.groups.CP};Math.sign||=function(t){return t=Number(t),t===0||isNaN(t)?t:t>0?1:-1};Math.cosh||=function(t){let e=Math.exp(t);return(e+1/e)/2};Math.sech||=function(t){return 1/Math.cosh(t)};Math.csch||=function(t){return 1/Math.sinh(t)};Math.coth||=function(t){return 1/Math.tanh(t)};Math.sinh||=function(t){let e=Math.exp(t);return(e-1/e)/2};Math.tanh||=function(t){if(t===1/0)return 1;if(t===-1/0)return-1;let e=Math.exp(2*t);return(e-1)/(e+1)};Math.asinh||=function(t){return t===-1/0?t:Math.log(t+Math.sqrt(t*t+1))};Math.acosh||=function(t){return Math.log(t+Math.sqrt(t*t-1))};Math.atanh||=function(t){return Math.log((1+t)/(1-t))/2};Math.trunc||=function(t){return isNaN(t)?NaN:t>0?Math.floor(t):Math.ceil(t)};function Vn(r){return/\\d+\\.?\\d*e[+-]*\\d+/iu.test(r)}var Xn={convert(r,t){let e=Number(r),o;if(e===0)o=[0,1];else if(Math.abs(e)<1e-6||Math.abs(e)>1e20){let g=this.quickConversion(e);if(g[1]<=1e16){let E=Math.abs(e),L=e/E;o=this.fullConversion(E.toFixed(`${g[1]}`.length-1)),o[0]*=L}else o=g}else o=this.fullConversion(e);return o},quickConversion(r){let t=function(o){typeof o!="string"&&(o=o.toString());let g="",E=o.charAt(0);return E==="-"?(o=o.substr(1,o.length),g="-"):E==="+"&&(o=o.substr(1,o.length)),{sign:g,value:o}};function e(o){Vn(o)&&(o=F0(o));let g=t(o),E=g.value.split("."),L;E.length===1?L=E[0]:L=E[0]+E[1];let A=E[1]?E[1].length:0,k=`1${"0".repeat(A)}`;return L!=="0"&&(L=L.replace(/^0+/u,"")),[g.sign+L,k]}return e(r)},fullConversion(r){let t=Number(r),e=Math.abs(t)>1e10?1e-16:1e-30,o=!1,g=0,E=1,L=1,A=0,k=0,G=t,V,J,me=1e-14;for(;!o;){k++;let Ae;if(Math.abs(G)>1e10){let Te=Math.round(G);Ae=Math.abs(G-Te)/Math.abs(Te)30)&&(o=!0)}return[V,J]}};re.classes.Fraction=Xn;function jt(r){let t=function(e){this.name=r,this.message=e===void 0?"":e;let o=new Error(this.message);o.name=this.name,this.stack=o.stack};return t.prototype=Object.create(Error.prototype),t}var yn=jt("DivisionByZero"),Gn=jt("ParseError"),Ht=jt("UndefinedError"),hn=jt("OutOfFunctionDomainError"),A1=jt("MaximumIterationsReached"),En=jt("NerdamerTypeError"),W0=jt("ParityError"),_0=jt("OperatorError"),b1=jt("OutOfRangeError"),gn=jt("DimensionError"),Hn=jt("InvalidVariableNameError"),C1=jt("ValueLimitExceededError"),jn=jt("NerdamerValueError"),I1=jt("SolveError"),_1=jt("InfiniteLoopError"),Zn=jt("UnexpectedTokenError");re.exceptions={DivisionByZero:yn,ParseError:Gn,OutOfFunctionDomainError:hn,UndefinedError:Ht,MaximumIterationsReached:A1,NerdamerTypeError:En,ParityError:W0,OperatorError:_0,OutOfRangeError:b1,DimensionError:gn,InvalidVariableNameError:Hn,ValueLimitExceededError:C1,NerdamerValueError:jn,SolveError:I1,InfiniteLoopError:_1,UnexpectedTokenError:Zn};var Rt={get bigInt(){return re.ext.bigInt},get bigDec(){return re.ext.bigDec},get isInt(){return re.utils.isInt},get scientificToDecimal(){return re.utils.scientificToDecimal},get DivisionByZero(){return yn},get Settings(){return re.settings},get Fraction(){return Xn}},Ve=class r{num;den;constructor(t){if(t instanceof r)return t;if(t===void 0)return this;try{if(Rt.isInt(t))try{this.num=Rt.bigInt(t),this.den=Rt.bigInt(1)}catch(e){if(e.message==="timeout")throw e;return r.simple(t)}else{let e=t instanceof Rt.bigDec?Rt.Fraction.quickConversion(t):Rt.Fraction.convert(t);this.num=new Rt.bigInt(e[0]),this.den=new Rt.bigInt(e[1])}}catch(e){if(e.message==="timeout")throw e;return r.simple(t)}}static create(t){if(t instanceof r)return t;t=t.toString();let e=t.charAt(0)==="-";e&&(t=t.substr(1,t.length-1));let o=new r(t);return e&&o.negate(),o}static isFrac(t){return t instanceof r}static quick(t,e){let o=new r;return o.num=new Rt.bigInt(t),o.den=new Rt.bigInt(e),o}static simple(t){let o=String(Rt.scientificToDecimal(t)).split("."),g=o.join(""),E="1",L=(o[1]||"").length;for(let k=0;k"u")return;let o=t;if(an.isVector(t)||(o=an.Vector.fromArray([t,...e])),o){let{elements:g}=o;for(let E=0,L=g.length;E{t.add(e.clone())}),t}union(t){let e=this.clone();return t.each(o=>{e.add(o)}),e}difference(t){let e=this.clone();return t.each(o=>{e.remove(o)}),e}remove(t){for(let e=0,o=this.elements.length;e{o.contains(g)&&e.add(g)}),e}intersects(t){return this.intersection(t).elements.length>0}isSubset(t){let{elements:e}=t;for(let o=0,g=e.length;oe.text(t)).join(",")})`}clone(){let t=r.create();return t.elements=this.elements.map(e=>e.clone()),t}expand(t){return this.elements=this.elements.map(e=>N0._.expand(e,t)),this}evaluate(t){return this.elements=this.elements.map(e=>N0._.evaluate(e,t)),this}map(t){let e=this.clone();return e.elements=e.elements.map((o,g)=>t(o,g+1)),e}add(t){return N0.block("SAFE",()=>{let e=t.elements;return this.elements.length!==e.length?null:this.map((o,g)=>N0._.add(o,e[g-1]))},void 0,this)}subtract(t){return N0.block("SAFE",()=>{let e=t.elements;return this.elements.length!==e.length?null:this.map((o,g)=>N0._.subtract(o,e[g-1]))},void 0,this)}};re.classes.Collection=t0;var Pn={get Settings(){return re.settings},get nround(){return re.utils.nround}},D0=class r{sign;coeff;exponent;wholes;dec;decp;constructor(t){t=String(typeof t>"u"?0:t),t.startsWith("-")?(this.sign=-1,t=t.substr(1,t.length)):this.sign=1,r.isScientific(t)?this.fromScientific(t):this.convert(t)}static isScientific(t){return Vn(t)}static leadingZeroes(t){let e=t.match(/^(?0*).*$/u);return e?e[1]:""}static removeLeadingZeroes(t){let e=t.match(/^0*(?.*)$/u);return e?e[1]:""}static removeTrailingZeroes(t){let e=t.match(/0*$/u);return e?t.substring(0,t.length-e[0].length):""}static round(t,e){let o=String(Pn.nround(t,e)),g=o.includes(".")?o.split(".").pop():"",E=e-g.length;return E>0&&(o.includes(".")||(o+="."),o+=new Array(E+1).join("0")),o}fromScientific(t){let e=String(t).toLowerCase().split("e");this.coeff=e[0],this.exponent=Number(e[1]);let o=this.coeff.split(".");this.wholes=o[0]||"",this.dec=o[1]||"";let{dec:g}=this;return this.decp=g==="0"?0:g.length,this}convert(t){let e=t.split("."),o=e[0]||"",g=e[1]||"";o=r.removeLeadingZeroes(o),g=r.removeTrailingZeroes(g);let E=o.length,L=o+g,A=r.leadingZeroes(L).length;this.exponent=E-(A+1);let k=r.removeLeadingZeroes(L);this.coeff=`${k.charAt(0)}.${r.removeTrailingZeroes(k.substr(1,k.length))||"0"}`;let G=this.coeff.split(".")[1]||"";return this.decp=G==="0"?0:G.length,this.dec=g,this.wholes=o,this}round(t){let e=this.copy();if(t=Number(t),t===0)e.coeff=e.coeff.charAt(0);else{let o=this.coeff.substring(0,t+1),g=this.coeff.substring(t+1,t+3),E=Number(g.charAt(0));Number(g.charAt(1))>4&&E++,e.coeff=o+E}return e}copy(){let t=new r(0);return t.coeff=this.coeff,t.exponent=this.exponent,t.sign=this.sign,t}toString(t){let e;if(Pn.Settings.SCIENTIFIC_IGNORE_ZERO_EXPONENTS&&this.exponent===0&&this.decp"u"?this.coeff:r.round(this.coeff,Math.min(t,this.decp||1)),g=this.exponent;o.startsWith("10.")&&(o=typeof t>"u"?o.replace(/^10\\./u,"1.0"):r.round(o.replace(/^10\\./u,"1.0"),Math.min(t,this.decp||1)),g=Number(g)+1),e=this.exponent===0?o:`${o}e${g}`}return(this.sign===-1?"-":"")+e}};re.classes.Scientific=D0;function Dt(r){return Array.isArray(r)}function Mt(r){return`(${r})`}function O1(r,t){return r<0==t<0}function qt(...r){return r.shift().replace(/\\{(?\\d+)\\}/gu,(o,g)=>{let E=r[g];return typeof E=="function"?E():E})}function q1(r,t,e){let o=[];e||=1;for(let g=r;g<=t;g++)o.push(g*e);return o}function T1(r){return r?String(r):""}function R1(r,t,e,o){return r.substr(0,t)+o+r.substr(e,r.length)}function L1(r){return r!==void 0&&r.custom}function U1(r){return Math.max.apply(void 0,r)}function Mn(r){return Math.min.apply(void 0,r)}function Ut(r){return Number(r)%2===0}function mn(r){return 1/(r%1)%2===0}function An(r){let t=r.length,e=[];for(let o=0;o=Number.MAX_VALUE?r.toString():Number(r):Math.round(r*10**t)/10**t}function D1(r,t){t||=20;let e=[],o,g,E;e.push(r[0]);for(let L=0;LNumber(L[0])-Number(A[0]));let g=[],E=[];for(let L=0;L{t(e)})}function X1(r){let t=i0.RESERVED.indexOf(r);t!==-1&&(i0.RESERVED[t]=void 0)}var $n={get ALLOW_CHARS(){return re.settings?.ALLOW_CHARS??[]},VALIDATION_REGEX:/^[a-z_][a-z\\d_]*$/iu};function w0(r,t="variable"){if($n.ALLOW_CHARS.indexOf(r)!==-1)return;if(!$n.VALIDATION_REGEX.test(r))throw new Hn(`${r} is not a valid ${t} name`)}function K0(r){return i0.RESERVED.indexOf(r)!==-1}var wn={get WARNINGS(){return re.state.WARNINGS},get SHOW_WARNINGS(){return!(re.settings?.SILENCE_WARNINGS??!0)}};function In(r){wn.WARNINGS.push(r),wn.SHOW_WARNINGS&&console&&console.warn&&console.warn(r)}function G1(){return wn.WARNINGS}var H1={get EXPRESSIONS(){return re.state.EXPRESSIONS}};function j1(){return H1.EXPRESSIONS.length}var Z1={get Settings(){return re.settings}};function z1(r){return Z1.Settings[r]}function W1(r){try{return w0(r),i0.RESERVED.indexOf(r)===-1}catch(t){if(t.message==="timeout")throw t;return!1}}function Q1(r){return r?i0.RESERVED:i0.RESERVED.join(", ")}var Jn={get _version(){return re.version},get C(){return re.core}};function J1(r){if(r)try{return Jn.C[r].version}catch(t){if(t.message==="timeout")throw t;return`No module named ${r} found!`}return re.version}function Y1(){return Jn.C}var K1={get functions(){return re.parser?.functions}};function ei(){return Cn(K1.functions)}var ti={get CONSTANTS(){return re.parser?.CONSTANTS}};function ni(r){return String(ti.CONSTANTS[r])}var O0={get VARS(){return re.state.VARS}};function ii(r){return O0.VARS[r]}function ri(r,t){r||="text";let e={};if(r==="object")e=O0.VARS;else for(let o in O0.VARS)Object.hasOwn(O0.VARS,o)&&(r==="latex"?e[o]=O0.VARS[o].latex(t):r==="text"&&(e[o]=O0.VARS[o].text(t)));return e}var Zt={get _(){return re.parser},get C(){return re.core}};function si(r,t){return Zt._.toTeX(r,t)}function oi(r){return Zt._.getOperator(r)}function li(r,t){Zt._.aliasOperator(r,t)}function ai(r,t,e){Zt._.setOperator(r,t,e)}function ui(r,t){Zt._.peekers[r]&&Zt._.peekers[r].push(t)}function ci(r,t){let e=Zt._.peekers[r];if(e){let o=e.indexOf(t);o!==-1&&d0(e,o)}}function Yn(r){let t=Zt._.toRPN(Zt._.tokenize(r));return Zt._.tree(t)}function fi(r){return String(r).split(";").map(t=>Zt._.parse(t))}function pi(r){return Zt._.toRPN(Zt._.tokenize(r))}function hi(r,t){return`
      \n
        \n
      • \n${Yn(r).toHTML(3,t)}\n
        • \n
      \n
      `}function gi(r,t,e){let o=Zt._.functions[r],g=typeof e>"u"?o[1]:e;Zt._.functions[r]=[t(o[0],Zt.C),g]}var Qt={get EXPRESSIONS(){return re.state.EXPRESSIONS},get USER_FUNCTIONS(){return re.state.USER_FUNCTIONS},get LaTeX(){return re.classes.LaTeX},get text(){return re.utils.text},get functions(){return re.parser?.functions??{}},get Math2(){return re.classes.Math2},get _(){return re.parser},get Expression(){return re.classes.Expression}};function mi(r,t,e){let o=r?{}:[];for(let g=0;g.*?)\\)/u.exec(V),g=g.split(",").map(J=>J.trim()),E="{JavaScript}"}let k=`${L}(${g.join(", ")})=${E}`,G=Qt.text(k,t);r?e[o+1]=G:e.push(G)}return e}function wi(r){r=r.replace(/_(?[A-Za-z0-9])/gu,(...e)=>`${e[0]} `),r=r.replace(/\\^(?[A-Za-z0-9])/gu,(...e)=>`^{${e[1]}}`),r=r.replace(/(?\\\\[A-Za-z]+)(?\\d)/gu,(...e)=>`${e[1]}{${e[2]}}`),r=r.replace(/(?\\\\[A-Za-z]+\\{.*?\\})(?\\d)/gu,(...e)=>`${e[1]}{${e[2]}}`);let t=Qt.LaTeX.parse(Qt._.tokenize(r));return new Qt.Expression(Qt._.parse(t))}var l0={get libExports(){return re.libExports},get VARS(){return re.state.VARS},get _clearFunctions(){return re.utils._clearFunctions},get _initConstants(){return re.parser?.initConstants??(()=>{})},get clear(){return Kn}};function Si(){for(let r in l0.VARS)Object.hasOwn(l0.VARS,r)&&delete l0.VARS[r];return l0.libExports}function vi(){return l0._clearFunctions(),l0.libExports}function Ni(){return l0.libExports}function yi(){return l0.clear("all"),l0.libExports}function Ei(r){return r.call(l0.libExports),l0.libExports}var cn={get libExports(){return re.libExports},get CONSTANTS(){return re.state.CONSTANTS}};function Mi(r,t){if(w0(r),!K0(r))if(t==="delete"||t==="")delete cn.CONSTANTS[r];else{if(isNaN(t))throw new En("Constant must be a number!");cn.CONSTANTS[r]=t}return cn.libExports}var C0={get libExports(){return re.libExports},get VARS(){return re.state.VARS},get CONSTANTS(){return re.state.CONSTANTS},get parse(){let{parser:r}=re;return r?.parse?.bind(r)??(()=>null)},get isSymbol(){return re.utils.isSymbol}};function Ai(r,t){return w0(r),r in C0.CONSTANTS&&Pt(`Cannot set value for constant ${r}`),t==="delete"||t===""?delete C0.VARS[r]:C0.VARS[r]=C0.isSymbol(t)?t:C0.parse(t),C0.libExports}var Dn={get libExports(){return re.libExports},get _setFunction(){return re.utils._setFunction}};function bi(r,t,e){if(!Dn._setFunction(r,t,e))throw new Error("Failed to set function!");return Dn.libExports}var y0={get libExports(){return re.libExports},get EXPRESSIONS(){return re.state.EXPRESSIONS}};function Kn(r,t=!1){if(r==="all")y0.EXPRESSIONS.length=0;else if(r==="last")y0.EXPRESSIONS.pop();else if(r==="first")y0.EXPRESSIONS.shift();else{let e=r?r-1:y0.EXPRESSIONS.length;t===!0?y0.EXPRESSIONS[e]=void 0:d0(y0.EXPRESSIONS,e)}return y0.libExports}var Z0={get libExports(){return re.libExports},get Settings(){return re.settings},get functions(){return re.parser?.functions??{}}};function e1(r){let t=Z0.libExports.getCore();if(Dt(r))for(let e=0;e21&&Sn("USE_BIG",!0)):r==="USE_LN"&&t===!0?(Wt.Settings.LOG="LN",Wt.Settings.LOG10="log",Wt.functions.log=Wt.Settings.LOG_FNS.log10,Wt.functions.log[0]=function(g){return g.isConstant()?new Wt.NerdamerSymbol(Math.log10(g)):Wt.symfunction(Wt.Settings.LOG10,[g])},Wt.functions.LN=Wt.Settings.LOG_FNS.log,delete Wt.functions.log10):Wt.Settings[r]=t}var I0={get libExports(){return re.libExports},get functions(){return re.parser?.functions??{}},get parse(){let{parser:r}=re;return r?.parse?.bind(r)??(()=>null)},get callfunction(){return re.utils.callfunction},get Expression(){return re.classes.Expression}};function Ci(r=!1){let t=function(o){return function(...E){for(let L=0;LI0.callfunction(o,E)))}};for(let e in I0.functions)(!(e in I0.libExports)||r)&&(I0.libExports[e]=t(e))}var Ii={get suppress_errors(){return re.settings?.suppress_errors??!1}};function Pt(r,t=void 0){if(!Ii.suppress_errors)throw t?new t(r):new Error(r)}var _i={get PRIMES_SET(){return re.ext.PRIMES_SET}};function $0(r){if(r in _i.PRIMES_SET)return!0;let t=Math.floor(Math.sqrt(r));for(let e=2;e<=t;e++)if(r%e===0)return!1;return!0}var A0={starttime:0,timeout:0,get TIMEOUT(){return re.settings?.TIMEOUT??800}};function t1(){A0.starttime=Date.now(),A0.timeout=A0.TIMEOUT}function n1(){A0.starttime=0}function en(){if(A0.starttime!==0&&Date.now()>A0.starttime+A0.timeout)throw new Error("timeout")}var M0={get PRIMES(){return re.ext.PRIMES},get PRIMES_SET(){return re.ext.PRIMES_SET}};function Oi(r){if(en(),$0(r))return[r];let t=r,e=1,o=[],g=2220446049250313e-31;for(;e1){if($0(e)&&(M0.PRIMES_SET[e]||(M0.PRIMES.push(e),M0.PRIMES_SET[e]=!0),o.push(e)),$0(L)){o.push(L);break}t=L}e++}return o.sort((E,L)=>E-L)}function i1(r){let t=M0.PRIMES[M0.PRIMES.length-1]||2;for(let e=t;ebt._.parse(r,t),!0)}var wt={get EXPRESSIONS(){return re.state.EXPRESSIONS},get Settings(){return re.settings},get LaTeX(){return re.classes.LaTeX},get text(){return re.utils.text},get variables(){return re.utils.variables},get isVector(){return re.utils.isVector},get isSymbol(){return re.utils.isSymbol},get isExpression(){return re.utils.isExpression},get isNumericSymbol(){return re.utils.isNumericSymbol},get isFraction(){return re.utils.isFraction},get isArray(){return re.utils.isArray},get _(){return re.parser},get Build(){return re.classes.Build}},S0=class r{symbol;constructor(t){this.symbol=t}static getExpression(t,e=void 0){(t==="last"||!t)&&(t=wt.EXPRESSIONS.length),t==="first"&&(t=1);let o=Number(t)-1,g=wt.EXPRESSIONS[o];return g&&new r(g.symbol)}text(t="decimals",e=void 0){e||=wt.Settings.EXPRESSION_DECP;let o=this.symbol;return o.text_?o.text_(t):wt.text(this.symbol,t,void 0,e)}latex(t){return this.symbol.latex?this.symbol.latex(t):wt.LaTeX.latex(this.symbol,t)}valueOf(){return this.symbol.valueOf()}evaluate(...t){if(wt.isVector(this.symbol)&&this.symbol.dimensions()===0)return this;let e=t[0],o,g=1;typeof e=="string"?o=e.charAt(0)==="%"?r.getExpression(e.substr(1)).text():e:e instanceof r||wt.isSymbol(e)?o=e.text():(o=this.symbol.text(),g--);let E=t[g]||{};return new r(Bt("PARSE2NUMBER",()=>wt._.parse(o,E),!0))}buildFunction(t){return wt.Build.build(this.symbol,t)}isNumber(){return wt.isNumericSymbol(this.symbol)}isInfinity(){return Math.abs(this.symbol.multiplier.valueOf())===1/0}isImaginary(){return Nt(wt._.parse(this.symbol)).isImaginary()}variables(){return wt.variables(this.symbol)}toString(){try{return wt.isArray(this.symbol)?`[${this.symbol.toString()}]`:this.symbol.toString()}catch(t){if(t.message==="timeout")throw t;return""}}toDecimal(t){wt.Settings.precision=t;let e=wt.text(this.symbol,"decimals");return wt.Settings.precision=void 0,e}isFraction(){return wt.isFraction(this.symbol)}isPolynomial(){return this.symbol.isPoly()}sub(t,e){return new r(this.symbol.sub(wt._.parse(t),wt._.parse(e)))}operation(t,e){let o;return wt.isExpression(e)?o=e.symbol:wt.isSymbol(e)?o=e:o=wt._.parse(e),new r(wt._[t](this.symbol.clone(),o.clone()))}add(t){return this.operation("add",t)}subtract(t){return this.operation("subtract",t)}multiply(t){return this.operation("multiply",t)}divide(t){return this.operation("divide",t)}pow(t){return this.operation("pow",t)}expand(){return new r(wt._.expand(this.symbol))}each(t,e){if(this.symbol.each)this.symbol.each(t,e);else if(wt.isArray(this.symbol))for(let o=0;o1&&Array.isArray(t.elements[0])&&t.elements[0].length===1&&(this.elements=t.elements.map(o=>o[0]),this.rowVector=!1):typeof t>"u"?this.elements=[]:this.elements=[t,...e]}static arrayPrefill(t,e){let o=[];e||=0;for(let g=0;gthis.elements.length?null:this.elements[t-1]}set(t,e){gt(e)?this.elements[t]=e:this.elements[t]=new ot.NerdamerSymbol(e)}dimensions(){return this.elements.length}modulus(){return Bt("SAFE",()=>ot._.pow(this.dot(this.clone()),new ot.NerdamerSymbol(.5)),void 0,this)}eql(t){let e=this.elements.length,o=t.elements||t;if(e!==o.length)return!1;do if(Math.abs(ot._.subtract(this.elements[e-1],o[e-1]).valueOf())>ot.Settings.PRECISION)return!1;while(--e);return!0}clone(){let t=new r,e=this.elements.length;for(let o=0;oot._.expand(e,t)),this}map(t){let e=[];return this.each((o,g)=>{e.push(t(o,g))}),new r(e)}each(t){let e=this.elements.length,o=e,g;do g=o-e,t(this.elements[g],g+1);while(--e)}toUnitVector(){return Bt("SAFE",()=>{let t=this.modulus();return t.valueOf()===0?this.clone():this.map(e=>ot._.divide(e,t))},void 0,this)}angleFrom(t){return Bt("SAFE",()=>{let e=t.elements||t;if(this.elements.length!==e.length)return null;let g=new ot.NerdamerSymbol(0),E=new ot.NerdamerSymbol(0),L=new ot.NerdamerSymbol(0);this.each((V,J)=>{g=ot._.add(g,ot._.multiply(V,e[J-1])),E=ot._.add(E,ot._.multiply(V,V)),L=ot._.add(L,ot._.multiply(e[J-1],e[J-1]))}),E=ot._.pow(E,new ot.NerdamerSymbol(.5)),L=ot._.pow(L,new ot.NerdamerSymbol(.5));let A=ot._.multiply(E,L);if(A.valueOf()===0)return null;let k=ot._.divide(g,A),G=k.valueOf();return G<-1&&(k=-1),G>1&&(k=1),new ot.NerdamerSymbol(Math.acos(k))},void 0,this)}isParallelTo(t){let e=this.angleFrom(t).valueOf();return e===null?null:e<=ot.Settings.PRECISION}isAntiparallelTo(t){let e=this.angleFrom(t).valueOf();return e===null?null:Math.abs(e-Math.PI)<=ot.Settings.PRECISION}isPerpendicularTo(t){let e=this.dot(t);return e===null?null:Math.abs(e)<=ot.Settings.PRECISION}add(t){return Bt("SAFE",()=>{let e=t.elements||t;return this.elements.length!==e.length?null:this.map((o,g)=>ot._.add(o,e[g-1]))},void 0,this)}subtract(t){return Bt("SAFE",()=>{let e=t.elements||t;return this.elements.length!==e.length?null:this.map((o,g)=>ot._.subtract(o,e[g-1]))},void 0,this)}multiply(t){return this.map(e=>ot._.multiply(e.clone(),t.clone()))}x(t){return this.multiply(t)}dot(t){return Bt("SAFE",()=>{let e=t.elements||t,o=new ot.NerdamerSymbol(0),g=this.elements.length;if(g!==e.length)return null;do o=ot._.add(o,ot._.multiply(this.elements[g-1],e[g-1]));while(--g);return o},void 0,this)}cross(t){let e=t.elements||t;if(this.elements.length!==3||e.length!==3)return null;let o=this.rowVector&&t.rowVector,g=this.elements;return Bt("SAFE",()=>{let E=new r([ot._.subtract(ot._.multiply(g[1],e[2]),ot._.multiply(g[2],e[1])),ot._.subtract(ot._.multiply(g[2],e[0]),ot._.multiply(g[0],e[2])),ot._.subtract(ot._.multiply(g[0],e[1]),ot._.multiply(g[1],e[0]))]);return E.rowVector=o,E},void 0,this)}toUnitMultiplier(){return this}max(){let t=0,e=this.elements.length,o=e,g;do{g=o-e;let E=this.elements[g],L=E.valueOf(),A=typeof t=="number"?t:t.valueOf();Math.abs(L)>Math.abs(A)&&(t=E)}while(--e);return t}magnitude(){let t=new ot.NerdamerSymbol(0);return this.each(e=>{t=ot._.add(t,ot._.pow(e,new ot.NerdamerSymbol(2)))}),ot._.sqrt(t)}indexOf(t){let e=null,o=this.elements.length,g=o,E;do E=g-o,e===null&&this.elements[E].valueOf()===t.valueOf()&&(e=E+1);while(--o);return e}text_(t,e){let o=Xt(this,e);return(this.rowVector?"[":"")+o+(this.rowVector?"]":"")}text(t,e){let o=Xt(this,e);return(this.rowVector?"[":"")+o+(this.rowVector?"]":"")}toString(){return this.text()}latex(t){let e=[];for(let o=0;o{o.set(E,L,t.call(o,g),e)}),o}set(t,e,o,g){this.elements[t]||=[],g||gt(o)?this.elements[t][e]=o:this.elements[t][e]=new Lt.NerdamerSymbol(o)}cols(){return this.elements[0].length}rows(){return this.elements.length}row(t){return!t||t>this.cols()?[]:this.elements[t-1]}col(t){let e=this.rows(),o=[];if(t>this.cols()||!t)return o;for(let g=0;gLt._.expand(e,t)),this}evaluate(t){return this.eachElement(e=>Lt._.evaluate(e,t)),this}invert(){return this.isSquare()||Pt("Matrix is not square!"),Bt("SAFE",()=>{let t=this.elements.length,e=t,o,g,E=r.identity(t),L=this.augment(E).toRightTriangular(),A,k=L.elements[0].length,G,V,J,me=[],Ae;do{o=t-1,V=[],A=k,me[o]=[],J=L.elements[o][o];do G=k-A,Ae=Lt._.divide(L.elements[o][G],J.clone()),V.push(Ae),G>=e&&me[o].push(Ae);while(--A);for(L.elements[o]=V,g=0;g{let t=this.clone(),e,o,g,E=this.elements.length,L=E,A,k,G=this.elements[0].length,V;do{if(A=L-E,o=t.elements[A][A],o.valueOf()===0){for(let J=A+1;J{let e=t.elements||t;if(!this.canMultiplyFromLeft(e)){let $e=t;if(this.sameSize($e)){let Te=new r,Ee=this.rows();for(let Me=0;Me{let A=Lt._.add(g.clone(),t.elements[E][L].clone());e&&(A=e.call(o,A,g,t.elements[E][L])),o.set(E,L,A)}),o}subtract(t,e){let o=new r;return this.sameSize(t)&&this.eachElement((g,E,L)=>{let A=Lt._.subtract(g.clone(),t.elements[E][L].clone());e&&(A=e.call(o,A,g,t.elements[E][L])),o.set(E,L,A)}),o}negate(){return this.each(t=>t.negate()),this}toVector(){if(this.rows()===1||this.cols()===1){let t=new It;return t.elements=this.elements.flat(),t}return this}toString(t,e){let o=this.rows(),g=[];t=t===void 0?`\n`:t;for(let E=0;E{let A=e?L.multiplier.toDecimal():L.toString();return L===void 0?"":A}).join(",")}]`);return`matrix${Mt(g.join(","))}`}text(){return`matrix(${this.elements.map(t=>`[${t.join(",")}]`)})`}latex(t){let e=this.cols(),{elements:o}=this;return qt("\\\\begin{vmatrix}{0}\\\\end{vmatrix}",()=>{let g=[];for(let E in o){if(!Object.hasOwn(o,E))continue;let L=[];for(let A=0;A1?L[1]:L[0]}=${A};`,g[E]=L.pop()}return[g,o]},getArgsDeps(r,t){let{args:e}=r,o=t,g=function(E){E.group===P0.FN&&(o=e0.compileDependencies(E.fname,o))};for(let E=0;Ee.parse(r),!0);let V=n0(r),J=[],me=[{},""],Ae=function(Ee,Me){Ee.fname===""&&(Ee=G.unwrapPARENS(Ee)),Me||=[];let a=[],{group:ue}=Ee,ve="",Ne=function(he){let be=he===k?"*":"+",we=[];for(let s in Ee.symbols){if(!Object.hasOwn(Ee.symbols,s))continue;let c=Ee.symbols[s],S=Ae(c,Me)[0];c.isComposite()&&(S=Mt(S)),we.push(S)}let fe=we.join(be);return fe=fe&&!Ee.multiplier.equals(1)?Mt(fe):fe,fe},ye=function(he){let be;if(he in Math)be=`Math.${he}`;else{if(he=e0.getProperName(he),J.indexOf(he)===-1){let we=P0.Math2[he].toString();!we.startsWith("function")&&!we.startsWith("(")&&!we.startsWith("async")&&(we=`function ${we}`),Me.push(`let ${he} = ${we}; `),J.push(he)}be=he}return be+=Mt(Ee.args.map(we=>Ae(we,Me)[0]).join(",")),be};ue===g?a.push(Ee.multiplier.toDecimal()):Ee.multiplier.equals(-1)?ve="-":Ee.multiplier.equals(1)||a.push(Ee.multiplier.toDecimal());let Ie;if(ue===E||ue===L)Ie=Ee.value;else if(ue===o)if(me=e0.compileDependencies(Ee.fname,me),me=e0.getArgsDeps(Ee,me),e0.reformat[Ee.fname]){let he=e0.reformat[Ee.fname](Ee,me);me=he[1],Ie=he[0]}else Ie=ye(Ee.fname);else if(ue===A){let he=Ee.previousGroup;he===g||he===E?Ie=Ee.value:he===o?(Ie=ye(Ee.fname),me=e0.compileDependencies(Ee.fname,me),me=e0.getArgsDeps(Ee,me)):Ie=Ne(Ee.previousGroup)}else Ie=Ne(Ee.group);if(Ee.group!==g&&!Ee.power.equals(1)){let he=Ae(e.parse(Ee.power));Me.push(he[1]),Ie=`Math.pow${Mt(`${Ie},${he[0]}`)}`}return Ie&&a.push(ve+Ie),[a.join("*"),Me.join("").replace(/\\n+\\s+/gu," ")]};t&&(V=t);let $e=Ae(r);for(let Ee in me[0]){if(!Object.hasOwn(me[0],Ee))continue;let Me=me[0][Ee];$e[1]=$e[1].replace(Ee,Me),me[1]=me[1].replace(Ee,Me)}return new Function(...V,`${(me[1]||"")+$e[1]} return ${$e[0]};`)}};re.classes.Build=e0;var s0={get _(){return re.parser},get Settings(){return re.settings},get SQRT(){return re.fnNames.SQRT},get ABS(){return re.fnNames.ABS},get PARENTHESIS(){return re.fnNames.PARENTHESIS},get FACTORIAL(){return re.fnNames.FACTORIAL},get DOUBLEFACTORIAL(){return re.fnNames.DOUBLEFACTORIAL},get N(){return re.groups.N},get P(){return re.groups.P},get S(){return re.groups.S},get EX(){return re.groups.EX},get FN(){return re.groups.FN},get CB(){return re.groups.CB},get CP(){return re.groups.CP},get Parser(){return re.classes.Parser}},yt={parser:null,space:"~",dot:" \\\\cdot ",latex(r,t){let{_:e,P:o,CB:g}=s0;if(r&&typeof r=="object"&&"clone"in r&&typeof r.clone=="function"&&(r=r.clone()),r instanceof e.classes.Collection&&(r=r.elements),Dt(r)){let Te=[];for(let Ee=0;Ee.+)_$/u,"$1\\\\_"));let Ne=String(ve).split("_"),ye=this.greek[Ne[0]];ye&&(Ne[0]=ye,ve=Ne.join("_"));let Ie=this.symbols[Ne[0]];Ie&&(Ne[0]=Ie,ve=Ne.join("_")),a[ue]=ve}else if(Ee===G||Me===G){let ve=[],{fname:Ne}=r;for(let ye=0;ye1)a[ue]=`\\\\mathrm${this.braces(s0.Settings.LOG)}_${this.braces(ve[1])}${this.brackets(ve[0])}`;else if(Ne===s0.Settings.LOG10)a[ue]=`\\\\mathrm${this.braces(s0.Settings.LOG)}_${this.braces("10")}${this.brackets(ve[0])}`;else if(Ne===s0.Settings.LOG2)a[ue]=`\\\\mathrm${this.braces(s0.Settings.LOG)}_${this.braces("2")}${this.brackets(ve[0])}`;else if(Ne===s0.Settings.LOG1P)a[ue]=`\\\\ln${this.brackets(`1 + ${ve[0]}`)}`;else if(Ne==="sum"){let ye=ve[0],Ie=ve[1],he=ve[2],be=ve[3];a[ue]=`\\\\sum\\\\limits_{${this.braces(Ie)}=${this.braces(he)}}^${this.braces(be)} ${this.braces(ye)}`}else if(Ne==="product"){let ye=ve[0],Ie=ve[1],he=ve[2],be=ve[3];a[ue]=`\\\\prod\\\\limits_{${this.braces(Ie)}=${this.braces(he)}}^${this.braces(be)} ${this.braces(ye)}`}else if(Ne==="nthroot")a[ue]=`\\\\sqrt[${ve[1]}]${this.braces(ve[0])}`;else if(Ne==="mod")a[ue]=`${ve[0]} \\\\bmod ${ve[1]}`;else if(Ne==="realpart")a[ue]=`\\\\operatorname{Re}${this.brackets(ve[0])}`;else if(Ne==="imagpart")a[ue]=`\\\\operatorname{Im}${this.brackets(ve[0])}`;else{let ye=Ne===""?"":`\\\\mathrm${this.braces(Ne.replace(/_/gu,"\\\\_"))}`;r.isConversion?a[ue]=ye+this.brackets(ve.join(""),"parens"):a[ue]=ye+this.brackets(ve.join(","),"parens")}}else if(r.isComposite()){let ve=r.collectSymbols().sort(Ee===$e||Me===$e?(be,we)=>we.group-be.group:(be,we)=>{let fe=gt(be.power)?-1:Number(be.power);return(gt(we.power)?-1:Number(we.power))-fe}),Ne=[],ye=ve.length;for(let be=0;be1&&s.length>0){let S=s.length;for(let O=0;O{let s=tn(fe.power),c;s?(c=yt.latex(fe.invert(),e),be++,fe.isComposite()&&(!r.multiplier.den.equals(1)&&Math.abs(Number(fe.power))===1&&(c=yt.brackets(c,"parens")),ye.push(ve.length)),ve.push(c)):(c=yt.latex(fe,e),he++,fe.isComposite()&&(!r.multiplier.num.equals(1)&&Math.abs(Number(fe.power))===1&&(c=yt.brackets(c,"parens")),Ie.push(Ne.length)),Ne.push(c))}),we(Ne,Ie,he),a[0]=Ne.join(this.dot),we(ve,ye,be),a[1]=ve.join(this.dot)}return a},set(r,t,e,o){let g=function(me){return/^\\\\left\\(.+\\\\right\\)$/u.test(me)};e&&=this.formatP(e);let E;o&&(E=e[0],e[0]=""),t=this.merge(t,e);let L=r[0],A=r[1],k=t[0],G=t[1];k&&Number(L)===1&&(L=""),Number(A)===1&&(A="");let V=this.join(L,k,g(k)?"":this.dot),J=this.join(A,G,g(G)?"":this.dot);if(V&&J){let me=this.frac(V,J);return o&&E&&(me=this.brackets(me)+E),me}return V},merge(r,t){let e=[];for(let o=0;o<2;o++)e[o]=r[o]+t[o];return e},join(r,t,e){return!r&&!t?"":r&&!t?r:t&&!r?t:r+e+t},formatSubscripts(r){let t=r.toString().split("_"),e="";for(;t.length>1;)t.length>0&&(e=`_${this.braces(t.pop()+e)}`);return t[0]+e},formatP(r){for(let t=0;t<2;t++){let e=r[t];e&&(r[t]=`^${this.braces(e)}`)}return r},formatFrac(r,t){let e=r.num.toString(),o=r.den.toString();return t&&e==="1"&&o==="1"?"":o==="1"?e:this.frac(e,o)},frac(r,t){return`\\\\frac${this.braces(r)}${this.braces(t)}`},braces(r){return`{${r}}`},brackets(r,t){t||="parens";let o={parens:["(",")"],square:["[","]"],brace:["{","}"],abs:["|","|"],angle:["\\\\langle","\\\\rangle"]}[t];return`\\\\left${o[0]}${r}\\\\right${o[1]}`},filterTokens(r){let t=[];Dt(r)&&(t.type=r.type);let e=["\\\\","left","right","big","Big","large","Large"];for(let o=0,g=r.length;o"u"?++e:e+=V]},k=function(){return yt.parse(A())},G=function(V){return V in L?L[V]:V==="*"&&E[e+1].value==="&"?(A(2),","):V==="&"?(A(),","):V==="\\\\"?"],[":V};for(e=0,o=E.length;e[a-z_][a-z0-9_]*)\\((?[a-z0-9_,\\s]*)\\)\\s*:?=\\s*(?.+)\\s*$/iu,VALIDATION_REGEX:/^[a-z_αAβBγΓδΔϵEζZηHθΘιIκKλΛμMνNξΞoOπΠρPσΣτTυϒϕΦχXψΨωΩ∞][0-9a-z_αAβBγΓδΔϵEζZηHθΘιIκKλΛμMνNξΞoOπΠρPσΣτTυϒϕΦχXψΨωΩ]*$/iu,IMPLIED_MULTIPLICATION_REGEX:/(?[+\\-/*]*[0-9]+)(?[a-z_αAβBγΓδΔϵEζZηHθΘιIκKλΛμMνNξΞoOπΠρPσΣτTυϒϕΦχXψΨωΩ]+[+\\-/*]*)/giu,ALIASES:{\\u03C0:"pi","\\u221E":"Infinity"},POSITIVE_MULTIPLIERS:!1,CACHE:{},SILENCE_WARNINGS:!1,PRECISION:21,EXPRESSION_DECP:19,DEFAULT_DECP:16,VECTOR:"vector",PARENTHESIS:"parens",SQRT:"sqrt",ABS:"abs",FACTORIAL:"factorial",DOUBLEFACTORIAL:"dfactorial",get LONG_PI(){return Fn.LONG_PI},get LONG_E(){return Fn.LONG_E},PI:Math.PI,E:Math.E,LOG:"log",LOG_LATEX:"log",LOG10:"log10",LOG10_LATEX:"log_{10}",LOG2:"log2",LOG2_LATEX:"log_{2}",LOG1P:"log1p",LOG1P_LATEX:"ln\\\\left( 1 + {0} \\\\right)",MAX_EXP:2e5,SCIENTIFIC_MAX_DECIMAL_PLACES:14,SCIENTIFIC_IGNORE_ZERO_EXPONENTS:!0,SCIENTIFIC_SWITCH_FROM_DECIMALS_MIN_EXPONENT:7,TIMEOUT:800,initCache(){this.CACHE.roots={};let r=40,t=40;for(let e=2;e<=r;e++)for(let o=2;o<=t;o++){let g=Nn(e).pow(o);this.CACHE.roots[`${g}-${o}`]=e}}};_e.CONST_HASH=re.fnNames.CONST_HASH;_e.initCache();sn.Settings=_e;var u0={get bigInt(){return re.ext.bigInt},get BIG_LOG_CACHE(){return re.ext.BIG_LOG_CACHE},get PRIMES(){return re.ext.PRIMES},get NerdamerSymbol(){return re.classes.NerdamerSymbol},get CB(){return re.groups.CB},get P(){return re.groups.P}},ut={csc(r){return 1/Math.sin(r)},sec(r){return 1/Math.cos(r)},cot(r){return 1/Math.tan(r)},acsc(r){return Math.asin(1/r)},asec(r){return Math.acos(1/r)},acot(r){return Math.PI/2-Math.atan(r)},erf(r){let t=1/(1+.5*Math.abs(r)),e=1-t*Math.exp(-r*r-1.26551223+t*(1.00002368+t*(.37409196+t*(.09678418+t*(-.18628806+t*(.27886807+t*(-1.13520398+t*(1.48851587+t*(-.82215223+t*.17087277)))))))));return r>=0?e:-e},diff(r){return function(o){return(r(o+.001)-r(o-.001))/.002}},median(...r){r.sort((e,o)=>e-o);let t=Math.floor(r.length/2);return r.length%2?r[t]:(r[t-1]+r[t])/2},fromContinued(r){let t=r.fractions.slice(),e=1/t.pop();for(let o=0,g=t.length;oG&&ut.fromContinued(me)-r<=Number.EPSILON));)me.fractions.push(J),E=V-J,(E<=k||L>=t-1)&&(A=!0),L++;let Ae=me.fractions.length-1;return me.fractions[Ae]===1&&(me.fractions.pop(),me.fractions[--Ae]++),me},bigpow(r,t){r instanceof Ve||(r=Ve.create(r)),t instanceof Ve||(t=Ve.create(t));let e=new Ve(0);if(t.isInteger())e.num=r.num.pow(t.toString()),e.den=r.den.pow(t.toString());else{let o=Ve.create(r.num**t.num),g=Ve.create(r.den**t.num);e.num=ut.nthroot(o,t.den.toString()),e.den=ut.nthroot(g,t.den)}return e},gamma(r){let e=[.9999999999998099,676.5203681218851,-1259.1392167224028,771.3234287776531,-176.6150291621406,12.507343278686905,-.13857109526572012,9984369578019572e-21,15056327351493116e-23];if(r<.5)return Math.PI/(Math.sin(Math.PI*r)*ut.gamma(1-r));r-=1;let o=e[0];for(let E=1;E<9;E++)o+=e[E]/(r+E);let g=r+7+.5;return Math.sqrt(2*Math.PI)*g**(r+.5)*Math.exp(-g)*o},bigfactorial(r){let t=new u0.bigInt(1);for(let e=2;e<=r;e++)t=t.times(e);return new Ve(t)},bigLog(r){let t=u0.BIG_LOG_CACHE;if(t[r])return Ve.quick.apply(null,t[r].split("/"));r=new Ve(r);let e=80,o=new Ve(0),g=r.subtract(new Ve(1)),E=r.add(new Ve(1));for(let L=0;LMath.abs(g))).sort(),e=Math.abs(t.shift()),o=t.length;for(;o-- >0;){let g=Math.abs(t.shift());for(;;){if(e%=g,e===0){e=g;break}if(g%=e,g===0)break}}return e},QGCD(...r){let t=r[0];for(let e=1;eg&&r<1e6&&i1(e);let E=o.length;for(let L=0;L1&&(t[r]=1),t},ifactor(r){let{bigInt:t}=u0,e=new t(r),o=new t(String(r));if(o.equals(0))return{0:1};let g=o.isNegative()?-1:1;o=o.abs();let E={};if(o.lt("65536"))E=ut.sfactor(o,E);else{let L=function(A){A.isPrime()?E[A]=(E[A]||0)+1:E=ut.sfactor(A,E)};try{let k={value:0},G=function(V,J,me){let Ae=new t(V),$e=2,Te=new t(V),Ee=new t(1);for(;Ee.equals(1);){for(let Me=0;Me<=$e&&Ee.equals(1);Me++){if(me.value++>1e3)throw new Error("stopping");Te=Te.pow(2).add(1).mod(J),Ee=t.gcd(Te.minus(Ae).abs(),J)}$e*=2,Ae=Te}return Ee.equals(J)?G(V+1,J,me):Ee};for(;!o.abs().equals(1);)if(o.isPrime()){L(o);break}else{let V=G(2,o,k);L(V),o=o.divide(V)}}catch(A){if(A.message==="timeout")throw A;E={},L(e)}}if(g===-1){let L=Mn(Cn(E).map(Number));E[`-${L}`]=E[L],delete E[L]}return E},boxfactor(r,t){t||=200;let e,o,g=Math.floor(5/12*r),E=0,L=!1;for(;e=Math.floor(r/g),o=r%g,o!==0;){if(L)return[r,1];g=Math.max(o,g-o),E++,L=E>t}return[e,g,E]},fib(r){let t=Math.sign(r);r=Math.abs(r),t=Ut(r)?t:Math.abs(t);let e=0,o=1,g=1;for(let E=2;E<=r;E++)g=e+o,e=o,o=g;return g*t},mod(r,t){return r%t},integer_part(r){return Math.sign(r)*Math.floor(Math.abs(r))},simpson(r,t,e,o){let g=function(me,Ae,$e){let Te=me(Ae),Ee=1e-12;return isNaN(Te)&&(Te=me($e===1?Ae+Ee:Ae-Ee)),Te};o||=1e-4;let E=Math.abs(Math.floor((e-t)/o));E%2!==0&&E++;let L=(e-t)/E,A=g(r,t,1),k=!1,G=t+L,V,J;for(let me=1;me1e3*Ee)return;if(Me>Ee)return a.maxDepthCount++,he+be;if(Math.abs(be)0&&In(`integrate-adaptive-simpson: Warning: maximum recursion depth (${me}) reached ${Ae.maxDepthCount} times`),Ae.nanEncountered)throw new Error("Function does not converge over interval!");return a}let A;try{A=L(r,t,e,o,g)}catch(k){if(k.message==="timeout")throw k;return ut.simpson(r,t,e)}return m0(A,12)},Ci(r){let e=.5772156649015329,o=0;for(let g=1;g<20;g++){let E=2*g;o+=(-1)**g*r**E/(E*ut.factorial(E))}return Math.log(r)+e+o},Si(r){let e=0;for(let o=0;o<20;o++){let g=2*o;e+=(-1)**o*r**(g+1)/((g+1)*ut.factorial(g+1))}return e},Ei(r){if(Number(r)===0)return-1/0;let t=30,e=.5772156649015329,o=0;for(let g=1;g0?1:r<0?0:.5},rect(r){let t=Math.abs(r);return t===.5?t:t>.5?0:1},sinc(r){return r.equals(0)?1:Math.sin(r)/r},tri(r){return r=Math.abs(r),r>=1?0:1-r},nthroot(r,t){if(r instanceof Ve||(r=new Ve(r.toString())),t instanceof Ve||(t=new Ve(t.toString())),t.equals(1))return r;let e=r.divide(new Ve(2)),o=new Ve(1e-15),g,E,L,A=t.clone().invert(),k=t.subtract(new Ve(1));do{let G=ut.bigpow(e,k),V=A.multiply(r.divide(G).subtract(e)).toDecimal(25);if(g=Ve.create(V),L)break;e=e.add(g),V=g.toDecimal(),L=E?E===V:!1,E=V}while(g.abs().gte(o));return e},sqrt(r){r instanceof Ve||(r=new Ve(r));let t,e,o,g,E=0,L=!1,A=new Ve(1e-20);t=r.divide(new Ve(2));let k=1e3;do{if(E>k)throw new Error(`Unable to calculate square root for ${r}`);t=t.add(r.divide(t)).divide(new Ve(2)),t=new Ve(t.decimal(30)),e=r.subtract(t.multiply(t)),g=o?o.equals(e):!1,(e.clone().abs().lessThan(A)||g)&&(L=!0),o=e,E++}while(!L);return t}};_e.FUNCTION_MODULES.push(ut);k0(ut);sn.Math2=ut;function gt(r){return r instanceof re.classes.NerdamerSymbol}function vt(r){return r instanceof It}function St(r){return r instanceof xt}function r1(r){return r instanceof S0}var o0={get EX(){return re.groups.EX},get CP(){return re.groups.CP},get CB(){return re.groups.CB},get S(){return re.groups.S},get PL(){return re.groups.PL},get FN(){return re.groups.FN}};function n0(r,t=null,e=null){if(e||={c:[],add(o){this.c.indexOf(o)===-1&&isNaN(o)&&this.c.push(o)}},gt(r)){let{group:o}=r,g=r.previousGroup;if(o===o0.EX&&n0(r.power,t,e),o===o0.CP||o===o0.CB||g===o0.CP||g===o0.CB)for(let E in r.symbols)Object.hasOwn(r.symbols,E)&&n0(r.symbols[E],t,e);else if(o===o0.S||g===o0.S)r.value==="e"||r.value==="pi"||r.value===_e.IMAGINARY||e.add(r.value);else if(o===o0.PL||g===o0.PL)n0(J0(r.symbols),t,e);else if(o===o0.EX)isNaN(Number(r.value))||e.add(r.value),n0(r.power,t,e);else if(o===o0.FN&&!t&&r.args)for(let E=0;E{let E,L;g.contains(t)?(E=g.stripVar(t),L=bt._.divide(g.clone(),E.clone()).power.toDecimal()):(E=g,L=0);let A=o[L];o[L]=A?bt._.add(A,E):E},!0);for(let g=0;gGt._.multiply(A,Gt.NerdamerSymbol.imaginary())))}else o=[Gt._.parse(r)];return It.fromArray(o)}function Ri(r,t,e){let g={},E;for(let L=0;L{E=bt._.parse(r,g).equals(bt._.parse(t,g))}),E}function _n(r){return gt(r)?_n(r.multiplier.toDecimal()):Number(r)%1!==0}function Li(r,t){let e=new re.classes.NerdamerSymbol(0);for(let o=0;o{o.isConstant("all")?e("constants",o):o.group===E0.S?e(o.value,o):o.group===E0.FN&&(o.fname===E0.ABS||o.fname==="")?s1(o.args[0]):o.group===E0.EX||o.group===E0.FN||e(n0(o).join(" "),o)}),t}var z0={get _(){return re.parser},get CP(){return re.groups.CP}};function o1(r,t,e){t=String(t);let o,g;if(r.group===z0.CP){let A=z0._.expand(r.clone()).stripVar(t);o=z0._.subtract(r.clone(),A.clone()),g=A}else o=r.clone();let E=o.stripVar(t),L=z0._.divide(o.clone(),E.clone());return g||=new re.classes.NerdamerSymbol(0),e?{a:E,x:L,ax:o,b:g}:[E,L,o,g]}function Bn(r,t,e){(t.isComposite()&&!r.isComposite()||t.isLinear()&&!r.isLinear())&&([r,t]=[t,r]);let o=new re.classes.NerdamerSymbol(0);return r.isLinear()?r.each(g=>{if(t.isComposite())t.isLinear()?t.each(E=>{let L=bt._.multiply(bt._.parse(g),bt._.parse(E)),A=bt._.expand(bt._.parse(L),e);o=bt._.add(o,A)},!0):o=bt._.add(o,bt._.multiply(g,bt._.parse(t)));else{let E=bt._.multiply(bt._.parse(g),bt._.parse(t));o=bt._.add(o,bt._.expand(E,e))}},!0):o=bt._.multiply(r,t),o}function l1(r){if(Dt(r)){let t=new It([]);for(let e=0;eG.trim()),e=k}else if(o==="function"){let g=r,E=g.name;return w0(E),K0(E)?!1:(p0.C.Math2[E]=g,p0._.functions[E]=[void 0,g.length],p0.USER_FUNCTIONS.includes(E)||p0.USER_FUNCTIONS.push(E),!0)}else return!1}return r=r.trim(),w0(r),K0(r)?!1:(t||=n0(p0._.parse(e)),t=t.map(o=>o.trim()),p0._.functions[r]=[p0._.mappedFunction,t.length,{name:r,params:t,body:e}],p0.USER_FUNCTIONS.includes(r)||p0.USER_FUNCTIONS.push(r),!0)}var pn={get _(){return re.parser},get C(){return re.core},get USER_FUNCTIONS(){return re.state.USER_FUNCTIONS}};function $i(){for(let r of pn.USER_FUNCTIONS)delete pn.C.Math2[r],delete pn._.functions[r]}function Di(){let r={};for(let t in bt._.functions)Object.hasOwn(bt._.functions,t)&&(r[t]=bt._.functions[t][0]);return r}var Et={get bigInt(){return re.ext.bigInt},get isSymbol(){return re.utils.isSymbol},get isVector(){return re.utils.isVector},get N(){return re.groups.N},get P(){return re.groups.P},get S(){return re.groups.S},get FN(){return re.groups.FN},get PL(){return re.groups.PL},get CB(){return re.groups.CB},get CP(){return re.groups.CP},get EX(){return re.groups.EX},get CUSTOM_OPERATORS(){return re.state.CUSTOM_OPERATORS}};function Xt(r,t=void 0,e=void 0,o=void 0){let g=t==="hash",E,L=g?void 0:t,A=L==="decimal"||L==="decimals"||L==="decimals_or_scientific";L==="decimals_or_scientific"&&typeof o>"u"&&(o=_e.DEFAULT_DECP);function k(G,V){switch(t){case"decimals":case"decimal":return E||=function(J){return!1},V?G.toDecimal(V):G.valueOf();case"recurring":{E||=function(ye){return ye.indexOf("\'")!==-1};let J=G.toString(),me=/^-?\\d+(?:\\/\\d+)?$/u.exec(J);if(me.length===0)return J;let Ae=me[0].split("/"),$e=!1,Te=Number(Ae[0]);Te<0&&(Te=-Te,$e=!0);let Ee=Number(Ae[1]);Ee||=1;let Me=Math.floor(Te/Ee),a=10*(Te-Me*Ee);for(Me=`${Me.toString()}.`;a&&a=_e.SCIENTIFIC_SWITCH_FROM_DECIMALS_MIN_EXPONENT?me.toString(_e.SCIENTIFIC_MAX_DECIMAL_PLACES):V?G.toDecimal(V):J}default:return E||=function(J){return J.indexOf("/")!==-1},G.toString()}}if(Et.isSymbol(r)){let G="",V="",J="",me=r.group||e,{value:Ae}=r;if(!g){let a=k(r.multiplier);String(a)==="-1"&&String(r.multiplier)==="-1"&&(J="-",a="1"),String(a)!=="1"&&(G=a);let ue=r.power?k(r.power):"";String(ue)!=="1"&&(gt(ue)?V=Xt(ue,L):V=ue)}switch(me){case Et.N:{G="";let a;L==="decimals_or_scientific"?a=k(r.multiplier,o):o&&A?a=r.multiplier.toDecimal(o):a=k(r.multiplier),Ae=String(r.multiplier)==="-1"?"1":a,V="";break}case Et.PL:Ae=r.collectSymbols().map(a=>{let ue=Xt(a,L,e,o);return ue==="0"&&(ue=""),ue}).sort().join("+").replace(/\\+-/gu,"-");break;case Et.CP:Ae=r.collectSymbols().map(a=>{let ue=Xt(a,L,e,o);return ue==="0"&&(ue=""),ue}).sort().join("+").replace(/\\+-/gu,"-");break;case Et.CB:Ae=r.collectSymbols(a=>{let ue=a.group;return(ue===Et.PL||ue===Et.CP)&&a.power.equals(1)&&a.multiplier.equals(1)?Mt(Xt(a,L)):Xt(a,L)}).join("*");break;case Et.EX:{let a=r.previousGroup,ue=r.power.group;a===Et.PL&&(Ae=r.collectSymbols(Xt,L).join("+").replace("+-","-")),!(a===Et.N||a===Et.S||a===Et.FN)&&!g&&(Ae=Mt(Ae)),(ue===Et.CP||ue===Et.CB||ue===Et.PL||r.power.multiplier.toString()!=="1")&&V&&(V=Mt(V));break}}if(me===Et.FN&&(Ae=r.fname+Mt(r.args.map(a=>Xt(a,L)).join(","))),me===Et.FN&&r.fname in Et.CUSTOM_OPERATORS){let a=Xt(r.args[0]),ue=Xt(r.args[1]);r.args[0].isComposite()&&(a=Mt(a)),r.args[1].isComposite()&&(ue=Mt(ue)),Ae=a+Et.CUSTOM_OPERATORS[r.fname]+ue}let $e=typeof E=="function"?E(V):!1;if(V&&me!==Et.EX&&$e&&(V=Mt(V)),((me===Et.CP||me===Et.PL)&&(G&&String(G)!=="1"||J==="-")||(me===Et.CB||me===Et.CP||me===Et.PL)&&V&&String(V)!=="1"||!g&&me===Et.P&&String(Ae)==="-1"||r.fname===_e.PARENTHESIS)&&(Ae=Mt(Ae)),o&&(t==="decimal"||(t==="decimals"||t==="decimals_or_scientific")&&G))if(G.toString().includes("e")){if(t!=="decimals_or_scientific"){let a=Number(G),ue=a.toExponential(),ve=a.toPrecision(o);G=ue.length-?\\+?\\d+)\\.?\\d*e?-?\\+?\\d*/iu.test(o)||typeof t=="object"&&t!==null&&t instanceof pe.bigDec?(this.group=pe.N,this.value=pe.CONST_HASH,this.multiplier=new Ve(t)):(this.group=pe.S,w0(t),this.value=t,this.multiplier=new Ve(1),this.imaginary=t===_e.IMAGINARY,this.isInfinity=e),this.power=new Ve(1)}static imaginary(){let t=new r(_e.IMAGINARY);return t.imaginary=!0,t}static infinity(t=void 0){let e=new r("Infinity");return t===-1&&e.negate(),e}static shell(t,e){let o=new r(e);return o.group=t,o.symbols={},o.length=0,o}static unwrapSQRT(t,e){let o=t.power;if(t.fname===_e.SQRT&&(t.isLinear()||e)){let g=t.args[0].clone();g.power=g.power.multiply(new Ve(1/2)),g.multiplier=g.multiplier.multiply(t.multiplier),t=g,e&&(t.power=o.multiply(new Ve(1/2)))}return t}static hyp(t,e){t||=new r(0),e||=new r(0);let{_:o}=pe;return o.sqrt(o.add(o.pow(t.clone(),new r(2)),o.pow(e.clone(),new r(2))))}static toPolarFormArray(t){let e=t.realpart(),o=t.imagpart(),g=r.hyp(e,o),E=e.equals(0)?pe._.parse("pi/2"):pe._.trig.atan(pe._.divide(o,e));return[g,E]}static unwrapPARENS(t){if(t.fname===""){let e=t.args[0];return e.power=e.power.multiply(t.power),e.multiplier=e.multiplier.multiply(t.multiplier),t.fname===""?r.unwrapPARENS(e):e}return t}static create(t,e){e=e===void 0?1:e;let{_:o}=pe;return o.parse(`(${t})^(${e})`)}pushMinus(){let{_:t}=pe,e=this;if((this.group===pe.CB||this.group===pe.CP||this.group===pe.PL)&&this.multiplier.lessThan(0)&&!Ut(this.power)){e=this.clone();let o=e.multiplier.clone();o.negate(),e.toUnitMultiplier();for(let g in e.symbols)if(Object.hasOwn(e.symbols,g)&&(e.symbols[g]=e.symbols[g].clone().negate(),e.group===pe.CB))break;e.length>0&&e.each(g=>g.pushMinus()),e=t.parse(e),e=t.multiply(t.parse(o),e)}return e}getNth(t){let{_:e}=pe,o=e.parse(String(t)),g=Nt(e.pow(e.parse(this.multiplier),o.clone().invert())),E=e.parse(m0(g));return Nt(e.pow(E,o.clone())).equals(e.parse(this.multiplier))?E:g}isToNth(t){let{_:e}=pe,o=this.getNth(t),g=mt(o.multiplier.toDecimal()),E;return this.group===pe.CB?(E=!0,this.each(L=>{L.isToNth(t)||(E=!1)})):E=this.group===pe.N?!0:mt(e.divide(e.parse(this.power),e.parse(t))),g&&E}isSquare(){return this.isToNth(2)}isCube(){return this.isToNth(3)}isSimple(){return this.power.equals(1)&&this.multiplier.equals(1)}powSimp(){let{_:t}=pe;if(this.group===pe.CB){let e=[],o=this.multiplier.sign();if(this.each(J=>{let me=J.power;pe.isSymbol(me)||me.equals(1)||e.push(me)}),e.length===0)return this.clone();let g=new Ve(Mn(e)),E=this.multiplier.clone().abs(),L=ut.ifactor(E.valueOf()),A=new Ve(1),k=new Ve(1);for(let J in L){if(!Object.hasOwn(L,J))continue;let me=new Ve(L[J]);me.lessThan(g)||(me=me.divide(g).subtract(new Ve(1)),k=k.multiply(new Ve(J))),A=A.multiply(t.parse(`${Mt(J)}^${Mt(me)}`).multiplier)}let G=new r(k);this.each(J=>{J=J.clone(),J.power=J.power.divide(g),G=t.multiply(G,J)});let V=t.symfunction(pe.PARENTHESIS,[G]);return V.power=g,V.multiplier=o<0?A.negate():A,V}return this.clone()}equals(t){let e;return pe.isSymbol(t)?e=t:e=new r(t),this.value===e.value&&this.power.equals(e.power)&&this.multiplier.equals(e.multiplier)&&this.group===e.group}abs(){let t=this.clone();return t.multiplier.abs(),t}gt(t){pe.isSymbol(t)||(t=new r(t));let e=t;return this.isConstant()&&e.isConstant()&&this.multiplier.greaterThan(e.multiplier)}gte(t){pe.isSymbol(t)||(t=new r(t));let e=t;return this.equals(e)||this.isConstant()&&e.isConstant()&&this.multiplier.greaterThan(e.multiplier)}lt(t){pe.isSymbol(t)||(t=new r(t));let e=t;return this.isConstant()&&e.isConstant()&&this.multiplier.lessThan(e.multiplier)}lte(t){pe.isSymbol(t)||(t=new r(t));let e=t;return this.equals(e)||this.isConstant()&&e.isConstant()&&this.multiplier.lessThan(e.multiplier)}isPoly(t=!1){let e=this.group,o=this.power;if(!mt(o)||Number(o)<0)return!1;if(e===pe.N||e===pe.S||this.isConstant(!0))return!0;let g=pe.variables(this);if(e===pe.CB&&g.length===1){let E=g[0];if(!E)return!0;for(let L in this.symbols){if(!Object.hasOwn(this.symbols,L))continue;let A=this.symbols[L];if(A.group===pe.FN&&!A.args[0].isConstant()||!A.contains(E)&&!A.isConstant(!0))return!1}return!0}if(this.isComposite()||e===pe.CB&&t){if(!t&&g.length>1)return!1;for(let E in this.symbols)if(!this.symbols[E].isPoly(t))return!1;return!0}return!1}stripVar(t,e=!1){let{_:o}=pe,g;return(this.group===pe.PL||this.group===pe.S)&&this.value===t?g=new r(e?0:this.multiplier):this.group===pe.CB&&this.isLinear()?(g=new r(1),this.each(E=>{E.contains(t,!0)||(g=o.multiply(g,E.clone()))}),g.multiplier=g.multiplier.multiply(this.multiplier)):this.group===pe.CP&&!this.isLinear()?g=new r(this.multiplier):this.group===pe.CP&&this.isLinear()?(g=new r(0),this.each(E=>{if(!E.contains(t)){let L=E.clone();L.multiplier=L.multiplier.multiply(this.multiplier),g=o.add(g,L)}}),g.equals(0)&&(g=new r(this.multiplier))):this.group===pe.EX&&this.power.contains(t,!0)?g=new r(this.multiplier):this.group===pe.FN&&this.contains(t)?g=new r(this.multiplier):g=this.clone(),g}toArray(t,e){let{_:o}=pe;e||={arr:[],add(E,L){let A=this.arr[L];this.arr[L]=A?o.add(A,E):E}};let g=this.group;if(g===pe.S&&this.contains(t))e.add(new r(this.multiplier),this.power);else if(g===pe.CB){let E=this.stripVar(t),L=o.divide(this.clone(),E.clone()),A=L.isConstant()?0:L.power;e.add(E,A)}else if(g===pe.PL&&this.value===t)this.each((E,L)=>{e.add(E.stripVar(t),L)});else if(g===pe.CP)this.each(E=>{E.toArray(t,e)});else{if(this.contains(t))throw new En("Cannot convert to array! Exiting");e.add(this.clone(),0)}e=e.arr;for(let E=0;E{let G=o.parse(k.sub(t,e));A=o.multiply(A,G)});else if(this.isComposite()){let k=this.clone();if(t.isComposite()&&k.isComposite()&&k.isLinear()&&t.isLinear()){let G=function(V,J){for(let me in V.symbols){if(!Object.hasOwn(V.symbols,me))continue;let Ae=V.symbols[me];if(Ae.isComposite()&&G(Ae,J)||Ae.equals(J))return!0}return!1};for(let V in t.symbols)if(Object.hasOwn(t.symbols,V)&&!G(k,t.symbols[V]))return k.clone();A=o.add(o.subtract(k.clone(),t),e)}else A=new r(0),k.each(G=>{A=o.add(A,G.sub(t,e))})}else if(this.group===pe.EX)A=o.parse(this.value).sub(t,e);else if(this.group===pe.FN){let k=[];for(let G=0;G{g.isConstant(t,e)||(o=!1)},!0),o}if(t==="all"&&(this.isPi()||this.isE()))return!0;if(t&&this.group===pe.FN){for(let o=0;o{e=t.add(e,o.realpart())}),e}return this.isImaginary()?new r(0):this.clone()}imagpart(){let{_:t}=pe;if(this.group===pe.S&&this.isImaginary()){let e=this;return this.power.isNegative()&&(e=this.clone(),e.power.negate(),e.multiplier.negate()),new r(e.multiplier)}if(this.isComposite()){let e=new r(0);return this.each(o=>{e=t.add(e,o.imagpart())}),e}return this.group===pe.CB?this.stripVar(_e.IMAGINARY):new r(0)}isInteger(){return this.isConstant()&&this.multiplier.isInteger()}isLinear(t){if(t){if(this.isConstant()||!this.contains(t,!0))return!0;if(this.group===pe.S)return this.value===t?this.power.equals(1):!0;if(this.isComposite()&&this.power.equals(1)){for(let e in this.symbols)if(!this.symbols[e].isLinear(t))return!1;return!0}return this.group===pe.CB?this.symbols[t]?this.symbols[t].isLinear(t):!0:!1}return this.power.equals(1)}containsFunction(t){if(typeof t=="string"&&(t=[t]),this.group===pe.FN&&t.indexOf(this.fname)!==-1)return!0;if(this.symbols){for(let e in this.symbols)if(this.symbols[e].containsFunction(t))return!0}return!1}multiplyPower(t){let{_:e}=pe;if(this.group===pe.N&&this.multiplier.equals(1))return this;let o=this.power;if(this.group!==pe.EX&&pe.isSymbol(t)&&t.group===pe.N){let g=t.multiplier;this.group===pe.N&&!g.isInteger()&&this.convert(pe.P),this.power=o.equals(1)?g.clone():o.multiply(g),this.group===pe.P&&mt(this.power)&&(this.value=String(Number(this.value)**Number(this.power)),this.toLinear(),this.convert(pe.N))}else{this.group!==pe.EX&&(o=new r(o),this.convert(pe.EX));let g=e.multiply(o,t);this.power=g}return this}setPower(t,e=!1){if(this.group===pe.N&&this.multiplier.equals(1))return this;if(this.group===pe.EX&&!pe.isSymbol(t))this.group=this.previousGroup,delete this.previousGroup,this.group===pe.N?(this.multiplier=new Ve(this.value),this.value=pe.CONST_HASH):this.power=t;else{let o=!1;pe.isSymbol(t)&&(t.group===pe.N?t=t.multiplier:o=!0);let g=o?pe.EX:pe.P;this.power=t,this.group===pe.N&&g&&this.convert(g,e)}return this}isInverse(){return this.group===pe.EX?this.power.multiplier.lessThan(0):Number(this.power)<0}clone(t=void 0){let e=this,o=t||new r(0),g=["value","group","length","previousGroup","imaginary","fname","args","isInfinity","scientific"],E=g.length,L;if(e.symbols){o.symbols={};for(let G in e.symbols)Object.hasOwn(e.symbols,G)&&(o.symbols[G]=e.symbols[G].clone())}for(L=0;Lo.invert()):this.power&&this.group!==pe.N&&this.power.negate(),this}distributeMultiplier(t=!1){let e=t?this.power.absEquals(1):this.power.equals(1);if(this.symbols&&e&&this.group!==pe.CB&&!this.multiplier.equals(1)){for(let o in this.symbols){if(!Object.hasOwn(this.symbols,o))continue;let g=this.symbols[o];g.multiplier=g.multiplier.multiply(this.multiplier),g.distributeMultiplier()}this.toUnitMultiplier()}return this}distributeExponent(){let{_:t}=pe;if(!this.power.equals(1)){let e=this.power;for(let o in this.symbols){if(!Object.hasOwn(this.symbols,o))continue;let g=this.symbols[o];g.group===pe.EX?g.power=t.multiply(g.power,new r(e)):pe.isSymbol(this.symbols[o].power)?this.symbols[o].power=t.multiply(this.symbols[o].power,new r(e)):this.symbols[o].power=this.symbols[o].power.multiply(e)}this.toLinear()}return this}convert(t,e=void 0){if(t>pe.FN){let o=this.clone();this.symbols={},t===pe.CB?o.toUnitMultiplier():this.toUnitMultiplier(),this.group===pe.FN&&(o.args=this.args,delete this.args,delete this.fname),this.isImgSymbol&&delete this.isImgSymbol,this.toLinear(),this.symbols[o.keyForGroup(t)]=o,this.group=t,this.length=1}else if(t===pe.EX)this.group===pe.N&&this.multiplier.equals(1)||(this.group!==pe.EX&&(this.previousGroup=this.group),this.group===pe.N?(this.value=this.multiplier.num.toString(),this.toUnitMultiplier()):this.value=pe.text(this,"hash"),this.group=pe.EX);else if(t===pe.N){let o=this.multiplier.toDecimal();this.symbols&&=void 0,new r(this.group===pe.P?Number(o)*Number(this.value)**Number(this.power):o).clone(this)}else t===pe.P&&this.group===pe.N&&(this.value=e?this.multiplier.num.toString():String(Math.abs(Number(this.multiplier.num.toString()))),this.toUnitMultiplier(!e),this.group=pe.P);return this}insert(t,e){let{_:o}=pe;if(pe.isSymbol(t)||Pt(`Object ${t} is not of type NerdamerSymbol!`),this.symbols){let{group:g}=this;if(g>pe.FN){let E=t.keyForGroup(g),L=E in this.symbols?this.symbols[E]:!1;if(e==="add"){let A=E;L?(this.symbols[A]=o.add(L,t),this.symbols[A].multiplier.equals(0)&&(delete this.symbols[A],this.length--,this.length===0&&(this.convert(pe.N),this.multiplier=new Ve(0)))):(this.symbols[E]=t,this.length++)}else t.group===pe.P&&mt(t.power)&&t.convert(pe.N),t.group===pe.EX?(t.parens=t.multiplier.lessThan(0),this.multiplier=this.multiplier.multiply(t.multiplier.clone().abs()),t.toUnitMultiplier(!0)):(this.multiplier=this.multiplier.multiply(t.multiplier),t.toUnitMultiplier()),L&&(t=o.multiply(d0(this.symbols,E),t),t.isConstant()&&(this.multiplier=this.multiplier.multiply(t.multiplier),t=new r(1)),this.length--),t.isOne(!0)?t.multiplier.lessThan(0)&&this.negate():(this.symbols[E]=t,this.length++);this.length===0&&this.convert(pe.N),(this.group===pe.CP||this.group===pe.CB)&&this.updateHash()}}return this}attach(t){if(Dt(t)){for(let e=0;e{(Number(g.power)>0||g.group===pe.EX&&g.power.multiplier.greaterThan(0))&&(e=t.multiply(e,g.clone()))})):e=t.parse(o.multiplier.num),e}toString(){return this.text()}};re.classes.NerdamerSymbol=W;var nn=class{constructor(){let{N:t,P:e,S:o,EX:g,FN:E,PL:L,CB:A,CP:k}=bt,{SQRT:G,ABS:V,FACTORIAL:J,DOUBLEFACTORIAL:me,PARENTHESIS:Ae}=bt,{bigDec:$e,PRIMES:Te,VARS:Ee}=bt,Me=this,a=Me,ue={},ve={names:[],actions:[]};class Ne{upper;lower;constructor(i,l){this.upper=i,this.lower=l}isConstant(){let i=this.upper,l=this.lower;return i.isConstant()&&l.isConstant()}text(){return`${Xt(this.upper)}:${Xt(this.lower)}`}}class ye{static OPERATOR="OPERATOR";static VARIABLE_OR_LITERAL="VARIABLE_OR_LITERAL";static FUNCTION="FUNCTION";static UNIT="UNIT";static KEYWORD="KEYWORD";static MAX_PRECEDENCE=999;constructor(i,l,v){if(this.type=l,this.value=i,v!==void 0&&(this.column=v+1),l===ye.OPERATOR){let d=we[i];for(let T in d)Object.hasOwn(d,T)&&(this[T]=d[T])}else l===ye.FUNCTION&&(this.precedence=ye.MAX_PRECEDENCE,this.leftAssoc=!1)}toString(){return this.is_prefix?`\\`${this.value}`:this.value}}this.classes={Collection:t0,Slice:Ne,Token:ye};let Ie={prec:void 0,cos(n,i){let l=a.parse(String(Math.cos(n)*Math.cosh(i))),v=a.parse(String(Math.sin(n)*Math.sinh(i)));return a.subtract(l,a.multiply(v,W.imaginary()))},sin(n,i){let l=a.parse(String(Math.sin(n)*Math.cosh(i))),v=a.parse(String(Math.cos(n)*Math.sinh(i)));return a.subtract(l,a.multiply(v,W.imaginary()))},tan(n,i){let l=a.parse(String(Math.sin(2*n)/(Math.cos(2*n)+Math.cosh(2*i)))),v=a.parse(String(Math.sinh(2*i)/(Math.cos(2*n)+Math.cosh(2*i))));return a.add(l,a.multiply(v,W.imaginary()))},sec(n,i){let l=this.removeDen(this.cos(n,i));return a.subtract(l[0],a.multiply(l[1],W.imaginary()))},csc(n,i){let l=this.removeDen(this.sin(n,i));return a.add(l[0],a.multiply(l[1],W.imaginary()))},cot(n,i){let l=this.removeDen(this.tan(n,i));return a.subtract(l[0],a.multiply(l[1],W.imaginary()))},acos(n,i){let l=this.fromArray([n,i]),v=a.pow(l.clone(),new W(2)),d=a.expand(v),T=a.multiply(Fe(a.subtract(new W(1),d)),W.imaginary()),M=a.expand(a.add(l.clone(),T)),I=B(M);return a.expand(a.multiply(W.imaginary().negate(),I))},asin(n,i){return a.subtract(a.parse("pi/2"),this.acos(n,i))},atan(n,i){if(n.equals(0)&&(i.equals(1)||i.equals(-1)))return a.parse(`${W.infinity()}*${_e.IMAGINARY}*${i}`);let l=Ie.fromArray([n,i]),v=a.expand(a.multiply(W.imaginary(),l.clone())),d=B(a.expand(a.subtract(new W(1),v.clone()))),T=B(a.expand(a.add(new W(1),v.clone())));return a.expand(a.multiply(a.divide(W.imaginary(),new W(2)),a.subtract(d,T)))},asec(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.acos(...l)},acsc(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.asin(...l)},acot(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.atan(...l)},cosh(n,i){let l=a.parse(String(Math.cosh(n)*Math.cos(i))),v=a.parse(String(Math.sinh(n)*Math.sin(i)));return a.add(l,a.multiply(v,W.imaginary()))},sinh(n,i){let l=a.parse(String(Math.sinh(n)*Math.cos(i))),v=a.parse(String(Math.cosh(n)*Math.sin(i)));return a.add(l,a.multiply(v,W.imaginary()))},tanh(n,i){let l=a.parse(String(Math.sinh(2*n)/(Math.cos(2*i)+Math.cosh(2*n)))),v=a.parse(String(Math.sin(2*i)/(Math.cos(2*i)+Math.cosh(2*n))));return a.subtract(l,a.multiply(v,W.imaginary()))},sech(n,i){let l=this.removeDen(this.cosh(n,i));return a.subtract(l[0],a.multiply(l[1],W.imaginary()))},csch(n,i){let l=this.removeDen(this.sinh(n,i));return a.subtract(l[0],a.multiply(l[1],W.imaginary()))},coth(n,i){let l=this.removeDen(this.tanh(n,i));return a.add(l[0],a.multiply(l[1],W.imaginary()))},acosh(n,i){let l=this.fromArray([n,i]),v=Fe(a.add(l.clone(),new W(1))),d=Fe(a.subtract(l.clone(),new W(1)));return a.expand(B(a.add(l,a.expand(a.multiply(v,d)))))},asinh(n,i){let l=this.fromArray([n,i]),v=Fe(a.add(new W(1),a.expand(a.pow(l.clone(),new W(2)))));return a.expand(B(a.add(l,v)))},atanh(n,i){let l=this.fromArray([n,i]),v=B(a.add(l.clone(),new W(1))),d=B(a.subtract(new W(1),l));return a.expand(a.divide(a.subtract(v,d),new W(2)))},asech(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.acosh(...l)},acsch(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.asinh(...l)},acoth(n,i){let l=this.removeDen([n,i]);return l[1].negate(),this.atanh(...l)},sqrt(n){let i=n.realpart(),l=n.imagpart(),v=W.hyp(i,l),d=a.add(i.clone(),v),T=Fe(a.multiply(new W(2),d.clone()));return a.add(a.divide(d.clone(),T.clone()),a.multiply(a.divide(l,T),W.imaginary()))},log(n,i){let l=B(W.hyp(n,i)),v=_e.USE_BIG?new W($e.atan2(i.multiplier.toDecimal(),n.multiplier.toDecimal())):Math.atan2(i,n),d=a.parse(v);return a.add(l,a.multiply(W.imaginary(),d))},erf(n,i){return a.symfunction("erf",[n])},removeDen(n){let i,l;Dt(n)?(i=n[0],l=n[1]):(i=n.realpart(),l=n.imagpart());let v=i**2+l**2,d=a.parse(String(i/v)),T=a.parse(String(l/v));return[d,T]},fromArray(n){return a.add(n[0],a.multiply(W.imaginary(),n[1]))},evaluate(n,i){let l,v,d=n.power.sign();if(n.power=n.power.abs(),n.power.greaterThan(1)&&(n=a.expand(n)),d<0){let T=this.removeDen(n);l=T[0],v=T[1]}else l=n.realpart(),v=n.imagpart();return l.isConstant("all")&&v.isConstant("all")?this[i](l,v):a.symfunction(i,[n])}},he=this.trig={cos(n){if(n.equals("pi")&&n.multiplier.den.equals(2))return new W(0);if(_e.PARSE2NUMBER){if(n.equals(new W(_e.PI/2)))return new W(0);if(n.isConstant())return _e.USE_BIG?new W($e.cos(n.multiplier.toDecimal())):new W(Math.cos(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"cos")}if(n.equals(0))return new W(1);let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier.abs();if(n.multiplier=d,n.isPi()&&n.isLinear())if(mt(d))i=new W(Ut(d)?1:-1);else{let T=Number(d.num),M=Number(d.den);M===2?i=new W(0):M===3?(i=a.parse("1/2"),l=!0):M===4?(i=a.parse("1/sqrt(2)"),l=!0):M===6?(i=a.parse("sqrt(3)/2"),l=!0):i=a.symfunction("cos",[n])}return l&&(v===2||v===3)&&i.negate(),i||=a.symfunction("cos",[n]),i},sin(n){if(_e.PARSE2NUMBER){if(n.isConstant())return Number(n.multiplier.toDecimal())%Math.PI===0?new W(0):_e.USE_BIG?new W($e.sin(n.multiplier.toDecimal())):new W(Math.sin(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"sin")}if(n.equals(0))return new W(0);let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier.sign(),T=n.multiplier.abs();if(n.multiplier=T,n.equals("pi"))i=new W(0);else if(n.isPi()&&n.isLinear())if(mt(T))i=new W(0);else{let M=T.num,I=T.den;I.equals(2)?(i=new W(1),l=!0):I.equals(3)?(i=a.parse("sqrt(3)/2"),l=!0):I.equals(4)?(i=a.parse("1/sqrt(2)"),l=!0):I.equals(6)?(i=a.parse("1/2"),l=!0):i=a.multiply(new W(d),a.symfunction("sin",[n]))}return i||=a.multiply(new W(d),a.symfunction("sin",[n])),l&&(v===3||v===4)&&i.negate(),i},tan(n){if(_e.PARSE2NUMBER){if(Number(n.multiplier.toDecimal())%Math.PI===0&&n.isLinear())return new W(0);if(n.isConstant())return _e.USE_BIG?new W($e.tan(n.multiplier.toDecimal())):new W(Math.tan(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"tan")}let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier;if(n.multiplier=d,n.isPi()&&n.isLinear())if(mt(d))i=new W(0);else{let T=d.num,M=d.den;if(M.equals(2))throw new Ht(`tan is undefined for ${n.toString()}`);M.equals(3)?(i=a.parse("sqrt(3)"),l=!0):M.equals(4)?(i=new W(1),l=!0):M.equals(6)?(i=a.parse("1/sqrt(3)"),l=!0):i=a.symfunction("tan",[n])}return i||=a.symfunction("tan",[n]),l&&(v===2||v===4)&&i.negate(),i},sec(n){if(_e.PARSE2NUMBER)return n.isConstant()?_e.USE_BIG?new W(new $e(1).dividedBy($e.cos(n.multiplier.toDecimal()))):new W(ut.sec(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"sec"):a.parse(qt("1/cos({0})",n));let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier.abs();if(n.multiplier=d,n.isPi()&&n.isLinear())if(mt(d))i=new W(Ut(d)?1:-1);else{let T=d.num,M=d.den;if(M.equals(2))throw new Ht(`sec is undefined for ${n.toString()}`);M.equals(3)?(i=new W(2),l=!0):M.equals(4)?(i=a.parse("sqrt(2)"),l=!0):M.equals(6)?(i=a.parse("2/sqrt(3)"),l=!0):i=a.symfunction("sec",[n])}return l&&(v===2||v===3)&&i.negate(),i||=a.symfunction("sec",[n]),i},csc(n){if(_e.PARSE2NUMBER)return n.isConstant()?_e.USE_BIG?new W(new $e(1).dividedBy($e.sin(n.multiplier.toDecimal()))):new W(ut.csc(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"csc"):a.parse(qt("1/sin({0})",n));let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier.sign(),T=n.multiplier.abs();if(n.multiplier=T,n.isPi()&&n.isLinear()){if(mt(T))throw new Ht(`csc is undefined for ${n.toString()}`);{let M=T.num,I=T.den;I.equals(2)?(i=new W(1),l=!0):I.equals(3)?(i=a.parse("2/sqrt(3)"),l=!0):I.equals(4)?(i=a.parse("sqrt(2)"),l=!0):I.equals(6)?(i=new W(2),l=!0):i=a.multiply(new W(d),a.symfunction("csc",[n]))}}return i||=a.multiply(new W(d),a.symfunction("csc",[n])),l&&(v===3||v===4)&&i.negate(),i},cot(n){if(_e.PARSE2NUMBER)return Number(n.multiplier.toDecimal())%(Math.PI/2)===0?new W(0):n.isConstant()?_e.USE_BIG?new W(new $e(1).dividedBy($e.tan(n.multiplier.toDecimal()))):new W(ut.cot(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"cot"):a.parse(qt("1/tan({0})",n));let i,l=!1,v=Y(n.multiplier.toDecimal()),d=n.multiplier;if(n.multiplier=d,n.isPi()&&n.isLinear()){if(mt(d))throw new Ht(`cot is undefined for ${n.toString()}`);{let T=d.num,M=d.den;M.equals(2)?i=new W(0):M.equals(3)?(i=a.parse("1/sqrt(3)"),l=!0):M.equals(4)?(i=new W(1),l=!0):M.equals(6)?(i=a.parse("sqrt(3)"),l=!0):i=a.symfunction("cot",[n])}}return i||=a.symfunction("cot",[n]),l&&(v===2||v===4)&&i.negate(),i},acos(n){if(_e.PARSE2NUMBER){if(n.isConstant()){if(n.gt(1)||n.lt(-1)){let i=n.toString();return le(Nt(`pi/2-asin(${i})`))}return _e.USE_BIG?new W($e.acos(n.multiplier.toDecimal())):new W(Math.acos(n.valueOf()))}if(n.isImaginary())return Ie.evaluate(n,"acos")}return a.symfunction("acos",[n])},asin(n){if(_e.PARSE2NUMBER){if(n.isConstant()){if(n.gt(1)||n.lt(-1)){let i=_e.IMAGINARY,l=n.multiplier.toDecimal();return le(Nt(`${i}*log(sqrt(1-${l}^2)-${i}*${l})`))}return _e.USE_BIG?new W($e.asin(n.multiplier.toDecimal())):new W(Math.asin(n.valueOf()))}if(n.isImaginary())return Ie.evaluate(n,"asin")}return a.symfunction("asin",[n])},atan(n){let i;if(n.equals(0))i=new W(0);else{if(_e.PARSE2NUMBER)return n.isConstant()?_e.USE_BIG?new W($e.atan(n.multiplier.toDecimal())):new W(Math.atan(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"atan"):a.symfunction("atan",[n]);n.equals(-1)?i=a.parse("-pi/4"):i=a.symfunction("atan",[n])}return i},asec(n){if(_e.PARSE2NUMBER){if(n.equals(0))throw new hn("Input is out of the domain of sec!");if(n.isConstant())return he.acos(n.invert());if(n.isImaginary())return Ie.evaluate(n,"asec")}return a.symfunction("asec",[n])},acsc(n){if(_e.PARSE2NUMBER){if(n.isConstant())return he.asin(n.invert());if(n.isImaginary())return Ie.evaluate(n,"acsc")}return a.symfunction("acsc",[n])},acot(n){if(_e.PARSE2NUMBER){if(n.isConstant())return a.add(a.parse("pi/2"),he.atan(n).negate());if(n.isImaginary())return Ie.evaluate(n,"acot")}return a.symfunction("acot",[n])},atan2(n,i){if(n.equals(0)&&i.equals(0))throw new Ht("atan2 is undefined for 0, 0");return _e.PARSE2NUMBER&&n.isConstant()&&i.isConstant()?new W(Math.atan2(n,i)):a.symfunction("atan2",[n,i])}},be=this.trigh={cosh(n){if(_e.PARSE2NUMBER){if(n.isConstant())return new W(Math.cosh(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"cosh")}return a.symfunction("cosh",[n])},sinh(n){if(_e.PARSE2NUMBER){if(n.isConstant())return new W(Math.sinh(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"sinh")}return a.symfunction("sinh",[n])},tanh(n){if(_e.PARSE2NUMBER){if(n.isConstant())return new W(Math.tanh(n.valueOf()));if(n.isImaginary())return Ie.evaluate(n,"tanh")}return a.symfunction("tanh",[n])},sech(n){return _e.PARSE2NUMBER?n.isConstant()?new W(Math.sech(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"sech"):a.parse(qt("1/cosh({0})",n)):a.symfunction("sech",[n])},csch(n){return _e.PARSE2NUMBER?n.isConstant()?new W(Math.csch(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"csch"):a.parse(qt("1/sinh({0})",n)):a.symfunction("csch",[n])},coth(n){return _e.PARSE2NUMBER?n.isConstant()?new W(Math.coth(n.valueOf())):n.isImaginary()?Ie.evaluate(n,"coth"):a.parse(qt("1/tanh({0})",n)):a.symfunction("coth",[n])},acosh(n){let i;return _e.PARSE2NUMBER&&n.isImaginary()?i=Ie.evaluate(n,"acosh"):_e.PARSE2NUMBER?i=Nt(a.parse(qt(`${_e.LOG}(({0})+sqrt(({0})^2-1))`,n.toString()))):i=a.symfunction("acosh",[n]),i},asinh(n){let i;return _e.PARSE2NUMBER&&n.isImaginary()?i=Ie.evaluate(n,"asinh"):_e.PARSE2NUMBER?i=Nt(a.parse(qt(`${_e.LOG}(({0})+sqrt(({0})^2+1))`,n.toString()))):i=a.symfunction("asinh",[n]),i},atanh(n){let i;return _e.PARSE2NUMBER&&n.isImaginary()?i=Ie.evaluate(n,"atanh"):_e.PARSE2NUMBER?i=Nt(a.parse(qt(`(1/2)*${_e.LOG}((1+({0}))/(1-({0})))`,n.toString()))):i=a.symfunction("atanh",[n]),i},asech(n){let i;return _e.PARSE2NUMBER&&n.isImaginary()?i=Ie.evaluate(n,"asech"):_e.PARSE2NUMBER?i=Nt(B(a.add(n.clone().invert(),Fe(a.subtract(a.pow(n,new W(-2)),new W(1)))))):i=a.symfunction("asech",[n]),i},acsch(n){let i;return _e.PARSE2NUMBER&&n.isImaginary()?i=Ie.evaluate(n,"acsch"):_e.PARSE2NUMBER?i=Nt(a.parse(qt(`${_e.LOG}((1+sqrt(1+({0})^2))/({0}))`,n.toString()))):i=a.symfunction("acsch",[n]),i},acoth(n){let i;if(_e.PARSE2NUMBER&&n.isImaginary())i=Ie.evaluate(n,"acoth");else if(_e.PARSE2NUMBER)if(n.equals(1))i=W.infinity();else{let l=B(a.divide(a.add(n.clone(),new W(1)),a.subtract(n.clone(),new W(1))));i=Nt(a.divide(l,new W(2)))}else i=a.symfunction("acoth",[n]);return i}};this.units={};let we={"\\\\":{precedence:8,operator:"\\\\",action:"slash",prefix:!0,postfix:!1,leftAssoc:!0,operation(n){return n}},"!!":{precedence:7,operator:"!!",action:"dfactorial",prefix:!1,postfix:!0,leftAssoc:!0,operation(n){return a.symfunction(_e.DOUBLEFACTORIAL,[n])}},"!":{precedence:7,operator:"!",action:"factorial",prefix:!1,postfix:!0,leftAssoc:!0,operation(n){return D(n)}},"^":{precedence:6,operator:"^",action:"pow",prefix:!1,postfix:!1,leftAssoc:!0},"**":{precedence:6,operator:"**",action:"pow",prefix:!1,postfix:!1,leftAssoc:!0},"%":{precedence:4,operator:"%",action:"percent",prefix:!1,postfix:!0,leftAssoc:!0,overloaded:!0,overloadAction:"mod",overloadLeftAssoc:!1,operation(n){return a.divide(n,new W(100))}},"*":{precedence:4,operator:"*",action:"multiply",prefix:!1,postfix:!1,leftAssoc:!1},"/":{precedence:4,operator:"/",action:"divide",prefix:!1,postfix:!1,leftAssoc:!1},"+":{precedence:3,operator:"+",action:"add",prefix:!0,postfix:!1,leftAssoc:!1,operation(n){return n}},plus:{precedence:3,operator:"plus",action:"add",prefix:!0,postfix:!1,leftAssoc:!1,operation(n){return n}},"-":{precedence:3,operator:"-",action:"subtract",prefix:!0,postfix:!1,leftAssoc:!1,operation(n){return n.negate()}},"=":{precedence:2,operator:"=",action:"equals",prefix:!1,postfix:!1,leftAssoc:!1},"==":{precedence:1,operator:"==",action:"eq",prefix:!1,postfix:!1,leftAssoc:!1},"<":{precedence:1,operator:"<",action:"lt",prefix:!1,postfix:!1,leftAssoc:!1},"<=":{precedence:1,operator:"<=",action:"lte",prefix:!1,postfix:!1,leftAssoc:!1},">":{precedence:1,operator:">",action:"gt",prefix:!1,postfix:!1,leftAssoc:!1},"=>":{precedence:1,operator:"=>",action:"gte",prefix:!1,postfix:!1,leftAssoc:!1},",":{precedence:0,operator:",",action:"comma",prefix:!1,postfix:!1,leftAssoc:!1},":":{precedence:0,operator:",",action:"assign",prefix:!1,postfix:!1,leftAssoc:!1,vectorFn:"slice"},":=":{precedence:0,operator:",",action:"functionAssign",prefix:!1,postfix:!1,leftAssoc:!0}},fe={"(":{type:"round",id:1,is_open:!0,is_close:!1},")":{type:"round",id:2,is_open:!1,is_close:!0},"[":{type:"square",id:3,is_open:!0,is_close:!1,maps_to:"vector"},"]":{type:"square",id:4,is_open:!1,is_close:!0},"{":{type:"curly",id:5,is_open:!0,is_close:!1,maps_to:"NerdamerSet"},"}":{type:"curly",id:6,is_open:!1,is_close:!0}},s=this.functions={cos:[he.cos,1],sin:[he.sin,1],tan:[he.tan,1],sec:[he.sec,1],csc:[he.csc,1],cot:[he.cot,1],acos:[he.acos,1],asin:[he.asin,1],atan:[he.atan,1],arccos:[he.acos,1],arcsin:[he.asin,1],arctan:[he.atan,1],asec:[he.asec,1],acsc:[he.acsc,1],acot:[he.acot,1],atan2:[he.atan2,2],acoth:[be.acoth,1],asech:[be.asech,1],acsch:[be.acsch,1],sinh:[be.sinh,1],cosh:[be.cosh,1],tanh:[be.tanh,1],asinh:[be.asinh,1],sech:[be.sech,1],csch:[be.csch,1],coth:[be.coth,1],acosh:[be.acosh,1],atanh:[be.atanh,1],log10:[void 0,1],log2:[void 0,1],log1p:[void 0,1],exp:[xe,1],radians:[Re,1],degrees:[He,1],min:[$,-1],max:[f,-1],erf:[void 0,1],floor:[void 0,1],ceil:[void 0,1],trunc:[void 0,1],Si:[void 0,1],step:[void 0,1],rect:[void 0,1],sinc:[Se,1],tri:[void 0,1],sign:[w,1],Ci:[void 0,1],Ei:[void 0,1],Shi:[void 0,1],Chi:[void 0,1],Li:[void 0,1],fib:[void 0,1],fact:[D,1],factorial:[D,1],continuedFraction:[K,[1,2]],dfactorial:[void 0,1],gamma_incomplete:[void 0,[1,2]],round:[Z,[1,2]],scientific:[Xe,[1,2]],mod:[te,2],pfactor:[Q,1],vector:[ft,-1],matrix:[At,-1],NerdamerSet:[$t,-1],imatrix:[ge,-1],parens:[q,-1],sqrt:[Fe,1],cbrt:[De,1],nthroot:[Be,2],log:[B,[1,2]],expand:[ne,1],abs:[P,1],invert:[Vt,1],determinant:[Tt,1],size:[pt,1],transpose:[Ot,1],dot:[Ft,2],cross:[_t,2],vecget:[ke,2],vecset:[We,3],vectrim:[Le,[1,2]],matget:[Qe,3],matset:[ct,4],matgetrow:[Ze,2],matsetrow:[tt,3],matgetcol:[je,2],matsetcol:[lt,3],rationalize:[Oe,1],IF:[ce,3],isIn:[de,2],realpart:[H,1],imagpart:[X,1],conjugate:[F,1],arg:[ee,1],polarform:[_,1],rectform:[x,1],sort:[U,[1,2]],integer_part:[void 0,1],union:[Jt,2],contains:[Yt,2],intersection:[c0,2],difference:[r0,2],intersects:[Kt,2],isSubset:[v0,2],primes:[u,2],print:[y,-1]};this.error=Pt;let c=function(n){let i=_e.FUNCTION_MODULES,l=i.length;for(let v=0;vqe&&Pt(qt(Ce,"maximum",qe,Pe))}let j=un(l);return M?I=M.apply(d[2],l):(M=c(i),_e.PARSE2NUMBER&&j?I=ie(M.apply(M,l)):I=a.symfunction(i,l)),I},this.operator_filter_regex=(function(){let i=`^\\\\${Object.keys(we).filter(l=>l.length===1).join("\\\\")}`;return new RegExp(`([${i}])\\\\s+([${i}])`)})(),this.setOperator=function(i,l=void 0,v=void 0){let d=i.operator;if(we[d]=i,l&&(this[i.action]=l),Me[d]=i.operation,!i.action&&!(i.prefix||i.postif)&&(i.action=d),v==="over"||v==="under"){let{precedence:T}=i;for(let M in we){if(!Object.hasOwn(we,M))continue;let I=we[M];(v==="over"?I.precedence>=T:I.precedence>T)&&I.precedence++}}},this.getOperator=function(i){return we[i]},this.aliasOperator=function(i,l){let v={},d=we[i];for(let T in d)Object.hasOwn(d,T)&&(v[T]=d[T]);v.operator=l,this.setOperator(v)},this.getOperators=function(){return we},this.getBrackets=function(){return fe};let S=function(i,l){i=String(i);for(let v=0;vF0(v)),i=i.replace(/(?F0(v))),i=i.replace(_e.IMPLIED_MULTIPLICATION_REGEX,(v,d,T,M,I)=>{let j=I.charAt(M),se="",ae="*";return j.match(/[+\\-/*]/u)||(se=I.charAt(M-1)),se.match(/[a-z]/iu)&&(ae=""),d+ae+T}).replace(/(?[a-z0-9_]+)/giu,(v,d)=>_e.USE_MULTICHARACTER_VARS===!1&&!(d in s)&&isNaN(d)?d.split("").join("*"):d).replace(/\\)\\(/gu,")*(")||"0";;){let v=i;if(i=i.replace(/(?[a-z0-9_]+)(?\\()|(?\\))(?[a-z0-9]+)/giu,(d,T,M,I,j)=>{let se=T||I,ae=M||j;return se in s?se+ae:`${se}*${ae}`}),v===i)break}return i};this.initConstants=function(){this.CONSTANTS={E:new W(_e.E),PI:new W(_e.PI)}},this.prettyPrint=function(i){if(Array.isArray(i)){let l=i,v=l.map(d=>a.prettyPrint(d)).join(", ");return l.type==="vector"?`vector<${v}>`:`(${v})`}return i.toString()},this.peekers={pre_operator:[],post_operator:[],pre_function:[],post_function:[]},this.callPeekers=function(i,...l){if(_e.callPeekers){let v=this.peekers[i],d=l.map(T1);for(let T=0;Tae.precedence||!ae.leftAssoc&&qe.precedence===ae.precedence))break;M.push(I.pop())}if((l==="vector"||l==="set")&&"vectorFn"in ae&&(ae.action=ae.vectorFn),ae.postfix){let qe=i[d-1];if(qe){if(qe.type===ye.OPERATOR&&!qe.postfix)throw new _0(`Unexpected prefix operator \'${qe.value}\'! at ${qe.column}`)}else throw new _0(`Unexpected prefix operator \'${T.value}\'! at ${T.column}`)}else{let qe;do{let Pe=i[d+1];if(qe=Pe?Pe.type===ye.OPERATOR:!1,qe){if(!Pe.prefix)throw new _0(`A prefix operator was expected at ${Pe.column}`);Pe.is_prefix=!0,j.push(Pe),d++}}while(qe)}for(ae.is_prefix?j.push(ae):I.push(ae);j.length&&(ae.leftAssoc||!ae.leftAssoc&&j[j.length-1].precedence>=ae.precedence);)I.push(j.pop())}else if(T.type===ye.VARIABLE_OR_LITERAL){M.length===0&&se(j,I),M.push(T);let ae=I[I.length-1];(!ae||!ae.leftAssoc)&&se(j,M)}else T.type===ye.FUNCTION?I.push(T):T.type===ye.UNIT&&M.push(T);if(Array.isArray(T)){let ae=T;M.push(this.toRPN(T)),ae.type&&M.push(new ye(ae.type,ye.FUNCTION,ae.column))}}return se(I,M),se(j,M),M},this.parseRPN=function(i,l){try{l||={};for(let M in l)Object.hasOwn(l,M)&&(l[M]=a.parse(l[M],{}));_e.PARSE2NUMBER&&("e"in l||(l.e=new W(_e.E)),"pi"in l||(l.pi=new W(_e.PI)));let v=[],d;for(let M=0,I=i.length;M"u")throw new _0(`${d} is not a valid postfix operator at ${d.column}`);let ae=d.action==="comma";se instanceof g0&&!ae&&(se=It.fromSet(se)),j instanceof g0&&!ae&&(j=It.fromSet(j)),this.callPeekers("pre_operator",se,j,d);let qe=a[d.action](se,j);this.callPeekers("post_operator",qe,se,j,d),v.push(qe)}else if(d.type===ye.FUNCTION){let j=v.pop(),{parent:se}=j;j instanceof t0||(j=t0.create(j));let ae=d.value,qe=j.getItems();this.callPeekers("pre_function",ae,qe);let Pe=a.callfunction(ae,qe);this.callPeekers("post_function",Pe,ae,qe);let Ce=v[v.length-1],Ge=i[M+1],st=Ge&&Ge.type===ye.OPERATOR&&Ge.value===",";se&&(Pe.parent=se),v.push(Pe)}else{let j,se=d.value;if(se in _e.ALIASES)d=a.parse(_e.ALIASES[d]);else if(d.type===ye.VARIABLE_OR_LITERAL)d=new W(se);else if(d.type===ye.UNIT){let ae=new W(se);ae.isUnit=!0,d=ae}se in a.CONSTANTS?(j=d,d=new W(a.CONSTANTS[se])):se in l&&se!==l[se].toString()?(j=d,d=l[se].clone()):se in Ee&&(j=d,d=Ee[se].clone()),j&&(d.subbed=j),v.push(d)}let T=v[0];if(["undefined","string","number"].indexOf(typeof T)!==-1)throw new Zn("Unexpected token!");return T}catch(v){if(v.message==="timeout"||v instanceof TypeError||v instanceof ReferenceError||v instanceof RangeError)throw v;[hn].forEach(M=>{if(v instanceof M){let I=v.column;throw new M(`${v.message}${I?`: ${I}`:""}`)}});let T=v.column;throw new Gn(`${v.message}${T?`: ${T}`:""}`)}};class O{constructor(i){this.type=i.type,this.value=i.value,this.left=i.left,this.right=i.right}toString(){let i=this.left?`${this.left.toString()}---`:"",l=this.right?`---${this.right.toString()}`:"";return`${i}(${this.value})${l}`}toHTML(i,l){i||=0,l=typeof l>"u"?4:l;let v=function(j){return" ".repeat(l*j)},d="",T=this.left?`${v(i+1)}
    1. \n${this.left.toHTML(i+2,l)}${v(i+1)}
      2. \n`:"",M=this.right?`${v(i+1)}
    2. \n${this.right.toHTML(i+2,l)}${v(i+1)}
      3. \n`:"";return d=`${v(i)}
      ${this.value}
      ${v(i)}\n`,(T||M)&&(d+=`${v(i)}
        \n${T}${M}${v(i)}
      \n`),d}}this.tree=function(i){let l=[];for(let v=0;v.+)\\\\right\\)$/gu,(i,l)=>l||i)},N=function(n){let i=[];for(;n.length;){let l=n.shift(),v=n[0],d=Dt(v),T=v==="-";if(l==="^"&&(v==="+"?n.shift():d&&v[0]==="+"&&v.shift(),d&&v.length===1&&n.unshift(n.shift()[0])),l==="^"&&(d&&v[0]==="-"||T)){let M=i.pop(),I=i[i.length-1],j="1";I==="*"?(i.pop(),j=i.pop()):Dt(I)&&(j=i.pop()),i.push(j,"/",M,l),d?v.shift():n.shift(),d&&v.length===1&&i.push(n.shift()[0])}else i.push(l)}return i};this.toTeX=function(i,l){l||={};let v=l.decimals===!0?"decimals":void 0,d=typeof i=="string"?this.toObject(i):i,T=[],M=typeof l.cdot>"u"?"\\\\cdot":l.cdot;if(d=N(d),Dt(d)){let I=[],j,se;for(let ae=0;ae0?`\\\\frac{d}{d ${st[0]}}`:"\\\\frac{d}{d x}"}else Pe.length===2?Ce=`\\\\frac{d}{d ${Pe[1]}}`:Ce=`\\\\frac{d^{${Pe[2]}}}{d ${this.toTeX(Pe[1])}^{${Pe[2]}}}`;qe=`${Ce}\\\\left(${Ge}\\\\right)`}else if(ae==="sum"||ae==="product"){let Pe=[[],[],[],[]],Ce=0;for(let Ge=0;GeArray.isArray(st)?Ce.toTeX(st.join("")):Pe(String(st)));qe=`\\\\lim_${yt.braces(`${Ge[1]}\\\\to ${Ge[2]}`)} ${yt.braces(Ge[0])}`}else ae===J||ae===me?qe=this.toTeX(se.args)+(ae===J?"!":"!!"):qe=yt.latex(se,v);T.push(qe)}else T.push(yt.latex(se,v));else Dt(se)?T.push(yt.brackets(this.toTeX(se))):se==="/"?T.push(yt.frac(h(T.pop()),h(this.toTeX([d[++I]])))):T.push(se)}return T.join(" ")};function q(n){return _e.PARSE2NUMBER?n:a.symfunction("parens",[n])}function P(n){if(n.isInfinity)return W.infinity();if(n.multiplier.lessThan(0)&&n.multiplier.negate(),n.isImaginary()){let l=n.realpart(),v=n.imagpart();if(l.isConstant()&&v.isConstant())return Fe(a.add(a.pow(l,new W(2)),a.pow(v,new W(2))))}else{if(q0(n)||Ut(n.power))return n;if(Qn(n)&&typeof n.value=="string"&&n.value.startsWith("baseunit_"))return n}if(n.isComposite()){let l=[];n.each(d=>{l.push(d.multiplier)}),ut.QGCD.apply(null,l).lessThan(0)&&(n.multiplier=n.multiplier.multiply(new Ve(-1)),n.distributeMultiplier())}let i=a.parse(n.multiplier);return n.toUnitMultiplier(),a.multiply(i,a.symfunction(V,[n]))}function D(n){let i;if(vt(n)){let l=new It;return n.each((v,d)=>{l.set(d-1,D(v))}),l}if(St(n)){let l=new xt;return n.each((v,d,T)=>{l.set(d,T,D(v))}),l}if(_e.PARSE2NUMBER&&n.isConstant())return mt(n)?i=ut.bigfactorial(n):i=ut.gamma(n.multiplier.add(new Ve(1)).toDecimal()),i=ie(i),i;if(n.isConstant()&&n.getDenom().equals(2)){let v=n.getNum(),d,T,M;n.multiplier.isNegative()?(M=a.subtract(v.negate(),new W(1)).multiplier.divide(new Ve(2)),d=a.pow(new W(-4),new W(M)).multiplier.multiply(ut.bigfactorial(M)),T=ut.bigfactorial(new Ve(2).multiply(M))):(M=a.add(v,new W(1)).multiplier.divide(new Ve(2)),d=ut.bigfactorial(new Ve(2).multiply(M)),T=a.pow(new W(4),new W(M)).multiplier.multiply(ut.bigfactorial(M)));let I=d.divide(T);return a.multiply(a.parse("sqrt(pi)"),new W(I))}return a.symfunction(J,[n])}function K(n,i){let l=Nt(n);if(l.isConstant()){let v=ut.continuedFraction(l,i),d=It.fromArray(v.fractions.map(T=>new W(T)));return It.fromArray([new W(v.sign),new W(v.whole),d])}return a.symfunction("continuedFraction",[n,i])}function z(n){let i=Nt(n);return i.isConstant()?new W(ut.erf(i)):i.isImaginary()?Ie.erf(n):a.symfunction("erf",[n])}function te(n,i){if(n.isConstant()&&i.isConstant()){let v=new W(1);return v.multiplier=v.multiplier.multiply(n.multiplier.mod(i.multiplier)),v}let l=a.divide(n.clone(),i.clone());return mt(l)?new W(0):a.symfunction("mod",[n,i])}function ce(n,i,l){return typeof n!="boolean"&&q0(n)&&(n=!!Number(n)),n?i:l}function de(n,i){if(St(n)){for(let l=0,v=n.rows();la.multiply(I,W.imaginary())))}else v=[a.parse(n)];return It.fromArray(v)}function Oe(n){if(n.isComposite()){let i=new W(0),l,v,d,T,M,I,j,se;return n.each(ae=>{l=ae.getNum(),v=ae.getDenom(),d=i.getNum(),T=i.getDenom(),M=a.multiply(v,d),I=a.multiply(l,T),j=a.expand(a.add(M,I)),se=a.multiply(T,v),i=a.divide(j,se)},!0),i}return n}function Fe(n){gt(n)||(n=a.parse(n));let i=a.symfunction("sqrt",[n]);if(n.group===g)return a.symfunction(G,[n]);n.fname===""&&n.power.equals(1)&&(n=n.args[0]);let l=n.multiplier.sign()<0;if(_e.PARSE2NUMBER){if(n.isConstant()&&!l)return new W($e.sqrt(n.multiplier.toDecimal()));if(n.isImaginary())return Ie.sqrt(n);if(n.group===o)return a.symfunction("sqrt",[n])}let v,d,T=n.isConstant();if(n.group===A&&n.isLinear()){let M=Fe(new W(n.multiplier));for(let I in n.symbols){if(!Object.hasOwn(n.symbols,I))continue;let j=n.symbols[I];M=a.multiply(M,Fe(j))}d=M}else if(n.fname===G){let M=n.args[0],I=n.multiplier;M.setPower(n.power.multiply(new Ve(.25))),d=M,I.equals(1)||(d=a.multiply(Fe(a.parse(I)),d))}else if(!n.power.isInteger())n.setPower(n.power.multiply(new Ve(.5))),d=n;else if(Number(n.multiplier)<0&&n.group===o){let M=a.parse(n.multiplier).negate(),I=a.parse(n).toUnitMultiplier().negate();d=a.multiply(a.symfunction(_e.SQRT,[I]),Fe(M))}else{let M=n.power.sign();n.power=n.power.abs(),T&&n.multiplier.lessThan(0)&&(v=W.imaginary(),n.multiplier=n.multiplier.abs());let I=Number(n.multiplier.toDecimal()),j=Math.abs(I),se=Math.sqrt(j),ae;if(mt(se))ae=new W(se);else if(mt(I)){let qe=ut.ifactor(I),Pe=1;for(let Ce in qe){if(!Object.hasOwn(qe,Ce))continue;let Ge=qe[Ce],st=Ge-Ge%2;if(st){let Ct=Number(Ce)**st;Pe*=Number(Ce)**(st/2),I/=Ct}}ae=a.multiply(a.symfunction(G,[new W(I)]),new W(Pe))}else{let qe=[new W(n.multiplier.num),new W(n.multiplier.den)],Pe=[new W(1),new W(1)],Ce=[new W(1),new W(1)],Ge=a;for(let st=0;st<2;st++){let Ct=qe[st];Q(Ct).each(Je=>{Je=W.unwrapPARENS(Je);let Ue=Je.clone().toLinear(),Ke=Number(Je.power),ze=Ke%2,Ye=(Ke-ze)/2;Pe[st]=Ge.multiply(Pe[st],Ge.pow(Ue,new W(Ye))),Ce[st]=Ge.multiply(Ce[st],Fe(Ge.pow(Ue,new W(ze))))})}ae=a.divide(a.multiply(Pe[0],Ce[0]),a.multiply(Pe[1],Ce[1]))}n=n.toUnitMultiplier(!0),n.isOne()?d=n:Ut(n.power.toString())?d=a.pow(n.clone(),new W(.5)):d=a.symfunction(G,[n]),M<0&&d.power.negate(),ae&&(d=a.multiply(ae,d)),v&&(d=a.multiply(v,d))}return tn&&_e.PARSE2NUMBER&&d.text()!==i.text()?a.parse(d):d}function De(n){if(!n.isConstant(!0)){let i,l=Number(n.power)/3,v=a.pow(a.parse(n.multiplier),new W(1/3)),d=n.toUnitMultiplier();return mt(l)?i=a.pow(d.toLinear(),a.parse(String(l))):d.group===A?(i=new W(1),d.each(T=>{i=a.multiply(i,De(T))})):i=a.symfunction("cbrt",[d]),a.multiply(v,i)}return Be(n,new W(3))}function Xe(n,i){return n.scientific=i||10,n}function Be(n,i,l=void 0,v=void 0){if(i=Nt(a.parse(i)),i.equals(0))throw new Ht("Unable to calculate nthroots of zero");if(Number(n)<0&&Ut(i))throw new Error("Cannot calculate nthroot of negative number for even powers");if(!n.isConstant(!0)){let I=[n,i];return typeof l<"u"&&I.push(new W(l)),typeof v<"u"&&I.push(new W(v?1:0)),a.symfunction("nthroot",I)}n.group!==t&&(n=Nt(n)),typeof v>"u"&&(v=!0),l||=25;let d=n.sign(),T,M;if(d<0&&(n=P(n)),mt(n)&&i.isConstant())return Number(n)<18446744073709552e3?M=Ve.create(Number(n)**(1/Number(i))):M=ut.nthroot(n,i),v?T=new W(M):T=new W(M.toDecimal(l)),a.multiply(new W(d),T)}function Q(n){if(n.greaterThan(9999999999998891e26)||n.equals(-1))return n;if(n.equals(Math.PI))return new W(Math.PI);n=Nt(n.clone());let i;if(n.isConstant()){i=new W(1);let l=n.toString();if(mt(l)){let v=ut.ifactor(l);for(let d in v){if(!Object.hasOwn(v,d))continue;let T=v[d];i=a.multiply(i,a.symfunction("parens",[new W(d).setPower(new Ve(T))]))}}else{let v=Q(new W(n.multiplier.num)),d=Q(new W(n.multiplier.den));i=a.multiply(a.symfunction("parens",[v]),a.symfunction("parens",[d]).invert())}}else i=a.symfunction("pfactor",[n]);return i}function H(n){return n.realpart()}function X(n){return n.imagpart()}function F(n){let i=n.realpart(),l=n.imagpart();return a.add(i,a.multiply(l.negate(),W.imaginary()))}function ee(n){let i=n.realpart(),l=n.imagpart();return i.isConstant()&&l.isConstant()?l.equals(0)&&i.equals(1)?a.parse("0"):l.equals(1)&&i.equals(0)?a.parse("pi/2"):l.equals(0)&&i.equals(-1)?a.parse("pi"):l.equals(-1)&&i.equals(0)?a.parse("-pi/2"):l.equals(1)&&i.equals(1)?a.parse("pi/4"):l.equals(1)&&i.equals(-1)?a.parse("pi*3/4"):l.equals(-1)&&i.equals(1)?a.parse("-pi/4"):l.equals(-1)&&i.equals(-1)?a.parse("-pi*3/4"):new W(Math.atan2(Number(l),Number(i))):a.symfunction("atan2",[l,i])}function _(n){let i=W.toPolarFormArray(n),l=i[1],v=i[0],d=a.parse(qt("e^({0}*({1}))",_e.IMAGINARY,l));return a.multiply(v,d)}function x(n){let i=n.clone();try{let l=o1(n,"e",!0),v=pe.isSymbol(l.x.power)?l.x.power:a.parse(l.x.power),d=a.divide(v,W.imaginary()),T=Nt(he.tan(d)),M=a.pow(l.a,new W(2)),I=T.getDenom(),j=T.getNum();return W.hyp(j,I).equals(l.a)?a.add(I,a.multiply(W.imaginary(),j)):i}catch(l){if(l.message==="timeout")throw l;return i}}function m(n,i){i.forEach(I=>{I.numVal=Nt(I).multiplier});let l,v,d,T,M;for(;;){if(l=i.length,l<2)return i[0];v=i.pop(),d=i[l-2],(n==="min"?v.numVald.numVal)&&(i.pop(),i.push(v))}}function f(...n){return Q0(n)?n[0]:un(n)?new W(Math.max.apply(null,n)):_e.SYMBOLIC_MIN_MAX&&kn(n)?m("max",n):a.symfunction("max",n)}function $(...n){return Q0(n)?n[0]:un(n)?new W(Math.min.apply(null,n)):_e.SYMBOLIC_MIN_MAX&&kn(n)?m("min",n):a.symfunction("min",n)}function w(n){return n.isConstant(!0)?new W(Math.sign(Nt(n))):a.symfunction("sign",[n])}function U(n,i){i=i?i.toString():"asc";let l=function(d){return d.group===t?d.multiplier:d.group===E?d.fname===""?l(d.args[0]):d.fname:d.group===o?d.power:d.value},v=vt(n)?n.elements:n.collectSymbols();return new It(v.sort((d,T)=>{let M=l(d),I=l(T);return i==="desc"?I-M:M-I}))}function B(n,i=void 0){let l=n,v=i===void 0?void 0:i;if(l.equals(1))return new W(0);let d;if(l.fname===G&&l.multiplier.equals(1))return d=a.divide(B(l.args[0]),new W(2)),l.power.sign()<0&&d.negate(),d;if(l.equals(0))throw new Ht(`${_e.LOG}(0) is undefined!`);if(l.isImaginary())return Ie.evaluate(l,_e.LOG);if(l.isConstant()&&typeof v<"u"&&v.isConstant()){let T=Math.log(l),M=Math.log(v);d=new W(T/M)}else if(l.group===g&&l.power.multiplier.lessThan(0)||l.power.toString()==="-1")l.power.negate(),d=B(l).negate();else if(l.value==="e"&&l.multiplier.equals(1)){let T=l.power;d=gt(T)?T:new W(T)}else if(l.group===E&&l.fname==="exp"){let T=l.args[0];l.multiplier.equals(1)?d=a.multiply(T,new W(l.power)):d=a.symfunction(_e.LOG,[l])}else if(_e.PARSE2NUMBER&&q0(l)){let T=a.parse(l),M;T.multiplier.lessThan(0)&&(T.negate(),M=a.multiply(new W(Math.PI),new W("i"))),d=new W(Math.log(T.multiplier.toDecimal())),M&&(d=a.add(d,M))}else{let T;!l.power.equals(1)&&!l.contains("e")&&l.multiplier.isOne()&&(T=l.group===g?l.power:new W(l.power),l.toLinear());let M=typeof v>"u"?[l]:[l,v];M.length>1&&Q0(M)?d=new W(1):d=a.symfunction(_e.LOG,M),T&&(d=a.multiply(T,d))}return d}function Z(n,i){typeof i=="number"&&(i=new W(i));let l=i&&i.isConstant()||typeof i>"u";if(n.isConstant()&&l){let d,T,M;d=n,i&&i.lessThan(0)&&(i=P(i),T=Number(n).toExponential().toString().split("e"),d=T[0],M=T[1]);let I=new W(m0(Number(d),Number(i)||0));return a.multiply(I,a.pow(new W(10),new W(M||0)))}let v=[n];return typeof i<"u"&&v.push(i),a.symfunction("round",v)}function Y(n){let i=Number(n)%2,l;return i<0&&(i=2+i),i>=0&&i<=.5?l=1:i>.5&&i<=1?l=2:i>1&&i<=1.5?l=3:l=4,l}function ie(n){if(!isFinite(n)){let l=Math.sign(n),v=new W(String(Math.abs(n)));return v.multiplier=v.multiplier.multiply(new Ve(l)),v}if(gt(n))return n;if(typeof n=="number")try{n=Ve.simple(n)}catch(l){if(l.message==="timeout")throw l;n=new Ve(n)}let i=new W(0);return i.multiplier=n,i}function oe(n){let i=n.group,l;if(i===k){let v=n.getNum(),d=n.getDenom()||new W(1),T=Number(n.power),M=new W(1);if(Math.abs(T)===1){d.each(se=>{se.group===A?M=a.multiply(M,oe(se.getDenom())):se.power.lessThan(0)&&(M=a.multiply(M,oe(se.clone().toUnitMultiplier())))});let I=new W(0);d.each(se=>{I=a.add(a.divide(se,M.clone()),I)}),M.invert();let j;v.isComposite()?(j=new W(0),v.each(se=>{j=a.add(a.multiply(oe(se),M.clone()),j)})):j=a.multiply(M,v),l=a.divide(j,I)}}else i===A?(l=new W(1),n.each(v=>{l=a.multiply(l,a.clean(v))})):i===E&&n.args.length===1&&n.args[0].isConstant()&&(l=Bt("PARSE2NUMBER",()=>a.parse(n),!0));return l||=n,l}function ne(n,i){return i||={expand_denominator:!0,expand_functions:!0},le(n,i)}function le(n,i){if(Array.isArray(n))return n.map(d=>le(d,i));if("expand"in n&&typeof n.expand=="function")return n.expand(i);let l=n;if(i||={},l.group===E&&l.fname===""){let d=le(l.args[0],i),T=le(a.pow(d,a.parse(l.power)),i);return a.multiply(a.parse(l.multiplier),T).distributeMultiplier()}if([t,e,o].indexOf(l.group)!==-1)return l;let v=l.clone();try{let d=l.multiplier.toString(),T=Number(l.power),M=l;if(l.isComposite()&&mt(l.power)&&T>0){let I=T-1,j=new W(0);l.each(ae=>{j=a.add(j,le(a.parse(ae),i))});let se=a.parse(j);for(let ae=0;ae{I.push(le(j,i))}),M=a.pow(a.symfunction(l.fname,I),a.parse(l.power)),M=a.multiply(M,a.parse(l.multiplier))}else if(l.isComposite()&&mt(l.power)&&T<0&&i.expand_denominator===!0){let I=l.invert();M=le(I,i),M.invert()}else if(l.group===A){let I=function(ae){switch(ae.group){case k:return 0;case L:return 1;case A:return 2;case E:return 3;default:return 4}},j=l.collectSymbols().sort((ae,qe)=>I(qe)-I(ae)).map(ae=>{let qe=a.pow(ae,a.parse(String(T)));return le(qe,i)}),se=j.pop();se.isComposite()&&se.isLinear()?(j.forEach(ae=>{se=Bn(se,ae,i)}),se.isComposite()?(Number(se.power)>1&&(se=le(a.pow(se,a.parse(se.power)),i)),M=a.multiply(a.parse(d),se).distributeMultiplier()):M=se):(M=se,j.forEach(ae=>{M=a.multiply(M,ae)}),M=a.multiply(M,a.parse(d)).distributeMultiplier()),M.group===A&&(M=a.parse(M))}else M=l;return M}catch(d){if(d.message==="timeout")throw d;return v}}function ge(n){return xt.identity(n)}function ke(n,i){return i.isConstant()&&mt(i)?n.elements[Number(i)]:a.symfunction("vecget",[n,i])}function Le(n,i){return i=typeof i>"u"?1e-14:i,n=n.clone(),i=Number(i),n.elements.sort((l,v)=>v.group-l.group),n.elements=B1(n.elements,(l,v)=>Number(a.subtract(Nt(l),Nt(v)).abs())<=i),n}function We(n,i,l){return i.isConstant?(n.elements[Number(i)]=l,n):a.symfunction("vecset",[n,i,l])}function Qe(n,i,l){return i.isConstant()&&l.isConstant()?n.elements[Number(i)][Number(l)]:a.symfunction("matget",[n,i,l])}function Ze(n,i){return i.isConstant()?It.fromArray(n.elements[Number(i)]):a.symfunction("matgetrow",[n,i])}function tt(n,i,l){if(!i.isConstant())return a.symfunction("matsetrow",[n,i,l]);if(n.elements[Number(i)].length!==l.elements.length)throw new gn("Matrix row must match row dimensions!");let v=n.clone();return v.elements[Number(i)]=l.clone().elements,v}function je(n,i){if(!i.isConstant())return a.symfunction("matgetcol",[n,i]);let l=Number(i),v=xt.fromArray([]);return n.each((d,T,M)=>{M===l&&v.elements.push([d.clone()])}),v}function lt(n,i,l){if(!i.isConstant())return a.symfunction("matsetcol",[n,i,l]);let v=Number(i);if(n.rows()!==l.elements.length)throw new gn("Matrix column length must match number of rows!");return l.each(((d,T)=>{n.set(T-1,v,d.elements[0].clone())})),n}function ct(n,i,l,v){return n.elements[i][l]=v,n}function ft(...n){return new It(n)}function At(...n){return xt.fromArray(n)}function $t(...n){return g0.fromArray(n)}function Tt(n){return St(n)?n.determinant():n}function pt(n){let i;return St(n)?i=[new W(n.cols()),new W(n.rows())]:vt(n)||bn(n)?i=new W(n.elements.length):Pt("size expects a matrix or a vector"),i}function Ft(n,i){return St(n)&&(n=new It(n)),St(i)&&(i=new It(i)),vt(n)&&vt(i)?n.dot(i):a.multiply(n.clone(),i.clone())}function _t(n,i){return St(n)&&(n=new It(n)),St(i)&&(i=new It(i)),vt(n)&&vt(i)?n.cross(i):a.multiply(n.clone(),i.clone())}function Ot(n){return St(n)?n.transpose():Pt("function transpose expects a matrix")}function Vt(n){return St(n)?n.invert():Pt("invert expects a matrix")}function Jt(n,i){return n.union(i)}function c0(n,i){return n.intersection(i)}function Yt(n,i){return n.contains(i)}function r0(n,i){return n.difference(i)}function Kt(n,i){return new W(Number(n.intersects(i)))}function v0(n,i){return new W(Number(n.isSubset(i)))}function u(n,i){i??=n;let l=Te.slice(n,i).map(v=>new W(v));return l.length===1?l[0]:l.length===0?new W(0):new It(l)}function y(...n){n.forEach(i=>{console.log(i.toString())})}function b(n){if(!gt(n.power)&&n.power.absEquals(.5)){let i=n.power.sign(),l=Fe(n.group===e?new W(n.value):n.toLinear());return i<0&&l.invert(),l}return n}function C(n){if(n.group===e){let i=n.value,l=Oi(i)[0];if(!l)return In("Unable to compute prime factors. This should not happen. Please review and report."),n;let d=new Ve(Math.log(i)/Math.log(l)).multiply(n.power);if(d.den>n.power.den)return n;mt(d)?n=new W(l**Number(d)):n=new W(l).setPower(d)}return n}this.expand=le,this.round=Z,this.clean=oe,this.sqrt=Fe,this.cbrt=De,this.abs=P,this.log=B,this.rationalize=Oe,this.nthroot=Be,this.arg=ee,this.conjugate=F,this.imagpart=X,this.realpart=H,this.getFunction=function(i){return s[i][0]},this.addPreprocessor=function(i,l,v,d){let{names:T}=ve,{actions:M}=ve;if(typeof l!="function")throw new Error("Incorrect parameters. Function expected!");v?d?(T.splice(v,0,i),M.splice(v,0,l)):(T[v]=i,M[v]=l):(T.push(i),M.push(l))},this.getPreprocessors=function(){let i={};for(let l=0,v=ve.names.length;lM.length&&M.group===I.group&&([M,I]=[I,M])),M.multiplier.equals(0))return I;if(I.multiplier.equals(0))return M;if(M.isConstant()&&I.isConstant()&&_e.PARSE2NUMBER)return new W(M.multiplier.add(I.multiplier).toDecimal(_e.PRECISION));let j=M.group,se=I.group,ae=M.power.toString(),qe=I.power.toString();if(jNumber(qe)&&Number(qe)>0)return this.add(I,M);if(j===A&&se===L&&M.value===I.value){let ht=M;M=I,I=ht,j=M.group,se=I.group,ae=M.power.toString(),qe=I.power.toString()}let Pe=ae===qe,Ce=M.value,Ge=I.value,st=M.isComposite(),Ct=I.isComposite(),Je,Ue,Ke;if(st&&(Je=Xt(M,"hash")),Ct&&(Ue=Xt(I,"hash")),j===k&&se===k&&I.isLinear()&&!M.isLinear()&&Je!==Ue)return this.add(I,M);j===L&&se===L&&(Ce=Je,Ge=Ue);let ze=j===e&&se===t,Ye=M.value===I.multiplier.toString(),at=Ce===Ge||Je===Ue&&Je!==void 0||ze&&Ye;if(at&&Pe&&j===se)if(ze&&(I=I.convert(e)),j===L&&(se===o||se===e))M.distributeMultiplier(),Ke=M.attach(I);else if(Ke=M,M.multiplier.isOne()&&I.multiplier.isOne()&&j===k&&M.isLinear()&&I.isLinear())for(let ht in I.symbols){if(!Object.hasOwn(I.symbols,ht))continue;let nt=I.symbols[ht];Ke.attach(nt)}else Ke.multiplier=Ke.multiplier.add(I.multiplier);else if(at&&j!==L)j===k&&se===L?(I.insert(M,"add"),Ke=I):(Ke=W.shell(L).attach([M,I]),Ke.value=j===L?Je:Ce);else if(st&&M.isLinear()){let ht=j===se,nt=j===L&&se===L;if(nt&&(ht=M.value===I.value),M.distributeMultiplier(),I.isComposite()&&I.isLinear()&&ht){I.distributeMultiplier();for(let it in I.symbols){if(!Object.hasOwn(I.symbols,it))continue;let rt=I.symbols[it];M.attach(rt)}Ke=M}else nt&&M.value!==Ue||j===L&&!at?(Ke=W.shell(k).attach([M,I]),Ke.updateHash()):Ke=M.attach(I)}else{if(j===E&&M.fname===G&&se!==g&&I.power.equals(.5)){let ht=I.multiplier.clone();I=Fe(I.toUnitMultiplier().toLinear()),I.multiplier=ht}M.length===2&&I.length===2&&Ut(M.power)&&Ut(I.power)?Ke=a.add(le(M),le(I)):(Ke=W.shell(k).attach([M,I]),Ke.updateHash())}Ke.multiplier.equals(0)&&(Ke=new W(0));let dt=Ke;if(dt.length===1){let ht=dt.multiplier,nt=J0(dt.symbols);return nt.multiplier=nt.multiplier.multiply(ht),nt}return Ke}if(d&&!v){let M=i;i=l,l=M;let I=d;d=v,v=I}let T=St(l);if(v&&T){let M=new xt;l.eachElement((j,se,ae)=>{M.set(se,ae,a.add(i.clone(),j))}),l=M}else if(St(i)&&T)l=i.add(l);else if(v&&vt(l)){let M=l;M.each((I,j)=>{j--,M.elements[j]=a.add(i.clone(),M.elements[j])})}else if(vt(i)&&vt(l)){let M=i,I=l;I.each((j,se)=>{se--,I.elements[se]=a.add(M.elements[se],I.elements[se])})}else{if(vt(i)&&St(l))return a.add(l,i);if(St(i)&&vt(l)){if(l.elements.length===i.rows()){let M=new xt,I=i.cols();return l.each((j,se)=>{let ae=[];if(vt(j))for(let qe=0;qea.subtract(M,l.clone()));else if(v&&vt(l))l=l.map(M=>a.subtract(i.clone(),M));else if(vt(i)&&vt(l)||dn(i)&&dn(l))i.dimensions()===l.dimensions()?l=i.subtract(l):a.error("Unable to subtract vectors/collections. Dimensions do not match.");else if(St(i)&&vt(l)){if(l.elements.length===i.rows()){let M=new xt,I=i.cols();return l.each((j,se)=>{let ae=[];for(let qe=0;qe{M.set(j,se,a.subtract(I,l.clone()))}),l=M}else if(v&&St(l)){let M=new xt;l.each((I,j,se)=>{M.set(j,se,a.subtract(i.clone(),I))}),l=M}return l},this.multiply=function(i,l){let v=gt(i),d=gt(l);if(v&&l instanceof t0)return l.elements.push(i),l;if(v&&d){let I=i,j=l;if(j.isUnit){let ze=I.clone();return I.unit=j,ze}if(I.unit||j.unit)return a.Unit.multiply(I,j);if(I.isInfinity||j.isInfinity){if(I.equals(0)||j.equals(0))throw new Ht(`${I}*${j} is undefined!`);if(j.power.lessThan(0)){if(!I.isInfinity)return new W(0);throw new Ht("Infinity/Infinity is not defined!")}let ze=I.multiplier.multiply(j.multiplier).sign(),Ye=W.infinity();if(I.isConstant()||j.isConstant()||I.isInfinity&&j.isInfinity)return ze<0&&Ye.negate(),Ye}if(I.multiplier.equals(0)||j.multiplier.equals(0))return new W(0);if(I.isOne())return j.clone();if(j.isOne())return I.clone();if(I.isConstant()&&j.isConstant()&&_e.PARSE2NUMBER){let ze,Ye=I.multiplier.num.abs().toString().length,at=I.multiplier.den.toString().length,dt=Ye-at,ht=j.multiplier.num.abs().toString().length,nt=j.multiplier.den.toString().length,it=ht-nt,rt=_e.PRECISION-5;if(dt<-rt||dt>rt||it<-rt||it>rt){let U0=new $e(String(I.multiplier.num)),a0=new $e(String(I.multiplier.den)),b0=new $e(String(j.multiplier.num)),G0=new $e(String(j.multiplier.den));ze=new W(U0.times(b0).dividedBy(a0).dividedBy(G0).toFixed())}else{let U0=new $e(I.multiplier.toDecimal()),a0=new $e(j.multiplier.toDecimal()),b0=U0.times(a0).toFixed();ze=new W(b0)}return ze}if(j.group>I.group&&j.group!==k)return this.multiply(j,I);if(I.group===A&&j.group===L&&I.value===j.value){let ze=I;I=j,j=ze}let se=I.group,ae=j.group,qe=j.multiplier.num,Pe=j.multiplier.den;if(se===E&&I.fname===G&&!j.isConstant()&&I.args[0].value===j.value&&!I.args[0].multiplier.lessThan(0)){let ze=I.power,Ye=a.parse(I.multiplier);I=a.multiply(Ye,I.args[0].clone()),I.setPower(new Ve(.5).multiply(ze)),se=I.group}else se===E&&I.fname===G&&I.multiplier.equals(1)&&I.power.equals(-1)&&j.isConstant()&&I.args[0].equals(j)&&(I=a.symfunction(G,[j.clone()]),j=new W(1));let Ce=I.value,Ge=j.value,st=new Ve(I.sign()),Ct=se===e&&ae===t&&j.multiplier.equals(I.value),Je=Ct?new Ve(1).multiply(I.multiplier).abs():I.multiplier.multiply(j.multiplier).abs(),Ue=I.clone().toUnitMultiplier();if(j=j.clone().toUnitMultiplier(!0),se===E&&ae===E){let ze=I.args[0].clone(),Ye=j.args[0].clone();if(I.fname===G&&j.fname===G&&I.isLinear()&&j.isLinear()){let at=a.divide(ze,Ye).invert();at.gt(1)&&mt(at)&&(Ue=a.multiply(I.args[0].clone(),Fe(at.clone())),j=new W(1))}else if(I.fname===J&&j.fname===J&&!ze.isConstant()&&!Ye.isConstant()&&Number(j.power)<0){let at=a.subtract(ze.clone(),Ye.clone());if(at.isConstant()){let dt=new W(1);if(Number(at)<0){for(let ht=0,nt=Math.abs(Number(at));ht<=nt;ht++){let it=a.add(ze.clone(),new W(ht));dt=a.multiply(dt,it)}Ue=a.multiply(a.pow(ze,new W(I.power)),a.pow(dt,new W(j.power))),j=new W(1)}else{for(let ht=0,nt=Math.abs(Number(at));ht<=nt;ht++){let it=a.add(Ye.clone(),new W(ht));dt=a.multiply(dt,it)}Ue=a.multiply(a.pow(dt,new W(I.power)),a.pow(Ye,new W(j.power))),j=new W(1)}}}}if(Ce===Ge&&se===L&&se===ae&&(Ce=I.text("hash"),Ge=j.text("hash")),ae===g&&j.previousGroup===L&&se===L&&(Ce=Xt(I,"hash",g)),(Ce===Ge||Ct)&&!(se===L&&(ae===o||ae===e||ae===E))&&!(se===L&&ae===A)){let ze=I.power,Ye=j.power,at=gt(ze),dt=gt(Ye),ht=at||dt;se===L&&ae!==L&&j.previousGroup!==L&&ze.equals(1)?(Ue=new W(0),I.each(nt=>{Ue=a.add(Ue,a.multiply(nt,j.clone()))},!0)):(ht?Ue.power=a.add(gt(ze)?ze:new W(ze),gt(Ye)?Ye:new W(Ye)):se===t?Ue.power=ze:Ue.power=ze.add(Ye),Ue.power.equals(0)&&(Ue=Ue.convert(t)),ht&&Ue.convert(g),I.imaginary&&j.imaginary&&Ut(Number(Ue.power)%2)&&(Ue=new W(1),Je.negate()),Ue.group!==g&&Ue.previousGroup&&(Ue.previousGroup=void 0),Ue.multiplier=Ue.multiplier.multiply(j.multiplier))}else if(se===A&&I.isLinear())if(ae===A&&j.distributeExponent(),ae===A&&j.isLinear()){for(let ze in j.symbols){if(!Object.hasOwn(j.symbols,ze))continue;let Ye=j.symbols[ze];Ue=Ue.combine(Ye)}Ue.multiplier=Ue.multiplier.multiply(j.multiplier)}else Ue.combine(j);else if(se===t)Ue=j.clone().toUnitMultiplier(!0);else if(se===A)Ue.distributeExponent(),Ue.combine(j);else if(!j.isOne()){let ze=j.multiplier.clone();j.toUnitMultiplier(),Ue=W.shell(A).combine([Ue,j]),Ue.multiplier=Ue.multiplier.multiply(ze)}if(Ue.group===e){let ze=Math.log(Number(Ue.value)),Ye=Math.log(Number(qe))/ze,at=Math.log(Number(Pe))/ze,dt=Number(Je.num)/Number(qe),ht=Number(Je.den)/Number(Pe);Ye!==0&&mt(Ye)&&mt(dt)&&(Ue.power=Ue.power.add(new Ve(Ye)),Je.num=Je.num.divide(qe)),at!==0&&mt(at)&&mt(ht)&&(Ue.power=Ue.power.subtract(new Ve(at)),Je.den=Je.den.divide(Pe))}if(Ue.length===1){let ze=Ue.multiplier;Ue=J0(Ue.symbols),Ue.multiplier=Ue.multiplier.multiply(ze)}let Ke=Ue.power.toString();if(Ut(Ke)&&Ue.fname===G){st=st.multiply(new Ve(Ue.sign()));let ze=Ue.power;Ue=Ue.args[0],Ue=a.multiply(new W(Je),a.pow(Ue,new W(ze.divide(new Ve(2))))),st.lessThan(0)&&Ue.negate()}else Ue.multiplier=Ue.multiplier.multiply(Je).multiply(st),Ue.group===k&&Ue.isImaginary()&&Ue.distributeMultiplier();return Ue.group===e&&mt(Ue.power.toDecimal())&&(Ue=Ue.convert(t)),Ue}if(d&&!v){let I=i;i=l,l=I;let j=d;d=v,v=j}let T=St(l),M=St(i);if(v&&T){let I=new xt;l.eachElement((se,ae,qe)=>{I.set(ae,qe,a.multiply(i.clone(),se))}),l=I}else if(M&&T)l=i.multiply(l);else if(v&&vt(l)){let I=l;I.each((j,se)=>{se--,I.elements[se]=a.multiply(i.clone(),I.elements[se])})}else if(vt(i)&&vt(l)){let I=i,j=l;j.each((se,ae)=>{ae--,j.elements[ae]=a.multiply(I.elements[ae],j.elements[ae])})}else{if(vt(i)&&St(l))return this.multiply(l,i);if(St(i)&&vt(l)){let I=i,j=l;if(j.elements.length===I.rows()){let se=new xt,ae=I.cols();return j.each((qe,Pe)=>{let Ce=[];for(let Ge=0;Gea.divide(i.clone(),I));else if(T&&d)l=i.map(I=>a.divide(I,l.clone()));else if(T&&M){let I=i;I.dimensions()===l.dimensions()?l=l.map((j,se)=>a.divide(I.elements[--se],j)):a.error("Cannot divide vectors. Dimensions do not match!")}else{let I=St(i),j=St(l);if(I&&d){let se=new xt;i.eachElement((ae,qe,Pe)=>{se.set(qe,Pe,a.divide(ae,l.clone()))}),l=se}else if(v&&j){let se=new xt;l.eachElement((ae,qe,Pe)=>{se.set(qe,Pe,a.divide(i.clone(),ae))}),l=se}else if(I&&j){let se=new xt,ae=i,qe=l;ae.rows()===qe.rows()&&ae.cols()===qe.cols()?(ae.eachElement((Pe,Ce,Ge)=>{se.set(Ce,Ge,a.divide(Pe,qe.elements[Ce][Ge]))}),l=se):a.error("Dimensions do not match!")}else if(I&&M){let se=i,ae=l;if(se.cols()===ae.dimensions()){let qe=new xt;se.eachElement((Pe,Ce,Ge)=>{qe.set(Ce,Ge,a.divide(Pe,ae.elements[Ce].clone()))}),l=qe}else a.error("Unable to divide matrix by vector.")}}return l},this.pow=function(i,l){let v=gt(i),d=gt(l);if(v&&d){let T=i,M=l;if(T.unit||M.unit)return a.Unit.pow(T,M);if(T.group===E&&T.fname===V&&Ut(M)){let Je=T.multiplier.clone(),Ue=a.pow(T.args[0],M);return Ue.multiplier=Je,Ue}if(T.isInfinity||M.isInfinity){if(T.isInfinity&&M.isInfinity)throw new Ht(`(${T})^(${M}) is undefined!`);if(T.isConstant()&&M.isInfinity){if(T.equals(0)){if(M.lessThan(0))throw new Ht("0^Infinity is undefined!");return new W(0)}if(T.equals(1))throw new Ht(`1^${M.toString()} is undefined!`);if(M.lessThan(0))return new W(0);if(!T.lessThan(0))return W.infinity()}if(T.isInfinity&&M.isConstant()){if(M.equals(0))throw new Ht(`${T}^0 is undefined!`);return M.lessThan(0)?new W(0):a.multiply(W.infinity(),a.pow(new W(T.sign()),M.clone()))}}let I=T.equals(0),j=M.equals(0);if(I&&j)throw new Ht("0^0 is undefined!");if(I&&M.isConstant()&&M.multiplier.greaterThan(0))return new W(0);if(j)return new W(1);let se=M.isConstant(),ae=T.isConstant(),qe=M.isInteger(),Pe=T.multiplier,Ce=T.clone();if(ae&&se&&T.equals(0)&&M.lessThan(0))throw new Ht("Division by zero is not allowed!");if(_e.PARSE2NUMBER&&ae&&se&&T.sign()<0&&mn(M)){let Je=Math.PI*Number(M.multiplier.toDecimal()),Ue=new W(Math.cos(Je)),Ke=a.multiply(W.imaginary(),new W(Math.sin(Je)));return a.add(Ue,Ke)}if(_e.PARSE2NUMBER&&T.isImaginary()&&se&&mt(M)&&!M.lessThan(0)){let Je,Ue,Ke,ze,Ye,at=T.realpart(),dt=T.imagpart();if(at.isConstant("all")&&dt.isConstant("all"))return Ye=_e.USE_BIG?rn.atan2(dt.multiplier.toDecimal(),at.multiplier.toDecimal()).times(M.toString()):Math.atan2(Number(dt.multiplier.toDecimal()),Number(at.multiplier.toDecimal()))*Number(M.multiplier.toDecimal()),Ue=new W(Ye),Je=a.pow(W.hyp(at,dt),M),Ke=a.multiply(Je.clone(),a.trig.cos(Ue.clone())),ze=a.multiply(Je,a.trig.sin(Ue)),a.add(Ke,a.multiply(W.imaginary(),ze))}Ce.toUnitMultiplier();let Ge;if(Ce.group===E&&Ce.fname===G&&!se){let Je=Ce.args[0];Je.multiplyPower(new W(.5)),Je.multiplier.multiply(Ce.multiplier),Je.multiplyPower(M),Ce=Je}else Ge=Pe.sign(),mn(M)&&Ge<0&&(Ce.negate(),Ce=a.symfunction(Ae,[Ce]),Ce.negate()),Ce.multiplyPower(M);let st,Ct;if(ae&&se&&_e.PARSE2NUMBER){let Je;Ge<0&&(T.negate(),M.multiplier.den.equals(2)?Je=new W(_e.IMAGINARY):mt(M.multiplier)?Ut(M.multiplier)?Je=new W(1):Je=new W(-1):Ut(M.multiplier.den)?Je=a.pow(a.symfunction(Ae,[new W(Ge)]),M.clone()):Je=new W(Ge**M.multiplier.num));let Ue=Number(T.multiplier.toDecimal())**Number(M.multiplier.toDecimal());if(Ue!==0||T.multiplier.equals(0))Ce=new W(Ue);else{let Ke=new $e(T.multiplier.toDecimal()),ze=new $e(M.multiplier.toDecimal());Ce=new W(Ke.pow(ze).toFixed())}Je&&(Ce=a.multiply(Ce,Je))}else if(qe&&!Pe.equals(1)){if(M.abs().gt(_e.MAX_EXP))return M.sign()<0?new W(0):W.infinity();let Ue=M.multiplier.toDecimal(),Ke=Math.sign(Number(Ue)),ze=Math.abs(Number(Ue)),Ye=new Ve(1);Ye.num=Pe.num.pow(Number(ze)),Ye.den=Pe.den.pow(Number(ze)),Ke<0&&Ye.invert(),Ce.multiplier=Ce.multiplier.multiply(Ye)}else{let Je=T.sign();if(M.isConstant()&&T.isConstant()&&!M.multiplier.den.equals(1)&&Je<0)if(M.multiplier.den.equals(2)){let Ue=new W(_e.IMAGINARY);T.negate(),M.lessThan(0)&&(Ue.negate(),M.negate()),Ce=a.multiply(a.pow(T,M),Ue)}else{let Ue=T.clone();Ue.multiplier.negate(),Ce=a.pow(a.symfunction(Ae,[new W(Ge)]),M.clone());let Ke=a.pow(new W(Ue.multiplier.num),M.clone()),ze=a.pow(new W(Ue.multiplier.den),M.clone()),Ye=a.divide(Ke,ze);Ce=a.multiply(Ce,Ye)}else if(_e.PARSE2NUMBER&&M.isImaginary()){let Ue=M.realpart(),Ke=M.imagpart(),ze=T.clone().toLinear(),Ye=a.pow(ze.clone(),Ue),at=B(ze.clone()),dt=he.cos(a.multiply(Ke.clone(),at)),ht=a.multiply(he.sin(a.multiply(Ke,B(ze))),W.imaginary());Ce=a.multiply(Ye,a.add(dt,ht)),Ce=a.expand(a.parse(Ce))}else{let Ue=T.group===t&&Je<0;if(st=b(new W(Ue?Number(Pe.num):Math.abs(Number(Pe.num))).setPower(M.clone())),Ct=b(new W(Number(Pe.den)).setPower(M.clone()).invert()),T.imaginary)if(qe){let Ke=Math.sign(M),Ye=P(M)%4;Ce=new W(Ut(Ye)?-1:_e.IMAGINARY),(Ye===0||Ke<0&&Ye===1||Ke>0&&Ye===3)&&Ce.negate()}else{let Ke=l.multiplier.multiply(Ve.quick(1,2)),ze=(-1)**Ke.num;Ce=Ut(Ke.den)?new W(-1).setPower(Ke,!0):new W(ze)}if(Je<0&&!Ue&&Ce.negate(),se&&T.group!==g){let Ke=Ut(M.multiplier.den),ze=Ut(T.power),Ye=Ce.power.toDecimal(),at=Ut(Ye);if(Ke&&ze&&!at){if(Ye==="1"||Ye==="1")typeof Ce.value=="string"&&Ce.value.startsWith("baseunit_")||(Ce=a.symfunction(V,[Ce]));else if(mt(Ye))Ce=a.multiply(a.symfunction(V,[Ce.clone().toLinear()]),Ce.clone().setPower(new Ve(Number(Ye)-1)));else{let dt=Ce.power;Ce=a.symfunction(V,[Ce.toLinear()]).setPower(dt)}_e.POSITIVE_MULTIPLIERS&&Ce.fname===V&&(Ce=Ce.args[0])}}if(M.equals(2)&&Ce.group===A){let Ke=new W(1);Ce.each(ze=>{Ke=a.multiply(Ke,a.pow(ze,M))}),Ce=Ke}}}if(Ce=b(Ce),st&&Ct&&(Ce=a.multiply(Ce,C(a.multiply(st,Ct)))),Ce.fname===G){let Je=Ce.group===g,Ue=Je?Ce.power.multiplier.toString():Ce.power.toString();if(Ut(Ue)){let Ke=Je?a.divide(Ce.power,new W(2)):new W(Ce.power.divide(new Ve(2))),ze=Ce.multiplier;Ce=a.pow(Ce.args[0],Ke),Ce.multiplier=Ce.multiplier.multiply(ze)}}else if(!_e.IGNORE_E&&Ce.isE()&&Ce.group===g&&Ce.power.contains("pi")&&Ce.power.contains(_e.IMAGINARY)&&M.group===A){let Je=M.stripVar(_e.IMAGINARY);Ce=a.add(he.cos(Je),a.multiply(W.imaginary(),he.sin(Je)))}return Ce}if(vt(i)&&d)i=i.map(T=>a.pow(T,l.clone()));else if(St(i)&&d){let T=new xt;i.eachElement((M,I,j)=>{T.set(I,j,a.pow(M,l.clone()))}),i=T}else if(v&&St(l)){let T=new xt;l.eachElement((M,I,j)=>{T.set(I,j,a.pow(i.clone(),M))}),i=T}return i},this.comma=function(i,l){return i instanceof t0||(i=t0.create(i)),i.append(l),i},this.mod=function(i,l){return te(i,l)},this.slice=function(i,l){return new Ne(i,l)},this.equals=function(i,l){return i.group!==o&&!i.isLinear()&&Pt(`Cannot set equality for ${i.toString()}`),Ee[i.value]=l.clone(),l},this.percent=function(i){return a.divide(i,new W(100))},this.assign=function(i,l){if(i instanceof t0&&l instanceof t0)return i.elements.map((v,d)=>a.assign(v,l.elements[d])),It.fromArray(l.elements);if(i.parent){let v=i.parent;return v.elements[v.getter]=l,delete v.getter,v}if(i.group!==o)throw new jn(`Cannot complete operation. Incorrect LH value for ${i}`);return Ee[i.value]=l,l},this.functionAssign=function(i,l){let v=i.elements.pop();return On(v,i.elements,l)};let R=function(i){return new W(i===!0?1:0)};this.eq=function(i,l){return R(i.equals(l))},this.gt=function(i,l){return R(i.gt(l))},this.gte=function(i,l){return R(i.gte(l))},this.lt=function(i,l){return R(i.lt(l))},this.lte=function(i,l){return R(i.lte(l))},this.factorial=function(i){return this.symfunction(J,[i])},this.dfactorial=function(i){return this.symfunction(me,[i])}}},Fi={allSame:Q0,allNumeric:k1,arguments2Array:x1,armTimeout:t1,arrayAddSlices:D1,arrayClone:$1,arrayMax:U1,arrayMin:Mn,arrayEqual:P1,arrayUnique:An,err:Pt,arrayGetVariables:xi,arraySum:Li,block:Bt,checkTimeout:en,clearU:X1,comboSort:V1,compare:Ri,convertToVector:l1,customError:jt,customType:L1,decompose_fn:o1,disarmTimeout:n1,each:Wn,evaluate:Nt,even:Ut,evenFraction:mn,fillHoles:Ui,firstObject:J0,format:qt,generatePrimes:i1,getCoeffs:qi,getU:Pi,importFunctions:Di,inBrackets:Mt,isArray:Dt,isCollection:dn,isExpression:r1,isFraction:_n,isInt:mt,isMatrix:St,isNegative:tn,isNumericSymbol:q0,isPrime:$0,isReserved:K0,isSet:bn,isSymbol:gt,isVariableSymbol:Qn,isVector:vt,keys:Cn,knownVariable:F1,nroots:Ti,remove:d0,reserveNames:k0,range:q1,round:m0,sameSign:O1,scientificToDecimal:F0,separate:s1,stringReplace:R1,text:Xt,validateName:w0,variables:n0,warn:In};function ki(){return(function(t,e,o,g){t1();try{let E=re.parser,L=re.state.EXPRESSIONS,A=!1;if((typeof t=="string"||typeof t=="function")&&On(t))return re.libExports;t!==null&&typeof t=="object"&&t instanceof S0&&(t=t.toString()),t!==null&&typeof t=="object"&&"text"in t&&typeof t.text=="function"&&(t=t.text()),Dt(o)||(o=typeof o>"u"?[]:[o]),o.forEach(V=>{if(V==="numer"){A=!0;return}let J=E.functions[V];J&&J[1]===1&&(t=`${V}(${t})`)});let k=Bt("PARSE2NUMBER",()=>E.parse(t,e),A||_e.PARSE2NUMBER),G=new S0(k);return g?L[g-1]=G:L.push(G),G}finally{n1()}})}function Bi(){let r=re.parser;return{groups:M1,NerdamerSymbol:W,Expression:S0,Collection:t0,Frac:Ve,Vector:It,Matrix:xt,NerdamerSet:g0,Math2:ut,LaTeX:yt,Build:e0,Utils:Fi,PARSER:r,Settings:_e,bigInt:Nn,bigDec:rn,exceptions:re.exceptions,Solve:{},Calculus:{},Algebra:{},Extra:{}}}function Vi(){let r=re.parser;k0(r.CONSTANTS),k0(r.functions),r.initConstants(),r.error||=Pt,_e.LOG_FNS={log:r.functions.log,log10:r.functions.log10}}function Xi(r){r.rpn=pi,r.convertToLaTeX=si,r.convertFromLaTeX=wi,r.version=J1,r.getWarnings=G1,r.setConstant=Mi,r.getConstant=ni,r.clearConstants=Ni,r.setFunction=bi,r.clearFunctions=vi,r.getCore=Y1,r.getExpression=r.getEquation=S0.getExpression,r.reserved=Q1,r.clear=Kn,r.flush=yi,r.expressions=mi,r.functions=di,r.register=e1,r.validateName=w0,r.validVarName=W1,r.supported=ei,r.numEquations=r.numExpressions=j1,r.setVar=Ai,r.getVar=ii,r.clearVars=Si,r.load=Ei,r.getVars=ri,r.set=Sn,r.get=z1,r.updateAPI=Ci,r.replaceFunction=gi,r.setOperator=ai,r.getOperator=oi,r.aliasOperator=li,r.tree=Yn,r.htmlTree=hi,r.addPeeker=ui,r.removePeeker=ci,r.parse=fi}var Gi=(function(){let t=new nn;re.parser=t,re.classes.Parser=nn,yt.initParser(),e0.initDependencies(),Vi();let e=Bi();re.core=e,re.classes.Math2=e.Math2,re.utils.symfunction=t.symfunction.bind(t),re.utils.callfunction=t.callfunction.bind(t),re.state.CONSTANTS=t.CONSTANTS;let o=ki();return re.libExports=o,Xi(o),o.updateAPI(),o})();typeof vn<"u"&&(vn.exports=Gi)});var V0=f0((Ji,a1)=>{"use strict";var B0=typeof globalThis<"u"&&globalThis.nerdamer?globalThis.nerdamer:void 0;typeof a1<"u"&&B0===void 0&&(B0=T0(),X0());(function(){let t=B0.getCore(),e=t.PARSER,{Frac:o}=t,{Settings:g}=t,{isSymbol:E}=t.Utils,{FN:L}=t.groups,{NerdamerSymbol:A}=t,{text:k}=t.Utils,{inBrackets:G}=t.Utils,{isInt:V}=t.Utils,{format:J}=t.Utils,{even:me}=t.Utils,{evaluate:Ae}=t.Utils,{N:$e}=t.groups,{S:Te}=t.groups,{PL:Ee}=t.groups,{CP:Me}=t.groups,{CB:a}=t.groups,{EX:ue}=t.groups,{P:ve}=t.groups,{LOG:Ne}=g,ye="exp",Ie="abs",he="sqrt",be="sin",we="cos",fe="tan",s="sec",c="csc",S="cot",O="asin",p="acos",h="atan",N="asec",q="acsc",P="acot",D="sinh",K="cosh",z="tanh",te="csch",ce="sech",de="coth",Se="asech",xe="acsch",Re="acoth";function He(H){return E(H.power)&&(H.power.group===Te||H.power.group===a)}function et(H){this.message=H||""}et.prototype=new Error,A.prototype.hasIntegral=function(){return this.containsFunction("integrate")},A.prototype.fnTransform=function(){if(this.group!==L)return this;let X,F=this.args[0],ee=new A(this.multiplier),_=this.clone().toUnitMultiplier();if(this.isLinear())switch(this.fname){case D:X=e.parse(J("(e^({0})-e^(-({0})))/2",F));break;case K:X=e.parse(J("(e^({0})+e^(-({0})))/2",F));break;case z:X=e.parse(J("(e^({0})-e^(-({0})))/(e^({0})+e^(-({0})))",F));break;case fe:X=e.parse(J("sin({0})/cos({0})",F));break;case c:X=e.parse(J("1/sin({0})",F));break;case s:X=e.parse(J("1/cos({0})",F));break;default:X=_}else if(this.power.equals(2))switch(this.fname){case be:X=e.parse(J("1/2-cos(2*({0}))/2",F));break;case we:X=e.parse(J("1/2+cos(2*({0}))/2",F));break;case fe:X=e.parse(J("sin({0})^2/cos({0})^2",F));break;case K:X=e.parse(J("1/2+cosh(2*({0}))/2",F));break;case D:X=e.parse(J("-1/2+cosh(2*({0}))/2",F));break;case z:X=e.parse(J("(1+cosh(2*({0})))/(-1+cosh(2*({0})))",F));break;case s:X=e.parse(J("(1-cos(2*({0})))/(1+cos(2*({0})))+1",F));break;default:X=_}else if(this.fname===s)X=e.parse(J("1/cos({0})^({1})",this.args[0],this.power));else if(this.fname===c)X=e.parse(J("1/sin({0})^({1})",this.args[0],this.power));else if(this.fname===fe)this.power.lessThan(0)?X=e.parse(J("cos({0})^(-({1}))/sin({0})^({1})",this.args[0],this.power.negate())):X=e.parse(J("sin({0})^({1})/cos({0})^({1})",this.args[0],this.power));else if(this.fname===be&&this.power.lessThan(0))X=e.parse(J("csc({0})^(-({1}))",this.args[0],this.power.negate()));else if(this.fname===we&&this.power.lessThan(0))X=e.parse(J("sec({0})^(-({1}))",this.args[0],this.power.negate()));else if(this.fname===be&&this.power.equals(3))X=e.parse(J("(3*sin({0})-sin(3*({0})))/4",this.args[0]));else if(this.fname===we&&this.power.equals(3))X=e.parse(J("(cos(3*({0}))+3*cos({0}))/4",this.args[0]));else if((this.fname===we||this.fname===be)&&me(this.power)){let x=this.power/2,m=this.clone().toLinear(),f=e.pow(m,e.parse(2)),$=e.expand(e.pow(f.fnTransform(),e.parse(x)));X=new A(0),$.each(w=>{let U=w.fnTransform();X=e.add(X,U)},!0)}else X=_;return e.multiply(X,ee)},A.prototype.hasTrig=function(){if(this.isConstant(!0)||this.group===Te)return!1;if(this.fname&&(t.Utils.inTrig(this.fname)||t.Utils.inInverseTrig(this.fname)))return!0;if(this.symbols){for(let X in this.symbols)if(this.symbols[X].hasTrig())return!0}return!1},t.Expression.prototype.hasIntegral=function(){return this.symbol.hasIntegral()},t.Utils.toCommonDenominator=function(X){if(X.isComposite()&&X.isLinear()){let F=new A(X.multiplier),ee=new A(1),_=new A(0);return X.each(m=>{ee=e.multiply(ee,m.getDenom())},!0),X.each(m=>{let f=m.getNum(),$=m.getDenom(),w=e.multiply(f,e.divide(ee.clone(),$));_=e.add(_,w)}),e.multiply(F,t.Algebra.divide(e.expand(_),e.expand(ee)))}return X},t.Utils.inInverseTrig=function(X){return[O,p,h,q,N,P].indexOf(X)!==-1},t.Utils.inTrig=function(X){return[we,be,fe,s,c,S].indexOf(X)!==-1},t.Utils.inHtrig=function(X){return[D,K,z,xe,Se,Re].indexOf(X)!==-1},t.Matrix.jacobian=function(X,F){let ee=new t.Matrix;return F||=t.Utils.arrayGetVariables(X),F.forEach((_,x)=>{X.forEach((m,f)=>{let $=t.Calculus.diff(m.clone(),_);ee.set(f,x,$)})}),ee},t.Matrix.prototype.max=function(){let X=new A(0);return this.each(F=>{let ee=F.abs();ee.gt(X)&&(X=ee)}),X},t.Matrix.cMatrix=function(X,F){let ee=new t.Matrix;return F.forEach((_,x)=>{ee.set(x,0,e.parse(X))}),ee};let Oe=t.Utils.allFunctions=function(X){for(let F=0,ee=X.length;F{let w=H.text(),U={"~":!0},B=new t.NerdamerSymbol(0);for(let Z=f;Z<=$;Z++){U[_]=new A(Z);let Y=e.parse(w,U);B=e.add(B,Y)}return B})}else x=e.symfunction("sum",[H,new A(_),F,ee]);return x},product(H,X,F,ee){if(X.group!==t.groups.S)throw new t.exceptions.NerdamerTypeError(`Index must be symbol. ${k(X)} provided`);let _=X.value,x;if(t.Utils.isNumericSymbol(F)&&t.Utils.isNumericSymbol(ee)){let m=Number(ee)-Number(F)<200?"":"PARSE2NUMBER";x=t.Utils.block(m,()=>{let f=Number(F),$=Number(ee.multiplier),w=H.text(),U={},B=new t.NerdamerSymbol(1);for(let Z=f;Z<=$;Z++)U[_]=new A(Z),B=e.multiply(B,e.parse(w,U));return B})}else x=e.symfunction("product",[H,new A(_),F,ee]);return x},diff(H,X,F){if(t.Utils.isVector(H)){let w=new t.Vector([]);return H.each(U=>{w.elements.push(Q.diff(U,X,F))}),w}if(t.Utils.isMatrix(H)){let w=new t.Matrix;return H.each((U,B,Z)=>{w.set(B,Z,Q.diff(U,X,F))}),w}let ee=H;if(ee.LHS&&ee.RHS)return new t.Equation(Q.diff(ee.LHS.clone(),X,F),Q.diff(ee.RHS.clone(),X,F));let _=E(X)?X.text():X;if(F=E(F)?F.multiplier.toDecimal():F||1,_===void 0&&(_=t.Utils.variables(H)[0]),ee.group===L&&ee.fname===he){let w=ee.args[0],U=ee.power.clone();(w.group!==$e||w.group!==ve)&&(w.power=E(w.power)?e.multiply(e.multiply(w.power,new A(1/2)),new A(U)):w.power.multiply(new o(.5)).multiply(U),w.multiplier=w.multiplier.multiply(ee.multiplier)),H=w}if(H.group===L&&!E(H.power)){let w=m(e.parse(H)),U=Q.diff(H.args[0].clone(),_);H=e.multiply(w,U)}else H=m(H);return F>1&&(F--,H=Q.diff(H,X,F)),H;function x(w){return(w.value===_||w.contains(_,!0))&&(w.multiplier=w.multiplier.multiply(w.power),w.power=w.power.subtract(new o(1)),w.power.equals(0)&&(w=new A(w.multiplier))),w}function m(w){let U=w.group,B,Z,Y;if(U===$e||U===Te&&w.value!==_||U===ve)w=new A(0);else if(U===Te)w=x(w);else if(U===a){let ie=w.multiplier.clone();w.toUnitMultiplier();let oe=e.multiply($(w),x(w));return oe.multiplier=oe.multiplier.multiply(ie),oe}else if(U===L&&w.power.equals(1)){let ie=w.multiplier.clone();switch(w.toUnitMultiplier(),w.fname){case Ne:Y=w.clone(),w=w.args[0].clone(),w.power=w.power.negate(),w.multiplier=Y.multiplier.divide(w.multiplier);break;case we:w.fname=be,w.multiplier.negate();break;case be:w.fname=we;break;case fe:w.fname=s,w.power=new o(2);break;case s:w=f(w,fe);break;case c:w=f(w,"-cot");break;case S:w.fname=c,w.multiplier.negate(),w.power=new o(2);break;case O:w=e.parse(`(sqrt(1-(${k(w.args[0])})^2))^(-1)`);break;case p:w=e.parse(`-(sqrt(1-(${k(w.args[0])})^2))^(-1)`);break;case h:w=e.parse(`(1+(${k(w.args[0])})^2)^(-1)`);break;case Ie:Z=w.args[0].clone(),Z.toUnitMultiplier(),w=e.parse(`${G(k(w.args[0]))}/abs${G(k(Z))}`);break;case"parens":w=new A(1);break;case"cosh":w.fname="sinh";break;case"sinh":w.fname="cosh";break;case z:w.fname=ce,w.power=new o(2);break;case ce:w=f(w,"-tanh");break;case te:{let oe=String(w.args[0]);w=e.parse(`-coth(${oe})*csch(${oe})`);break}case de:{let oe=String(w.args[0]);w=e.parse(`-csch(${oe})^2`);break}case"asinh":w=e.parse(`(sqrt(1+(${k(w.args[0])})^2))^(-1)`);break;case"acosh":w=e.parse(`(sqrt(-1+(${k(w.args[0])})^2))^(-1)`);break;case"atanh":w=e.parse(`(1-(${k(w.args[0])})^2)^(-1)`);break;case Se:{let oe=String(w.args[0]);w=e.parse(`-1/(sqrt(1/(${oe})^2-1)*(${oe})^2)`);break}case Re:w=e.parse(`-1/((${w.args[0]})^2-1)`);break;case xe:{let oe=String(w.args[0]);w=e.parse(`-1/(sqrt(1/(${oe})^2+1)*(${oe})^2)`);break}case N:{let oe=String(w.args[0]);w=e.parse(`1/(sqrt(1-1/(${oe})^2)*(${oe})^2)`);break}case q:{let oe=String(w.args[0]);w=e.parse(`-1/(sqrt(1-1/(${oe})^2)*(${oe})^2)`);break}case P:w=e.parse(`-1/((${w.args[0]})^2+1)`);break;case"S":{let oe=String(w.args[0]);w=e.parse(`sin((pi*(${oe})^2)/2)`);break}case"C":{let oe=String(w.args[0]);w=e.parse(`cos((pi*(${oe})^2)/2)`);break}case"Si":{let oe=w.args[0];w=e.parse(`sin(${oe})/(${oe})`);break}case"Shi":{let oe=w.args[0];w=e.parse(`sinh(${oe})/(${oe})`);break}case"Ci":{let oe=w.args[0];w=e.parse(`cos(${oe})/(${oe})`);break}case"Chi":{let oe=w.args[0];w=e.parse(`cosh(${oe})/(${oe})`);break}case"Ei":{let oe=w.args[0];w=e.parse(`e^(${oe})/(${oe})`);break}case"Li":{let oe=w.args[0];w=e.parse(`1/${g.LOG}(${oe})`);break}case"erf":w=e.parse(`(2*e^(-(${w.args[0]})^2))/sqrt(pi)`);break;case"atan2":{let oe=String(w.args[0]),ne=String(w.args[1]);w=e.parse(`(${ne})/((${ne})^2+(${oe})^2)`);break}case"sign":w=new A(0);break;case"sinc":w=e.parse(J("(({0})*cos({0})-sin({0}))*({0})^(-2)",w.args[0]));break;case g.LOG10:w=e.parse(`1/((${w.args[0]})*${g.LOG}(10))`);break;default:w=e.symfunction("diff",[w,X])}w.multiplier=w.multiplier.multiply(ie)}else if(U===ue||U===L&&E(w.power)){let ie;U===ue?ie=w.value:U===L&&w.contains(_)?ie=w.fname+G(k(w.args[0])):ie=w.value+G(k(w.args[0])),Z=Q.diff(e.multiply(e.parse(Ne+G(ie)),w.power.clone()),_),w=e.multiply(w,Z)}else if(U===L&&!w.power.equals(1))Z=w.clone(),Z.toLinear(),Z.toUnitMultiplier(),w=e.multiply(x(w.clone()),m(Z));else if(U===Me||U===Ee){let ie=w.clone(),oe=new A(0);for(let ne in w.symbols)Object.hasOwn(w.symbols,ne)&&(oe=e.add(oe,Q.diff(w.symbols[ne].clone(),_)));w=e.multiply(x(ie),oe)}return w.updateHash(),w}function f(w,U,B){return e.multiply(w,e.parse(U+G(B||k(w.args[0]))))}function $(w){let U=w.collectSymbols(),B=new A(0),Z=U.length;for(let Y=0;Y{m.isLinear()||Q.integration.stop()}),x.each(m=>{_=e.add(_,Q.integrate(m,X,F,ee))})):_=e.add(_,Q.integrate(x,X,F,ee)),_},get_udv(H){let X=[[],[],[],[],[]],F=function(x){let m=x.group;if(m===L){let{fname:f}=x;t.Utils.inTrig(f)||t.Utils.inHtrig(f)?X[3].push(x):t.Utils.inInverseTrig(f)?X[1].push(x):f===Ne?X[0].push(x):Q.integration.stop()}else m===Te||x.isComposite()&&x.isLinear()||m===a&&x.isLinear()?X[2].push(x):m===ue||x.isComposite()&&!x.isLinear()?X[4].push(x):Q.integration.stop()};H.group===a?H.each(x=>{F(A.unwrapSQRT(x,!0))}):F(H);let ee,_=new A(1);for(let x=0;x<5;x++){let m=X[x],f,$=m.length;if($>0){if($>1){f=new A(1);for(let w=0;w<$;w++)f=e.multiply(f,m[w].clone())}else f=m[0].clone();ee?_=e.multiply(_,f):(ee=f,ee.multiplier=ee.multiplier.multiply(H.multiplier))}}return[ee,_]},trig_sub(H,X,F,ee,_,x){_||=Q.integration.decompose_arg(H.clone().toLinear(),X);let m=_[3],f=_[2],$=_[0],w=_[1];if(w.power.equals(2)&&$.greaterThan(0)){let U=t.Utils.getU(H),B=e.parse(fe+G(U)),Z=e.parse(`${s+G(U)}^2`),Y=e.multiply(H.sub(w,B),Z),ie=Q.integrate(Y,U,F,ee).sub(B,w);return t.Utils.clearU(B),ie}},by_parts(H,X,F,ee){ee.previous||=[];let _,x=Q.integration.get_udv(H),m=x[0],f=x[1],$=A.unwrapSQRT(e.expand(Q.diff(m.clone(),X)),!0),w=$.clone().stripVar(X);$=e.divide($,w.clone());let U=Q.integrate(f.clone(),X,F||0),B=e.multiply(U.clone(),$),Z=B.toString();if(ee.previous.indexOf(Z)!==-1&&t.Utils.inTrig(m.fname)&&f.isE())return ee.is_cyclic=!0,new A(1);ee.previous.push(Z);let Y=e.multiply(m,U),ie=B.multiplier.clone();B.toUnitMultiplier();let oe=e.multiply(Q.integrate(B.clone(),X,F,ee),w);if(oe.multiplier=oe.multiplier.multiply(ie),_=e.subtract(Y,oe),ee.is_cyclic&&(ee.previous.pop(),ee.previous.length===0)){_=e.expand(_);let ne=new A(0);_.each(le=>{le.contains(X)||(ne=e.add(ne,le.clone()))}),_=e.divide(e.subtract(_,ne.clone()),e.subtract(new A(1),ne))}return _},decompose_arg:t.Utils.decompose_fn},integrate(H,X,F,ee){if(t.Utils.isVector(H)){let _=new t.Vector([]);return H.each(x=>{_.elements.push(Q.integrate(x,X))}),_}if(!X){let _=t.Utils.variables(H);_.length===1&&(X=_[0]),X||="x"}return isNaN(parseFloat(X))||e.error(`variable expected but received ${X}`),H.isConstant(!0)?e.multiply(H.clone(),e.parse(X)):(ee||={},t.Utils.block("PARSE2NUMBER",()=>{F||=0;let _=E(X)?X.toString():X,x=A.unwrapSQRT(H.clone(),!0),m=x.group,f;try{if(++F>t.Settings.integration_depth&&Q.integration.stop("Maximum depth reached. Exiting!"),!x.contains(_,!0))f=e.multiply(x.clone(),e.parse(_));else if(m===Te)f=Q.integration.poly_integrate(x,_,F);else if(m===ue)if(x.previousGroup===L&&!(x.fname==="sqrt"||x.fname===g.PARENTHESIS)&&Q.integration.stop(),x.contains(_)&&x.previousGroup!==L)x.power.contains(_)?Q.integration.stop():(Q.diff(x.clone().toLinear(),_).contains(_)&&Q.integration.stop(),f=Q.integration.poly_integrate(x));else{let w=Q.diff(x.power.clone(),_);if(w.contains(_)){let U=w.stripVar(_),B=e.divide(w.clone(),U.clone());if(B.group===Te&&B.isLinear())return U.multiplier=U.multiplier.divide(new o(2)),e.parse(J("({2})*(sqrt(pi)*erf(sqrt(-{0})*{1}))/(2*sqrt(-{0}))",U,_,x.multiplier));Q.integration.stop()}if(x.isE())if(w.isLinear())f=x;else if(w.isE()&&E(w.power)&&w.power.group===Te&&w.power.power.equals(1)){let U=E(x.power)?x.power:new A(x.power);f=e.multiply(e.symfunction("Ei",[U.clone()]),U)}else Q.integration.stop();else{let U=e.symfunction(Ne,[e.parse(x.value)]);f=e.divide(x,U)}f=e.divide(f,w)}else if(x.isComposite()&&x.isLinear()){let w=e.parse(x.multiplier);x.toUnitMultiplier(),f=new A(0),x.each(U=>{f=e.add(f,Q.integrate(U,_,F))}),f=e.multiply(w,f)}else if(m===Me)if(x.power.greaterThan(1)&&(x=e.expand(x)),x.power.equals(1))f=new A(0),x.each(w=>{f=e.add(f,Q.integrate(w,_,F))},!0);else{let w=Number(x.power),U=x.multiplier.clone();x.toUnitMultiplier();let B=x.clone().toLinear(),Z=Q.integration.decompose_arg(B,_),Y=Z[3],ie=Z[2],oe=Z[0],ne=Z[1];if(w===-1&&ne.group!==Ee&&ne.power.equals(2)){let le=V(Y)?Number(Y)>0:!0;if(ne.group===Te&&ne.power.equals(2)&&le){let ge=function(Ze){let tt=new A(1);return Ze.each(je=>{tt=e.multiply(tt,je.fname==="abs"?je.args[0]:je)}),tt},ke=oe.clone(),Le=Y.clone();ke=e.pow(ke,new A(1/2)),Le=e.pow(Le,new A(1/2));let We=e.multiply(ge(Le),ge(ke)),Qe=e.symfunction(h,[e.divide(e.multiply(oe,ne.toLinear()),We.clone())]);f=e.divide(Qe,We)}else if(ne.group===Te&&ne.isLinear())f=e.divide(Q.integration.poly_integrate(x),oe);else if(ne.power.equals(4)){let ge=G,ke=e.parse(`${he+ge(String(oe))}*${_}^2`),Le=e.parse(`${he+ge(String(2))}*${ge(String(oe))}^${ge("1/4")}*${ge(String(Y))}^${ge("1/4")}*${_}`),We=e.parse(he+ge(String(Y))),Qe=e.add(e.add(ke.clone(),Le.clone()),We.clone()),Ze=e.add(e.subtract(ke,Le),We),tt=e.parse(`${he+ge(String(2))}*${ge(String(Y))}^${ge("3/4")}`),je=e.parse(`${he+ge(String(Y))}*${ge(String(Y))}^${ge("1/4")}*${_}`),lt=e.parse(`2*${ge(String(Y))}*${he}${ge(String(2))}*${ge(String(Y))}^${ge("1/4")}`),ct=e.divide(e.subtract(tt.clone(),je.clone()),e.multiply(lt.clone(),Ze)),ft=e.divide(e.add(tt,je),e.multiply(lt,Qe.clone()));f=e.add(Q.integrate(ct,_,F,ee),Q.integrate(ft,_,F,ee))}else f=Q.integration.partial_fraction(x,_,F)}else if(w===-1/2)if(ne.group===Te&&ne.power.equals(2))if(ie.multiplier.lessThan(0)&&!Y.multiplier.lessThan(0))if(oe.negate(),Y.isConstant()&&oe.isConstant()){let le=e.symfunction(he,[oe.clone()]),ge=e.symfunction(he,[e.multiply(oe.clone(),Y)]);f=e.divide(e.symfunction(O,[e.divide(ie.toLinear(),ge)]),le)}else{let le=e.symfunction(he,[oe]),ge=e.multiply(le.clone(),ne.clone().toLinear());f=e.divide(e.symfunction(h,[e.divide(ge,e.symfunction(he,[B.clone()]))]),le)}else Q.integration.stop();else Q.integration.stop();else if(w===1/2&&ne.power.equals(2)&&oe.greaterThan(0))Q.integration.stop();else if(ne.isLinear()&&ne.group!==Ee)f=e.divide(Q.integration.poly_integrate(x),oe);else if(ne.power.equals(2)&&oe.greaterThan(0)){let le=e.parse(he+G(oe)),ge=e.parse(he+G(Y)),ke=e.multiply(le.clone(),ge.clone()).invert(),Le=e.pow(Y,new A(x.power.toDecimal())),We=t.Utils.getU(x),Qe=e.multiply(ke,ne.clone().toLinear()),Ze=e.symfunction(h,[Qe]),tt=(Math.abs(Number(x.power))-1)*2,je=Q.integrate(e.parse(`${we+G(We)}^${tt}`));return t.Utils.clearU(We),e.multiply(je.sub(We,Ze),Le)}else if(x.group!==a&&!x.power.lessThan(0))f=Q.integration.by_parts(x,_,F,ee);else{let le=x.clone().toLinear(),ke=t.Algebra.Factor.factorInner(le).toString()!==le.toString();if(t.Algebra.degree(le,e.parse(_)).equals(2)&&!ke)try{let Le=t.Algebra.sqComplete(le,_),We=t.Utils.getU(le),Qe=Le.f.sub(Le.a,We),Ze=e.pow(Qe,e.parse(x.power));f=Q.integrate(Ze,We).sub(We,Le.a)}catch(Le){if(Le.message==="timeout")throw Le;Q.integration.stop()}else f=Q.integration.partial_fraction(x,_,F,ee)}f.multiplier=f.multiplier.multiply(U)}else if(m===L){let w=x.args[0],U=x.multiplier.clone();x.toUnitMultiplier();let B=Q.integration.decompose_arg(w,_),Z=B[0],Y=B[1],{fname:ie}=x;if(ie===Ne||ie===O||ie===p||ie===h&&Y.isLinear()){let oe=x.power.toString();if(V(oe)&&(F-=Number(oe)),w.isComposite()){let ne=t.Utils.getU(x),le=e.pow(e.parse(Ne+G(ne)),new A(oe)),ge=Q.diff(w,_),ke=e.multiply(le,ge),Le=Q.integrate(ke,ne,F,ee);f=e.multiply(e.parse(U),Le.sub(ne,w))}else f=e.multiply(e.parse(U),Q.integration.by_parts(x,_,F,ee))}else if(ie===fe&&x.power.lessThan(0)){let oe=x.clone();return oe.power.negate(),oe.fname=S,e.multiply(e.parse(U),Q.integrate(oe,_,F))}else{if(!Z.contains(_,!0)&&x.isLinear())if(ie===Ie){let oe=e.divide(w.clone(),Z.clone());if(oe.group===Te&&!oe.power.lessThan(0))if(t.Utils.even(oe.power))f=Q.integrate(w,_,F);else{let ne=Q.integrate(oe,_,F);ne.power=ne.power.subtract(new o(1)),f=e.multiply(e.multiply(e.symfunction(Ie,[oe.toLinear()]),ne),Z)}else Q.integration.stop()}else{let oe=x.args[0].group,ne=Q.integration.decompose_arg(w,_);switch((!(oe===Me||oe===Te||oe===a)||!ne[1].power.equals(1)||w.hasFunc(""))&&Q.integration.stop(),ie){case we:f=e.symfunction(be,[w]);break;case be:f=e.symfunction(we,[w]),f.negate();break;case fe:f=e.parse(J(`${g.LOG}(sec({0}))`,w));break;case s:f=e.parse(J(`${g.LOG}(tan({0})+sec({0}))`,w));break;case c:f=e.parse(J(`-${g.LOG}(csc({0})+cot({0}))`,w));break;case S:f=e.parse(J(`${g.LOG}(sin({0}))`,w));break;case D:f=e.symfunction(K,[w]);break;case K:f=e.symfunction(D,[w]);break;case z:f=e.parse(J(`${g.LOG}(cosh({0}))`,w));break;case N:f=Q.integration.by_parts(x,_,F,ee);break;case q:f=Q.integration.by_parts(x,_,F,ee);break;case P:f=Q.integration.by_parts(x,_,F,ee);break;case Se:f=Q.integration.by_parts(x,_,F,ee);break;case xe:f=Q.integration.by_parts(x,_,F,ee);break;case Re:f=Q.integration.by_parts(x,_,F,ee);break;case ce:f=e.parse(J("atan(sinh({0}))",w));break;case te:f=e.parse(J(`${g.LOG}(tanh(({0})/2))`,w));break;case de:f=e.parse(J(`${g.LOG}(sinh({0}))`,w));break;case ye:f=Q.integrate(e.parse(J("e^({0})",w)),_,F);break;case"S":{let le=x.args[0].clone(),ge=Q.integration.decompose_arg(le,_),ke=ge[1],Le=ge[0],We=ge[3];f=e.parse(J("(cos((1/2)*pi*(({1})+({0})*({2}))^2)+pi*(({1})+({0})*({2}))*S(({1})+({0})*({2})))/(({0})*pi)",Le,We,Y));break}case"C":{let le=x.args[0].clone(),ge=Q.integration.decompose_arg(le,_),ke=ge[1],Le=ge[0],We=ge[3];f=e.parse(J("(pi*(({1})+({0})*({2}))*C(({1})+({0})*({2}))-sin((1/2)*pi*(({1})+({0})*({2}))^2))/(({0})*pi)",Le,We,ke));break}case"erf":{let le=x.args[0].clone(),ge=Q.integration.decompose_arg(le,_),ke=ge[1],Le=ge[0];f=e.parse(J("e^(-(({2}))^2)/(({0})*sqrt(pi))+(1/({0})+({1}))*erf(({2}))",Le,ke,le));break}case"sign":f=e.multiply(x.clone(),w.clone());break;default:Q.integration.stop()}f=e.divide(f,Z)}else if(Y.isLinear())if(ie===we||ie===be){let oe=Number(x.power);if(oe<0)x.fname=ie===be?c:s,x.invert().updateHash(),f=Q.integrate(x,_,F);else{let ne=x.args[0],le=x.clone(),ge=x.clone(),ke=new A((oe-1)/oe),Le=e.multiply(Z.clone(),new A(oe)).invert();le.power=le.power.subtract(new o(1)),ge.power=ge.power.subtract(new o(2));let We=e.symfunction(ie===we?be:we,[w.clone()]);ie===be&&We.negate(),f=e.add(e.multiply(e.multiply(Le,le),We),e.multiply(ke,Q.integrate(e.parse(ge),_,F)))}}else if(ie===fe||ie===S){if(x.args[0].isLinear(_)){let oe=x.power.subtract(new o(1)).toString(),ne=x.clone().toUnitMultiplier(),le=e.parse(J(`${ie===S?"-":""}1/({2}*{0})*{3}({1})^({0})`,oe,w,Z,ie));ne.power=ne.power.subtract(new o(2)),ne.power.equals(0)&&(ne=e.parse(ne)),f=e.subtract(le,Q.integrate(ne,_,F))}}else if(ie===s||ie===c){let oe=x.power.subtract(new o(1)).toString(),ne=x.power.subtract(new o(2)).toString(),le=ie===s?fe:S,ge=x.clone().toUnitMultiplier(),ke=J(`${ie===c?"-":""}1/({0}*{1})*{4}({3})^({2})*{5}({3})`,Z,oe,ne,w,ie,le),Le=e.parse(ke);ge.power=ge.power.subtract(new o(2)),ge.power.equals(0)&&(ge=e.parse(ge)),f=e.add(Le,e.multiply(new A(Number(ne)/Number(oe)),Q.integrate(ge,_,F)))}else(ie===K||ie===D)&&x.power.equals(2)?f=Q.integrate(x.fnTransform(),_,F):Q.integration.stop();else Q.integration.stop();f.multiplier=f.multiplier.multiply(U)}}else if(m===Ee)f=Q.integration.partial_fraction(x,_,F);else if(m===a){x.getDenom().group===Te&&(x=e.expand(x));let U=x.stripVar(_),B=e.divide(x.clone(),U.clone());if(U.contains(_)&&(B=e.multiply(B,U),U=new A(1)),B.group===a){let Z=B.collectSymbols().sort((ie,oe)=>ie.group===oe.group?Number(ie.power)===Number(oe.power)?ie{let oe=A.unwrapSQRT(ie,!0);return oe.fname===ye?e.parse(J("({1})*e^({0})",oe.args[0],oe.multiplier)):oe}),Y=Z.length;if(Number(x.power)<0){if(Y===2)return Q.integrate(e.expand(x),_,F,ee)}else if(Y===2){try{f=Q.integration.u_substitution(Z,_)}catch(ie){if(ie.message==="timeout")throw ie}if(!f){let ie=Z[0].group,oe=Z[1].group,ne=Z[0],le=Z[1],ge=ne.fname,ke=le.fname;if(x=e.multiply(ne.clone(),le.clone()),ie===L&&oe===L)if(ge===Ne||ke===Ne)f=Q.integration.by_parts(x.clone(),_,F,ee);else{Z.sort((je,lt)=>lt.fname>je.fname?1:-1);let Le=ne.args[0];(!Le.isLinear()||!(Le.group===Me||Le.group===a||Le.group===Te))&&Q.integration.stop();let We=Q.integration.decompose_arg(Le,_),Qe=We[1],Ze=We[0];Qe.isLinear()||Q.integration.stop();let tt=le.args[0];if(Le.equals(tt))if(ge===be&&ke===we||ge===we&&ke===be)if(ne.power.lessThan(0)&&Q.integration.stop(),ge===be&&ne.power.add(le.power).equals(0))ne.fname=fe,ne.updateHash(),f=Q.integrate(ne,_,F);else if(me(ne.power)&&ke===we&&le.power.lessThan(0)){let je=Number(ne.power)/2,lt=e.parse(J("(1-cos({0})^2)^({1})",ne.args[0],je));f=Q.integrate(e.expand(e.multiply(lt,le.clone())),_,F,ee)}else if(me(ne.power)&&ke===be&&le.power.lessThan(0)){let je=Number(ne.power)/2,lt=e.parse(J("(1-sin({0})^2)^({1})",ne.args[0],je));f=Q.integrate(e.expand(e.multiply(lt,le.clone())),_,F,ee)}else{let je=t.Utils.even(ne.power),lt=t.Utils.even(le.power);if(f=new A(0),!je||!lt){let ct,ft;je?(ct=ne,ft=le):(ct=le,ft=ne);let At=ct.fname===we?-1:1,Tt=(Number(ft.power)-1)/2,pt=e.parse(`(1-${ct.fname}${t.Utils.inBrackets(Le.toString())}^2)^${Tt}`);e.expand(e.multiply(new A(At),e.multiply(ct.clone(),pt))).each(_t=>{f=e.add(f,Q.integration.poly_integrate(_t.clone()))})}else{let ct=function(pt){let _t=pt.power/2,Ot;return pt.fname===we?Ot=`((1/2)+(cos(2*(${pt.args[0]}))/2))^${_t}`:Ot=`((1/2)-(cos(2*(${pt.args[0]}))/2))^${_t}`,e.parse(Ot)},ft=ct(ne),At=ct(le),$t=e.multiply(ft,At);return e.expand($t).each(pt=>{f=e.add(f,Q.integrate(pt,_,F))}),e.multiply(f,U)}}else if(ge===s&&ke===fe&&Qe.isLinear()&&le.isLinear())f=e.parse(J("sec({0})^({1})/({1})",ne.args[0],ne.power));else if(ge===fe&&ke===s&&Qe.isLinear())if(ne.isLinear()&&le.isLinear())f=e.divide(e.symfunction(s,[Le.clone()]),Ze);else if(me(ne.power)){let je=Number(ne.power)/2,lt=e.parse(J("(sec({0})^2-1)^({1})",ne.args[0],je));f=Q.integrate(e.expand(e.multiply(lt,le)),_,F)}else Q.integration.stop();else if(ge===s&&ke===we)ne.fname=we,ne.invert().updateHash(),f=Q.integrate(e.multiply(ne,le),_,F);else if(ge===be&&ke===c)le.fname=be,le.invert().updateHash(),f=Q.integrate(e.multiply(ne,le),_,F);else if(ge===fe&&(ke===we||ke===be)&&le.power.lessThan(0)){let je=e.multiply(ne.fnTransform(),le);f=Q.integrate(e.expand(je),_,F)}else{let je=e.multiply(ne.fnTransform(),le.fnTransform());f=Q.integrate(e.expand(je),_,F)}else if((ge===be||ge===we)&&(ke===be||ke===we))if(ne.isLinear()&&le.isLinear())if(ne.args[0].isLinear()&&le.args[0].isLinear()){let je,lt;ke===be?(je=ne.args[0],lt=le.args[0]):(lt=ne.args[0],je=le.args[0]);let ct=e.parse(J("(sin(({1})+({0}))+sin(({1})-({0})))/2",je.toString(),lt.toString()));f=Q.integrate(ct,_,F)}else{let je=Be(Z);f=Q.integrate(e.expand(je),_,F)}else{let je=new A(1);Z.forEach(ct=>{let ft=ct.fnTransform();je=e.multiply(je,ft)});let lt=e.expand(je);f=Q.integrate(lt,_,F),f.hasIntegral()&&(f=Q.integrate(Be(je.collectSymbols()),_,F))}else Q.integration.stop()}else if(ie===L&&oe===Te){let Le=ne.isLinear();if(ne.fname===we&&Le&&le.power.equals(-1))f=e.symfunction("Ci",[ne.args[0]]);else if(ne.fname===we&&le.power.equals(-1))f=Q.integrate(e.multiply(ne.fnTransform(),le.clone()),_,F);else if(ne.fname===K&&Le&&le.power.equals(-1))f=e.symfunction("Chi",[ne.args[0]]);else if(ne.fname===K&&le.power.equals(-1))f=Q.integrate(e.multiply(ne.fnTransform(),le.clone()),_,F);else if(ne.fname===be&&Le&&le.power.equals(-1))f=e.symfunction("Si",[ne.args[0]]);else if(ne.fname===be&&le.power.equals(-1))f=Q.integrate(e.multiply(ne.fnTransform(),le.clone()),_,F);else if(ne.fname===D&&Le&&le.power.equals(-1))f=e.symfunction("Shi",[ne.args[0]]);else if(ne.fname===D&&le.power.equals(-1))f=Q.integrate(e.multiply(ne.fnTransform(),le.clone()),_,F);else if(ne.fname===Ne&&le.power.equals(-1))f=Q.integration.poly_integrate(ne,_,F);else if(ne.fname==="erf"){if(le.power.equals(1)){let We=Q.integration.decompose_arg(ne.args[0],_),Qe=We[0],Ze=We[1],tt=ne.args[0].toString();f=e.parse(J("(e^(-(({2}))^2)*(sqrt(pi)*e^((({2}))^2)*(2*({0})^2*({1})^2-3)*erf(({2}))+2*({0})*({1})-2))/(4*sqrt(pi)*({0})^2)",Qe,Ze,tt))}}else f=Q.integration.by_parts(x,_,F,ee)}else if(ie===ue&&oe===Te){let Le=ge===Ne?Q.integration.decompose_arg(ne.args[0],_)[1]:null;ne.isE()&&He(ne)&&le.power.equals(-1)?f=e.symfunction("Ei",[ne.power.clone()]):ge===Ne&&Le.value===le.value?f=Q.integration.poly_integrate(ne):f=Q.integration.by_parts(x,_,F,ee)}else if(ie===Ee&&oe===Te){if(le.value===ne.value&&ne.power.equals(-1)){let Le=Math.min.apply(null,t.Utils.keys(ne.symbols)),We=Math.min(Le,Number(le.power)),Qe=le.clone();Qe.power=new o(We),le=e.divide(le,Qe.clone());let Ze=new A(0);ne.each(tt=>{Ze=e.add(Ze,e.divide(tt.clone(),Qe.clone()))}),Ze.multiplier=ne.multiplier,x=e.divide(le,Ze)}else x=e.expand(x);f=Q.integration.partial_fraction(x,_,F)}else if(ie===Me&&oe===Te){let Le=ne.clone().toLinear(),We=t.Algebra.degree(Le,e.parse(_)).equals(1);if(ne.power.equals(-1/2)){let Qe=Q.integration.decompose_arg(ne.clone().toLinear(),_),Ze=Qe[0].negate(),tt=Qe[1],je=Qe[3],lt=Number(ne.power),ct=Number(le.power);if(V(ct)&&t.Utils.even(ct)&&tt.power.equals(2)){let ft=e.divide(e.multiply(e.pow(je.clone(),new A(2)),e.symfunction(he,[e.divide(je.clone(),Ze.clone())])),e.pow(Ze.clone(),new A(2)));ft=e.multiply(ft,e.symfunction(he,[je]).invert());let At=e.parse("sin(u)");At.power=At.power.multiply(le.power);let $t=Q.integrate(At,"u",F),Tt=e.parse(`${O}(${he}(${Ze}/${je})*${_})`);f=e.multiply(ft,$t.sub(new A("u"),Tt))}else if(lt===-1/2){let ft=function(At,$t){let Tt=e.parse(Q.integrate(At,_,F,ee).sub(_,J($t,_)));if(!Tt.hasIntegral())return Tt};ct===-1?f=ft(e.expand(e.expand(e.pow(e.multiply(ne.invert(),le.invert()),new A(2)))).invert(),"sqrt(1-1/({0})^2)"):ct===-2&&(f=ft(e.sqrt(e.expand(e.divide(e.pow(x,new A(2)).invert(),e.pow(new A(_),new A(2))).negate())).invert(),"sqrt(1-1/({0})^2)"))}}else if(ne.power.equals(-1)&&le.isLinear()&&We)f=Q.integration.partial_fraction(x,_,F);else if(!ne.power.lessThan(0)&&V(ne.power)){let Qe=e.expand(ne);f=new A(0),Qe.each(Ze=>{Ze.group===Ee?Ze.each(tt=>{f=e.add(f,Q.integrate(e.multiply(le.clone(),tt),_,F))}):f=e.add(f,Q.integrate(e.multiply(le.clone(),Ze),_,F))})}else if(ne.power.lessThan(-2))f=Q.integration.by_parts(x,_,F,ee);else if(ne.power.lessThan(0)&&le.power.greaterThan(1)){let Qe=Q.integration.decompose_arg(ne.clone().toLinear(),_),Ze=Qe[0].negate(),tt=Qe[1],je=Qe[3],lt=ne.clone().toLinear();if(tt.group!==Ee&&tt.isLinear()){let ct=Number(le.power),ft="_u_",At=new A(ft),$t=e.expand(e.divide(e.pow(e.subtract(At.clone(),je.clone()),new A(ct)),At.clone())),Tt={};Tt[ft]=lt;let pt=e.parse($t,Tt);f=Q.integrate(pt,_,0)}else if(le.power.greaterThan(tt.power)||le.power.equals(tt.power)){let ct=new t.Algebra.Classes.Factors;ne=t.Algebra.Factor.coeffFactor(ne.invert(),ct);let ft=t.Algebra.divide(le,ne);ft.group===a?f=Q.integration.by_parts(x,_,F,ee):(f=new A(0),ft.each(At=>{f=e.add(f,Q.integrate(At,_,F))}),ct.each(At=>{f=e.divide(f,At)}),f=e.expand(f))}else f=Q.integration.partial_fraction(x,_,F)}else if(ne.power.den.equals(2)){let Qe=Q.integration.decompose_arg(ne.clone().toLinear(),_),Ze=Qe[3],tt=Qe[1],je=Qe[0],lt=Qe[2];if(tt.power.equals(2)&&je.lessThan(0)){Ze.equals(1)||(U=e.multiply(U,e.pow(Ze,new A(2))));let ct=_,ft=e.divide(e.pow(je.clone().negate(),new A(1/2)),e.pow(Ze,new A(1/2))),At=e.symfunction(we,[new A(ct)]),$t=e.pow(e.symfunction(we,[new A(ct)]),new A(Number(ne.power.num))),Tt=e.pow(e.symfunction(be,[new A(ct)]),new A(Number(le.power))),pt=e.multiply(e.multiply($t,At),Tt);f=Q.integrate(pt,ct,F).sub(ct,e.symfunction(O,[e.multiply(new A(_),ft)]))}else f=Q.integration.partial_fraction(x,_,F,ee)}else We&&(f=Q.integration.partial_fraction(x,_,F))}else if(ne.isComposite()&&le.isComposite())if(f=new A(0),ne.power.greaterThan(0)&&le.power.greaterThan(0))e.expand(x).each(We=>{f=e.add(f,Q.integrate(We,_,F))},!0);else{let Le=Number(ne.power),We=Number(le.power);if(Le<0&&We>0){let Qe=ne;ne=le,le=Qe}Le===-1&&We===-1?f=Q.integration.partial_fraction(x,_,F):ne.each(Qe=>{let Ze=e.multiply(Qe,le.clone()),tt=Q.integrate(Ze,_,F);f=e.add(f,tt)})}else if(ie===Me&&Z[0].power.greaterThan(0))ne=e.expand(ne),f=new A(0),ne.each(Le=>{f=e.add(f,Q.integrate(e.multiply(Le,le.clone()),_,F))},!0);else if(ie===L&&oe===ue&&t.Utils.inHtrig(ne.fname))ne=ne.fnTransform(),f=Q.integrate(e.expand(e.multiply(ne,le)),_,F);else if(ie===L&&oe===Me||oe===L&&ie===Me){if(oe===L&&ie===Me){let lt=ne;ne=le,le=lt}let Le,We,Qe,Ze,tt=A.unwrapSQRT(Q.diff(ne.clone(),_),!0),je=A.unwrapSQRT(le,!0);if(tt.power.equals(je.power)){if(Le=new A(Number(le.power)),Qe=tt.clone().toLinear(),Ze=le.clone().toLinear(),We=t.Algebra.divide(Qe.toLinear(),Ze),We.isConstant()){let lt=e.pow(We,Le.negate());f=e.multiply(lt,Q.integration.poly_integrate(ne.clone()))}}else f=Q.integration.by_parts(x,_,F,ee)}else{let Le=ne.clone().toLinear(),We=le.clone().toLinear();ie===ue&&oe===ue&&ne.power.contains(_)&&le.power.contains(_)&&!Le.contains(_)&&!We.contains(_)?f=e.parse(J("(({0})^(({2})*({4}))*({1})^(({3})*({4})))/(log(({0})^({2}))+log(({1})^({3})))",Le.toString(),We.toString(),ne.power.multiplier.toString(),le.power.multiplier.toString(),_)):f=Q.integration.by_parts(x,_,F,ee)}}}else if(Y===3&&(Z[2].group===Te&&Z[2].power.lessThan(2)||Z[0].group===Me)){let ie=Z[0];if(ie.group===Me){ie.power.greaterThan(1)&&(ie=e.expand(ie));let oe=e.multiply(Z[1],Z[2]);f=new A(0),ie.each(ne=>{let le=e.multiply(ne,oe.clone()),ge=Q.integrate(le,_,F);f=e.add(f,ge)},!0)}else f=Q.integration.by_parts(x,_,F,ee)}else if(Oe(Z)){let ie=new A(1);for(let oe=0,ne=Z.length;oe1&&(B=t.Algebra.Factor.factorInner(B)),f=Q.integrate(B,_,F)}f=e.multiply(f,U)}if(f)return f}catch(w){if(w.message==="timeout"||!(w instanceof et||w instanceof t.exceptions.DivisionByZero))throw w}let $=E(X)?X.toString():X;return e.symfunction("integrate",[H,new A($)])},!1))},defint(H,X,F,ee){ee||="x";let _=function(w,U,B){try{return e.parse(w,U)}catch(Z){if(Z.message==="timeout")throw Z;return Q.Limit.limit(w,ee,B)}},x=t.Utils.variables(H),m=H.hasTrig(),f,$;if(x.length===1&&!ee&&(ee=x[0]),m||($=Q.integrate(H,ee)),!m&&!$.hasIntegral()){let w={},U={};w[ee]=F,U[ee]=X;let B=_($,w,F),Z=_($,U,X);f=e.subtract(B,Z)}else if(x.length===1&&X.isConstant()&&F.isConstant()){let w=t.Build.build(H);f=new A(t.Math2.num_integrate(w,Number(X),Number(F)))}else f=e.symfunction("defint",[H,X,F,new A(ee)]);return f},Limit:{interval(H,X){return e.parse(J("[{0}, {1}]",H,X))},diverges(){return Q.Limit.interval("-Infinity","Infinity")},divide(H,X,F,ee,_){if(_++>g.max_lim_depth)return;let x=H.clone(),m=X.clone();if(X.fname===Ie){let ne=H.sign(),le=ee.sign();if(ee.isInfinity)return e.multiply(new A(ne),new A(le));if(ee.equals(0)){let ge=e.parse(H.multiplier),ke=e.parse(X.multiplier);return e.divide(e.multiply(ge,Q.Limit.interval("-1","1")),ke)}return Q.Limit.diverges()}let f=function(ne){if(t.Utils.isVector(ne)){let le=ne;for(let ge=0;ge=g.max_lim_depth)return;let ie=Z.equals(0),oe=Number(m.power);return ee.isConstant(!0)&&ie?w=A.infinity(B.lessThan(0)?-1:void 0):ie?w=Q.Limit.diverges():w=e.divide(B,Z),w},rewriteToLog(H){let X=H.power.clone();return H.toLinear(),e.pow(new A("e"),e.multiply(X,e.symfunction(`${g.LOG}`,[H])))},getSubbed(H,X,F){let ee;H.group===ue&&(H=Q.Limit.rewriteToLog(H));try{ee=H.sub(X,F)}catch(_){if(_.message==="timeout")throw _;ee=H}return ee},isInterval(H){return t.Utils.isVector(H)},isConvergent(H){return!(Q.Limit.isInterval(H)&&H.elements[0].isInfinity&&H.elements[1].isInfinity||H.containsFunction("limit"))},limit(H,X,F,ee){if(H.isLinear()&&H.isComposite()){let m=new A(0);return H.each(f=>{m=e.add(m,Q.Limit.limit(f,X,F,ee))},!0),m}if(H=t.Algebra.Simplify.simplify(H),ee||=1,ee++>g.max_lim_depth)return;let _=e.parse(H.multiplier);H.toUnitMultiplier();let x;try{if(H.isConstant(!0))x=H;else{let m={};m[X]=F;try{let f=e.parse(H.sub(X,F),m);(f.isConstant(!0)||f.isInfinity)&&(x=f)}catch(f){if(f.message==="timeout")throw f}if(!x){let f=H.getNum(),$=H.getDenom();if($.isConstant(!0)){if(H.group===ue){let w=H.clone().toLinear(),U=H.power.clone(),B=w.getNum(),Z=w.getDenom(),Y=t.Utils.decompose_fn(Z,X,!0);if(B.group===Te&&B.multiplier.isOne()&&Y.ax.group===Te&&Y.b.isConstant(!0)&&Y.a.isOne()&&Y.b.isConstant(!0))x=e.parse(J("(1/e^({0}))",Y.b));else{let ie=Q.Limit.rewriteToLog(H.clone()),oe=ie.power.clone(),ne=ie.clone().toLinear(),le=Q.Limit.limit(ne,X,F,ee),ge=E(oe)?oe:new A(oe),ke=Q.Limit.limit(ge,X,F,ee);x=e.pow(le,ke)}}else if(H.group===L&&H.args.length===1){let w,U=Q.Limit.limit(H.args[0],X,F,ee);if(t.Utils.isVector(U))return x=U.map(Z=>{let Y=H.clone();return Y.args[0]=Z,Q.Limit.limit(e.symfunction(H.fname,[Z]),X,F,ee)}),e.multiply(_,x);let B;if(U.isConstant(!0)){B=e.symfunction(H.fname,[U]);try{Ae(B),w=!0}catch(Z){if(Z.message==="timeout")throw Z;w=!1}}if(w)x=B;else if(Q.Limit.isConvergent(U)){if(H.fname===Ne)switch(U.toString()){case"0":x=A.infinity().negate();break;case"Infinity":x=A.infinity();break;case"-Infinity":x=A.infinity();break}else if((H.fname===we||H.fname===be)&&F.isInfinity)x=Q.Limit.interval(-1,1);else if(H.fname===fe){let Z=H.args[0],Y=Z.getNum(),ie=Z.getDenom(),oe=Y.toUnitMultiplier();(F.isInfinity||oe.equals("pi")&&ie.equals(2))&&(x=Q.Limit.diverges())}else if(H.fname===g.FACTORIAL&&U.isInfinity)return A.infinity()}}else if(H.group===Te){if(Number(H.power)>0)return e.parse(H,m);t.Utils.even(H.power)?x=A.infinity():x=Q.Limit.diverges()}else if(H.group===a){let w,U,B=H.collectSymbols().sort((Y,ie)=>Y.group-ie.group),Z=B.pop();for(w=Ae(Q.Limit.limit(Z,X,F,ee));B.length;){let Y=B.pop();U=Ae(Q.Limit.limit(Y,X,F,ee)),w.isInfinity||!Q.Limit.isConvergent(w)&&U.equals(0)||w.equals(0)&&Q.Limit.isConvergent(U)?(Y.containsFunction(Ne)&&(Y=[Z,Z=Y][0]),Y.invert(),w.isInfinity&&U.isInfinity?w=A.infinity():w=Q.Limit.divide(Z,Y,X,F,ee)):(w=e.multiply(w,U),Z=e.multiply(Z,Y))}x=w}else if(H.isComposite()){let w;H.isLinear()||(H=e.expand(H)),x=new A(0);let U=H.collectSymbols().sort((Y,ie)=>ie.group-Y.group),B=[],Z=new A(0);for(let Y=0,ie=U.length;Yg.max_lim_depth)return;x=Q.Limit.limit(Q.diff(H,X),X,F,ee)}}}}else x=Q.Limit.divide(f,$,X,F,ee)}}x||=e.symfunction("limit",[H,new A(X),F])}catch(m){if(m.message==="timeout")throw m;x=e.symfunction("limit",[H,new A(X),F])}return e.multiply(_,x)}},Fresnel:{S(H){return H.isConstant(!0)?Q.defint(e.parse("sin(pi*x^2/2)"),new A(0),H,"x"):e.symfunction("S",[H])},C(H){return H.isConstant(!0)?Q.defint(e.parse("cos(pi*x^2/2)"),new A(0),H,"x"):e.symfunction("C",[H])}}};B0.register([{name:"diff",visible:!0,numargs:[1,3],build(){return Q.diff}},{name:"sum",visible:!0,numargs:4,build(){return Q.sum}},{name:"product",visible:!0,numargs:4,build(){return Q.product}},{name:"integrate",visible:!0,numargs:[1,2],build(){return Q.integrate}},{name:"defint",visible:!0,numargs:[3,4],build(){return Q.defint}},{name:"S",visible:!0,numargs:1,build(){return Q.Fresnel.S}},{name:"C",visible:!0,numargs:1,build(){return Q.Fresnel.C}},{name:"limit",visible:!0,numargs:[3,4],build(){return Q.Limit.limit}}]),B0.updateAPI()})()});var X0=f0((Yi,u1)=>{"use strict";var h0=typeof globalThis<"u"&&globalThis.nerdamer?globalThis.nerdamer:void 0;typeof u1<"u"&&h0===void 0&&(h0=T0(),V0());(function(){let t=h0.getCore(),e=t.PARSER,{N:o,P:g,S:E,EX:L,FN:A,PL:k,CP:G,CB:V}=t.groups,{keys:J,even:me,variables:Ae,format:$e,round:Te,isInt:Ee}=t.Utils,{Frac:Me,NerdamerSymbol:a,Vector:ue,Expression:ve}=t,{CONST_HASH:Ne}=t.Settings,ye=t.Utils.importFunctions(),Ie=t.Utils.evaluate;function he(s,c,S){if(this.coeffs=[],this.variable="",t.Utils.isSymbol(s))this.parse(s),this.variable||=c||"";else if(typeof s=="number"&&!isNaN(s)){if(S||=0,c===void 0)throw new t.exceptions.InvalidVariableNameError("Polynomial expects a variable name when creating using order");this.coeffs=[],this.coeffs[S]=new Me(s),this.fill(s)}else typeof s=="string"&&this.parse(e.parse(s))}he.fromArray=function(c,S){if(typeof S>"u")throw new t.exceptions.InvalidVariableNameError("A variable name must be specified when creating polynomial from array");let O=new he;return O.coeffs=c,O.variable=S,O},he.fit=function(c,S,O,p,h,N){let q=new Array(h+1),P=O-S;q[0]=S,q[h]=c,P-=c*p**h;for(let D=h-1;D>0;D--){let K=p**D,z=P/K,ce=Math.sign(z)*Math.floor(Math.abs(z));P-=ce*K,q[D]=ce}if(P!==0)return null;for(let D=0;DS;p--)this.coeffs[p]=this.coeffs[p].subtract(new Me(1)),this.coeffs[p-1]=this.coeffs[p-1].add(new Me(s));O=this.coeffs[S]}}let h=O.mod(new Me(s)),N=O.subtract(h).divide(new Me(s));if(!N.equals(0)){let q=S+1,P=this.coeffs[q]||new Me(0);P=P.add(N),this.coeffs[q]=P,this.coeffs[S]=h}}return this},add(s){let c=Math.max(this.coeffs.length,s.coeffs.length);for(let S=0;S3)throw new Error(`Cannot calculate quadratic order of ${this.coeffs.length-1}`);if(this.coeffs.length===0)throw new Error("Polynomial array has no terms");let S=this.coeffs[2]?Number(this.coeffs[2].toDecimal()):0,O=this.coeffs[1]?Number(this.coeffs[1].toDecimal()):0,p=Number(this.coeffs[0].toDecimal()),h=O*O-4*S*p;return h<0&&!s||(c[0]=(-O+Math.sqrt(h))/(2*S),c[1]=(-O-Math.sqrt(h))/(2*S)),c},squareFree(){let s=this.clone(),c=1,S=s.clone().diff(),O=s.clone().gcd(S),p=s.divide(O)[0],h=he.fromArray([new Me(1)],s.variable);for(;!O.equalsNumber(1);){let N=p.gcd(O),q=p.divide(N)[0];if(!q.equalsNumber(1)&&c>1){let P=q.clone();for(let D=1;D{(h.isConstant(!0)||h.imaginary)&&(p=e.multiply(p,h))}),c.push(p)}else c.push(O.multiplier);if(S)for(let p=0;p"u")throw new Error("NerdamerSymbol.tBase requires a map object!");let S=[],O=this.collectSymbols(null,null,null,!0),p=O.length;for(let h=0;h{if(N.group===k){p=N.groupTerms(c);for(let q=0;q{c.push(S.clone())}):c.push(this.clone()),c};function be(){this.factors={},this.length=0,this.preAdd=void 0,this.pFactor=void 0}be.prototype.getNumberSymbolics=function(){let c=0;return this.each(S=>{S.isConstant(!0)||c++}),c},be.prototype.add=function(c){if(c.equals(0))return this;if(c.equals(-1)&&this.length>0){let S=t.Utils.firstObject(this.factors,null,!0),O=e.symfunction(t.Settings.PARENTHESIS,[S.obj]).negate();return delete this.factors[S.key],this.add(O),this.length--,this}if(c.group===V){let S=this;c.multiplier.equals(1)||S.add(new a(c.multiplier)),c.each(O=>{S.add(O)})}else{this.preAdd&&(c=this.preAdd(c)),this.pFactor&&(c=e.pow(c,new a(this.pFactor)));let S=c.isConstant();if(S&&c.equals(1))return this;let O=S?c.value:c.text();O in this.factors?(this.factors[O]=e.multiply(this.factors[O],c),this.factors[O].equals(1)&&(delete this.factors[O],this.length--)):(this.factors[O]=c,this.length++)}return this},be.prototype.toSymbol=function(){let c=new a(1),S=Object.values(this.factors).sort((O,p)=>O.group>p.group?1:-1);for(let O=0,p=S.length;O{S.negate()}))}catch(c){if(c.message==="timeout")throw c}},be.prototype.toString=function(){return this.toSymbol().toString()};function we(s,c,S){this.terms=c||[],this.coeff=s,this.map=S,this.sum=new Me(0),this.image=void 0,this.revMap=void 0,this.count=void 0}we.prototype.updateCount=function(){this.count||=0;for(let c=0;c"u"&&this.updateCount(),this.count||0},we.prototype.toSymbol=function(c){c||=this.getRevMap();let S=new a(this.coeff);for(let O=0;O"u"?this.terms[S]=new Me(0):this.sum=this.sum.add(this.terms[S]);return this},we.prototype.divide=function(c){let S=this.coeff.divide(c.coeff),O=this.terms.length,p=new we(S,[],this.map);for(let h=0;h"u"&&(O[h]=S,S++)}return O.length=S,O},t.Utils.filledArray=function(c,S,O){let p=[];for(;S--;)p[S]=O?new O(c):c;return p},t.Utils.arrSum=function(c){let S=0,O=c.length;for(let p=0;pc.length&&([c,S]=[S,c]),c.some(O=>S.indexOf(O)>-1)},t.Utils.subFunctions=function(c,S){S||={};let O=[],p=new Set(Ae(c));return c.each(h=>{if(h.group===A||h.previousGroup===A){let N=t.Utils.text(h,"hash"),q=S[N];if(q)O.push(h.altVar(q));else{let P=0,D;do D=h.fname+J(S).length+(P>0?String(P):""),P++;while(p.has(D));S[N]=D,O.push(h.altVar(D))}}else h.group===V||h.group===k||h.group===G?O.push(t.Utils.subFunctions(h,S)):O.push(h.text())}),c.group===G||c.group===k?c.altVar(t.Utils.inBrackets(O.join("+"))):c.group===V?c.altVar(t.Utils.inBrackets(O.join("*"))):c.text()},t.Utils.getFunctionsSubs=function(c){let S={};for(let O in c)Object.hasOwn(c,O)&&(S[c[O]]=e.parse(O));return S};let fe=t.Algebra={version:"1.4.6",proots(s,c){c||=7;let S=0,O=[],p=function(N,q,P){let D=h(N,q,P).concat(O);for(let K=0;K100)throw new t.exceptions.ValueLimitExceededError("This utility accepts polynomials of degree up to 100. ");let te=[],ce={};for(ce.Degree=P,K=0;K=Math.abs(_.c)?(U=2,_.e=F/_.d,_.f=_.c/_.d,_.g=m*ee,_.a3=_.e*(_.g+F)+_.h*(ee/_.d),_.a1=-F+_.f*ee,_.a7=_.h+(_.f+m)*F):(U=1,_.e=F/_.c,_.f=_.d/_.c,_.g=_.e*m,_.a3=_.e*F+(_.g+_.h/_.c)*ee,_.a1=-(F*(_.d/_.c))+ee,_.a7=_.g*_.d+_.h*_.f+F)),U}function Re(H,X,F,ee,_,x,m,f,$){if(F===3){m[1]=m[0]=0;for(let U=2;U10*H*Math.abs(w)){x.a7/=x.a1,x.a3/=x.a1,m[0]=$[0],m[1]=-($[0]*x.a7)+$[1];for(let U=2;U=0?H:-H,x=-x+m*(m/Math.abs(F)),_=Math.sqrt(Math.abs(x))*Math.sqrt(Math.abs(F))):(x=-(H/m*(F/m))+1,_=Math.sqrt(Math.abs(x))*Math.abs(m)),x>=0?(_=m>=0?-_:_,ee.lr=(-m+_)/H,ee.sr=ee.lr===0?ee.sr:F/ee.lr/H):(ee.lr=ee.sr=-(m/H),ee.si=Math.abs(_/H),ee.li=-ee.si)}function Oe(H,X,F,ee,_,x,m,f,$,w,U,B){let Z={},Y,ie,oe,ne=0,le,ge,ke,Le,We,Qe,Ze,tt=0,je,lt=0;F.NZ=0,ge=ee,Le=_;do{if(Z.li=Z.lr=Z.si=Z.sr=0,et(1,ge,Le,Z),F.szr=Z.sr,F.szi=Z.si,F.lzr=Z.lr,F.lzi=Z.li,Math.abs(Math.abs(F.szr)-Math.abs(F.lzr))>.01*Math.abs(F.lzr))break;for(Se(m,ge,Le,$,x,f),ie=Math.abs(-(F.szr*f.b)+f.a)+Math.abs(F.szi*f.b),Qe=Math.sqrt(Math.abs(Le)),Y=2*Math.abs(x[0]),le=-(F.szr*f.b),Ze=1;Ze20)break;if(tt>=2&&ne<=.01&&ie>=oe&&!lt){for(ne=ne10)break;if(ke>=2&&Math.abs(ne)<=.001*Math.abs(-ne+oe)&&B>Y){le=1,X.a=oe;break}for(Y=B,$[0]=U=f[0],ge=1;geMath.abs(f[Le])*10*H)for(ne=-(ie/U),f[0]=m[0],ge=1;geMath.abs(f[Le])*10*H?-(ie/U):0,oe+=ne}return le}function De(H,X,F,ee,_,x,m,f,$,w,U,B){let Z={},Y={},ie=new Array(X),oe=new Array(X),ne,le,ge,ke,Le,We,Qe,Ze,tt,je,lt,ct,ft,At,$t,Tt,pt,Ft,_t,Ot=1,Vt,Jt,c0,Yt,r0,Kt;for(B.NZ=0,ke=ge=.25,Le=ee,Ze=_,Z.b=Z.a=0,Se($,U,_,f,w,Z),ne=Z.a,le=Z.b,Y.h=Y.g=Y.f=Y.e=Y.d=Y.c=Y.a7=Y.a3=Y.a1=0,Yt=xe(H,m,ne,le,Y,x,U,_,ie),Vt=0;Vt0)return;if(Ot=Kt=1,ke*=.25,c0||!Jt)Ot=0;else for(_t=0;_t0)return;if(c0=1,ge*=.25,Ot!==0){$t=-(tt+tt),Tt=tt*tt;continue}}for(_t=0;_t1);let c0=Number.MIN_VALUE/oe,Yt=Math.cos(94*x),r0=Math.sin(94*x),Kt=Math.sqrt(.5),v0=-Kt;for(Y.NZ=pt=0,Y.szr=Y.szi=Y.lzr=Y.lzi=0;X[_]===0;)F[pt]=ee[pt]=0,_--,pt++;for(Vt=_+1;_>=1;){if(_<=2){_<2?(F[H.Degree-1]=-(X[1]/X[0]),ee[H.Degree-1]=0):(Z.li=Z.lr=Z.si=Z.sr=0,et(X[0],X[1],X[2],Z),F[H.Degree-2]=Z.sr,ee[H.Degree-2]=Z.si,F[H.Degree-1]=Z.lr,ee[H.Degree-1]=Z.li);break}for(Le=0,We=Number.MAX_VALUE,K=0;KLe&&(Le=Ze),Ze!==0&&Ze=10||Qe>1&&Number.MAX_VALUE/Qe>=Le)&&(Qe=Qe===0?Number.MIN_VALUE:Qe,_t=Math.floor(Math.log(Qe)/m+.5),ge=2**_t,ge!==1))for(K=0;K0);le=Ze;do{ne=ke=w[0];for(let u=1;u<_;u++)ke=Ze*ke+w[u],ne=Ze*ne+ke;ke=Ze*ke+w[_],le=ke/ne,Ze-=le}while(Math.abs(le/Ze)>.005);ie=Ze;for(let u=1;u<_;u++)$[u]=(_-u)*X[u]/_;for($[0]=X[0],je=X[_],lt=X[Ot],Jt=$[Ot]===0?1:0,Ft=0;Ft<5;Ft++)if(ct=$[Ot],Jt){for(let u=0;u20){H.Degree-=_;break}}}Xe(ce,z,de,te);let Be=te.length,Q=[];for(K=0;K2?X:Number(de[K]);let F=Number(H)<0?"-":"",ee=X,_=H;X===0&&(ee=""),H===0&&(_=""),Math.abs(Number(H))===1?_=`${F}i`:H?_=`${H}*i`:_="";let x=ee&&_?`${ee}+${_}`:String(ee)+String(_);Q[K]=x.replace(/\\+-/gu,"-")}return Q}},roots(s){if(s.isConstant(!0,!0))return t.Utils.nroots(s);let c=fe.proots(s).map(S=>e.parse(S));return t.Vector.fromArray(c)},froot(s,c,S){return function(p){let N=S||t.Build.build(t.Calculus.diff(s.clone())),q=s instanceof Function?s:t.Build.build(s),P=1e4,D=!1,K=0;for(;!D;){let z=p-q(p)/N(p),te=Math.abs(z)-Math.abs(p),ce=Math.abs(te);p=z,ce<1e-12?D=!0:K>P&&(p=null,D=!0),K++}return p}(Number(c))},quad(s,c,S){let O=function(p,h,N,q){return e.parse(`-(${h}+${q}*sqrt((${h})^2-4*(${p})*(${N})))/(2*${p})`)};return[O(s,c,S,1),O(s,c,S,-1)]},sumProd(s,c){return fe.quad(String(-c),String(s),"-1").map(S=>S.invert())},coeffs(s,c,S){s=e.expand(s),S||=[new a(0)];let O=Ae(s);c===void 0&&O.length===1&&(c=O[0]),c=String(c),s.group===L&&s.contains(c,!0)&&e.error(`Unable to get coefficients using expression ${s.toString()}`),O=Ae(s);let p=s.contains("pi")||s.contains("e")||s.containsFunction("sqrt");if(O.length===1&&O[0]===c&&!s.isImaginary()&&!p){let h=new he(s).coeffs.map(N=>new a(N));for(let N=0,q=h.length;N{fe.coeffs(N.clone(),c,S)},!0)}for(let h=0,N=S.length;h"u"&&(S[h]=new a(0));return S},polyPowers(s,c,S){S||=[];let O=s.group;if(O===k&&c===s.value)S=S.concat(J(s.symbols));else if(O===G)for(let p in s.symbols){if(!Object.hasOwn(s.symbols,p))continue;let h=s.symbols[p],N=h.group,q=h.value;if(N===E&&c===q)S.push(h.power);else if(N===k||N===G)S=fe.polyPowers(h,c,S);else if(N===V&&h.contains(c)){let P=h.symbols[c];P&&S.push(P.power)}else(N===o||c!==q)&&S.push(0)}else if(O===V&&s.contains(c)){let p=t.Utils.decompose_fn(s,c,!0);S.push(p.x.power)}return t.Utils.arrayUnique(S).sort()},Factor:{split(s){let c=new a(1),S=new a(1);return fe.Factor.factorInner(s,new be).each(O=>{let p=e.parse(O);O.isConstant(!0)?c=e.multiply(c,p):S=e.multiply(S,p)}),[c,S]},mix(s,c){let S=J(s),O=S.length,p=[];for(let h=0;hD.length||1,p=S.collectSymbols(null,null,(D,K)=>O(K)-O(D)),h={},N=[];for(let D=0;D{let te=Number(z.power);if(isNaN(te))throw new Error("exiting");z.value in h?(te{let D=e.parse(fe.Factor._factor(P));if(N=e.multiply(N,a.create(D.multiplier.toString())),D.toUnitMultiplier(),D.group===V){let K=new a(1);D.each(z=>{let te=e.parse(fe.Factor._factor(z));te.group===V&&(N=e.multiply(N,a.create(te.multiplier.toString())),te.toUnitMultiplier()),K=e.multiply(K,te)}),K=e.pow(K,new a(D.power.toString())),p=e.multiply(p,K)}else p=e.multiply(p,D)});let q=e.pow(p,h);O=e.multiply(N,q)}return O},quadFactor(s,c){if(s.isPoly()&&fe.degree(s).equals(2)){let S=t.Utils.variables(s)[0],O=fe.coeffs(s,S);if(O.length<3)return s;let p=fe.Factor._factor(O[2].clone());if(p.group===V){let h=p.collectSymbols();if(h.length>2)return s;let N=e.multiply(e.parse(O[0]),e.parse(h[0])),q=e.parse(O[1]).negate(),P=e.parse(h[1]),D=fe.quad(P,q,N).filter(K=>t.Utils.isInt(K));if(D.length===1){let K=D[0],z=e.divide(O[0],e.parse(K));t.Utils.isInt(z)&&(c.add(e.parse($e("({0})*({1})+({2})",String(h[1]),S,String(z)))),c.add(e.parse($e("({0})*({1})+({2})",String(h[0]),S,K))),s=new a(1))}}}return s},cubeFactor(s,c){if(s.isComposite()){let S=s.collectSymbols();if(S.length===2){let O=S[0].sign(),p=S[0].clone().abs(),h=S[1].sign(),N=S[1].clone().abs();if(p.isCube()&&N.isCube()){O{(h.group===G&&h.power.greaterThan(1)||h.group===V)&&(h=e.expand(h)),p=e.add(p,h)}),p.power=s.power,s=p}s.group===A&&s.fname!=="sqrt"&&(s=t.Utils.evaluate(s));let O=s.clone();try{if(s.group===V){let h=e.parse(s.power),N=fe.Simplify.strip(s.getDenom()),q=fe.Simplify.strip(s.getNum()),P=N.pop(),D=q.pop();if(D.equals(s))return s;let K=fe.Factor.factorInner(D),z=fe.Factor.factorInner(P),te=fe.Simplify.unstrip(q,K),ce=fe.Simplify.unstrip(N,z);return e.divide(te,ce)}if(s.group===E)return s;if(s.isConstant())return s.equals(1)||s.equals(0)||!s.isInteger()?s.clone():t.Math2.factor(Number(s.multiplier));let p=s.power.clone();if(Ee(p)&&!(p.lessThan(0)&&s.group===A)){let h=p.sign();s.toLinear(),c||=new be;let N={};s=e.parse(t.Utils.subFunctions(s,N)),J(N).length>0&&(c.preAdd=function(de){return e.parse(de,t.Utils.getFunctionsSubs(N))}),s.isLinear()||(c.pFactor=s.power.toString(),s.toLinear());let q=Ae(s);s.isImaginary()&&q.push(t.Settings.IMAGINARY);let P=q.length>1;if(P){let ce=!0,de=!0;if(s.each(Se=>{Se.group!==E&&(ce=!1),Se.multiplier.equals(1)||(de=!1)}),ce&&de)return e.pow(e.parse(s,t.Utils.getFunctionsSubs(N)),e.parse(p))}let D=new be;s=fe.Factor.coeffFactor(s,D),D.each(ce=>{me(Number(p))&&ce.lessThan(0)&&ce.negate(),h<0&&ce.invert(),c.add(ce)});let K=new be;if(s=fe.Factor.powerFactor(s,K),K.each(ce=>{h<0&&ce.invert(),c.add(ce)}),P)s=fe.Factor.cubeFactor(s,c),s=fe.Factor.mfactor(s,c),c.each(ce=>{h<0&&ce.power.negate()});else{let ce=q[0];s=fe.Factor.squareFree(s,c,ce);let de=new be;s=fe.Factor.trialAndError(s,de,ce);let Se=de.toSymbol();if(Se.equals(O))return Se;for(let xe in de.factors){if(!Object.hasOwn(de.factors,xe))continue;let Re=de.factors[xe];c.add(e.pow(Re,e.parse(p)))}s.equals(O)&&(s=fe.Factor.quadFactor(s,c))}s=e.parse(s,t.Utils.getFunctionsSubs(N));let z=c.length===1;c.add(e.pow(s,e.parse(p)));let te=c.toSymbol();return z&&s.equals(1)&&te.isLinear()&&(te=e.pow(te,e.parse(p))),te}return s}catch(p){if(p?.message==="timeout")throw p;return O}},reduce(s,c){if(s.group===G&&s.length===2){let S=s.collectSymbols().sort((O,p)=>Number(p.multiplier)-Number(O.multiplier));if(S[0].power.equals(S[1].power)){let O=e.parse(S[0].power),p=S[0].clone().toLinear(),h=S[1].clone().toLinear();c.add(e.add(p.clone(),h.clone())),h.negate();let N=Number(O),q=new a(0);for(let P=1;P<=N;P++){let D=e.pow(p.clone(),e.subtract(O.clone(),new a(P))),K=e.pow(h.clone(),e.subtract(new a(P),new a(1)));q=e.add(q,e.multiply(D,K))}return q}}return s},squareFree(s,c,S){if(s.isConstant()||s.group===E||!s.isPoly())return s;let p=new he(s,S).squareFree(),h=p[2];if(h!==1){let N=p[1].toSymbol();return N.power=N.power.multiply(new Me(h)),c.add(fe.Factor.factorInner(N)),fe.Factor.squareFree(p[0].toSymbol(),c)}return s},powerFactor(s,c){if(s.group!==k||s.previousGroup===L)return s;let S=J(s.symbols);if(!t.Utils.allNumeric(S))return s;let O=t.Utils.arrayMin(S),p=new a(0),h=e.parse(`${s.value}^${O}`);return s.each(N=>{N=e.divide(N,h.clone()),p=e.add(p,N)}),c.add(h),p},coeffFactor(s,c){if(s.isComposite()){let S=t.Math2.QGCD.apply(null,s.coeffs());if(S.equals(1)){let O=function(N){let q;return N.group===V?(q=0,N.each(P=>{q+=P.power})):q=Number(N.power),q},p=s.collectSymbols(null,null,null,!0).sort((N,q)=>N.isConstant(!0)?1:Number(q.power)-Number(N.power)),h=p[0];(O(h)>O(p[1])||p[1].isConstant(!0))&&h.multiplier.lessThan(0)&&(c.add(new a(-1)),s.each(N=>{N.negate()},!0))}else s.each(O=>{O.isComposite()?O.each(p=>{p.multiplier=p.multiplier.divide(S)}):O.multiplier=O.multiplier.divide(S)}),s.updateHash();c&&c.add(new a(S))}return s},trialAndError(s,c,S){let O=s.clone();try{let p=[];if(s.isConstant()||s.group===E||!s.isPoly())return s;let h=new he(s,S),N=h.coeffs[0],q=t.Math2.ifactor(Number(N)),P=fe.proots(s);for(let D=0;D{c.add(D)}),h.toSymbol()}catch(p){if(p.message==="timeout")throw p;return O}},search(s,c,S){S||=10;let O=s.variable,p=function(Se,xe,Re,He){let et=he.fit(Se,xe,Re,S,He,O);if(et&&et.coeffs.length>1){let Oe=s.divide(et);if(Oe[1].equalsNumber(0))return c.add(et.toSymbol()),[Oe[0],et]}return null},h=s.coeffs[0],N=t.Math2.ifactor(Number(h)),q=s.lc(),P=t.Math2.ifactor(Number(q)),D=s.sub(S),K=t.Math2.ifactor(D),z=fe.Factor.mix(K,D<0),te=Math.ceil(s.coeffs.length/2),ce=q.lessThan(0),de=h.lessThan(0);for(P[1]=1,N[1]=1;te--;)for(let Se in P)if(Object.hasOwn(P,Se)){for(let xe in N)if(Object.hasOwn(N,xe))for(let Re=0;Re{Number(D.multiplier)%Number(N.multiplier)!==0&&(q=!1)},!0);let P;if(q){let D=s.clone();if(P=fe.divWithCheck(s,N.clone()),p=P[1].equals(0),s.equals(P[0])&&P[1].equals(0)){s=D;break}if(P[0].isConstant()){c.add(P[0]);break}}else p=!1;p&&(c.add(P[0]),s=N)}while(p)}}return s},sqdiff(s,c){if(s.isConstant("all"))return s;try{let S=function(h){return t.Utils.block("POSITIVE_MULTIPLIERS",()=>a.unwrapPARENS(ye.sqrt(ye.abs(h))),!0)},O=t.Utils.separate(s.clone());if(!O)return s;let p=[];for(let h in O)h!=="constants"&&p.push(O[h]);if(p.sort((h,N)=>Number(N.power)-Number(h.power)),p.length===2){let h,N;if(h=p.pop(),N=p.pop(),me(Number(h.power))&&me(Number(N.power))&&h.sign()===N.sign()&&h.group===E&&N.group===E)throw new Error("Unable to factor");if(h.isComposite()&&N.power.equals(2)&&h.sign()!==N.sign()){N=S(N);let q=fe.Factor.factorInner(e.add(h,O.constants));q.power.equals(2)&&(q.toLinear(),c.add(e.subtract(q.clone(),N.clone())),c.add(e.add(q,N)),s=new a(1))}else if(h=h.powSimp(),N=N.powSimp(),(h.group===E||h.fname==="")&&h.power.equals(2)&&(N.group===E||N.fname==="")&&N.power.equals(2)&&!O.constants){if(h.multiplier.lessThan(0)){let q=N;N=h,h=q}h.multiplier.greaterThan(0)&&(h=S(h),N=S(N)),c.add(e.subtract(h.clone(),N.clone())),c.add(e.add(h,N)),s=new a(1)}}}catch(S){if(S.message==="timeout")throw S}return s},mfactor(s,c){if(s.group===A)if(s.fname==="sqrt"){let S=new be,O=fe.Factor.common(s.args[0].clone(),S);O=fe.Factor.coeffFactor(O,null),s=e.multiply(e.symfunction("sqrt",[O]),e.parse(s.multiplier)),S.each(p=>{s=e.multiply(s,e.parse(t.Utils.format("sqrt({0})",String(p))))})}else c.add(s),s=new a(1);else{s=fe.Factor.mSqfrFactor(s,c);let S=Ae(s),O=s.collectSymbols().map(P=>a.unwrapSQRT(P)),p={},h={},N=S.length,q=O.length;for(let P=0;P{Ee(Se.multiplier)||(de=!0)}),de){te[1]=e.expand(e.multiply(te[1],z));break}}let ce=Ee(z)&&z.lessThan(0);if(te[1].equals(0)&&!ce){let de=fe.divWithCheck(s.clone(),te[0].clone()),Se=de[0];if(Se.equals(0)||(s=de[1],Se.equals(-1)&&!s.equals(0)))return s;let xe=te[0];if(s.equals(xe)){let Re=fe.Factor.reduce(xe,c);return s.equals(Re)?Re:fe.Factor.mfactor(Re,c)}return c.add(xe),s.equals(0)?Se:Se.isConstant("all")?(c.add(Se),Se):(s=fe.Factor.mfactor(Se,c),s)}}}return s=fe.Factor.sqdiff(s,c),s=fe.Factor.zeroes(s,c),s}},allLinear(s){let c=s.length;for(let S=0;Sp.getDenom().equals(1))){let p=c[0];for(let h=1;hp.getNum())),fe.lcm.apply(null,c.map(p=>p.getDenom())))}return e.symfunction("gcd",c)},gcd_(s,c){if((s.group===A||s.group===g)&&(s=t.Utils.block("PARSE2NUMBER",()=>e.parse(s))),(c.group===A||c.group===g)&&(c=t.Utils.block("PARSE2NUMBER",()=>e.parse(c))),c.group===A&&(c=t.Utils.block("PARSE2NUMBER",()=>e.parse(c))),s.isConstant()&&c.isConstant())return new a(t.Math2.QGCD(new Me(Number(s)),new Me(Number(c))));let S=e.multiply(s.getDenom()||new a(1),c.getDenom()||new a(1)).invert();if(s=e.multiply(s.clone(),S.clone()),c=e.multiply(c.clone(),S.clone()),s=e.expand(s),c=e.expand(c),s.group===V||c.group===V){let P=e.divide(s.clone(),c.clone()),D=e.multiply(c.clone(),P.getDenom().invert());if(!D.equals(1))return D}if(s.group===L||c.group===L){let P=new a(t.Math2.QGCD(s.multiplier,c.multiplier)),D=fe.gcd_(s.value===Ne?new a(1):e.parse(s.value),c.value===Ne?new a(1):e.parse(c.value)),K=fe.gcd_(e.parse(s.power),e.parse(c.power));return e.multiply(P,e.pow(D,K))}if(s.length{h.push(P.multiplier)}),c.each(P=>{h.push(P.multiplier)});let N;for(;!c.equals(0);){let P=c.clone();if(s=s.clone(),N=fe.div(s,P),c=N[1],N[0].equals(0))return e.divide(new a(t.Math2.QGCD(s.multiplier,c.multiplier)),S);s=P}let q=t.Math2.QGCD.apply(void 0,h);return q.equals(1)||s.each(P=>{P.multiplier=P.multiplier.divide(q)}),s.equals(1)&&!s.isConstant()&&!c.isConstant()?e.divide(e.symfunction("gcd",[s,c]),S):e.divide(s,S)},lcm(...s){let c;s.length===1?s[0]instanceof t.Vector?c=s[0].elements:e.error("lcm expects either 1 vector or 2 or more arguments"):c=s;let S=c.reduce((N,q)=>e.multiply(N,q.clone()),new a(1)),O=(function(q,P){P=Number(P);let D=[],K,z,te,ce=2**q.length;for(z=P;zN.reduce((q,P)=>e.multiply(q,P.clone()),new a(1))),p;return c.every(N=>t.Utils.isVariableSymbol(N))?p=e.symfunction("gcd",t.Utils.arrayUnique(O)):p=fe.gcd.apply(null,O),e.divide(S,p)},divide(s,c){let S,O=fe.Factor.factorInner(s.clone());S=O.getDenom(),S.isConstant("all")?S=new a(1):s=e.expand(a.unwrapPARENS(e.multiply(O,S.clone())));let p=fe.div(s,c),h=e.divide(p[1],c);return e.divide(e.add(p[0],h),S)},divWithCheck(s,c){let S=[new a(0),s.clone()],O=fe.div(s,c),p=s.clone(),h=e.multiply(O[0].clone(),c.clone());h=e.add(h,O[1].clone());let N=e.subtract(p,h);return N=e.expand(N),N.equals(0)?O:S},div(s,c){let S=[new a(0),s.clone()];try{if(c.isConstant("all"))return s.each(z=>{z.multiplier=z.multiplier.divide(c.multiplier)}),[s,new a(0)];if(s=e.expand(s),c=e.expand(c),s.group===E&&c.group===G){let z=s.value,te=t.Utils.decompose_fn(c.clone(),z,!0);if(s.isLinear()&&te.x&&te.x.isLinear()&&c.isLinear()){let ce=a.create(s.multiplier);return[e.divide(ce.clone(),te.a.clone()),e.divide(e.multiply(ce,te.b),te.a).negate()]}}if(s.group===E&&c.group===E){let z=e.divide(s.clone(),c.clone());return z.isConstant()?[z,new a(0)]:[new a(0),s.clone()]}let O=s.hasFunc(),p=c.hasFunc(),h=!1,N;if(O||p){h=!0;let z={};s=e.parse(t.Utils.subFunctions(s,z)),c=e.parse(t.Utils.subFunctions(c,z)),N=t.Utils.getFunctionsSubs(z)}let q=t.Utils.arrayUnique(Ae(s).concat(Ae(c))),P,D,K;if((s.isImaginary()||c.isImaginary())&&q.push(t.Settings.IMAGINARY),q.length===1){let z=new he(s).divide(new he(c));P=z[0].toSymbol(),D=z[1].toSymbol()}else{q.push(Ne);let z=function(De){let Xe=new a(0);for(let Be=0;Be1)return}if(Xe){for(let X=0;X"u"||ie.greaterThan(m))&&(m=ie,$=Y),(typeof f>"u"||oe.greaterThan(f))&&(f=oe,w=Y)}let B=m.subtract(_.terms[$]),Z=f.subtract(Be.terms[w]);if(Z>B){H=[f,w,_];break}if(B>Z){H=[m,$,Be];break}}else if(H=te(_),H)break;H=te(_)}if(!H)return te(De[0],!0);let X,F;for(let ee=0;eexe[0].count?xe:Se,Oe=Re(et),Fe=[];if(Oe){let De=Oe[1],Xe=function(x,m){return x[0].sum.equals(m[0].sum)?x.length>=m.length:!0},Be=function(x,m,f){let $=[];for(let w=0;wf&&w.greaterThan(U)?$-f:w.subtract(U)};De=Be(Se,xe,De),Se.sort(Q),xe.sort(Q);let H=xe[0],X=Se[0];if(K=new we(new Me(1),[],X.map),H.sum.greaterThan(X.sum)&&X.len()>1)for(let x=0;x_)throw new t.exceptions.InfiniteLoopError("Unable to compute!");let x=Se[0].divide(xe[0]);Fe.push(x),Se.shift();for(let m=1;m=xe.length){for(let m=1;m{if(z.group===A&&z.fname===""&&z.args[0].group===E){let ce=z.args[0];s.symbols?(delete s.symbols[te],s.symbols[ce.value]=ce):s=z.args[0]}});let p,h,N,q=c.collectFactors?.()||[],P=[],D=[],K=new a(1);for(let z=0;ze.multiply(z,K.clone())),[S,P,D]},partfrac(s,c,S){let O=Ae(s);c||=e.parse(O[0]);try{let p,h,N,q=e.expand(s.getNum()),P=e.expand(s.getDenom().toUnitMultiplier());q.multiplier=s.multiplier;let D=c.value;if(p=q.groupTerms(D),Number(fe.degree(q,c))>=Number(fe.degree(P,c))?(h=fe.div(q.clone(),e.expand(P.clone())),N=h[0],q=h[1],p=q.groupTerms(D)):N=new a(0),Number(fe.degree(P,c))===1){let H=e.divide(q,P);return S?[N,H]:e.add(N,H)}let K=fe.Factor.factorInner(P),z=fe.PartFrac.createTemplate(P.clone(),K,[],c),te=z[0],ce=z[1],de=z[2],Se=[p.length],xe=[],Re=[],He=[],et,Oe;ce.forEach((H,X)=>{et=te[X],Oe=de[X];for(let F=0;F{let ee=e.multiply(He[F],e.divide(X,Re[F]));H.push(ee)}),H}let Q=N;return Be.each((H,X)=>{let F=e.multiply(He[X],e.divide(H,Re[X]));Q=e.add(Q,F)}),Q}catch(p){if(p.message==="timeout")throw p;try{if(s.isComposite()){let h={};s.each(q=>{let P=q.getDenom(),D=q.getNum(),K=h[P];h[P]=K?e.add(K,D):D});let N=new a(0);for(let q in h)Object.hasOwn(h,q)&&(N=e.add(N,e.divide(h[q],e.parse(q))));s=N}}catch(h){if(h.message==="timeout")throw h}}return s}},degree(s,c,S){if(S||={nd:[],sd:[],depth:0},!c){let h=Ae(s);if(h.length>1)throw new Error("You must specify the variable for multivariate polynomials!");if(h.length===0)return new a(0);c=e.parse(h[0])}let O=s.group;s.isComposite()?(s=s.clone(),s.distributeExponent(),s.each(h=>{S.depth++,fe.degree(h,c,S),S.depth--})):s.group===V?s.each(h=>{S.depth++,fe.degree(h,c,S),S.depth++}):O===L&&s.value===c.value?S.sd.push(s.power.clone()):O===E&&s.value===c.value?S.nd.push(e.parse(s.power)):S.nd.push(new a(0));let p=S.nd.length>0?t.Utils.arrayMax(S.nd):void 0;return S.depth===0&&S.sd.length>0?(p!==void 0&&S.sd.unshift(e.parse(p)),e.symfunction("max",S.sd)):e.parse(p??0)},sqComplete(s,c,S){t.Utils.isSymbol(c)||(c=e.parse(c));let O=function(Se){throw Se||="Stopping",new t.exceptions.ValueLimitExceededError(Se)};s.isPoly(!0)||O("Must be a polynomial!");let p=t.Utils.inBrackets;s=s.clone();let h=t.Algebra.degree(s,c);h.equals(2)||O(`Cannot complete square for degree ${h.text()}`);let N=t.Algebra.coeffs(s,c),q=N[2],P=N[1].sign(),D=e.divide(N[1],new a(2)),K=e.pow(D.clone(),new a(2)),z=ye.sqrt(q),te=e.divide(ye.sqrt(K),z.clone()),ce=e.subtract(N[0],e.pow(te.clone(),new a(2)));if(S)return[q,D,ce];let de=e.parse(p(`${z.clone()}*${c}${P<0?"-":"+"}${te}`));return{a:de,c:ce,f:e.add(e.pow(de.clone(),new a(2)),ce.clone())}},Simplify:{strip(s){let c=e.parse(s.multiplier);s.toUnitMultiplier();let S=e.parse(s.power);return s.toLinear(),[c,S,s]},unstrip(s,c){let S=s[0],O=s[1];return e.multiply(S,e.pow(c,O))},complexSimp(s,c){let S=s.realpart(),O=s.imagpart(),p=c.realpart(),h=c.imagpart(),N=e.multiply(S.clone(),p.clone()),q=e.multiply(O.clone(),h.clone()),P=e.multiply(p.clone(),O),D=e.multiply(S,h.clone()),K=e.add(e.pow(p,new a(2)),e.pow(h,new a(2)));return e.divide(e.add(e.add(N,q),e.multiply(e.subtract(P,D),a.imaginary())),K)},trigSimp(s){let c=!0,S=0;for(;c&&s.containsFunction(["cos","sin","tan"]);){S++,c=!1,s=s.clone();let O=fe.Simplify.strip(s);s=O.pop();let p=s.clone();if(s.group===G){let h=new a(0);s.each(N=>{let q=fe.Simplify.trigSimp(N.fnTransform());h=e.add(h,q)},!0),p=e.pow(e.multiply(new a(s.multiplier),h),new a(s.power)),c=p.text()!==s.text()}else if(s.group===V){let h=s.getNum(),N=s.getDenom();if(h.fname==="sin"&&N.fname==="cos"&&h.args[0].equals(N.args[0])&&h.power.equals(N.power))p=e.parse(t.Utils.format("(({1})/({0}))*tan({2})^({3})",N.multiplier,h.multiplier,h.args[0],h.power)),c=!0;else if(h.fname==="tan"&&N.fname==="sin"&&h.args[0].equals(N.args[0])&&h.power.equals(N.power))p=e.parse(t.Utils.format("(({1})/({0}))*cos({2})^(-({3}))",N.multiplier,h.multiplier,h.args[0],h.power)),c=!0;else{let q=new a(1),P={workDone:c};p.each(D=>{if(D.fname==="tan")D=e.parse(t.Utils.format("({0})*sin({1})^({2})/cos({1})^({2})",D.multiplier,fe.Simplify._simplify(D.args[0]),D.power)),P.workDone=!0;else if(D.containsFunction(["cos","sin","tan"])){let K=fe.Simplify.trigSimp(D);D.equals(K)||(D=K,P.workDone=!0)}q=e.multiply(q,D)}),c=P.workDone,p=q}}else if((s.fname==="cos"||s.fname==="sin")&&s.args[0].group===G){let h=0,N=new a(0),q=e.parse("pi/2");if(s.args[0].each(P=>{let D=e.divide(P.clone(),q.clone());D=fe.Simplify._simplify(D),D=t.Utils.evaluate(D),Ee(D)?h+=D.multiplier.num.toJSNumber():N=e.add(N,P)}),h){h+=s.fname==="cos"?1:0,h%=4,h+=h<0?4:0;let P=["sin({0})","cos({0})","-sin({0})","-cos({0})"],D=t.Utils.format(P[h],String(N));p=e.parse(D),c=!0}else if(Object.keys(s.args[0].symbols).length>1){let P=s.args[0].clone(),D=Object.values(P.symbols),K=D[0],te=D.slice(1).map(de=>`(${de.text()})`).join("+"),ce;s.fname==="sin"?ce=t.Utils.format("sin({0})cos({1})+sin({1})cos({0})",K,te):ce=t.Utils.format("cos({0})cos({1})-sin({1})sin({0})",K,te),p=e.parse(ce),c=!0}}else if((s.fname==="cos"||s.fname==="sin")&&s.args[0].multiplier.sign()===-1){let h=s.args[0].clone().negate(),N=t.Utils.format(`${s.fname}({0})`,h);s.fname==="sin"&&(N=`-${N}`),p=e.parse(N),c=!0}if(s.fname==="sin"&&s.args[0].multiplier.equals(2)&&!s.args[0].equals(2)){let h=s.args[0].clone().toUnitMultiplier(),N=t.Utils.format("2sin({0})cos({0})",h);p=e.parse(N),c=!0}if(p=fe.Simplify.unstrip(O,p).distributeMultiplier(),s=p,S>10)break}return s},logArgSimp(s,c){if(c.value==="1"||c.value===String(1))return new a(0);let S=new a(0),O=c.multiplier.clone();if(c.toUnitMultiplier(),!O.equals(1)){let p=t.Utils.format("({0}({1}))",s,O);S=e.add(S,e.parse(p))}if(c.group===V)c.each(p=>{p=p.clone();let h=p.power.clone();fe.Simplify.strip(p);let N=t.Utils.format("(({1})*{0}({2}))",s,h,p);S=e.add(S,e.parse(N))});else{let p=c.clone(),h=p.power.clone();fe.Simplify.strip(p);let N=t.Utils.format("(({1})*{0}({2}))",s,h,p);S=e.add(S,e.parse(N))}return S},logSimp(s){if(s.group===A&&(s.fname==="log"||s.fname==="log10")){let c=s.clone(),S=fe.Simplify.strip(s);s=S.pop();let O=s.args[0].clone(),p=O.getNum().clone(),h=O.getDenom().clone(),N=s.fname,q=fe.Simplify.logArgSimp(N,p);if(!h.equals(1)){let P=fe.Simplify.logArgSimp(N,h);q=e.subtract(q,P)}q=fe.Simplify.unstrip(S,q).distributeMultiplier(),s=q}else if(s.containsFunction(["log","log10"]))for(let c in s.symbols){if(!Object.hasOwn(s.symbols,c))continue;let S=s.symbols[c];s.symbols[c]=fe.Simplify.logSimp(S)}return s},_sqrtCompression(s,c,S){let O=fe.Simplify.strip(s),p=de=>de.fname==="abs",h=de=>de.args[0],N=de=>p(de)?h(de):null,q=de=>de.type===E&&de.value.startsWith("baseunit_"),P=(de,Se)=>{let xe=h(Se);return xe.equals(N(de))?[Se,null]:xe.equals(de)&&q(de)?[Se,null]:[null,Se]},D,K=!1,z=(de,Se)=>{for(let xe=0;xeHe),Se=Se.filter(He=>He)}}return[de,Se]},te=c.collectFactors(),ce=S.collectFactors();do D=!1,[te,ce]=z(te,ce),[ce,te]=z(ce,te);while(D);return K&&(s=te.reduce((de,Se)=>de=e.multiply(de,Se),new a(1)),s=ce.reduce((de,Se)=>de=e.divide(de,Se),s)),s=fe.Simplify.unstrip(O,s),s},fracSimp(s){let c=s.getDenom(),S=s.getNum();if(S.isImaginary()&&c.isImaginary()&&(s=fe.Simplify.complexSimp(S,c)),s.isComposite()){s.power.gt(1)&&(s=e.expand(s));let O=s.collectSymbols(),p,h,N,q,P,D,K,z,te,ce,de;for(h=O.pop();O.length;)N=O.pop(),q=e.parse(h.getDenom()),P=e.parse(N.getDenom()),D=h.getNum(),K=N.getNum(),de=e.multiply(q.clone(),P.clone()),te=e.multiply(D,P),ce=e.multiply(K,q),z=e.add(te,ce),h=e.divide(z,de);return c=e.expand(h.getDenom()),S=e.expand(h.getNum()),S.isImaginary()&&c.isImaginary()?p=fe.Simplify.complexSimp(S,c):p=e.divide(S,c),p.equals(s)?s:fe.Simplify._simplify(p)}return s=fe.Simplify._sqrtCompression(s,S,c),s=fe.Simplify.simpleFracSimp(s),s},simpleFracSimp(s){let c=s.getDenom(),S=s.getNum(),O;return c=e.expand(c),S=e.expand(S),S.isImaginary()&&c.isImaginary()?O=fe.Simplify.complexSimp(S,c):O=e.divide(S,c),O.equals(s)?s:O},ratSimp(s){if(s.group===V){let c=s.getDenom(),S=s.getNum().distributeMultiplier(),O=fe.Simplify.fracSimp(c),p=fe.Simplify.fracSimp(S);s=e.divide(p,O)}return s},sqrtSimp(s,c){let S,O=!1,p=s.clone();try{if(s.isSQRT()){let h=s.multiplier.clone(),N=s.args[0].clone(),q=fe.Factor.factorInner(N),P=e.parse(q.multiplier),D=P.sign();S=new a(1);let K;if(q.group===V){let z=new a(1);q.each(ce=>{if(ce=e.parse(ce),ce.group===o){let de=e.sqrt(ce.clone());Ee(de)?S=e.multiply(S,de):z=e.multiply(z,ce)}else z=e.multiply(z,ce)});let te=e.multiply(z,e.parse(D));K=e.sqrt(te.clone()),K.isImaginary()&&(K=e.sqrt(e.expand(te.clone())))}else K=q.clone().toUnitMultiplier(),K=e.multiply(K,new a(D)),K=e.sqrt(K);S=e.multiply(S,K),S=e.pow(S,e.parse(s.power)),S=e.multiply(S,e.sqrt(P.abs())),S=e.multiply(S,e.parse(h)),O=!0}else s.isComposite()&&s.isLinear()?(S=new a(0),s.each(h=>{S=e.add(S,fe.Simplify.sqrtSimp(h))},!0),S=e.pow(S,e.parse(s.power)),S=e.multiply(S,e.parse(s.multiplier)),O=!0):s.group===V&&(S=new a(1),s.each(h=>{let N=fe.Simplify.sqrtSimp(h);S=e.multiply(S,N)}),S=e.pow(S,e.parse(s.power)),S=e.multiply(S,e.parse(s.multiplier)),O=!0);return O||S&&!Ee(S)&&(S=null),S||=e.parse(s),S}catch(h){if(h.message==="timeout")throw h;return p}},patternSub(s){let c={},S=function(p){let h=!1;return p.each(N=>{N.group===G?h=!0:N.symbols&&(h=S(N))}),h},O=function(p){p.each(h=>{if(!(!h.symbols&&h.group!==A)){if(S(h))O(h);else if(!c[h.value]){let N=t.Utils.getU(s);c[h.value]=N,s=s.sub(h.value,N)}}},!0)};return O(s),[s,c]},simplify(s){if(s.simplify)return s.simplify();let c=fe.Simplify._simplify(s);return c=c.pushMinus(),c=e.parse(c),c},_simplify(s){let c=fe.Simplify.strip(s.clone());if(s=c.pop(),s=fe.Simplify.fracSimp(s),s.isConstant()||s.group===t.groups.S)return c.push(s),fe.Simplify.unstrip(c,s);let S=s.clone();if(S=fe.Simplify.sqrtSimp(S,c),S=fe.Simplify.trigSimp(S),S=fe.Simplify.logSimp(S),S=fe.Simplify.ratSimp(S),S=fe.Factor.factorInner(S),S.group===t.groups.CP&&S.isLinear()){let O=S.multiplier.clone();S.toUnitMultiplier();let p=new a(0);return S.each(h=>{let N=fe.Simplify._simplify(h);p=e.add(p,N)}),S=p,S=e.multiply(S,new a(O)),S.multiplier.equals(-1)&&S.distributeMultiplier(),S=fe.Simplify.unstrip(c,S),S}return S=fe.Simplify.unstrip(c,S),S}},Classes:{Polynomial:he,Factors:be,MVTerm:we}};t.Expression.prototype.simplify=function(){t.Utils.armTimeout();try{let c;if(typeof this.symbol.LHS>"u")c=new t.Expression(fe.Simplify.simplify(this.symbol));else{let S=this.symbol.clone();S.LHS=fe.Simplify.simplify(S.LHS),S.RHS=fe.Simplify.simplify(S.RHS),c=S}return c}catch(c){if(c.message==="timeout")throw c;return this}finally{t.Utils.disarmTimeout()}},t.Collection.prototype.simplify=function(){return this.elements=this.elements.map(c=>fe.Simplify.simplify(c)),this},t.Matrix.prototype.simplify=function(){return this.elements=this.elements.map(c=>c.map(S=>fe.Simplify.simplify(S))),this},h0.useAlgebraDiv=function(){let c=fe.divideFn=e.divide,S=0;e.divide=function O(p,h){S++;let N;return S===1?N=t.Algebra.divide(p,h):N=O(p,h),S=0,N}},h0.useParserDiv=function(){fe.divideFn&&(e.divide=fe.divideFn),delete fe.divideFn},h0.register([{name:"factor",visible:!0,numargs:1,build(){return fe.Factor.factor}},{name:"simplify",visible:!0,numargs:1,build(){return fe.Simplify.simplify}},{name:"gcd",visible:!0,numargs:[1],build(){return fe.gcd}},{name:"lcm",visible:!0,numargs:[1],build(){return fe.lcm}},{name:"roots",visible:!0,numargs:-1,build(){return fe.roots}},{name:"divide",visible:!0,numargs:2,build(){return fe.divide}},{name:"div",visible:!0,numargs:2,build(){return fe.div}},{name:"partfrac",visible:!0,numargs:[1,2],build(){return fe.PartFrac.partfrac}},{name:"deg",visible:!0,numargs:[1,2],build(){return fe.degree}},{name:"coeffs",visible:!0,numargs:[1,2],build(){return function(...c){let S=fe.coeffs(c[0],c[1]);return new t.Vector(S)}}}]),h0.coeffs=function(...c){let S=t.PARSER;for(let p=0;p{"use strict";var R0=typeof globalThis<"u"&&globalThis.nerdamer?globalThis.nerdamer:void 0;typeof c1<"u"&&R0===void 0&&(R0=T0(),V0(),X0());(function(){let t=R0.getCore(),e=t.PARSER,o=t.Algebra,g=t.Calculus,{integration:E}=g,{decompose_arg:L}=E,{Factor:A,Simplify:k,Classes:G}=o,{evaluate:V,remove:J,format:me,knownVariable:Ae,isSymbol:$e,variables:Te,range:Ee}=t.Utils,{build:Me}=t.Build,{NerdamerSymbol:a}=t,{S:ue,PL:ve,CB:Ne,CP:ye,FN:Ie}=t.groups,{Settings:he}=t,{isArray:be}=t.Utils;t.Settings.SOLVE_RADIUS=1e3,t.Settings.ROOTS_PER_SIDE=10,t.Settings.make_pi_conversions=!1,t.Settings.STEP_SIZE=.1,t.Settings.EPSILON=2e-13,t.Settings.MAX_NEWTON_ITERATIONS=200,t.Settings.NEWTON_EPSILON=2e-15,t.Settings.MAX_NON_LINEAR_TRIES=12,t.Settings.NON_LINEAR_JUMP_AT=50,t.Settings.NON_LINEAR_JUMP_SIZE=100,t.Settings.NON_LINEAR_START=.01,t.Settings.NEWTON_SLICES=200,t.Settings.SOLUTION_PROXIMITY=1e-14,t.Settings.FILTER_SOLUTIONS=!0,t.Settings.MAX_SOLVE_DEPTH=10,t.Settings.ZERO_EPSILON=1e-9,t.Settings.MAX_BISECTION_ITER=2e3,t.Settings.BI_SECTION_EPSILON=1e-12,t.NerdamerSymbol.prototype.hasTrig=function(){return this.containsFunction(["cos","sin","tan","cot","csc","sec"])},t.NerdamerSymbol.prototype.hasNegativeTerms=function(){if(this.isComposite())for(let h in this.symbols){if(!Object.hasOwn(this.symbols,h))continue;let N=this.symbols[h];if(N.group===ve&&N.hasNegativeTerms()||this.symbols[h].power.lessThan(0))return!0}return!1};function we(p,h){if(h.isConstant()&&p.isConstant()&&!p.equals(h)||p.equals(t.Settings.IMAGINARY)&&h.isConstant(!0)||h.equals(t.Settings.IMAGINARY)&&p.isConstant(!0))throw new t.exceptions.NerdamerValueError(`${p.toString()} does not equal ${h.toString()}`);this.LHS=p,this.RHS=h}we.prototype={toString(){return`${this.LHS.toString()}=${this.RHS.toString()}`},text(p){return`${this.LHS.text(p)}=${this.RHS.text(p)}`},toLHS(p){p=!!p;let h=this.removeDenom(),N=h.LHS,q=h.RHS;N.isConstant(!0)&&!q.isConstant(!0)&&([N,q]=[q,N]);let P=e.subtract(N,q),D=p?e.expand(P):P;return D=new we(D,new a(0)).removeDenom().LHS,D},removeDenom(){let p=this.LHS.clone(),h=this.RHS.clone(),N=e.multiply(p.getDenom(),h.getDenom());if(p=e.expand(e.multiply(p,N.clone())),h=e.expand(e.multiply(h,N)),h.group===ye&&h.group!==ye){let q=p;p=h,h=q}if(p.group===Ne){let q=new a(p.multiplier),P=h.clone();p.each(D=>{D.power.lessThan(0)?P=e.divide(P,D):q=e.multiply(q,D)}),p=q,h=P}else if(p.group===ye)for(let q in p.symbols){if(!Object.hasOwn(p.symbols,q))continue;let P=p.symbols[q];if(P.group===Ne)for(let D in P.symbols){if(!Object.hasOwn(P.symbols,D))continue;let K=P.symbols[D];if(K.power.lessThan(0))return new we(e.expand(e.multiply(K.clone().toLinear(),p)),e.expand(e.multiply(K.clone().toLinear(),h)))}}return new we(p,h)},clone(){return new we(this.LHS.clone(),this.RHS.clone())},sub(p,h){let N=this.clone();return N.LHS=N.LHS.sub(p.clone(),h.clone()),N.RHS=N.RHS.sub(p.clone(),h.clone()),N},isZero(){return t.Utils.evaluate(this.toLHS()).equals(0)},latex(p){return[this.LHS.latex(p),this.RHS.latex(p)].join("=")}},e.equals=function(h,N){return new we(h,N)},(function(){let h=e.functions.simplify[0];e.functions.simplify[0]=function(q){return q instanceof we?(q.LHS=h(q.LHS),q.RHS=h(q.RHS),q):h(q)}})(),t.Expression.prototype.equals=function(h){return h instanceof t.Expression&&(h=h.symbol),new we(this.symbol,h)},t.Expression.prototype.solveFor=function(h){t.Utils.armTimeout();try{let{symbol:N}=this;if(this.symbol instanceof we){if(this.symbol.LHS.isConstant()&&this.symbol.RHS.equals(h))return[new t.Expression(this.symbol.LHS)];if(this.symbol.RHS.isConstant()&&this.symbol.LHS.equals(h))return[new t.Expression(this.symbol.RHS)]}return O(N,h).map(D=>(D=k.simplify(e.parse(D)),new t.Expression(D)))}finally{t.Utils.disarmTimeout()}},t.Expression.prototype.expand=function(){if(this.symbol instanceof we){let h=this.symbol.clone();return h.RHS=e.expand(h.RHS),h.LHS=e.expand(h.LHS),new t.Expression(h)}return new t.Expression(e.expand(this.symbol))},t.Expression.prototype.variables=function(){return this.symbol instanceof we?t.Utils.arrayUnique(t.Utils.variables(this.symbol.LHS).concat(t.Utils.variables(this.symbol.RHS))):t.Utils.variables(this.symbol)};let fe=function(h,N){return e.equals(h,N)};t.Equation=we;let s=t.Utils.checkAll=function(h,N){for(let q=0;qe.parse(z)),q=[],P=[];for(let z=0;zq[1][2]&&([K,D]=[D,K],[q[1],q[0]]=[q[0],q[1]]),q[0][0]===1&&q[0][2]===2&&q[1][0]===2&&q[1][2]===4){let z=h[0],te=h[1],ce=O(e.parse(K,Ae(z,O(e.parse(D),z)[0])),te).map(Se=>Se.toString()),de=[O(e.parse(D,Ae(te,ce[0])))[0].toString()];if(ce[1]&&de.push(O(e.parse(D,Ae(te,ce[1])))[0].toString()),he.SOLUTIONS_AS_OBJECT){let Se={};Se[z]=de,Se[te]=ce,P=Se}else ce.unshift(te),de.unshift(z),P=[de,ce]}return P},solveNonLinearSystem(p,h,N){if(h<0)return[];N=typeof N>"u"?t.Settings.NON_LINEAR_START:N;let q=t.Settings.MAX_NON_LINEAR_TRIES,P=Math.floor(q/2);h=typeof h>"u"?q:h;let D=t.Settings.NON_LINEAR_JUMP_AT,K=t.Settings.NON_LINEAR_JUMP_SIZE,z=!0,te=function(X,F){return X.map((ee,_)=>Number(F.get(_,0)))},ce=t.Utils.arrayGetVariables(p),de=t.Matrix.jacobian(p,ce,X=>Me(X,ce),!0),Se=t.Settings.MAX_NEWTON_ITERATIONS,xe,Re,He,et,Oe,Fe,De,Xe,Be=p.map(X=>Me(X,ce)),Q=de.map(X=>Me(X,ce),!0);et=t.Matrix.cMatrix(0,ce);let H=t.Matrix.cMatrix(N,ce);He=0;do{if(He>Se){z=!1;break}xe=te(ce,H),De=H.clone();let X=xe,F=H;Be.forEach((_,x)=>{F.set(x,0,_(...X))});let ee=new t.Matrix;if(Q.each((_,x,m)=>{let f=_(...X);ee.set(x,m,f)}),ee=ee.invert(),Re=e.multiply(ee,H).negate(),Xe=Re.subtract(et,_=>e.parse(Number(_))),et=De.add(Re,_=>e.parse(Number(_))),H=et,He>=D&&Number(Oe)>1){h===P&&(N=0);let _=h>P?1:-1,x=h%Math.floor(P)+1;return N+=_*x*K,c.solveNonLinearSystem(p,--h,N)}if(Fe=Oe,He++,Oe=Xe.max(),Number(Oe)===Number(Fe))break}while(Number(Oe)>=Number.EPSILON);return z?c.systemSolutions(H,ce,!0,X=>t.Utils.round(Number(X),14)):[]},systemSolutions(p,h,N,q){if(t.Settings.SOLUTIONS_AS_OBJECT){let D={};return p.each((K,z)=>{let te=(N?e.expand(K):K).valueOf();q&&(te=q.call(K,te)),D[h[z]]=te}),D}let P=[];return p.each((D,K)=>{let z=(N?e.expand(D):D).valueOf();q&&(z=q.call(D,z)),P.push([h[K],z])}),P},solveSystemBySubstitution(p){let h=Te(p[0]),N=Te(p[1]);return p.length===2&&h.length===2&&t.Utils.arrayEqual(h,N)?c.solveCircle(p,h):[]},solveSystem(p,h){for(let te=0;te"u"){if(!o.allLinear(p))try{return c.solveNonLinearSystem(p)}catch(te){if(te.message==="timeout")throw te;if(te instanceof t.exceptions.DivisionByZero)return c.solveSystemBySubstitution(p)}if(K=t.Utils.arrayGetVariables(p),K.length===1){let te=0,ce,de;do de=p[te].clone(),te>0&&(de=de.sub(K[0],ce[0])),ce=O(de,K[0]);while(++te{Array.isArray(Re[1])||(de[Re[0]]=Re[1])});else for(let Re of Object.keys(Se)){let He=Se[Re];Array.isArray(He)||(de[Re]=He)}let xe=!0;for(let Re=ce-1;Re{et.contains(xe)&&(Re=Re.concat(et.coeffs()))});let He=t.Utils.arraySum(Re);q.set(te,Se,He)}let de=ce.clone();K.forEach(Se=>{de=de.stripVar(Se,!0)}),P.set(te,0,de.negate())}}else{K=h,D=!0;for(let te=0;tete.negate()),c.systemSolutions(z,K,D)},quad(p,h,N){let q=e.subtract(e.pow(h.clone(),new a(2)),e.multiply(e.multiply(N.clone(),p.clone()),new a(4)));q=e.expand(q);let P=e.pow(q,new a(.5)),D=e.parse(e.multiply(new a(2),N.clone()));return[e.parse(me("(-({0})+({1}))/({2})",h,P,D)),e.parse(me("(-({0})-({1}))/({2})",h,P,D))]},cubic(p,h,N,q){let P=q.text(),D=N.text(),K=h.text(),z=p.text(),te=`(-(${D})^3/(27*(${P})^3)+(${D})*(${K})/(6*(${P})^2)-(${z})/(2*(${P})))`,ce=`((${K})/(3*(${P}))-(${D})^2/(9*(${P})^2))`,de=`(${D})/(3*(${P}))`,Se=`((${te})+sqrt((${te})^2+(${ce})^3))^(1/3)+((${te})-sqrt((${te})^2+(${ce})^3))^(1/3)-(${de})`,xe="1/2+sqrt(3)/2*i";return[e.parse(Se),e.parse(`(${Se})(${xe})`),e.parse(`(${Se})(${xe})^2`)]},quartic(p,h,N,q,P){let D={};t.Utils.arrayUnique(Te(P).concat(Te(q)).concat(Te(N)).concat(Te(h)).concat(Te(p))).forEach(H=>{D[H]=1});let K=P.toString(),z=q.toString(),te=N.toString(),ce=h.toString(),de=p.toString(),Se,xe=e.parse(me("(8*({0})*({2})-3*({1})^2)/(8*({0})^2)",K,z,te)).toString(),Re=e.parse(me("(({1})^3-4*({0})*({1})*({2})+8*({0})^2*({3}))/(8*({0})^3)",K,z,te,ce)).toString(),He=e.parse(me("12*({0})*({4})-3*({1})*({3})+({2})^2",K,z,te,ce,de)).toString(),et=e.parse(me("2*({2})^3-9*({1})*({2})*({3})+27*({1})^2*({4})+27*({0})*({3})^2-72*({0})*({2})*({4})",K,z,te,ce,de)).toString(),Oe=e.parse(me("((({1})+(({1})^2-4*({0})^3)^(1/2))/2)^(1/3)",He,et)).toString(),Fe=e.parse(me("(1/2)*(-(2/3)*({1})+(1/(3*({0}))*(({2})+(({3})/({2})))))^(1/2)",K,xe,Oe,He)).toString(),De=e.parse(me("-(({1})/(4*({0})))-({4})+(1/2)*sqrt(-4*({4})^2-2*({2})+(({3})/({4})))",K,z,xe,Re,Fe)),Xe=e.parse(me("-(({1})/(4*({0})))-({4})-(1/2)*sqrt(-4*({4})^2-2*({2})+(({3})/({4})))",K,z,xe,Re,Fe)),Be=e.parse(me("-(({1})/(4*({0})))+({4})+(1/2)*sqrt(-4*({4})^2-2*({2})-(({3})/({4})))",K,z,xe,Re,Fe)),Q=e.parse(me("-(({1})/(4*({0})))+({4})-(1/2)*sqrt(-4*({4})^2-2*({2})-(({3})/({4})))",K,z,xe,Re,Fe));return[De,Xe,Be,Q]},divideAndConquer(p,h){let N=[],q=A.factorInner(p);return q.group===Ne&&q.each(P=>{P=a.unwrapPARENS(P),N=N.concat(O(P,h))}),N},csolve(p,h){return t.Utils.block("IGNORE_E",()=>{let N,q,P,D,K,z,te,ce,de=[],Se=t.Utils.decompose_fn(p,h,!0);if(Se.x.group===ue){N=e.parse(Se.x.power),q=Number(N),P=e.pow(e.divide(Se.b.negate(),Se.a),N.invert()),D=a.toPolarFormArray(P),K=D[0],z=D[1],te=K.toString(),ce=N.toString();let xe,Re,He;for(let et=0;et{Re.containsFunction(t.Settings.LOG)&&q.push(.1)});let de=Ee(-t.Settings.SOLVE_RADIUS,K,h),Se=Ee(K,t.Settings.SOLVE_RADIUS,h),xe=function(Re,He){let et,Oe,Fe,De=[],Xe=Re[0],Be=Math.sign(P(Xe));for(let Q=0,H=Re.length;Qt.Settings.MAX_BISECTION_ITER||isNaN(D))return;K=(N+q)/2,h(N)*h(K)>0?N=K:q=K}while(D>=he.EPSILON);let z=(N+q)/2,te=h(z);return!isNaN(te)&&Math.abs(te)<=t.Settings.BI_SECTION_EPSILON?t.Utils.round(z,13):void 0}},bSearch(p,h,N){let q=N(p),P=N(h);if(Math.sign(q)===Math.sign(P)||isNaN(q)||isNaN(P))return;let D=80,K=0;do{let z=(p+h)/2,te=Math.sign(q),ce=Math.sign(N(z));if(te===ce){if(z===p)break;p=z,q=N(p)}else{if(z===h)break;h=z,P=N(h)}K++}while(p!==h&&KP)return;let Se=N(K);if(isNaN(Se)||isNaN(de))return;if(Se===0)z+=ce;else{if(!isFinite(de)||!isFinite(Se)||Math.abs(de)>1e25)return c.bSearch(q,K,h);z=K-de/Se}if(ce=z-K,ce===0&&!isFinite(Se))return;te=Math.abs(ce),K=z}while(te>he.NEWTON_EPSILON);return z},rewrite(p,h,N){if(h||=new a(0),p.isComposite()&&p.isLinear()){let D=[],K=[];p.each(z=>{z=z.clone(),z.fname==="sqrt"&&z.contains(N)?D.push(z):K.push(z)},!0),D.length===1&&(h=e.expand(e.pow(e.subtract(h,t.Utils.arraySum(K)),new a(2))),p=e.expand(e.pow(a.unwrapSQRT(D[0]),new a(2))))}else p=a.unwrapSQRT(e.expand(p));let q=0,P=p.length;if(p.group===ye&&p.contains(N)&&p.isLinear()){p.distributeMultiplier();let D=new a(0);return p.each(K=>{K.contains(N)?(q++,D=e.add(D,K.clone())):h=e.subtract(h,K.clone())}),p=D,q!==P?c.rewrite(p,h,N):[p,h]}if(p.group===Ne&&p.contains(N)&&p.isLinear()){if(p.multiplier.lessThan(0)&&(p.multiplier=p.multiplier.multiply(new t.Frac(-1)),h.multiplier=h.multiplier.multiply(new t.Frac(-1))),h.equals(0))return new a(0);let D=new a(1);return p.each(K=>{K.contains(N)?D=e.multiply(D,K.clone()):h=e.divide(h,K.clone())}),p=D,c.rewrite(p,h,N)}if(!p.isLinear()&&p.contains(N)){let D=e.parse(p.power.clone().invert());return p=e.pow(p,D.clone()),h=e.pow(e.expand(h),D.clone()),c.rewrite(p,h,N)}return p.group===Ie||p.group===ue||p.group===ve?[p,h]:[p,h]},sqrtSolve(p,h){let N=new a(0),q=new a(0);if(p.isComposite()&&(p.each(P=>{P.fname==="sqrt"&&P.contains(h)?N=e.add(N,P.clone()):q=e.add(q,P.clone())}),!N.equals(0))){let P=e.expand(e.multiply(e.parse(p.multiplier),e.subtract(e.pow(q,new a(2)),e.pow(N,new a(2))))),D=O(P,h);return D=D.filter(K=>{if(K.isImaginary())return!0;let z={};return z[h]=K,!!V(p,z).equals(0)}),D}}},S=function(p,h,N,q){let P=p.toString(),D=P.match(/(?2||p.LHS.group!==Ie&&p.RHS.group!==Ie)return null;let K=p.constructor(P.replace(/(?he.MAX_SOLVE_DEPTH)return N;N||=[];let D={},K={};K[h]=0;let z=function(Oe,Fe){let De=$e(Oe);if(!(Oe===void 0||typeof Oe=="number"&&isNaN(Oe))){if(be(Oe))Oe.forEach(Xe=>{z(Xe)});else if(Oe.valueOf()!=="null"){if(typeof t.Settings.PRE_ADD_SOLUTION=="function"&&(Oe=t.Settings.PRE_ADD_SOLUTION(Oe)),De||(Oe=e.parse(Oe)),t.Settings.make_pi_conversions&&Fe){let Be=e.divide(Oe.clone(),new a(Math.PI)),Q=Be.multiplier,H=Math.abs(Number(Q.num)),X=Math.abs(Number(Q.den));H<10&&X<10&&(Oe=e.multiply(Be,new a("pi")))}let Xe=Oe.toString();D[Xe]||N.push(Oe),D[Xe]=!0}}};if(p instanceof we){let Oe=S(p,h,q,P);if(Oe)return z(Oe),N;if(p.isZero())return[new a(0)];if(p.LHS.equals(h)&&!p.RHS.contains(h,!0))return[p.RHS];if(p.RHS.equals(h)&&!p.LHS.contains(h,!0))return[p.LHS]}if(p instanceof t.Vector&&(p=p.elements),be(p))return c.solveSystem(p,h);if(h||="x",$e(p)&&V(p.getDenom(),K).equals(0)===!0)return N;if(p.group===ue&&p.contains(h)){try{let Oe={};Oe[h]=0,V(P,Oe),z(new a(0))}catch(Oe){if(Oe.message==="timeout")throw Oe}return N}if(p.group===Ne){let Oe=p.getNum();if(Oe.group===Ne){let Fe=String(h);return Oe.each(De=>{De.contains(Fe)&&O(De,h,N,q,p)}),N}return O(Oe,h,N,q,P)}p.group===Ie&&p.fname==="sqrt"&&(p=e.pow(a.unwrapSQRT(p),new a(2)));let te=(t.Utils.isSymbol(p)?p:c.toLHS(p,!1)).getNum(),ce=t.Utils.variables(te),de=ce.length;if(t.Utils.isInt(te.power)&&Number(te.power)>1&&(te=e.parse(te).toLinear()),(te.group===ue||te.group===Ne)&&te.contains(h))return[new a(0)];let Se={},xe,Re=function(Oe){Oe=e.expand(Oe,{expand_denominator:!0,expand_functions:!0});let Fe=Oe.clone();if(Oe.symbols)for(let De in Oe.symbols){if(!Object.hasOwn(Oe.symbols,De))continue;let Xe=Oe.symbols[De],Be=Xe.getDenom();if(!Be.isConstant(!0)&&Oe.isComposite()){let ee=new a(0);return Oe.each(_=>{ee=e.add(ee,e.multiply(_,Be.clone()))}),Re(e.multiply(e.parse(Oe.multiplier),ee))}let Q=L(Xe,h),H=Q[1].fname===t.Settings.SQRT,X=a.unwrapSQRT(Q[1]),F=X.power.clone();if(!$e(F)&&!F.equals(1/2)){if(Number(F.den)>1){if(H)return Oe=e.subtract(Oe,Xe.clone()),Oe=e.add(Oe,e.multiply(Q[0].clone(),X)),Re(Oe);let ee=Se[Number(F.den)];Se[Number(F.den)]=ee?ee++:1}else if(F.sign()===-1){let ee=e.parse(`${h}^${Math.abs(Number(F))}`),_=Oe;return _.each((x,m)=>{x.contains(h)&&(_.symbols[m]=e.multiply(x,ee.clone()))}),Se={},Re(e.parse(_))}else if(Xe.group===ve){let ee=t.Utils.arrayMin(t.Utils.keys(Xe.symbols).map(Number));if(ee<0){let _=e.parse(`${h}^${Math.abs(ee)}`),x=new a(0);return Fe.each(m=>{x=e.add(x,e.multiply(m.clone(),_.clone()))},!0),x}}}}return Oe},He=function(Oe){let Fe=new a(0),De=new a(0);return Oe.each(Xe=>{Xe.contains(h,!0)?Fe=e.add(Fe,Xe.clone()):De=e.subtract(De,Xe.clone())}),[Fe,De]};if(c.inverseFunctionSolve=function(Fe,De,Xe){let Be=L(De.args[0],h);if(Be[1].group===ue)return e.divide(e.symfunction(Fe,[e.divide(Xe,e.parse(De.multiplier))]),Be[0])},te=Re(te),te.equals(0))return[te];let et=t.Utils.keys(Se);if(et.length===1&&(xe=et[0],te.each((Oe,Fe)=>{if(Oe.contains(h)){let De=L(Oe,h),Xe=De[1],Be=Xe.power;Be.den.gt(1)&&(Xe.power=Be.multiply(new t.Frac(xe)),te.symbols[Fe]=e.multiply(Xe,De[0]))}}),te=e.parse(te)),z(c.sqrtSolve(te,h)),de===1)if(te.isPoly(!0)){let Oe=new G.Factors;if(A.factorInner(te,Oe),Oe.getNumberSymbolics()>1)for(let Fe in Oe.factors)Object.hasOwn(Oe.factors,Fe)&&z(O(Oe.factors[Fe],h));else{let Fe=t.Utils.getCoeffs(te,h),De=Fe.length-1,Xe=!1;if(ce[0]===h){if(s(Fe,Be=>Be.group!==t.groups.N)){let Be=t.Algebra.proots(te);s(Be,Q=>!t.Utils.isInt(Q))&&(Xe=!0,Be.forEach(Q=>{z(new a(Q))}))}if(!Xe)if(p=e.parse(p),p instanceof t.Equation&&(p=p.toLHS()),De===1)z(e.divide(Fe[0],Fe[1].negate()));else if(De===2)z(e.expand(c.quad.apply(void 0,Fe)));else if(De===3){let Be=[],Q=A.factorInner(p);Be=[],Be.length>0?z(Be):z(c.cubic.apply(void 0,Fe))}else o.proots(te).map(z)}}}else{let Oe=te.hasTrig(),Fe=c.getPoints(te,.1),De=c.getPoints(te,.05),Xe=c.getPoints(te,.01,!0),Be=t.Utils.arrayUnique(Fe.concat(De).concat(Xe)).sort((f,$)=>f-$),Q,H,X,F=Me(te.clone()),ee=[];for(Q=0;Q"u"){ee.push(H);continue}z(X,Oe)}Be=ee;let _=g.diff(te.clone()),x=Me(_),m=Be[0];for(Q=0;Q{let w=f.text("decimals"),U=$.text("decimals"),B=Number(w),Z=Number(U);return isNaN(B)&&isNaN(Z)?w.localeCompare(U):isNaN(B)&&!isNaN(Z)?-1:!isNaN(B)&&isNaN(Z)?1:B-Z}),N=N.map(f=>f.isConstant()?new a(Number(Number(f).toPrecision(15))):f),N=N.filter((f,$,w)=>{let U=Number(Number(f).toPrecision(15)),B=Number(w[$-1]);return $===0||isNaN(U)||isNaN(B)?!0:Math.abs(U-B)>=he.EPSILON})}else if(!te.hasFunc(h)&&te.isComposite())try{let Oe=A.factorInner(te.clone()),Fe=e.expand(e.parse(Oe)),De=e.expand(te.clone()),Xe=e.subtract(Fe,De),Be=!0;if(Xe.equals(0)||(Be=!1),Be&&Oe.group===Ne)Oe.each(Q=>{z(O(Q,h))});else{let Q=t.Utils.getCoeffs(te,h);switch(Q.length-1){case 0:{let F=He(te),ee=F[0],_=F[1];if(ee.group===t.groups.EX){let x=t.Settings.LOG,m=`${x}((${_})/(${ee.multiplier}))/(${x}(${ee.value})*${ee.power.multiplier})`,f=e.parse(m);z(f)}break}case 1:z(e.divide(Q[0],Q[1].negate()));break;case 2:z(c.quad.apply(void 0,Q));break;case 3:z(c.cubic.apply(void 0,Q));break;case 4:z(c.quartic.apply(void 0,Q));break;default:z(c.csolve(te,h)),N.length===0&&z(c.divideAndConquer(te,h))}N.length===0&&z(O(Oe,h,N,q))}}catch(Oe){if(Oe.message==="timeout")throw Oe}else try{let Oe=c.rewrite(te,null,h),Fe=Oe[0],De=Oe[1];if(Fe.group===Ie)if(Fe.fname==="abs")Fe.args[0].toString()===h&&z([De.clone(),De.negate()]);else if(Fe.fname==="sin")z(c.inverseFunctionSolve("asin",Fe,De));else if(Fe.fname==="cos")z(c.inverseFunctionSolve("acos",Fe,De));else if(Fe.fname==="tan")z(c.inverseFunctionSolve("atan",Fe,De));else if(Fe.fname===t.Settings.LOG){let Xe=L(Fe.args[0],h),Be=Xe[1];if(Be.group===ue){De=e.divide(e.subtract(e.pow(Fe.args.length>1?Fe.args[1]:new a("e"),e.divide(De,e.parse(Fe.multiplier))),Xe[3]),Xe[0]);let Q=new we(Be,De).toLHS();z(O(Q,h))}}else z(e.subtract(Fe,De));else{let Xe=new we(Fe,De).toLHS();if(Xe.equals(te))throw new Error("Stopping. No stop condition exists");z(O(Xe,h))}}catch(Oe){if(Oe.message==="timeout")throw Oe;if(te.group===Ne)z(0);else if(te.group===ye){let Fe=He(te),De=Fe[0],Xe=Fe[1];if(De.group===t.groups.EX&&De.value===h){let Be=De.power.clone().invert();z(e.pow(Xe,Be))}}}if(xe&&(N=N.map(Oe=>e.pow(Oe,new a(xe)))),$e(p)){let Oe={};N=N.filter(Fe=>{try{Oe[h]=Fe;let De=Number(V(p,Oe));return isNaN(De),!0}catch(De){if(De.message==="timeout")throw De;return!1}})}return N}R0.register([{name:"solveEquations",parent:"nerdamer",numargs:-1,visible:!0,build(){return O}},{name:"solve",parent:"Solve",numargs:2,visible:!0,build(){return t.Solve.solve}},{name:"setEquation",parent:"Solve",numargs:2,visible:!0,build(){return fe}}]),R0.updateAPI()})()});var p1=f0((e2,on)=>{"use strict";var L0=typeof globalThis<"u"&&globalThis.nerdamer?globalThis.nerdamer:void 0;typeof on<"u"&&L0===void 0&&(L0=T0(),V0(),X0());(function(){let t=L0.getCore(),e=t.PARSER,{NerdamerSymbol:o,Vector:g,Algebra:E,Calculus:L}=t,{format:A,isVector:k,isArray:G,isSymbol:V}=t.Utils,{S:J,EX:me,CP:Ae,PL:$e,CB:Te,FN:Ee}=t.groups;t.Settings.Laplace_integration_depth=40;function Me(ue){return V(ue.power)&&(ue.power.group===J||ue.power.group===Te)}o.prototype.findFunction=function(ve){if(this.group===Ee&&this.fname===ve)return this.clone();let Ne;if(this.symbols){for(let ye in this.symbols)if(Object.hasOwn(this.symbols,ye)&&(Ne=this.symbols[ye].findFunction(ve),Ne))break}return Ne};let a=t.Extra={version:"1.4.2",LaPlace:{transform(ue,ve,Ne){ue=ue.clone(),ve=ve.toString(),ue=o.unwrapSQRT(ue,!0);let ye,Ie=ue.stripVar(ve),he=ue.group;if(ue=e.divide(ue,Ie.clone()),ue.isConstant()||!ue.contains(ve,!0))ye=e.parse(A("({0})/({1})",ue,Ne));else if(he===J&&t.Utils.isInt(ue.power)){let be=String(ue.power);ye=e.parse(A("factorial({0})/({1})^({0}+1)",be,Ne))}else if(ue.group===J&&ue.power.equals(1/2))ye=e.parse(A("sqrt(pi)/(2*({0})^(3/2))",Ne));else if(ue.isComposite())ye=new o(0),ue.each(be=>{ye=e.add(ye,a.LaPlace.transform(be,ve,Ne))},!0);else if(ue.isE()&&Me(ue)){let be=ue.power.stripVar(ve);ye=e.parse(A("1/(({1})-({0}))",be,Ne))}else{let be=["sin","cos","sinh","cosh"];if(ue.group===Ee&&be.indexOf(ue.fname)!==-1&&(ue.args[0].group===J||ue.args[0].group===Te)){let we=ue.args[0].stripVar(ve);switch(ue.fname){case"sin":ye=e.parse(A("({0})/(({1})^2+({0})^2)",we,Ne));break;case"cos":ye=e.parse(A("({1})/(({1})^2+({0})^2)",we,Ne));break;case"sinh":ye=e.parse(A("({0})/(({1})^2-({0})^2)",we,Ne));break;case"cosh":ye=e.parse(A("({1})/(({1})^2-({0})^2)",we,Ne));break}}else{let we=t.Settings.integration_depth{let s=ve,c=ue.sub(ve,s),S=e.parse(`e^(-${Ne}*${s})*${c}`);if(ye=L.integrate(S,s),ye.hasIntegral?.()){ye=e.symfunction("laplace",[ue,e.parse(String(ve)),e.parse(String(Ne))]);return}ye=ye.sub(ve,0),ye=e.expand(e.multiply(ye,new o(-1))),ye=ye.sub(s,ve)},!1),ye=t.Utils.block("PARSE2NUMBER",()=>e.parse(ye),!0),we&&(t.Settings.integration_depth=fe)}}return e.multiply(ye,Ie)},inverse(ue,ve,Ne){let ye=ue.clone();return t.Utils.block("POSITIVE_MULTIPLIERS",()=>{let Ie;if(ue.group===Te&&(ue=E.PartFrac.partfrac(e.expand(ue),ve)),ue.group===J||ue.group===Te||ue.isComposite()){let he,be,we,fe,s,c,S,O,p=ue.multiplier.clone();ue.toUnitMultiplier();let h=ue.getNum(),N=ue.getDenom().toUnitMultiplier();N.group===Ae||N.group===$e?(be=N.power.clone(),N.toLinear()):be=new t.Frac(1);let q=ve.toString(),P=t.Utils.decompose_fn(N,q,!0),D=t.Utils.decompose_fn(e.expand(h.clone()),q,!0);h.multiplier=h.multiplier.multiply(p);let K=function(){Ie=e.multiply(Ie,h),Ie.multiplier=Ie.multiplier.multiply(ue.multiplier),Ie=e.divide(Ie,P.a)};if((N.group===J||N.group===Te)&&P.x.value===q&&P.b.equals(0)&&t.Utils.isInt(P.x.power))he=P.x.power-1,O=t.Math2.factorial(he),Ie=e.divide(e.pow(e.parse(String(Ne)),new o(he)),new o(O)),K();else if(N.group===Ae&&be.equals(1)){if(P.x.group===t.groups.PL&&E.degree(N).equals(2)){let z=E.sqComplete(N,q),te=t.Utils.getU(N);we=t.Utils.decompose_fn(z.a,q,!0).b;let ce=a.LaPlace.inverse(e.parse(`1/((${te})^2+(${z.c}))`),te,String(Ne));Ie=e.multiply(ce,e.parse(`(${p})*e^(-(${we})*(${Ne}))`))}else if(P.x.isLinear()&&!h.contains(q))Ne=e.divide(e.parse(String(Ne)),P.a.clone()),he=be-1,O=he===0||he===1?"1":`(${be}-1)!`,Ie=e.parse(A("(({0})^({3}-1)*e^(-(({2})*({0}))/({1})))/(({4})*({1})^({3}))",Ne,P.a,P.b,be,O)),K();else if(P.x.group===J&&P.x.power.equals(2))if(h.contains(q)){if(we=new o(1),h.group===Te){let Re=new o(1);h.each(He=>{He.contains(q)?Re=e.multiply(Re,He):we=e.multiply(we,He)}),h=Re}S=t.Utils.decompose_fn(h,q,!0);let z=S.a,te=S.b,ce=z.containsFunction("sin"),de=z.containsFunction("cos"),Se=te.containsFunction("cos"),xe=te.containsFunction("sin");if(S.x.value===q&&S.x.isLinear()&&!(ce&&Se||de||xe))Ie=e.parse(A("(({1})*cos((sqrt(({2})*({3}))*({0}))/({2})))/({2})",Ne,S.a,P.a,P.b));else if(ce&&Se){let Re=z.findFunction?.("sin"),He=te.findFunction?.("cos");if(Re?.args?.[0].equals(He?.args?.[0])&&!Re?.args?.[0].contains(q)){fe=e.divide(te,He.toUnitMultiplier()).toString();let et=Re.args[0].toString();s=P.b;let Oe=e.divide(z,Re.toUnitMultiplier());c="(({1})*({2})*cos({3})*sin(sqrt({4})*({0})))/sqrt({4})+({1})*sin({3})*({5})*cos(sqrt({4})*({0}))",Ie=e.parse(A(c,Ne,we,fe,et,s,Oe))}}}else Ie=e.parse(A("(({1})*sin((sqrt(({2})*({3}))*({0}))/({2})))/sqrt(({2})*({3}))",Ne,h,P.a,P.b))}else if(P.x.power.num&&P.x.power.num.equals(3)&&P.x.power.den.equals(2)&&h.contains("sqrt(pi)")&&!h.contains(q)&&h.isLinear())fe=e.divide(h.clone(),e.parse("sqrt(pi)")),Ie=e.parse(A("(2*({2})*sqrt({0}))/({1})",Ne,P.a,fe,h));else if(be.equals(2)&&P.x.power.equals(2))if(h.contains(q))if(S=t.Utils.decompose_fn(e.expand(h.clone()),q,!0),S.x.isComposite()){let z=[],te=h.collectSymbols(ce=>{ce=o.unwrapPARENS(ce);let de=t.Utils.decompose_fn(ce,q,!0);return de.symbol=ce,de}).sort((ce,de)=>{let Se=ce.x.value===q?ce.x.power:0;return(de.x.value===q?de.x.power:0)-Se});we=new o(-1);for(let ce=0;ce{Ie=e.add(Ie,a.LaPlace.inverse(z,ve,Ne))},!0)))}return Ie||=e.symfunction("ilt",[ye,e.parse(String(ve)),e.parse(String(Ne))]),Ie},!0)}},Statistics:{frequencyMap(ue){let ve={};for(let Ne=0,ye=ue.length;Ne((!ve.isConstant()||!Ne.isConstant())&&e.error("Unable to sort! All values must be numeric"),ve.multiplier.subtract(Ne.multiplier)))},count(ue){return new o(ue.length)},sum(ue,ve){let Ne=new o(0);for(let ye=0,Ie=ue.length;yeNumber(we)),he=Math.max.apply(null,Ie),be=ye[he];G(be)?ve=e.symfunction("mode",be.sort().map(we=>e.parse(we))):ve=e.parse(be)}return ve},gVariance(ue,ve){let Ne=a.Statistics.mean(...ve),ye=a.Statistics.sum(ve,Ne);return e.multiply(ue,ye)},variance(...ue){if(k(ue[0]))return a.Statistics.variance(...ue[0].elements);let ve=e.divide(new o(1),a.Statistics.count(ue));return a.Statistics.gVariance(ve,ue)},sampleVariance(...ue){if(k(ue[0]))return a.Statistics.sampleVariance(...ue[0].elements);let ve=e.divide(new o(1),e.subtract(a.Statistics.count(ue),new o(1)));return a.Statistics.gVariance(ve,ue)},standardDeviation(...ue){return k(ue[0])?a.Statistics.standardDeviation(...ue[0].elements):e.pow(a.Statistics.variance(...ue),new o(1/2))},sampleStandardDeviation(...ue){return k(ue[0])?a.Statistics.sampleStandardDeviation(...ue[0].elements):e.pow(a.Statistics.sampleVariance(...ue),new o(1/2))},zScore(ue,ve,Ne){return e.divide(e.subtract(ue,ve),Ne)}},Units:{table:{foot:"12 inch",meter:"100 cm",decimeter:"10 cm"}}};L0.register([{name:"laplace",visible:!0,numargs:3,build(){return a.LaPlace.transform}},{name:"ilt",visible:!0,numargs:3,build(){return a.LaPlace.inverse}},{name:"mean",visible:!0,numargs:-1,build(){return a.Statistics.mean}},{name:"median",visible:!0,numargs:-1,build(){return a.Statistics.median}},{name:"mode",visible:!0,numargs:-1,build(){return a.Statistics.mode}},{name:"smpvar",visible:!0,numargs:-1,build(){return a.Statistics.sampleVariance}},{name:"variance",visible:!0,numargs:-1,build(){return a.Statistics.variance}},{name:"smpstdev",visible:!0,numargs:-1,build(){return a.Statistics.sampleStandardDeviation}},{name:"stdev",visible:!0,numargs:-1,build(){return a.Statistics.standardDeviation}},{name:"zscore",visible:!0,numargs:3,build(){return a.Statistics.zScore}}]),L0.updateAPI()})();typeof on<"u"&&(on.exports=L0)});var ji=f0((t2,h1)=>{var Hi=T0();X0();V0();f1();p1();h1.exports=Hi});return ji();})();\n/*!\n * decimal.js v10.6.0\n * An arbitrary-precision Decimal type for JavaScript.\n * https://github.com/MikeMcl/decimal.js\n * Copyright (c) 2025 Michael Mclaughlin \n * MIT Licence\n */\n';export{e as default}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/alert-dialog-cancel.js b/tools/ui/.svelte-kit/output/server/chunks/alert-dialog-cancel.js new file mode 100644 index 0000000000000000000000000000000000000000..14458cf7b8fd8f1eb8a8c59a24dd192c196f55b9 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/alert-dialog-cancel.js @@ -0,0 +1 @@ +import{p as g,c as M,a as r,d as A,s as _}from"./root.js";import{I as P}from"./uuid.js";import{c as I,aW as N,b as h,m as V,H as W,W as x}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";function b(l,t){l.component(s=>{const n=g(s);let{id:a=I(n),ref:e=null,children:d,child:c,disabled:p=!1,$$slots:i,$$events:f,...o}=t;const u=N.create({id:h(()=>a),ref:h(()=>e,v=>e=v),disabled:h(()=>!!p)}),m=A(()=>V(o,u.props));c?(s.push(""),c(s,{props:m()}),s.push("")):(s.push(""),s.push(``),d?.(s),s.push("")),s.push(""),r(t,{ref:e})})}function w(l,t){let{$$slots:s,$$events:n,...a}=t;P(l,_([{name:"trash-2"},a,{iconNode:[["path",{d:"M10 11v6"}],["path",{d:"M14 11v6"}],["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"}],["path",{d:"M3 6h18"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"}]]}]))}function y(l,t){l.component(s=>{let{class:n,ref:a=null,$$slots:e,$$events:d,...c}=t,p=!0,i;function f(o){b?(o.push(""),b(o,_([{"data-slot":"alert-dialog-cancel",class:W(x({variant:"outline"}),n)},c,{get ref(){return a},set ref(u){a=u,p=!1}}])),o.push("")):(o.push(""),o.push(""))}do p=!0,i=s.copy(),f(i);while(!p);s.subsume(i),r(t,{ref:a})})}export{y as A,w as T}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/api-key-validation.js b/tools/ui/.svelte-kit/output/server/chunks/api-key-validation.js new file mode 100644 index 0000000000000000000000000000000000000000..4795da430a2196cf0de80e04abfe8743b2c9c644 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/api-key-validation.js @@ -0,0 +1 @@ +import"@sveltejs/kit";import"./url.js";import"@sveltejs/kit/internal/server";import"./root.js";import"./uuid.js";import"clsx";import"style-to-object";async function n(t){}export{n as v}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/app.js b/tools/ui/.svelte-kit/output/server/chunks/app.js new file mode 100644 index 0000000000000000000000000000000000000000..b3ca7e533c8f5a7cd4b37dc5ee0d175d5137247e --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/app.js @@ -0,0 +1 @@ +const _={},t=_?.VITE_PUBLIC_APP_NAME||"llama-ui";export{t as A}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/arrow-right.js b/tools/ui/.svelte-kit/output/server/chunks/arrow-right.js new file mode 100644 index 0000000000000000000000000000000000000000..b6cbd3448d699f21c944281ab145a81c36bc1d99 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/arrow-right.js @@ -0,0 +1 @@ +import{s}from"./root.js";import{I as p}from"./uuid.js";function c(o,r){let{$$slots:a,$$events:e,...t}=r;p(o,s([{name:"arrow-right"},t,{iconNode:[["path",{d:"M5 12h14"}],["path",{d:"m12 5 7 7-7 7"}]]}]))}export{c as A}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/bot.js b/tools/ui/.svelte-kit/output/server/chunks/bot.js new file mode 100644 index 0000000000000000000000000000000000000000..7eac114554a35f3ef4db57eceb531880dcbb3a11 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/bot.js @@ -0,0 +1 @@ +import{s}from"./root.js";import{I as a}from"./uuid.js";function i(t,o){let{$$slots:e,$$events:h,...p}=o;a(t,s([{name:"bot"},p,{iconNode:[["path",{d:"M12 8V4H8"}],["rect",{width:"16",height:"12",x:"4",y:"8",rx:"2"}],["path",{d:"M2 14h2"}],["path",{d:"M20 14h2"}],["path",{d:"M15 13v2"}],["path",{d:"M9 13v2"}]]}]))}export{i as B}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/card.js b/tools/ui/.svelte-kit/output/server/chunks/card.js new file mode 100644 index 0000000000000000000000000000000000000000..3239608cfba2d6f02ad6703057ce1ac71074bd37 --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/card.js @@ -0,0 +1 @@ +import{c as d,e,a as p}from"./root.js";import{H as i,ak as n}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";import"./uuid.js";function b(o,a){o.component(s=>{let{children:t,class:l,ref:c=null,$$slots:m,$$events:f,...r}=a;s.push(``),t?.(s),s.push(""),p(a,{ref:c})})}export{b as C}; diff --git a/tools/ui/.svelte-kit/output/server/chunks/chat.svelte.js b/tools/ui/.svelte-kit/output/server/chunks/chat.svelte.js new file mode 100644 index 0000000000000000000000000000000000000000..164d746dad99d9d428bfa0f8be14cd3e413114da --- /dev/null +++ b/tools/ui/.svelte-kit/output/server/chunks/chat.svelte.js @@ -0,0 +1,52 @@ +import{s as De}from"./root.js";import{I as ke,ap as Ge,bu as _t,bv as Qe,bw as vt,H as Tt,r as et,bx as Mt,C as yt,q as At,by as Ne,ax as ee,bz as te,aA as Te,A as ne,g as Ze,bA as Rt,ah as wt,bB as Je,bC as qe,bD as Z,bE as tt,bF as Ke,bG as be,bH as Nt,bI as nt,bJ as bt,a0 as xt,a1 as It,bK as Lt,f as Me,bL as st,bM as Pt,bN as Ot,bO as Dt,$ as Q,bP as ot,bQ as kt,bR as Ft,av as se,Y as Se,a7 as K,aK as Ee,ak as ze,B as Ut,y as it,bS as Et,bT as Gt,bU as $t,bV as Xt,bW as Bt,bX as Ht,aj as ve,bY as rt,d as at,bZ as Wt,b_ as Jt,b$ as qt,a5 as pe,c0 as ye,c1 as Kt,ag as Ve}from"./uuid.js";import"clsx";import{N as T,Q as z,aq as lt,a7 as we,ah as zt,ar as ct,R as a,a1 as y,as as de,at as me,au as $e,a5 as Ae,av as Xe,aw as Vt,ax as dt}from"./SidebarNavigationConversationItem.svelte_svelte_type_style_lang.js";import{M as Yt}from"./TruncatedText.js";import{b as jt}from"./checkbox.js";import{B as Qt}from"./bot.js";import{S as Zt}from"./settings.js";import{m as Ce,e as Re,h as en,n as tn}from"./models.svelte.js";import{g as xe}from"./formatters.js";import"./url.js";import"@sveltejs/kit/internal/server";import"@sveltejs/kit";import"@modelcontextprotocol/sdk/client";import"@modelcontextprotocol/sdk/client/sse.js";import"@modelcontextprotocol/sdk/client/streamableHttp.js";import"@modelcontextprotocol/sdk/client/websocket.js";import"dexie";function Ss(l,e){let{$$slots:t,$$events:n,...o}=e;ke(l,De([{name:"git-branch"},o,{iconNode:[["path",{d:"M15 6a9 9 0 0 0-9 9V3"}],["circle",{cx:"18",cy:"6",r:"3"}],["circle",{cx:"6",cy:"18",r:"3"}]]}]))}function Cs(l,e){let{$$slots:t,$$events:n,...o}=e;ke(l,De([{name:"loader-circle"},o,{iconNode:[["path",{d:"M21 12a9 9 0 1 1-6.219-8.56"}]]}]))}function nn(l,e){let{$$slots:t,$$events:n,...o}=e;ke(l,De([{name:"package"},o,{iconNode:[["path",{d:"M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z"}],["path",{d:"M12 22V12"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["path",{d:"m7.5 4.27 9 5.15"}]]}]))}function sn(l,e){let{$$slots:t,$$events:n,...o}=e;ke(l,De([{name:"square-pen"},o,{iconNode:[["path",{d:"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"}],["path",{d:"M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"}]]}]))}function _s(l,e){let{$$slots:t,$$events:n,...o}=e;ke(l,De([{name:"square"},o,{iconNode:[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]]}]))}const on=/\[Attachment saved: ([^\]]+)\]/,rn=/^[[{]/,an=/^(```|~~~)/m,ln=/^#{1,6}\s+\S/,cn=/^>\s+\S/,dn=/^\s*[-*+]\s+\S/,gn=/^\s*\d+[.)]\s+\S/,un=/\[[^\]\n]+\]\([^)\s]+\)/,fn=/\*\*[^*\n]+\*\*|__[^_\n]+__/,hn=/^\s*\|?[\s:|-]+\|?\s*$/,gt=`--- +`,pn=/Total matches:\s*(\d+)/,Ts=" - ",ut={enabled:!0,maxTurns:100},ft={END:"",START:""},mn={REASONING_BLOCK:/<<>>[\s\S]*?<<>>/g},Sn="PDF File",Cn="MCP Prompt",_n="MCP Resource",Tn={END_REASONING:"reasoning_end"},Mn=3e3,Ms=8,En="System message",Es=nn,vs="22rem",ys=[{icon:sn,keys:["shift","cmd","o"],route:Ge.NEW_CHAT,tooltip:"New chat"},{icon:jt,keys:["cmd","k"],tooltip:"Search"},{activeRouteId:"/agents",activeUrlIncludes:"#/agents",icon:Qt,route:Ge.AGENTS,tooltip:"Agent Control Center"},{activeRouteId:"/mcp-servers",icon:Yt,route:Ge.MCP_SERVERS,tooltip:"MCP Servers"},{activeUrlIncludes:"#/settings",icon:Zt,route:`${Ge.SETTINGS}/general`,tooltip:"Settings"}];function ht(l){const e=l.replace(At,""),t=e.lastIndexOf(et);return t===-1?e:e.slice(t+1)}function vn(l,e){return l?e?l===e?Tt:l.startsWith(e+et)?Mt+l.slice(e.length+1):ht(l):ht(l):""}function As(l,e){return e?l===e?Tt:l.startsWith(e+et)?Mt+l.slice(e.length+1):l:l}function pt(l,e){const t=vn(l,e);return`${Qe}[${yt}${l}](${t}).`}function Rs(l){const e=l.trim();if(e===_t)return{display:"",path:null};if(e.startsWith(Qe)){const t=e.slice(Qe.length),n=t.match(vt);return n?{display:n[2],path:n[1]}:{display:t,path:t}}return null}function Ye(l,e=[],t=[],n=!1){const o=[];if(l.reasoningContent){const r=He(l.toolCalls),d=!!l.content?.trim()||r.length>0||t.length>0,u=n&&!d;o.push({content:l.reasoningContent,type:u?ee.REASONING_PENDING:ee.REASONING,wasInterrupted:!n&&!d})}l.content?.trim()&&o.push({content:l.content,type:ee.TEXT});const s=He(l.toolCalls),c=new Map;for(const r of e)r.toolCallId&&!c.has(r.toolCallId)&&c.set(r.toolCallId,r);for(const r of s){const d=r.id?c.get(r.id):void 0,u=d?ee.TOOL_CALL:n?ee.TOOL_CALL_PENDING:ee.TOOL_CALL;o.push({content:d?.content||"",toolArgs:r.function?.arguments,toolCallId:r.id,toolCwd:d?.toolCwd,toolName:r.function?.name,toolResult:d?.content,toolResultExtras:d?.extra,type:u})}const i=new Set(s.map(r=>r.id).filter(Boolean));for(const r of t)r.id&&i.has(r.id)||o.push({content:"",toolArgs:r.function?.arguments,toolCallId:r.id,toolName:r.function?.name,type:ee.TOOL_CALL_STREAMING});return o}function ws(l,e=[],t=[],n=!1){if(!e.some(r=>r.role===T.ASSISTANT))return Ye(l,e,t,n);const s=[],c=mt(e,0);s.push(...Ye(l,c));let i=c.length;for(;i=e.length;s.push(...Ye(r,d,u?t:[],u&&n)),i+=1+d.length}else i++}return s}function Ns(l){const e=[];for(const t of l)switch(t.type){case ee.REASONING:case ee.REASONING_PENDING:e.push(`${ft.START}${te}${t.content}${ft.END}`);break;case ee.TEXT:e.push(t.content);break;case ee.TOOL_CALL:case ee.TOOL_CALL_PENDING:case ee.TOOL_CALL_STREAMING:{const n={name:t.toolName};if(t.toolArgs)try{n.arguments=JSON.parse(t.toolArgs)}catch{n.arguments=t.toolArgs}e.push(JSON.stringify(n,null,2)),t.toolResult&&e.push(`${te}${t.toolResult}`);break}}return e.join(`${te}${te}`)}function mt(l,e){const t=[];for(let n=e;ni.trim()).filter(i=>i.length>0)}}const yn=32,Ie=new Map;function xs(l,e){const n=`${(e??[]).filter(i=>i.type===ne.IMAGE).map(i=>i.name).join(te)}:${l}`,o=Ie.get(n);if(o!==void 0)return o;const c=l.split(te).map(i=>{const r=i.match(on);if(!r||!e)return{text:i};const d=r[1];return{image:e.find(h=>h.type===ne.IMAGE&&h.name===d),text:i}});return Ie.size>=yn&&Ie.delete(Ie.keys().next().value),Ie.set(n,c),c}const An=32,Le=new Map;function Is(l){if(!l)return Te.TEXT;const e=Le.get(l);if(e!==void 0)return e;const t=l.trim();if(!t)return Te.TEXT;let n=Te.TEXT;if(rn.test(t))try{JSON.parse(t),n=Te.JSON}catch(o){console.error("[agentic] tool result looked like JSON but failed to parse:",o)}return n===Te.TEXT&&Rn(t)&&(n=Te.MARKDOWN),Le.size>=An&&Le.delete(Le.keys().next().value),Le.set(l,n),n}function Rn(l){if(an.test(l))return!0;const e=l.split(te);for(const t of e)if(ln.test(t)||cn.test(t)||dn.test(t)||gn.test(t))return!0;if(un.test(l)||fn.test(l))return!0;if(e.length>=2){const t=e[0],n=e[1];if(t.includes("|")&&hn.test(n))return!0}return!1}const wn=64,Pe=new Map;function He(l){if(!l)return[];const e=Pe.get(l);if(e)return e;let t;try{const n=JSON.parse(l);t=Array.isArray(n)?n:[]}catch{t=[]}return Pe.size>=wn&&Pe.delete(Pe.keys().next().value),Pe.set(l,t),t}function Ls(l,e=[]){return l.toolCalls&&He(l.toolCalls).length>0?!0:e.length>0}function Nn(l,e){const t=l[e];if(!t||t.role!==T.ASSISTANT)return{kind:Ne.APPEND_TEXT};if(!(He(t.toolCalls).length>0))return{kind:Ne.APPEND_TEXT};let o=e;for(let s=e+1;se?{kind:Ne.NEXT_TURN,truncateAfter:o}:{kind:Ne.RERUN_TURN,truncateAfter:e-1}}const bn=1e6,Ps=.85,xn=128*1024,In=65496,Ln=225,Pn=218,On=1165519206,Dn=18761,kn=42,Fn=274,St=12;function Un(l){try{const e=l.indexOf(",")+1;if(e<=0)return 1;const t=Math.ceil(xn/3)*4,n=l.slice(e,e+t),o=atob(n.slice(0,n.length-n.length%4)),s=new Uint8Array(o.length);for(let c=0;cn||l.getUint32(e)!==On||l.getUint16(e+4)!==0)return 1;const o=e+6;if(o+8>n)return 1;const s=l.getUint16(o)===Dn;if(l.getUint16(o+2,s)!==kn)return 1;const c=l.getUint32(o+4,s);if(o+c+2>n)return 1;const i=l.getUint16(o+c,s);for(let r=0;rn)return 1;if(l.getUint16(d,s)===Fn){const u=l.getUint16(d+8,s);return u>=1&&u<=8?u:1}}return 1}function Xn(l){return l===Ze.JPEG||l===Ze.JPG}function Bn(l,e){return new Promise((t,n)=>{try{const o=l.match(Rt);if(!o)return n(new Error("Invalid data URL format."));const s=o[1];if(!Object.values(Ze).includes(s))return n(new Error(`Unsupported image MIME type: ${s}`));const c=Xn(s)?Un(l):1,i=new Image;i.onload=()=>{try{const r=document.createElement("canvas"),d=r.getContext("2d");if(!d)throw new Error("Failed to get 2D canvas context.");const u=i.naturalWidth,h=i.naturalHeight,p=u*h,g=Math.floor(e*bn);if(g>0&&p>g){const M=Math.sqrt(g/p);r.width=Math.floor(u*M),r.height=Math.floor(h*M)}else if(c>1)r.width=u,r.height=h;else return t(l);d.drawImage(i,0,0,r.width,r.height),t(r.toDataURL(s))}catch(r){n(r instanceof Error?r:new Error(String(r)))}},i.onerror=()=>{n(new Error("Failed to load image."))},i.src=l}catch(o){const c=`Error resizing image: ${o instanceof Error?o.message:String(o)}`;console.error(c,o),n(new Error(c))}})}function Oe(l,e){return l?e?`${l}::${e}`:l:""}function Hn(l){const e=l.trim().toLowerCase();return e===Me.WAV||e===Me.WAVE||e===Me.X_WAV||e===Me.X_WAVE||e===Me.VND_WAVE||e===Me.X_PN_WAV?st.WAV:st.MP3}function je(l){return Lt+l}class R{static async generateTitle(e,t,n){let o="";try{await R.sendMessage([e],{custom:{chat_template_kwargs:{enable_thinking:!1}},model:t||void 0,onChunk:s=>{o+=s},stream:!0},void 0,n)}catch{return""}return o}static async sendMessage(e,t={},n,o){const{backend_sampling:s,continueFinalMessage:c,custom:i,disableReasoningParsing:r,dry_allowed_length:d,dry_base:u,dry_multiplier:h,dry_penalty_last_n:p,dynatemp_exponent:g,dynatemp_range:M,enableThinking:S,excludeReasoningFromContext:U,frequency_penalty:E,max_tokens:G,min_p:F,onChunk:N,onComplete:w,onCompletionId:W,onConnectionState:f,onError:C,onModel:m,onReasoningChunk:P,onTimings:b,onToolCallChunk:X,presence_penalty:O,reasoningEffort:H,repeat_last_n:$,repeat_penalty:oe,samplers:ae,stream:L,temperature:D,timings_per_token:q,tools:A,top_k:x,top_p:J,typ_p:B,xtc_probability:fe,xtc_threshold:Y}=t,le=(await Promise.all(e.map(_=>{if("id"in _&&"convId"in _&&"timestamp"in _){const I=_;return R.convertDbMessageToApiChatMessageData(I)}else return _}))).filter(_=>_.role===T.SYSTEM?(typeof _.content=="string"?_.content:"").trim().length>0:!0);t.model&&!Ce.modelSupportsVision(t.model)&&le.forEach(_=>{Array.isArray(_.content)&&(_.content=_.content.filter(I=>I.type===z.IMAGE_URL?(console.info(`[ChatService] Skipping image attachment in message history (model "${t.model}" does not support vision)`),!1):!0),_.content.length===1&&_.content[0].type===z.TEXT&&typeof _.content[0].text=="string"&&(_.content=_.content[0].text))});const v={messages:le.map(_=>{const I={content:_.content,role:_.role,tool_call_id:_.tool_call_id,tool_calls:_.tool_calls};return!U&&_.reasoning_content&&(I.reasoning_content=_.reasoning_content),I}),return_progress:L?!0:void 0,sse_ping_interval:L?1:void 0,stream:L,tools:A&&A.length>0?A:void 0};t.model&&(v.model=t.model),v.reasoning_format=r?lt.NONE:lt.AUTO;const j=S&&H?wt[H]??-1:-1;if(S!==void 0&&(v.chat_template_kwargs={...v.chat_template_kwargs??{},enable_thinking:S}),j>=0&&(v.thinking_budget_tokens=j),v.reasoning_control=!0,c&&(v.continue_final_message=!0,v.add_generation_prompt=!1),D!==void 0&&(v.temperature=D),G!==void 0&&(v.max_tokens=G!==null&&G!==0?G:-1),M!==void 0&&(v.dynatemp_range=M),g!==void 0&&(v.dynatemp_exponent=g),x!==void 0&&(v.top_k=x),J!==void 0&&(v.top_p=J),F!==void 0&&(v.min_p=F),fe!==void 0&&(v.xtc_probability=fe),Y!==void 0&&(v.xtc_threshold=Y),B!==void 0&&(v.typ_p=B),$!==void 0&&(v.repeat_last_n=$),oe!==void 0&&(v.repeat_penalty=oe),O!==void 0&&(v.presence_penalty=O),E!==void 0&&(v.frequency_penalty=E),h!==void 0&&(v.dry_multiplier=h),u!==void 0&&(v.dry_base=u),d!==void 0&&(v.dry_allowed_length=d),p!==void 0&&(v.dry_penalty_last_n=p),ae!==void 0&&(v.samplers=typeof ae=="string"?ae.split(";").filter(_=>_.trim()):ae),s!==void 0&&(v.backend_sampling=s),q!==void 0&&(v.timings_per_token=q),i)try{const _=typeof i=="string"?JSON.parse(i):i;Object.assign(v,_)}catch(_){console.warn("Failed to parse custom parameters:",_)}try{const _={...Je()};L&&n&&(_["X-Conversation-Id"]=Oe(n,t.model),R.saveStreamState(n,0,t.model??null));const I=await fetch(qe.COMPLETIONS,{body:JSON.stringify(v),headers:_,method:"POST",signal:o});if(!I.ok){n&&R.clearStreamState(n);const ge=await R.parseErrorResponse(I);throw C&&C(ge),ge}if(L){await R.handleStreamResponse(I,N,w,C,P,X,m,W,b,n,o,f,t.model);return}else return R.handleNonStreamResponse(I,w,C,X,m)}catch(_){if(Z(_)){console.log("Chat completion request was aborted");return}let I;throw _ instanceof Error?_.name==="TypeError"&&_.message.includes("fetch")?(I=new Error("Unable to connect to server - please check if the server is running"),I.name="NetworkError"):_.message.includes("ECONNREFUSED")?(I=new Error("Connection refused - server may be offline"),I.name="NetworkError"):_.message.includes("ETIMEDOUT")?(I=new Error("Request timed out - the server took too long to respond"),I.name="TimeoutError"):I=_:I=new Error("Unknown error occurred while sending message"),console.error("Error in sendMessage:",_),C&&C(I),I}}static async areAllSlotsIdle(e,t){try{const n=e?`${tt.LIST}?model=${encodeURIComponent(e)}`:tt.LIST,o=await fetch(n,{signal:t});return o.ok?(await o.json()).every(c=>!c.is_processing):!0}catch{return!0}}static async stopReasoning(e,t){if(!e)return console.error("stopReasoning: no completion id for the active message, cannot target the running completion"),!1;const n={action:Tn.END_REASONING,id:e};t&&(n.model=t);try{const o=await fetch(qe.CONTROL,{body:JSON.stringify(n),headers:Je(),method:"POST"}),s=await o.json().catch(()=>null);return!o.ok||s?.success!==!0?(console.error("stopReasoning: control request failed",{completionId:e,response:s,status:o.status}),!1):!0}catch(o){return console.error("stopReasoning: control request threw",{completionId:e,error:o}),!1}}static async cancelServerStream(e,t){if(e)try{const n=Oe(e,t);await fetch(`${Ke.BASE}?conv_id=${encodeURIComponent(n)}`,{headers:be(),method:"DELETE"})}catch(n){console.warn("cancelServerStream failed:",n)}}static selectActiveStream(e){if(!Array.isArray(e)||e.length===0)return null;const t=e.filter(n=>!n.is_done);return t.length===0?null:t.reduce((n,o)=>o.started_at>n.started_at?o:n)}static saveStreamState(e,t,n){if(e)try{const o={bytesReceived:t,model:n??null,updatedAt:Date.now()};localStorage.setItem(je(e),JSON.stringify(o))}catch{}}static getStreamState(e){if(!e)return null;try{const t=localStorage.getItem(je(e));if(!t)return null;const n=JSON.parse(t);return!n||typeof n.bytesReceived!="number"?null:n}catch{return null}}static clearStreamState(e){if(e)try{localStorage.removeItem(je(e))}catch{}}static resumeStreamIdentity(e,t,n){const o=t&&t.model!==void 0?t.model:n;return Oe(e,o)}static async probeResumeStatus(e){if(!e)return 0;const t=new AbortController;try{const n=await fetch(`${Ke.BASE}?conv_id=${encodeURIComponent(e)}&from=0`,{headers:be(),signal:t.signal});return t.abort(),n.status}catch{return 0}}static async resumeStream(e,t,n){if(!e)return null;const s=R.getStreamState(e)?.bytesReceived??0,c=Oe(e,n),i=`${Ke.BASE}?conv_id=${encodeURIComponent(c)}&from=${s}`;return await fetch(i,{headers:be(),method:"GET",signal:t})}static async preEncode(e,t,n,o){const c={messages:(await Promise.all(e.map(i=>"id"in i&&"convId"in i&&"timestamp"in i?R.convertDbMessageToApiChatMessageData(i):i))).filter(i=>i.role===T.SYSTEM?(typeof i.content=="string"?i.content:"").trim().length>0:!0).map(i=>{const r={content:n?R.stripReasoningContent(i.content):i.content,role:i.role,tool_call_id:i.tool_call_id,tool_calls:i.tool_calls};return!n&&i.reasoning_content&&(r.reasoning_content=i.reasoning_content),r}),n_predict:0,stream:!1};t&&(c.model=t);try{await fetch(qe.COMPLETIONS,{body:JSON.stringify(c),headers:Je(),method:"POST",signal:o})}catch(i){Z(i)||console.warn("[ChatService] Pre-encode request failed:",i)}}static async handleStreamResponse(e,t,n,o,s,c,i,r,d,u,h,p,g){let M=e.body?.getReader();if(!M)throw new Error("No response body");let S=0,U=0,E=0,G=Date.now(),F=!0;const N=new TextEncoder;u&&R.saveStreamState(u,0,g),p?.(we.STREAMING);let w=new TextDecoder,W="",f="",C=[],m,P=!1,b=!1,X=!1,O=0,H=!1;const $=()=>{H&&(O=C.length,H=!1)},oe=L=>{if(!L||L.length===0||(C=R.mergeToolCallDeltas(C,L,O),C.length===0))return;H=!0;const D=JSON.stringify(C);D&&(h?.aborted||c?.(D))},ae=()=>{typeof document>"u"||document.visibilityState==="visible"&&(P||u&&Date.now()-G>Mn&&M.cancel().catch(()=>{}))};typeof document<"u"&&document.addEventListener("visibilitychange",ae);try{let L="";for(;;){for(;!h?.aborted;){let A,x;try{const B=await M.read();A=B.done,x=B.value}catch(B){if(Z(B))throw B;console.warn("reader.read() rejected, treating as premature end:",B),A=!0,x=void 0}if(A||h?.aborted)break;x&&x.byteLength>0&&(E+=x.byteLength,G=Date.now(),F||(F=!0,p?.(we.STREAMING))),L+=w.decode(x,{stream:!0});const J=L.split(Nt);if(L=J.pop()||"",u){const B=N.encode(L).byteLength;S=U+E-B,R.saveStreamState(u,S,g)}for(const B of J){if(h?.aborted)break;if(B.startsWith(nt)){const fe=B.slice(nt.length).trim();if(fe===bt){P=!0;continue}try{const Y=JSON.parse(fe),le=Y.choices?.[0],v=le?.delta?.content,j=le?.delta?.reasoning_content,_=le?.delta?.tool_calls,I=Y.timings,ge=Y.prompt_progress,ce=R.extractModelName(Y);ce&&!b&&(b=!0,i?.(ce)),Y.id&&!X&&(X=!0,r?.(Y.id)),ge&&R.notifyTimings(void 0,ge,d),I&&(R.notifyTimings(I,ge,d),m=I),v&&($(),W+=v,h?.aborted||t?.(v)),j&&($(),f+=j,h?.aborted||s?.(j)),oe(_)}catch(Y){console.error("Error parsing JSON chunk:",Y)}}}if(h?.aborted||P)break}if(h?.aborted||P||!u)break;if(!F){p?.(we.LOST),o?.(new Error("Stream resume produced no new bytes, giving up"));break}p?.(we.RESUMING),F=!1;const D=await R.resumeStream(u,h,g).catch(()=>null);if(h?.aborted)break;if(!D||D.status!==200){p?.(we.LOST),o?.(new Error("Stream connection lost and could not be resumed"));break}const q=D.body?.getReader();if(!q)break;try{M.releaseLock()}catch{}M=q,w=new TextDecoder,L="",U=S,E=0,G=Date.now()}if(h?.aborted)return;if(P){$(),u&&R.clearStreamState(u);const D=C.length>0?JSON.stringify(C):void 0;n?.(W,f||void 0,m,D)}}catch(L){const D=L instanceof Error?L:new Error("Stream error");throw o?.(D),D}finally{typeof document<"u"&&document.removeEventListener("visibilitychange",ae);try{M.releaseLock()}catch{}}}static async handleNonStreamResponse(e,t,n,o,s){try{const c=await e.text();if(!c.trim())throw new Error("No response received from server. Please try again.");const i=JSON.parse(c),r=R.extractModelName(i);r&&s?.(r);const d=i.choices[0]?.message?.content||"",u=i.choices[0]?.message?.reasoning_content,h=i.choices[0]?.message?.tool_calls;let p;if(h&&h.length>0){const g=R.mergeToolCallDeltas([],h);g.length>0&&(p=JSON.stringify(g),p&&o?.(p))}if(!d.trim()&&!p)throw new Error("No response received from server. Please try again.");return t?.(d,u,void 0,p),d}catch(c){const i=c instanceof Error?c:new Error("Parse error");throw n?.(i),i}}static mergeToolCallDeltas(e,t,n=0){const o=e.map(s=>({...s,function:s.function?{...s.function}:void 0}));for(const s of t){const c=typeof s.index=="number"&&s.index>=0?s.index+n:o.length;for(;o.length<=c;)o.push({function:void 0});const i=o[c];if(s.id&&(i.id=s.id),s.type&&(i.type=s.type),s.function){const r=i.function?{...i.function}:{};s.function.name&&(r.name=s.function.name),s.function.arguments&&(r.arguments=(r.arguments??"")+s.function.arguments),i.function=r}}return o}static async convertDbMessageToApiChatMessageData(e){if(e.role===T.TOOL&&e.toolCallId)return{content:e.content,role:T.TOOL,tool_call_id:e.toolCallId};let t;if(e.toolCalls)try{t=JSON.parse(e.toolCalls)}catch{}if(!e.extra||e.extra.length===0){const g={content:e.content,role:e.role};return e.reasoningContent&&(g.reasoning_content=e.reasoningContent),t&&t.length>0&&(g.tool_calls=t),g}const n=[],o=e.extra.filter(g=>g.type===ne.TEXT);for(const g of o)n.push({text:xe("File",g.name,g.content),type:z.TEXT});const s=e.extra.filter(g=>g.type===ne.LEGACY_CONTEXT);for(const g of s)n.push({text:xe("File",g.name,g.content),type:z.TEXT});const c=e.extra.filter(g=>g.type===ne.IMAGE);for(const g of c){const M=xt.getConfig(It.MAX_IMAGE_RESOLUTION),S=await Bn(g.base64Url,M);n.push({image_url:{url:S},type:z.IMAGE_URL})}const i=e.extra.filter(g=>g.type===ne.AUDIO);for(const g of i)n.push({input_audio:{data:g.base64Data,format:Hn(g.mimeType)},type:z.INPUT_AUDIO});e.content&&n.push({text:e.content,type:z.TEXT});const r=e.extra.filter(g=>g.type===ne.VIDEO);for(const g of r)n.push({input_video:{data:g.base64Data,format:g.mimeType.includes("mp4")?"mp4":g.mimeType.includes("ogg")?"ogg":"auto"},type:z.INPUT_VIDEO});const d=e.extra.filter(g=>g.type===ne.PDF);for(const g of d)if(g.processedAsImages&&g.images)for(let M=0;Mg.type===ne.MCP_PROMPT);for(const g of u)n.push({text:xe(Cn,g.name,g.content,g.serverName),type:z.TEXT});const h=e.extra.filter(g=>g.type===ne.MCP_RESOURCE);for(const g of h)n.push({text:xe(_n,g.name,g.content,g.serverName),type:z.TEXT});const p={content:n,role:e.role};return e.reasoningContent&&(p.reasoning_content=e.reasoningContent),t&&t.length>0&&(p.tool_calls=t),p}static stripReasoningContent(e){const t=n=>n.replace(mn.REASONING_BLOCK,"").trim();return typeof e=="string"?t(e):e.map(n=>n.type===z.TEXT&&n.text?{...n,text:t(n.text)}:n)}static async parseErrorResponse(e){try{const t=await e.text(),n=JSON.parse(t),o=n.error?.message||"Unknown server error",s=new Error(o);return s.name=e.status===400?"ServerError":"HttpError",n.error&&"n_prompt_tokens"in n.error&&"n_ctx"in n.error&&(s.contextInfo={n_ctx:n.error.n_ctx,n_prompt_tokens:n.error.n_prompt_tokens}),s}catch{const t=new Error(`Server error (${e.status}): ${e.statusText}`);return t.name="HttpError",t}}static extractModelName(e){const t=d=>typeof d=="object"&&d!==null?d:void 0,n=d=>typeof d=="string"&&d.trim()?d.trim():void 0,o=t(e);if(!o)return;const s=n(o.model);if(s)return s;const c=Array.isArray(o.choices)?t(o.choices[0]):void 0;if(!c)return;const i=n(t(c.delta)?.model);if(i)return i;const r=n(t(c.message)?.model);if(r)return r}static notifyTimings(e,t,n){!n||!e&&!t||n(e,t)}}const Wn=`const logs = []; +const fmt = (value) => { + if (typeof value === 'string') return value; + try { + return JSON.stringify(value); + } catch { + return String(value); + } +}; +const capture = + (level, prefix) => + (...args) => { + logs.push(prefix + args.map(fmt).join(' ')); + }; +console.log = capture('log', ''); +console.info = capture('info', ''); +console.debug = capture('debug', ''); +console.warn = capture('warn', 'warn: '); +console.error = capture('error', 'error: '); +self.onmessage = async (event) => { + const reply = { logs, result: null, error: null }; + try { + const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor; + // The prelude bundled ahead of this shim defines self.nerdamer, + // passed into the execution scope as the \`nerdamer\` parameter. + const value = await new AsyncFunction('nerdamer', event.data.code)(self.nerdamer); + if (value !== undefined) reply.result = fmt(value); + } catch (err) { + reply.error = err instanceof Error ? err.stack || err.message : String(err); + } + self.postMessage(reply); +}; +`,Jn="default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval'; worker-src blob:";function Ct(l){return` + + + diff --git a/tools/ui/dist/manifest.webmanifest b/tools/ui/dist/manifest.webmanifest new file mode 100644 index 0000000000000000000000000000000000000000..a49b8f698895988af5d5c21ef15d1147c23c9641 --- /dev/null +++ b/tools/ui/dist/manifest.webmanifest @@ -0,0 +1 @@ +{"name":"llama-ui","short_name":"llama-ui","description":"Local AI chat interface powered by llama.cpp","start_url":"./","display":"standalone","background_color":"#faf8f5","theme_color":"#faf8f5","lang":"en","scope":"./","icons":[{"sizes":"64x64","src":"pwa-64x64.png","type":"image/png"},{"sizes":"192x192","src":"pwa-192x192.png","type":"image/png"},{"purpose":"any","sizes":"512x512","src":"pwa-512x512.png","type":"image/png"},{"purpose":"maskable","sizes":"512x512","src":"maskable-icon-512x512.png","type":"image/png"}]} diff --git a/tools/ui/dist/maskable-icon-512x512.png b/tools/ui/dist/maskable-icon-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..318f3d067a743a4d7455e16b2d58e8e0cacbb1f2 --- /dev/null +++ b/tools/ui/dist/maskable-icon-512x512.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fee829f3443a419a6356af2a45095018e67b0dd92219bba1f651b6030f03984 +size 14329 diff --git a/tools/ui/dist/pwa-192x192.png b/tools/ui/dist/pwa-192x192.png new file mode 100644 index 0000000000000000000000000000000000000000..5a4ce2eff3fe7f5fbad3b579d537248590e55273 --- /dev/null +++ b/tools/ui/dist/pwa-192x192.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:244db802b9e589b5268fd2c4aabff5341c6cdc0e7631241c40866b669029578d +size 14529 diff --git a/tools/ui/dist/pwa-512x512.png b/tools/ui/dist/pwa-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..7b754141e71b90f6eb0fbdcb27077c4e6f8f2f76 --- /dev/null +++ b/tools/ui/dist/pwa-512x512.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b956fc599089ae84d5585ae11663b9856d0f2d14cb94068814aefd6c3804ddb +size 80369 diff --git a/tools/ui/dist/pwa-64x64.png b/tools/ui/dist/pwa-64x64.png new file mode 100644 index 0000000000000000000000000000000000000000..9635e16c6c78ca7139df212889b738f0b4f5dc66 --- /dev/null +++ b/tools/ui/dist/pwa-64x64.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b807f22c186632bad6bdb2df71439ca7d24132bd8f0fbb4cc094e18da5a7b684 +size 2381 diff --git a/tools/ui/dist/recommended-mcp/context7.png b/tools/ui/dist/recommended-mcp/context7.png new file mode 100644 index 0000000000000000000000000000000000000000..7b406fbc9f39dfd1db1c9b1c4401a064fdeeb574 --- /dev/null +++ b/tools/ui/dist/recommended-mcp/context7.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d42a0cad320600ee0ebb805065f212a81a257895e9dc39687b7958602ea4f70 +size 1489 diff --git a/tools/ui/dist/recommended-mcp/exa.ico b/tools/ui/dist/recommended-mcp/exa.ico new file mode 100644 index 0000000000000000000000000000000000000000..25e4283d07429cbee428a84cfddda5d4d5fda592 Binary files /dev/null and b/tools/ui/dist/recommended-mcp/exa.ico differ diff --git a/tools/ui/dist/recommended-mcp/github-dark.png b/tools/ui/dist/recommended-mcp/github-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..dc3fc76165ca9ab2709660b84a446bf0fd857a3d --- /dev/null +++ b/tools/ui/dist/recommended-mcp/github-dark.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf0a7086aa8828289df0e48c1a9a57e14fe5b437fba84c7eff4d305d1d074ff1 +size 584 diff --git a/tools/ui/dist/recommended-mcp/github-light.png b/tools/ui/dist/recommended-mcp/github-light.png new file mode 100644 index 0000000000000000000000000000000000000000..1fdea741b3bc4ee99e0078aa3000ae25888c5547 --- /dev/null +++ b/tools/ui/dist/recommended-mcp/github-light.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74cf90ac2fe6624ab1056cacea11cf7ed4f8bef54bbb0e869638013bba45bc08 +size 958 diff --git a/tools/ui/dist/recommended-mcp/huggingface.ico b/tools/ui/dist/recommended-mcp/huggingface.ico new file mode 100644 index 0000000000000000000000000000000000000000..abb1244e42fbb6eee04c2e2e0d7644eccd3e6716 --- /dev/null +++ b/tools/ui/dist/recommended-mcp/huggingface.ico @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7266292a5073388702cfca169d26766460cb90ba978bacc95c914ad7a5c611cb +size 205556 diff --git a/tools/ui/dist/registerSW.js b/tools/ui/dist/registerSW.js new file mode 100644 index 0000000000000000000000000000000000000000..179c13c06ca402440d18733a5185cf49ed9d63cd --- /dev/null +++ b/tools/ui/dist/registerSW.js @@ -0,0 +1 @@ +if('serviceWorker' in navigator) {window.addEventListener('load', () => {navigator.serviceWorker.register('./sw.js', { scope: './' })})} \ No newline at end of file diff --git a/tools/ui/dist/sw.js b/tools/ui/dist/sw.js new file mode 100644 index 0000000000000000000000000000000000000000..3bcbd8c1e37edf3061333b53698da2011694fb1a --- /dev/null +++ b/tools/ui/dist/sw.js @@ -0,0 +1 @@ +if(!self.define){let a,e={};const p=(p,r)=>(p=new URL(p+".js",r).href,e[p]||new Promise(e=>{if("document"in self){const a=document.createElement("script");a.src=p,a.onload=e,document.head.appendChild(a)}else a=p,importScripts(p),e()}).then(()=>{let a=e[p];if(!a)throw new Error(`Module ${p} didn’t register its module`);return a}));self.define=(r,s)=>{const c=a||("document"in self?document.currentScript.src:"")||location.href;if(e[c])return;let d={};const l=a=>p(a,c),i={module:{uri:c},exports:d,require:l};e[c]=Promise.all(r.map(a=>i[a]||l(a))).then(a=>(s(...a),d))}}define(["./workbox-b3c04f83"],function(a){"use strict";self.addEventListener("message",a=>{a.data&&"SKIP_WAITING"===a.data.type&&self.skipWaiting()}),a.precacheAndRoute([{url:"./",revision:"e8342c58c9da96da60e1d5a3c7db9a35"},{url:"registerSW.js",revision:"402b66900e731ca748771b6fc5e7a068"},{url:"pwa-64x64.png",revision:"d5ac6cd1e1ad6b51effbd2f58b6bb846"},{url:"pwa-512x512.png",revision:"1d08a2651f877c070a29b7b56e4d0d4d"},{url:"pwa-192x192.png",revision:"6409fa17447e9080cbd1039dbd4de61c"},{url:"maskable-icon-512x512.png",revision:"fc682186380a090ce51956e9db0a8293"},{url:"favicon.svg",revision:"81eeb60ac7cfcf2c7ecb272d4df20d98"},{url:"favicon.ico",revision:"8ee7f5150dc221b0794e137b66159128"},{url:"favicon-dark.svg",revision:"81eeb60ac7cfcf2c7ecb272d4df20d98"},{url:"favicon-dark.ico",revision:"8ee7f5150dc221b0794e137b66159128"},{url:"apple-touch-icon-180x180.png",revision:"a6e05050941d6f4d1f680ab05d153602"},{url:"apple-splash-portrait-dark-750x1334.png",revision:"9dcf60b9516d6e33a447429d4d9c8a22"},{url:"apple-splash-portrait-dark-640x1136.png",revision:"8dd4297ecefbc9240a87d2c3838a11a3"},{url:"apple-splash-portrait-dark-2048x2732.png",revision:"fd4ceb9ba7e08d583dd2806f2a2be27f"},{url:"apple-splash-portrait-dark-1668x2388.png",revision:"154ed6d54915ab86a7ff83a8912279ff"},{url:"apple-splash-portrait-dark-1640x2360.png",revision:"c70505bb4ca85c2fac4b2b77f6e761f1"},{url:"apple-splash-portrait-dark-1488x2266.png",revision:"b3859f53e2d51aaeb79fa624f8cf6925"},{url:"apple-splash-portrait-dark-1320x2868.png",revision:"d8a45ded013f6e79a6a246a149f75c58"},{url:"apple-splash-portrait-dark-1290x2796.png",revision:"ad6cdb3e57250848f7c427f462cc106d"},{url:"apple-splash-portrait-dark-1284x2778.png",revision:"876cfcd5e72c42f23bd1c21250b21333"},{url:"apple-splash-portrait-dark-1206x2622.png",revision:"57c9c6cd5fba737894aae5f0b66a532f"},{url:"apple-splash-portrait-dark-1179x2556.png",revision:"c63fc2f9ecbca3c07ab48accb384bc24"},{url:"apple-splash-portrait-dark-1170x2532.png",revision:"5e4e49b1cde0a086b4f5e0ee7d548a87"},{url:"apple-splash-portrait-750x1334.png",revision:"bd2c7bc5d99e056247188e1e313a1bfa"},{url:"apple-splash-portrait-640x1136.png",revision:"a1bf7e6ddc72f932a64b3a6d48404963"},{url:"apple-splash-portrait-2048x2732.png",revision:"ef7d56425bf82428b6c26e9af88cd626"},{url:"apple-splash-portrait-1668x2388.png",revision:"6f5e91520dbdb1fad269acaed52521f8"},{url:"apple-splash-portrait-1640x2360.png",revision:"a8c7fb0ddb54e67ca0400efd56183a31"},{url:"apple-splash-portrait-1488x2266.png",revision:"b5a101b106cf3fd26f179eb40adb2688"},{url:"apple-splash-portrait-1320x2868.png",revision:"09ce0a5536bfc662d5cf01ea16cf234c"},{url:"apple-splash-portrait-1290x2796.png",revision:"e0ff669c9114e344ef7f07988dae7a4d"},{url:"apple-splash-portrait-1284x2778.png",revision:"2d65fb31b6583c33502fdf37c24d341c"},{url:"apple-splash-portrait-1206x2622.png",revision:"9dd9bc97cf486ad61beeb44519919396"},{url:"apple-splash-portrait-1179x2556.png",revision:"0ec8b87ffd2387509a2222116d12ac04"},{url:"apple-splash-portrait-1170x2532.png",revision:"baa57adff458724d4617c4f52ec9b499"},{url:"apple-splash-landscape-dark-2868x1320.png",revision:"4f0258be6a4f700fade6d3ca24c6f61d"},{url:"apple-splash-landscape-dark-2796x1290.png",revision:"c2f9070fcf987aa8849453849cb88ba2"},{url:"apple-splash-landscape-dark-2778x1284.png",revision:"8801b8418dbc9b5a5f4eec113fe2b7b2"},{url:"apple-splash-landscape-dark-2732x2048.png",revision:"dfbfae3a8aa3c33872e29ec760b741eb"},{url:"apple-splash-landscape-dark-2622x1206.png",revision:"181c2fa2aa88a4e3b99777048033d115"},{url:"apple-splash-landscape-dark-2556x1179.png",revision:"8ae6822a905d8b705aa49956348e783a"},{url:"apple-splash-landscape-dark-2532x1170.png",revision:"df7ba48bfd03bafad2a0e8473888a31b"},{url:"apple-splash-landscape-dark-2388x1668.png",revision:"f84c4ac571182994cdc5ec312ce69170"},{url:"apple-splash-landscape-dark-2360x1640.png",revision:"23c093af8d315cde220774dee08e0356"},{url:"apple-splash-landscape-dark-2266x1488.png",revision:"1cefe2cd1b9924d8320929a53f05a605"},{url:"apple-splash-landscape-dark-1334x750.png",revision:"fa1ae61fab4de81d03da7621fd840cb6"},{url:"apple-splash-landscape-dark-1136x640.png",revision:"c2c991f523fe0af872522cd81eec08b6"},{url:"apple-splash-landscape-2868x1320.png",revision:"6f64d4b0bd04b8b8cd58b672c7fc3c8a"},{url:"apple-splash-landscape-2796x1290.png",revision:"900cb6b3037ba6956f8d1c120e3fce65"},{url:"apple-splash-landscape-2778x1284.png",revision:"02a46b61c56b94690d58df7370336562"},{url:"apple-splash-landscape-2732x2048.png",revision:"91300acd052811db4ba65ec414ccddd3"},{url:"apple-splash-landscape-2622x1206.png",revision:"ad79ca6fac9571d1956783ab60f413c8"},{url:"apple-splash-landscape-2556x1179.png",revision:"158c045085d547a2541a9096f8bfd266"},{url:"apple-splash-landscape-2532x1170.png",revision:"4b183bde995e26acf11b930fc2d19c8d"},{url:"apple-splash-landscape-2388x1668.png",revision:"5619006273231d1b8f6042efbf25719f"},{url:"apple-splash-landscape-2360x1640.png",revision:"8417c0c3729c20fc59506ee561eb72ee"},{url:"apple-splash-landscape-2266x1488.png",revision:"c58775f391a118517ec76c94f26076be"},{url:"apple-splash-landscape-1334x750.png",revision:"d9bf9567c8efa1e0f03428d06795d486"},{url:"apple-splash-landscape-1136x640.png",revision:"3fad9eb03be4a96078bd435c356f5e5d"},{url:"recommended-mcp/huggingface.ico",revision:"263cfcce0eb8ff9417af21f6a2e412b7"},{url:"recommended-mcp/github-light.png",revision:"346e09471362f2907510a31812129cd2"},{url:"recommended-mcp/github-dark.png",revision:"9cdfb21c81d7335ed2b50f341c3f9f89"},{url:"recommended-mcp/exa.ico",revision:"add8299852c312936d15dede815bb32c"},{url:"recommended-mcp/context7.png",revision:"c04f0501ca5f53dcef09d0763b96ff59"},{url:"_app/version.json",revision:"650321b662a6c1fe766e16e135c38e03"},{url:"_app/immutable/bundle.Yxmpoeis.js",revision:null},{url:"_app/immutable/assets/bundle.S65JMH_w.css",revision:null},{url:"manifest.webmanifest",revision:"0bb25d64e73c8c2afe8d6434c56da303"}],{}),a.cleanupOutdatedCaches(),a.registerRoute(/^\/v1\/.*/,new a.NetworkFirst({cacheName:"api-cache",plugins:[new a.ExpirationPlugin({maxAgeSeconds:86400,maxEntries:50})]}),"GET"),a.registerRoute(/^\/(health|props|models|tools|slots|cors-proxy).*/,new a.NetworkFirst({cacheName:"api-cache",plugins:[new a.ExpirationPlugin({maxAgeSeconds:86400,maxEntries:50})]}),"GET")}); diff --git a/tools/ui/dist/workbox-b3c04f83.js b/tools/ui/dist/workbox-b3c04f83.js new file mode 100644 index 0000000000000000000000000000000000000000..e3eee8e5bbb531707d73b899ec0036eb9db325f9 --- /dev/null +++ b/tools/ui/dist/workbox-b3c04f83.js @@ -0,0 +1 @@ +define(["exports"],function(t){"use strict";try{self["workbox:core:7.4.0"]&&_()}catch(t){}const e=(t,...e)=>{let s=t;return e.length>0&&(s+=` :: ${JSON.stringify(e)}`),s};class s extends Error{constructor(t,s){super(e(t,s)),this.name=t,this.details=s}}try{self["workbox:routing:7.4.0"]&&_()}catch(t){}const n=t=>t&&"object"==typeof t?t:{handle:t};class i{constructor(t,e,s="GET"){this.handler=n(e),this.match=t,this.method=s}setCatchHandler(t){this.catchHandler=n(t)}}class r extends i{constructor(t,e,s){super(({url:e})=>{const s=t.exec(e.href);if(s&&(e.origin===location.origin||0===s.index))return s.slice(1)},e,s)}}class a{constructor(){this.t=new Map,this.i=new Map}get routes(){return this.t}addFetchListener(){self.addEventListener("fetch",t=>{const{request:e}=t,s=this.handleRequest({request:e,event:t});s&&t.respondWith(s)})}addCacheListener(){self.addEventListener("message",t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,s=Promise.all(e.urlsToCache.map(e=>{"string"==typeof e&&(e=[e]);const s=new Request(...e);return this.handleRequest({request:s,event:t})}));t.waitUntil(s),t.ports&&t.ports[0]&&s.then(()=>t.ports[0].postMessage(!0))}})}handleRequest({request:t,event:e}){const s=new URL(t.url,location.href);if(!s.protocol.startsWith("http"))return;const n=s.origin===location.origin,{params:i,route:r}=this.findMatchingRoute({event:e,request:t,sameOrigin:n,url:s});let a=r&&r.handler;const o=t.method;if(!a&&this.i.has(o)&&(a=this.i.get(o)),!a)return;let c;try{c=a.handle({url:s,request:t,event:e,params:i})}catch(t){c=Promise.reject(t)}const h=r&&r.catchHandler;return c instanceof Promise&&(this.o||h)&&(c=c.catch(async n=>{if(h)try{return await h.handle({url:s,request:t,event:e,params:i})}catch(t){t instanceof Error&&(n=t)}if(this.o)return this.o.handle({url:s,request:t,event:e});throw n})),c}findMatchingRoute({url:t,sameOrigin:e,request:s,event:n}){const i=this.t.get(s.method)||[];for(const r of i){let i;const a=r.match({url:t,sameOrigin:e,request:s,event:n});if(a)return i=a,(Array.isArray(i)&&0===i.length||a.constructor===Object&&0===Object.keys(a).length||"boolean"==typeof a)&&(i=void 0),{route:r,params:i}}return{}}setDefaultHandler(t,e="GET"){this.i.set(e,n(t))}setCatchHandler(t){this.o=n(t)}registerRoute(t){this.t.has(t.method)||this.t.set(t.method,[]),this.t.get(t.method).push(t)}unregisterRoute(t){if(!this.t.has(t.method))throw new s("unregister-route-but-not-found-with-method",{method:t.method});const e=this.t.get(t.method).indexOf(t);if(!(e>-1))throw new s("unregister-route-route-not-registered");this.t.get(t.method).splice(e,1)}}let o;const c=()=>(o||(o=new a,o.addFetchListener(),o.addCacheListener()),o);function h(t,e,n){let a;if("string"==typeof t){const s=new URL(t,location.href);a=new i(({url:t})=>t.href===s.href,e,n)}else if(t instanceof RegExp)a=new r(t,e,n);else if("function"==typeof t)a=new i(t,e,n);else{if(!(t instanceof i))throw new s("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});a=t}return c().registerRoute(a),a}const u={googleAnalytics:"googleAnalytics",precache:"precache-v2",prefix:"workbox",runtime:"runtime",suffix:"undefined"!=typeof registration?registration.scope:""},l=t=>[u.prefix,t,u.suffix].filter(t=>t&&t.length>0).join("-"),f=t=>t||l(u.precache),w=t=>t||l(u.runtime);function d(t){t.then(()=>{})}const p=new Set;function y(){return y=Object.assign?Object.assign.bind():function(t){for(var e=1;e(t[e]=s,!0),has:(t,e)=>t instanceof IDBTransaction&&("done"===e||"store"===e)||e in t};function x(t){return t!==IDBDatabase.prototype.transaction||"objectStoreNames"in IDBTransaction.prototype?(g||(g=[IDBCursor.prototype.advance,IDBCursor.prototype.continue,IDBCursor.prototype.continuePrimaryKey])).includes(t)?function(...e){return t.apply(E(this),e),L(R.get(this))}:function(...e){return L(t.apply(E(this),e))}:function(e,...s){const n=t.call(E(this),e,...s);return b.set(n,e.sort?e.sort():[e]),L(n)}}function I(t){return"function"==typeof t?x(t):(t instanceof IDBTransaction&&function(t){if(v.has(t))return;const e=new Promise((e,s)=>{const n=()=>{t.removeEventListener("complete",i),t.removeEventListener("error",r),t.removeEventListener("abort",r)},i=()=>{e(),n()},r=()=>{s(t.error||new DOMException("AbortError","AbortError")),n()};t.addEventListener("complete",i),t.addEventListener("error",r),t.addEventListener("abort",r)});v.set(t,e)}(t),e=t,(m||(m=[IDBDatabase,IDBObjectStore,IDBIndex,IDBCursor,IDBTransaction])).some(t=>e instanceof t)?new Proxy(t,U):t);var e}function L(t){if(t instanceof IDBRequest)return function(t){const e=new Promise((e,s)=>{const n=()=>{t.removeEventListener("success",i),t.removeEventListener("error",r)},i=()=>{e(L(t.result)),n()},r=()=>{s(t.error),n()};t.addEventListener("success",i),t.addEventListener("error",r)});return e.then(e=>{e instanceof IDBCursor&&R.set(e,t)}).catch(()=>{}),D.set(e,t),e}(t);if(q.has(t))return q.get(t);const e=I(t);return e!==t&&(q.set(t,e),D.set(e,t)),e}const E=t=>D.get(t);const C=["get","getKey","getAll","getAllKeys","count"],N=["put","add","delete","clear"],O=new Map;function k(t,e){if(!(t instanceof IDBDatabase)||e in t||"string"!=typeof e)return;if(O.get(e))return O.get(e);const s=e.replace(/FromIndex$/,""),n=e!==s,i=N.includes(s);if(!(s in(n?IDBIndex:IDBObjectStore).prototype)||!i&&!C.includes(s))return;const r=async function(t,...e){const r=this.transaction(t,i?"readwrite":"readonly");let a=r.store;return n&&(a=a.index(e.shift())),(await Promise.all([a[s](...e),i&&r.done]))[0]};return O.set(e,r),r}U=(t=>y({},t,{get:(e,s,n)=>k(e,s)||t.get(e,s,n),has:(e,s)=>!!k(e,s)||t.has(e,s)}))(U);try{self["workbox:expiration:7.4.0"]&&_()}catch(t){}const B="cache-entries",T=t=>{const e=new URL(t,location.href);return e.hash="",e.href};class P{constructor(t){this.h=null,this.u=t}l(t){const e=t.createObjectStore(B,{keyPath:"id"});e.createIndex("cacheName","cacheName",{unique:!1}),e.createIndex("timestamp","timestamp",{unique:!1})}p(t){this.l(t),this.u&&function(t,{blocked:e}={}){const s=indexedDB.deleteDatabase(t);e&&s.addEventListener("blocked",t=>e(t.oldVersion,t)),L(s).then(()=>{})}(this.u)}async setTimestamp(t,e){const s={url:t=T(t),timestamp:e,cacheName:this.u,id:this.m(t)},n=(await this.getDb()).transaction(B,"readwrite",{durability:"relaxed"});await n.store.put(s),await n.done}async getTimestamp(t){const e=await this.getDb(),s=await e.get(B,this.m(t));return null==s?void 0:s.timestamp}async expireEntries(t,e){const s=await this.getDb();let n=await s.transaction(B).store.index("timestamp").openCursor(null,"prev");const i=[];let r=0;for(;n;){const s=n.value;s.cacheName===this.u&&(t&&s.timestamp=e?i.push(n.value):r++),n=await n.continue()}const a=[];for(const t of i)await s.delete(B,t.id),a.push(t.url);return a}m(t){return this.u+"|"+T(t)}async getDb(){return this.h||(this.h=await function(t,e,{blocked:s,upgrade:n,blocking:i,terminated:r}={}){const a=indexedDB.open(t,e),o=L(a);return n&&a.addEventListener("upgradeneeded",t=>{n(L(a.result),t.oldVersion,t.newVersion,L(a.transaction),t)}),s&&a.addEventListener("blocked",t=>s(t.oldVersion,t.newVersion,t)),o.then(t=>{r&&t.addEventListener("close",()=>r()),i&&t.addEventListener("versionchange",t=>i(t.oldVersion,t.newVersion,t))}).catch(()=>{}),o}("workbox-expiration",1,{upgrade:this.p.bind(this)})),this.h}}class M{constructor(t,e={}){this.R=!1,this.v=!1,this.q=e.maxEntries,this.D=e.maxAgeSeconds,this.U=e.matchOptions,this.u=t,this._=new P(t)}async expireEntries(){if(this.R)return void(this.v=!0);this.R=!0;const t=this.D?Date.now()-1e3*this.D:0,e=await this._.expireEntries(t,this.q),s=await self.caches.open(this.u);for(const t of e)await s.delete(t,this.U);this.R=!1,this.v&&(this.v=!1,d(this.expireEntries()))}async updateTimestamp(t){await this._.setTimestamp(t,Date.now())}async isURLExpired(t){if(this.D){const e=await this._.getTimestamp(t),s=Date.now()-1e3*this.D;return void 0===e||e200===t.status||0===t.status?t:null};function j(t,e){const s=new URL(t);for(const t of e)s.searchParams.delete(t);return s.href}class S{constructor(){this.promise=new Promise((t,e)=>{this.resolve=t,this.reject=e})}}function K(t){return"string"==typeof t?new Request(t):t}class A{constructor(t,e){this.I={},Object.assign(this,e),this.event=e.event,this.L=t,this.C=new S,this.N=[],this.O=[...t.plugins],this.k=new Map;for(const t of this.O)this.k.set(t,{});this.event.waitUntil(this.C.promise)}async fetch(t){const{event:e}=this;let n=K(t);if("navigate"===n.mode&&e instanceof FetchEvent&&e.preloadResponse){const t=await e.preloadResponse;if(t)return t}const i=this.hasCallback("fetchDidFail")?n.clone():null;try{for(const t of this.iterateCallbacks("requestWillFetch"))n=await t({request:n.clone(),event:e})}catch(t){if(t instanceof Error)throw new s("plugin-error-request-will-fetch",{thrownErrorMessage:t.message})}const r=n.clone();try{let t;t=await fetch(n,"navigate"===n.mode?void 0:this.L.fetchOptions);for(const s of this.iterateCallbacks("fetchDidSucceed"))t=await s({event:e,request:r,response:t});return t}catch(t){throw i&&await this.runCallbacks("fetchDidFail",{error:t,event:e,originalRequest:i.clone(),request:r.clone()}),t}}async fetchAndCachePut(t){const e=await this.fetch(t),s=e.clone();return this.waitUntil(this.cachePut(t,s)),e}async cacheMatch(t){const e=K(t);let s;const{cacheName:n,matchOptions:i}=this.L,r=await this.getCacheKey(e,"read"),a=Object.assign(Object.assign({},i),{cacheName:n});s=await caches.match(r,a);for(const t of this.iterateCallbacks("cachedResponseWillBeUsed"))s=await t({cacheName:n,matchOptions:i,cachedResponse:s,request:r,event:this.event})||void 0;return s}async cachePut(t,e){const n=K(t);var i;await(i=0,new Promise(t=>setTimeout(t,i)));const r=await this.getCacheKey(n,"write");if(!e)throw new s("cache-put-with-no-response",{url:(a=r.url,new URL(String(a),location.href).href.replace(new RegExp(`^${location.origin}`),""))});var a;const o=await this.B(e);if(!o)return!1;const{cacheName:c,matchOptions:h}=this.L,u=await self.caches.open(c),l=this.hasCallback("cacheDidUpdate"),f=l?await async function(t,e,s,n){const i=j(e.url,s);if(e.url===i)return t.match(e,n);const r=Object.assign(Object.assign({},n),{ignoreSearch:!0}),a=await t.keys(e,r);for(const e of a)if(i===j(e.url,s))return t.match(e,n)}(u,r.clone(),["__WB_REVISION__"],h):null;try{await u.put(r,l?o.clone():o)}catch(t){if(t instanceof Error)throw"QuotaExceededError"===t.name&&await async function(){for(const t of p)await t()}(),t}for(const t of this.iterateCallbacks("cacheDidUpdate"))await t({cacheName:c,oldResponse:f,newResponse:o.clone(),request:r,event:this.event});return!0}async getCacheKey(t,e){const s=`${t.url} | ${e}`;if(!this.I[s]){let n=t;for(const t of this.iterateCallbacks("cacheKeyWillBeUsed"))n=K(await t({mode:e,request:n,event:this.event,params:this.params}));this.I[s]=n}return this.I[s]}hasCallback(t){for(const e of this.L.plugins)if(t in e)return!0;return!1}async runCallbacks(t,e){for(const s of this.iterateCallbacks(t))await s(e)}*iterateCallbacks(t){for(const e of this.L.plugins)if("function"==typeof e[t]){const s=this.k.get(e),n=n=>{const i=Object.assign(Object.assign({},n),{state:s});return e[t](i)};yield n}}waitUntil(t){return this.N.push(t),t}async doneWaiting(){for(;this.N.length;){const t=this.N.splice(0),e=(await Promise.allSettled(t)).find(t=>"rejected"===t.status);if(e)throw e.reason}}destroy(){this.C.resolve(null)}async B(t){let e=t,s=!1;for(const t of this.iterateCallbacks("cacheWillUpdate"))if(e=await t({request:this.request,response:e,event:this.event})||void 0,s=!0,!e)break;return s||e&&200!==e.status&&(e=void 0),e}}class F{constructor(t={}){this.cacheName=w(t.cacheName),this.plugins=t.plugins||[],this.fetchOptions=t.fetchOptions,this.matchOptions=t.matchOptions}handle(t){const[e]=this.handleAll(t);return e}handleAll(t){t instanceof FetchEvent&&(t={event:t,request:t.request});const e=t.event,s="string"==typeof t.request?new Request(t.request):t.request,n="params"in t?t.params:void 0,i=new A(this,{event:e,request:s,params:n}),r=this.T(i,s,e);return[r,this.P(r,i,s,e)]}async T(t,e,n){let i;await t.runCallbacks("handlerWillStart",{event:n,request:e});try{if(i=await this.M(e,t),!i||"error"===i.type)throw new s("no-response",{url:e.url})}catch(s){if(s instanceof Error)for(const r of t.iterateCallbacks("handlerDidError"))if(i=await r({error:s,event:n,request:e}),i)break;if(!i)throw s}for(const s of t.iterateCallbacks("handlerWillRespond"))i=await s({event:n,request:e,response:i});return i}async P(t,e,s,n){let i,r;try{i=await t}catch(r){}try{await e.runCallbacks("handlerDidRespond",{event:n,request:s,response:i}),await e.doneWaiting()}catch(t){t instanceof Error&&(r=t)}if(await e.runCallbacks("handlerDidComplete",{event:n,request:s,response:i,error:r}),e.destroy(),r)throw r}}function H(t,e){const s=e();return t.waitUntil(s),s}try{self["workbox:precaching:7.4.0"]&&_()}catch(t){}function $(t){if(!t)throw new s("add-to-cache-list-unexpected-type",{entry:t});if("string"==typeof t){const e=new URL(t,location.href);return{cacheKey:e.href,url:e.href}}const{revision:e,url:n}=t;if(!n)throw new s("add-to-cache-list-unexpected-type",{entry:t});if(!e){const t=new URL(n,location.href);return{cacheKey:t.href,url:t.href}}const i=new URL(n,location.href),r=new URL(n,location.href);return i.searchParams.set("__WB_REVISION__",e),{cacheKey:i.href,url:r.href}}class G{constructor(){this.updatedURLs=[],this.notUpdatedURLs=[],this.handlerWillStart=async({request:t,state:e})=>{e&&(e.originalRequest=t)},this.cachedResponseWillBeUsed=async({event:t,state:e,cachedResponse:s})=>{if("install"===t.type&&e&&e.originalRequest&&e.originalRequest instanceof Request){const t=e.originalRequest.url;s?this.notUpdatedURLs.push(t):this.updatedURLs.push(t)}return s}}}class V{constructor({precacheController:t}){this.cacheKeyWillBeUsed=async({request:t,params:e})=>{const s=(null==e?void 0:e.cacheKey)||this.W.getCacheKeyForURL(t.url);return s?new Request(s,{headers:t.headers}):t},this.W=t}}let J,Q;async function z(t,e){let n=null;if(t.url){n=new URL(t.url).origin}if(n!==self.location.origin)throw new s("cross-origin-copy-response",{origin:n});const i=t.clone(),r={headers:new Headers(i.headers),status:i.status,statusText:i.statusText},a=function(){if(void 0===J){const t=new Response("");if("body"in t)try{new Response(t.body),J=!0}catch(t){J=!1}J=!1}return J}()?i.body:await i.blob();return new Response(a,r)}class X extends F{constructor(t={}){t.cacheName=f(t.cacheName),super(t),this.j=!1!==t.fallbackToNetwork,this.plugins.push(X.copyRedirectedCacheableResponsesPlugin)}async M(t,e){const s=await e.cacheMatch(t);return s||(e.event&&"install"===e.event.type?await this.S(t,e):await this.K(t,e))}async K(t,e){let n;const i=e.params||{};if(!this.j)throw new s("missing-precache-entry",{cacheName:this.cacheName,url:t.url});{const s=i.integrity,r=t.integrity,a=!r||r===s;n=await e.fetch(new Request(t,{integrity:"no-cors"!==t.mode?r||s:void 0})),s&&a&&"no-cors"!==t.mode&&(this.A(),await e.cachePut(t,n.clone()))}return n}async S(t,e){this.A();const n=await e.fetch(t);if(!await e.cachePut(t,n.clone()))throw new s("bad-precaching-response",{url:t.url,status:n.status});return n}A(){let t=null,e=0;for(const[s,n]of this.plugins.entries())n!==X.copyRedirectedCacheableResponsesPlugin&&(n===X.defaultPrecacheCacheabilityPlugin&&(t=s),n.cacheWillUpdate&&e++);0===e?this.plugins.push(X.defaultPrecacheCacheabilityPlugin):e>1&&null!==t&&this.plugins.splice(t,1)}}X.defaultPrecacheCacheabilityPlugin={cacheWillUpdate:async({response:t})=>!t||t.status>=400?null:t},X.copyRedirectedCacheableResponsesPlugin={cacheWillUpdate:async({response:t})=>t.redirected?await z(t):t};class Y{constructor({cacheName:t,plugins:e=[],fallbackToNetwork:s=!0}={}){this.F=new Map,this.H=new Map,this.$=new Map,this.L=new X({cacheName:f(t),plugins:[...e,new V({precacheController:this})],fallbackToNetwork:s}),this.install=this.install.bind(this),this.activate=this.activate.bind(this)}get strategy(){return this.L}precache(t){this.addToCacheList(t),this.G||(self.addEventListener("install",this.install),self.addEventListener("activate",this.activate),this.G=!0)}addToCacheList(t){const e=[];for(const n of t){"string"==typeof n?e.push(n):n&&void 0===n.revision&&e.push(n.url);const{cacheKey:t,url:i}=$(n),r="string"!=typeof n&&n.revision?"reload":"default";if(this.F.has(i)&&this.F.get(i)!==t)throw new s("add-to-cache-list-conflicting-entries",{firstEntry:this.F.get(i),secondEntry:t});if("string"!=typeof n&&n.integrity){if(this.$.has(t)&&this.$.get(t)!==n.integrity)throw new s("add-to-cache-list-conflicting-integrities",{url:i});this.$.set(t,n.integrity)}if(this.F.set(i,t),this.H.set(i,r),e.length>0){const t=`Workbox is precaching URLs without revision info: ${e.join(", ")}\nThis is generally NOT safe. Learn more at https://bit.ly/wb-precache`;console.warn(t)}}}install(t){return H(t,async()=>{const e=new G;this.strategy.plugins.push(e);for(const[e,s]of this.F){const n=this.$.get(s),i=this.H.get(e),r=new Request(e,{integrity:n,cache:i,credentials:"same-origin"});await Promise.all(this.strategy.handleAll({params:{cacheKey:s},request:r,event:t}))}const{updatedURLs:s,notUpdatedURLs:n}=e;return{updatedURLs:s,notUpdatedURLs:n}})}activate(t){return H(t,async()=>{const t=await self.caches.open(this.strategy.cacheName),e=await t.keys(),s=new Set(this.F.values()),n=[];for(const i of e)s.has(i.url)||(await t.delete(i),n.push(i.url));return{deletedURLs:n}})}getURLsToCacheKeys(){return this.F}getCachedURLs(){return[...this.F.keys()]}getCacheKeyForURL(t){const e=new URL(t,location.href);return this.F.get(e.href)}getIntegrityForCacheKey(t){return this.$.get(t)}async matchPrecache(t){const e=t instanceof Request?t.url:t,s=this.getCacheKeyForURL(e);if(s){return(await self.caches.open(this.strategy.cacheName)).match(s)}}createHandlerBoundToURL(t){const e=this.getCacheKeyForURL(t);if(!e)throw new s("non-precached-url",{url:t});return s=>(s.request=new Request(t),s.params=Object.assign({cacheKey:e},s.params),this.strategy.handle(s))}}const Z=()=>(Q||(Q=new Y),Q);class tt extends i{constructor(t,e){super(({request:s})=>{const n=t.getURLsToCacheKeys();for(const i of function*(t,{ignoreURLParametersMatching:e=[/^utm_/,/^fbclid$/],directoryIndex:s="index.html",cleanURLs:n=!0,urlManipulation:i}={}){const r=new URL(t,location.href);r.hash="",yield r.href;const a=function(t,e=[]){for(const s of[...t.searchParams.keys()])e.some(t=>t.test(s))&&t.searchParams.delete(s);return t}(r,e);if(yield a.href,s&&a.pathname.endsWith("/")){const t=new URL(a.href);t.pathname+=s,yield t.href}if(n){const t=new URL(a.href);t.pathname+=".html",yield t.href}if(i){const t=i({url:r});for(const e of t)yield e.href}}(s.url,e)){const e=n.get(i);if(e){return{cacheKey:e,integrity:t.getIntegrityForCacheKey(e)}}}},t.strategy)}}t.ExpirationPlugin=class{constructor(t={}){this.cachedResponseWillBeUsed=async({event:t,request:e,cacheName:s,cachedResponse:n})=>{if(!n)return null;const i=this.V(n),r=this.J(s);d(r.expireEntries());const a=r.updateTimestamp(e.url);if(t)try{t.waitUntil(a)}catch(t){}return i?n:null},this.cacheDidUpdate=async({cacheName:t,request:e})=>{const s=this.J(t);await s.updateTimestamp(e.url),await s.expireEntries()},this.X=t,this.D=t.maxAgeSeconds,this.Y=new Map,t.purgeOnQuotaError&&function(t){p.add(t)}(()=>this.deleteCacheAndMetadata())}J(t){if(t===w())throw new s("expire-custom-caches-only");let e=this.Y.get(t);return e||(e=new M(t,this.X),this.Y.set(t,e)),e}V(t){if(!this.D)return!0;const e=this.Z(t);if(null===e)return!0;return e>=Date.now()-1e3*this.D}Z(t){if(!t.headers.has("date"))return null;const e=t.headers.get("date"),s=new Date(e).getTime();return isNaN(s)?null:s}async deleteCacheAndMetadata(){for(const[t,e]of this.Y)await self.caches.delete(t),await e.delete();this.Y=new Map}},t.NetworkFirst=class extends F{constructor(t={}){super(t),this.plugins.some(t=>"cacheWillUpdate"in t)||this.plugins.unshift(W),this.tt=t.networkTimeoutSeconds||0}async M(t,e){const n=[],i=[];let r;if(this.tt){const{id:s,promise:a}=this.et({request:t,logs:n,handler:e});r=s,i.push(a)}const a=this.st({timeoutId:r,request:t,logs:n,handler:e});i.push(a);const o=await e.waitUntil((async()=>await e.waitUntil(Promise.race(i))||await a)());if(!o)throw new s("no-response",{url:t.url});return o}et({request:t,logs:e,handler:s}){let n;return{promise:new Promise(e=>{n=setTimeout(async()=>{e(await s.cacheMatch(t))},1e3*this.tt)}),id:n}}async st({timeoutId:t,request:e,logs:s,handler:n}){let i,r;try{r=await n.fetchAndCachePut(e)}catch(t){t instanceof Error&&(i=t)}return t&&clearTimeout(t),!i&&r||(r=await n.cacheMatch(e)),r}},t.cleanupOutdatedCaches=function(){self.addEventListener("activate",t=>{const e=f();t.waitUntil((async(t,e="-precache-")=>{const s=(await self.caches.keys()).filter(s=>s.includes(e)&&s.includes(self.registration.scope)&&s!==t);return await Promise.all(s.map(t=>self.caches.delete(t))),s})(e).then(t=>{}))})},t.precacheAndRoute=function(t,e){!function(t){Z().precache(t)}(t),function(t){const e=Z();h(new tt(e,t))}(e)},t.registerRoute=h}); diff --git a/tools/ui/docs/architecture/high-level-architecture-simplified.md b/tools/ui/docs/architecture/high-level-architecture-simplified.md new file mode 100644 index 0000000000000000000000000000000000000000..500f477c9a4cf1164545d1bb1a42703fe0166bc5 --- /dev/null +++ b/tools/ui/docs/architecture/high-level-architecture-simplified.md @@ -0,0 +1,145 @@ +```mermaid +flowchart TB + subgraph Routes["📍 Routes"] + R1["/ (Welcome)"] + R2["/chat/[id]"] + RL["+layout.svelte"] + end + + subgraph Components["🧩 Components"] + C_Sidebar["ChatSidebar"] + C_Screen["ChatScreen"] + C_Form["ChatForm"] + C_Messages["ChatMessages"] + C_Message["ChatMessage"] + C_ChatMessageAgenticContent["ChatMessageAgenticContent"] + C_MessageEditForm["ChatMessageEditForm"] + C_ModelsSelector["ModelsSelector"] + C_Settings["ChatSettings"] + C_McpSettings["McpServersSettings"] + C_McpResourceBrowser["McpResourceBrowser"] + C_McpServersSelector["McpServersSelector"] + end + + subgraph Hooks["🪝 Hooks"] + H1["useModelChangeValidation"] + H2["useProcessingState"] + end + + subgraph Stores["🗄️ Stores"] + S1["chatStore
      Chat interactions & streaming"] + SA["agenticStore
      Multi-turn agentic loop orchestration"] + S2["conversationsStore
      Conversation data, messages & MCP overrides"] + S3["modelsStore
      Model selection & loading"] + S4["serverStore
      Server props & role detection"] + S5["settingsStore
      User configuration incl. MCP"] + S6["mcpStore
      MCP servers, tools, prompts"] + S7["mcpResourceStore
      MCP resources & attachments"] + end + + subgraph Services["⚙️ Services"] + SV1["ChatService"] + SV2["ModelsService"] + SV3["PropsService"] + SV4["DatabaseService"] + SV5["ParameterSyncService"] + SV6["MCPService
      protocol operations"] + end + + subgraph Storage["💾 Storage"] + ST1["IndexedDB
      conversations, messages"] + ST2["LocalStorage
      config, userOverrides, mcpServers"] + end + + subgraph APIs["🌐 llama-server API"] + API1["/v1/chat/completions"] + API2["/props"] + API3["/models/*"] + API4["/v1/models"] + end + + subgraph ExternalMCP["🔌 External MCP Servers"] + EXT1["MCP Server 1
      WebSocket/HTTP/SSE"] + EXT2["MCP Server N"] + end + + %% Routes → Components + R1 & R2 --> C_Screen + RL --> C_Sidebar + + %% Layout runs MCP health checks + RL --> S6 + + %% Component hierarchy + C_Screen --> C_Form & C_Messages & C_Settings + C_Messages --> C_Message + C_Message --> C_ChatMessageAgenticContent + C_Message --> C_MessageEditForm + C_Form & C_MessageEditForm --> C_ModelsSelector + C_Form --> C_McpServersSelector + C_Settings --> C_McpSettings + C_McpSettings --> C_McpResourceBrowser + + %% Components → Hooks → Stores + C_Form & C_Messages --> H1 & H2 + H1 --> S3 & S4 + H2 --> S1 & S5 + + %% Components → Stores + C_Screen --> S1 & S2 + C_Sidebar --> S2 + C_ModelsSelector --> S3 & S4 + C_Settings --> S5 + C_McpSettings --> S6 + C_McpResourceBrowser --> S6 & S7 + C_McpServersSelector --> S6 + C_Form --> S6 + + %% chatStore → agenticStore → mcpStore (agentic loop) + S1 --> SA + SA --> SV1 + SA --> S6 + + %% Stores → Services + S1 --> SV1 & SV4 + S2 --> SV4 + S3 --> SV2 & SV3 + S4 --> SV3 + S5 --> SV5 + S6 --> SV6 + S7 --> SV6 + + %% Services → Storage + SV4 --> ST1 + SV5 --> ST2 + + %% Services → APIs + SV1 --> API1 + SV2 --> API3 & API4 + SV3 --> API2 + + %% MCP → External Servers + SV6 --> EXT1 & EXT2 + + %% Styling + classDef routeStyle fill:#e1f5fe,stroke:#01579b,stroke-width:2px + classDef componentStyle fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px + classDef hookStyle fill:#fff8e1,stroke:#ff8f00,stroke-width:2px + classDef storeStyle fill:#fff3e0,stroke:#e65100,stroke-width:2px + classDef serviceStyle fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px + classDef storageStyle fill:#fce4ec,stroke:#c2185b,stroke-width:2px + classDef apiStyle fill:#e3f2fd,stroke:#1565c0,stroke-width:2px + classDef mcpStyle fill:#e0f2f1,stroke:#00695c,stroke-width:2px + classDef agenticStyle fill:#e8eaf6,stroke:#283593,stroke-width:2px + classDef externalStyle fill:#f3e5f5,stroke:#6a1b9a,stroke-width:2px,stroke-dasharray: 5 5 + + class R1,R2,RL routeStyle + class C_Sidebar,C_Screen,C_Form,C_Messages,C_Message,C_ChatMessageAgenticContent,C_MessageEditForm,C_ModelsSelector,C_Settings componentStyle + class C_McpSettings,C_McpResourceBrowser,C_McpServersSelector componentStyle + class H1,H2 hookStyle + class S1,S2,S3,S4,S5,SA,S6,S7 storeStyle + class SV1,SV2,SV3,SV4,SV5,SV6 serviceStyle + class ST1,ST2 storageStyle + class API1,API2,API3,API4 apiStyle + class EXT1,EXT2 externalStyle +``` diff --git a/tools/ui/docs/architecture/high-level-architecture.md b/tools/ui/docs/architecture/high-level-architecture.md new file mode 100644 index 0000000000000000000000000000000000000000..42ddb3f4f5ba57be9373a9141fe50154bcb92de6 --- /dev/null +++ b/tools/ui/docs/architecture/high-level-architecture.md @@ -0,0 +1,373 @@ +```mermaid +flowchart TB +subgraph Routes["📍 Routes"] +R1["/ (+page.svelte)"] +R2["/chat/[id]"] +RL["+layout.svelte"] +end + + subgraph Components["🧩 Components"] + direction TB + subgraph LayoutComponents["Layout"] + C_Sidebar["ChatSidebar"] + C_Screen["ChatScreen"] + end + subgraph ChatUIComponents["Chat UI"] + C_Form["ChatForm"] + C_Messages["ChatMessages"] + C_Message["ChatMessage"] + C_MessageUser["ChatMessageUser"] + C_MessageEditForm["ChatMessageEditForm"] + C_Attach["ChatAttachments"] + C_ModelsSelector["ModelsSelector"] + C_Settings["ChatSettings"] + end + subgraph MCPComponents["MCP UI"] + C_McpSettings["McpServersSettings"] + C_McpServerCard["McpServerCard"] + C_McpResourceBrowser["McpResourceBrowser"] + C_McpResourcePreview["McpResourcePreview"] + C_McpServersSelector["McpServersSelector"] + end + end + + subgraph Hooks["🪝 Hooks"] + H1["useModelChangeValidation"] + H2["useProcessingState"] + H3["isMobile"] + end + + subgraph Stores["🗄️ Stores"] + direction TB + subgraph S1["chatStore"] + S1State["State:
      isLoading, currentResponse
      errorDialogState
      activeProcessingState
      chatLoadingStates
      chatStreamingStates
      abortControllers
      processingStates
      activeConversationId
      isStreamingActive"] + S1LoadState["Loading State:
      setChatLoading()
      isChatLoading()
      syncLoadingStateForChat()
      clearUIState()
      isChatLoadingPublic()
      getAllLoadingChats()
      getAllStreamingChats()"] + S1ProcState["Processing State:
      setActiveProcessingConversation()
      getProcessingState()
      clearProcessingState()
      getActiveProcessingState()
      updateProcessingStateFromTimings()
      getCurrentProcessingStateSync()
      restoreProcessingStateFromMessages()"] + S1Stream["Streaming:
      streamChatCompletion()
      startStreaming()
      stopStreaming()
      stopGeneration()
      isStreaming()"] + S1Error["Error Handling:
      showErrorDialog()
      dismissErrorDialog()
      isAbortError()"] + S1Msg["Message Operations:
      addMessage()
      sendMessage()
      updateMessage()
      deleteMessage()
      getDeletionInfo()"] + S1Regen["Regeneration:
      regenerateMessage()
      regenerateMessageWithBranching()
      continueAssistantMessage()"] + S1Edit["Editing:
      editAssistantMessage()
      editUserMessagePreserveResponses()
      editMessageWithBranching()
      clearEditMode()
      isEditModeActive()
      getAddFilesHandler()
      setEditModeActive()"] + S1Utils["Utilities:
      getApiOptions()
      parseTimingData()
      getOrCreateAbortController()
      getConversationModel()"] + end + subgraph SA["agenticStore"] + SAState["State:
      sessions (Map)
      isAnyRunning"] + SASession["Session Management:
      getSession()
      updateSession()
      clearSession()
      getActiveSessions()
      isRunning()
      currentTurn()
      totalToolCalls()
      lastError()
      streamingToolCall()"] + SAConfig["Configuration:
      getConfig()
      maxTurns, maxToolPreviewLines"] + SAFlow["Agentic Loop:
      runAgenticFlow()
      executeAgenticLoop()
      normalizeToolCalls()
      emitToolCallResult()
      extractBase64Attachments()"] + end + subgraph S2["conversationsStore"] + S2State["State:
      conversations
      activeConversation
      activeMessages
      isInitialized
      pendingMcpServerOverrides
      titleUpdateConfirmationCallback"] + S2Lifecycle["Lifecycle:
      initialize()
      loadConversations()
      clearActiveConversation()"] + S2ConvCRUD["Conversation CRUD:
      createConversation()
      loadConversation()
      deleteConversation()
      deleteAll()
      updateConversationName()
      updateConversationTitleWithConfirmation()"] + S2MsgMgmt["Message Management:
      refreshActiveMessages()
      addMessageToActive()
      updateMessageAtIndex()
      findMessageIndex()
      sliceActiveMessages()
      removeMessageAtIndex()
      getConversationMessages()"] + S2Nav["Navigation:
      navigateToSibling()
      updateCurrentNode()
      updateConversationTimestamp()"] + S2McpOverrides["MCP Per-Chat Overrides:
      getMcpServerOverride()
      getAllMcpServerOverrides()
      setMcpServerOverride()
      toggleMcpServerForChat()
      removeMcpServerOverride()
      isMcpServerEnabledForChat()
      clearPendingMcpServerOverrides()"] + S2Export["Import/Export:
      downloadConversation()
      exportAllConversations()
      importConversations()
      importConversationsData()
      triggerDownload()"] + S2Utils["Utilities:
      setTitleUpdateConfirmationCallback()"] + end + subgraph S3["modelsStore"] + S3State["State:
      models, routerModels
      selectedModelId
      selectedModelName
      loading, updating, error
      modelLoadingStates
      modelPropsCache
      modelPropsFetching
      propsCacheVersion"] + S3Getters["Computed Getters:
      selectedModel
      loadedModelIds
      loadingModelIds
      singleModelName"] + S3Modal["Modalities:
      getModelModalities()
      modelSupportsVision()
      modelSupportsAudio()
      getModelModalitiesArray()
      getModelProps()
      updateModelModalities()"] + S3Status["Status Queries:
      isModelLoaded()
      isModelOperationInProgress()
      getModelStatus()
      isModelPropsFetching()"] + S3Fetch["Data Fetching:
      fetch()
      fetchRouterModels()
      fetchModelProps()
      fetchModalitiesForLoadedModels()"] + S3Select["Model Selection:
      selectModelById()
      selectModelByName()
      clearSelection()
      findModelByName()
      findModelById()
      hasModel()"] + S3LoadUnload["Loading/Unloading Models:
      loadModel()
      unloadModel()
      ensureModelLoaded()
      waitForModelStatus()
      pollForModelStatus()"] + S3Utils["Utilities:
      toDisplayName()
      clear()"] + end + subgraph S4["serverStore"] + S4State["State:
      props
      loading, error
      role
      fetchPromise"] + S4Getters["Getters:
      defaultParams
      contextSize
      isRouterMode
      isModelMode"] + S4Data["Data Handling:
      fetch()
      getErrorMessage()
      clear()"] + S4Utils["Utilities:
      detectRole()"] + end + subgraph S5["settingsStore"] + S5State["State:
      config
      theme
      isInitialized
      userOverrides"] + S5Lifecycle["Lifecycle:
      initialize()
      loadConfig()
      saveConfig()
      loadTheme()
      saveTheme()"] + S5Update["Config Updates:
      updateConfig()
      updateMultipleConfig()
      updateTheme()"] + S5Reset["Reset:
      resetConfig()
      resetTheme()
      resetAll()
      resetParameterToServerDefault()"] + S5Sync["Server Sync:
      syncWithServerDefaults()
      forceSyncWithServerDefaults()"] + S5Utils["Utilities:
      getConfig()
      getAllConfig()
      getParameterInfo()
      getParameterDiff()
      getServerDefaults()
      clearAllUserOverrides()"] + end + subgraph S6["mcpStore"] + S6State["State:
      isInitializing, error
      toolCount, connectedServers
      healthChecks (Map)
      connections (Map)
      toolsIndex (Map)"] + S6Lifecycle["Lifecycle:
      ensureInitialized()
      initialize()
      shutdown()
      acquireConnection()
      releaseConnection()"] + S6Health["Health Checks:
      runHealthCheck()
      runHealthChecksForServers()
      updateHealthCheck()
      getHealthCheckState()
      clearHealthCheck()"] + S6Servers["Server Management:
      getServers()
      addServer()
      updateServer()
      removeServer()
      getServerById()
      getServerDisplayName()"] + S6Tools["Tool Operations:
      getToolDefinitionsForLLM()
      getToolNames()
      hasTool()
      getToolServer()
      executeTool()
      executeToolByName()"] + S6Prompts["Prompt Operations:
      getAllPrompts()
      getPrompt()
      hasPromptsCapability()
      getPromptCompletions()"] + end + subgraph S7["mcpResourceStore"] + S7State["State:
      serverResources (Map)
      cachedResources (Map)
      subscriptions (Map)
      attachments[]
      isLoading"] + S7Resources["Resource Discovery:
      setServerResources()
      getServerResources()
      getAllResourceInfos()
      getAllTemplateInfos()
      clearServerResources()"] + S7Cache["Caching:
      cacheResourceContent()
      getCachedContent()
      invalidateCache()
      clearCache()"] + S7Subs["Subscriptions:
      addSubscription()
      removeSubscription()
      isSubscribed()
      handleResourceUpdate()"] + S7Attach["Attachments:
      addAttachment()
      updateAttachmentContent()
      removeAttachment()
      clearAttachments()
      toMessageExtras()"] + end + + subgraph ReactiveExports["⚡ Reactive Exports"] + direction LR + subgraph ChatExports["chatStore"] + RE1["isLoading()"] + RE2["currentResponse()"] + RE3["errorDialog()"] + RE4["activeProcessingState()"] + RE5["isChatStreaming()"] + RE6["isChatLoading()"] + RE7["getChatStreaming()"] + RE8["getAllLoadingChats()"] + RE9["getAllStreamingChats()"] + RE9a["isEditModeActive()"] + RE9b["getAddFilesHandler()"] + RE9c["setEditModeActive()"] + RE9d["clearEditMode()"] + end + subgraph AgenticExports["agenticStore"] + REA1["agenticIsRunning()"] + REA2["agenticCurrentTurn()"] + REA3["agenticTotalToolCalls()"] + REA4["agenticLastError()"] + REA5["agenticStreamingToolCall()"] + REA6["agenticIsAnyRunning()"] + end + subgraph ConvExports["conversationsStore"] + RE10["conversations()"] + RE11["activeConversation()"] + RE12["activeMessages()"] + RE13["isConversationsInitialized()"] + end + subgraph ModelsExports["modelsStore"] + RE15["modelOptions()"] + RE16["routerModels()"] + RE17["modelsLoading()"] + RE18["modelsUpdating()"] + RE19["modelsError()"] + RE20["selectedModelId()"] + RE21["selectedModelName()"] + RE22["selectedModelOption()"] + RE23["loadedModelIds()"] + RE24["loadingModelIds()"] + RE25["propsCacheVersion()"] + RE26["singleModelName()"] + end + subgraph ServerExports["serverStore"] + RE27["serverProps()"] + RE28["serverLoading()"] + RE29["serverError()"] + RE30["serverRole()"] + RE31["defaultParams()"] + RE32["contextSize()"] + RE33["isRouterMode()"] + RE34["isModelMode()"] + end + subgraph SettingsExports["settingsStore"] + RE35["config()"] + RE36["theme()"] + RE37["isInitialized()"] + end + subgraph MCPExports["mcpStore / mcpResourceStore"] + RE38["mcpResources()"] + RE39["mcpResourceAttachments()"] + RE40["mcpHasResourceAttachments()"] + RE41["mcpTotalResourceCount()"] + RE42["mcpResourcesLoading()"] + end + end + end + + subgraph Services["⚙️ Services"] + direction TB + subgraph SV1["ChatService"] + SV1Msg["Messaging:
      sendMessage()"] + SV1Stream["Streaming:
      handleStreamResponse()
      handleNonStreamResponse()"] + SV1Convert["Conversion:
      convertDbMessageToApiChatMessageData()
      mergeToolCallDeltas()"] + SV1Utils["Utilities:
      stripReasoningContent()
      extractModelName()
      parseErrorResponse()"] + end + subgraph SV2["ModelsService"] + SV2List["Listing:
      list()
      listRouter()"] + SV2LoadUnload["Load/Unload:
      load()
      unload()"] + SV2Status["Status:
      isModelLoaded()
      isModelLoading()"] + end + subgraph SV3["PropsService"] + SV3Fetch["Fetching:
      fetch()
      fetchForModel()"] + end + subgraph SV4["DatabaseService"] + SV4Conv["Conversations:
      createConversation()
      getConversation()
      getAllConversations()
      updateConversation()
      deleteConversation()"] + SV4Msg["Messages:
      createMessageBranch()
      createRootMessage()
      createSystemMessage()
      getConversationMessages()
      updateMessage()
      deleteMessage()
      deleteMessageCascading()"] + SV4Node["Navigation:
      updateCurrentNode()"] + SV4Import["Import:
      importConversations()"] + end + subgraph SV5["ParameterSyncService"] + SV5Extract["Extraction:
      extractServerDefaults()"] + SV5Merge["Merging:
      mergeWithServerDefaults()"] + SV5Info["Info:
      getParameterInfo()
      canSyncParameter()
      getSyncableParameterKeys()
      validateServerParameter()"] + SV5Diff["Diff:
      createParameterDiff()"] + end + subgraph SV6["MCPService"] + SV6Transport["Transport:
      createTransport()
      WebSocket / StreamableHTTP / SSE"] + SV6Conn["Connection:
      connect()
      disconnect()"] + SV6Tools["Tools:
      listTools()
      callTool()"] + SV6Prompts["Prompts:
      listPrompts()
      getPrompt()"] + SV6Resources["Resources:
      listResources()
      listResourceTemplates()
      readResource()
      subscribeResource()
      unsubscribeResource()"] + SV6Complete["Completions:
      complete()"] + end + end + + subgraph ExternalMCP["🔌 External MCP Servers"] + EXT1["MCP Server 1
      (WebSocket/StreamableHTTP/SSE)"] + EXT2["MCP Server N"] + end + + subgraph Storage["💾 Storage"] + ST1["IndexedDB"] + ST2["conversations"] + ST3["messages"] + ST5["LocalStorage"] + ST6["config"] + ST7["userOverrides"] + ST8["mcpServers"] + end + + subgraph APIs["🌐 llama-server API"] + API1["/v1/chat/completions"] + API2["/props
      /props?model="] + API3["/models
      /models/load
      /models/unload"] + API4["/v1/models"] + end + + %% Routes render Components + R1 --> C_Screen + R2 --> C_Screen + RL --> C_Sidebar + + %% Layout runs MCP health checks on startup + RL --> S6 + + %% Component hierarchy + C_Screen --> C_Form & C_Messages & C_Settings + C_Messages --> C_Message + C_Message --> C_MessageUser + C_MessageUser --> C_MessageEditForm + C_MessageEditForm --> C_ModelsSelector + C_MessageEditForm --> C_Attach + C_Form --> C_ModelsSelector + C_Form --> C_Attach + C_Form --> C_McpServersSelector + C_Message --> C_Attach + + %% MCP Components hierarchy + C_Settings --> C_McpSettings + C_McpSettings --> C_McpServerCard + C_McpServerCard --> C_McpResourceBrowser + C_McpResourceBrowser --> C_McpResourcePreview + + %% Components use Hooks + C_Form --> H1 + C_Message --> H1 & H2 + C_MessageEditForm --> H1 + C_Screen --> H2 + + %% Hooks use Stores + H1 --> S3 & S4 + H2 --> S1 & S5 + + %% Components use Stores + C_Screen --> S1 & S2 + C_Messages --> S2 + C_Message --> S1 & S2 & S3 + C_Form --> S1 & S3 & S6 + C_Sidebar --> S2 + C_ModelsSelector --> S3 & S4 + C_Settings --> S5 + C_McpSettings --> S6 + C_McpServerCard --> S6 + C_McpResourceBrowser --> S6 & S7 + C_McpServersSelector --> S6 + + %% Stores export Reactive State + S1 -. exports .-> ChatExports + SA -. exports .-> AgenticExports + S2 -. exports .-> ConvExports + S3 -. exports .-> ModelsExports + S4 -. exports .-> ServerExports + S5 -. exports .-> SettingsExports + S6 -. exports .-> MCPExports + S7 -. exports .-> MCPExports + + %% chatStore → agenticStore (agentic loop orchestration) + S1 --> SA + SA --> SV1 + SA --> S6 + + %% Stores use Services + S1 --> SV1 & SV4 + S2 --> SV4 + S3 --> SV2 & SV3 + S4 --> SV3 + S5 --> SV5 + S6 --> SV6 + S7 --> SV6 + + %% Services to Storage + SV4 --> ST1 + ST1 --> ST2 & ST3 + SV5 --> ST5 + ST5 --> ST6 & ST7 & ST8 + + %% Services to APIs + SV1 --> API1 + SV2 --> API3 & API4 + SV3 --> API2 + + %% MCP → External Servers + SV6 --> EXT1 & EXT2 + + %% Styling + classDef routeStyle fill:#e1f5fe,stroke:#01579b,stroke-width:2px + classDef componentStyle fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px + classDef componentGroupStyle fill:#e1bee7,stroke:#7b1fa2,stroke-width:1px + classDef hookStyle fill:#fff8e1,stroke:#ff8f00,stroke-width:2px + classDef storeStyle fill:#fff3e0,stroke:#e65100,stroke-width:2px + classDef stateStyle fill:#ffe0b2,stroke:#e65100,stroke-width:1px + classDef methodStyle fill:#ffecb3,stroke:#e65100,stroke-width:1px + classDef reactiveStyle fill:#fffde7,stroke:#f9a825,stroke-width:1px + classDef serviceStyle fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px + classDef serviceMStyle fill:#c8e6c9,stroke:#2e7d32,stroke-width:1px + classDef externalStyle fill:#f3e5f5,stroke:#6a1b9a,stroke-width:2px,stroke-dasharray: 5 5 + classDef storageStyle fill:#fce4ec,stroke:#c2185b,stroke-width:2px + classDef apiStyle fill:#e3f2fd,stroke:#1565c0,stroke-width:2px + + class R1,R2,RL routeStyle + class C_Sidebar,C_Screen,C_Form,C_Messages,C_Message,C_MessageUser,C_MessageEditForm componentStyle + class C_ModelsSelector,C_Settings componentStyle + class C_Attach componentStyle + class C_McpSettings,C_McpServerCard,C_McpResourceBrowser,C_McpResourcePreview,C_McpServersSelector componentStyle + class H1,H2,H3 hookStyle + class LayoutComponents,ChatUIComponents,MCPComponents componentGroupStyle + class Hooks hookStyle + classDef agenticStyle fill:#e8eaf6,stroke:#283593,stroke-width:2px + classDef agenticMethodStyle fill:#c5cae9,stroke:#283593,stroke-width:1px + + class S1,S2,S3,S4,S5,SA,S6,S7 storeStyle + class S1State,S2State,S3State,S4State,S5State,SAState,S6State,S7State stateStyle + class S1Msg,S1Regen,S1Edit,S1Stream,S1LoadState,S1ProcState,S1Error,S1Utils methodStyle + class SASession,SAConfig,SAFlow methodStyle + class S2Lifecycle,S2ConvCRUD,S2MsgMgmt,S2Nav,S2McpOverrides,S2Export,S2Utils methodStyle + class S3Getters,S3Modal,S3Status,S3Fetch,S3Select,S3LoadUnload,S3Utils methodStyle + class S4Getters,S4Data,S4Utils methodStyle + class S5Lifecycle,S5Update,S5Reset,S5Sync,S5Utils methodStyle + class S6Lifecycle,S6Health,S6Servers,S6Tools,S6Prompts methodStyle + class S7Resources,S7Cache,S7Subs,S7Attach methodStyle + class ChatExports,AgenticExports,ConvExports,ModelsExports,ServerExports,SettingsExports,MCPExports reactiveStyle + class SV1,SV2,SV3,SV4,SV5,SV6 serviceStyle + class SV6Transport,SV6Conn,SV6Tools,SV6Prompts,SV6Resources,SV6Complete serviceMStyle + class EXT1,EXT2 externalStyle + class SV1Msg,SV1Stream,SV1Convert,SV1Utils serviceMStyle + class SV2List,SV2LoadUnload,SV2Status serviceMStyle + class SV3Fetch serviceMStyle + class SV4Conv,SV4Msg,SV4Node,SV4Import serviceMStyle + class SV5Extract,SV5Merge,SV5Info,SV5Diff serviceMStyle + class ST1,ST2,ST3,ST5,ST6,ST7,ST8 storageStyle + class API1,API2,API3,API4 apiStyle +``` diff --git a/tools/ui/docs/flows/chat-flow.md b/tools/ui/docs/flows/chat-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..296693c6a541ed01c616db493f03e7dc5b238efd --- /dev/null +++ b/tools/ui/docs/flows/chat-flow.md @@ -0,0 +1,228 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 ChatForm / ChatMessage + participant chatStore as 🗄️ chatStore + participant agenticStore as 🗄️ agenticStore + participant convStore as 🗄️ conversationsStore + participant settingsStore as 🗄️ settingsStore + participant mcpStore as 🗄️ mcpStore + participant ChatSvc as ⚙️ ChatService + participant DbSvc as ⚙️ DatabaseService + participant API as 🌐 /v1/chat/completions + + Note over chatStore: State:
      isLoading, currentResponse
      errorDialogState, activeProcessingState
      chatLoadingStates (Map)
      chatStreamingStates (Map)
      abortControllers (Map)
      processingStates (Map) + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 💬 SEND MESSAGE + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>chatStore: sendMessage(content, extras) + activate chatStore + + chatStore->>chatStore: setChatLoading(convId, true) + chatStore->>chatStore: clearChatStreaming(convId) + + alt no active conversation + chatStore->>convStore: createConversation() + Note over convStore: → see conversations-flow.mmd + end + + chatStore->>mcpStore: consumeResourceAttachmentsAsExtras() + Note right of mcpStore: Converts pending MCP resource
      attachments into message extras + + chatStore->>chatStore: addMessage("user", content, extras) + chatStore->>DbSvc: createMessageBranch(userMsg, parentId) + chatStore->>convStore: addMessageToActive(userMsg) + chatStore->>convStore: updateCurrentNode(userMsg.id) + + chatStore->>chatStore: createAssistantMessage(userMsg.id) + chatStore->>DbSvc: createMessageBranch(assistantMsg, userMsg.id) + chatStore->>convStore: addMessageToActive(assistantMsg) + + chatStore->>chatStore: streamChatCompletion(messages, assistantMsg) + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🌊 STREAMING (with agentic flow detection) + %% ═══════════════════════════════════════════════════════════════════════════ + + activate chatStore + chatStore->>chatStore: startStreaming() + Note right of chatStore: isStreamingActive = true + + chatStore->>chatStore: setActiveProcessingConversation(convId) + chatStore->>chatStore: getOrCreateAbortController(convId) + Note right of chatStore: abortControllers.set(convId, new AbortController()) + + chatStore->>chatStore: getApiOptions() + Note right of chatStore: Merge from settingsStore.config:
      temperature, max_tokens, top_p, etc. + + alt agenticConfig.enabled && mcpStore has connected servers + chatStore->>agenticStore: runAgenticFlow(convId, messages, assistantMsg, options, signal) + Note over agenticStore: Multi-turn agentic loop:
      1. Call ChatService.sendMessage()
      2. If response has tool_calls → execute via mcpStore
      3. Append tool results as messages
      4. Loop until no more tool_calls or maxTurns
      → see agentic flow details below + agenticStore-->>chatStore: final response with timings + else standard (non-agentic) flow + chatStore->>ChatSvc: sendMessage(messages, options, signal) + end + + activate ChatSvc + + ChatSvc->>ChatSvc: convertDbMessageToApiChatMessageData(messages) + Note right of ChatSvc: DatabaseMessage[] → ApiChatMessageData[]
      Process attachments (images, PDFs, audio) + + ChatSvc->>API: POST /v1/chat/completions + Note right of API: {messages, model?, stream: true, ...params} + + loop SSE chunks + API-->>ChatSvc: data: {"choices":[{"delta":{...}}]} + ChatSvc->>ChatSvc: handleStreamResponse(response) + + alt content chunk + ChatSvc-->>chatStore: onChunk(content) + chatStore->>chatStore: setChatStreaming(convId, response, msgId) + Note right of chatStore: currentResponse = $state(accumulated) + chatStore->>convStore: updateMessageAtIndex(idx, {content}) + end + + alt reasoning chunk + ChatSvc-->>chatStore: onReasoningChunk(reasoning) + chatStore->>convStore: updateMessageAtIndex(idx, {thinking}) + end + + alt tool_calls chunk + ChatSvc-->>chatStore: onToolCallChunk(toolCalls) + chatStore->>convStore: updateMessageAtIndex(idx, {toolCalls}) + end + + alt model info + ChatSvc-->>chatStore: onModel(modelName) + chatStore->>chatStore: recordModel(modelName) + chatStore->>DbSvc: updateMessage(msgId, {model}) + end + + alt timings (during stream) + ChatSvc-->>chatStore: onTimings(timings, promptProgress) + chatStore->>chatStore: updateProcessingStateFromTimings() + end + + chatStore-->>UI: reactive $state update + end + + API-->>ChatSvc: data: [DONE] + ChatSvc-->>chatStore: onComplete(content, reasoning, timings, toolCalls) + deactivate ChatSvc + + chatStore->>chatStore: stopStreaming() + chatStore->>DbSvc: updateMessage(msgId, {content, timings, model}) + chatStore->>convStore: updateCurrentNode(msgId) + chatStore->>chatStore: setChatLoading(convId, false) + chatStore->>chatStore: clearChatStreaming(convId) + chatStore->>chatStore: clearProcessingState(convId) + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ⏹️ STOP GENERATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>chatStore: stopGeneration() + activate chatStore + chatStore->>chatStore: savePartialResponseIfNeeded(convId) + Note right of chatStore: Save currentResponse to DB if non-empty + chatStore->>chatStore: abortControllers.get(convId).abort() + Note right of chatStore: fetch throws AbortError → caught by isAbortError() + chatStore->>chatStore: stopStreaming() + chatStore->>chatStore: setChatLoading(convId, false) + chatStore->>chatStore: clearChatStreaming(convId) + chatStore->>chatStore: clearProcessingState(convId) + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🔁 REGENERATE + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>chatStore: regenerateMessageWithBranching(msgId, model?) + activate chatStore + chatStore->>convStore: findMessageIndex(msgId) + chatStore->>chatStore: Get parent of target message + chatStore->>chatStore: createAssistantMessage(parentId) + chatStore->>DbSvc: createMessageBranch(newAssistantMsg, parentId) + chatStore->>convStore: refreshActiveMessages() + Note right of chatStore: Same streaming flow + chatStore->>chatStore: streamChatCompletion(...) + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ➡️ CONTINUE + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>chatStore: continueAssistantMessage(msgId) + activate chatStore + chatStore->>chatStore: Get existing content from message + chatStore->>chatStore: streamChatCompletion(..., existingContent) + Note right of chatStore: Appends to existing message content + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ✏️ EDIT USER MESSAGE + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>chatStore: editMessageWithBranching(msgId, newContent, extras) + activate chatStore + chatStore->>chatStore: Get parent of target message + chatStore->>DbSvc: createMessageBranch(editedMsg, parentId) + chatStore->>convStore: refreshActiveMessages() + Note right of chatStore: Creates new branch, original preserved + chatStore->>chatStore: createAssistantMessage(editedMsg.id) + chatStore->>chatStore: streamChatCompletion(...) + Note right of chatStore: Automatically regenerates response + deactivate chatStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ❌ ERROR HANDLING + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over chatStore: On stream error (non-abort): + chatStore->>chatStore: showErrorDialog(type, message) + Note right of chatStore: errorDialogState = {type: 'timeout'|'server', message} + chatStore->>convStore: removeMessageAtIndex(failedMsgIdx) + chatStore->>DbSvc: deleteMessage(failedMsgId) + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🤖 AGENTIC LOOP (when agenticConfig.enabled) + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over agenticStore: agenticStore.runAgenticFlow(convId, messages, assistantMsg, options, signal) + activate agenticStore + agenticStore->>agenticStore: getSession(convId) or create new + agenticStore->>agenticStore: updateSession(turn: 0, running: true) + + loop executeAgenticLoop (until no tool_calls or maxTurns) + agenticStore->>agenticStore: turn++ + agenticStore->>ChatSvc: sendMessage(messages, options, signal) + ChatSvc->>API: POST /v1/chat/completions + API-->>ChatSvc: response with potential tool_calls + ChatSvc-->>agenticStore: onComplete(content, reasoning, timings, toolCalls) + + alt response has tool_calls + agenticStore->>agenticStore: normalizeToolCalls(toolCalls) + loop for each tool_call + agenticStore->>agenticStore: updateSession(streamingToolCall) + agenticStore->>mcpStore: executeTool(mcpCall, signal) + mcpStore-->>agenticStore: tool result + agenticStore->>agenticStore: extractBase64Attachments(result) + agenticStore->>agenticStore: emitToolCallResult(convId, ...) + agenticStore->>convStore: addMessageToActive(toolResultMsg) + agenticStore->>DbSvc: createMessageBranch(toolResultMsg) + end + agenticStore->>agenticStore: Create new assistantMsg for next turn + Note right of agenticStore: Continue loop with updated messages + else no tool_calls (final response) + agenticStore->>agenticStore: buildFinalTimings(allTurns) + Note right of agenticStore: Break loop, return final response + end + end + + agenticStore->>agenticStore: updateSession(running: false) + agenticStore-->>chatStore: final content, timings, model + deactivate agenticStore +``` diff --git a/tools/ui/docs/flows/conversations-flow.md b/tools/ui/docs/flows/conversations-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..bd2309bc03eb46547f30ac10f489402a2d97723b --- /dev/null +++ b/tools/ui/docs/flows/conversations-flow.md @@ -0,0 +1,183 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 ChatSidebar / ChatScreen + participant convStore as 🗄️ conversationsStore + participant chatStore as 🗄️ chatStore + participant DbSvc as ⚙️ DatabaseService + participant IDB as 💾 IndexedDB + + Note over convStore: State:
      conversations: DatabaseConversation[]
      activeConversation: DatabaseConversation | null
      activeMessages: DatabaseMessage[]
      isInitialized: boolean
      pendingMcpServerOverrides: Map<string, McpServerOverride> + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 🚀 INITIALIZATION + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over convStore: Auto-initialized in constructor (browser only) + convStore->>convStore: initialize() + activate convStore + convStore->>convStore: loadConversations() + convStore->>DbSvc: getAllConversations() + DbSvc->>IDB: SELECT * FROM conversations ORDER BY lastModified DESC + IDB-->>DbSvc: Conversation[] + DbSvc-->>convStore: conversations + convStore->>convStore: conversations = $state(data) + convStore->>convStore: isInitialized = true + deactivate convStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: ➕ CREATE CONVERSATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: createConversation(name?) + activate convStore + convStore->>DbSvc: createConversation(name || "New Chat") + DbSvc->>IDB: INSERT INTO conversations + IDB-->>DbSvc: conversation {id, name, lastModified, currNode: ""} + DbSvc-->>convStore: conversation + convStore->>convStore: conversations.unshift(conversation) + convStore->>convStore: activeConversation = $state(conversation) + convStore->>convStore: activeMessages = $state([]) + + alt pendingMcpServerOverrides has entries + loop each pending override + convStore->>DbSvc: Store MCP server override for new conversation + end + convStore->>convStore: clearPendingMcpServerOverrides() + end + deactivate convStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 📂 LOAD CONVERSATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: loadConversation(convId) + activate convStore + convStore->>DbSvc: getConversation(convId) + DbSvc->>IDB: SELECT * FROM conversations WHERE id = ? + IDB-->>DbSvc: conversation + convStore->>convStore: activeConversation = $state(conversation) + + convStore->>convStore: refreshActiveMessages() + convStore->>DbSvc: getConversationMessages(convId) + DbSvc->>IDB: SELECT * FROM messages WHERE convId = ? + IDB-->>DbSvc: allMessages[] + convStore->>convStore: filterByLeafNodeId(allMessages, currNode) + Note right of convStore: Filter to show only current branch path + convStore->>convStore: activeMessages = $state(filtered) + + Note right of convStore: Route (+page.svelte) then calls:
      chatStore.syncLoadingStateForChat(convId) + deactivate convStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 🌳 MESSAGE BRANCHING MODEL + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over IDB: Message Tree Structure:
      - Each message has parent (null for root)
      - Each message has children[] array
      - Conversation.currNode points to active leaf
      - filterByLeafNodeId() traverses from root to currNode + + rect rgb(240, 240, 255) + Note over convStore: Example Branch Structure: + Note over convStore: root → user1 → assistant1 → user2 → assistant2a (currNode)
      ↘ assistant2b (alt branch) + end + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: ↔️ BRANCH NAVIGATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: navigateToSibling(msgId, direction) + activate convStore + convStore->>convStore: Find message in activeMessages + convStore->>convStore: Get parent message + convStore->>convStore: Find sibling in parent.children[] + convStore->>convStore: findLeafNode(siblingId, allMessages) + Note right of convStore: Navigate to leaf of sibling branch + convStore->>convStore: updateCurrentNode(leafId) + convStore->>DbSvc: updateCurrentNode(convId, leafId) + DbSvc->>IDB: UPDATE conversations SET currNode = ? + convStore->>convStore: refreshActiveMessages() + deactivate convStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 📝 UPDATE CONVERSATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: updateConversationName(convId, newName) + activate convStore + convStore->>DbSvc: updateConversation(convId, {name: newName}) + DbSvc->>IDB: UPDATE conversations SET name = ? + convStore->>convStore: Update in conversations array + deactivate convStore + + Note over convStore: Auto-title update (after first response): + convStore->>convStore: updateConversationTitleWithConfirmation() + convStore->>convStore: titleUpdateConfirmationCallback?() + Note right of convStore: Shows dialog if title would change + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 🗑️ DELETE CONVERSATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: deleteConversation(convId) + activate convStore + convStore->>DbSvc: deleteConversation(convId) + DbSvc->>IDB: DELETE FROM conversations WHERE id = ? + DbSvc->>IDB: DELETE FROM messages WHERE convId = ? + convStore->>convStore: conversations.filter(c => c.id !== convId) + alt deleted active conversation + convStore->>convStore: clearActiveConversation() + end + deactivate convStore + + UI->>convStore: deleteAll() + activate convStore + convStore->>DbSvc: Delete all conversations and messages + convStore->>convStore: conversations = [] + convStore->>convStore: clearActiveConversation() + deactivate convStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: � MCP SERVER PER-CHAT OVERRIDES + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over convStore: Conversations can override which MCP servers are enabled. + Note over convStore: Uses pendingMcpServerOverrides before conversation
      is created, then persists to conversation metadata. + + UI->>convStore: setMcpServerOverride(convId, serverName, override) + Note right of convStore: override = {enabled: boolean} + + UI->>convStore: toggleMcpServerForChat(convId, serverName, enabled) + activate convStore + convStore->>convStore: setMcpServerOverride(convId, serverName, {enabled}) + deactivate convStore + + UI->>convStore: isMcpServerEnabledForChat(convId, serverName) + Note right of convStore: Check override → fall back to global MCP config + + UI->>convStore: getAllMcpServerOverrides(convId) + Note right of convStore: Returns all overrides for a conversation + + UI->>convStore: removeMcpServerOverride(convId, serverName) + UI->>convStore: getMcpServerOverride(convId, serverName) + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,IDB: 📤 EXPORT / 📥 IMPORT + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>convStore: exportAllConversations() + activate convStore + convStore->>DbSvc: getAllConversations() + loop each conversation + convStore->>DbSvc: getConversationMessages(convId) + end + convStore->>convStore: triggerDownload(JSON blob) + deactivate convStore + + UI->>convStore: importConversations(file) + activate convStore + convStore->>convStore: Parse JSON file + convStore->>convStore: importConversationsData(parsed) + convStore->>DbSvc: importConversations(parsed) + Note right of DbSvc: Skips duplicate conversations
      (checks existing by ID) + DbSvc->>IDB: INSERT conversations + messages (skip existing) + convStore->>convStore: loadConversations() + deactivate convStore +``` diff --git a/tools/ui/docs/flows/data-flow-simplified-model-mode.md b/tools/ui/docs/flows/data-flow-simplified-model-mode.md new file mode 100644 index 0000000000000000000000000000000000000000..07b362147facca19f1ec306dee4007f2cc961d4b --- /dev/null +++ b/tools/ui/docs/flows/data-flow-simplified-model-mode.md @@ -0,0 +1,45 @@ +```mermaid +%% MODEL Mode Data Flow (single model) +%% Detailed flows: ./flows/server-flow.mmd, ./flows/models-flow.mmd, ./flows/chat-flow.mmd + +sequenceDiagram + participant User as 👤 User + participant UI as 🧩 UI + participant Stores as 🗄️ Stores + participant DB as 💾 IndexedDB + participant API as 🌐 llama-server + + Note over User,API: 🚀 Initialization (see: server-flow.mmd, models-flow.mmd) + + UI->>Stores: initialize() + Stores->>DB: load conversations + Stores->>API: GET /props + API-->>Stores: server config + modalities + Stores->>API: GET /v1/models + API-->>Stores: single model (auto-selected) + + Note over User,API: 💬 Chat Flow (see: chat-flow.mmd) + + User->>UI: send message + UI->>Stores: sendMessage() + Stores->>DB: save user message + Stores->>API: POST /v1/chat/completions (stream) + loop streaming + API-->>Stores: SSE chunks + Stores-->>UI: reactive update + end + API-->>Stores: done + timings + Stores->>DB: save assistant message + + Note over User,API: 🔁 Regenerate + + User->>UI: regenerate + Stores->>DB: create message branch + Note right of Stores: same streaming flow + + Note over User,API: ⏹️ Stop + + User->>UI: stop + Stores->>Stores: abort stream + Stores->>DB: save partial response +``` diff --git a/tools/ui/docs/flows/data-flow-simplified-router-mode.md b/tools/ui/docs/flows/data-flow-simplified-router-mode.md new file mode 100644 index 0000000000000000000000000000000000000000..bccacf568412df8d7c1d998819e874b41a87775e --- /dev/null +++ b/tools/ui/docs/flows/data-flow-simplified-router-mode.md @@ -0,0 +1,77 @@ +```mermaid +%% ROUTER Mode Data Flow (multi-model) +%% Detailed flows: ./flows/server-flow.mmd, ./flows/models-flow.mmd, ./flows/chat-flow.mmd + +sequenceDiagram + participant User as 👤 User + participant UI as 🧩 UI + participant Stores as 🗄️ Stores + participant DB as 💾 IndexedDB + participant API as 🌐 llama-server + + Note over User,API: 🚀 Initialization (see: server-flow.mmd, models-flow.mmd) + + UI->>Stores: initialize() + Stores->>DB: load conversations + Stores->>API: GET /props + API-->>Stores: {role: "router"} + Stores->>API: GET /v1/models + API-->>Stores: models[] with status (loaded/available) + loop each loaded model + Stores->>API: GET /props?model=X + API-->>Stores: modalities (vision/audio) + end + + Note over User,API: 🔄 Model Selection (see: models-flow.mmd) + + User->>UI: select model + alt model not loaded + Stores->>API: POST /models/load + loop poll status + Stores->>API: GET /v1/models + API-->>Stores: check if loaded + end + Stores->>API: GET /props?model=X + API-->>Stores: cache modalities + end + Stores->>Stores: validate modalities vs conversation + alt valid + Stores->>Stores: select model + else invalid + Stores->>API: POST /models/unload + UI->>User: show error toast + end + + Note over User,API: 💬 Chat Flow (see: chat-flow.mmd) + + User->>UI: send message + UI->>Stores: sendMessage() + Stores->>DB: save user message + Stores->>API: POST /v1/chat/completions {model: X} + Note right of API: router forwards to model + loop streaming + API-->>Stores: SSE chunks + model info + Stores-->>UI: reactive update + end + API-->>Stores: done + timings + Stores->>DB: save assistant message + model used + + Note over User,API: 🔁 Regenerate (optional: different model) + + User->>UI: regenerate + Stores->>Stores: validate modalities up to this message + Stores->>DB: create message branch + Note right of Stores: same streaming flow + + Note over User,API: ⏹️ Stop + + User->>UI: stop + Stores->>Stores: abort stream + Stores->>DB: save partial response + + Note over User,API: 🗑️ LRU Unloading + + Note right of API: Server auto-unloads LRU models
      when cache full + User->>UI: select unloaded model + Note right of Stores: triggers load flow again +``` diff --git a/tools/ui/docs/flows/database-flow.md b/tools/ui/docs/flows/database-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..38cd6941cf78ca3e0d2e3619fcf6d8a9d289bfb4 --- /dev/null +++ b/tools/ui/docs/flows/database-flow.md @@ -0,0 +1,174 @@ +```mermaid +sequenceDiagram + participant Store as 🗄️ Stores + participant DbSvc as ⚙️ DatabaseService + participant Dexie as 📦 Dexie ORM + participant IDB as 💾 IndexedDB + + Note over DbSvc: Stateless service - all methods static
      Database: "LlamacppWebui" + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 📊 SCHEMA + %% ═══════════════════════════════════════════════════════════════════════════ + + rect rgb(240, 248, 255) + Note over IDB: conversations table:
      id (PK), lastModified, currNode, name + end + + rect rgb(255, 248, 240) + Note over IDB: messages table:
      id (PK), convId (FK), type, role, timestamp,
      parent, children[], content, thinking,
      toolCalls, extra[], model, timings + end + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 💬 CONVERSATIONS CRUD + %% ═══════════════════════════════════════════════════════════════════════════ + + Store->>DbSvc: createConversation(name) + activate DbSvc + DbSvc->>DbSvc: Generate UUID + DbSvc->>Dexie: db.conversations.add({id, name, lastModified, currNode: ""}) + Dexie->>IDB: INSERT + IDB-->>Dexie: success + DbSvc-->>Store: DatabaseConversation + deactivate DbSvc + + Store->>DbSvc: getConversation(convId) + DbSvc->>Dexie: db.conversations.get(convId) + Dexie->>IDB: SELECT WHERE id = ? + IDB-->>DbSvc: DatabaseConversation + + Store->>DbSvc: getAllConversations() + DbSvc->>Dexie: db.conversations.orderBy('lastModified').reverse().toArray() + Dexie->>IDB: SELECT ORDER BY lastModified DESC + IDB-->>DbSvc: DatabaseConversation[] + + Store->>DbSvc: updateConversation(convId, updates) + DbSvc->>Dexie: db.conversations.update(convId, {...updates, lastModified}) + Dexie->>IDB: UPDATE + + Store->>DbSvc: deleteConversation(convId) + activate DbSvc + DbSvc->>Dexie: db.conversations.delete(convId) + Dexie->>IDB: DELETE FROM conversations + DbSvc->>Dexie: db.messages.where('convId').equals(convId).delete() + Dexie->>IDB: DELETE FROM messages WHERE convId = ? + deactivate DbSvc + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 📝 MESSAGES CRUD + %% ═══════════════════════════════════════════════════════════════════════════ + + Store->>DbSvc: createRootMessage(convId) + activate DbSvc + DbSvc->>DbSvc: Create root message {type: "root", parent: null} + DbSvc->>Dexie: db.messages.add(rootMsg) + Dexie->>IDB: INSERT + DbSvc-->>Store: rootMessageId + deactivate DbSvc + + Store->>DbSvc: createSystemMessage(convId, content, parentId) + activate DbSvc + DbSvc->>DbSvc: Create message {role: "system", parent: parentId} + DbSvc->>Dexie: db.messages.add(systemMsg) + Dexie->>IDB: INSERT + DbSvc-->>Store: DatabaseMessage + deactivate DbSvc + + Store->>DbSvc: createMessageBranch(message, parentId) + activate DbSvc + DbSvc->>DbSvc: Generate UUID for new message + DbSvc->>Dexie: db.messages.add({...message, id, parent: parentId}) + Dexie->>IDB: INSERT message + + alt parentId exists + DbSvc->>Dexie: db.messages.get(parentId) + Dexie->>IDB: SELECT parent + DbSvc->>DbSvc: parent.children.push(newId) + DbSvc->>Dexie: db.messages.update(parentId, {children}) + Dexie->>IDB: UPDATE parent.children + end + + DbSvc->>Dexie: db.conversations.update(convId, {currNode: newId}) + Dexie->>IDB: UPDATE conversation.currNode + DbSvc-->>Store: DatabaseMessage + deactivate DbSvc + + Store->>DbSvc: getConversationMessages(convId) + DbSvc->>Dexie: db.messages.where('convId').equals(convId).toArray() + Dexie->>IDB: SELECT WHERE convId = ? + IDB-->>DbSvc: DatabaseMessage[] + + Store->>DbSvc: updateMessage(msgId, updates) + DbSvc->>Dexie: db.messages.update(msgId, updates) + Dexie->>IDB: UPDATE + + Store->>DbSvc: deleteMessage(msgId) + DbSvc->>Dexie: db.messages.delete(msgId) + Dexie->>IDB: DELETE + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 🌳 BRANCHING OPERATIONS + %% ═══════════════════════════════════════════════════════════════════════════ + + Store->>DbSvc: updateCurrentNode(convId, nodeId) + DbSvc->>Dexie: db.conversations.update(convId, {currNode: nodeId, lastModified}) + Dexie->>IDB: UPDATE + + Store->>DbSvc: deleteMessageCascading(msgId) + activate DbSvc + DbSvc->>DbSvc: findDescendantMessages(msgId, allMessages) + Note right of DbSvc: Recursively find all children + loop each descendant + DbSvc->>Dexie: db.messages.delete(descendantId) + Dexie->>IDB: DELETE + end + DbSvc->>Dexie: db.messages.delete(msgId) + Dexie->>IDB: DELETE target message + + alt target message has a parent + DbSvc->>Dexie: db.messages.get(parentId) + DbSvc->>DbSvc: parent.children.filter(id !== msgId) + DbSvc->>Dexie: db.messages.update(parentId, {children}) + Note right of DbSvc: Remove deleted message from parent's children[] + end + deactivate DbSvc + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 📥 IMPORT + %% ═══════════════════════════════════════════════════════════════════════════ + + Store->>DbSvc: importConversations(data) + activate DbSvc + loop each conversation in data + DbSvc->>Dexie: db.conversations.get(conv.id) + alt conversation already exists + Note right of DbSvc: Skip duplicate (keep existing) + else conversation is new + DbSvc->>Dexie: db.conversations.add(conversation) + Dexie->>IDB: INSERT conversation + loop each message + DbSvc->>Dexie: db.messages.add(message) + Dexie->>IDB: INSERT message + end + end + end + deactivate DbSvc + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over Store,IDB: 🔗 MESSAGE TREE UTILITIES + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over DbSvc: Used by stores (imported from utils): + + rect rgb(240, 255, 240) + Note over DbSvc: filterByLeafNodeId(messages, leafId)
      → Returns path from root to leaf
      → Used to display current branch + end + + rect rgb(240, 255, 240) + Note over DbSvc: findLeafNode(startId, messages)
      → Traverse to deepest child
      → Used for branch navigation + end + + rect rgb(240, 255, 240) + Note over DbSvc: findDescendantMessages(msgId, messages)
      → Find all children recursively
      → Used for cascading deletes + end +``` diff --git a/tools/ui/docs/flows/mcp-flow.md b/tools/ui/docs/flows/mcp-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..c8aa6665993ff2d649b3e8a6a8ca48ab388410ff --- /dev/null +++ b/tools/ui/docs/flows/mcp-flow.md @@ -0,0 +1,226 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 McpServersSettings / ChatForm + participant chatStore as 🗄️ chatStore + participant mcpStore as 🗄️ mcpStore + participant mcpResStore as 🗄️ mcpResourceStore + participant convStore as 🗄️ conversationsStore + participant MCPSvc as ⚙️ MCPService + participant LS as 💾 LocalStorage + participant ExtMCP as 🔌 External MCP Server + + Note over mcpStore: State:
      isInitializing, error
      toolCount, connectedServers
      healthChecks (Map)
      connections (Map)
      toolsIndex (Map)
      serverConfigs (Map) + + Note over mcpResStore: State:
      serverResources (Map)
      cachedResources (Map)
      subscriptions (Map)
      attachments[] + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: 🚀 INITIALIZATION (App Startup) + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>mcpStore: ensureInitialized() + activate mcpStore + + mcpStore->>LS: get(MCP_SERVERS_LOCALSTORAGE_KEY) + LS-->>mcpStore: MCPServerSettingsEntry[] + + mcpStore->>mcpStore: parseServerSettings(servers) + Note right of mcpStore: Filter enabled servers
      Build MCPServerConfig objects
      Per-chat overrides checked via convStore + + loop For each enabled server + mcpStore->>mcpStore: runHealthCheck(serverId) + mcpStore->>mcpStore: updateHealthCheck(id, CONNECTING) + + mcpStore->>MCPSvc: connect(serverName, config, clientInfo, capabilities, onPhase) + activate MCPSvc + + MCPSvc->>MCPSvc: createTransport(config) + Note right of MCPSvc: WebSocket / StreamableHTTP / SSE
      with optional CORS proxy + + MCPSvc->>ExtMCP: Transport handshake + ExtMCP-->>MCPSvc: Connection established + + MCPSvc->>ExtMCP: Initialize request + Note right of ExtMCP: Exchange capabilities
      Server info, protocol version + + ExtMCP-->>MCPSvc: InitializeResult (serverInfo, capabilities) + + MCPSvc->>ExtMCP: listTools() + ExtMCP-->>MCPSvc: Tool[] + + MCPSvc-->>mcpStore: MCPConnection + deactivate MCPSvc + + mcpStore->>mcpStore: connections.set(serverName, connection) + mcpStore->>mcpStore: indexTools(connection.tools, serverName) + Note right of mcpStore: toolsIndex.set(toolName, serverName)
      Handle name conflicts with prefixes + + mcpStore->>mcpStore: updateHealthCheck(id, SUCCESS) + mcpStore->>mcpStore: _connectedServers.push(serverName) + + alt Server supports resources + mcpStore->>MCPSvc: listAllResources(connection) + MCPSvc->>ExtMCP: listResources() + ExtMCP-->>MCPSvc: MCPResource[] + MCPSvc-->>mcpStore: resources + + mcpStore->>MCPSvc: listAllResourceTemplates(connection) + MCPSvc->>ExtMCP: listResourceTemplates() + ExtMCP-->>MCPSvc: MCPResourceTemplate[] + MCPSvc-->>mcpStore: templates + + mcpStore->>mcpResStore: setServerResources(serverName, resources, templates) + end + end + + mcpStore->>mcpStore: _isInitializing = false + deactivate mcpStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: 🔧 TOOL EXECUTION (Chat with Tools) + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>mcpStore: executeTool(mcpCall: MCPToolCall, signal?) + activate mcpStore + + mcpStore->>mcpStore: toolsIndex.get(mcpCall.function.name) + Note right of mcpStore: Resolve serverName from toolsIndex
      MCPToolCall = {id, type, function: {name, arguments}} + + mcpStore->>mcpStore: acquireConnection() + Note right of mcpStore: activeFlowCount++
      Prevent shutdown during execution + + mcpStore->>mcpStore: connection = connections.get(serverName) + + mcpStore->>MCPSvc: callTool(connection, {name, arguments}, signal) + activate MCPSvc + + MCPSvc->>MCPSvc: throwIfAborted(signal) + MCPSvc->>ExtMCP: callTool(name, arguments) + + alt Tool execution success + ExtMCP-->>MCPSvc: ToolCallResult (content, isError) + MCPSvc->>MCPSvc: formatToolResult(result) + Note right of MCPSvc: Handle text, image (base64),
      embedded resource content + MCPSvc-->>mcpStore: ToolExecutionResult + else Tool execution error + ExtMCP-->>MCPSvc: Error + MCPSvc-->>mcpStore: throw Error + else Aborted + MCPSvc-->>mcpStore: throw AbortError + end + + deactivate MCPSvc + + mcpStore->>mcpStore: releaseConnection() + Note right of mcpStore: activeFlowCount-- + + mcpStore-->>UI: ToolExecutionResult + deactivate mcpStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: � RESOURCE ATTACHMENT CONSUMPTION + %% ═══════════════════════════════════════════════════════════════════════════ + + chatStore->>mcpStore: consumeResourceAttachmentsAsExtras() + activate mcpStore + mcpStore->>mcpResStore: getAttachments() + mcpResStore-->>mcpStore: MCPResourceAttachment[] + mcpStore->>mcpStore: Convert attachments to message extras + mcpStore->>mcpResStore: clearAttachments() + mcpStore-->>chatStore: MessageExtra[] (for user message) + deactivate mcpStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: �📝 PROMPT OPERATIONS + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>mcpStore: getAllPrompts() + activate mcpStore + + loop For each connected server with prompts capability + mcpStore->>MCPSvc: listPrompts(connection) + MCPSvc->>ExtMCP: listPrompts() + ExtMCP-->>MCPSvc: Prompt[] + MCPSvc-->>mcpStore: prompts + end + + mcpStore-->>UI: MCPPromptInfo[] (with serverName) + deactivate mcpStore + + UI->>mcpStore: getPrompt(serverName, promptName, args?) + activate mcpStore + + mcpStore->>MCPSvc: getPrompt(connection, name, args) + MCPSvc->>ExtMCP: getPrompt({name, arguments}) + ExtMCP-->>MCPSvc: GetPromptResult (messages) + MCPSvc-->>mcpStore: GetPromptResult + + mcpStore-->>UI: GetPromptResult + deactivate mcpStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: 📁 RESOURCE OPERATIONS + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>mcpResStore: addAttachment(resourceInfo) + activate mcpResStore + mcpResStore->>mcpResStore: Create MCPResourceAttachment (loading: true) + mcpResStore-->>UI: attachment + + UI->>mcpStore: readResource(serverName, uri) + activate mcpStore + + mcpStore->>MCPSvc: readResource(connection, uri) + MCPSvc->>ExtMCP: readResource({uri}) + ExtMCP-->>MCPSvc: MCPReadResourceResult (contents) + MCPSvc-->>mcpStore: contents + + mcpStore-->>UI: MCPResourceContent[] + deactivate mcpStore + + UI->>mcpResStore: updateAttachmentContent(attachmentId, content) + mcpResStore->>mcpResStore: cacheResourceContent(resource, content) + deactivate mcpResStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: 🔄 AUTO-RECONNECTION + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over mcpStore: On WebSocket close or connection error: + mcpStore->>mcpStore: autoReconnect(serverName, attempt) + activate mcpStore + + mcpStore->>mcpStore: Calculate backoff delay + Note right of mcpStore: delay = min(30s, 1s * 2^attempt) + + mcpStore->>mcpStore: Wait for delay + mcpStore->>mcpStore: reconnectServer(serverName) + + alt Reconnection success + mcpStore->>mcpStore: updateHealthCheck(id, SUCCESS) + else Max attempts reached + mcpStore->>mcpStore: updateHealthCheck(id, ERROR) + end + deactivate mcpStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,ExtMCP: 🛑 SHUTDOWN + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>mcpStore: shutdown() + activate mcpStore + + mcpStore->>mcpStore: Wait for activeFlowCount == 0 + + loop For each connection + mcpStore->>MCPSvc: disconnect(connection) + MCPSvc->>MCPSvc: transport.onclose = undefined + MCPSvc->>ExtMCP: close() + end + + mcpStore->>mcpStore: connections.clear() + mcpStore->>mcpStore: toolsIndex.clear() + mcpStore->>mcpStore: _connectedServers = [] + + mcpStore->>mcpResStore: clear() + deactivate mcpStore +``` diff --git a/tools/ui/docs/flows/models-flow.md b/tools/ui/docs/flows/models-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..c3031b7292355b0e04cb743f302ae85a06cd9542 --- /dev/null +++ b/tools/ui/docs/flows/models-flow.md @@ -0,0 +1,181 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 ModelsSelector + participant Hooks as 🪝 useModelChangeValidation + participant modelsStore as 🗄️ modelsStore + participant serverStore as 🗄️ serverStore + participant convStore as 🗄️ conversationsStore + participant ModelsSvc as ⚙️ ModelsService + participant PropsSvc as ⚙️ PropsService + participant API as 🌐 llama-server + + Note over modelsStore: State:
      models: ModelOption[]
      routerModels: ApiModelDataEntry[]
      selectedModelId, selectedModelName
      loading, updating, error
      modelLoadingStates (Map)
      modelPropsCache (Map)
      propsCacheVersion + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🚀 INITIALIZATION (MODEL mode) + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>modelsStore: fetch() + activate modelsStore + modelsStore->>modelsStore: loading = true + + alt serverStore.props not loaded + modelsStore->>serverStore: fetch() + Note over serverStore: → see server-flow.mmd + end + + modelsStore->>ModelsSvc: list() + ModelsSvc->>API: GET /v1/models + API-->>ModelsSvc: ApiModelListResponse {data: [model]} + + modelsStore->>modelsStore: models = $state(mapped) + Note right of modelsStore: Map to ModelOption[]:
      {id, name, model, description, capabilities} + + Note over modelsStore: MODEL mode: Get modalities from serverStore.props + modelsStore->>modelsStore: modelPropsCache.set(model.id, serverStore.props) + modelsStore->>modelsStore: models[0].modalities = props.modalities + + modelsStore->>modelsStore: Auto-select single model + Note right of modelsStore: selectedModelId = models[0].id + modelsStore->>modelsStore: loading = false + deactivate modelsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🚀 INITIALIZATION (ROUTER mode) + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>modelsStore: fetch() + activate modelsStore + modelsStore->>ModelsSvc: list() + ModelsSvc->>API: GET /v1/models + API-->>ModelsSvc: ApiModelListResponse + modelsStore->>modelsStore: models = $state(mapped) + deactivate modelsStore + + Note over UI: After models loaded, layout triggers: + UI->>modelsStore: fetchRouterModels() + activate modelsStore + modelsStore->>ModelsSvc: listRouter() + ModelsSvc->>API: GET /v1/models + API-->>ModelsSvc: ApiRouterModelsListResponse + Note right of API: {data: [{id, status, path, in_cache}]} + modelsStore->>modelsStore: routerModels = $state(data) + + modelsStore->>modelsStore: fetchModalitiesForLoadedModels() + loop each model where status === "loaded" + modelsStore->>PropsSvc: fetchForModel(modelId) + PropsSvc->>API: GET /props?model={modelId} + API-->>PropsSvc: ApiLlamaCppServerProps + modelsStore->>modelsStore: modelPropsCache.set(modelId, props) + end + modelsStore->>modelsStore: propsCacheVersion++ + deactivate modelsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🔄 MODEL SELECTION (ROUTER mode) + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>Hooks: useModelChangeValidation({getRequiredModalities, onSuccess?, onValidationFailure?}) + Note over Hooks: Hook configured per-component:
      ChatForm: getRequiredModalities = usedModalities
      ChatMessage: getRequiredModalities = getModalitiesUpToMessage(msgId) + + UI->>Hooks: handleModelChange(modelId, modelName) + activate Hooks + Hooks->>Hooks: previousSelectedModelId = modelsStore.selectedModelId + Hooks->>modelsStore: isModelLoaded(modelName)? + + alt model NOT loaded + Hooks->>modelsStore: loadModel(modelName) + Note over modelsStore: → see LOAD MODEL section below + end + + Note over Hooks: Always fetch props (from cache or API) + Hooks->>modelsStore: fetchModelProps(modelName) + modelsStore-->>Hooks: props + + Hooks->>convStore: getRequiredModalities() + convStore-->>Hooks: {vision, audio} + + Hooks->>Hooks: Validate: model.modalities ⊇ required? + + alt validation PASSED + Hooks->>modelsStore: selectModelById(modelId) + Hooks-->>UI: return true + else validation FAILED + Hooks->>UI: toast.error("Model doesn't support required modalities") + alt model was just loaded + Hooks->>modelsStore: unloadModel(modelName) + end + alt onValidationFailure provided + Hooks->>modelsStore: selectModelById(previousSelectedModelId) + end + Hooks-->>UI: return false + end + deactivate Hooks + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ⬆️ LOAD MODEL (ROUTER mode) + %% ═══════════════════════════════════════════════════════════════════════════ + + modelsStore->>modelsStore: loadModel(modelId) + activate modelsStore + + alt already loaded + modelsStore-->>modelsStore: return (no-op) + end + + modelsStore->>modelsStore: modelLoadingStates.set(modelId, true) + modelsStore->>ModelsSvc: load(modelId) + ModelsSvc->>API: POST /models/load {model: modelId} + API-->>ModelsSvc: {status: "loading"} + + modelsStore->>modelsStore: pollForModelStatus(modelId, LOADED) + loop poll every 500ms (max 60 attempts) + modelsStore->>modelsStore: fetchRouterModels() + modelsStore->>ModelsSvc: listRouter() + ModelsSvc->>API: GET /v1/models + API-->>ModelsSvc: models[] + modelsStore->>modelsStore: getModelStatus(modelId) + alt status === LOADED + Note right of modelsStore: break loop + else status === LOADING + Note right of modelsStore: wait 500ms, continue + end + end + + modelsStore->>modelsStore: updateModelModalities(modelId) + modelsStore->>PropsSvc: fetchForModel(modelId) + PropsSvc->>API: GET /props?model={modelId} + API-->>PropsSvc: props with modalities + modelsStore->>modelsStore: modelPropsCache.set(modelId, props) + modelsStore->>modelsStore: propsCacheVersion++ + + modelsStore->>modelsStore: modelLoadingStates.set(modelId, false) + deactivate modelsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ⬇️ UNLOAD MODEL (ROUTER mode) + %% ═══════════════════════════════════════════════════════════════════════════ + + modelsStore->>modelsStore: unloadModel(modelId) + activate modelsStore + modelsStore->>modelsStore: modelLoadingStates.set(modelId, true) + modelsStore->>ModelsSvc: unload(modelId) + ModelsSvc->>API: POST /models/unload {model: modelId} + + modelsStore->>modelsStore: pollForModelStatus(modelId, UNLOADED) + loop poll until unloaded + modelsStore->>ModelsSvc: listRouter() + ModelsSvc->>API: GET /v1/models + end + + modelsStore->>modelsStore: modelLoadingStates.set(modelId, false) + deactivate modelsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 📊 COMPUTED GETTERS + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over modelsStore: Getters:
      - selectedModel: ModelOption | null
      - loadedModelIds: string[] (from routerModels)
      - loadingModelIds: string[] (from modelLoadingStates)
      - singleModelName: string | null (MODEL mode only) + + Note over modelsStore: Modality helpers:
      - getModelModalities(modelId): {vision, audio}
      - modelSupportsVision(modelId): boolean
      - modelSupportsAudio(modelId): boolean +``` diff --git a/tools/ui/docs/flows/server-flow.md b/tools/ui/docs/flows/server-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..d6a1611f6f48044b97e760bb8bc6e5b015f0321e --- /dev/null +++ b/tools/ui/docs/flows/server-flow.md @@ -0,0 +1,76 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 +layout.svelte + participant serverStore as 🗄️ serverStore + participant PropsSvc as ⚙️ PropsService + participant API as 🌐 llama-server + + Note over serverStore: State:
      props: ApiLlamaCppServerProps | null
      loading, error
      role: ServerRole | null (MODEL | ROUTER)
      fetchPromise (deduplication) + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🚀 INITIALIZATION + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>serverStore: fetch() + activate serverStore + + alt fetchPromise exists (already fetching) + serverStore-->>UI: return fetchPromise + Note right of serverStore: Deduplicate concurrent calls + end + + serverStore->>serverStore: loading = true + serverStore->>serverStore: fetchPromise = new Promise() + + serverStore->>PropsSvc: fetch() + PropsSvc->>API: GET /props + API-->>PropsSvc: ApiLlamaCppServerProps + Note right of API: {role, model_path, model_alias,
      modalities, default_generation_settings, ...} + + PropsSvc-->>serverStore: props + serverStore->>serverStore: props = $state(data) + + serverStore->>serverStore: detectRole(props) + Note right of serverStore: role = props.role === "router"
      ? ServerRole.ROUTER
      : ServerRole.MODEL + + serverStore->>serverStore: loading = false + serverStore->>serverStore: fetchPromise = null + deactivate serverStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 📊 COMPUTED GETTERS + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over serverStore: Getters from props: + + rect rgb(240, 255, 240) + Note over serverStore: defaultParams
      → props.default_generation_settings.params
      (temperature, top_p, top_k, etc.) + end + + rect rgb(240, 255, 240) + Note over serverStore: contextSize
      → props.default_generation_settings.n_ctx + end + + rect rgb(255, 240, 240) + Note over serverStore: isRouterMode
      → role === ServerRole.ROUTER + end + + rect rgb(255, 240, 240) + Note over serverStore: isModelMode
      → role === ServerRole.MODEL + end + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: 🔗 RELATIONSHIPS + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over serverStore: Used by: + Note right of serverStore: - modelsStore: role detection, MODEL mode modalities
      - settingsStore: syncWithServerDefaults (defaultParams)
      - chatStore: contextSize for processing state
      - UI components: isRouterMode for conditional rendering + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,API: ❌ ERROR HANDLING + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over serverStore: getErrorMessage(): string | null
      Returns formatted error for UI display + + Note over serverStore: clear(): void
      Resets all state (props, error, loading, role) +``` diff --git a/tools/ui/docs/flows/settings-flow.md b/tools/ui/docs/flows/settings-flow.md new file mode 100644 index 0000000000000000000000000000000000000000..260713a17b8d7f3b3e6219b32abba99a6c775f43 --- /dev/null +++ b/tools/ui/docs/flows/settings-flow.md @@ -0,0 +1,156 @@ +```mermaid +sequenceDiagram + participant UI as 🧩 ChatSettings + participant settingsStore as 🗄️ settingsStore + participant serverStore as 🗄️ serverStore + participant ParamSvc as ⚙️ ParameterSyncService + participant LS as 💾 LocalStorage + + Note over settingsStore: State:
      config: SettingsConfigType
      theme: string ("auto" | "light" | "dark")
      isInitialized: boolean
      userOverrides: Set<string> + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 🚀 INITIALIZATION + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over settingsStore: Auto-initialized in constructor (browser only) + settingsStore->>settingsStore: initialize() + activate settingsStore + + settingsStore->>settingsStore: loadConfig() + settingsStore->>LS: get("llama-config") + LS-->>settingsStore: StoredConfig | null + + alt config exists + settingsStore->>settingsStore: Merge with SETTING_CONFIG_DEFAULT + Note right of settingsStore: Fill missing keys with defaults + else no config + settingsStore->>settingsStore: config = SETTING_CONFIG_DEFAULT + end + + settingsStore->>LS: get("llama-userOverrides") + LS-->>settingsStore: string[] | null + settingsStore->>settingsStore: userOverrides = new Set(data) + + settingsStore->>settingsStore: loadTheme() + settingsStore->>LS: get("llama-theme") + LS-->>settingsStore: theme | "auto" + + settingsStore->>settingsStore: isInitialized = true + deactivate settingsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 🔄 SYNC WITH SERVER DEFAULTS + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over UI: Triggered from +layout.svelte when serverStore.props loaded + UI->>settingsStore: syncWithServerDefaults() + activate settingsStore + + settingsStore->>serverStore: defaultParams + serverStore-->>settingsStore: {temperature, top_p, top_k, ...} + + loop each SYNCABLE_PARAMETER + alt key NOT in userOverrides + settingsStore->>settingsStore: config[key] = serverDefault[key] + Note right of settingsStore: Non-overridden params adopt server default + else key in userOverrides + Note right of settingsStore: Keep user value, skip server default + end + end + + alt serverStore.props has uiSettings + settingsStore->>settingsStore: Apply uiSettings from server + Note right of settingsStore: Server-provided UI settings
      (e.g. showRawOutputSwitch) + end + + settingsStore->>settingsStore: saveConfig() + deactivate settingsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: ⚙️ UPDATE CONFIG + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>settingsStore: updateConfig(key, value) + activate settingsStore + settingsStore->>settingsStore: config[key] = value + + alt value matches server default for key + settingsStore->>settingsStore: userOverrides.delete(key) + Note right of settingsStore: Matches server default, remove override + else value differs from server default + settingsStore->>settingsStore: userOverrides.add(key) + Note right of settingsStore: Mark as user-modified (won't be overwritten) + end + + settingsStore->>settingsStore: saveConfig() + settingsStore->>LS: set(CONFIG_LOCALSTORAGE_KEY, config) + settingsStore->>LS: set(USER_OVERRIDES_LOCALSTORAGE_KEY, [...userOverrides]) + deactivate settingsStore + + UI->>settingsStore: updateMultipleConfig({key1: val1, key2: val2}) + activate settingsStore + Note right of settingsStore: Batch update, single save + settingsStore->>settingsStore: For each key: config[key] = value + settingsStore->>settingsStore: For each key: userOverrides.add(key) + settingsStore->>settingsStore: saveConfig() + deactivate settingsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 🔄 RESET + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>settingsStore: resetConfig() + activate settingsStore + settingsStore->>settingsStore: config = {...SETTING_CONFIG_DEFAULT} + settingsStore->>settingsStore: userOverrides.clear() + Note right of settingsStore: All params reset to defaults
      Next syncWithServerDefaults will adopt server values + settingsStore->>settingsStore: saveConfig() + deactivate settingsStore + + UI->>settingsStore: resetParameterToServerDefault(key) + activate settingsStore + settingsStore->>settingsStore: userOverrides.delete(key) + settingsStore->>serverStore: defaultParams[key] + settingsStore->>settingsStore: config[key] = serverDefault + settingsStore->>settingsStore: saveConfig() + deactivate settingsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 🎨 THEME + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>settingsStore: updateTheme(newTheme) + activate settingsStore + settingsStore->>settingsStore: theme = newTheme + settingsStore->>settingsStore: saveTheme() + settingsStore->>LS: set("llama-theme", theme) + deactivate settingsStore + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 📊 PARAMETER INFO + %% ═══════════════════════════════════════════════════════════════════════════ + + UI->>settingsStore: getParameterInfo(key) + settingsStore->>ParamSvc: getParameterInfo(key, config, serverDefaults, userOverrides) + ParamSvc-->>settingsStore: ParameterInfo + Note right of ParamSvc: {
      currentValue,
      serverDefault,
      isUserOverride: boolean,
      canSync: boolean,
      isDifferentFromServer: boolean
      } + + UI->>settingsStore: getParameterDiff() + settingsStore->>ParamSvc: createParameterDiff(config, serverDefaults, userOverrides) + ParamSvc-->>settingsStore: ParameterDiff[] + Note right of ParamSvc: Array of parameters where user != server + + %% ═══════════════════════════════════════════════════════════════════════════ + Note over UI,LS: 📋 CONFIG CATEGORIES + %% ═══════════════════════════════════════════════════════════════════════════ + + Note over settingsStore: Syncable with server (from /props): + rect rgb(240, 255, 240) + Note over settingsStore: temperature, top_p, top_k, min_p
      repeat_penalty, presence_penalty, frequency_penalty
      dynatemp_range, dynatemp_exponent
      typ_p, xtc_probability, xtc_threshold
      dry_multiplier, dry_base, dry_allowed_length, dry_penalty_last_n + end + + Note over settingsStore: UI-only (not synced): + rect rgb(255, 240, 240) + Note over settingsStore: systemMessage, custom (JSON)
      showStatistics, enableContinueGeneration
      autoMicOnEmpty, disableAutoScroll
      apiKey, pdfAsImage, disableReasoningParsing, showRawOutputSwitch + end +``` diff --git a/tools/ui/embed.cpp b/tools/ui/embed.cpp new file mode 100644 index 0000000000000000000000000000000000000000..914d51fa1d8c2add618b5d2f1ab5e0b86e1e020c --- /dev/null +++ b/tools/ui/embed.cpp @@ -0,0 +1,306 @@ +// llama-ui-embed: generate ui.cpp / ui.h that embed UI assets as C arrays. +// +// Usage: +// llama-ui-embed [] +// +// Recursively embeds every regular file under . +// Asset names are relative paths from (e.g. "_app/immutable/bundle.HASH.js"). +// Without , emits an empty asset table. + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + + +static const char * mime_from_ext(const std::string & name) { + auto ext = name.rfind('.'); + if (ext == std::string::npos) return "application/octet-stream"; + std::string e = name.substr(ext + 1); + if (e == "html") return "text/html; charset=utf-8"; + if (e == "css") return "text/css"; + if (e == "js") return "application/javascript"; + if (e == "json") return "application/json"; + if (e == "webmanifest") return "application/manifest+json"; + if (e == "svg") return "image/svg+xml"; + if (e == "png") return "image/png"; + if (e == "jpg" || + e == "jpeg") return "image/jpeg"; + if (e == "ico") return "image/x-icon"; + if (e == "woff") return "font/woff"; + if (e == "woff2") return "font/woff2"; + return "application/octet-stream"; +} + +// Computes FNV-1a hash of the data +static uint64_t fnv_hash(const uint8_t * data, size_t len) { + const uint64_t fnv_prime = 0x100000001b3ULL; + uint64_t hash = 0xcbf29ce484222325ULL; + + for (size_t i = 0; i < len; ++i) { + hash ^= data[i]; + hash *= fnv_prime; + } + return hash; +} + +static bool read_file(const std::filesystem::path & path, std::vector & out) { + std::ifstream f(path, std::ios::binary | std::ios::ate); + if (!f) { + fprintf(stderr, "embed: cannot open %s\n", path.string().c_str()); + return false; + } + const auto sz = f.tellg(); + if (sz < 0) { + return false; + } + f.seekg(0); + out.resize(static_cast(sz)); + if (sz > 0 && !f.read(reinterpret_cast(out.data()), sz)) { + return false; + } + return true; +} + +static void append_bytes_hex(std::string & out, const std::vector & bytes) { + static const char hex[] = "0123456789abcdef"; + out.reserve(out.size() + bytes.size() * 5); + for (unsigned char b : bytes) { + out += '0'; + out += 'x'; + out += hex[b >> 4]; + out += hex[b & 0xf]; + out += ','; + } +} + +static bool write_if_different(const std::string & path, const std::string & content) { + std::ifstream f(path, std::ios::binary | std::ios::ate); + if (f) { + const auto sz = f.tellg(); + if (sz >= 0 && static_cast(sz) == content.size()) { + std::string existing(static_cast(sz), '\0'); + f.seekg(0); + if (sz == 0 || f.read(existing.data(), sz)) { + if (existing == content) { + return true; + } + } + } + } + + std::ofstream out(path, std::ios::binary | std::ios::trunc); + if (!out) { + fprintf(stderr, "embed: cannot write %s\n", path.c_str()); + return false; + } + if (!content.empty()) { + out.write(content.data(), static_cast(content.size())); + } + bool ok = out.good(); + if (ok) { + printf("embed: write output file %s\n", path.c_str()); + } + return ok; +} + +static std::string path_basename(const std::string & name) { + const size_t p = name.rfind('/'); + return p == std::string::npos ? name : name.substr(p + 1); +} +static bool str_starts_with(const std::string & s, const char * prefix) { + const size_t n = strlen(prefix); + return s.size() >= n && s.compare(0, n, prefix) == 0; +} +static bool str_ends_with(const std::string & s, const char * suffix) { + const size_t n = strlen(suffix); + return s.size() >= n && s.compare(s.size() - n, n, suffix) == 0; +} + +static std::string fmt(const char * pattern, ...) { + char tmp[512]; + va_list ap; + va_start(ap, pattern); + const int n = vsnprintf(tmp, sizeof(tmp), pattern, ap); + va_end(ap); + return (n > 0) ? std::string(tmp, static_cast(n)) : std::string(); +} + +struct asset_entry { + std::string name; + std::filesystem::path path; +}; + +int main(int argc, char ** argv) { + if (argc < 3 || argc > 4) { + fprintf(stderr, "usage: %s []\n", argv[0]); + return 1; + } + + const std::string out_cpp = argv[1]; + const std::string out_h = argv[2]; + const std::string asset_dir = (argc >= 4) ? argv[3] : std::string(); + + const bool use_gzip = !asset_dir.empty() && std::filesystem::exists(asset_dir + "/_gzip"); + const std::string in_dir = use_gzip ? (asset_dir + "/_gzip") : asset_dir; + + std::vector assets; + if (!in_dir.empty()) { + const std::filesystem::path dir = in_dir; + + std::error_code ec; + std::filesystem::recursive_directory_iterator it(dir, ec); + if (ec) { + fprintf(stderr, "embed: cannot iterate %s: %s\n", argv[3], ec.message().c_str()); + return 1; + } + for (const auto & entry : it) { + if (!entry.is_regular_file()) { + continue; + } + // name is the relative path from dir, with forward slashes + const std::string name = entry.path().lexically_relative(dir).generic_string(); + assets.push_back({ name, entry.path() }); + } + + // directory iteration order is unspecified; sort for reproducible output + std::sort(assets.begin(), assets.end(), + [](const asset_entry & a, const asset_entry & b) { return a.name < b.name; }); + } + + const int n_assets = static_cast(assets.size()); + + if (n_assets > 0) { + using match_fn = std::function; + auto exact = [](const char * name) -> match_fn { + return [name](const std::string & base) { return base == name; }; + }; + + struct required_check { const char * label; match_fn match; bool found; }; + required_check checks[] = { + { "index.html", exact("index.html"), false }, + { "manifest.webmanifest", exact("manifest.webmanifest"), false }, + { "sw.js", exact("sw.js"), false }, + { "build.json", exact("build.json"), false }, + { "version.json", exact("version.json"), false }, + { "bundle[hash].js", [](const std::string & b) { + return str_starts_with(b, "bundle") && str_ends_with(b, ".js"); + }, false }, + { "bundle[hash].css", [](const std::string & b) { + return str_starts_with(b, "bundle") && str_ends_with(b, ".css"); + }, false }, + { "workbox[hash].js", [](const std::string & b) { + return str_starts_with(b, "workbox") && str_ends_with(b, ".js"); + }, false }, + }; + + for (const auto & a : assets) { + const std::string base = path_basename(a.name); + for (auto & c : checks) { + if (!c.found) { c.found = c.match(base); } + } + } + + std::vector missing; + for (const auto & c : checks) { + if (!c.found) { missing.push_back(c.label); } + } + if (!missing.empty()) { + fprintf(stderr, "\ncurrent asset files:\n"); + for (const auto & a : assets) { + fprintf(stderr, " %s\n", a.name.c_str()); + } + fprintf(stderr, "missing required asset(s):\n"); + for (const char * m : missing) { + fprintf(stderr, " %s\n", m); + } + fprintf(stderr, "hint: try cleaning your build directory: %s\n", in_dir.c_str()); + return 1; + } + } + + std::string h; + h += "#pragma once\n\n#include \n#include \n\n"; + if (n_assets > 0) { + h += "#define LLAMA_UI_HAS_ASSETS 1\n\n"; + } + h += + "struct llama_ui_asset {\n" + " std::string name;\n" + " const unsigned char * data;\n" + " std::size_t size;\n" + " std::string etag;\n" + " std::string type;\n" + "};\n\n" + "const llama_ui_asset * llama_ui_find_asset(const std::string & name);\n" + "bool llama_ui_use_gzip();\n"; + h += fmt("const std::array & llama_ui_get_assets();\n", n_assets); + + std::string cpp; + cpp += "#include \"ui.h\"\n\n"; + + if (n_assets > 0) { + for (int i = 0; i < n_assets; i++) { + std::vector bytes; + if (!read_file(assets[i].path, bytes)) { + return 1; + } + if (bytes.empty()) { + fprintf(stderr, "embed: empty file: %s\n", assets[i].path.generic_string().c_str()); + return 1; + } + cpp += fmt("static const unsigned char asset_%d_data[] = {", i); + append_bytes_hex(cpp, bytes); + const auto hash = fnv_hash(bytes.data(), bytes.size()); + + cpp += fmt("};\nstatic const std::size_t asset_%d_size = %zu;\n", + i, bytes.size()); + cpp += fmt("static const char asset_%d_etag[] = \"\\\"0x%016" PRIx64 "\\\"\";\n\n", + i, hash); + } + + cpp += fmt("static const std::array g_assets = {{\n", n_assets); + for (int i = 0; i < n_assets; i++) { + const std::string & name = assets[i].name; + cpp += fmt(" { \"%s\", asset_%d_data, asset_%d_size, asset_%d_etag, \"%s\" },\n", + name.c_str(), i, i, i, mime_from_ext(name)); + } + cpp += "}};\n\n"; + + cpp += + "const llama_ui_asset * llama_ui_find_asset(const std::string & name) {\n" + " for (const auto & a : g_assets) {\n" + " if (a.name == name) {\n" + " return &a;\n" + " }\n" + " }\n" + " return nullptr;\n" + "}\n"; + cpp += fmt("const std::array & llama_ui_get_assets() {\n", n_assets); + cpp += " return g_assets;\n" + "}\n"; + } else { + cpp += + "const llama_ui_asset * llama_ui_find_asset(const std::string &) {\n" + " return nullptr;\n" + "}\n" + "const std::array & llama_ui_get_assets() {\n" + " static const std::array empty{};\n" + " return empty;\n" + "}\n"; + } + cpp += fmt("bool llama_ui_use_gzip() { return %s; }\n", use_gzip ? "true" : "false"); + + bool ok = true; + ok = write_if_different(out_h, h) && ok; + ok = write_if_different(out_cpp, cpp) && ok; + return ok ? 0 : 1; +} diff --git a/tools/ui/eslint.config.js b/tools/ui/eslint.config.js new file mode 100644 index 0000000000000000000000000000000000000000..c65484048e806ceae7fa5d7e5fab90c2c057ad2b --- /dev/null +++ b/tools/ui/eslint.config.js @@ -0,0 +1,103 @@ +// For more info, see https://github.com/storybookjs/eslint-plugin-storybook#configuration-flat-config-format +import svelteConfig from './svelte.config.js'; +import { includeIgnoreFile } from '@eslint/compat'; +import js from '@eslint/js'; +import prettier from 'eslint-config-prettier'; +import perfectionist from 'eslint-plugin-perfectionist'; +import simpleImportSort from 'eslint-plugin-simple-import-sort'; +import storybook from 'eslint-plugin-storybook'; +import svelte from 'eslint-plugin-svelte'; +import globals from 'globals'; +import { fileURLToPath } from 'node:url'; +import ts from 'typescript-eslint'; + +const gitignorePath = fileURLToPath(new URL('./.gitignore', import.meta.url)); + +export default ts.config( + includeIgnoreFile(gitignorePath), + js.configs.recommended, + ...ts.configs.recommended, + ...svelte.configs.recommended, + prettier, + ...svelte.configs.prettier, + { + languageOptions: { globals: { ...globals.browser, ...globals.node } }, + plugins: { perfectionist, 'simple-import-sort': simpleImportSort }, + rules: { + // Snippet bodies often ignore one or more of the parent's params + // (e.g. `{#snippet children(_meta, ctx)}` when only ctx is read). + '@typescript-eslint/no-unused-vars': [ + 'error', + { argsIgnorePattern: '^_', varsIgnorePattern: '^_' } + ], + // Enforce empty line at end of file + 'eol-last': 'error', + // typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects. + // see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors + 'no-undef': 'off', + + 'padding-line-between-statements': [ + 'error', + // Blank line between function/class declarations. + { blankLine: 'always', next: ['function', 'class'], prev: ['function', 'class'] }, + // Blank line around if blocks (if/else and else if stay one statement). + { blankLine: 'always', next: '*', prev: 'if' }, + { blankLine: 'always', next: 'if', prev: '*' }, + // Blank line after the last declaration in a group. Because the 'never' + // rules below are scoped per declaration kind, a const group and a let + // group get separated by a blank line, while same-kind declarations stay + // together. + { blankLine: 'always', next: '*', prev: ['const', 'let', 'var'] }, + // No blank line between consecutive declarations of the same kind (kept + // last so each takes precedence over the always rule above for matching + // declaration pairs). + { blankLine: 'never', next: 'const', prev: 'const' }, + { blankLine: 'never', next: 'let', prev: 'let' }, + { blankLine: 'never', next: 'var', prev: 'var' }, + // Blank line before a statement that follows another statement in the block + // (works for return/throw/break/continue). A blank line for a terminal + // statement that opens a block body can't be enforced here: Prettier removes + // the leading blank line of a block, so the two formatters would fight. + { blankLine: 'always', next: ['return', 'throw', 'break', 'continue'], prev: '*' } + ], + + 'perfectionist/sort-objects': ['error', { type: 'natural' }], + + // Alphabetical order for variable declarations and object keys + 'perfectionist/sort-variable-declarations': ['error', { type: 'natural' }], + + // Sort imports alphabetically by module path, and sort named members within + // each statement. A single catch-all group keeps the list flat (no blank-line + // grouping); Prettier normalizes comma spacing afterwards. + 'simple-import-sort/imports': ['error', { groups: [['.*']] }], + 'svelte/no-at-html-tags': 'off', + + // This app uses hash-based routing (#/) where resolve() from $app/paths does not apply + 'svelte/no-navigation-without-resolve': 'off' + } + }, + { + files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'], + languageOptions: { + parserOptions: { + extraFileExtensions: ['.svelte'], + parser: ts.parser, + projectService: true, + svelteConfig + } + } + }, + { + // Exclude generated build output and Storybook files from ESLint + ignores: [ + 'dist/**', + 'build/**', + '.svelte-kit/**', + 'test-results/**', + '.storybook/**/*', + 'src/lib/services/sandbox-worker.js', + 'src/lib/vendors/**' + ] + }, + storybook.configs['flat/recommended'] +); diff --git a/tools/ui/node_modules/.bin/acorn b/tools/ui/node_modules/.bin/acorn new file mode 100644 index 0000000000000000000000000000000000000000..3ef3c124b08bd4fb0f27cd13301dfeeae4a6464c --- /dev/null +++ b/tools/ui/node_modules/.bin/acorn @@ -0,0 +1,4 @@ +#!/usr/bin/env node +"use strict" + +require("../dist/bin.js") diff --git a/tools/ui/node_modules/.bin/baseline-browser-mapping b/tools/ui/node_modules/.bin/baseline-browser-mapping new file mode 100644 index 0000000000000000000000000000000000000000..b52b3b0930145d6628f6c8fa770cdac7a5857684 --- /dev/null +++ b/tools/ui/node_modules/.bin/baseline-browser-mapping @@ -0,0 +1,2 @@ +#!/usr/bin/env node +"use strict";const{getCompatibleVersions:e}=require("./index.cjs"),a=process.argv.slice(2),s={};for(let e=0;e{let n={};process.env.DOTENV_CONFIG_ENCODING!=null&&(n.encoding=process.env.DOTENV_CONFIG_ENCODING),process.env.DOTENV_CONFIG_PATH!=null&&(n.path=process.env.DOTENV_CONFIG_PATH),process.env.DOTENV_CONFIG_QUIET!=null&&(n.quiet=process.env.DOTENV_CONFIG_QUIET),process.env.DOTENV_CONFIG_DEBUG!=null&&(n.debug=process.env.DOTENV_CONFIG_DEBUG),process.env.DOTENV_CONFIG_OVERRIDE!=null&&(n.override=process.env.DOTENV_CONFIG_OVERRIDE),process.env.DOTENV_CONFIG_DOTENV_KEY!=null&&(n.DOTENV_KEY=process.env.DOTENV_CONFIG_DOTENV_KEY),t.exports=n})),r=e.t(((e,t)=>{let n=/^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;t.exports=function(e){let t=e.reduce(function(e,t){let r=t.match(n);return r&&(e[r[1]]=r[2]),e},{});return`quiet`in t||(t.quiet=`true`),t}}));(function(){t.t().config(Object.assign({},n(),r()(process.argv)))})();const i={"generate-manifest":()=>Promise.resolve().then(()=>require(`./generateManifest-B2W0ZcyR.cjs`)).then(({main:e})=>e(process.argv.slice(3))),init:()=>Promise.resolve().then(()=>require(`./init-B913ABoW.cjs`)).then(({main:e})=>e(process.argv.slice(3))),main:()=>Promise.resolve().then(()=>require(`./main-BXErEqYy.cjs`)).then(({main:e})=>e(process.argv.slice(2))),"react-native-build":()=>Promise.resolve().then(()=>require(`./reactNativeBuild-BZStPtgU.cjs`)).then(({main:e})=>e(process.argv.slice(3))),trace:()=>Promise.resolve().then(()=>require(`./trace-pmv5IdSD.cjs`)).then(({main:e})=>e(process.argv.slice(3))),"trim-stats-file":()=>Promise.resolve().then(()=>require(`./trimStatsFile-Dx01BerQ.cjs`)).then(e=>e.n).then(({main:e})=>e(process.argv.slice(3)))};(i[process.argv[2]]||i.main)(); +//# sourceMappingURL=bin.cjs.map +//# debugId=28be70c2-4c98-5d5c-8ea0-27ba96d70a36 diff --git a/tools/ui/node_modules/.bin/chromatic b/tools/ui/node_modules/.bin/chromatic new file mode 100644 index 0000000000000000000000000000000000000000..ac7e62d69fd367272f1072cf24e0ccc97219a769 --- /dev/null +++ b/tools/ui/node_modules/.bin/chromatic @@ -0,0 +1,6 @@ +#!/usr/bin/env node + +!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="28be70c2-4c98-5d5c-8ea0-27ba96d70a36")}catch(e){}}(); +const e=require(`./chunk-gGpyby2o.cjs`),t=require(`./main-YTS_kgLz.cjs`);var n=e.t(((e,t)=>{let n={};process.env.DOTENV_CONFIG_ENCODING!=null&&(n.encoding=process.env.DOTENV_CONFIG_ENCODING),process.env.DOTENV_CONFIG_PATH!=null&&(n.path=process.env.DOTENV_CONFIG_PATH),process.env.DOTENV_CONFIG_QUIET!=null&&(n.quiet=process.env.DOTENV_CONFIG_QUIET),process.env.DOTENV_CONFIG_DEBUG!=null&&(n.debug=process.env.DOTENV_CONFIG_DEBUG),process.env.DOTENV_CONFIG_OVERRIDE!=null&&(n.override=process.env.DOTENV_CONFIG_OVERRIDE),process.env.DOTENV_CONFIG_DOTENV_KEY!=null&&(n.DOTENV_KEY=process.env.DOTENV_CONFIG_DOTENV_KEY),t.exports=n})),r=e.t(((e,t)=>{let n=/^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;t.exports=function(e){let t=e.reduce(function(e,t){let r=t.match(n);return r&&(e[r[1]]=r[2]),e},{});return`quiet`in t||(t.quiet=`true`),t}}));(function(){t.t().config(Object.assign({},n(),r()(process.argv)))})();const i={"generate-manifest":()=>Promise.resolve().then(()=>require(`./generateManifest-B2W0ZcyR.cjs`)).then(({main:e})=>e(process.argv.slice(3))),init:()=>Promise.resolve().then(()=>require(`./init-B913ABoW.cjs`)).then(({main:e})=>e(process.argv.slice(3))),main:()=>Promise.resolve().then(()=>require(`./main-BXErEqYy.cjs`)).then(({main:e})=>e(process.argv.slice(2))),"react-native-build":()=>Promise.resolve().then(()=>require(`./reactNativeBuild-BZStPtgU.cjs`)).then(({main:e})=>e(process.argv.slice(3))),trace:()=>Promise.resolve().then(()=>require(`./trace-pmv5IdSD.cjs`)).then(({main:e})=>e(process.argv.slice(3))),"trim-stats-file":()=>Promise.resolve().then(()=>require(`./trimStatsFile-Dx01BerQ.cjs`)).then(e=>e.n).then(({main:e})=>e(process.argv.slice(3)))};(i[process.argv[2]]||i.main)(); +//# sourceMappingURL=bin.cjs.map +//# debugId=28be70c2-4c98-5d5c-8ea0-27ba96d70a36 diff --git a/tools/ui/node_modules/.bin/chromatic-cli b/tools/ui/node_modules/.bin/chromatic-cli new file mode 100644 index 0000000000000000000000000000000000000000..ac7e62d69fd367272f1072cf24e0ccc97219a769 --- /dev/null +++ b/tools/ui/node_modules/.bin/chromatic-cli @@ -0,0 +1,6 @@ +#!/usr/bin/env node + +!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="28be70c2-4c98-5d5c-8ea0-27ba96d70a36")}catch(e){}}(); +const e=require(`./chunk-gGpyby2o.cjs`),t=require(`./main-YTS_kgLz.cjs`);var n=e.t(((e,t)=>{let n={};process.env.DOTENV_CONFIG_ENCODING!=null&&(n.encoding=process.env.DOTENV_CONFIG_ENCODING),process.env.DOTENV_CONFIG_PATH!=null&&(n.path=process.env.DOTENV_CONFIG_PATH),process.env.DOTENV_CONFIG_QUIET!=null&&(n.quiet=process.env.DOTENV_CONFIG_QUIET),process.env.DOTENV_CONFIG_DEBUG!=null&&(n.debug=process.env.DOTENV_CONFIG_DEBUG),process.env.DOTENV_CONFIG_OVERRIDE!=null&&(n.override=process.env.DOTENV_CONFIG_OVERRIDE),process.env.DOTENV_CONFIG_DOTENV_KEY!=null&&(n.DOTENV_KEY=process.env.DOTENV_CONFIG_DOTENV_KEY),t.exports=n})),r=e.t(((e,t)=>{let n=/^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;t.exports=function(e){let t=e.reduce(function(e,t){let r=t.match(n);return r&&(e[r[1]]=r[2]),e},{});return`quiet`in t||(t.quiet=`true`),t}}));(function(){t.t().config(Object.assign({},n(),r()(process.argv)))})();const i={"generate-manifest":()=>Promise.resolve().then(()=>require(`./generateManifest-B2W0ZcyR.cjs`)).then(({main:e})=>e(process.argv.slice(3))),init:()=>Promise.resolve().then(()=>require(`./init-B913ABoW.cjs`)).then(({main:e})=>e(process.argv.slice(3))),main:()=>Promise.resolve().then(()=>require(`./main-BXErEqYy.cjs`)).then(({main:e})=>e(process.argv.slice(2))),"react-native-build":()=>Promise.resolve().then(()=>require(`./reactNativeBuild-BZStPtgU.cjs`)).then(({main:e})=>e(process.argv.slice(3))),trace:()=>Promise.resolve().then(()=>require(`./trace-pmv5IdSD.cjs`)).then(({main:e})=>e(process.argv.slice(3))),"trim-stats-file":()=>Promise.resolve().then(()=>require(`./trimStatsFile-Dx01BerQ.cjs`)).then(e=>e.n).then(({main:e})=>e(process.argv.slice(3)))};(i[process.argv[2]]||i.main)(); +//# sourceMappingURL=bin.cjs.map +//# debugId=28be70c2-4c98-5d5c-8ea0-27ba96d70a36 diff --git a/tools/ui/node_modules/.bin/cssesc b/tools/ui/node_modules/.bin/cssesc new file mode 100644 index 0000000000000000000000000000000000000000..188c034ffe948300ab1a75496c2ea9e83c5a50bb --- /dev/null +++ b/tools/ui/node_modules/.bin/cssesc @@ -0,0 +1,116 @@ +#!/usr/bin/env node +const fs = require('fs'); +const cssesc = require('../cssesc.js'); +const strings = process.argv.splice(2); +const stdin = process.stdin; +const options = {}; +const log = console.log; + +const main = function() { + const option = strings[0]; + + if (/^(?:-h|--help|undefined)$/.test(option)) { + log( + 'cssesc v%s - https://mths.be/cssesc', + cssesc.version + ); + log([ + '\nUsage:\n', + '\tcssesc [string]', + '\tcssesc [-i | --identifier] [string]', + '\tcssesc [-s | --single-quotes] [string]', + '\tcssesc [-d | --double-quotes] [string]', + '\tcssesc [-w | --wrap] [string]', + '\tcssesc [-e | --escape-everything] [string]', + '\tcssesc [-v | --version]', + '\tcssesc [-h | --help]', + '\nExamples:\n', + '\tcssesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tcssesc --identifier \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tcssesc --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tcssesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | cssesc' + ].join('\n')); + return process.exit(1); + } + + if (/^(?:-v|--version)$/.test(option)) { + log('v%s', cssesc.version); + return process.exit(1); + } + + strings.forEach(function(string) { + // Process options + if (/^(?:-i|--identifier)$/.test(string)) { + options.isIdentifier = true; + return; + } + if (/^(?:-s|--single-quotes)$/.test(string)) { + options.quotes = 'single'; + return; + } + if (/^(?:-d|--double-quotes)$/.test(string)) { + options.quotes = 'double'; + return; + } + if (/^(?:-w|--wrap)$/.test(string)) { + options.wrap = true; + return; + } + if (/^(?:-e|--escape-everything)$/.test(string)) { + options.escapeEverything = true; + return; + } + + // Process string(s) + let result; + try { + result = cssesc(string, options); + log(result); + } catch (exception) { + log(exception.message + '\n'); + log('Error: failed to escape.'); + log('If you think this is a bug in cssesc, please report it:'); + log('https://github.com/mathiasbynens/cssesc/issues/new'); + log( + '\nStack trace using cssesc@%s:\n', + cssesc.version + ); + log(exception.stack); + return process.exit(1); + } + }); + // Return with exit status 0 outside of the `forEach` loop, in case + // multiple strings were passed in. + return process.exit(0); + +}; + +if (stdin.isTTY) { + // handle shell arguments + main(); +} else { + let timeout; + // Either the script is called from within a non-TTY context, or `stdin` + // content is being piped in. + if (!process.stdout.isTTY) { + // The script was called from a non-TTY context. This is a rather uncommon + // use case we don’t actively support. However, we don’t want the script + // to wait forever in such cases, so… + timeout = setTimeout(function() { + // …if no piped data arrived after a whole minute, handle shell + // arguments instead. + main(); + }, 60000); + } + let data = ''; + stdin.on('data', function(chunk) { + clearTimeout(timeout); + data += chunk; + }); + stdin.on('end', function() { + strings.push(data.trim()); + main(); + }); + stdin.resume(); +} diff --git a/tools/ui/node_modules/.bin/csv2json b/tools/ui/node_modules/.bin/csv2json new file mode 100644 index 0000000000000000000000000000000000000000..c2a447f85f3c9c3835f318569e3bd49937808449 --- /dev/null +++ b/tools/ui/node_modules/.bin/csv2json @@ -0,0 +1,38 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-a, --auto-type", "parse rows with type inference (see d3.autoType)") + .option("-n, --newline-delimited", "output newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + const rowConverter = options.autoType ? dsv.autoType : null + const rows = inFormat.parse(iconv.decode(text, options.inputEncoding), rowConverter); + rw.dash.writeFile(options.out, iconv.encode(options.newlineDelimited + ? rows.map((row) => JSON.stringify(row)).join("\n") + "\n" + : JSON.stringify(rows) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/csv2tsv b/tools/ui/node_modules/.bin/csv2tsv new file mode 100644 index 0000000000000000000000000000000000000000..0dd38ba121781de10fe8ccfe1ad382b9cc52b34b --- /dev/null +++ b/tools/ui/node_modules/.bin/csv2tsv @@ -0,0 +1,35 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + rw.dash.writeFile("-", iconv.encode(outFormat.format(inFormat.parse(iconv.decode(text, options.inputEncoding))) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/dsv2dsv b/tools/ui/node_modules/.bin/dsv2dsv new file mode 100644 index 0000000000000000000000000000000000000000..0dd38ba121781de10fe8ccfe1ad382b9cc52b34b --- /dev/null +++ b/tools/ui/node_modules/.bin/dsv2dsv @@ -0,0 +1,35 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + rw.dash.writeFile("-", iconv.encode(outFormat.format(inFormat.parse(iconv.decode(text, options.inputEncoding))) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/dsv2json b/tools/ui/node_modules/.bin/dsv2json new file mode 100644 index 0000000000000000000000000000000000000000..c2a447f85f3c9c3835f318569e3bd49937808449 --- /dev/null +++ b/tools/ui/node_modules/.bin/dsv2json @@ -0,0 +1,38 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-a, --auto-type", "parse rows with type inference (see d3.autoType)") + .option("-n, --newline-delimited", "output newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + const rowConverter = options.autoType ? dsv.autoType : null + const rows = inFormat.parse(iconv.decode(text, options.inputEncoding), rowConverter); + rw.dash.writeFile(options.out, iconv.encode(options.newlineDelimited + ? rows.map((row) => JSON.stringify(row)).join("\n") + "\n" + : JSON.stringify(rows) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/ejs b/tools/ui/node_modules/.bin/ejs new file mode 100644 index 0000000000000000000000000000000000000000..cb11aa4c03c8effadd4f4020837487c9680e1435 --- /dev/null +++ b/tools/ui/node_modules/.bin/ejs @@ -0,0 +1,211 @@ +#!/usr/bin/env node +/* + * EJS Embedded JavaScript templates + * Copyright 2112 Matthew Eernisse (mde@fleegix.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +let path = require('path'); + +let program = require('jake').program; +delete global.jake; // NO NOT WANT +program.setTaskNames = function (n) { this.taskNames = n; }; + +let ejs = require('../lib/ejs'); +let { hyphenToCamel } = require('../lib/utils'); +let fs = require('fs'); +let args = process.argv.slice(2); +let usage = fs.readFileSync(`${__dirname}/../usage.txt`).toString(); + +const CLI_OPTS = [ + { full: 'output-file', + abbr: 'o', + expectValue: true, + }, + { full: 'data-file', + abbr: 'f', + expectValue: true, + }, + { full: 'data-input', + abbr: 'i', + expectValue: true, + }, + { full: 'delimiter', + abbr: 'm', + expectValue: true, + passThrough: true, + }, + { full: 'open-delimiter', + abbr: 'p', + expectValue: true, + passThrough: true, + }, + { full: 'close-delimiter', + abbr: 'c', + expectValue: true, + passThrough: true, + }, + { full: 'strict', + abbr: 's', + expectValue: false, + allowValue: false, + passThrough: true, + }, + { full: 'no-with', + abbr: 'n', + expectValue: false, + allowValue: false, + }, + { full: 'locals-name', + abbr: 'l', + expectValue: true, + passThrough: true, + }, + { full: 'rm-whitespace', + abbr: 'w', + expectValue: false, + allowValue: false, + passThrough: true, + }, + { full: 'debug', + abbr: 'd', + expectValue: false, + allowValue: false, + passThrough: true, + }, + { full: 'help', + abbr: 'h', + passThrough: true, + }, + { full: 'version', + abbr: 'V', + passThrough: true, + }, + // Alias lowercase v + { full: 'version', + abbr: 'v', + passThrough: true, + }, +]; + +let preempts = { + version: function () { + program.die(ejs.VERSION); + }, + help: function () { + program.die(usage); + } +}; + +let stdin = ''; +process.stdin.setEncoding('utf8'); +process.stdin.on('readable', () => { + let chunk; + while ((chunk = process.stdin.read()) !== null) { + stdin += chunk; + } +}); + +function run() { + + program.availableOpts = CLI_OPTS; + program.parseArgs(args); + + let templatePath = program.taskNames[0]; + let pVals = program.envVars; + let pOpts = {}; + + for (let p in program.opts) { + let name = hyphenToCamel(p); + pOpts[name] = program.opts[p]; + } + + let opts = {}; + let vals = {}; + + // Same-named 'passthrough' opts + CLI_OPTS.forEach((opt) => { + let optName = hyphenToCamel(opt.full); + if (opt.passThrough && typeof pOpts[optName] != 'undefined') { + opts[optName] = pOpts[optName]; + } + }); + + // Bail out for help/version + for (let p in opts) { + if (preempts[p]) { + return preempts[p](); + } + } + + // Ensure there's a template to render + if (!templatePath) { + throw new Error('Please provide a template path. (Run ejs -h for help)'); + } + + if (opts.strict) { + pOpts.noWith = true; + } + if (pOpts.noWith) { + opts._with = false; + } + + // Grab and parse any input data, in order of precedence: + // 1. Stdin + // 2. CLI arg via -i + // 3. Data file via -f + // Any individual vals passed at the end (e.g., foo=bar) will override + // any vals previously set + let input; + let err = new Error('Please do not pass data multiple ways. Pick one of stdin, -f, or -i.'); + if (stdin) { + input = stdin; + } + else if (pOpts.dataInput) { + if (input) { + throw err; + } + input = decodeURIComponent(pOpts.dataInput); + } + else if (pOpts.dataFile) { + if (input) { + throw err; + } + input = fs.readFileSync(pOpts.dataFile).toString(); + } + + if (input) { + vals = JSON.parse(input); + } + + // Override / set any individual values passed from the command line + for (let p in pVals) { + vals[p] = pVals[p]; + } + + opts.filename = path.resolve(process.cwd(), templatePath); + let template = fs.readFileSync(opts.filename).toString(); + let output = ejs.render(template, vals, opts); + if (pOpts.outputFile) { + fs.writeFileSync(pOpts.outputFile, output); + } + else { + process.stdout.write(output); + } + process.exit(); +} + +// Defer execution so that stdin can be read if necessary +setImmediate(run); diff --git a/tools/ui/node_modules/.bin/esbuild b/tools/ui/node_modules/.bin/esbuild new file mode 100644 index 0000000000000000000000000000000000000000..0045b52bdf0f07a10b166f676abcdd2d419325d7 --- /dev/null +++ b/tools/ui/node_modules/.bin/esbuild @@ -0,0 +1,223 @@ +#!/usr/bin/env node +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// lib/npm/node-platform.ts +var fs = require("fs"); +var os = require("os"); +var path = require("path"); +var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH; +var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild"; +var packageDarwin_arm64 = "@esbuild/darwin-arm64"; +var packageDarwin_x64 = "@esbuild/darwin-x64"; +var knownWindowsPackages = { + "win32 arm64 LE": "@esbuild/win32-arm64", + "win32 ia32 LE": "@esbuild/win32-ia32", + "win32 x64 LE": "@esbuild/win32-x64" +}; +var knownUnixlikePackages = { + "aix ppc64 BE": "@esbuild/aix-ppc64", + "android arm64 LE": "@esbuild/android-arm64", + "darwin arm64 LE": "@esbuild/darwin-arm64", + "darwin x64 LE": "@esbuild/darwin-x64", + "freebsd arm64 LE": "@esbuild/freebsd-arm64", + "freebsd x64 LE": "@esbuild/freebsd-x64", + "linux arm LE": "@esbuild/linux-arm", + "linux arm64 LE": "@esbuild/linux-arm64", + "linux ia32 LE": "@esbuild/linux-ia32", + "linux mips64el LE": "@esbuild/linux-mips64el", + "linux ppc64 LE": "@esbuild/linux-ppc64", + "linux riscv64 LE": "@esbuild/linux-riscv64", + "linux s390x BE": "@esbuild/linux-s390x", + "linux x64 LE": "@esbuild/linux-x64", + "linux loong64 LE": "@esbuild/linux-loong64", + "netbsd arm64 LE": "@esbuild/netbsd-arm64", + "netbsd x64 LE": "@esbuild/netbsd-x64", + "openbsd arm64 LE": "@esbuild/openbsd-arm64", + "openbsd x64 LE": "@esbuild/openbsd-x64", + "sunos x64 LE": "@esbuild/sunos-x64" +}; +var knownWebAssemblyFallbackPackages = { + "android arm LE": "@esbuild/android-arm", + "android x64 LE": "@esbuild/android-x64", + "openharmony arm64 LE": "@esbuild/openharmony-arm64" +}; +function pkgAndSubpathForCurrentPlatform() { + let pkg; + let subpath; + let isWASM2 = false; + let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`; + if (platformKey in knownWindowsPackages) { + pkg = knownWindowsPackages[platformKey]; + subpath = "esbuild.exe"; + } else if (platformKey in knownUnixlikePackages) { + pkg = knownUnixlikePackages[platformKey]; + subpath = "bin/esbuild"; + } else if (platformKey in knownWebAssemblyFallbackPackages) { + pkg = knownWebAssemblyFallbackPackages[platformKey]; + subpath = "bin/esbuild"; + isWASM2 = true; + } else { + throw new Error(`Unsupported platform: ${platformKey}`); + } + return { pkg, subpath, isWASM: isWASM2 }; +} +function pkgForSomeOtherPlatform() { + const libMainJS = require.resolve("esbuild"); + const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS))); + if (path.basename(nodeModulesDirectory) === "node_modules") { + for (const unixKey in knownUnixlikePackages) { + try { + const pkg = knownUnixlikePackages[unixKey]; + if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg; + } catch { + } + } + for (const windowsKey in knownWindowsPackages) { + try { + const pkg = knownWindowsPackages[windowsKey]; + if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg; + } catch { + } + } + } + return null; +} +function downloadedBinPath(pkg, subpath) { + const esbuildLibDir = path.dirname(require.resolve("esbuild")); + return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`); +} +function generateBinPath() { + if (isValidBinaryPath(ESBUILD_BINARY_PATH)) { + if (!fs.existsSync(ESBUILD_BINARY_PATH)) { + console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`); + } else { + return { binPath: ESBUILD_BINARY_PATH, isWASM: false }; + } + } + const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform(); + let binPath2; + try { + binPath2 = require.resolve(`${pkg}/${subpath}`); + } catch (e) { + binPath2 = downloadedBinPath(pkg, subpath); + if (!fs.existsSync(binPath2)) { + try { + require.resolve(pkg); + } catch { + const otherPkg = pkgForSomeOtherPlatform(); + if (otherPkg) { + let suggestions = ` +Specifically the "${otherPkg}" package is present but this platform +needs the "${pkg}" package instead. People often get into this +situation by installing esbuild on Windows or macOS and copying "node_modules" +into a Docker image that runs Linux, or by copying "node_modules" between +Windows and WSL environments. + +If you are installing with npm, you can try not copying the "node_modules" +directory when you copy the files over, and running "npm ci" or "npm install" +on the destination platform after the copy. Or you could consider using yarn +instead of npm which has built-in support for installing a package on multiple +platforms simultaneously. + +If you are installing with yarn, you can try listing both this platform and the +other platform in your ".yarnrc.yml" file using the "supportedArchitectures" +feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures +Keep in mind that this means multiple copies of esbuild will be present. +`; + if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) { + suggestions = ` +Specifically the "${otherPkg}" package is present but this platform +needs the "${pkg}" package instead. People often get into this +situation by installing esbuild with npm running inside of Rosetta 2 and then +trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta +2 is Apple's on-the-fly x86_64-to-arm64 translation service). + +If you are installing with npm, you can try ensuring that both npm and node are +not running under Rosetta 2 and then reinstalling esbuild. This likely involves +changing how you installed npm and/or node. For example, installing node with +the universal installer here should work: https://nodejs.org/en/download/. Or +you could consider using yarn instead of npm which has built-in support for +installing a package on multiple platforms simultaneously. + +If you are installing with yarn, you can try listing both "arm64" and "x64" +in your ".yarnrc.yml" file using the "supportedArchitectures" feature: +https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures +Keep in mind that this means multiple copies of esbuild will be present. +`; + } + throw new Error(` +You installed esbuild for another platform than the one you're currently using. +This won't work because esbuild is written with native code and needs to +install a platform-specific binary executable. +${suggestions} +Another alternative is to use the "esbuild-wasm" package instead, which works +the same way on all platforms. But it comes with a heavy performance cost and +can sometimes be 10x slower than the "esbuild" package, so you may also not +want to do that. +`); + } + throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild. + +If you are installing esbuild with npm, make sure that you don't specify the +"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature +of "package.json" is used by esbuild to install the correct binary executable +for your current platform.`); + } + throw e; + } + } + if (/\.zip\//.test(binPath2)) { + let pnpapi; + try { + pnpapi = require("pnpapi"); + } catch (e) { + } + if (pnpapi) { + const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation; + const binTargetPath = path.join( + root, + "node_modules", + ".cache", + "esbuild", + `pnpapi-${pkg.replace("/", "-")}-${"0.28.1"}-${path.basename(subpath)}` + ); + if (!fs.existsSync(binTargetPath)) { + fs.mkdirSync(path.dirname(binTargetPath), { recursive: true }); + fs.copyFileSync(binPath2, binTargetPath); + fs.chmodSync(binTargetPath, 493); + } + return { binPath: binTargetPath, isWASM: isWASM2 }; + } + } + return { binPath: binPath2, isWASM: isWASM2 }; +} + +// lib/npm/node-shim.ts +var { binPath, isWASM } = generateBinPath(); +if (isWASM) { + require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" }); +} else { + require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" }); +} diff --git a/tools/ui/node_modules/.bin/eslint b/tools/ui/node_modules/.bin/eslint new file mode 100644 index 0000000000000000000000000000000000000000..9b202a98233128cd3b46c71940c27dfbf334c5df --- /dev/null +++ b/tools/ui/node_modules/.bin/eslint @@ -0,0 +1,196 @@ +#!/usr/bin/env node + +/** + * @fileoverview Main CLI that is run via the eslint command. + * @author Nicholas C. Zakas + */ + +/* eslint no-console:off -- CLI */ + +"use strict"; + +const mod = require("node:module"); + +// to use V8's code cache to speed up instantiation time +mod.enableCompileCache?.(); + +// must do this initialization *before* other requires in order to work +if (process.argv.includes("--debug")) { + require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*"); +} + +//------------------------------------------------------------------------------ +// Helpers +//------------------------------------------------------------------------------ + +/** + * Read data from stdin til the end. + * + * Note: See + * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin + * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io + * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html + * - https://github.com/nodejs/node/issues/7439 (historical) + * + * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems + * to read 4096 bytes before blocking and never drains to read further data. + * + * The investigation on the Emacs thread indicates: + * + * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a + * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than + * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for + * > the subprocess to read its end of the pipe, at which time Emacs will + * > write the rest of the stuff. + * @returns {Promise} The read text. + */ +function readStdin() { + return new Promise((resolve, reject) => { + let content = ""; + let chunk = ""; + + process.stdin + .setEncoding("utf8") + .on("readable", () => { + while ((chunk = process.stdin.read()) !== null) { + content += chunk; + } + }) + .on("end", () => resolve(content)) + .on("error", reject); + }); +} + +/** + * Get the error message of a given value. + * @param {any} error The value to get. + * @returns {string} The error message. + */ +function getErrorMessage(error) { + // Lazy loading because this is used only if an error happened. + const util = require("node:util"); + + // Foolproof -- third-party module might throw non-object. + if (typeof error !== "object" || error === null) { + return String(error); + } + + // Use templates if `error.messageTemplate` is present. + if (typeof error.messageTemplate === "string") { + try { + const template = require(`../messages/${error.messageTemplate}.js`); + + return template(error.messageData || {}); + } catch { + // Ignore template error then fallback to use `error.stack`. + } + } + + // Use the stacktrace if it's an error object. + if (typeof error.stack === "string") { + return error.stack; + } + + // Otherwise, dump the object. + return util.format("%o", error); +} + +/** + * Tracks error messages that are shown to the user so we only ever show the + * same message once. + * @type {Set} + */ +const displayedErrors = new Set(); + +/** + * Tracks whether an unexpected error was caught + * @type {boolean} + */ +let hadFatalError = false; + +/** + * Catch and report unexpected error. + * @param {any} error The thrown error object. + * @returns {void} + */ +function onFatalError(error) { + process.exitCode = 2; + hadFatalError = true; + + const { version } = require("../package.json"); + const message = ` +Oops! Something went wrong! :( + +ESLint: ${version} + +${getErrorMessage(error)}`; + + if (!displayedErrors.has(message)) { + console.error(message); + displayedErrors.add(message); + } +} + +//------------------------------------------------------------------------------ +// Execution +//------------------------------------------------------------------------------ + +(async function main() { + process.on("uncaughtException", onFatalError); + process.on("unhandledRejection", onFatalError); + + // Call the config initializer if `--init` is present. + if (process.argv.includes("--init")) { + // `eslint --init` has been moved to `@eslint/create-config` + console.warn( + "You can also run this command directly using 'npm init @eslint/config@latest'.", + ); + + const spawn = require("cross-spawn"); + + spawn.sync("npm", ["init", "@eslint/config@latest"], { + encoding: "utf8", + stdio: "inherit", + }); + return; + } + + // start the MCP server if `--mcp` is present + if (process.argv.includes("--mcp")) { + console.warn( + "You can also run this command directly using 'npx @eslint/mcp@latest'.", + ); + + const spawn = require("cross-spawn"); + + spawn.sync("npx", ["@eslint/mcp@latest"], { + encoding: "utf8", + stdio: "inherit", + }); + return; + } + + // Otherwise, call the CLI. + const cli = require("../lib/cli"); + const exitCode = await cli.execute( + process.argv, + process.argv.includes("--stdin") ? await readStdin() : null, + true, + ); + + /* + * If an uncaught exception or unhandled rejection was detected in the meantime, + * keep the fatal exit code 2 that is already assigned to `process.exitCode`. + * Without this condition, exit code 2 (unsuccessful execution) could be overwritten with + * 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found). + * This ensures that unexpected errors that seemingly don't affect the success + * of the execution will still cause a non-zero exit code, as it's a common + * practice and the default behavior of Node.js to exit with non-zero + * in case of an uncaught exception or unhandled rejection. + * + * Otherwise, assign the exit code returned from CLI. + */ + if (!hadFatalError) { + process.exitCode = exitCode; + } +})().catch(onFatalError); diff --git a/tools/ui/node_modules/.bin/eslint-config-prettier b/tools/ui/node_modules/.bin/eslint-config-prettier new file mode 100644 index 0000000000000000000000000000000000000000..da85433640340258448a748ac62b830855f8a668 --- /dev/null +++ b/tools/ui/node_modules/.bin/eslint-config-prettier @@ -0,0 +1,240 @@ +#!/usr/bin/env node + +"use strict"; + +const validators = require("./validators"); +const config = require(".."); +const prettier = require("../prettier"); + +// Require locally installed eslint, for `npx eslint-config-prettier` support +// with no local eslint-config-prettier installation. +const localRequire = (request) => + require( + require.resolve(request, { + paths: [process.cwd(), ...require.resolve.paths("eslint")], + }) + ); + +let experimentalApi = {}; +try { + experimentalApi = localRequire("eslint/use-at-your-own-risk"); +} catch (_error) {} + +const { ESLint, FlatESLint = experimentalApi.FlatESLint } = + localRequire("eslint"); + +const SPECIAL_RULES_URL = + "https://github.com/prettier/eslint-config-prettier#special-rules"; + +const PRETTIER_RULES_URL = + "https://github.com/prettier/eslint-config-prettier#arrow-body-style-and-prefer-arrow-callback"; + +if (module === require.main) { + const args = process.argv.slice(2); + + if (args.length === 0) { + console.error(help()); + process.exit(1); + } + + const eslint = new ESLint(); + const flatESLint = FlatESLint === undefined ? undefined : new FlatESLint(); + + Promise.all( + args.map((file) => { + switch (process.env.ESLINT_USE_FLAT_CONFIG) { + case "true": { + return flatESLint.calculateConfigForFile(file); + } + case "false": { + return eslint.calculateConfigForFile(file); + } + default: { + // This turns synchronous errors (such as `.calculateConfigForFile` not existing) + // and turns them into promise rejections. + return Promise.resolve() + .then(() => flatESLint.calculateConfigForFile(file)) + .catch(() => eslint.calculateConfigForFile(file)); + } + } + }) + ) + .then((configs) => { + const rules = configs.flatMap( + ( + // Initializing config and rules for files that aren't included in the flat config, + // which is a very unlikely scenario, but should still be treated as a success + { rules = {} } = {}, + index + ) => Object.entries(rules).map((entry) => [...entry, args[index]]) + ); + const result = processRules(rules); + if (result.stderr) { + console.error(result.stderr); + } + if (result.stdout) { + console.error(result.stdout); + } + process.exit(result.code); + }) + .catch((error) => { + console.error(error.message); + process.exit(1); + }); +} + +function help() { + return ` +Usage: npx eslint-config-prettier FILE... + +Resolves an ESLint configuration for every given FILE and checks if they +contain rules that are unnecessary or conflict with Prettier. Example: + + npx eslint-config-prettier index.js test/index.js other/file/to/check.js + +Exit codes: + +0: No automatically detectable problems found. +1: General error. +2: Conflicting rules found. + +For more information, see: +https://github.com/prettier/eslint-config-prettier#cli-helper-tool + `.trim(); +} + +function processRules(configRules) { + const regularRules = filterRules(config.rules, (_, value) => value === "off"); + const optionsRules = filterRules( + config.rules, + (ruleName, value) => value === 0 && ruleName in validators + ); + const specialRules = filterRules( + config.rules, + (ruleName, value) => value === 0 && !(ruleName in validators) + ); + + const enabledRules = configRules + .map(([ruleName, value, source]) => { + const arrayValue = Array.isArray(value) ? value : [value]; + const [level, ...options] = arrayValue; + const isOff = level === "off" || level === 0; + return isOff ? null : { ruleName, options, source }; + }) + .filter(Boolean); + + const flaggedRules = enabledRules.filter( + ({ ruleName }) => ruleName in config.rules + ); + + const regularFlaggedRuleNames = filterRuleNames( + flaggedRules, + ({ ruleName }) => ruleName in regularRules + ); + const optionsFlaggedRuleNames = filterRuleNames( + flaggedRules, + ({ ruleName, ...rule }) => + ruleName in optionsRules && !validators[ruleName](rule) + ); + const specialFlaggedRuleNames = filterRuleNames( + flaggedRules, + ({ ruleName }) => ruleName in specialRules + ); + const prettierFlaggedRuleNames = filterRuleNames( + enabledRules, + ({ ruleName, source }) => + ruleName in prettier.rules && + enabledRules.some( + (rule) => + rule.ruleName === "prettier/prettier" && rule.source === source + ) + ); + + const regularMessage = [ + "The following rules are unnecessary or might conflict with Prettier:", + "", + printRuleNames(regularFlaggedRuleNames), + ].join("\n"); + + const optionsMessage = [ + "The following rules are enabled with config that might conflict with Prettier. See:", + SPECIAL_RULES_URL, + "", + printRuleNames(optionsFlaggedRuleNames), + ].join("\n"); + + const specialMessage = [ + "The following rules are enabled but cannot be automatically checked. See:", + SPECIAL_RULES_URL, + "", + printRuleNames(specialFlaggedRuleNames), + ].join("\n"); + + const prettierMessage = [ + "The following rules can cause issues when using eslint-plugin-prettier at the same time.", + "Only enable them if you know what you are doing! See:", + PRETTIER_RULES_URL, + "", + printRuleNames(prettierFlaggedRuleNames), + ].join("\n"); + + if ( + regularFlaggedRuleNames.length === 0 && + optionsFlaggedRuleNames.length === 0 + ) { + const message = + specialFlaggedRuleNames.length === 0 && + prettierFlaggedRuleNames.length === 0 + ? "No rules that are unnecessary or conflict with Prettier were found." + : [ + specialFlaggedRuleNames.length === 0 ? null : specialMessage, + prettierFlaggedRuleNames.length === 0 ? null : prettierMessage, + "Other than that, no rules that are unnecessary or conflict with Prettier were found.", + ] + .filter(Boolean) + .join("\n\n"); + + return { + stdout: message, + code: 0, + }; + } + + const message = [ + regularFlaggedRuleNames.length === 0 ? null : regularMessage, + optionsFlaggedRuleNames.length === 0 ? null : optionsMessage, + specialFlaggedRuleNames.length === 0 ? null : specialMessage, + prettierFlaggedRuleNames.length === 0 ? null : prettierMessage, + ] + .filter(Boolean) + .join("\n\n"); + + return { + stdout: message, + code: 2, + }; +} + +function filterRules(rules, fn) { + return Object.fromEntries( + Object.entries(rules) + .filter(([ruleName, value]) => fn(ruleName, value)) + .map(([ruleName]) => [ruleName, true]) + ); +} + +function filterRuleNames(rules, fn) { + return [ + ...new Set(rules.filter((rule) => fn(rule)).map((rule) => rule.ruleName)), + ]; +} + +function printRuleNames(ruleNames) { + return ruleNames + .slice() + .sort() + .map((ruleName) => `- ${ruleName}`) + .join("\n"); +} + +exports.processRules = processRules; diff --git a/tools/ui/node_modules/.bin/esparse b/tools/ui/node_modules/.bin/esparse new file mode 100644 index 0000000000000000000000000000000000000000..45d05fbb732673ddbd05d73e9a737d94d26742f2 --- /dev/null +++ b/tools/ui/node_modules/.bin/esparse @@ -0,0 +1,139 @@ +#!/usr/bin/env node +/* + Copyright JS Foundation and other contributors, https://js.foundation/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*jslint sloppy:true node:true rhino:true */ + +var fs, esprima, fname, forceFile, content, options, syntax; + +if (typeof require === 'function') { + fs = require('fs'); + try { + esprima = require('esprima'); + } catch (e) { + esprima = require('../'); + } +} else if (typeof load === 'function') { + try { + load('esprima.js'); + } catch (e) { + load('../esprima.js'); + } +} + +// Shims to Node.js objects when running under Rhino. +if (typeof console === 'undefined' && typeof process === 'undefined') { + console = { log: print }; + fs = { readFileSync: readFile }; + process = { argv: arguments, exit: quit }; + process.argv.unshift('esparse.js'); + process.argv.unshift('rhino'); +} + +function showUsage() { + console.log('Usage:'); + console.log(' esparse [options] [file.js]'); + console.log(); + console.log('Available options:'); + console.log(); + console.log(' --comment Gather all line and block comments in an array'); + console.log(' --loc Include line-column location info for each syntax node'); + console.log(' --range Include index-based range for each syntax node'); + console.log(' --raw Display the raw value of literals'); + console.log(' --tokens List all tokens in an array'); + console.log(' --tolerant Tolerate errors on a best-effort basis (experimental)'); + console.log(' -v, --version Shows program version'); + console.log(); + process.exit(1); +} + +options = {}; + +process.argv.splice(2).forEach(function (entry) { + + if (forceFile || entry === '-' || entry.slice(0, 1) !== '-') { + if (typeof fname === 'string') { + console.log('Error: more than one input file.'); + process.exit(1); + } else { + fname = entry; + } + } else if (entry === '-h' || entry === '--help') { + showUsage(); + } else if (entry === '-v' || entry === '--version') { + console.log('ECMAScript Parser (using Esprima version', esprima.version, ')'); + console.log(); + process.exit(0); + } else if (entry === '--comment') { + options.comment = true; + } else if (entry === '--loc') { + options.loc = true; + } else if (entry === '--range') { + options.range = true; + } else if (entry === '--raw') { + options.raw = true; + } else if (entry === '--tokens') { + options.tokens = true; + } else if (entry === '--tolerant') { + options.tolerant = true; + } else if (entry === '--') { + forceFile = true; + } else { + console.log('Error: unknown option ' + entry + '.'); + process.exit(1); + } +}); + +// Special handling for regular expression literal since we need to +// convert it to a string literal, otherwise it will be decoded +// as object "{}" and the regular expression would be lost. +function adjustRegexLiteral(key, value) { + if (key === 'value' && value instanceof RegExp) { + value = value.toString(); + } + return value; +} + +function run(content) { + syntax = esprima.parse(content, options); + console.log(JSON.stringify(syntax, adjustRegexLiteral, 4)); +} + +try { + if (fname && (fname !== '-' || forceFile)) { + run(fs.readFileSync(fname, 'utf-8')); + } else { + var content = ''; + process.stdin.resume(); + process.stdin.on('data', function(chunk) { + content += chunk; + }); + process.stdin.on('end', function() { + run(content); + }); + } +} catch (e) { + console.log('Error: ' + e.message); + process.exit(1); +} diff --git a/tools/ui/node_modules/.bin/esvalidate b/tools/ui/node_modules/.bin/esvalidate new file mode 100644 index 0000000000000000000000000000000000000000..d49a7e40a8c3d409aec5256a317c60dc98e8eefc --- /dev/null +++ b/tools/ui/node_modules/.bin/esvalidate @@ -0,0 +1,236 @@ +#!/usr/bin/env node +/* + Copyright JS Foundation and other contributors, https://js.foundation/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/*jslint sloppy:true plusplus:true node:true rhino:true */ +/*global phantom:true */ + +var fs, system, esprima, options, fnames, forceFile, count; + +if (typeof esprima === 'undefined') { + // PhantomJS can only require() relative files + if (typeof phantom === 'object') { + fs = require('fs'); + system = require('system'); + esprima = require('./esprima'); + } else if (typeof require === 'function') { + fs = require('fs'); + try { + esprima = require('esprima'); + } catch (e) { + esprima = require('../'); + } + } else if (typeof load === 'function') { + try { + load('esprima.js'); + } catch (e) { + load('../esprima.js'); + } + } +} + +// Shims to Node.js objects when running under PhantomJS 1.7+. +if (typeof phantom === 'object') { + fs.readFileSync = fs.read; + process = { + argv: [].slice.call(system.args), + exit: phantom.exit, + on: function (evt, callback) { + callback(); + } + }; + process.argv.unshift('phantomjs'); +} + +// Shims to Node.js objects when running under Rhino. +if (typeof console === 'undefined' && typeof process === 'undefined') { + console = { log: print }; + fs = { readFileSync: readFile }; + process = { + argv: arguments, + exit: quit, + on: function (evt, callback) { + callback(); + } + }; + process.argv.unshift('esvalidate.js'); + process.argv.unshift('rhino'); +} + +function showUsage() { + console.log('Usage:'); + console.log(' esvalidate [options] [file.js...]'); + console.log(); + console.log('Available options:'); + console.log(); + console.log(' --format=type Set the report format, plain (default) or junit'); + console.log(' -v, --version Print program version'); + console.log(); + process.exit(1); +} + +options = { + format: 'plain' +}; + +fnames = []; + +process.argv.splice(2).forEach(function (entry) { + + if (forceFile || entry === '-' || entry.slice(0, 1) !== '-') { + fnames.push(entry); + } else if (entry === '-h' || entry === '--help') { + showUsage(); + } else if (entry === '-v' || entry === '--version') { + console.log('ECMAScript Validator (using Esprima version', esprima.version, ')'); + console.log(); + process.exit(0); + } else if (entry.slice(0, 9) === '--format=') { + options.format = entry.slice(9); + if (options.format !== 'plain' && options.format !== 'junit') { + console.log('Error: unknown report format ' + options.format + '.'); + process.exit(1); + } + } else if (entry === '--') { + forceFile = true; + } else { + console.log('Error: unknown option ' + entry + '.'); + process.exit(1); + } +}); + +if (fnames.length === 0) { + fnames.push(''); +} + +if (options.format === 'junit') { + console.log(''); + console.log(''); +} + +count = 0; + +function run(fname, content) { + var timestamp, syntax, name; + try { + if (typeof content !== 'string') { + throw content; + } + + if (content[0] === '#' && content[1] === '!') { + content = '//' + content.substr(2, content.length); + } + + timestamp = Date.now(); + syntax = esprima.parse(content, { tolerant: true }); + + if (options.format === 'junit') { + + name = fname; + if (name.lastIndexOf('/') >= 0) { + name = name.slice(name.lastIndexOf('/') + 1); + } + + console.log(''); + + syntax.errors.forEach(function (error) { + var msg = error.message; + msg = msg.replace(/^Line\ [0-9]*\:\ /, ''); + console.log(' '); + console.log(' ' + + error.message + '(' + name + ':' + error.lineNumber + ')' + + ''); + console.log(' '); + }); + + console.log(''); + + } else if (options.format === 'plain') { + + syntax.errors.forEach(function (error) { + var msg = error.message; + msg = msg.replace(/^Line\ [0-9]*\:\ /, ''); + msg = fname + ':' + error.lineNumber + ': ' + msg; + console.log(msg); + ++count; + }); + + } + } catch (e) { + ++count; + if (options.format === 'junit') { + console.log(''); + console.log(' '); + console.log(' ' + + e.message + '(' + fname + ((e.lineNumber) ? ':' + e.lineNumber : '') + + ')'); + console.log(' '); + console.log(''); + } else { + console.log(fname + ':' + e.lineNumber + ': ' + e.message.replace(/^Line\ [0-9]*\:\ /, '')); + } + } +} + +fnames.forEach(function (fname) { + var content = ''; + try { + if (fname && (fname !== '-' || forceFile)) { + content = fs.readFileSync(fname, 'utf-8'); + } else { + fname = ''; + process.stdin.resume(); + process.stdin.on('data', function(chunk) { + content += chunk; + }); + process.stdin.on('end', function() { + run(fname, content); + }); + return; + } + } catch (e) { + content = e; + } + run(fname, content); +}); + +process.on('exit', function () { + if (options.format === 'junit') { + console.log(''); + } + + if (count > 0) { + process.exit(1); + } + + if (count === 0 && typeof phantom === 'object') { + process.exit(0); + } +}); diff --git a/tools/ui/node_modules/.bin/he b/tools/ui/node_modules/.bin/he new file mode 100644 index 0000000000000000000000000000000000000000..cfdfd6c31aaa09f26d7493680c5bfbd45f6e4384 --- /dev/null +++ b/tools/ui/node_modules/.bin/he @@ -0,0 +1,148 @@ +#!/usr/bin/env node +(function() { + + var fs = require('fs'); + var he = require('../he.js'); + var strings = process.argv.splice(2); + var stdin = process.stdin; + var data; + var timeout; + var action; + var options = {}; + var log = console.log; + + var main = function() { + var option = strings[0]; + var count = 0; + + if (/^(?:-h|--help|undefined)$/.test(option)) { + log( + 'he v%s - https://mths.be/he', + he.version + ); + log([ + '\nUsage:\n', + '\the [--escape] string', + '\the [--encode] [--use-named-refs] [--everything] [--allow-unsafe] [--decimal] string', + '\the [--decode] [--attribute] [--strict] string', + '\the [-v | --version]', + '\the [-h | --help]', + '\nExamples:\n', + '\the --escape \\', + '\techo \'© 𝌆\' | he --decode' + ].join('\n')); + return process.exit(option ? 0 : 1); + } + + if (/^(?:-v|--version)$/.test(option)) { + log('v%s', he.version); + return process.exit(0); + } + + strings.forEach(function(string) { + // Process options + if (string == '--escape') { + action = 'escape'; + return; + } + if (string == '--encode') { + action = 'encode'; + return; + } + if (string == '--use-named-refs') { + action = 'encode'; + options.useNamedReferences = true; + return; + } + if (string == '--everything') { + action = 'encode'; + options.encodeEverything = true; + return; + } + if (string == '--allow-unsafe') { + action = 'encode'; + options.allowUnsafeSymbols = true; + return; + } + if (string == '--decimal') { + action = 'encode'; + options.decimal = true; + return; + } + if (string == '--decode') { + action = 'decode'; + return; + } + if (string == '--attribute') { + action = 'decode'; + options.isAttributeValue = true; + return; + } + if (string == '--strict') { + action = 'decode'; + options.strict = true; + return; + } + // Process string(s) + var result; + if (!action) { + log('Error: he requires at least one option and a string argument.'); + log('Try `he --help` for more information.'); + return process.exit(1); + } + try { + result = he[action](string, options); + log(result); + count++; + } catch(error) { + log(error.message + '\n'); + log('Error: failed to %s.', action); + log('If you think this is a bug in he, please report it:'); + log('https://github.com/mathiasbynens/he/issues/new'); + log( + '\nStack trace using he@%s:\n', + he.version + ); + log(error.stack); + return process.exit(1); + } + }); + if (!count) { + log('Error: he requires a string argument.'); + log('Try `he --help` for more information.'); + return process.exit(1); + } + // Return with exit status 0 outside of the `forEach` loop, in case + // multiple strings were passed in. + return process.exit(0); + }; + + if (stdin.isTTY) { + // handle shell arguments + main(); + } else { + // Either the script is called from within a non-TTY context, or `stdin` + // content is being piped in. + if (!process.stdout.isTTY) { + // The script was called from a non-TTY context. This is a rather uncommon + // use case we don’t actively support. However, we don’t want the script + // to wait forever in such cases, so… + timeout = setTimeout(function() { + // …if no piped data arrived after a whole minute, handle shell + // arguments instead. + main(); + }, 60000); + } + data = ''; + stdin.on('data', function(chunk) { + clearTimeout(timeout); + data += chunk; + }); + stdin.on('end', function() { + strings.push(data.trim()); + main(); + }); + stdin.resume(); + } + +}()); diff --git a/tools/ui/node_modules/.bin/http-server b/tools/ui/node_modules/.bin/http-server new file mode 100644 index 0000000000000000000000000000000000000000..7c597fa8ab82f173661ca1d6bbbc94b910d5d4e1 --- /dev/null +++ b/tools/ui/node_modules/.bin/http-server @@ -0,0 +1,278 @@ +#!/usr/bin/env node + +'use strict'; + +var chalk = require('chalk'), + os = require('os'), + httpServer = require('../lib/http-server'), + portfinder = require('portfinder'), + opener = require('opener'), + + fs = require('fs'), + url = require('url'); +var argv = require('minimist')(process.argv.slice(2), { + alias: { + tls: 'ssl' + } +}); +var ifaces = os.networkInterfaces(); + +process.title = 'http-server'; + +if (argv.h || argv.help) { + console.log([ + 'usage: http-server [path] [options]', + '', + 'options:', + ' -p --port Port to use. If 0, look for open port. [8080]', + ' -a Address to use [0.0.0.0]', + ' -d Show directory listings [true]', + ' -i Display autoIndex [true]', + ' -g --gzip Serve gzip files when possible [false]', + ' -b --brotli Serve brotli files when possible [false]', + ' If both brotli and gzip are enabled, brotli takes precedence', + ' -e --ext Default file extension if none supplied [none]', + ' -s --silent Suppress log messages from output', + ' --cors[=headers] Enable CORS via the "Access-Control-Allow-Origin" header', + ' Optionally provide CORS headers list separated by commas', + ' -o [path] Open browser window after starting the server.', + ' Optionally provide a URL path to open the browser window to.', + ' -c Cache time (max-age) in seconds [3600], e.g. -c10 for 10 seconds.', + ' To disable caching, use -c-1.', + ' -t Connections timeout in seconds [120], e.g. -t60 for 1 minute.', + ' To disable timeout, use -t0', + ' -U --utc Use UTC time format in log messages.', + ' --log-ip Enable logging of the client\'s IP address', + '', + ' -P --proxy Fallback proxy if the request cannot be resolved. e.g.: http://someurl.com', + ' --proxy-options Pass options to proxy using nested dotted objects. e.g.: --proxy-options.secure false', + '', + ' --username Username for basic authentication [none]', + ' Can also be specified with the env variable NODE_HTTP_SERVER_USERNAME', + ' --password Password for basic authentication [none]', + ' Can also be specified with the env variable NODE_HTTP_SERVER_PASSWORD', + '', + ' -S --tls --ssl Enable secure request serving with TLS/SSL (HTTPS)', + ' -C --cert Path to TLS cert file (default: cert.pem)', + ' -K --key Path to TLS key file (default: key.pem)', + '', + ' -r --robots Respond to /robots.txt [User-agent: *\\nDisallow: /]', + ' --no-dotfiles Do not show dotfiles', + ' --mimetypes Path to a .types file for custom mimetype definition', + ' -h --help Print this list and exit.', + ' -v --version Print the version and exit.' + ].join('\n')); + process.exit(); +} + +var port = argv.p || argv.port || parseInt(process.env.PORT, 10), + host = argv.a || '0.0.0.0', + tls = argv.S || argv.tls, + sslPassphrase = process.env.NODE_HTTP_SERVER_SSL_PASSPHRASE, + proxy = argv.P || argv.proxy, + proxyOptions = argv['proxy-options'], + utc = argv.U || argv.utc, + version = argv.v || argv.version, + logger; + +var proxyOptionsBooleanProps = [ + 'ws', 'xfwd', 'secure', 'toProxy', 'prependPath', 'ignorePath', 'changeOrigin', + 'preserveHeaderKeyCase', 'followRedirects', 'selfHandleResponse' +]; + +if (proxyOptions) { + Object.keys(proxyOptions).forEach(function (key) { + if (proxyOptionsBooleanProps.indexOf(key) > -1) { + proxyOptions[key] = proxyOptions[key].toLowerCase() === 'true'; + } + }); +} + +if (!argv.s && !argv.silent) { + logger = { + info: console.log, + request: function (req, res, error) { + var date = utc ? new Date().toUTCString() : new Date(); + var ip = argv['log-ip'] + ? req.headers['x-forwarded-for'] || '' + req.connection.remoteAddress + : ''; + if (error) { + logger.info( + '[%s] %s "%s %s" Error (%s): "%s"', + date, ip, chalk.red(req.method), chalk.red(req.url), + chalk.red(error.status.toString()), chalk.red(error.message) + ); + } + else { + logger.info( + '[%s] %s "%s %s" "%s"', + date, ip, chalk.cyan(req.method), chalk.cyan(req.url), + req.headers['user-agent'] + ); + } + } + }; +} +else if (chalk) { + logger = { + info: function () {}, + request: function () {} + }; +} + +if (version) { + logger.info('v' + require('../package.json').version); + process.exit(); +} + +if (!port) { + portfinder.basePort = 8080; + portfinder.getPort(function (err, port) { + if (err) { throw err; } + listen(port); + }); +} +else { + listen(port); +} + +function listen(port) { + var options = { + root: argv._[0], + cache: argv.c, + timeout: argv.t, + showDir: argv.d, + autoIndex: argv.i, + gzip: argv.g || argv.gzip, + brotli: argv.b || argv.brotli, + robots: argv.r || argv.robots, + ext: argv.e || argv.ext, + logFn: logger.request, + proxy: proxy, + proxyOptions: proxyOptions, + showDotfiles: argv.dotfiles, + mimetypes: argv.mimetypes, + username: argv.username || process.env.NODE_HTTP_SERVER_USERNAME, + password: argv.password || process.env.NODE_HTTP_SERVER_PASSWORD + }; + + if (argv.cors) { + options.cors = true; + if (typeof argv.cors === 'string') { + options.corsHeaders = argv.cors; + } + } + + if (proxy) { + try { + new url.URL(proxy) + } + catch (err) { + logger.info(chalk.red('Error: Invalid proxy url')); + process.exit(1); + } + } + + if (tls) { + options.https = { + cert: argv.C || argv.cert || 'cert.pem', + key: argv.K || argv.key || 'key.pem', + passphrase: sslPassphrase, + }; + try { + fs.lstatSync(options.https.cert); + } + catch (err) { + logger.info(chalk.red('Error: Could not find certificate ' + options.https.cert)); + process.exit(1); + } + try { + fs.lstatSync(options.https.key); + } + catch (err) { + logger.info(chalk.red('Error: Could not find private key ' + options.https.key)); + process.exit(1); + } + } + + var server = httpServer.createServer(options); + server.listen(port, host, function () { + var protocol = tls ? 'https://' : 'http://'; + + logger.info([ + chalk.yellow('Starting up http-server, serving '), + chalk.cyan(server.root), + tls ? (chalk.yellow(' through') + chalk.cyan(' https')) : '' + ].join('')); + + logger.info([chalk.yellow('\nhttp-server version: '), chalk.cyan(require('../package.json').version)].join('')); + + logger.info([ + chalk.yellow('\nhttp-server settings: '), + ([chalk.yellow('CORS: '), argv.cors ? chalk.cyan(argv.cors) : chalk.red('disabled')].join('')), + ([chalk.yellow('Cache: '), argv.c ? (argv.c === '-1' ? chalk.red('disabled') : chalk.cyan(argv.c + ' seconds')) : chalk.cyan('3600 seconds')].join('')), + ([chalk.yellow('Connection Timeout: '), argv.t === '0' ? chalk.red('disabled') : (argv.t ? chalk.cyan(argv.t + ' seconds') : chalk.cyan('120 seconds'))].join('')), + ([chalk.yellow('Directory Listings: '), argv.d ? chalk.red('not visible') : chalk.cyan('visible')].join('')), + ([chalk.yellow('AutoIndex: '), argv.i ? chalk.red('not visible') : chalk.cyan('visible')].join('')), + ([chalk.yellow('Serve GZIP Files: '), argv.g || argv.gzip ? chalk.cyan('true') : chalk.red('false')].join('')), + ([chalk.yellow('Serve Brotli Files: '), argv.b || argv.brotli ? chalk.cyan('true') : chalk.red('false')].join('')), + ([chalk.yellow('Default File Extension: '), argv.e ? chalk.cyan(argv.e) : (argv.ext ? chalk.cyan(argv.ext) : chalk.red('none'))].join('')) + ].join('\n')); + + logger.info(chalk.yellow('\nAvailable on:')); + + if (argv.a && host !== '0.0.0.0') { + logger.info(` ${protocol}${host}:${chalk.green(port.toString())}`); + } else { + Object.keys(ifaces).forEach(function (dev) { + ifaces[dev].forEach(function (details) { + if (details.family === 'IPv4') { + logger.info((' ' + protocol + details.address + ':' + chalk.green(port.toString()))); + } + }); + }); + } + + if (typeof proxy === 'string') { + if (proxyOptions) { + logger.info('Unhandled requests will be served from: ' + proxy + '. Options: ' + JSON.stringify(proxyOptions)); + } + else { + logger.info('Unhandled requests will be served from: ' + proxy); + } + } + + logger.info('Hit CTRL-C to stop the server'); + if (argv.o) { + const openHost = host === '0.0.0.0' ? '127.0.0.1' : host; + let openUrl = `${protocol}${openHost}:${port}`; + if (typeof argv.o === 'string') { + openUrl += argv.o[0] === '/' ? argv.o : '/' + argv.o; + } + logger.info('Open: ' + openUrl); + opener(openUrl); + } + + // Spacing before logs + if (!argv.s) logger.info(); + }); +} + +if (process.platform === 'win32') { + require('readline').createInterface({ + input: process.stdin, + output: process.stdout + }).on('SIGINT', function () { + process.emit('SIGINT'); + }); +} + +process.on('SIGINT', function () { + logger.info(chalk.red('http-server stopped.')); + process.exit(); +}); + +process.on('SIGTERM', function () { + logger.info(chalk.red('http-server stopped.')); + process.exit(); +}); diff --git a/tools/ui/node_modules/.bin/is-docker b/tools/ui/node_modules/.bin/is-docker new file mode 100644 index 0000000000000000000000000000000000000000..3b200aa51bb5befe93e7ff525246d3ac47bae52c --- /dev/null +++ b/tools/ui/node_modules/.bin/is-docker @@ -0,0 +1,5 @@ +#!/usr/bin/env node +import process from 'node:process'; +import isDocker from './index.js'; + +process.exitCode = isDocker() ? 0 : 2; diff --git a/tools/ui/node_modules/.bin/is-inside-container b/tools/ui/node_modules/.bin/is-inside-container new file mode 100644 index 0000000000000000000000000000000000000000..b39acaca64e822f0e4b206e7f9fe760e66926e26 --- /dev/null +++ b/tools/ui/node_modules/.bin/is-inside-container @@ -0,0 +1,5 @@ +#!/usr/bin/env node +import process from 'node:process'; +import isInsideContainer from './index.js'; + +process.exitCode = isInsideContainer() ? 0 : 2; diff --git a/tools/ui/node_modules/.bin/jake b/tools/ui/node_modules/.bin/jake new file mode 100644 index 0000000000000000000000000000000000000000..9f68abbf7fe6f2364781a19f158d7f4d6af894de --- /dev/null +++ b/tools/ui/node_modules/.bin/jake @@ -0,0 +1,31 @@ +#!/usr/bin/env node +/* + * Jake JavaScript build tool + * Copyright 2112 Matthew Eernisse (mde@fleegix.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ + +// Try to load a local jake +try { + require(`${ process.cwd() }/node_modules/jake`); +} +// If that fails, likely running globally +catch(e) { + require('../lib/jake'); +} + +var args = process.argv.slice(2); + +jake.run.apply(jake, args); diff --git a/tools/ui/node_modules/.bin/jiti b/tools/ui/node_modules/.bin/jiti new file mode 100644 index 0000000000000000000000000000000000000000..3bb3b9e9af1fa260ac6e7489a459f76360254890 --- /dev/null +++ b/tools/ui/node_modules/.bin/jiti @@ -0,0 +1,34 @@ +#!/usr/bin/env node + +import { resolve } from "node:path"; +import nodeModule from "node:module"; + +const script = process.argv.splice(2, 1)[0]; + +if (!script) { + console.error("Usage: jiti [...arguments]"); + process.exit(1); +} + +// https://nodejs.org/api/module.html#moduleenablecompilecachecachedir +// https://github.com/nodejs/node/pull/54501 +if (nodeModule.enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) { + try { + nodeModule.enableCompileCache(); + } catch { + // Ignore errors + } +} + +const pwd = process.cwd(); + +const { createJiti } = await import("./jiti.cjs"); + +const jiti = createJiti(pwd); + +const resolved = (process.argv[1] = jiti.resolve(resolve(pwd, script))); + +await jiti.import(resolved).catch((error) => { + console.error(error); + process.exit(1); +}); diff --git a/tools/ui/node_modules/.bin/js-yaml b/tools/ui/node_modules/.bin/js-yaml new file mode 100644 index 0000000000000000000000000000000000000000..abcd7e000bd312d4c03f3faf85f75b7a82218d5a --- /dev/null +++ b/tools/ui/node_modules/.bin/js-yaml @@ -0,0 +1,117 @@ +#!/usr/bin/env node + +'use strict' + +const fs = require('fs') +const argparse = require('argparse') +const yaml = require('..') + +/// ///////////////////////////////////////////////////////////////////////////// + +const cli = new argparse.ArgumentParser({ + prog: 'js-yaml', + add_help: true +}) + +cli.add_argument('-v', '--version', { + action: 'version', + version: require('../package.json').version +}) + +cli.add_argument('-c', '--compact', { + help: 'Display errors in compact mode', + action: 'store_true' +}) + +// deprecated (not needed after we removed output colors) +// option suppressed, but not completely removed for compatibility +cli.add_argument('-j', '--to-json', { + help: argparse.SUPPRESS, + dest: 'json', + action: 'store_true' +}) + +cli.add_argument('-t', '--trace', { + help: 'Show stack trace on error', + action: 'store_true' +}) + +cli.add_argument('file', { + help: 'File to read, utf-8 encoded without BOM', + nargs: '?', + default: '-' +}) + +/// ///////////////////////////////////////////////////////////////////////////// + +const options = cli.parse_args() + +/// ///////////////////////////////////////////////////////////////////////////// + +function readFile (filename, encoding, callback) { + if (options.file === '-') { + // read from stdin + + const chunks = [] + + process.stdin.on('data', function (chunk) { + chunks.push(chunk) + }) + + process.stdin.on('end', function () { + return callback(null, Buffer.concat(chunks).toString(encoding)) + }) + } else { + fs.readFile(filename, encoding, callback) + } +} + +readFile(options.file, 'utf8', function (error, input) { + let output + let isYaml + + if (error) { + if (error.code === 'ENOENT') { + console.error('File not found: ' + options.file) + process.exit(2) + } + + console.error( + (options.trace && error.stack) || + error.message || + String(error)) + + process.exit(1) + } + + try { + output = JSON.parse(input) + isYaml = false + } catch (err) { + if (err instanceof SyntaxError) { + try { + output = [] + yaml.loadAll(input, function (doc) { output.push(doc) }, {}) + isYaml = true + + if (output.length === 0) output = null + else if (output.length === 1) output = output[0] + } catch (e) { + if (options.trace && err.stack) console.error(e.stack) + else console.error(e.toString(options.compact)) + + process.exit(1) + } + } else { + console.error( + (options.trace && err.stack) || + err.message || + String(err)) + + process.exit(1) + } + } + + if (isYaml) console.log(JSON.stringify(output, null, ' ')) + else console.log(yaml.dump(output)) +}) diff --git a/tools/ui/node_modules/.bin/jsesc b/tools/ui/node_modules/.bin/jsesc new file mode 100644 index 0000000000000000000000000000000000000000..e9a541db322abe86e96da58a3ab528de98b90ce9 --- /dev/null +++ b/tools/ui/node_modules/.bin/jsesc @@ -0,0 +1,148 @@ +#!/usr/bin/env node +(function() { + + var fs = require('fs'); + var stringEscape = require('../jsesc.js'); + var strings = process.argv.splice(2); + var stdin = process.stdin; + var data; + var timeout; + var isObject = false; + var options = {}; + var log = console.log; + + var main = function() { + var option = strings[0]; + + if (/^(?:-h|--help|undefined)$/.test(option)) { + log( + 'jsesc v%s - https://mths.be/jsesc', + stringEscape.version + ); + log([ + '\nUsage:\n', + '\tjsesc [string]', + '\tjsesc [-s | --single-quotes] [string]', + '\tjsesc [-d | --double-quotes] [string]', + '\tjsesc [-w | --wrap] [string]', + '\tjsesc [-e | --escape-everything] [string]', + '\tjsesc [-t | --escape-etago] [string]', + '\tjsesc [-6 | --es6] [string]', + '\tjsesc [-l | --lowercase-hex] [string]', + '\tjsesc [-j | --json] [string]', + '\tjsesc [-o | --object] [stringified_object]', // `JSON.parse()` the argument + '\tjsesc [-p | --pretty] [string]', // `compact: false` + '\tjsesc [-v | --version]', + '\tjsesc [-h | --help]', + '\nExamples:\n', + '\tjsesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tjsesc --json \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tjsesc --json --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\tjsesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'', + '\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | jsesc' + ].join('\n')); + return process.exit(1); + } + + if (/^(?:-v|--version)$/.test(option)) { + log('v%s', stringEscape.version); + return process.exit(1); + } + + strings.forEach(function(string) { + // Process options + if (/^(?:-s|--single-quotes)$/.test(string)) { + options.quotes = 'single'; + return; + } + if (/^(?:-d|--double-quotes)$/.test(string)) { + options.quotes = 'double'; + return; + } + if (/^(?:-w|--wrap)$/.test(string)) { + options.wrap = true; + return; + } + if (/^(?:-e|--escape-everything)$/.test(string)) { + options.escapeEverything = true; + return; + } + if (/^(?:-t|--escape-etago)$/.test(string)) { + options.escapeEtago = true; + return; + } + if (/^(?:-6|--es6)$/.test(string)) { + options.es6 = true; + return; + } + if (/^(?:-l|--lowercase-hex)$/.test(string)) { + options.lowercaseHex = true; + return; + } + if (/^(?:-j|--json)$/.test(string)) { + options.json = true; + return; + } + if (/^(?:-o|--object)$/.test(string)) { + isObject = true; + return; + } + if (/^(?:-p|--pretty)$/.test(string)) { + isObject = true; + options.compact = false; + return; + } + + // Process string(s) + var result; + try { + if (isObject) { + string = JSON.parse(string); + } + result = stringEscape(string, options); + log(result); + } catch(error) { + log(error.message + '\n'); + log('Error: failed to escape.'); + log('If you think this is a bug in jsesc, please report it:'); + log('https://github.com/mathiasbynens/jsesc/issues/new'); + log( + '\nStack trace using jsesc@%s:\n', + stringEscape.version + ); + log(error.stack); + return process.exit(1); + } + }); + // Return with exit status 0 outside of the `forEach` loop, in case + // multiple strings were passed in. + return process.exit(0); + + }; + + if (stdin.isTTY) { + // handle shell arguments + main(); + } else { + // Either the script is called from within a non-TTY context, + // or `stdin` content is being piped in. + if (!process.stdout.isTTY) { // called from a non-TTY context + timeout = setTimeout(function() { + // if no piped data arrived after a while, handle shell arguments + main(); + }, 250); + } + + data = ''; + stdin.on('data', function(chunk) { + clearTimeout(timeout); + data += chunk; + }); + stdin.on('end', function() { + strings.push(data.trim()); + main(); + }); + stdin.resume(); + } + +}()); diff --git a/tools/ui/node_modules/.bin/json2csv b/tools/ui/node_modules/.bin/json2csv new file mode 100644 index 0000000000000000000000000000000000000000..75606b827e74d5d4edf0bfb0d59755efa27ab016 --- /dev/null +++ b/tools/ui/node_modules/.bin/json2csv @@ -0,0 +1,36 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("-n, --newline-delimited", "accept newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + text = iconv.decode(text, options.inputEncoding); + rw.dash.writeFile(options.out, iconv.encode(outFormat.format(options.newlineDelimited + ? text.trim().split(/\r?\n/g).map((line) => JSON.parse(line)) + : JSON.parse(text)) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/json2dsv b/tools/ui/node_modules/.bin/json2dsv new file mode 100644 index 0000000000000000000000000000000000000000..75606b827e74d5d4edf0bfb0d59755efa27ab016 --- /dev/null +++ b/tools/ui/node_modules/.bin/json2dsv @@ -0,0 +1,36 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("-n, --newline-delimited", "accept newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + text = iconv.decode(text, options.inputEncoding); + rw.dash.writeFile(options.out, iconv.encode(outFormat.format(options.newlineDelimited + ? text.trim().split(/\r?\n/g).map((line) => JSON.parse(line)) + : JSON.parse(text)) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/json2tsv b/tools/ui/node_modules/.bin/json2tsv new file mode 100644 index 0000000000000000000000000000000000000000..75606b827e74d5d4edf0bfb0d59755efa27ab016 --- /dev/null +++ b/tools/ui/node_modules/.bin/json2tsv @@ -0,0 +1,36 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("-n, --newline-delimited", "accept newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + text = iconv.decode(text, options.inputEncoding); + rw.dash.writeFile(options.out, iconv.encode(outFormat.format(options.newlineDelimited + ? text.trim().split(/\r?\n/g).map((line) => JSON.parse(line)) + : JSON.parse(text)) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/json5 b/tools/ui/node_modules/.bin/json5 new file mode 100644 index 0000000000000000000000000000000000000000..93cb80921e21aed8acfdd81bf5c096138f2e228f --- /dev/null +++ b/tools/ui/node_modules/.bin/json5 @@ -0,0 +1,152 @@ +#!/usr/bin/env node + +const fs = require('fs') +const path = require('path') +const pkg = require('../package.json') +const JSON5 = require('./') + +const argv = parseArgs() + +if (argv.version) { + version() +} else if (argv.help) { + usage() +} else { + const inFilename = argv.defaults[0] + + let readStream + if (inFilename) { + readStream = fs.createReadStream(inFilename) + } else { + readStream = process.stdin + } + + let json5 = '' + readStream.on('data', data => { + json5 += data + }) + + readStream.on('end', () => { + let space + if (argv.space === 't' || argv.space === 'tab') { + space = '\t' + } else { + space = Number(argv.space) + } + + let value + try { + value = JSON5.parse(json5) + if (!argv.validate) { + const json = JSON.stringify(value, null, space) + + let writeStream + + // --convert is for backward compatibility with v0.5.1. If + // specified with and not --out-file, then a file with + // the same name but with a .json extension will be written. + if (argv.convert && inFilename && !argv.outFile) { + const parsedFilename = path.parse(inFilename) + const outFilename = path.format( + Object.assign( + parsedFilename, + {base: path.basename(parsedFilename.base, parsedFilename.ext) + '.json'} + ) + ) + + writeStream = fs.createWriteStream(outFilename) + } else if (argv.outFile) { + writeStream = fs.createWriteStream(argv.outFile) + } else { + writeStream = process.stdout + } + + writeStream.write(json) + } + } catch (err) { + console.error(err.message) + process.exit(1) + } + }) +} + +function parseArgs () { + let convert + let space + let validate + let outFile + let version + let help + const defaults = [] + + const args = process.argv.slice(2) + for (let i = 0; i < args.length; i++) { + const arg = args[i] + switch (arg) { + case '--convert': + case '-c': + convert = true + break + + case '--space': + case '-s': + space = args[++i] + break + + case '--validate': + case '-v': + validate = true + break + + case '--out-file': + case '-o': + outFile = args[++i] + break + + case '--version': + case '-V': + version = true + break + + case '--help': + case '-h': + help = true + break + + default: + defaults.push(arg) + break + } + } + + return { + convert, + space, + validate, + outFile, + version, + help, + defaults, + } +} + +function version () { + console.log(pkg.version) +} + +function usage () { + console.log( + ` + Usage: json5 [options] + + If is not provided, then STDIN is used. + + Options: + + -s, --space The number of spaces to indent or 't' for tabs + -o, --out-file [file] Output to the specified file, otherwise STDOUT + -v, --validate Validate JSON5 but do not output JSON + -V, --version Output the version number + -h, --help Output usage information` + ) +} diff --git a/tools/ui/node_modules/.bin/katex b/tools/ui/node_modules/.bin/katex new file mode 100644 index 0000000000000000000000000000000000000000..b9e7f951d18d3e62c36368e84b38bfa7d61486a2 --- /dev/null +++ b/tools/ui/node_modules/.bin/katex @@ -0,0 +1,114 @@ +#!/usr/bin/env node +// Simple CLI for KaTeX. +// Reads TeX from stdin, outputs HTML to stdout. +// To run this from the repository, you must first build KaTeX by running +// `yarn` and `yarn build`. + +/* eslint no-console:0 */ + +let katex; +try { + katex = require("./"); +} catch (e) { + console.error( + "KaTeX could not import, likely because dist/katex.js is missing."); + console.error("Please run 'yarn' and 'yarn build' before running"); + console.error("cli.js from the KaTeX repository."); + console.error(); + throw e; +} +const {version} = require("./package.json"); +const fs = require("fs"); + +const {program} = require("commander"); +program.version(version); + +for (const prop in katex.SETTINGS_SCHEMA) { + if (katex.SETTINGS_SCHEMA.hasOwnProperty(prop)) { + const opt = katex.SETTINGS_SCHEMA[prop]; + if (opt.cli !== false) { + program.option(opt.cli || "--" + prop, opt.cliDescription || + opt.description, opt.cliProcessor, opt.cliDefault); + } + } +} +program.option("-f, --macro-file ", + "Read macro definitions, one per line, from the given file.") + .option("-i, --input ", "Read LaTeX input from the given file.") + .option("-o, --output ", "Write html output to the given file."); + +let options; + +function readMacros() { + if (options.macroFile) { + fs.readFile(options.macroFile, "utf-8", function(err, data) { + if (err) {throw err;} + splitMacros(data.toString().split('\n')); + }); + } else { + splitMacros([]); + } +} + +function splitMacros(macroStrings) { + // Override macros from macro file (if any) + // with macros from command line (if any) + macroStrings = macroStrings.concat(options.macro); + + const macros = {}; + + for (const m of macroStrings) { + const i = m.search(":"); + if (i !== -1) { + macros[m.substring(0, i).trim()] = m.substring(i + 1).trim(); + } + } + + options.macros = macros; + readInput(); +} + +function readInput() { + let input = ""; + + if (options.input) { + fs.readFile(options.input, "utf-8", function(err, data) { + if (err) {throw err;} + input = data.toString(); + writeOutput(input); + }); + } else { + process.stdin.on("data", function(chunk) { + input += chunk.toString(); + }); + + process.stdin.on("end", function() { + writeOutput(input); + }); + } +} + +function writeOutput(input) { + // --format specifies the KaTeX output + const outputFile = options.output; + options.output = options.format; + + const output = katex.renderToString(input, options) + "\n"; + + if (outputFile) { + fs.writeFile(outputFile, output, function(err) { + if (err) { + return console.log(err); + } + }); + } else { + console.log(output); + } +} + +if (require.main !== module) { + module.exports = program; +} else { + options = program.parse(process.argv).opts(); + readMacros(); +} diff --git a/tools/ui/node_modules/.bin/lz-string b/tools/ui/node_modules/.bin/lz-string new file mode 100644 index 0000000000000000000000000000000000000000..113ae313b6c297d253872f0b0584a7e9ce775b2e --- /dev/null +++ b/tools/ui/node_modules/.bin/lz-string @@ -0,0 +1,13 @@ +#! /usr/bin/env node +var lzString = require('../libs/lz-string.js'); +var fs = require('fs'); + +if (process.argv.length < 3) { + console.error('Usage: lz-string '); + process.exit(1); +} + +console.log(lzString.compress(fs.readFileSync(process.argv[2], { + encoding: 'utf8', +}))); + diff --git a/tools/ui/node_modules/.bin/marked b/tools/ui/node_modules/.bin/marked new file mode 100644 index 0000000000000000000000000000000000000000..65ff0aaa4c0140a3c66f9d55b8f0f3be4b593116 --- /dev/null +++ b/tools/ui/node_modules/.bin/marked @@ -0,0 +1,16 @@ +#!/usr/bin/env node + +/** + * Marked CLI + * Copyright (c) 2018+, MarkedJS. (MIT License) + * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + */ + +import { main } from './main.js'; + +/** + * Expose / Entry Point + */ + +process.title = 'marked'; +main(process); diff --git a/tools/ui/node_modules/.bin/mime b/tools/ui/node_modules/.bin/mime new file mode 100644 index 0000000000000000000000000000000000000000..20b1ffeb2f97648e0faa7e022c98ed9e6a8e9a0d --- /dev/null +++ b/tools/ui/node_modules/.bin/mime @@ -0,0 +1,8 @@ +#!/usr/bin/env node + +var mime = require('./mime.js'); +var file = process.argv[2]; +var type = mime.lookup(file); + +process.stdout.write(type + '\n'); + diff --git a/tools/ui/node_modules/.bin/mini-svg-data-uri b/tools/ui/node_modules/.bin/mini-svg-data-uri new file mode 100644 index 0000000000000000000000000000000000000000..c5a47dd7b44c9606a8985d0ef6fd44999e422a0f --- /dev/null +++ b/tools/ui/node_modules/.bin/mini-svg-data-uri @@ -0,0 +1,41 @@ +#!/usr/bin/env node + +let help = ` +Usage: mini-svg-data-uri [dest] + +Options: +-v, --version Output the version number +-h, --help Display help for command + +Examples: + mini-svg-data-uri file.svg Write to stdout + mini-svg-data-uri icon.svg icon.uri Write to file +`; + +let [source, dest] = process.argv.slice(2); + +switch (source) { + case '-h': + case '--help': + case undefined: + console.log(help); + process.exit(); + + case '-v': + case '--version': + console.log(require('./package').version); + process.exit(); +} + +const fs = require('fs'); +const svgToMiniDataURI = require('.'); + +fs.readFile(source, 'utf8', (err, data) => { + if (err) { + console.error(err.message); + console.log(help); + process.exit(1); + } + const out = svgToMiniDataURI(data); + dest ? fs.writeFileSync(dest, out) : console.log(out); +}); diff --git a/tools/ui/node_modules/.bin/nanoid b/tools/ui/node_modules/.bin/nanoid new file mode 100644 index 0000000000000000000000000000000000000000..c76db0faa81f6d683c4a18a212f804fb70cf8143 --- /dev/null +++ b/tools/ui/node_modules/.bin/nanoid @@ -0,0 +1,55 @@ +#!/usr/bin/env node + +let { nanoid, customAlphabet } = require('..') + +function print(msg) { + process.stdout.write(msg + '\n') +} + +function error(msg) { + process.stderr.write(msg + '\n') + process.exit(1) +} + +if (process.argv.includes('--help') || process.argv.includes('-h')) { + print(` + Usage + $ nanoid [options] + + Options + -s, --size Generated ID size + -a, --alphabet Alphabet to use + -h, --help Show this help + + Examples + $ nanoid --s 15 + S9sBF77U6sDB8Yg + + $ nanoid --size 10 --alphabet abc + bcabababca`) + process.exit() +} + +let alphabet, size +for (let i = 2; i < process.argv.length; i++) { + let arg = process.argv[i] + if (arg === '--size' || arg === '-s') { + size = Number(process.argv[i + 1]) + i += 1 + if (Number.isNaN(size) || size <= 0) { + error('Size must be positive integer') + } + } else if (arg === '--alphabet' || arg === '-a') { + alphabet = process.argv[i + 1] + i += 1 + } else { + error('Unknown argument ' + arg) + } +} + +if (alphabet) { + let customNanoid = customAlphabet(alphabet, size) + print(customNanoid()) +} else { + print(nanoid(size)) +} diff --git a/tools/ui/node_modules/.bin/node-which b/tools/ui/node_modules/.bin/node-which new file mode 100644 index 0000000000000000000000000000000000000000..7cee3729eebdd09e39bd891aa4d17483ea4a757a --- /dev/null +++ b/tools/ui/node_modules/.bin/node-which @@ -0,0 +1,52 @@ +#!/usr/bin/env node +var which = require("../") +if (process.argv.length < 3) + usage() + +function usage () { + console.error('usage: which [-as] program ...') + process.exit(1) +} + +var all = false +var silent = false +var dashdash = false +var args = process.argv.slice(2).filter(function (arg) { + if (dashdash || !/^-/.test(arg)) + return true + + if (arg === '--') { + dashdash = true + return false + } + + var flags = arg.substr(1).split('') + for (var f = 0; f < flags.length; f++) { + var flag = flags[f] + switch (flag) { + case 's': + silent = true + break + case 'a': + all = true + break + default: + console.error('which: illegal option -- ' + flag) + usage() + } + } + return false +}) + +process.exit(args.reduce(function (pv, current) { + try { + var f = which.sync(current, { all: all }) + if (all) + f = f.join('\n') + if (!silent) + console.log(f) + return pv; + } catch (e) { + return 1; + } +}, 0)) diff --git a/tools/ui/node_modules/.bin/opener b/tools/ui/node_modules/.bin/opener new file mode 100644 index 0000000000000000000000000000000000000000..a051ea8f03f192c2a3e96a76fa53b474d817bbef --- /dev/null +++ b/tools/ui/node_modules/.bin/opener @@ -0,0 +1,10 @@ +#!/usr/bin/env node +"use strict"; + +var opener = require(".."); + +opener(process.argv.slice(2), function (error) { + if (error) { + throw error; + } +}); diff --git a/tools/ui/node_modules/.bin/parser b/tools/ui/node_modules/.bin/parser new file mode 100644 index 0000000000000000000000000000000000000000..4808c5ee86f71fc4452fa6bb50580669fe52e8f2 --- /dev/null +++ b/tools/ui/node_modules/.bin/parser @@ -0,0 +1,15 @@ +#!/usr/bin/env node +/* eslint-disable no-var, unicorn/prefer-node-protocol */ + +var parser = require(".."); +var fs = require("fs"); + +var filename = process.argv[2]; +if (!filename) { + console.error("no filename specified"); +} else { + var file = fs.readFileSync(filename, "utf8"); + var ast = parser.parse(file); + + console.log(JSON.stringify(ast, null, " ")); +} diff --git a/tools/ui/node_modules/.bin/playwright b/tools/ui/node_modules/.bin/playwright new file mode 100644 index 0000000000000000000000000000000000000000..e42facb076f4b05f009186346d05d39c2d9b784d --- /dev/null +++ b/tools/ui/node_modules/.bin/playwright @@ -0,0 +1,19 @@ +#!/usr/bin/env node +/** + * Copyright (c) Microsoft Corporation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +const { program } = require('playwright/lib/program'); +program.parse(process.argv); diff --git a/tools/ui/node_modules/.bin/playwright-core b/tools/ui/node_modules/.bin/playwright-core new file mode 100644 index 0000000000000000000000000000000000000000..fb309ead0ae54fd88866372386364149a41cfcea --- /dev/null +++ b/tools/ui/node_modules/.bin/playwright-core @@ -0,0 +1,18 @@ +#!/usr/bin/env node +/** + * Copyright (c) Microsoft Corporation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +const { program } = require('./lib/cli/programWithTestStub'); +program.parse(process.argv); diff --git a/tools/ui/node_modules/.bin/prettier b/tools/ui/node_modules/.bin/prettier new file mode 100644 index 0000000000000000000000000000000000000000..642c99dd135f7b9ea845f6d4faacef76e195e5aa --- /dev/null +++ b/tools/ui/node_modules/.bin/prettier @@ -0,0 +1,80 @@ +#!/usr/bin/env node +"use strict"; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __commonJS = function(cb, mod) { + return function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; +}; + +// node_modules/semver-compare/index.js +var require_semver_compare = __commonJS({ + "node_modules/semver-compare/index.js": function(exports2, module2) { + module2.exports = function cmp(a, b) { + var pa = a.split("."); + var pb = b.split("."); + for (var i = 0; i < 3; i++) { + var na = Number(pa[i]); + var nb = Number(pb[i]); + if (na > nb) return 1; + if (nb > na) return -1; + if (!isNaN(na) && isNaN(nb)) return 1; + if (isNaN(na) && !isNaN(nb)) return -1; + } + return 0; + }; + } +}); + +// node_modules/please-upgrade-node/index.js +var require_please_upgrade_node = __commonJS({ + "node_modules/please-upgrade-node/index.js": function(exports2, module2) { + var semverCompare = require_semver_compare(); + module2.exports = function pleaseUpgradeNode2(pkg, opts) { + var opts = opts || {}; + var requiredVersion = pkg.engines.node.replace(">=", ""); + var currentVersion = process.version.replace("v", ""); + if (semverCompare(currentVersion, requiredVersion) === -1) { + if (opts.message) { + console.error(opts.message(requiredVersion)); + } else { + console.error( + pkg.name + " requires at least version " + requiredVersion + " of Node, please upgrade" + ); + } + if (opts.hasOwnProperty("exitCode")) { + process.exit(opts.exitCode); + } else { + process.exit(1); + } + } + }; + } +}); + +// bin/prettier.cjs +var nodeModule = require("module"); +if (typeof nodeModule.enableCompileCache === "function") { + nodeModule.enableCompileCache(); +} +var pleaseUpgradeNode = require_please_upgrade_node(); +var packageJson = require("../package.json"); +pleaseUpgradeNode(packageJson); +var dynamicImport = new Function("module", "return import(module)"); +var promise; +var index = process.argv.indexOf("--experimental-cli"); +if (process.env.PRETTIER_EXPERIMENTAL_CLI || index !== -1) { + if (index !== -1) { + process.argv.splice(index, 1); + } + promise = dynamicImport("../internal/experimental-cli.mjs").then( + function(cli) { + return cli.__promise; + } + ); +} else { + promise = dynamicImport("../internal/legacy-cli.mjs").then(function runCli(cli) { + return cli.run(); + }); +} +module.exports.__promise = promise; diff --git a/tools/ui/node_modules/.bin/pwa-assets-generator b/tools/ui/node_modules/.bin/pwa-assets-generator new file mode 100644 index 0000000000000000000000000000000000000000..d5caadbe4d51e3844cce2da12757164a91c7f474 --- /dev/null +++ b/tools/ui/node_modules/.bin/pwa-assets-generator @@ -0,0 +1,3 @@ +#!/usr/bin/env node +'use strict' +import('../dist/cli.mjs') diff --git a/tools/ui/node_modules/.bin/regjsparser b/tools/ui/node_modules/.bin/regjsparser new file mode 100644 index 0000000000000000000000000000000000000000..73549ac07214ef6b39bfdf8f8811a6c2e02ebbb4 --- /dev/null +++ b/tools/ui/node_modules/.bin/regjsparser @@ -0,0 +1,63 @@ +#!/usr/bin/env node +(function() { + + var fs = require('fs'); + var path = require('path'); + var parse = require('../parser').parse; + var jsesc = require('jsesc'); + var regexes = process.argv.splice(2); + var first = regexes[0]; + var data; + var log = console.log; + var flags = ''; + var main = function() { + if (/^(?:-h|--help|undefined)$/.test(first)) { + log([ + '\nUsage:\n', + '\tregjsparser [regex ...]', + '\tregjsparser [-f | --flags] u [regex ...]', + '\tregjsparser [-v | --version]', + '\tregjsparser [-h | --help]', + '\nExamples:\n', + '\tregjsparser \'^foo.bar$\'', + '\tregjsparser \'[a-zA-Z0-9]\'' + ].join('\n')); + return process.exit(1); + } + + if (/^(?:-v|--version)$/.test(first)) { + log('v%s', require(path.resolve(__dirname, '../package.json')).version); + return process.exit(1); + } + + if (/^(?:-f|--flags)$/.test(first)) { + flags = regexes[1]; + regexes = regexes.slice(2); + } + + regexes.forEach(function(snippet) { + try { + result = parse(snippet, flags); + log(jsesc(result, { + 'json': true, + 'compact': false, + 'indent': '\t' + })); + } catch(error) { + log(error.message + '\n'); + log('Error: failed to parse. Make sure the regular expression is valid.'); + log('If you think this is a bug in regjsparser, please report it:'); + log('\thttps://github.com/jviereck/regjsparser/issues/new'); + log('\nStack trace:\n'); + log(error.stack); + return process.exit(1); + } + }); + // Return with exit status 0 outside of the `forEach` loop, in case + // multiple regular expressions were passed in. + return process.exit(0); + }; + + main(); + +}()); diff --git a/tools/ui/node_modules/.bin/resolve b/tools/ui/node_modules/.bin/resolve new file mode 100644 index 0000000000000000000000000000000000000000..21d1a87eec1fe1557a535fc0cdfd877908cb5c71 --- /dev/null +++ b/tools/ui/node_modules/.bin/resolve @@ -0,0 +1,50 @@ +#!/usr/bin/env node + +'use strict'; + +var path = require('path'); +var fs = require('fs'); + +if ( + String(process.env.npm_lifecycle_script).slice(0, 8) !== 'resolve ' + && ( + !process.argv + || process.argv.length < 2 + || (process.argv[1] !== __filename && fs.statSync(process.argv[1]).ino !== fs.statSync(__filename).ino) + || (process.env.npm_lifecycle_event !== 'npx' && process.env._ && fs.realpathSync(path.resolve(process.env._)) !== __filename) + ) +) { + console.error('Error: `resolve` must be run directly as an executable'); + process.exit(1); +} + +var supportsPreserveSymlinkFlag = require('supports-preserve-symlinks-flag'); + +var preserveSymlinks = false; +for (var i = 2; i < process.argv.length; i += 1) { + if (process.argv[i].slice(0, 2) === '--') { + if (supportsPreserveSymlinkFlag && process.argv[i] === '--preserve-symlinks') { + preserveSymlinks = true; + } else if (process.argv[i].length > 2) { + console.error('Unknown argument ' + process.argv[i].replace(/[=].*$/, '')); + process.exit(2); + } + process.argv.splice(i, 1); + i -= 1; + if (process.argv[i] === '--') { break; } // eslint-disable-line no-restricted-syntax + } +} + +if (process.argv.length < 3) { + console.error('Error: `resolve` expects a specifier'); + process.exit(2); +} + +var resolve = require('../'); + +var result = resolve.sync(process.argv[2], { + basedir: process.cwd(), + preserveSymlinks: preserveSymlinks +}); + +console.log(result); diff --git a/tools/ui/node_modules/.bin/rollup b/tools/ui/node_modules/.bin/rollup new file mode 100644 index 0000000000000000000000000000000000000000..16df48da34de5ceb173730c92106097cd154b439 --- /dev/null +++ b/tools/ui/node_modules/.bin/rollup @@ -0,0 +1,1912 @@ +#!/usr/bin/env node +/* + @license + Rollup.js v4.61.1 + Thu, 04 Jun 2026 05:21:21 GMT - commit b77daf0a97cf96e61870cc02de584e923bc70fad + + https://github.com/rollup/rollup + + Released under the MIT License. +*/ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const process$1 = require('node:process'); +const rollup = require('../shared/rollup.js'); +const require$$2 = require('util'); +const require$$0 = require('path'); +const require$$0$1 = require('fs'); +const parseAst_js = require('../shared/parseAst.js'); +const fseventsImporter = require('../shared/fsevents-importer.js'); +const promises = require('node:fs/promises'); +const path = require('node:path'); +const loadConfigFile_js = require('../shared/loadConfigFile.js'); +require('../native.js'); +require('node:perf_hooks'); +require('node:url'); +require('../getLogFilter.js'); + +const help = "rollup version 4.61.1\n=====================================\n\nUsage: rollup [options] \n\nOptions:\n\n-c, --config Use this config file (if argument is used but value\n is unspecified, Rollup will try to load configuration files in\n the following order:\n rollup.config.mjs -> rollup.config.cjs -> rollup.config.js)\n-d, --dir Directory for chunks (if absent, prints to stdout)\n-e, --external Comma-separate list of module IDs to exclude\n-f, --format Type of output (amd, cjs, es, iife, umd, system)\n-g, --globals Comma-separate list of `moduleID:Global` pairs\n-h, --help Show this help message\n-i, --input Input (alternative to )\n-m, --sourcemap Generate sourcemap (`-m inline` for inline map)\n-n, --name Name for UMD export\n-o, --file Single output file (if absent, prints to stdout)\n-p, --plugin Use the plugin specified (may be repeated)\n-v, --version Show version number\n-w, --watch Watch files in bundle and rebuild on changes\n--amd.autoId Generate the AMD ID based off the chunk name\n--amd.basePath Path to prepend to auto generated AMD ID\n--amd.define Function to use in place of `define`\n--amd.forceJsExtensionForImports Use `.js` extension in AMD imports\n--amd.id ID for AMD module (default is anonymous)\n--assetFileNames Name pattern for emitted assets\n--banner Code to insert at top of bundle (outside wrapper)\n--chunkFileNames Name pattern for emitted secondary chunks\n--compact Minify wrapper code\n--context Specify top-level `this` value\n--no-dynamicImportInCjs Write external dynamic CommonJS imports as require\n--entryFileNames Name pattern for emitted entry chunks\n--environment Settings passed to config file (see example)\n--no-esModule Do not add __esModule property\n--exports Specify export mode (auto, default, named, none)\n--extend Extend global variable defined by --name\n--no-externalImportAttributes Omit import attributes in \"es\" output\n--no-externalLiveBindings Do not generate code to support live bindings\n--failAfterWarnings Exit with an error if the build produced warnings\n--filterLogs Filter log messages\n--footer Code to insert at end of bundle (outside wrapper)\n--forceExit Force exit the process when done\n--no-freeze Do not freeze namespace objects\n--generatedCode Which code features to use (es5/es2015)\n--generatedCode.arrowFunctions Use arrow functions in generated code\n--generatedCode.constBindings Use \"const\" in generated code\n--generatedCode.objectShorthand Use shorthand properties in generated code\n--no-generatedCode.reservedNamesAsProps Always quote reserved names as props\n--generatedCode.symbols Use symbols in generated code\n--hashCharacters Use the specified character set for file hashes\n--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks\n--importAttributesKey Use the specified keyword for import attributes\n--no-indent Don't indent result\n--inlineDynamicImports Create single bundle when using dynamic imports\n--no-interop Do not include interop block\n--intro Code to insert at top of bundle (inside wrapper)\n--logLevel Which kind of logs to display\n--no-makeAbsoluteExternalsRelative Prevent normalization of external imports\n--maxParallelFileOps How many files to read in parallel\n--minifyInternalExports Force or disable minification of internal exports\n--noConflict Generate a noConflict method for UMD globals\n--outro Code to insert at end of bundle (inside wrapper)\n--perf Display performance timings\n--no-preserveEntrySignatures Avoid facade chunks for entry points\n--preserveModules Preserve module structure\n--preserveModulesRoot Put preserved modules under this path at root level\n--preserveSymlinks Do not follow symlinks when resolving files\n--no-reexportProtoFromExternal Ignore `__proto__` in star re-exports\n--no-sanitizeFileName Do not replace invalid characters in file names\n--shimMissingExports Create shim variables for missing exports\n--silent Don't print warnings\n--sourcemapBaseUrl Emit absolute sourcemap URLs with given base\n--sourcemapDebugIds Emit unique debug ids in source and sourcemaps\n--sourcemapExcludeSources Do not include source code in source maps\n--sourcemapFile Specify bundle position for source maps\n--sourcemapFileNames Name pattern for emitted sourcemaps\n--stdin=ext Specify file extension used for stdin input\n--no-stdin Do not read \"-\" from stdin\n--no-strict Don't emit `\"use strict\";` in the generated modules\n--strictDeprecations Throw errors for deprecated features\n--no-systemNullSetters Do not replace empty SystemJS setters with `null`\n--no-treeshake Disable tree-shaking optimisations\n--no-treeshake.annotations Ignore pure call annotations\n--treeshake.correctVarValueBeforeDeclaration Deoptimize variables until declared\n--treeshake.manualPureFunctions Manually declare functions as pure\n--no-treeshake.moduleSideEffects Assume modules have no side effects\n--no-treeshake.propertyReadSideEffects Ignore property access side effects\n--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking\n--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw\n--validate Validate output\n--waitForBundleInput Wait for bundle input files\n--watch.allowInputInsideOutputPath Whether the input path is allowed to be a\n subpath of the output path\n--watch.buildDelay Throttle watch rebuilds\n--no-watch.clearScreen Do not clear the screen when rebuilding\n--watch.exclude Exclude files from being watched\n--watch.include Limit watching to specified files\n--watch.onBundleEnd Shell command to run on `\"BUNDLE_END\"` event\n--watch.onBundleStart Shell command to run on `\"BUNDLE_START\"` event\n--watch.onEnd Shell command to run on `\"END\"` event\n--watch.onError Shell command to run on `\"ERROR\"` event\n--watch.onStart Shell command to run on `\"START\"` event\n--watch.skipWrite Do not write files to disk when watching\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n"; + +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +function camelCase(str) { + // Handle the case where an argument is provided as camel case, e.g., fooBar. + // by ensuring that the string isn't already mixed case: + const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase(); + if (!isCamelCase) { + str = str.toLowerCase(); + } + if (str.indexOf('-') === -1 && str.indexOf('_') === -1) { + return str; + } + else { + let camelcase = ''; + let nextChrUpper = false; + const leadingHyphens = str.match(/^-+/); + for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) { + let chr = str.charAt(i); + if (nextChrUpper) { + nextChrUpper = false; + chr = chr.toUpperCase(); + } + if (i !== 0 && (chr === '-' || chr === '_')) { + nextChrUpper = true; + } + else if (chr !== '-' && chr !== '_') { + camelcase += chr; + } + } + return camelcase; + } +} +function decamelize(str, joinString) { + const lowercase = str.toLowerCase(); + joinString = joinString || '-'; + let notCamelcase = ''; + for (let i = 0; i < str.length; i++) { + const chrLower = lowercase.charAt(i); + const chrString = str.charAt(i); + if (chrLower !== chrString && i > 0) { + notCamelcase += `${joinString}${lowercase.charAt(i)}`; + } + else { + notCamelcase += chrString; + } + } + return notCamelcase; +} +function looksLikeNumber(x) { + if (x === null || x === undefined) + return false; + // if loaded from config, may already be a number. + if (typeof x === 'number') + return true; + // hexadecimal. + if (/^0x[0-9a-f]+$/i.test(x)) + return true; + // don't treat 0123 as a number; as it drops the leading '0'. + if (/^0[^.]/.test(x)) + return false; + return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); +} + +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +// take an un-split argv string and tokenize it. +function tokenizeArgString(argString) { + if (Array.isArray(argString)) { + return argString.map(e => typeof e !== 'string' ? e + '' : e); + } + argString = argString.trim(); + let i = 0; + let prevC = null; + let c = null; + let opening = null; + const args = []; + for (let ii = 0; ii < argString.length; ii++) { + prevC = c; + c = argString.charAt(ii); + // split on spaces unless we're in quotes. + if (c === ' ' && !opening) { + if (!(prevC === ' ')) { + i++; + } + continue; + } + // don't split the string if we're in matching + // opening or closing single and double quotes. + if (c === opening) { + opening = null; + } + else if ((c === "'" || c === '"') && !opening) { + opening = c; + } + if (!args[i]) + args[i] = ''; + args[i] += c; + } + return args; +} + +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +var DefaultValuesForTypeKey; +(function (DefaultValuesForTypeKey) { + DefaultValuesForTypeKey["BOOLEAN"] = "boolean"; + DefaultValuesForTypeKey["STRING"] = "string"; + DefaultValuesForTypeKey["NUMBER"] = "number"; + DefaultValuesForTypeKey["ARRAY"] = "array"; +})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {})); + +/** + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +let mixin; +class YargsParser { + constructor(_mixin) { + mixin = _mixin; + } + parse(argsInput, options) { + const opts = Object.assign({ + alias: undefined, + array: undefined, + boolean: undefined, + config: undefined, + configObjects: undefined, + configuration: undefined, + coerce: undefined, + count: undefined, + default: undefined, + envPrefix: undefined, + narg: undefined, + normalize: undefined, + string: undefined, + number: undefined, + __: undefined, + key: undefined + }, options); + // allow a string argument to be passed in rather + // than an argv array. + const args = tokenizeArgString(argsInput); + // tokenizeArgString adds extra quotes to args if argsInput is a string + // only strip those extra quotes in processValue if argsInput is a string + const inputIsString = typeof argsInput === 'string'; + // aliases might have transitive relationships, normalize this. + const aliases = combineAliases(Object.assign(Object.create(null), opts.alias)); + const configuration = Object.assign({ + 'boolean-negation': true, + 'camel-case-expansion': true, + 'combine-arrays': false, + 'dot-notation': true, + 'duplicate-arguments-array': true, + 'flatten-duplicate-arrays': true, + 'greedy-arrays': true, + 'halt-at-non-option': false, + 'nargs-eats-options': false, + 'negation-prefix': 'no-', + 'parse-numbers': true, + 'parse-positional-numbers': true, + 'populate--': false, + 'set-placeholder-key': false, + 'short-option-groups': true, + 'strip-aliased': false, + 'strip-dashed': false, + 'unknown-options-as-args': false + }, opts.configuration); + const defaults = Object.assign(Object.create(null), opts.default); + const configObjects = opts.configObjects || []; + const envPrefix = opts.envPrefix; + const notFlagsOption = configuration['populate--']; + const notFlagsArgv = notFlagsOption ? '--' : '_'; + const newAliases = Object.create(null); + const defaulted = Object.create(null); + // allow a i18n handler to be passed in, default to a fake one (util.format). + const __ = opts.__ || mixin.format; + const flags = { + aliases: Object.create(null), + arrays: Object.create(null), + bools: Object.create(null), + strings: Object.create(null), + numbers: Object.create(null), + counts: Object.create(null), + normalize: Object.create(null), + configs: Object.create(null), + nargs: Object.create(null), + coercions: Object.create(null), + keys: [] + }; + const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/; + const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)'); + [].concat(opts.array || []).filter(Boolean).forEach(function (opt) { + const key = typeof opt === 'object' ? opt.key : opt; + // assign to flags[bools|strings|numbers] + const assignment = Object.keys(opt).map(function (key) { + const arrayFlagKeys = { + boolean: 'bools', + string: 'strings', + number: 'numbers' + }; + return arrayFlagKeys[key]; + }).filter(Boolean).pop(); + // assign key to be coerced + if (assignment) { + flags[assignment][key] = true; + } + flags.arrays[key] = true; + flags.keys.push(key); + }); + [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) { + flags.bools[key] = true; + flags.keys.push(key); + }); + [].concat(opts.string || []).filter(Boolean).forEach(function (key) { + flags.strings[key] = true; + flags.keys.push(key); + }); + [].concat(opts.number || []).filter(Boolean).forEach(function (key) { + flags.numbers[key] = true; + flags.keys.push(key); + }); + [].concat(opts.count || []).filter(Boolean).forEach(function (key) { + flags.counts[key] = true; + flags.keys.push(key); + }); + [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) { + flags.normalize[key] = true; + flags.keys.push(key); + }); + if (typeof opts.narg === 'object') { + Object.entries(opts.narg).forEach(([key, value]) => { + if (typeof value === 'number') { + flags.nargs[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.coerce === 'object') { + Object.entries(opts.coerce).forEach(([key, value]) => { + if (typeof value === 'function') { + flags.coercions[key] = value; + flags.keys.push(key); + } + }); + } + if (typeof opts.config !== 'undefined') { + if (Array.isArray(opts.config) || typeof opts.config === 'string') { + [].concat(opts.config).filter(Boolean).forEach(function (key) { + flags.configs[key] = true; + }); + } + else if (typeof opts.config === 'object') { + Object.entries(opts.config).forEach(([key, value]) => { + if (typeof value === 'boolean' || typeof value === 'function') { + flags.configs[key] = value; + } + }); + } + } + // create a lookup table that takes into account all + // combinations of aliases: {f: ['foo'], foo: ['f']} + extendAliases(opts.key, aliases, opts.default, flags.arrays); + // apply default values to all aliases. + Object.keys(defaults).forEach(function (key) { + (flags.aliases[key] || []).forEach(function (alias) { + defaults[alias] = defaults[key]; + }); + }); + let error = null; + checkConfiguration(); + let notFlags = []; + const argv = Object.assign(Object.create(null), { _: [] }); + // TODO(bcoe): for the first pass at removing object prototype we didn't + // remove all prototypes from objects returned by this API, we might want + // to gradually move towards doing so. + const argvReturn = {}; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + const truncatedArg = arg.replace(/^-{3,}/, '---'); + let broken; + let key; + let letters; + let m; + let next; + let value; + // any unknown option (except for end-of-options, "--") + if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) { + pushPositional(arg); + // ---, ---=, ----, etc, + } + else if (truncatedArg.match(/^---+(=|$)/)) { + // options without key name are invalid. + pushPositional(arg); + continue; + // -- separated by = + } + else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) { + // Using [\s\S] instead of . because js doesn't support the + // 'dotall' regex modifier. See: + // http://stackoverflow.com/a/1068308/13216 + m = arg.match(/^--?([^=]+)=([\s\S]*)$/); + // arrays format = '--f=a b c' + if (m !== null && Array.isArray(m) && m.length >= 3) { + if (checkAllAliases(m[1], flags.arrays)) { + i = eatArray(i, m[1], args, m[2]); + } + else if (checkAllAliases(m[1], flags.nargs) !== false) { + // nargs format = '--f=monkey washing cat' + i = eatNargs(i, m[1], args, m[2]); + } + else { + setArg(m[1], m[2], true); + } + } + } + else if (arg.match(negatedBoolean) && configuration['boolean-negation']) { + m = arg.match(negatedBoolean); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false); + } + // -- separated by space. + } + else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) { + m = arg.match(/^--?(.+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (checkAllAliases(key, flags.arrays)) { + // array format = '--foo a b c' + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '--foo a b c' + // should be truthy even if: flags.nargs[key] === 0 + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!next.match(/^-/) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + // dot-notation flag separated by '='. + } + else if (arg.match(/^-.\..+=/)) { + m = arg.match(/^-([^=]+)=([\s\S]*)$/); + if (m !== null && Array.isArray(m) && m.length >= 3) { + setArg(m[1], m[2]); + } + // dot-notation flag separated by space. + } + else if (arg.match(/^-.\..+/) && !arg.match(negative)) { + next = args[i + 1]; + m = arg.match(/^-(.\..+)/); + if (m !== null && Array.isArray(m) && m.length >= 2) { + key = m[1]; + if (next !== undefined && !next.match(/^-/) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + else if (arg.match(/^-[^-]+/) && !arg.match(negative)) { + letters = arg.slice(1, -1).split(''); + broken = false; + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (letters[j + 1] && letters[j + 1] === '=') { + value = arg.slice(j + 3); + key = letters[j]; + if (checkAllAliases(key, flags.arrays)) { + // array format = '-f=a b c' + i = eatArray(i, key, args, value); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '-f=monkey washing cat' + i = eatNargs(i, key, args, value); + } + else { + setArg(key, value); + } + broken = true; + break; + } + if (next === '-') { + setArg(letters[j], next); + continue; + } + // current letter is an alphabetic character and next value is a number + if (/[A-Za-z]/.test(letters[j]) && + /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && + checkAllAliases(next, flags.bools) === false) { + setArg(letters[j], next); + broken = true; + break; + } + if (letters[j + 1] && letters[j + 1].match(/\W/)) { + setArg(letters[j], next); + broken = true; + break; + } + else { + setArg(letters[j], defaultValue(letters[j])); + } + } + key = arg.slice(-1)[0]; + if (!broken && key !== '-') { + if (checkAllAliases(key, flags.arrays)) { + // array format = '-f a b c' + i = eatArray(i, key, args); + } + else if (checkAllAliases(key, flags.nargs) !== false) { + // nargs format = '-f a b c' + // should be truthy even if: flags.nargs[key] === 0 + i = eatNargs(i, key, args); + } + else { + next = args[i + 1]; + if (next !== undefined && (!/^(-|--)[^-]/.test(next) || + next.match(negative)) && + !checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts)) { + setArg(key, next); + i++; + } + else if (/^(true|false)$/.test(next)) { + setArg(key, next); + i++; + } + else { + setArg(key, defaultValue(key)); + } + } + } + } + else if (arg.match(/^-[0-9]$/) && + arg.match(negative) && + checkAllAliases(arg.slice(1), flags.bools)) { + // single-digit boolean alias, e.g: xargs -0 + key = arg.slice(1); + setArg(key, defaultValue(key)); + } + else if (arg === '--') { + notFlags = args.slice(i + 1); + break; + } + else if (configuration['halt-at-non-option']) { + notFlags = args.slice(i); + break; + } + else { + pushPositional(arg); + } + } + // order of precedence: + // 1. command line arg + // 2. value from env var + // 3. value from config file + // 4. value from config objects + // 5. configured default value + applyEnvVars(argv, true); // special case: check env vars that point to config file + applyEnvVars(argv, false); + setConfig(argv); + setConfigObjects(); + applyDefaultsAndAliases(argv, flags.aliases, defaults, true); + applyCoercions(argv); + if (configuration['set-placeholder-key']) + setPlaceholderKeys(argv); + // for any counts either not in args or without an explicit default, set to 0 + Object.keys(flags.counts).forEach(function (key) { + if (!hasKey(argv, key.split('.'))) + setArg(key, 0); + }); + // '--' defaults to undefined. + if (notFlagsOption && notFlags.length) + argv[notFlagsArgv] = []; + notFlags.forEach(function (key) { + argv[notFlagsArgv].push(key); + }); + if (configuration['camel-case-expansion'] && configuration['strip-dashed']) { + Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => { + delete argv[key]; + }); + } + if (configuration['strip-aliased']) { + [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => { + if (configuration['camel-case-expansion'] && alias.includes('-')) { + delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]; + } + delete argv[alias]; + }); + } + // Push argument into positional array, applying numeric coercion: + function pushPositional(arg) { + const maybeCoercedNumber = maybeCoerceNumber('_', arg); + if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') { + argv._.push(maybeCoercedNumber); + } + } + // how many arguments should we consume, based + // on the nargs option? + function eatNargs(i, key, args, argAfterEqualSign) { + let ii; + let toEat = checkAllAliases(key, flags.nargs); + // NaN has a special meaning for the array type, indicating that one or + // more values are expected. + toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat; + if (toEat === 0) { + if (!isUndefined(argAfterEqualSign)) { + error = Error(__('Argument unexpected for: %s', key)); + } + setArg(key, defaultValue(key)); + return i; + } + let available = isUndefined(argAfterEqualSign) ? 0 : 1; + if (configuration['nargs-eats-options']) { + // classic behavior, yargs eats positional and dash arguments. + if (args.length - (i + 1) + available < toEat) { + error = Error(__('Not enough arguments following: %s', key)); + } + available = toEat; + } + else { + // nargs will not consume flag arguments, e.g., -abc, --foo, + // and terminates when one is observed. + for (ii = i + 1; ii < args.length; ii++) { + if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii])) + available++; + else + break; + } + if (available < toEat) + error = Error(__('Not enough arguments following: %s', key)); + } + let consumed = Math.min(available, toEat); + if (!isUndefined(argAfterEqualSign) && consumed > 0) { + setArg(key, argAfterEqualSign); + consumed--; + } + for (ii = i + 1; ii < (consumed + i + 1); ii++) { + setArg(key, args[ii]); + } + return (i + consumed); + } + // if an option is an array, eat all non-hyphenated arguments + // following it... YUM! + // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"] + function eatArray(i, key, args, argAfterEqualSign) { + let argsToSet = []; + let next = argAfterEqualSign || args[i + 1]; + // If both array and nargs are configured, enforce the nargs count: + const nargsCount = checkAllAliases(key, flags.nargs); + if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) { + argsToSet.push(true); + } + else if (isUndefined(next) || + (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) { + // for keys without value ==> argsToSet remains an empty [] + // set user default value, if available + if (defaults[key] !== undefined) { + const defVal = defaults[key]; + argsToSet = Array.isArray(defVal) ? defVal : [defVal]; + } + } + else { + // value in --option=value is eaten as is + if (!isUndefined(argAfterEqualSign)) { + argsToSet.push(processValue(key, argAfterEqualSign, true)); + } + for (let ii = i + 1; ii < args.length; ii++) { + if ((!configuration['greedy-arrays'] && argsToSet.length > 0) || + (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount)) + break; + next = args[ii]; + if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) + break; + i = ii; + argsToSet.push(processValue(key, next, inputIsString)); + } + } + // If both array and nargs are configured, create an error if less than + // nargs positionals were found. NaN has special meaning, indicating + // that at least one value is required (more are okay). + if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) || + (isNaN(nargsCount) && argsToSet.length === 0))) { + error = Error(__('Not enough arguments following: %s', key)); + } + setArg(key, argsToSet); + return i; + } + function setArg(key, val, shouldStripQuotes = inputIsString) { + if (/-/.test(key) && configuration['camel-case-expansion']) { + const alias = key.split('.').map(function (prop) { + return camelCase(prop); + }).join('.'); + addNewAlias(key, alias); + } + const value = processValue(key, val, shouldStripQuotes); + const splitKey = key.split('.'); + setKey(argv, splitKey, value); + // handle populating aliases of the full key + if (flags.aliases[key]) { + flags.aliases[key].forEach(function (x) { + const keyProperties = x.split('.'); + setKey(argv, keyProperties, value); + }); + } + // handle populating aliases of the first element of the dot-notation key + if (splitKey.length > 1 && configuration['dot-notation']) { + (flags.aliases[splitKey[0]] || []).forEach(function (x) { + let keyProperties = x.split('.'); + // expand alias with nested objects in key + const a = [].concat(splitKey); + a.shift(); // nuke the old key. + keyProperties = keyProperties.concat(a); + // populate alias only if is not already an alias of the full key + // (already populated above) + if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) { + setKey(argv, keyProperties, value); + } + }); + } + // Set normalize getter and setter when key is in 'normalize' but isn't an array + if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) { + const keys = [key].concat(flags.aliases[key] || []); + keys.forEach(function (key) { + Object.defineProperty(argvReturn, key, { + enumerable: true, + get() { + return val; + }, + set(value) { + val = typeof value === 'string' ? mixin.normalize(value) : value; + } + }); + }); + } + } + function addNewAlias(key, alias) { + if (!(flags.aliases[key] && flags.aliases[key].length)) { + flags.aliases[key] = [alias]; + newAliases[alias] = true; + } + if (!(flags.aliases[alias] && flags.aliases[alias].length)) { + addNewAlias(alias, key); + } + } + function processValue(key, val, shouldStripQuotes) { + // strings may be quoted, clean this up as we assign values. + if (shouldStripQuotes) { + val = stripQuotes(val); + } + // handle parsing boolean arguments --foo=true --bar false. + if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) { + if (typeof val === 'string') + val = val === 'true'; + } + let value = Array.isArray(val) + ? val.map(function (v) { return maybeCoerceNumber(key, v); }) + : maybeCoerceNumber(key, val); + // increment a count given as arg (either no value or value parsed as boolean) + if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) { + value = increment(); + } + // Set normalized value when key is in 'normalize' and in 'arrays' + if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) { + if (Array.isArray(val)) + value = val.map((val) => { return mixin.normalize(val); }); + else + value = mixin.normalize(val); + } + return value; + } + function maybeCoerceNumber(key, value) { + if (!configuration['parse-positional-numbers'] && key === '_') + return value; + if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) { + const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`)))); + if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) { + value = Number(value); + } + } + return value; + } + // set args from config.json file, this should be + // applied last so that defaults can be applied. + function setConfig(argv) { + const configLookup = Object.create(null); + // expand defaults/aliases, in-case any happen to reference + // the config.json file. + applyDefaultsAndAliases(configLookup, flags.aliases, defaults); + Object.keys(flags.configs).forEach(function (configKey) { + const configPath = argv[configKey] || configLookup[configKey]; + if (configPath) { + try { + let config = null; + const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath); + const resolveConfig = flags.configs[configKey]; + if (typeof resolveConfig === 'function') { + try { + config = resolveConfig(resolvedConfigPath); + } + catch (e) { + config = e; + } + if (config instanceof Error) { + error = config; + return; + } + } + else { + config = mixin.require(resolvedConfigPath); + } + setConfigObject(config); + } + catch (ex) { + // Deno will receive a PermissionDenied error if an attempt is + // made to load config without the --allow-read flag: + if (ex.name === 'PermissionDenied') + error = ex; + else if (argv[configKey]) + error = Error(__('Invalid JSON config file: %s', configPath)); + } + } + }); + } + // set args from config object. + // it recursively checks nested objects. + function setConfigObject(config, prev) { + Object.keys(config).forEach(function (key) { + const value = config[key]; + const fullKey = prev ? prev + '.' + key : key; + // if the value is an inner object and we have dot-notation + // enabled, treat inner objects in config the same as + // heavily nested dot notations (foo.bar.apple). + if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) { + // if the value is an object but not an array, check nested object + setConfigObject(value, fullKey); + } + else { + // setting arguments via CLI takes precedence over + // values within the config file. + if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) { + setArg(fullKey, value); + } + } + }); + } + // set all config objects passed in opts + function setConfigObjects() { + if (typeof configObjects !== 'undefined') { + configObjects.forEach(function (configObject) { + setConfigObject(configObject); + }); + } + } + function applyEnvVars(argv, configOnly) { + if (typeof envPrefix === 'undefined') + return; + const prefix = typeof envPrefix === 'string' ? envPrefix : ''; + const env = mixin.env(); + Object.keys(env).forEach(function (envVar) { + if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) { + // get array of nested keys and convert them to camel case + const keys = envVar.split('__').map(function (key, i) { + if (i === 0) { + key = key.substring(prefix.length); + } + return camelCase(key); + }); + if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) { + setArg(keys.join('.'), env[envVar]); + } + } + }); + } + function applyCoercions(argv) { + let coerce; + const applied = new Set(); + Object.keys(argv).forEach(function (key) { + if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases + coerce = checkAllAliases(key, flags.coercions); + if (typeof coerce === 'function') { + try { + const value = maybeCoerceNumber(key, coerce(argv[key])); + ([].concat(flags.aliases[key] || [], key)).forEach(ali => { + applied.add(ali); + argv[ali] = value; + }); + } + catch (err) { + error = err; + } + } + } + }); + } + function setPlaceholderKeys(argv) { + flags.keys.forEach((key) => { + // don't set placeholder keys for dot notation options 'foo.bar'. + if (~key.indexOf('.')) + return; + if (typeof argv[key] === 'undefined') + argv[key] = undefined; + }); + return argv; + } + function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) { + Object.keys(defaults).forEach(function (key) { + if (!hasKey(obj, key.split('.'))) { + setKey(obj, key.split('.'), defaults[key]); + if (canLog) + defaulted[key] = true; + (aliases[key] || []).forEach(function (x) { + if (hasKey(obj, x.split('.'))) + return; + setKey(obj, x.split('.'), defaults[key]); + }); + } + }); + } + function hasKey(obj, keys) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + o = (o[key] || {}); + }); + const key = keys[keys.length - 1]; + if (typeof o !== 'object') + return false; + else + return key in o; + } + function setKey(obj, keys, value) { + let o = obj; + if (!configuration['dot-notation']) + keys = [keys.join('.')]; + keys.slice(0, -1).forEach(function (key) { + // TODO(bcoe): in the next major version of yargs, switch to + // Object.create(null) for dot notation: + key = sanitizeKey(key); + if (typeof o === 'object' && o[key] === undefined) { + o[key] = {}; + } + if (typeof o[key] !== 'object' || Array.isArray(o[key])) { + // ensure that o[key] is an array, and that the last item is an empty object. + if (Array.isArray(o[key])) { + o[key].push({}); + } + else { + o[key] = [o[key], {}]; + } + // we want to update the empty object at the end of the o[key] array, so set o to that object + o = o[key][o[key].length - 1]; + } + else { + o = o[key]; + } + }); + // TODO(bcoe): in the next major version of yargs, switch to + // Object.create(null) for dot notation: + const key = sanitizeKey(keys[keys.length - 1]); + const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays); + const isValueArray = Array.isArray(value); + let duplicate = configuration['duplicate-arguments-array']; + // nargs has higher priority than duplicate + if (!duplicate && checkAllAliases(key, flags.nargs)) { + duplicate = true; + if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) { + o[key] = undefined; + } + } + if (value === increment()) { + o[key] = increment(o[key]); + } + else if (Array.isArray(o[key])) { + if (duplicate && isTypeArray && isValueArray) { + o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]); + } + else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) { + o[key] = value; + } + else { + o[key] = o[key].concat([value]); + } + } + else if (o[key] === undefined && isTypeArray) { + o[key] = isValueArray ? value : [value]; + } + else if (duplicate && !(o[key] === undefined || + checkAllAliases(key, flags.counts) || + checkAllAliases(key, flags.bools))) { + o[key] = [o[key], value]; + } + else { + o[key] = value; + } + } + // extend the aliases list with inferred aliases. + function extendAliases(...args) { + args.forEach(function (obj) { + Object.keys(obj || {}).forEach(function (key) { + // short-circuit if we've already added a key + // to the aliases array, for example it might + // exist in both 'opts.default' and 'opts.key'. + if (flags.aliases[key]) + return; + flags.aliases[key] = [].concat(aliases[key] || []); + // For "--option-name", also set argv.optionName + flags.aliases[key].concat(key).forEach(function (x) { + if (/-/.test(x) && configuration['camel-case-expansion']) { + const c = camelCase(x); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + // For "--optionName", also set argv['option-name'] + flags.aliases[key].concat(key).forEach(function (x) { + if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) { + const c = decamelize(x, '-'); + if (c !== key && flags.aliases[key].indexOf(c) === -1) { + flags.aliases[key].push(c); + newAliases[c] = true; + } + } + }); + flags.aliases[key].forEach(function (x) { + flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) { + return x !== y; + })); + }); + }); + }); + } + function checkAllAliases(key, flag) { + const toCheck = [].concat(flags.aliases[key] || [], key); + const keys = Object.keys(flag); + const setAlias = toCheck.find(key => keys.includes(key)); + return setAlias ? flag[setAlias] : false; + } + function hasAnyFlag(key) { + const flagsKeys = Object.keys(flags); + const toCheck = [].concat(flagsKeys.map(k => flags[k])); + return toCheck.some(function (flag) { + return Array.isArray(flag) ? flag.includes(key) : flag[key]; + }); + } + function hasFlagsMatching(arg, ...patterns) { + const toCheck = [].concat(...patterns); + return toCheck.some(function (pattern) { + const match = arg.match(pattern); + return match && hasAnyFlag(match[1]); + }); + } + // based on a simplified version of the short flag group parsing logic + function hasAllShortFlags(arg) { + // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group + if (arg.match(negative) || !arg.match(/^-[^-]+/)) { + return false; + } + let hasAllFlags = true; + let next; + const letters = arg.slice(1).split(''); + for (let j = 0; j < letters.length; j++) { + next = arg.slice(j + 2); + if (!hasAnyFlag(letters[j])) { + hasAllFlags = false; + break; + } + if ((letters[j + 1] && letters[j + 1] === '=') || + next === '-' || + (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) || + (letters[j + 1] && letters[j + 1].match(/\W/))) { + break; + } + } + return hasAllFlags; + } + function isUnknownOptionAsArg(arg) { + return configuration['unknown-options-as-args'] && isUnknownOption(arg); + } + function isUnknownOption(arg) { + arg = arg.replace(/^-{3,}/, '--'); + // ignore negative numbers + if (arg.match(negative)) { + return false; + } + // if this is a short option group and all of them are configured, it isn't unknown + if (hasAllShortFlags(arg)) { + return false; + } + // e.g. '--count=2' + const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/; + // e.g. '-a' or '--arg' + const normalFlag = /^-+([^=]+?)$/; + // e.g. '-a-' + const flagEndingInHyphen = /^-+([^=]+?)-$/; + // e.g. '-abc123' + const flagEndingInDigits = /^-+([^=]+?\d+)$/; + // e.g. '-a/usr/local' + const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/; + // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method + return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters); + } + // make a best effort to pick a default value + // for an option based on name and type. + function defaultValue(key) { + if (!checkAllAliases(key, flags.bools) && + !checkAllAliases(key, flags.counts) && + `${key}` in defaults) { + return defaults[key]; + } + else { + return defaultForType(guessType(key)); + } + } + // return a default value, given the type of a flag., + function defaultForType(type) { + const def = { + [DefaultValuesForTypeKey.BOOLEAN]: true, + [DefaultValuesForTypeKey.STRING]: '', + [DefaultValuesForTypeKey.NUMBER]: undefined, + [DefaultValuesForTypeKey.ARRAY]: [] + }; + return def[type]; + } + // given a flag, enforce a default type. + function guessType(key) { + let type = DefaultValuesForTypeKey.BOOLEAN; + if (checkAllAliases(key, flags.strings)) + type = DefaultValuesForTypeKey.STRING; + else if (checkAllAliases(key, flags.numbers)) + type = DefaultValuesForTypeKey.NUMBER; + else if (checkAllAliases(key, flags.bools)) + type = DefaultValuesForTypeKey.BOOLEAN; + else if (checkAllAliases(key, flags.arrays)) + type = DefaultValuesForTypeKey.ARRAY; + return type; + } + function isUndefined(num) { + return num === undefined; + } + // check user configuration settings for inconsistencies + function checkConfiguration() { + // count keys should not be set as array/narg + Object.keys(flags.counts).find(key => { + if (checkAllAliases(key, flags.arrays)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key)); + return true; + } + else if (checkAllAliases(key, flags.nargs)) { + error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key)); + return true; + } + return false; + }); + } + return { + aliases: Object.assign({}, flags.aliases), + argv: Object.assign(argvReturn, argv), + configuration: configuration, + defaulted: Object.assign({}, defaulted), + error: error, + newAliases: Object.assign({}, newAliases) + }; + } +} +// if any aliases reference each other, we should +// merge them together. +function combineAliases(aliases) { + const aliasArrays = []; + const combined = Object.create(null); + let change = true; + // turn alias lookup hash {key: ['alias1', 'alias2']} into + // a simple array ['key', 'alias1', 'alias2'] + Object.keys(aliases).forEach(function (key) { + aliasArrays.push([].concat(aliases[key], key)); + }); + // combine arrays until zero changes are + // made in an iteration. + while (change) { + change = false; + for (let i = 0; i < aliasArrays.length; i++) { + for (let ii = i + 1; ii < aliasArrays.length; ii++) { + const intersect = aliasArrays[i].filter(function (v) { + return aliasArrays[ii].indexOf(v) !== -1; + }); + if (intersect.length) { + aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]); + aliasArrays.splice(ii, 1); + change = true; + break; + } + } + } + } + // map arrays back to the hash-lookup (de-dupe while + // we're at it). + aliasArrays.forEach(function (aliasArray) { + aliasArray = aliasArray.filter(function (v, i, self) { + return self.indexOf(v) === i; + }); + const lastAlias = aliasArray.pop(); + if (lastAlias !== undefined && typeof lastAlias === 'string') { + combined[lastAlias] = aliasArray; + } + }); + return combined; +} +// this function should only be called when a count is given as an arg +// it is NOT called to set a default value +// thus we can start the count at 1 instead of 0 +function increment(orig) { + return orig !== undefined ? orig + 1 : 1; +} +// TODO(bcoe): in the next major version of yargs, switch to +// Object.create(null) for dot notation: +function sanitizeKey(key) { + if (key === '__proto__') + return '___proto___'; + return key; +} +function stripQuotes(val) { + return (typeof val === 'string' && + (val[0] === "'" || val[0] === '"') && + val[val.length - 1] === val[0]) + ? val.substring(1, val.length - 1) + : val; +} + +/** + * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js + * CJS and ESM environments. + * + * @license + * Copyright (c) 2016, Contributors + * SPDX-License-Identifier: ISC + */ +var _a, _b, _c; +// See https://github.com/yargs/yargs-parser#supported-nodejs-versions for our +// version support policy. The YARGS_MIN_NODE_VERSION is used for testing only. +const minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION) + ? Number(process.env.YARGS_MIN_NODE_VERSION) + : 12; +const nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1); +if (nodeVersion) { + const major = Number(nodeVersion.match(/^([^.]+)/)[1]); + if (major < minNodeVersion) { + throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`); + } +} +// Creates a yargs-parser instance using Node.js standard libraries: +const env = process ? process.env : {}; +const parser = new YargsParser({ + cwd: process.cwd, + env: () => { + return env; + }, + format: require$$2.format, + normalize: require$$0.normalize, + resolve: require$$0.resolve, + // TODO: figure out a way to combine ESM and CJS coverage, such that + // we can exercise all the lines below: + require: (path) => { + if (typeof require !== 'undefined') { + return require(path); + } + else if (path.match(/\.json$/)) { + // Addresses: https://github.com/yargs/yargs/issues/2040 + return JSON.parse(require$$0$1.readFileSync(path, 'utf8')); + } + else { + throw Error('only .json config files are supported in ESM'); + } + } +}); +const yargsParser = function Parser(args, opts) { + const result = parser.parse(args.slice(), opts); + return result.argv; +}; +yargsParser.detailed = function (args, opts) { + return parser.parse(args.slice(), opts); +}; +yargsParser.camelCase = camelCase; +yargsParser.decamelize = decamelize; +yargsParser.looksLikeNumber = looksLikeNumber; + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise, SuppressedError, Symbol, Iterator */ + + +function __addDisposableResource(env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; + +} + +var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +function __disposeResources(env) { + function fail(e) { + env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); +} + +const toZeroIfInfinity = value => Number.isFinite(value) ? value : 0; + +function parseNumber(milliseconds) { + return { + days: Math.trunc(milliseconds / 86_400_000), + hours: Math.trunc(milliseconds / 3_600_000 % 24), + minutes: Math.trunc(milliseconds / 60_000 % 60), + seconds: Math.trunc(milliseconds / 1000 % 60), + milliseconds: Math.trunc(milliseconds % 1000), + microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1000) % 1000), + nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1000), + }; +} + +function parseBigint(milliseconds) { + return { + days: milliseconds / 86_400_000n, + hours: milliseconds / 3_600_000n % 24n, + minutes: milliseconds / 60_000n % 60n, + seconds: milliseconds / 1000n % 60n, + milliseconds: milliseconds % 1000n, + microseconds: 0n, + nanoseconds: 0n, + }; +} + +function parseMilliseconds(milliseconds) { + switch (typeof milliseconds) { + case 'number': { + if (Number.isFinite(milliseconds)) { + return parseNumber(milliseconds); + } + + break; + } + + case 'bigint': { + return parseBigint(milliseconds); + } + + // No default + } + + throw new TypeError('Expected a finite number or bigint'); +} + +const isZero = value => value === 0 || value === 0n; +const pluralize = (word, count) => (count === 1 || count === 1n) ? word : `${word}s`; + +const SECOND_ROUNDING_EPSILON = 0.000_000_1; +const ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n; + +function prettyMilliseconds(milliseconds, options) { + const isBigInt = typeof milliseconds === 'bigint'; + if (!isBigInt && !Number.isFinite(milliseconds)) { + throw new TypeError('Expected a finite number or bigint'); + } + + options = {...options}; + + const sign = milliseconds < 0 ? '-' : ''; + milliseconds = milliseconds < 0 ? -milliseconds : milliseconds; // Cannot use `Math.abs()` because of BigInt support. + + if (options.colonNotation) { + options.compact = false; + options.formatSubMilliseconds = false; + options.separateMilliseconds = false; + options.verbose = false; + } + + if (options.compact) { + options.unitCount = 1; + options.secondsDecimalDigits = 0; + options.millisecondsDecimalDigits = 0; + } + + let result = []; + + const floorDecimals = (value, decimalDigits) => { + const flooredInterimValue = Math.floor((value * (10 ** decimalDigits)) + SECOND_ROUNDING_EPSILON); + const flooredValue = Math.round(flooredInterimValue) / (10 ** decimalDigits); + return flooredValue.toFixed(decimalDigits); + }; + + const add = (value, long, short, valueString) => { + if ( + (result.length === 0 || !options.colonNotation) + && isZero(value) + && !(options.colonNotation && short === 'm')) { + return; + } + + valueString ??= String(value); + if (options.colonNotation) { + const wholeDigits = valueString.includes('.') ? valueString.split('.')[0].length : valueString.length; + const minLength = result.length > 0 ? 2 : 1; + valueString = '0'.repeat(Math.max(0, minLength - wholeDigits)) + valueString; + } else { + valueString += options.verbose ? ' ' + pluralize(long, value) : short; + } + + result.push(valueString); + }; + + const parsed = parseMilliseconds(milliseconds); + const days = BigInt(parsed.days); + + if (options.hideYearAndDays) { + add((BigInt(days) * 24n) + BigInt(parsed.hours), 'hour', 'h'); + } else { + if (options.hideYear) { + add(days, 'day', 'd'); + } else { + add(days / 365n, 'year', 'y'); + add(days % 365n, 'day', 'd'); + } + + add(Number(parsed.hours), 'hour', 'h'); + } + + add(Number(parsed.minutes), 'minute', 'm'); + + if (!options.hideSeconds) { + if ( + options.separateMilliseconds + || options.formatSubMilliseconds + || (!options.colonNotation && milliseconds < 1000 && !options.subSecondsAsDecimals) + ) { + const seconds = Number(parsed.seconds); + const milliseconds = Number(parsed.milliseconds); + const microseconds = Number(parsed.microseconds); + const nanoseconds = Number(parsed.nanoseconds); + + add(seconds, 'second', 's'); + + if (options.formatSubMilliseconds) { + add(milliseconds, 'millisecond', 'ms'); + add(microseconds, 'microsecond', 'µs'); + add(nanoseconds, 'nanosecond', 'ns'); + } else { + const millisecondsAndBelow + = milliseconds + + (microseconds / 1000) + + (nanoseconds / 1e6); + + const millisecondsDecimalDigits + = typeof options.millisecondsDecimalDigits === 'number' + ? options.millisecondsDecimalDigits + : 0; + + const roundedMilliseconds = millisecondsAndBelow >= 1 + ? Math.round(millisecondsAndBelow) + : Math.ceil(millisecondsAndBelow); + + const millisecondsString = millisecondsDecimalDigits + ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) + : roundedMilliseconds; + + add( + Number.parseFloat(millisecondsString), + 'millisecond', + 'ms', + millisecondsString, + ); + } + } else { + const seconds = ( + (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) + / 1000 + ) % 60; + const secondsDecimalDigits + = typeof options.secondsDecimalDigits === 'number' + ? options.secondsDecimalDigits + : 1; + const secondsFixed = floorDecimals(seconds, secondsDecimalDigits); + const secondsString = options.keepDecimalsOnWholeSeconds + ? secondsFixed + : secondsFixed.replace(/\.0+$/, ''); + add(Number.parseFloat(secondsString), 'second', 's', secondsString); + } + } + + if (result.length === 0) { + return sign + '0' + (options.verbose ? ' milliseconds' : 'ms'); + } + + const separator = options.colonNotation ? ':' : ' '; + if (typeof options.unitCount === 'number') { + result = result.slice(0, Math.max(options.unitCount, 1)); + } + + return sign + result.join(separator); +} + +const BYTE_UNITS = [ + 'B', + 'kB', + 'MB', + 'GB', + 'TB', + 'PB', + 'EB', + 'ZB', + 'YB', +]; + +const BIBYTE_UNITS = [ + 'B', + 'KiB', + 'MiB', + 'GiB', + 'TiB', + 'PiB', + 'EiB', + 'ZiB', + 'YiB', +]; + +const BIT_UNITS = [ + 'b', + 'kbit', + 'Mbit', + 'Gbit', + 'Tbit', + 'Pbit', + 'Ebit', + 'Zbit', + 'Ybit', +]; + +const BIBIT_UNITS = [ + 'b', + 'kibit', + 'Mibit', + 'Gibit', + 'Tibit', + 'Pibit', + 'Eibit', + 'Zibit', + 'Yibit', +]; + +/* +Formats the given number using `Number#toLocaleString`. +- If locale is a string, the value is expected to be a locale-key (for example: `de`). +- If locale is true, the system default locale is used for translation. +- If no value for locale is specified, the number is returned unmodified. +*/ +const toLocaleString = (number, locale, options) => { + let result = number; + if (typeof locale === 'string' || Array.isArray(locale)) { + result = number.toLocaleString(locale, options); + } else if (locale === true || options !== undefined) { + result = number.toLocaleString(undefined, options); + } + + return result; +}; + +const log10 = numberOrBigInt => { + if (typeof numberOrBigInt === 'number') { + return Math.log10(numberOrBigInt); + } + + const string = numberOrBigInt.toString(10); + + return string.length + Math.log10(`0.${string.slice(0, 15)}`); +}; + +const log = numberOrBigInt => { + if (typeof numberOrBigInt === 'number') { + return Math.log(numberOrBigInt); + } + + return log10(numberOrBigInt) * Math.log(10); +}; + +const divide = (numberOrBigInt, divisor) => { + if (typeof numberOrBigInt === 'number') { + return numberOrBigInt / divisor; + } + + const integerPart = numberOrBigInt / BigInt(divisor); + const remainder = numberOrBigInt % BigInt(divisor); + return Number(integerPart) + (Number(remainder) / divisor); +}; + +const applyFixedWidth = (result, fixedWidth) => { + if (fixedWidth === undefined) { + return result; + } + + if (typeof fixedWidth !== 'number' || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0) { + throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`); + } + + if (fixedWidth === 0) { + return result; + } + + return result.length < fixedWidth ? result.padStart(fixedWidth, ' ') : result; +}; + +const buildLocaleOptions = options => { + const {minimumFractionDigits, maximumFractionDigits} = options; + + if (minimumFractionDigits === undefined && maximumFractionDigits === undefined) { + return undefined; + } + + return { + ...(minimumFractionDigits !== undefined && {minimumFractionDigits}), + ...(maximumFractionDigits !== undefined && {maximumFractionDigits}), + roundingMode: 'trunc', + }; +}; + +function prettyBytes(number, options) { + if (typeof number !== 'bigint' && !Number.isFinite(number)) { + throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`); + } + + options = { + bits: false, + binary: false, + space: true, + nonBreakingSpace: false, + ...options, + }; + + const UNITS = options.bits + ? (options.binary ? BIBIT_UNITS : BIT_UNITS) + : (options.binary ? BIBYTE_UNITS : BYTE_UNITS); + + const separator = options.space ? (options.nonBreakingSpace ? '\u00A0' : ' ') : ''; + + // Handle signed zero case + const isZero = typeof number === 'number' ? number === 0 : number === 0n; + if (options.signed && isZero) { + const result = ` 0${separator}${UNITS[0]}`; + return applyFixedWidth(result, options.fixedWidth); + } + + const isNegative = number < 0; + const prefix = isNegative ? '-' : (options.signed ? '+' : ''); + + if (isNegative) { + number = -number; + } + + const localeOptions = buildLocaleOptions(options); + let result; + + if (number < 1) { + const numberString = toLocaleString(number, options.locale, localeOptions); + result = prefix + numberString + separator + UNITS[0]; + } else { + const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1); + number = divide(number, (options.binary ? 1024 : 1000) ** exponent); + + if (!localeOptions) { + const minPrecision = Math.max(3, Math.floor(number).toString().length); + number = number.toPrecision(minPrecision); + } + + const numberString = toLocaleString(Number(number), options.locale, localeOptions); + const unit = UNITS[exponent]; + result = prefix + numberString + separator + unit; + } + + return applyFixedWidth(result, options.fixedWidth); +} + +function printTimings(timings) { + for (const [label, [time, memory, total]] of Object.entries(timings)) { + const appliedColor = label[0] === '#' ? (label[1] === '#' ? rollup.bold : rollup.underline) : (text) => text; + const row = `${label}: ${time.toFixed(0)}ms, ${prettyBytes(memory)} / ${prettyBytes(total)}`; + console.info(appliedColor(row)); + } +} + +async function build(inputOptions, warnings, silent = false) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const outputOptions = inputOptions.output; + const useStdout = !outputOptions[0].file && !outputOptions[0].dir; + const start = Date.now(); + const files = useStdout ? ['stdout'] : outputOptions.map(t => parseAst_js.relativeId(t.file || t.dir)); + if (!silent) { + let inputFiles; + if (typeof inputOptions.input === 'string') { + inputFiles = inputOptions.input; + } + else if (Array.isArray(inputOptions.input)) { + inputFiles = inputOptions.input.join(', '); + } + else if (typeof inputOptions.input === 'object' && inputOptions.input !== null) { + inputFiles = Object.values(inputOptions.input).join(', '); + } + rollup.stderr(rollup.cyan(`\n${rollup.bold(inputFiles)} → ${rollup.bold(files.join(', '))}...`)); + } + const bundle = __addDisposableResource(env_1, await rollup.rollup(inputOptions), true); + if (useStdout) { + const output = outputOptions[0]; + if (output.sourcemap && output.sourcemap !== 'inline') { + rollup.handleError(parseAst_js.logOnlyInlineSourcemapsForStdout()); + } + const { output: outputs } = await bundle.generate(output); + for (const file of outputs) { + if (outputs.length > 1) + process$1.stdout.write(`\n${rollup.cyan(rollup.bold(`//→ ${file.fileName}:`))}\n`); + process$1.stdout.write(file.type === 'asset' ? file.source : file.code); + } + if (!silent) { + warnings.flush(); + } + return; + } + await Promise.all(outputOptions.map(bundle.write)); + if (!silent) { + warnings.flush(); + rollup.stderr(rollup.green(`created ${rollup.bold(files.join(', '))} in ${rollup.bold(prettyMilliseconds(Date.now() - start))}`)); + if (bundle && bundle.getTimings) { + printTimings(bundle.getTimings()); + } + } + } + catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } + finally { + const result_1 = __disposeResources(env_1); + if (result_1) + await result_1; + } +} + +const DEFAULT_CONFIG_BASE = 'rollup.config'; +async function getConfigPath(commandConfig) { + if (commandConfig === true) { + return path.resolve(await findConfigFileNameInCwd()); + } + if (commandConfig.slice(0, 5) === 'node:') { + const packageName = commandConfig.slice(5); + try { + return require.resolve(`rollup-config-${packageName}`, { paths: [process$1.cwd()] }); + } + catch { + try { + return require.resolve(packageName, { paths: [process$1.cwd()] }); + } + catch (error) { + if (error.code === 'MODULE_NOT_FOUND') { + rollup.handleError(parseAst_js.logMissingExternalConfig(commandConfig)); + } + throw error; + } + } + } + return path.resolve(commandConfig); +} +async function findConfigFileNameInCwd() { + const filesInWorkingDirectory = new Set(await promises.readdir(process$1.cwd())); + for (const extension of ['mjs', 'cjs', 'ts']) { + const fileName = `${DEFAULT_CONFIG_BASE}.${extension}`; + if (filesInWorkingDirectory.has(fileName)) + return fileName; + } + return `${DEFAULT_CONFIG_BASE}.js`; +} + +async function loadConfigFromCommand(commandOptions, watchMode) { + const warnings = loadConfigFile_js.batchWarnings(commandOptions); + if (!commandOptions.input && (commandOptions.stdin || !process$1.stdin.isTTY)) { + commandOptions.input = loadConfigFile_js.stdinName; + } + const options = await rollup.mergeOptions({ input: [] }, watchMode, commandOptions, warnings.log); + await loadConfigFile_js.addCommandPluginsToInputOptions(options, commandOptions); + return { options: [options], warnings }; +} + +async function runRollup(command) { + let inputSource; + if (command._.length > 0) { + if (command.input) { + rollup.handleError(parseAst_js.logDuplicateImportOptions()); + } + inputSource = command._; + } + else if (typeof command.input === 'string') { + inputSource = [command.input]; + } + else { + inputSource = command.input; + } + if (inputSource && inputSource.length > 0) { + if (inputSource.some((input) => input.includes('='))) { + command.input = {}; + for (const input of inputSource) { + const equalsIndex = input.indexOf('='); + const value = input.slice(Math.max(0, equalsIndex + 1)); + const key = input.slice(0, Math.max(0, equalsIndex)) || parseAst_js.getAliasName(input); + command.input[key] = value; + } + } + else { + command.input = inputSource; + } + } + if (command.environment) { + const environment = Array.isArray(command.environment) + ? command.environment + : [command.environment]; + for (const argument of environment) { + for (const pair of argument.split(',')) { + const [key, ...value] = pair.split(':'); + process$1.env[key] = value.length === 0 ? String(true) : value.join(':'); + } + } + } + if (rollup.isWatchEnabled(command.watch)) { + await fseventsImporter.loadFsEvents(); + const { watch } = await Promise.resolve().then(() => require('../shared/watch-cli.js')); + await watch(command); + } + else { + try { + const { options, warnings } = await getConfigs(command); + try { + for (const inputOptions of options) { + if (!inputOptions.cache) { + // We explicitly disable the cache when unused as the CLI will not + // use the cache object on the bundle when not in watch mode. This + // improves performance as the cache is not generated. + inputOptions.cache = false; + } + await build(inputOptions, warnings, command.silent); + } + if (command.failAfterWarnings && warnings.warningOccurred) { + warnings.flush(); + rollup.handleError(parseAst_js.logFailAfterWarnings()); + } + } + catch (error) { + warnings.flush(); + rollup.handleError(error); + } + } + catch (error) { + rollup.handleError(error); + } + } +} +async function getConfigs(command) { + if (command.config) { + const configFile = await getConfigPath(command.config); + const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command, false); + return { options, warnings }; + } + return await loadConfigFromCommand(command, false); +} + +const command = yargsParser(process$1.argv.slice(2), { + alias: rollup.commandAliases, + configuration: { 'camel-case-expansion': false } +}); +if (command.help || (process$1.argv.length <= 2 && process$1.stdin.isTTY)) { + console.log(`\n${help}\n`); +} +else if (command.version) { + console.log(`rollup v${rollup.version}`); +} +else { + try { + // eslint-disable-next-line @typescript-eslint/no-require-imports + require('source-map-support').install(); + } + catch { + // do nothing + } + const promise = runRollup(command); + if (command.forceExit) { + promise.then(() => process$1.exit()); + } +} + +exports.getConfigPath = getConfigPath; +exports.loadConfigFromCommand = loadConfigFromCommand; +exports.prettyMilliseconds = prettyMilliseconds; +exports.printTimings = printTimings; +//# sourceMappingURL=rollup.map diff --git a/tools/ui/node_modules/.bin/sass b/tools/ui/node_modules/.bin/sass new file mode 100644 index 0000000000000000000000000000000000000000..df287fc4709baf2e5d7e182f74147acbf9f45d98 --- /dev/null +++ b/tools/ui/node_modules/.bin/sass @@ -0,0 +1,18 @@ +#!/usr/bin/env node + +require('./sass.dart.js'); +var library = globalThis._cliPkgExports.pop(); +if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports; + +library.load({ + readline: require("readline"), + chokidar: require("chokidar"), + parcel_watcher: (function(i){let r;return function parcel_watcher(){if(void 0!==r)return r;try{r=require(i)}catch(e){if('MODULE_NOT_FOUND'!==e.code)console.error(e);r=null}return r}})("@parcel/watcher"), + util: require("util"), + stream: require("stream"), + nodeModule: require("module"), + fs: require("fs"), + immutable: require("immutable"), +}); + +library.cli_pkg_main_0_(process.argv.slice(2)); diff --git a/tools/ui/node_modules/.bin/semver b/tools/ui/node_modules/.bin/semver new file mode 100644 index 0000000000000000000000000000000000000000..9ae8aadb95fbd9a67a0e8da3a1c8eacc86e86201 --- /dev/null +++ b/tools/ui/node_modules/.bin/semver @@ -0,0 +1,195 @@ +#!/usr/bin/env node +// Standalone semver comparison program. +// Exits successfully and prints matching version(s) if +// any supplied version is valid and passes all tests. + +'use strict' + +const argv = process.argv.slice(2) + +let versions = [] + +const range = [] + +let inc = null + +const version = require('../package.json').version + +let loose = false + +let includePrerelease = false + +let coerce = false + +let rtl = false + +let identifier + +let identifierBase + +const semver = require('../') +const parseOptions = require('../internal/parse-options') + +let reverse = false + +let options = {} + +const main = () => { + if (!argv.length) { + return help() + } + while (argv.length) { + let a = argv.shift() + const indexOfEqualSign = a.indexOf('=') + if (indexOfEqualSign !== -1) { + const value = a.slice(indexOfEqualSign + 1) + a = a.slice(0, indexOfEqualSign) + argv.unshift(value) + } + + switch (a) { + case '-rv': case '-rev': case '--rev': case '--reverse': + reverse = true + break + case '-l': case '--loose': + loose = true + break + case '-p': case '--include-prerelease': + includePrerelease = true + break + case '-v': case '--version': + versions.push(argv.shift()) + break + case '-i': case '--inc': case '--increment': + if (semver.RELEASE_TYPES.includes(argv[0]) || (argv[0] === 'release')) { + inc = { value: argv.shift(), maybeErrantValue: null, option: a } + } else { + inc = { value: 'patch', maybeErrantValue: argv[0], option: a } + } + break + case '--preid': + identifier = argv.shift() + break + case '-r': case '--range': + range.push(argv.shift()) + break + case '-n': + identifierBase = argv.shift() + if (identifierBase === 'false') { + identifierBase = false + } + break + case '-c': case '--coerce': + coerce = true + break + case '--rtl': + rtl = true + break + case '--ltr': + rtl = false + break + case '-h': case '--help': case '-?': + return help() + default: + versions.push(a) + break + } + } + + options = parseOptions({ loose, includePrerelease, rtl }) + + if ( + inc && + versions.includes(inc.maybeErrantValue) && + !semver.valid(inc.maybeErrantValue, options) + ) { + console.warn(`Invalid value for ${inc.option}; defaulting to 'patch'. This may become a failure in future major versions.`) + } + + versions = versions.map((v) => { + return coerce ? (semver.coerce(v, options) || { version: v }).version : v + }).filter((v) => { + return semver.valid(v, options) + }) + if (!versions.length) { + return fail() + } + if (inc && (versions.length !== 1 || range.length)) { + return failInc() + } + + for (let i = 0, l = range.length; i < l; i++) { + versions = versions.filter((v) => { + return semver.satisfies(v, range[i], options) + }) + if (!versions.length) { + return fail() + } + } + versions + .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options)) + .map(v => semver.clean(v, options)) + .map(v => inc ? semver.inc(v, inc.value, options, identifier, identifierBase) : v) + .forEach(v => console.log(v)) +} + +const failInc = () => { + console.error('--inc can only be used on a single version with no range') + fail() +} + +const fail = () => process.exit(1) + +const help = () => console.log( +`SemVer ${version} + +A JavaScript implementation of the https://semver.org/ specification +Copyright Isaac Z. Schlueter + +Usage: semver [options] [ [...]] +Prints valid versions sorted by SemVer precedence + +Options: +-r --range + Print versions that match the specified range. + +-i --increment [] + Increment a version by the specified level. Level can + be one of: major, minor, patch, premajor, preminor, + prepatch, prerelease, or release. Default level is 'patch'. + Only one version may be specified. + +--preid + Identifier to be used to prefix premajor, preminor, + prepatch or prerelease version increments. + +-l --loose + Interpret versions and ranges loosely + +-p --include-prerelease + Always include prerelease versions in range matching + +-c --coerce + Coerce a string into SemVer if possible + (does not imply --loose) + +--rtl + Coerce version strings right to left + +--ltr + Coerce version strings left to right (default) + +-n + Base number to be used for the prerelease identifier. + Can be either 0 or 1, or false to omit the number altogether. + Defaults to 0. + +Program exits successfully if any valid version satisfies +all supplied ranges, and prints all satisfying versions. + +If no satisfying versions are found, then exits failure. + +Versions are printed in ascending order, so supplying +multiple versions to the utility will just sort them.`) + +main() diff --git a/tools/ui/node_modules/.bin/storybook b/tools/ui/node_modules/.bin/storybook new file mode 100644 index 0000000000000000000000000000000000000000..b4ec3e7d0b9c77832ac83c0ed523fe9202669fe7 --- /dev/null +++ b/tools/ui/node_modules/.bin/storybook @@ -0,0 +1,91 @@ +#!/usr/bin/env node +import CJS_COMPAT_NODE_URL_9zo2090uugq from 'node:url'; +import CJS_COMPAT_NODE_PATH_9zo2090uugq from 'node:path'; +import CJS_COMPAT_NODE_MODULE_9zo2090uugq from "node:module"; + +var __filename = CJS_COMPAT_NODE_URL_9zo2090uugq.fileURLToPath(import.meta.url); +var __dirname = CJS_COMPAT_NODE_PATH_9zo2090uugq.dirname(__filename); +var require = CJS_COMPAT_NODE_MODULE_9zo2090uugq.createRequire(import.meta.url); + +// ------------------------------------------------------------ +// end of CJS compatibility banner, injected by Storybook's esbuild configuration +// ------------------------------------------------------------ +import { + MIN_SUPPORTED_NODE_DESCRIPTION, + isNodeVersionSupported, + versions_default +} from "../_node-chunks/chunk-6IJC47ZF.js"; +import { + resolvePackageDir +} from "../_node-chunks/chunk-P34EJWSD.js"; +import "../_node-chunks/chunk-WBGUDDIU.js"; +import { + require_dist +} from "../_node-chunks/chunk-RSQFAFCN.js"; +import { + join +} from "../_node-chunks/chunk-AN5PKEA2.js"; +import { + __toESM +} from "../_node-chunks/chunk-IATWEHFW.js"; + +// src/bin/dispatcher.ts +import { pathToFileURL } from "node:url"; +import { + JsPackageManagerFactory, + executeNodeCommand, + getRemotePackageRunnerArgs +} from "storybook/internal/common"; +import { logger } from "storybook/internal/node-logger"; +var import_ts_dedent = __toESM(require_dist(), 1); +var [major, minor, patch] = process.versions.node.split(".").map(Number); +isNodeVersionSupported(major, minor, patch) || (logger.error( + import_ts_dedent.dedent`To run Storybook, you need Node.js version ${MIN_SUPPORTED_NODE_DESCRIPTION}. + You are currently running Node.js ${process.version}. Please upgrade your Node.js installation.` +), process.exit(1)); +async function run() { + let args = process.argv.slice(2); + if (["dev", "build", "index", "ai"].includes(args[0])) { + await import(pathToFileURL(join(resolvePackageDir("storybook"), "dist/bin/core.js")).href); + return; + } + let targetCli = args[0] === "init" ? { + pkg: "create-storybook", + args: args.slice(1) + } : { + pkg: "@storybook/cli", + args + }; + try { + let { default: targetCliPackageJson } = await import(`${targetCli.pkg}/package.json`, { + with: { type: "json" } + }); + if (targetCliPackageJson.version === versions_default[targetCli.pkg]) { + executeNodeCommand({ + scriptPath: join(resolvePackageDir(targetCli.pkg), "dist/bin/index.js"), + args: targetCli.args, + options: { + stdio: "inherit" + } + }).on("exit", (code) => { + process.exit(code ?? 1); + }); + return; + } + } catch { + } + let packageManager = JsPackageManagerFactory.getPackageManager(); + packageManager.runPackageCommand({ + args: getRemotePackageRunnerArgs( + packageManager.type, + targetCli.pkg, + versions_default[targetCli.pkg], + targetCli.args + ), + useRemotePkg: !0, + stdio: "inherit" + }).on("exit", (code) => { + process.exit(code ?? 1); + }); +} +run(); diff --git a/tools/ui/node_modules/.bin/svelte-check b/tools/ui/node_modules/.bin/svelte-check new file mode 100644 index 0000000000000000000000000000000000000000..2d3922d757e29feb2a6e93b279cd9dc79d973ce3 --- /dev/null +++ b/tools/ui/node_modules/.bin/svelte-check @@ -0,0 +1,2 @@ +#!/usr/bin/env node +require('../dist/src/index.js'); diff --git a/tools/ui/node_modules/.bin/svelte-kit b/tools/ui/node_modules/.bin/svelte-kit new file mode 100644 index 0000000000000000000000000000000000000000..b48389f6962510eccf6058a32bbf131e376d97d8 --- /dev/null +++ b/tools/ui/node_modules/.bin/svelte-kit @@ -0,0 +1,2 @@ +#!/usr/bin/env node +import './src/cli.js'; diff --git a/tools/ui/node_modules/.bin/terser b/tools/ui/node_modules/.bin/terser new file mode 100644 index 0000000000000000000000000000000000000000..b0cdc7c570e3149b05660695f17f7427863dde96 --- /dev/null +++ b/tools/ui/node_modules/.bin/terser @@ -0,0 +1,21 @@ +#!/usr/bin/env node + +"use strict"; + +require("../tools/exit.cjs"); + +try { + require("source-map-support").install(); +} catch (err) {} + +const fs = require("fs"); +const path = require("path"); +const program = require("commander"); + +const packageJson = require("../package.json"); +const { _run_cli: run_cli } = require(".."); + +run_cli({ program, packageJson, fs, path }).catch((error) => { + console.error(error); + process.exitCode = 1; +}); diff --git a/tools/ui/node_modules/.bin/tsc b/tools/ui/node_modules/.bin/tsc new file mode 100644 index 0000000000000000000000000000000000000000..19c62bf7a0004aab7bd188aae51ff2564fdfc18d --- /dev/null +++ b/tools/ui/node_modules/.bin/tsc @@ -0,0 +1,2 @@ +#!/usr/bin/env node +require('../lib/tsc.js') diff --git a/tools/ui/node_modules/.bin/tsserver b/tools/ui/node_modules/.bin/tsserver new file mode 100644 index 0000000000000000000000000000000000000000..7143b6a73ab8a901ccf93752cc36f8e9f8191d93 --- /dev/null +++ b/tools/ui/node_modules/.bin/tsserver @@ -0,0 +1,2 @@ +#!/usr/bin/env node +require('../lib/tsserver.js') diff --git a/tools/ui/node_modules/.bin/tsv2csv b/tools/ui/node_modules/.bin/tsv2csv new file mode 100644 index 0000000000000000000000000000000000000000..0dd38ba121781de10fe8ccfe1ad382b9cc52b34b --- /dev/null +++ b/tools/ui/node_modules/.bin/tsv2csv @@ -0,0 +1,35 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; +const defaultOutDelimiter = progname.slice(-3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-w, --output-delimiter ", "output delimiter character", defaultOutDelimiter) + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); +const outFormat = dsvFormat(options.outputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + rw.dash.writeFile("-", iconv.encode(outFormat.format(inFormat.parse(iconv.decode(text, options.inputEncoding))) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/tsv2json b/tools/ui/node_modules/.bin/tsv2json new file mode 100644 index 0000000000000000000000000000000000000000..c2a447f85f3c9c3835f318569e3bd49937808449 --- /dev/null +++ b/tools/ui/node_modules/.bin/tsv2json @@ -0,0 +1,38 @@ +#!/usr/bin/env node + +import {EOL} from "os"; +import {basename, dirname, resolve} from "path"; +import {readFileSync} from "fs"; +import {fileURLToPath} from "url"; +import rw from "rw"; +import {program} from "commander"; +import iconv from "iconv-lite"; +import {dsvFormat} from "../src/index.js"; + +const progname = basename(process.argv[1]); +const defaultInDelimiter = progname.slice(0, 3) === "tsv" ? "\t" : ","; + +const options = program + .version(JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), "../package.json"))).version) + .usage("[options] [file]") + .option("-o, --out ", "output file name; defaults to “-” for stdout", "-") + .option("-r, --input-delimiter ", "input delimiter character", defaultInDelimiter) + .option("-a, --auto-type", "parse rows with type inference (see d3.autoType)") + .option("-n, --newline-delimited", "output newline-delimited JSON") + .option("--input-encoding ", "input character encoding; defaults to “utf8”", "utf8") + .option("--output-encoding ", "output character encoding; defaults to “utf8”", "utf8") + .parse(process.argv) + .opts(); + +const inFormat = dsvFormat(options.inputDelimiter); + +rw.dash.readFile(program.args[0] || "-", (error, text) => { + if (error) throw error; + const rowConverter = options.autoType ? dsv.autoType : null + const rows = inFormat.parse(iconv.decode(text, options.inputEncoding), rowConverter); + rw.dash.writeFile(options.out, iconv.encode(options.newlineDelimited + ? rows.map((row) => JSON.stringify(row)).join("\n") + "\n" + : JSON.stringify(rows) + EOL, options.outputEncoding), (error) => { + if (error) throw error; + }); +}); diff --git a/tools/ui/node_modules/.bin/update-browserslist-db b/tools/ui/node_modules/.bin/update-browserslist-db new file mode 100644 index 0000000000000000000000000000000000000000..1388e94d08ce1c949cd65ef98172fa64c16c096a --- /dev/null +++ b/tools/ui/node_modules/.bin/update-browserslist-db @@ -0,0 +1,42 @@ +#!/usr/bin/env node + +let { readFileSync } = require('fs') +let { join } = require('path') + +require('./check-npm-version') +let updateDb = require('./') + +const ROOT = __dirname + +function getPackage() { + return JSON.parse(readFileSync(join(ROOT, 'package.json'))) +} + +let args = process.argv.slice(2) + +let USAGE = 'Usage:\n npx update-browserslist-db\n' + +function isArg(arg) { + return args.some(i => i === arg) +} + +function error(msg) { + process.stderr.write('update-browserslist-db: ' + msg + '\n') + process.exit(1) +} + +if (isArg('--help') || isArg('-h')) { + process.stdout.write(getPackage().description + '.\n\n' + USAGE + '\n') +} else if (isArg('--version') || isArg('-v')) { + process.stdout.write('browserslist-lint ' + getPackage().version + '\n') +} else { + try { + updateDb() + } catch (e) { + if (e.name === 'BrowserslistUpdateError') { + error(e.message) + } else { + throw e + } + } +} diff --git a/tools/ui/node_modules/.bin/uuid b/tools/ui/node_modules/.bin/uuid new file mode 100644 index 0000000000000000000000000000000000000000..b4f612d447167233cc1473bf54424766c54bc243 --- /dev/null +++ b/tools/ui/node_modules/.bin/uuid @@ -0,0 +1,2 @@ +#!/usr/bin/env node +import '../uuid-bin.js'; diff --git a/tools/ui/node_modules/.bin/vite b/tools/ui/node_modules/.bin/vite new file mode 100644 index 0000000000000000000000000000000000000000..79c49ab70f624eac6d3b0888864e279998c32662 --- /dev/null +++ b/tools/ui/node_modules/.bin/vite @@ -0,0 +1,79 @@ +#!/usr/bin/env node +import { performance } from 'node:perf_hooks' +import module from 'node:module' + +if (!import.meta.url.includes('node_modules')) { + if (!process.env.DEBUG_DISABLE_SOURCE_MAP) { + // eslint-disable-next-line n/no-unsupported-features/node-builtins -- only used in dev + process.setSourceMapsEnabled(true) + } + + process.on('unhandledRejection', (err) => { + throw new Error('UNHANDLED PROMISE REJECTION', { cause: err }) + }) +} + +global.__vite_start_time = performance.now() + +// check debug mode first before requiring the CLI. +const debugIndex = process.argv.findIndex((arg) => /^(?:-d|--debug)$/.test(arg)) +const filterIndex = process.argv.findIndex((arg) => + /^(?:-f|--filter)$/.test(arg), +) +const profileIndex = process.argv.indexOf('--profile') + +if (debugIndex > 0) { + let value = process.argv[debugIndex + 1] + if (!value || value[0] === '-') { + value = 'vite:*' + } else { + // support debugging multiple flags with comma-separated list + value = value + .split(',') + .map((v) => `vite:${v}`) + .join(',') + } + process.env.DEBUG = `${ + process.env.DEBUG ? process.env.DEBUG + ',' : '' + }${value}` + + if (filterIndex > 0) { + const filter = process.argv[filterIndex + 1] + if (filter && filter[0] !== '-') { + process.env.VITE_DEBUG_FILTER = filter + } + } +} + +function start() { + try { + // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.8.0+ and only called if it exists + module.enableCompileCache?.() + // flush the cache after 10s because the cache is not flushed until process end + // for dev server, the cache is never flushed unless manually flushed because the process.exit is called + // also flushing the cache in SIGINT handler seems to cause the process to hang + setTimeout(() => { + try { + // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.12.0+ and only called if it exists + module.flushCompileCache?.() + } catch {} + }, 10 * 1000).unref() + } catch {} + return import('../dist/node/cli.js') +} + +if (profileIndex > 0) { + process.argv.splice(profileIndex, 1) + const next = process.argv[profileIndex] + if (next && next[0] !== '-') { + process.argv.splice(profileIndex, 1) + } + const inspector = await import('node:inspector').then((r) => r.default) + const session = (global.__vite_profile_session = new inspector.Session()) + session.connect() + session.post('Profiler.enable', () => { + session.post('Profiler.start', start) + }) +} else { + start() +} diff --git a/tools/ui/node_modules/.bin/vitest b/tools/ui/node_modules/.bin/vitest new file mode 100644 index 0000000000000000000000000000000000000000..02dd4714b90340442ab2b2b72a704a99c9b5e4b8 --- /dev/null +++ b/tools/ui/node_modules/.bin/vitest @@ -0,0 +1,2 @@ +#!/usr/bin/env node +import './dist/cli.js' diff --git a/tools/ui/node_modules/.bin/why-is-node-running b/tools/ui/node_modules/.bin/why-is-node-running new file mode 100644 index 0000000000000000000000000000000000000000..15cf2b9147ab2cb4c36afdc1ff50604e32cd593a --- /dev/null +++ b/tools/ui/node_modules/.bin/why-is-node-running @@ -0,0 +1,18 @@ +#!/usr/bin/env node + +var spawn = require('child_process').spawn +var path = require('path') + +var prog = path.resolve(process.argv[2]) +var progArgs = process.argv.slice(3) + +console.log('probing program', prog) + +var nodeArgs = [ + '-r', + path.join(__dirname, 'include.js') +] +var nodeOpts = { stdio: 'inherit' } +var child = spawn('node', nodeArgs.concat(prog).concat(progArgs), nodeOpts) + +console.log('kill -SIGUSR1', child.pid, 'for logging') diff --git a/tools/ui/node_modules/.package-lock.json b/tools/ui/node_modules/.package-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..fab5202f35b020baa6f58bea1cc5cece7766f6f6 --- /dev/null +++ b/tools/ui/node_modules/.package-lock.json @@ -0,0 +1,15324 @@ +{ + "name": "llama-ui", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/@adobe/css-tools": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.5.0.tgz", + "integrity": "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@ampproject/remapping": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz", + "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@antfu/install-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.1.0.tgz", + "integrity": "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "package-manager-detector": "^1.3.0", + "tinyexec": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@apideck/better-ajv-errors": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.7.tgz", + "integrity": "sha512-TajUJwGWbDwkCx/CZi7tRE8PVB7simCvKJfHUsSdvps+aTM/PDPP4gkLmKnc+x3CE//y9i/nj74GqdL/hwk7Iw==", + "dev": true, + "license": "MIT", + "dependencies": { + "jsonpointer": "^5.0.1", + "leven": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "ajv": ">=8" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz", + "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.29.7", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz", + "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz", + "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helpers": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz", + "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-annotate-as-pure": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz", + "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz", + "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-class-features-plugin": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz", + "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-member-expression-to-functions": "^7.29.7", + "@babel/helper-optimise-call-expression": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", + "@babel/traverse": "^7.29.7", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.29.7.tgz", + "integrity": "sha512-907Uymvqgg1dwUA+7IGwFAOSYzQOuzPXKNJ1yxzwPffzkYFg2q2eHi1fIOs6sXkG9NbIUMunnUlkYsfRFNvomg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "regexpu-core": "^6.3.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-define-polyfill-provider": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz", + "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", + "debug": "^4.4.3", + "lodash.debounce": "^4.0.8", + "resolve": "^1.22.11" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz", + "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-member-expression-to-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz", + "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz", + "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz", + "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz", + "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz", + "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.29.7.tgz", + "integrity": "sha512-16AMiW26DbXWBbr3B8wNozKM0ydMLB892vaOaJW/fPJdnT8vJk5sdkQcU/isqUxyCE0cEoa8wZOcbgDuC4b6Og==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-wrap-function": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz", + "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-member-expression-to-functions": "^7.29.7", + "@babel/helper-optimise-call-expression": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz", + "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz", + "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-wrap-function": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.29.7.tgz", + "integrity": "sha512-iES0Skag9ERIF68aXadpO6dbXa03mNWK3sEqJaMnLNs/eC3l0lkImdfoy6Y09/SfkpawdAB4RjQ7PVA7TcVGdw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz", + "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz", + "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.29.7.tgz", + "integrity": "sha512-j8SrR0zLZrRsC09DlszEx8FpMiwukKffYXMK0d5LmOglO7vGG6sz/BR/20yHqWH+Lnn31JTt2PE3hIWNgM2J6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.29.7.tgz", + "integrity": "sha512-r8j8escF+U2FUHo0KOhPUdMzUO+jp9fInva6+ACVAF3Y97Ev+5iNZwiqTghmzNeWwDkOPlYuTcfb1vDaoZKmAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.29.7.tgz", + "integrity": "sha512-GE1TFSiuFeGsCxmYXZl8HwoPrVlwe4rHPFE8weieGKZqnDORK+Ar3vgWMgW+AOxQ6/2TgLSKx9p6W7O4rC6qgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array/-/plugin-bugfix-safari-rest-destructuring-rhs-array-7.29.7.tgz", + "integrity": "sha512-oBNVCvnO5tND+xSopWvV8WNGfpTfgP4Zr/YXXSj8zfmcPktp5Ku/aZlsIowgSD4fjmgHn6sGmB9APVsU5zOdhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.29.7.tgz", + "integrity": "sha512-QQt9qKHZ2sg/kivaLr7lnQr8HVrQDdBNSfCsTjiDxRuX/K5ORyKq+Bu8Xr0cDE3Dfkv0cw28Ve0EKyKMvulkOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7", + "@babel/plugin-transform-optional-chaining": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.13.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.29.7.tgz", + "integrity": "sha512-pn6QacGLgvCcwc+syUhKE/qSjV2D1IHDB84RNxWYSt1mW3K/SCtjinZ2p0cETJxAWBjPy3K/1lHwG5BjjPxNlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.29.7.tgz", + "integrity": "sha512-/An1OCBN93thpBAGyfsK2pcf0jvju1SAtKkL2Ny++B5Sy6sqgzXDQH1cZxWbF96Wuk+bn41MDA9bLd4VVAw6rw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.29.7.tgz", + "integrity": "sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.29.7.tgz", + "integrity": "sha512-N7zArUXWzAMzm+/N0uPBeVB3Fam5lMxtUwMmDK5f/IBBS7a7p1qeUoxd/6CckXoxUdgsntq1Dh8xNW06maZbDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-generator-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.7.tgz", + "integrity": "sha512-d98gXZkgswvkyohMBABkhm3GeXhYj8psWfwQ2C7gtfrKGTykQa/iOIi+JJhwMjPlZ6Vm2XN+DCf3Es1EoG4ZLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-remap-async-to-generator": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.29.7.tgz", + "integrity": "sha512-pcUb2SS+RMo9TWVBwKGI5ShtoG7R+zBsFmCKDa6fe8c+hPr3XJlZgoE5j6i8W7gDjhyvy+85vmYexanvXh3d1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-remap-async-to-generator": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.29.7.tgz", + "integrity": "sha512-cUSmjh72N+rN4PrkFlN1dJwNCwjVp5d38/CQrEsFggkD10UiFlBFgdH3tv5dNsLuHY+3S8db2xCHjhZcv5WgvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.29.7.tgz", + "integrity": "sha512-ONyr4+AZhKh8yKWInVxU9AXA9EbsyeLcL6V0dJy6M2/62vuvpGm29zzuymbTpdc451GEpDIdAyPLP3r+P61yKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.29.7.tgz", + "integrity": "sha512-GtcpjFvanPfzNQi3eTitsCqtRRmmqzpy/A+yhTR1HaZo1Ly3EA8ZXxlPyHdR8/IuRMYc3E4wdGBewB2QKQjAaA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-static-block": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.29.7.tgz", + "integrity": "sha512-kibJgmEdX2iMwsHY2tSZNDgj8PwIlCQz7FK9KuGKO8zsuoUwSEhoNnNVp/emKWrbY4HeO6kkXfdMqRKKKXBm2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, + "node_modules/@babel/plugin-transform-classes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.29.7.tgz", + "integrity": "sha512-qV0OGGBVacduzQHE649JyCneOFI/maT+YKsO+K4Yi3xv2wTPNjM/W2o2gdzMwEAZz7fXNTHAe0NcSg30bIN69g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-globals": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.29.7.tgz", + "integrity": "sha512-RK7/IyU5phpuCdBAuig5VkzG/EnbDaui5SQGdU9BFrHdV+mV4cUjLMQ9lJDjLNtWHsqtiefpGZUXQP2BiTYMsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/template": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.29.7.tgz", + "integrity": "sha512-iPX8aD6H9zV5s7ZsqTdNocPN/MGQ5sSMnElKrktxjJRMnB2jN/1p2+R7GkfD6CAYoVFqy5A4XnSIUeGgJzIWpg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.29.7.tgz", + "integrity": "sha512-3qc18hsD2RdZiyJNDNc7HQpv6xbncwh8FYtxNFFzclSyh/trPD9KkVR9BDECUjDLvb7yJVF15GfYUuC+LMkkiQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.29.7.tgz", + "integrity": "sha512-6IvRRriEMqnBwD6chtxdLpMYCHWEzN+oL5cyQtjykya19UgzbmKhxmhZgKC/LHxS2nYr9Q/qYPZ5Lr6jOL9+yQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.7.tgz", + "integrity": "sha512-2wiIyo2BjtgU7HufSeDnL9L2O7zr8jmhFKuSr65VpRkUiRKRNpb0mdlk56+XPPKoIrfHqzbMuglDvZun0RISsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.29.7.tgz", + "integrity": "sha512-giOlEm/EFjfjr+te9NsdjkUo2v4f8rS/SXPumRVHAtbNcyNlvtREkU1dZzaIDclNpnaVhlCqRdFKhJBjBikzLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-explicit-resource-management": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.29.7.tgz", + "integrity": "sha512-Rstj7coNz8sE+7Ju7ihpHLI564lsK5pUpNNlvptCIC/16E/S5hbl6n3kESPKdNRmqEWlpn5xpS5Q2dvXBsySLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.29.7.tgz", + "integrity": "sha512-zFpMOTLZBdW5LfObqcSbL6kefg4R4eLdmvS0wbN9M6D5Mym/sKm9toOoWyVOa+xDjvCnuWcHls2YonXwHvH3CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.29.7.tgz", + "integrity": "sha512-24B2nOy2TeJSMheqwPD4DDQOV/elLSIlKxjZt4i05H5AgdPdWR3n18HnNrcJ+j76WJd9gbwb9jPjNYUy6RautA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.29.7.tgz", + "integrity": "sha512-zeSIHh0+E1Um1WJRXCFlHQYu2ieJNdivLLjlBEp+dIBu3S51n+SZZmIXjxnItw6pz56Cn+KvK68BIBVsxq2JiQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.29.7.tgz", + "integrity": "sha512-otRWaHXE6fbAGkePvaj/kvs3HsqXfPhlnzwSOlnFgbqCPMd975dW+4wZ00WFBt+/YlBGcJwNrARQTOJOb4ZrIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.29.7.tgz", + "integrity": "sha512-RRnE2+eon1rJAq8MnoF1b5kTpY1vU88twHcvcKMrsqP/jxIRqDVs9iJB5fqPuqyeFAW0wJo4MlUIPpQCq/aRsg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.29.7.tgz", + "integrity": "sha512-DZ/oLP21ZuWx1vKqnoNv6/tvEK48AQOBRai40CX9dTjGluvT/YZCyY3rryDtyUqCEoyNroy5KKPwX2iQCiRvyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.29.7.tgz", + "integrity": "sha512-A0H91hh6W8MFRkp5TqJmMr39jzGD1A1E1Ysiv2O06Sfbhkapm+XyIzxWCEh5kqwOZ1/8QZ0dY3SeQ7XBqfJd5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.29.7.tgz", + "integrity": "sha512-hl1kwFZCCiDyfH25Xmco9jTrkPgnS9pmOzSG7W5I4SaGbLeqKv417hcU2RKmaxoPEgsoJh7ZPOrnPGq99bHoUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.29.7.tgz", + "integrity": "sha512-fxtQoH3m5ywUSIfaH0FGCzWu4McsYon5bD3K4XnskC7f+OyQMj7rsOMi4NvvmJ83WwBAg4UCe+ov4VZlqEvyew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz", + "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.7.tgz", + "integrity": "sha512-TM2ZcQLoG2/y4HODiStCo10DibYhWhGWAwVv+EQKmG/7GFl0N+AAmUiXOMKM+aiJ9XBJ9AHVZBvTzMnJ2sM3cQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.29.7.tgz", + "integrity": "sha512-B4UkaTK3QpgCwJnrxKfMPKdo92CN7OKXAlpAAnM3UPu0Q0lCCk57ylA9AJbRy2v8dDKOPAAWcoR6CMyeoHwRCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.7.tgz", + "integrity": "sha512-vuFoLwr4qnv2xbZ16SQd6uPcH5FNrLHhk/Jzo++0XJFcaDsr4gjJVg6j398oMHiC+83k/GiBzviwF5KBJkPUtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.29.7.tgz", + "integrity": "sha512-fEo41GmsOUhOBlw8ioo6zvjX5Xc2Lqkzlyfqbpsk3eB6TReV18uhxZ0esfEokVbY2+PVJAQHNKxER6lGrzNd3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.29.7.tgz", + "integrity": "sha512-idmp1dFaekP9GbcMvG24Kvw2BfhFZjHnNJCkV4WuIY4PskJzwI3f1N5OdgYke38T7rftO6ERulFRn2cFeZwRkg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.29.7.tgz", + "integrity": "sha512-zR7fv/z14OjgHl4AgRtkDBvBMhIzCxqV/qN/2BCRC7LjFwvuzjYe7gDWxC4Wl/SNsLM6SE1IWvRPYMgSJaUvNw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.29.7.tgz", + "integrity": "sha512-Ld98jn4c0smUywL57m7SgsHq3OpThOa6LqZJif3G6jYOovPleoFhVrBJ1WegRApSFB2wu4+RelAj9AC9G08Z4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7", + "@babel/plugin-transform-parameters": "^7.29.7", + "@babel/traverse": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.29.7.tgz", + "integrity": "sha512-Ea/diGcw0twB5IlZPO5sgET6fJsLJqPABqTuFWIR+iMPGPZJkATEIWx0wa+aEQ5UY1CBQyP/gkAiLEqn1vBiQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-replace-supers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.29.7.tgz", + "integrity": "sha512-sLsyndxK2VwX6yNUOakMb7Sh553ZTe/vVM1XJ+9Z5aW1ytsc8xOIwmyk05NNjN60vkc5/KqoTH6hB4V41LJhng==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.29.7.tgz", + "integrity": "sha512-6GM1dhvK3gNODkXcEcMCOLEDCLSoZ/sBbro2Ax8HURyasQ4NshagQixkRFdh5niI6E4gmA/jYI/4aT7rRos3ZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.29.7.tgz", + "integrity": "sha512-ZDOBqV/qLYJI0YElr8DcENEyARsFQeESqWXH6gZlghYXuPPjvweuDhP4VyEi4BlUBlLRFZVjxoZDMjxhLW766g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.29.7.tgz", + "integrity": "sha512-/6Rz4DK1ETDEM/bWHsPHcaEe7ZaT1EqSXjtSP/L0DijOYuaUhiRiOKcwpZ8P7zR4xXEHc2ITdiCgBm9Tpyv9ug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.29.7.tgz", + "integrity": "sha512-+BNo06dnrzdNNqCm1X6YUaVv0DKk8Q+JYcoZfOkLhYWNCXzlwTSRq8zGWayT1csjcpNXV9CQTBRRbmTLZac5cA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.29.7", + "@babel/helper-create-class-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.29.7.tgz", + "integrity": "sha512-bOMRLQuI0A5ZqHq3OWJ89/rXpJ/NJrbVhXiP4zwPGMs6kpcVsuTUNjwoE30K0Qm3mf48a/TnRYYD6vPNqcg6jA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.7.tgz", + "integrity": "sha512-rNNFV0DBAJp988xW2DOntfDoYn1eR8GGF5AT5vYc+rjyfaQkM242c9tZUHHPe7KYaiJizXPWhQTzzdbXySyhBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regexp-modifiers": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.29.7.tgz", + "integrity": "sha512-mB5Fs0VWrJ42ZCmc8114v60qetdaUVNkj9PmSZRmanCZM3S9hm0CFRLjRmYIsuXav14l2jvZ+4T8iiCGnhj3nQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.29.7.tgz", + "integrity": "sha512-5+YhdpVgmfSmwZyLMftfaiffLRMHjzIRHFHHLdibcSyJm2pasMrKHrO3Ptrt2DRshjvpgjEJJ1zVW14WPq/6QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.29.7.tgz", + "integrity": "sha512-I+WYbGBAiCn7nA6xBrlgPH+MB7HWb4u8pv5S0Pv7OtwNvIFvCCb24YlttKEeUFVurfBCEaOTnuhlqsb7f0Z5Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.29.7.tgz", + "integrity": "sha512-/u5K1QWada7tbYNqTjMh96718g9NTwh9tfPJMsSmVsQwGT447FskV+KcfeXkXq2GWki4EM/MuTdmBec+hOuVTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.29.7.tgz", + "integrity": "sha512-BCHzNYJGe9l7EpwwDBN/ztlL2NYFFq8hp9ddjtUEM9f2O7S7kKV/lL6Fwo7IF7NSkYhPK2vO+86nIGltA90MsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.29.7.tgz", + "integrity": "sha512-NCSEJ4sLFU2gqAub45HYh4fus2yQ36rr6ei6vpU7NdoJqCpxvEG8E6eJpscGyXP3VHD2Ny+fSXr04k1hoUrFqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.29.7.tgz", + "integrity": "sha512-223mNGoTkBiTEWFoK+Q6Go3tueMRclO8vxxxxquNCYuNI4jWOofFKJRRDu6SDrB8Sgo1UEGW9T4GAQ8ZyRso1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.29.7.tgz", + "integrity": "sha512-jCfXxSjf94lf4E0hKE0AByxF6F3/pVFqRdUUNkDJhsY0m1ZKjnN6ZYyMeHNpzflxb/0q5b7t3p+BE+SLF1WOtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.29.7.tgz", + "integrity": "sha512-OgZ+zoAJgZLUCunsTRQ5LAjOywDv5zzZ2/hQ5aMw1pGXyY2rtE8/chXYUmu3AlVHKpm10KEdG9aMwbI/K76ZGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.29.7.tgz", + "integrity": "sha512-7D/x/23/d/3VqZ0QA+LGbZMlGwZjztBygSWWWsfTPoQ1oQ6Q1P6Mr3d0kk42XabyUVw+fha3LqdRsFqeKqvCyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.29.7.tgz", + "integrity": "sha512-BLOhLht9DOJwIxlmp91wHvkXv1lguuHS3/FwUO8HL1H0u8s4hR1gASVFyilu9iGtcTRYqjTZmlsFFeQletntEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/preset-env": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.7.tgz", + "integrity": "sha512-GYzX36n1nsciIb0uyH0GHwxwtNwPQIcpxSeiVLDtG/B7jB5xXgchnmL1f/jCX5o+pwnaDBtO60ONSJhEBJfxYA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.29.7", + "@babel/helper-compilation-targets": "^7.29.7", + "@babel/helper-plugin-utils": "^7.29.7", + "@babel/helper-validator-option": "^7.29.7", + "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.29.7", + "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.29.7", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.29.7", + "@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": "^7.29.7", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.29.7", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.29.7", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", + "@babel/plugin-syntax-import-assertions": "^7.29.7", + "@babel/plugin-syntax-import-attributes": "^7.29.7", + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.29.7", + "@babel/plugin-transform-async-generator-functions": "^7.29.7", + "@babel/plugin-transform-async-to-generator": "^7.29.7", + "@babel/plugin-transform-block-scoped-functions": "^7.29.7", + "@babel/plugin-transform-block-scoping": "^7.29.7", + "@babel/plugin-transform-class-properties": "^7.29.7", + "@babel/plugin-transform-class-static-block": "^7.29.7", + "@babel/plugin-transform-classes": "^7.29.7", + "@babel/plugin-transform-computed-properties": "^7.29.7", + "@babel/plugin-transform-destructuring": "^7.29.7", + "@babel/plugin-transform-dotall-regex": "^7.29.7", + "@babel/plugin-transform-duplicate-keys": "^7.29.7", + "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.7", + "@babel/plugin-transform-dynamic-import": "^7.29.7", + "@babel/plugin-transform-explicit-resource-management": "^7.29.7", + "@babel/plugin-transform-exponentiation-operator": "^7.29.7", + "@babel/plugin-transform-export-namespace-from": "^7.29.7", + "@babel/plugin-transform-for-of": "^7.29.7", + "@babel/plugin-transform-function-name": "^7.29.7", + "@babel/plugin-transform-json-strings": "^7.29.7", + "@babel/plugin-transform-literals": "^7.29.7", + "@babel/plugin-transform-logical-assignment-operators": "^7.29.7", + "@babel/plugin-transform-member-expression-literals": "^7.29.7", + "@babel/plugin-transform-modules-amd": "^7.29.7", + "@babel/plugin-transform-modules-commonjs": "^7.29.7", + "@babel/plugin-transform-modules-systemjs": "^7.29.7", + "@babel/plugin-transform-modules-umd": "^7.29.7", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.7", + "@babel/plugin-transform-new-target": "^7.29.7", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.29.7", + "@babel/plugin-transform-numeric-separator": "^7.29.7", + "@babel/plugin-transform-object-rest-spread": "^7.29.7", + "@babel/plugin-transform-object-super": "^7.29.7", + "@babel/plugin-transform-optional-catch-binding": "^7.29.7", + "@babel/plugin-transform-optional-chaining": "^7.29.7", + "@babel/plugin-transform-parameters": "^7.29.7", + "@babel/plugin-transform-private-methods": "^7.29.7", + "@babel/plugin-transform-private-property-in-object": "^7.29.7", + "@babel/plugin-transform-property-literals": "^7.29.7", + "@babel/plugin-transform-regenerator": "^7.29.7", + "@babel/plugin-transform-regexp-modifiers": "^7.29.7", + "@babel/plugin-transform-reserved-words": "^7.29.7", + "@babel/plugin-transform-shorthand-properties": "^7.29.7", + "@babel/plugin-transform-spread": "^7.29.7", + "@babel/plugin-transform-sticky-regex": "^7.29.7", + "@babel/plugin-transform-template-literals": "^7.29.7", + "@babel/plugin-transform-typeof-symbol": "^7.29.7", + "@babel/plugin-transform-unicode-escapes": "^7.29.7", + "@babel/plugin-transform-unicode-property-regex": "^7.29.7", + "@babel/plugin-transform-unicode-regex": "^7.29.7", + "@babel/plugin-transform-unicode-sets-regex": "^7.29.7", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.15", + "babel-plugin-polyfill-corejs3": "^0.14.0", + "babel-plugin-polyfill-regenerator": "^0.6.6", + "core-js-compat": "^3.48.0", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/preset-modules": { + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz", + "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz", + "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz", + "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.7", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.7", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz", + "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", + "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@blazediff/core": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/@blazediff/core/-/core-1.9.1.tgz", + "integrity": "sha512-ehg3jIkYKulZh+8om/O25vkvSsXXwC+skXmyA87FFx6A/45eqOkZsBltMw/TVteb0mloiGT8oGRTcjRAz66zaA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@braintree/sanitize-url": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.2.tgz", + "integrity": "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@canvas/image-data": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@canvas/image-data/-/image-data-1.1.0.tgz", + "integrity": "sha512-QdObRRjRbcXGmM1tmJ+MrHcaz1MftF2+W7YI+MsphnsCrmtyfS0d5qJbk0MeSbUeyM/jCb0hmnkXPsy026L7dA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@chevrotain/types": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.1.2.tgz", + "integrity": "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/@chromatic-com/storybook": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/@chromatic-com/storybook/-/storybook-5.2.1.tgz", + "integrity": "sha512-z6I7NJk/0VngA64y5TNYaB4Hc2X8+90n4op6lBt9PvWk5TmIlFLDqdX33rlrwbNRkkYijVgA/wO04rVYXi5Mlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@neoconfetti/react": "^1.0.0", + "chromatic": "16.10.0", + "jsonfile": "^6.1.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=20.0.0", + "yarn": ">=1.22.18" + }, + "peerDependencies": { + "storybook": "^0.0.0-0 || ^10.1.0 || ^10.1.0-0 || ^10.2.0-0 || ^10.3.0-0 || ^10.4.0-0 || ^10.5.0-0 || ^10.6.0-0" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz", + "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/compat": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/@eslint/compat/-/compat-1.4.1.tgz", + "integrity": "sha512-cfO82V9zxxGBxcQDr1lfaYB7wykTa0b00mGa36FrJl7iTFd0Z2cHfEYuxcBRP/iNijCsWsEkA+jzT8hGYmv33w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "peerDependencies": { + "eslint": "^8.40 || 9" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + } + }, + "node_modules/@eslint/config-array": { + "version": "0.21.2", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz", + "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.5" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz", + "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.14.0", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.1", + "minimatch": "^3.1.5", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/ajv": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", + "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==", + "dev": true, + "license": "MIT", + "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/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/eslintrc/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==", + "dev": true, + "license": "MIT" + }, + "node_modules/@eslint/js": { + "version": "9.39.2", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz", + "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@floating-ui/core": { + "version": "1.7.5", + "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz", + "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/dom": { + "version": "1.7.6", + "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz", + "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@floating-ui/core": "^1.7.5", + "@floating-ui/utils": "^0.2.11" + } + }, + "node_modules/@floating-ui/utils": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz", + "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@hono/node-server": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-2.1.0.tgz", + "integrity": "sha512-XovyyCCnBzW+zKu+z/zq8hwNs4KOR5rEMAOxo2f40Q5xoOI37IMm6MIg2COOUtUApo0i6850MTBKH2u4QLGIqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "peerDependencies": { + "hono": "^4" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz", + "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/types": "^0.15.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz", + "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.2", + "@humanfs/types": "^0.15.0", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/types": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz", + "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.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==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@iconify/types": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz", + "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@iconify/utils": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.1.3.tgz", + "integrity": "sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@antfu/install-pkg": "^1.1.0", + "@iconify/types": "^2.0.0", + "import-meta-resolve": "^4.2.0" + } + }, + "node_modules/@img/colour": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz", + "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@img/sharp-libvips-linux-x64": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.2.tgz", + "integrity": "sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-libvips-linuxmusl-x64": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.2.tgz", + "integrity": "sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "LGPL-3.0-or-later", + "optional": true, + "os": [ + "linux" + ], + "funding": { + "url": "https://opencollective.com/libvips" + } + }, + "node_modules/@img/sharp-linux-x64": { + "version": "0.35.3", + "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.3.tgz", + "integrity": "sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linux-x64": "1.3.2" + } + }, + "node_modules/@img/sharp-linuxmusl-x64": { + "version": "0.35.3", + "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.3.tgz", + "integrity": "sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-libvips-linuxmusl-x64": "1.3.2" + } + }, + "node_modules/@internationalized/date": { + "version": "3.12.2", + "resolved": "https://registry.npmjs.org/@internationalized/date/-/date-3.12.2.tgz", + "integrity": "sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@swc/helpers": "^0.5.0" + } + }, + "node_modules/@isaacs/fs-minipass": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz", + "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "minipass": "^7.0.4" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.11", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz", + "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@lucide/svelte": { + "version": "1.25.0", + "resolved": "https://registry.npmjs.org/@lucide/svelte/-/svelte-1.25.0.tgz", + "integrity": "sha512-v9m+dD68jxVnqkU3K59mG/RSRFlPGzmKCGSyMfnXcaGv9jODDQMyQkcp1CGvk3Y/cUj9v7f8rw1n//K0B53xGQ==", + "dev": true, + "license": "ISC", + "peerDependencies": { + "svelte": "^5" + } + }, + "node_modules/@mdx-js/react": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz", + "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdx": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "peerDependencies": { + "@types/react": ">=16", + "react": ">=16" + } + }, + "node_modules/@mermaid-js/parser": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-1.1.1.tgz", + "integrity": "sha512-VuHdsYMK1bT6X2JbcAaWAhugTRvRBRyuZgd+c22swUeI9g/ntaxF7CY7dYarhZovofCbUNO0G7JesfmNtjYOCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@chevrotain/types": "~11.1.1" + } + }, + "node_modules/@modelcontextprotocol/sdk": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.0.tgz", + "integrity": "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@hono/node-server": "^1.19.9 || ^2.0.5", + "ajv": "^8.17.1", + "ajv-formats": "^3.0.1", + "content-type": "^1.0.5", + "cors": "^2.8.5", + "cross-spawn": "^7.0.5", + "eventsource": "^3.0.2", + "eventsource-parser": "^3.0.0", + "express": "^5.2.1", + "express-rate-limit": "^8.2.1", + "hono": "^4.11.4", + "jose": "^6.1.3", + "json-schema-typed": "^8.0.2", + "pkce-challenge": "^5.0.0", + "raw-body": "^3.0.0", + "zod": "^3.25 || ^4.0", + "zod-to-json-schema": "^3.25.1" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@cfworker/json-schema": "^4.1.1", + "zod": "^3.25 || ^4.0" + }, + "peerDependenciesMeta": { + "@cfworker/json-schema": { + "optional": true + }, + "zod": { + "optional": false + } + } + }, + "node_modules/@napi-rs/canvas": { + "version": "0.1.100", + "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-0.1.100.tgz", + "integrity": "sha512-xglYA6q3XO5P3BNJYxVZ1IV7DLVjp1Py6nwag88YntrS+3vKHyYcMqXVS4ZztJmwz2uGvz1FWhI/4LgbR5uQDA==", + "dev": true, + "license": "MIT", + "optional": true, + "workspaces": [ + "e2e/*" + ], + "engines": { + "node": ">= 10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/Brooooooklyn" + }, + "optionalDependencies": { + "@napi-rs/canvas-android-arm64": "0.1.100", + "@napi-rs/canvas-darwin-arm64": "0.1.100", + "@napi-rs/canvas-darwin-x64": "0.1.100", + "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.100", + "@napi-rs/canvas-linux-arm64-gnu": "0.1.100", + "@napi-rs/canvas-linux-arm64-musl": "0.1.100", + "@napi-rs/canvas-linux-riscv64-gnu": "0.1.100", + "@napi-rs/canvas-linux-x64-gnu": "0.1.100", + "@napi-rs/canvas-linux-x64-musl": "0.1.100", + "@napi-rs/canvas-win32-arm64-msvc": "0.1.100", + "@napi-rs/canvas-win32-x64-msvc": "0.1.100" + } + }, + "node_modules/@napi-rs/canvas-linux-x64-gnu": { + "version": "0.1.100", + "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-0.1.100.tgz", + "integrity": "sha512-1eCvkDCazm7FFhsT7DfGOdSaHgZVK3bt/dSBl5EWHOWmnz+I7j8tPseJqqD81NF+MH21jKUK4wQSDjN0mdhnTg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/Brooooooklyn" + } + }, + "node_modules/@napi-rs/canvas-linux-x64-musl": { + "version": "0.1.100", + "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-0.1.100.tgz", + "integrity": "sha512-20arT6lnI19S68qNlii73TSEDbECNgzMz2EpldC1V3mZFuRkeujXkcebRk0LRJe9SEUAooYiLokfMViY8IX7yA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/Brooooooklyn" + } + }, + "node_modules/@neoconfetti/react": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@neoconfetti/react/-/react-1.0.0.tgz", + "integrity": "sha512-klcSooChXXOzIm+SE5IISIAn3bYzYfPjbX7D7HoqZL84oAfgREeSg5vSIaSFH+DaGzzvImTyWe1OyrJ67vik4A==", + "dev": true, + "license": "MIT" + }, + "node_modules/@oxc-parser/binding-linux-x64-gnu": { + "version": "0.127.0", + "resolved": "https://registry.npmjs.org/@oxc-parser/binding-linux-x64-gnu/-/binding-linux-x64-gnu-0.127.0.tgz", + "integrity": "sha512-MYCguB9RvBvlSd6gbuNI7QwiLoCCAlGnlRJFPrzLI6U1/9wkC/WK6LtBAUln55H1Ctqw45PWmqrobKoMhsYQzQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@oxc-parser/binding-linux-x64-musl": { + "version": "0.127.0", + "resolved": "https://registry.npmjs.org/@oxc-parser/binding-linux-x64-musl/-/binding-linux-x64-musl-0.127.0.tgz", + "integrity": "sha512-5eY0B/bxf1xIUxb4NOTvOI3KWtBQfPWYyKAzgcrCt0mDibSZygVpO1Pz8bkeiSZ5Jj9+M09dkggG3H8I5d0Uyg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@oxc-project/types": { + "version": "0.127.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.127.0.tgz", + "integrity": "sha512-aIYXQBo4lCbO4z0R3FHeucQHpF46l2LbMdxRvqvuRuW2OxdnSkcng5B8+K12spgLDj93rtN3+J2Vac/TIO+ciQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@oxc-resolver/binding-linux-x64-gnu": { + "version": "11.20.0", + "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-gnu/-/binding-linux-x64-gnu-11.20.0.tgz", + "integrity": "sha512-x2YeSimvhJjKLVD8KSu8f/rqU1potcdEMkApIPJqjZWN7c2Fpt4g2X32WDg1p+XDAmyT7nuQGe0vnhvXeLbH+g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oxc-resolver/binding-linux-x64-musl": { + "version": "11.20.0", + "resolved": "https://registry.npmjs.org/@oxc-resolver/binding-linux-x64-musl/-/binding-linux-x64-musl-11.20.0.tgz", + "integrity": "sha512-kcRLEIxpZefeYfLChjpgFf3ilBzRDZ+yobMrpRsQlSrxuFGtm3U6PMU7AaEpMqo3NfDGVyJJseAjnRLzMFHjwQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@parcel/watcher": { + "version": "2.5.6", + "resolved": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.6.tgz", + "integrity": "sha512-tmmZ3lQxAe/k/+rNnXQRawJ4NjxO2hqiOLTHvWchtGZULp4RyFeh6aU4XdOYBFe2KE1oShQTv4AblOs2iOrNnQ==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "dependencies": { + "detect-libc": "^2.0.3", + "is-glob": "^4.0.3", + "node-addon-api": "^7.0.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "@parcel/watcher-android-arm64": "2.5.6", + "@parcel/watcher-darwin-arm64": "2.5.6", + "@parcel/watcher-darwin-x64": "2.5.6", + "@parcel/watcher-freebsd-x64": "2.5.6", + "@parcel/watcher-linux-arm-glibc": "2.5.6", + "@parcel/watcher-linux-arm-musl": "2.5.6", + "@parcel/watcher-linux-arm64-glibc": "2.5.6", + "@parcel/watcher-linux-arm64-musl": "2.5.6", + "@parcel/watcher-linux-x64-glibc": "2.5.6", + "@parcel/watcher-linux-x64-musl": "2.5.6", + "@parcel/watcher-win32-arm64": "2.5.6", + "@parcel/watcher-win32-ia32": "2.5.6", + "@parcel/watcher-win32-x64": "2.5.6" + } + }, + "node_modules/@parcel/watcher-linux-x64-glibc": { + "version": "2.5.6", + "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-glibc/-/watcher-linux-x64-glibc-2.5.6.tgz", + "integrity": "sha512-kbT5wvNQlx7NaGjzPFu8nVIW1rWqV780O7ZtkjuWaPUgpv2NMFpjYERVi0UYj1msZNyCzGlaCWEtzc+exjMGbQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@parcel/watcher-linux-x64-musl": { + "version": "2.5.6", + "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-musl/-/watcher-linux-x64-musl-2.5.6.tgz", + "integrity": "sha512-1JRFeC+h7RdXwldHzTsmdtYR/Ku8SylLgTU/reMuqdVD7CtLwf0VR1FqeprZ0eHQkO0vqsbvFLXUmYm/uNKJBg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/@playwright/test": { + "version": "1.56.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.56.1.tgz", + "integrity": "sha512-vSMYtL/zOcFpvJCW71Q/OEGQb7KYBPAdKh35WNSkaZA75JlAO8ED8UN6GUNTm3drWomcbcqRPFqQbLae8yBTdg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright": "1.56.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@polka/url": { + "version": "1.0.0-next.29", + "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.29.tgz", + "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==", + "dev": true, + "license": "MIT" + }, + "node_modules/@quansync/fs": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@quansync/fs/-/fs-1.0.0.tgz", + "integrity": "sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "quansync": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + } + }, + "node_modules/@rollup/plugin-babel": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.1.0.tgz", + "integrity": "sha512-dFZNuFD2YRcoomP4oYf+DvQNSUA9ih+A3vUqopQx5EdtPGo3WBnQcI/S8pwpz91UsGfL0HsMSOlaMld8HrbubA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.18.6", + "@rollup/pluginutils": "^5.0.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + }, + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "16.0.3", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-16.0.3.tgz", + "integrity": "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-replace": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-6.0.3.tgz", + "integrity": "sha512-J4RZarRvQAm5IF0/LwUUg+obsm+xZhYnbMXmXROyoSE1ATJe3oXSb9L5MMppdxP2ylNSjv6zFBwKYjcKMucVfA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "magic-string": "^0.30.3" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-terser": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-1.0.0.tgz", + "integrity": "sha512-FnCxhTBx6bMOYQrar6C8h3scPt8/JwIzw3+AJ2K++6guogH5fYaIFia+zZuhqv0eo1RN7W1Pz630SyvLbDjhtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "serialize-javascript": "^7.0.3", + "smob": "^1.0.0", + "terser": "^5.17.4" + }, + "engines": { + "node": ">=20.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz", + "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/pluginutils/node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.61.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.61.1.tgz", + "integrity": "sha512-bVWIOIk6pV01p4CdUbPP7CJ/434z+OooYjDuFcR+44N35YvKUC66G8MGnvcWx5mWKW3g61J+t74l3Kj15Kwn2Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.61.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.61.1.tgz", + "integrity": "sha512-qy5pBvZbqNFheBz61R1rzsezjm0J7O2oNGoWtGoY89SZYLUfxAJTBAqDChqAIdB4rCiIbi9nF7yZ83GnNiLwSw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@storybook/addon-a11y": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/addon-a11y/-/addon-a11y-10.5.6.tgz", + "integrity": "sha512-pMqbmtvkIgb7/kVE2BTNovGhSerRXWsVag62zpwQe0SwYYkgN+1Q9h4TYuIe2+npGkxgwALCjwtqkcnpOoND+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "axe-core": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.5.6" + } + }, + "node_modules/@storybook/addon-docs": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.5.6.tgz", + "integrity": "sha512-zyUJBrrpC9NTrmsREaVFNr+9WW6pikJtmRvo7GgZGqthEyhjQKSarHrW0aNWkwae2ep3jp1CZi8vIUVG1Dnp0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.5.6", + "@storybook/icons": "^2.0.2", + "@storybook/react-dom-shim": "10.5.6", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.5.6" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@storybook/addon-mcp": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@storybook/addon-mcp/-/addon-mcp-0.7.0.tgz", + "integrity": "sha512-f/IWGRMzWynBg5kDJ3DYvvnafuSX88kykGNFzzLOlkLVpfxEZoAmQF6AS47tw25GuH6EFIqSo6ZDBLHLVyZ/IQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/mcp": "0.8.0", + "@tmcp/adapter-valibot": "^0.1.5", + "@tmcp/transport-http": "^0.8.5", + "picoquery": "^2.5.0", + "tmcp": "^1.19.4", + "valibot": "1.2.0" + }, + "peerDependencies": { + "@storybook/addon-vitest": "^0.0.0-0 || ^9.1.16 || ^10.0.0 || ^10.1.0-0 || ^10.2.0-0 || ^10.3.0-0 || ^10.4.0-0 || ^10.5.0-0", + "storybook": "^0.0.0-0 || ^9.1.16 || ^10.0.0 || ^10.1.0-0 || ^10.2.0-0 || ^10.3.0-0 || ^10.4.0-0 || ^10.5.0-0" + }, + "peerDependenciesMeta": { + "@storybook/addon-vitest": { + "optional": true + } + } + }, + "node_modules/@storybook/addon-svelte-csf": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@storybook/addon-svelte-csf/-/addon-svelte-csf-5.1.2.tgz", + "integrity": "sha512-NpImknEb48J7yr/ArTYpvhDSvGUrgm5Nuybu9PCicjSKTACsXX7cln2R19572ORtns399RTE+t20BBOKxSPm2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf": "^0.1.13", + "dedent": "^1.5.3", + "es-toolkit": "^1.26.1", + "esrap": "^1.2.2", + "magic-string": "^0.30.12", + "svelte-ast-print": "^0.4.0", + "zimmerframe": "^1.1.2" + }, + "peerDependencies": { + "@storybook/svelte": "^0.0.0-0 || ^8.2.0 || ^9.0.0 || ^9.1.0-0 || ^10.0.0-0 || ^10.1.0-0 || ^10.2.0-0 || ^10.3.0-0 || ^10.4.0-0", + "@sveltejs/vite-plugin-svelte": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0", + "storybook": "^0.0.0-0 || ^8.2.0 || ^9.0.0 || ^9.1.0-0 || ^10.0.0-0 || ^10.1.0-0 || ^10.2.0-0 || ^10.3.0-0 || ^10.4.0-0", + "svelte": "^5.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@storybook/addon-vitest": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/addon-vitest/-/addon-vitest-10.5.6.tgz", + "integrity": "sha512-oxq7Qi4Vujc8Etoi1TZBurMs4RiKoGnvAOCXePOLglXSJMpy95gEb7iu/hvj8E21lV+vVtQYmFvj9Z7gJeMtdg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.2" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "@vitest/browser": "^3.0.0 || ^4.0.0", + "@vitest/browser-playwright": "^4.0.0", + "@vitest/runner": "^3.0.0 || ^4.0.0", + "storybook": "^10.5.6", + "vitest": "^3.0.0 || ^4.0.0" + }, + "peerDependenciesMeta": { + "@vitest/browser": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/runner": { + "optional": true + }, + "vitest": { + "optional": true + } + } + }, + "node_modules/@storybook/builder-vite": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.5.6.tgz", + "integrity": "sha512-Ts8EohKPj8okDPCkueeKVN+IRGNpI3LuddsFGupqraRvK6aRWawDKA28uc0PlsLCLWbMkMsGVw+IpFXfmoLJgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.5.6", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.5.6", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@storybook/csf": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/@storybook/csf/-/csf-0.1.13.tgz", + "integrity": "sha512-7xOOwCLGB3ebM87eemep89MYRFTko+D8qE7EdAAq74lgdqRR5cOUtYWJLjO2dLtP94nqoOdHJo6MdLLKzg412Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^2.19.0" + } + }, + "node_modules/@storybook/csf-plugin": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.5.6.tgz", + "integrity": "sha512-PJLyOmcKe1OZDBw7RaGX/gjuiJuVfS5pVgc4W2RnHYOFpU6F5Bv9+9MqQwp0i7tWZBWc4fsCJudgVqwgjuTROA==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.5.6", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "node_modules/@storybook/global": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@storybook/global/-/global-5.0.0.tgz", + "integrity": "sha512-FcOqPAXACP0I3oJ/ws6/rrPT9WGhu915Cg8D02a9YxLo0DE9zI+a9A5gRGvmQ09fiWPukqI8ZAEoQEdWUKMQdQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@storybook/icons": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@storybook/icons/-/icons-2.0.2.tgz", + "integrity": "sha512-KZBCpXsshAIjczYNXR/rlxEtCUX/eAbpFNwKi8bcOomrLA4t/SyPz5RF+lVPO2oZBUE4sAkt43mfJUevQDSEEw==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/@storybook/mcp": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/@storybook/mcp/-/mcp-0.8.0.tgz", + "integrity": "sha512-G+XDgoWGrE98moXqKSee8fQyMQxoIWxRAbPG8r/HQ95pKodratevDqNyOgW+t6ZigM6AAVN1WHiFc5MI+hc8sg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@tmcp/adapter-valibot": "^0.1.5", + "@tmcp/transport-http": "^0.8.5", + "tmcp": "^1.19.4", + "valibot": "1.2.0" + } + }, + "node_modules/@storybook/react-dom-shim": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.5.6.tgz", + "integrity": "sha512-dV3oOHc5ImggxEqeIiUj4vvnQO5SKScFtqAkxgIWLju1wiSZSIqQ5Q4Mp12Rhs9hQrjF039DueH7f2xJJZfvSw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "@types/react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.5.6" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "@types/react-dom": { + "optional": true + } + } + }, + "node_modules/@storybook/svelte": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/svelte/-/svelte-10.5.6.tgz", + "integrity": "sha512-dx95/i86Lvif3wJZvMIWa/FnnyRljdIbDYicdBitbqS3SBldX6EE9DhYEY/e3ELEbRHMhsIANKoP2rzxs5xjVw==", + "dev": true, + "license": "MIT", + "dependencies": { + "ts-dedent": "^2.0.0", + "type-fest": "^5.6.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.5.6", + "svelte": "^5.0.0" + } + }, + "node_modules/@storybook/svelte/node_modules/type-fest": { + "version": "5.8.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.8.0.tgz", + "integrity": "sha512-YGYEVz3Fm5iy/AybuA0oyNFq7H4CgQNfRp/qfe8nurE1kuCeNm3/vfm9X4Mtl+qLyaKJUh5xrFZwogr41SMjYA==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "dependencies": { + "tagged-tag": "^1.0.0" + }, + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@storybook/sveltekit": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/sveltekit/-/sveltekit-10.5.6.tgz", + "integrity": "sha512-dwQb4B4zLitoQvQUpuudEjbnHAVc3/a0ZzvounwloJINGAmFvTp/fz4F5wHvh5a0vXFK/QT6VSpF3+CcKFqYDw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/builder-vite": "10.5.6", + "@storybook/svelte": "10.5.6", + "@storybook/svelte-vite": "10.5.6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.5.6", + "svelte": "^5.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@storybook/sveltekit/node_modules/@storybook/svelte-vite": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/@storybook/svelte-vite/-/svelte-vite-10.5.6.tgz", + "integrity": "sha512-jMmCOvOJ3VL7ee0258nbqrnRBT7e0kFjimnwe7MGUz1HnmOHvH7gUlcZXGh79kb8kkFjJJ6x4ZPHNK689IndNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/builder-vite": "10.5.6", + "@storybook/svelte": "10.5.6", + "magic-string": "^0.30.0", + "svelte2tsx": "^0.7.55", + "typescript": "^4.9.4 || ^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "@sveltejs/vite-plugin-svelte": "^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0", + "storybook": "^10.5.6", + "svelte": "^5.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@sveltejs/acorn-typescript": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.10.tgz", + "integrity": "sha512-4WfKk68eTih+MiJD4fSbxN7E8kVBmTMPWHUPYjvl2N0rMs53YLTT8/YjKU5Dtnz5LqDjl7LEw4U7lXR2W3J5WA==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^8.9.0" + } + }, + "node_modules/@sveltejs/adapter-static": { + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@sveltejs/adapter-static/-/adapter-static-3.0.10.tgz", + "integrity": "sha512-7D9lYFWJmB7zxZyTE/qxjksvMqzMuYrrsyh1f4AlZqeZeACPRySjbC3aFiY55wb1tWUaKOQG9PVbm74JcN2Iew==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@sveltejs/kit": "^2.0.0" + } + }, + "node_modules/@sveltejs/kit": { + "version": "2.70.2", + "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.70.2.tgz", + "integrity": "sha512-RzRoRpuR2KXqc5yMO0akQHDZeT4AslOlznGITURsqHaVbtyYP4Wn3eE3gxj9JcDyNYO0crkxhdwFHc+2vkVm6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@sveltejs/acorn-typescript": "^1.0.9", + "@types/cookie": "^0.6.0", + "acorn": "^8.16.0", + "cookie": "^0.6.0", + "devalue": "^5.8.1", + "esm-env": "^1.2.2", + "kleur": "^4.1.5", + "magic-string": "^0.30.5", + "mrmime": "^2.0.0", + "set-cookie-parser": "^3.0.0", + "sirv": "^3.0.0" + }, + "bin": { + "svelte-kit": "svelte-kit.js" + }, + "engines": { + "node": ">=18.13" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.0.0", + "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0 || ^7.0.0", + "svelte": "^4.0.0 || ^5.0.0-next.0", + "typescript": "^5.3.3 || ^6.0.0", + "vite": "^5.0.3 || ^6.0.0 || ^7.0.0-beta.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@opentelemetry/api": { + "optional": true + }, + "typescript": { + "optional": true + } + } + }, + "node_modules/@sveltejs/load-config": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@sveltejs/load-config/-/load-config-0.1.1.tgz", + "integrity": "sha512-BXXm+VOH/9X4N7Dd1iZ2MqA1h7M+9i2noI8QYuLDY8QcN2WHYn7D/VK/+IJNfcAmRw7ACNJ538UT9GXIhnBTiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 18.0.0" + } + }, + "node_modules/@sveltejs/vite-plugin-svelte": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-6.2.1.tgz", + "integrity": "sha512-YZs/OSKOQAQCnJvM/P+F1URotNnYNeU3P2s4oIpzm1uFaqUEqRxUB0g5ejMjEb5Gjb9/PiBI5Ktrq4rUUF8UVQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0", + "debug": "^4.4.1", + "deepmerge": "^4.3.1", + "magic-string": "^0.30.17", + "vitefu": "^1.1.1" + }, + "engines": { + "node": "^20.19 || ^22.12 || >=24" + }, + "peerDependencies": { + "svelte": "^5.0.0", + "vite": "^6.3.0 || ^7.0.0" + } + }, + "node_modules/@sveltejs/vite-plugin-svelte-inspector": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-5.0.2.tgz", + "integrity": "sha512-TZzRTcEtZffICSAoZGkPSl6Etsj2torOVrx6Uw0KpXxrec9Gg6jFWQ60Q3+LmNGfZSxHRCZL7vXVZIWmuV50Ig==", + "dev": true, + "license": "MIT", + "dependencies": { + "obug": "^2.1.0" + }, + "engines": { + "node": "^20.19 || ^22.12 || >=24" + }, + "peerDependencies": { + "@sveltejs/vite-plugin-svelte": "^6.0.0-next.0", + "svelte": "^5.0.0", + "vite": "^6.3.0 || ^7.0.0" + } + }, + "node_modules/@swc/helpers": { + "version": "0.5.23", + "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.23.tgz", + "integrity": "sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.8.0" + } + }, + "node_modules/@tailwindcss/forms": { + "version": "0.5.10", + "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.10.tgz", + "integrity": "sha512-utI1ONF6uf/pPNO68kmN1b8rEwNXv3czukalo8VtJH8ksIkZXr3Q3VYudZLkCsDd4Wku120uF02hYK25XGPorw==", + "dev": true, + "license": "MIT", + "dependencies": { + "mini-svg-data-uri": "^1.2.3" + }, + "peerDependencies": { + "tailwindcss": ">=3.0.0 || >= 3.0.0-alpha.1 || >= 4.0.0-alpha.20 || >= 4.0.0-beta.1" + } + }, + "node_modules/@tailwindcss/node": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.11.tgz", + "integrity": "sha512-yzhzuGRmv5QyU9qLNg4GTlYI6STedBWRE7NjxP45CsFYYq9taI0zJXZBMqIC/c8fViNLhmrbpSFS57EoxUmD6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ampproject/remapping": "^2.3.0", + "enhanced-resolve": "^5.18.1", + "jiti": "^2.4.2", + "lightningcss": "1.30.1", + "magic-string": "^0.30.17", + "source-map-js": "^1.2.1", + "tailwindcss": "4.1.11" + } + }, + "node_modules/@tailwindcss/node/node_modules/tailwindcss": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.11.tgz", + "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@tailwindcss/oxide": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.11.tgz", + "integrity": "sha512-Q69XzrtAhuyfHo+5/HMgr1lAiPP/G40OMFAnws7xcFEYqcypZmdW8eGXaOUIeOl1dzPJBPENXgbjsOyhg2nkrg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "detect-libc": "^2.0.4", + "tar": "^7.4.3" + }, + "engines": { + "node": ">= 10" + }, + "optionalDependencies": { + "@tailwindcss/oxide-android-arm64": "4.1.11", + "@tailwindcss/oxide-darwin-arm64": "4.1.11", + "@tailwindcss/oxide-darwin-x64": "4.1.11", + "@tailwindcss/oxide-freebsd-x64": "4.1.11", + "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.11", + "@tailwindcss/oxide-linux-arm64-gnu": "4.1.11", + "@tailwindcss/oxide-linux-arm64-musl": "4.1.11", + "@tailwindcss/oxide-linux-x64-gnu": "4.1.11", + "@tailwindcss/oxide-linux-x64-musl": "4.1.11", + "@tailwindcss/oxide-wasm32-wasi": "4.1.11", + "@tailwindcss/oxide-win32-arm64-msvc": "4.1.11", + "@tailwindcss/oxide-win32-x64-msvc": "4.1.11" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-gnu": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.1.11.tgz", + "integrity": "sha512-YW6sblI7xukSD2TdbbaeQVDysIm/UPJtObHJHKxDEcW2exAtY47j52f8jZXkqE1krdnkhCMGqP3dbniu1Te2Fg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@tailwindcss/oxide-linux-x64-musl": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.1.11.tgz", + "integrity": "sha512-e3C/RRhGunWYNC3aSF7exsQkdXzQ/M+aYuZHKnw4U7KQwTJotnWsGOIVih0s2qQzmEzOFIJ3+xt7iq67K/p56Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@tailwindcss/typography": { + "version": "0.5.16", + "resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.16.tgz", + "integrity": "sha512-0wDLwCVF5V3x3b1SGXPCDcdsbDHMBe+lkFzBRaHeLvNi+nrrnZ1lA18u+OTWO8iSWU2GxUOCvlXtDuqftc1oiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "lodash.castarray": "^4.4.0", + "lodash.isplainobject": "^4.0.6", + "lodash.merge": "^4.6.2", + "postcss-selector-parser": "6.0.10" + }, + "peerDependencies": { + "tailwindcss": ">=3.0.0 || insiders || >=4.0.0-alpha.20 || >=4.0.0-beta.1" + } + }, + "node_modules/@tailwindcss/vite": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.1.11.tgz", + "integrity": "sha512-RHYhrR3hku0MJFRV+fN2gNbDNEh3dwKvY8XJvTxCSXeMOsCRSr+uKvDWQcbizrHgjML6ZmTE5OwMrl5wKcujCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@tailwindcss/node": "4.1.11", + "@tailwindcss/oxide": "4.1.11", + "tailwindcss": "4.1.11" + }, + "peerDependencies": { + "vite": "^5.2.0 || ^6 || ^7" + } + }, + "node_modules/@tailwindcss/vite/node_modules/tailwindcss": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.11.tgz", + "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@testing-library/dom": { + "version": "10.4.1", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz", + "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "5.3.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.5.0", + "picocolors": "1.1.1", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@testing-library/jest-dom": { + "version": "6.9.1", + "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz", + "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@adobe/css-tools": "^4.4.0", + "aria-query": "^5.0.0", + "css.escape": "^1.5.1", + "dom-accessibility-api": "^0.6.3", + "picocolors": "^1.1.1", + "redent": "^3.0.0" + }, + "engines": { + "node": ">=14", + "npm": ">=6", + "yarn": ">=1" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz", + "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@testing-library/svelte-core": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@testing-library/svelte-core/-/svelte-core-1.0.0.tgz", + "integrity": "sha512-VkUePoLV6oOYwSUvX6ShA8KLnJqZiYMIbP2JW2t0GLWLkJxKGvuH5qrrZBV/X7cXFnLGuFQEC7RheYiZOW68KQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16" + }, + "peerDependencies": { + "svelte": "^3 || ^4 || ^5 || ^5.0.0-next.0" + } + }, + "node_modules/@testing-library/user-event": { + "version": "14.6.1", + "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz", + "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12", + "npm": ">=6" + }, + "peerDependencies": { + "@testing-library/dom": ">=7.21.4" + } + }, + "node_modules/@tmcp/adapter-valibot": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/@tmcp/adapter-valibot/-/adapter-valibot-0.1.6.tgz", + "integrity": "sha512-drirZeNinhYLiRSMksN+m//u0ImFxtGRk1Vp425Xp/7CbBXFQdjAG+f7grssyHAukbVTGzmWsMMP6ejrGVErUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@valibot/to-json-schema": "^1.3.0", + "valibot": "^1.1.0" + }, + "peerDependencies": { + "tmcp": "^1.17.0", + "valibot": "^1.1.0" + } + }, + "node_modules/@tmcp/adapter-valibot/node_modules/@valibot/to-json-schema": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/@valibot/to-json-schema/-/to-json-schema-1.7.1.tgz", + "integrity": "sha512-3qkmU6KXWh8GIThEAW3kuRHPQBMjWkKy+Ppz3WkUucx53DTpOa6siMn4xDGSOhlVyMrDaJTCTMLYPZVAIk1P0A==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "valibot": "^1.4.0" + } + }, + "node_modules/@tmcp/session-manager": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@tmcp/session-manager/-/session-manager-0.2.2.tgz", + "integrity": "sha512-UrCRpTsxh5XnMbplspvftEYboiZWgAiXqqAUbyFTHoHMJ0LoNDy8bQd0+7qtxtT4S5Qsnv650gvs/Nbec5NTCQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "tmcp": "^1.16.3" + } + }, + "node_modules/@tmcp/transport-http": { + "version": "0.8.6", + "resolved": "https://registry.npmjs.org/@tmcp/transport-http/-/transport-http-0.8.6.tgz", + "integrity": "sha512-iLcxu+tEMbkVHbhFfyXQhxfPDDTfm+F0kEw8Xg/a1rm29s4cBg1vwcpbtk02XTxsdDh8RJ1AZkQwF9WDGeb/IA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@tmcp/session-manager": "^0.2.2", + "esm-env": "^1.2.2" + }, + "peerDependencies": { + "@tmcp/auth": "^0.3.3 || ^0.4.0", + "tmcp": "^1.18.0" + }, + "peerDependenciesMeta": { + "@tmcp/auth": { + "optional": true + } + } + }, + "node_modules/@trickfilm400/rollup-plugin-off-main-thread": { + "version": "3.0.0-pre1", + "resolved": "https://registry.npmjs.org/@trickfilm400/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-3.0.0-pre1.tgz", + "integrity": "sha512-/67zpWDBLV+oYAEL682s1ktXL0HgqX76f6gaVGkGnVZlBbm1zd0v4Bz8MFF2GGhoX9rvfq3KSQHubFHwa6w6/Q==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "ejs": "^3.1.10", + "json5": "^2.2.3", + "magic-string": "^0.30.21", + "string.prototype.matchall": "^4.0.12" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@types/aria-query": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz", + "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/cookie": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.6.0.tgz", + "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3": { + "version": "7.4.3", + "resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz", + "integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-array": "*", + "@types/d3-axis": "*", + "@types/d3-brush": "*", + "@types/d3-chord": "*", + "@types/d3-color": "*", + "@types/d3-contour": "*", + "@types/d3-delaunay": "*", + "@types/d3-dispatch": "*", + "@types/d3-drag": "*", + "@types/d3-dsv": "*", + "@types/d3-ease": "*", + "@types/d3-fetch": "*", + "@types/d3-force": "*", + "@types/d3-format": "*", + "@types/d3-geo": "*", + "@types/d3-hierarchy": "*", + "@types/d3-interpolate": "*", + "@types/d3-path": "*", + "@types/d3-polygon": "*", + "@types/d3-quadtree": "*", + "@types/d3-random": "*", + "@types/d3-scale": "*", + "@types/d3-scale-chromatic": "*", + "@types/d3-selection": "*", + "@types/d3-shape": "*", + "@types/d3-time": "*", + "@types/d3-time-format": "*", + "@types/d3-timer": "*", + "@types/d3-transition": "*", + "@types/d3-zoom": "*" + } + }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-axis": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz", + "integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-brush": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz", + "integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-chord": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz", + "integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-contour": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz", + "integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-array": "*", + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-dispatch": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz", + "integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-dsv": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz", + "integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-fetch": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz", + "integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-dsv": "*" + } + }, + "node_modules/@types/d3-force": { + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz", + "integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-format": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz", + "integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-geo": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz", + "integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-hierarchy": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz", + "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-polygon": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz", + "integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-quadtree": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz", + "integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-random": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz", + "integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-selection": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-shape": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-time-format": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz", + "integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, + "node_modules/@types/debug": { + "version": "4.1.13", + "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz", + "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/ms": "*" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz", + "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/geojson": { + "version": "7946.0.16", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz", + "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/hast": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", + "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/katex": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.16.8.tgz", + "integrity": "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/mdast": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mdx": { + "version": "2.0.13", + "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz", + "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/ms": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz", + "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "24.13.0", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.0.tgz", + "integrity": "sha512-5vtOqGQr4NJKeEzV441FcOi2MeG9UTWq9LqVLGneDdu4vlX17H8kQ2PA2UmNwCUGPVDj4oBjNhS7ReVEIWJJrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.18.0" + } + }, + "node_modules/@types/react": { + "version": "19.2.17", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz", + "integrity": "sha512-MXfmqaVPEVgkBT/aY0aGCkRWWtByiYQXo3xdQ8r5RzuFrPiRn8Gar2tQdXSUQ2GKV3bkXckek89V8wQBY2Q/Aw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/resolve": { + "version": "1.20.2", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz", + "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/trusted-types": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", + "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.1.tgz", + "integrity": "sha512-JQ4S5GB0tfjO8BuJ4fcX+HodkzJjYBV+7OJ+wLygaX7OGQ7FudyHL4NSCA6ob+w3Yn+5MkKIozOwQhXeM7opVg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.60.1", + "@typescript-eslint/type-utils": "8.60.1", + "@typescript-eslint/utils": "8.60.1", + "@typescript-eslint/visitor-keys": "8.60.1", + "ignore": "^7.0.5", + "natural-compare": "^1.4.0", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^8.60.1", + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz", + "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.1.tgz", + "integrity": "sha512-A0M6ua6H252bVjPvvtSgl2QA4+ET9S5Mtkb2GDyTxIhH/C4qDItT7RQNO5PhMC6NXGYXOR9dIalcDDgBKT7oFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/scope-manager": "8.60.1", + "@typescript-eslint/types": "8.60.1", + "@typescript-eslint/typescript-estree": "8.60.1", + "@typescript-eslint/visitor-keys": "8.60.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/project-service": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.1.tgz", + "integrity": "sha512-eXkTH2bxmXlqD1RnOPmLZ9ZM9D3VwSx04JOwBnP9RQ+yUA5a2Mu7SfW8uaV2Aon53NJzZlZYuX7tn91Izf+xaw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.60.1", + "@typescript-eslint/types": "^8.60.1", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.1.tgz", + "integrity": "sha512-gvI5OQoptnxQnchOirukCuQ55svJSTuD/4k5+pC267xyBtYry748R9/c3tYUzb/iE6RZfllRz2lVulLCHkTm4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.60.1", + "@typescript-eslint/visitor-keys": "8.60.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/tsconfig-utils": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.1.tgz", + "integrity": "sha512-nh8w4qAteiKuZu3pSSzG/yGKpw0OlkrKnzFmbVRenKaD4qc+7i1GrmZaLVkr8rk4uipiPGMOW4YsM6WmKZ5CvA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.1.tgz", + "integrity": "sha512-sdwTrpjosW7ANQYJ39ZBF1ZyEMEGVB2UsikrserVM/30a/F1dTLnu9bGxEdosugyu5caigjLrR2qiD11asjI1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.60.1", + "@typescript-eslint/typescript-estree": "8.60.1", + "@typescript-eslint/utils": "8.60.1", + "debug": "^4.4.3", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/types": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.1.tgz", + "integrity": "sha512-4h0tY8ppCkdCzcrl2YM5M3my0xsE1Tf8om3owEu5oPWmXwkKRmk0j0LGDzYBGUcAlesEbxBhazqu/K4cu3Ug7w==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.1.tgz", + "integrity": "sha512-alpRkfG8hlVE5kdJW2GkfgDgXxold3e8e4l6EnmhRmRLbekgAPCCGDVD++sABy9FcgPFroq+uFcCSM1vR57Cew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.60.1", + "@typescript-eslint/tsconfig-utils": "8.60.1", + "@typescript-eslint/types": "8.60.1", + "@typescript-eslint/visitor-keys": "8.60.1", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz", + "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.5" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.1.tgz", + "integrity": "sha512-h2MPBLoNtjc3qZWfY3Tl51yPorQ2McHn8pJfcMNTcIvrrZrr90Ykffit0yjrPFWQcRcUxzH20+6OcVdW4yHtUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.60.1", + "@typescript-eslint/types": "8.60.1", + "@typescript-eslint/typescript-estree": "8.60.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.1.tgz", + "integrity": "sha512-EbGRQg4FhrmwLodl+t3JNAnXHWVr9Vp+Zl1QBZVPY4ByfkzIT8cX3K6QWODHtkIZqqJVEWvhHSx3v5PDHsaQag==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.60.1", + "eslint-visitor-keys": "^5.0.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz", + "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.1.tgz", + "integrity": "sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/@upsetjs/venn.js": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@upsetjs/venn.js/-/venn.js-2.0.0.tgz", + "integrity": "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw==", + "dev": true, + "license": "MIT", + "optionalDependencies": { + "d3-selection": "^3.0.0", + "d3-transition": "^3.0.1" + } + }, + "node_modules/@vite-pwa/assets-generator": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@vite-pwa/assets-generator/-/assets-generator-1.0.2.tgz", + "integrity": "sha512-MCbrb508JZHqe7bUibmZj/lyojdhLRnfkmyXnkrCM2zVrjTgL89U8UEfInpKTvPeTnxsw2hmyZxnhsdNR6yhwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "colorette": "^2.0.20", + "consola": "^3.4.2", + "sharp": "^0.33.5", + "sharp-ico": "^0.1.5", + "unconfig": "^7.3.1" + }, + "bin": { + "pwa-assets-generator": "bin/pwa-assets-generator.mjs" + }, + "engines": { + "node": ">=16.14.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vite-pwa/sveltekit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@vite-pwa/sveltekit/-/sveltekit-1.1.0.tgz", + "integrity": "sha512-mMIf2tY+7Hg8jecpu/WY+Ki2ikoXy3hVmt3tOxi0K+lYYnKQrDYthuHireI0S+26Mg9BXzL7qQF1xeB5VYlYlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "kolorist": "^1.8.0", + "tinyglobby": "^0.2.9", + "vite-plugin-pwa": "^1.2.0" + }, + "engines": { + "node": ">=18.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@sveltejs/kit": "^1.3.1 || ^2.0.1", + "@vite-pwa/assets-generator": "^1.0.0" + }, + "peerDependenciesMeta": { + "@vite-pwa/assets-generator": { + "optional": true + } + } + }, + "node_modules/@vitest/browser": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/browser/-/browser-4.1.10.tgz", + "integrity": "sha512-UDwuWGwXj646CBx/bQHOaJSX7np0I8JL/UKQYa1e4QrVHH8VdWtx8eaOuf8sy0ShwDgR6NjJAsp5eF6vjF6qng==", + "dev": true, + "license": "MIT", + "dependencies": { + "@blazediff/core": "1.9.1", + "@vitest/mocker": "4.1.10", + "@vitest/utils": "4.1.10", + "magic-string": "^0.30.21", + "pngjs": "^7.0.0", + "sirv": "^3.0.2", + "tinyrainbow": "^3.1.0", + "ws": "^8.19.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "vitest": "4.1.10" + } + }, + "node_modules/@vitest/browser-playwright": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/browser-playwright/-/browser-playwright-4.1.10.tgz", + "integrity": "sha512-nMoXGEiRpT7m3W7NsbvrM2aKNwiNHZf+zEpUCvMteGjZFvfT96Q9fh7QyB98dvDWXiKvrLxA7bJ1mCOOv+JQPw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/browser": "4.1.10", + "@vitest/mocker": "4.1.10", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "playwright": "*", + "vitest": "4.1.10" + }, + "peerDependenciesMeta": { + "playwright": { + "optional": false + } + } + }, + "node_modules/@vitest/coverage-v8": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.10.tgz", + "integrity": "sha512-IM49HmthevbgAO4anp1hwtoT9wYe59w0LR00gr+eagHE+ZJ5lK4sLPeO0ubgoJcwLk6dehU3R24N+FbEEKDc8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@bcoe/v8-coverage": "^1.0.2", + "@vitest/utils": "4.1.10", + "ast-v8-to-istanbul": "^1.0.0", + "istanbul-lib-coverage": "^3.2.2", + "istanbul-lib-report": "^3.0.1", + "istanbul-reports": "^3.2.0", + "magicast": "^0.5.2", + "obug": "^2.1.1", + "std-env": "^4.0.0-rc.1", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@vitest/browser": "4.1.10", + "vitest": "4.1.10" + }, + "peerDependenciesMeta": { + "@vitest/browser": { + "optional": true + } + } + }, + "node_modules/@vitest/expect": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz", + "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/expect/node_modules/@vitest/pretty-format": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz", + "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/expect/node_modules/@vitest/spy": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz", + "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/expect/node_modules/@vitest/utils": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz", + "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/expect/node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@vitest/mocker": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz", + "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "4.1.10", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.21" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/pretty-format": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz", + "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz", + "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "4.1.10", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz", + "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.1.10", + "@vitest/utils": "4.1.10", + "magic-string": "^0.30.21", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz", + "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz", + "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "4.1.10", + "convert-source-map": "^2.0.0", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@webcontainer/env": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@webcontainer/env/-/env-1.1.1.tgz", + "integrity": "sha512-6aN99yL695Hi9SuIk1oC88l9o0gmxL1nGWWQ/kNy81HigJ0FoaoTXpytCj6ItzgyCEwA9kF1wixsTuv5cjsgng==", + "dev": true, + "license": "MIT" + }, + "node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz", + "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz", + "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "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==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/aria-query": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", + "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz", + "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "is-array-buffer": "^3.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "is-array-buffer": "^3.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/ast-types": { + "version": "0.16.1", + "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.16.1.tgz", + "integrity": "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^2.0.1" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/ast-v8-to-istanbul": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.3.tgz", + "integrity": "sha512-jCMQ6ZylLPudp0CDfBmQBZUsrh1/8psbmu9ibeVWKuHWD0YrH9YABwlKu5kVEFoT0GCQQW9Z/SxfuEbbkGQCRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.31", + "estree-walker": "^3.0.3", + "js-tokens": "^10.0.0" + } + }, + "node_modules/ast-v8-to-istanbul/node_modules/js-tokens": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz", + "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", + "dev": true, + "license": "MIT" + }, + "node_modules/async-function": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz", + "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/axe-core": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.12.0.tgz", + "integrity": "sha512-FTavr/7Ba0IptwGOPxnQvdyW2tAsdLBMTBXz7rKH6xJ2skpyxpBxyHkDdBs4lf69yRqYpkqCdfhnwS8YULGOmg==", + "dev": true, + "license": "MPL-2.0", + "engines": { + "node": ">=4" + } + }, + "node_modules/axobject-query": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", + "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/babel-plugin-polyfill-corejs2": { + "version": "0.4.17", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz", + "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@babel/helper-define-polyfill-provider": "^0.6.8", + "semver": "^6.3.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.14.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz", + "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.8", + "core-js-compat": "^3.48.0" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-regenerator": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz", + "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.8" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", + "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.33", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.33.tgz", + "integrity": "sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/basic-auth": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/basic-auth/-/basic-auth-2.0.1.tgz", + "integrity": "sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "5.1.2" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/bits-ui": { + "version": "2.18.1", + "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.18.1.tgz", + "integrity": "sha512-KkemzKFH4T3gt3H+P86JcnAWExjByv/6vlwjm/BoCwTPHu03yiCdxbghdJLvFReQTe0acCAiRcKfmixxD6XvlA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@floating-ui/core": "^1.7.1", + "@floating-ui/dom": "^1.7.1", + "esm-env": "^1.1.2", + "runed": "^0.35.1", + "svelte-toolbelt": "^0.10.6", + "tabbable": "^6.2.0" + }, + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/huntabyte" + }, + "peerDependencies": { + "@internationalized/date": "^3.8.1", + "svelte": "^5.33.0" + } + }, + "node_modules/body-parser": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz", + "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^2.0.0", + "debug": "^4.4.3", + "http-errors": "^2.0.1", + "iconv-lite": "^0.7.2", + "on-finished": "^2.4.1", + "qs": "^6.15.2", + "raw-body": "^3.0.2", + "type-is": "^2.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/body-parser/node_modules/content-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz", + "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.18", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz", + "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.28.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz", + "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==", + "dev": true, + "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" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.10.12", + "caniuse-lite": "^1.0.30001782", + "electron-to-chromium": "^1.5.328", + "node-releases": "^2.0.36", + "update-browserslist-db": "^1.2.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz", + "integrity": "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "get-intrinsic": "^1.3.0", + "set-function-length": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001793", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz", + "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==", + "dev": true, + "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" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/ccount": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz", + "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "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/character-entities": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz", + "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-html4": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz", + "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-legacy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz", + "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/chokidar": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-5.0.0.tgz", + "integrity": "sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==", + "dev": true, + "license": "MIT", + "dependencies": { + "readdirp": "^5.0.0" + }, + "engines": { + "node": ">= 20.19.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/chownr": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz", + "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/chromatic": { + "version": "16.10.0", + "resolved": "https://registry.npmjs.org/chromatic/-/chromatic-16.10.0.tgz", + "integrity": "sha512-nFsztmnu7rFiGafUJgXvLUNpqmRylz92eNvzBoJNTKKQj4EQUyxznwnfpf1dTs7hXtWD8JwcH92jADydaHA1sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.3.5" + }, + "bin": { + "chroma": "dist/bin.cjs", + "chromatic": "dist/bin.cjs", + "chromatic-cli": "dist/bin.cjs" + }, + "peerDependencies": { + "@chromatic-com/cypress": "^0.*.* || ^1.0.0", + "@chromatic-com/playwright": "^0.*.* || ^1.0.0", + "@chromatic-com/vitest": "^0.*.* || ^1.0.0" + }, + "peerDependenciesMeta": { + "@chromatic-com/cypress": { + "optional": true + }, + "@chromatic-com/playwright": { + "optional": true + }, + "@chromatic-com/vitest": { + "optional": true + } + } + }, + "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/common-tags": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz", + "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/consola": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz", + "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.18.0 || >=16.10.0" + } + }, + "node_modules/content-disposition": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz", + "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cookie": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz", + "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/core-js-compat": { + "version": "3.49.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.49.0.tgz", + "integrity": "sha512-VQXt1jr9cBz03b331DFDCCP90b3fanciLkgiOoy8SBHy06gNf+vQ1A3WFLqG7I8TipYIKeYK9wxd0tUrvHcOZA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.28.1" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/cors": { + "version": "2.8.6", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz", + "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/corser": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/corser/-/corser-2.0.1.tgz", + "integrity": "sha512-utCYNzRSQIZNPIcGZdQc92UVJYAhtGAteCFg0yRaFm8f0P+CPtyGyHXJcGXnffjCybUCEx3FQ2G7U3/o9eIkVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/cose-base": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-1.0.3.tgz", + "integrity": "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==", + "dev": true, + "license": "MIT", + "dependencies": { + "layout-base": "^1.0.0" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/crypto-random-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz", + "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/css.escape": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz", + "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/cytoscape": { + "version": "3.34.0", + "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.34.0.tgz", + "integrity": "sha512-62rNSrioXw93uliKFBwjukeQyeWwH2PqDrTac31r2P6464u3AUvTk0xS4LVvT251g7IgkFunrI48ZEZGjywSOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/cytoscape-cose-bilkent": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/cytoscape-cose-bilkent/-/cytoscape-cose-bilkent-4.1.0.tgz", + "integrity": "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "cose-base": "^1.0.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cytoscape-fcose/-/cytoscape-fcose-2.2.0.tgz", + "integrity": "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "cose-base": "^2.2.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/cose-base": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-2.2.0.tgz", + "integrity": "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "layout-base": "^2.0.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/layout-base": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-2.0.1.tgz", + "integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==", + "dev": true, + "license": "MIT" + }, + "node_modules/d3": { + "version": "7.9.0", + "resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz", + "integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-array": "3", + "d3-axis": "3", + "d3-brush": "3", + "d3-chord": "3", + "d3-color": "3", + "d3-contour": "4", + "d3-delaunay": "6", + "d3-dispatch": "3", + "d3-drag": "3", + "d3-dsv": "3", + "d3-ease": "3", + "d3-fetch": "3", + "d3-force": "3", + "d3-format": "3", + "d3-geo": "3", + "d3-hierarchy": "3", + "d3-interpolate": "3", + "d3-path": "3", + "d3-polygon": "3", + "d3-quadtree": "3", + "d3-random": "3", + "d3-scale": "4", + "d3-scale-chromatic": "3", + "d3-selection": "3", + "d3-shape": "3", + "d3-time": "3", + "d3-time-format": "4", + "d3-timer": "3", + "d3-transition": "3", + "d3-zoom": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "dev": true, + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-axis": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz", + "integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-brush": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz", + "integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "3", + "d3-transition": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-chord": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz", + "integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-path": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-contour": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz", + "integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-array": "^3.2.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==", + "dev": true, + "license": "ISC", + "dependencies": { + "delaunator": "5" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-selection": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dsv": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz", + "integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "commander": "7", + "iconv-lite": "0.6", + "rw": "1" + }, + "bin": { + "csv2json": "bin/dsv2json.js", + "csv2tsv": "bin/dsv2dsv.js", + "dsv2dsv": "bin/dsv2dsv.js", + "dsv2json": "bin/dsv2json.js", + "json2csv": "bin/json2dsv.js", + "json2dsv": "bin/json2dsv.js", + "json2tsv": "bin/json2dsv.js", + "tsv2csv": "bin/dsv2dsv.js", + "tsv2json": "bin/dsv2json.js" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dsv/node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-fetch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz", + "integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-dsv": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-force": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz", + "integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-quadtree": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-geo": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz", + "integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-array": "2.5.0 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-hierarchy": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz", + "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-polygon": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz", + "integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-quadtree": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz", + "integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-random": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz", + "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-sankey": { + "version": "0.12.3", + "resolved": "https://registry.npmjs.org/d3-sankey/-/d3-sankey-0.12.3.tgz", + "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "d3-array": "1 - 2", + "d3-shape": "^1.2.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-array": { + "version": "2.12.1", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-2.12.1.tgz", + "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "internmap": "^1.0.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-path": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz", + "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/d3-sankey/node_modules/d3-shape": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz", + "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "d3-path": "1" + } + }, + "node_modules/d3-sankey/node_modules/internmap": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz", + "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==", + "dev": true, + "license": "ISC" + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-interpolate": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-dispatch": "1 - 3", + "d3-ease": "1 - 3", + "d3-interpolate": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "d3-selection": "2 - 3" + } + }, + "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", + "dev": true, + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "2 - 3", + "d3-transition": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/dagre-d3-es": { + "version": "7.0.14", + "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.14.tgz", + "integrity": "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg==", + "dev": true, + "license": "MIT", + "dependencies": { + "d3": "^7.9.0", + "lodash-es": "^4.17.21" + } + }, + "node_modules/data-view-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz", + "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-length": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz", + "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/inspect-js" + } + }, + "node_modules/data-view-byte-offset": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", + "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/dayjs": { + "version": "1.11.21", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.21.tgz", + "integrity": "sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decode-bmp": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/decode-bmp/-/decode-bmp-0.2.1.tgz", + "integrity": "sha512-NiOaGe+GN0KJqi2STf24hfMkFitDUaIoUU3eKvP/wAbLe8o6FuW5n/x7MHPR0HKvBokp6MQY/j7w8lewEeVCIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@canvas/image-data": "^1.0.0", + "to-data-view": "^1.1.0" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/decode-ico": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/decode-ico/-/decode-ico-0.4.1.tgz", + "integrity": "sha512-69NZfbKIzux1vBOd31al3XnMnH+2mqDhEgLdpygErm4d60N+UwA5Sq5WFjmEDQzumgB9fElojGwWG0vybVfFmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@canvas/image-data": "^1.0.0", + "decode-bmp": "^0.2.0", + "to-data-view": "^1.1.0" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/decode-named-character-reference": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz", + "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "character-entities": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/dedent": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.7.2.tgz", + "integrity": "sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "babel-plugin-macros": "^3.1.0" + }, + "peerDependenciesMeta": { + "babel-plugin-macros": { + "optional": true + } + } + }, + "node_modules/dedent-js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dedent-js/-/dedent-js-1.0.1.tgz", + "integrity": "sha512-OUepMozQULMLUmhxS95Vudo0jb0UchLimi3+pQ2plj61Fcy8axbP9hbiD4Sz6DPqn6XG3kfmziVfQ1rSys5AJQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/defu": { + "version": "6.1.7", + "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.7.tgz", + "integrity": "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/delaunator": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.1.0.tgz", + "integrity": "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "robust-predicates": "^3.0.2" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/devalue": { + "version": "5.8.1", + "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.8.1.tgz", + "integrity": "sha512-4CXDYRBGqN+57wVJkuXBYmpAVUSg3L6JAQa/DFqm238G73E1wuyc/JhGQJzN7vUf/CMphYau2zXbfWzDR5aTEw==", + "dev": true, + "license": "MIT" + }, + "node_modules/devlop": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz", + "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==", + "dev": true, + "license": "MIT", + "dependencies": { + "dequal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/dexie": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/dexie/-/dexie-4.4.3.tgz", + "integrity": "sha512-N+3IGQ3HPlyO2YAkntGAwitm42BpBGV86MttzUMiRzWLa4NGh0pltVRcUVF4ybL/OnXjCrr9k7SDPIKkFYP2Lg==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/dom-accessibility-api": { + "version": "0.5.16", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz", + "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==", + "dev": true, + "license": "MIT" + }, + "node_modules/dompurify": { + "version": "3.4.13", + "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.13.tgz", + "integrity": "sha512-2vmYIoqjze2d+kakP8S/nS5shfsl587kzwEjcGlTdiksUVgFHnFCsLYDVj/JNqJVOQZGSYBTmuycv0PodwmnMQ==", + "dev": true, + "license": "(MPL-2.0 OR Apache-2.0)", + "optionalDependencies": { + "@types/trusted-types": "^2.0.7" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "dev": true, + "license": "MIT" + }, + "node_modules/ejs": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz", + "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.367", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.367.tgz", + "integrity": "sha512-4Mk/mrynCNQ+atY40D3UpmhLWB6AHMbYMlIrPhHcMF6x0L7O0b052FCAsxw1LlaR++UFuNg3D/A6XCuGDa0guQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.23.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.23.0.tgz", + "integrity": "sha512-yJN/BOOLxcOW2aQgeif9mSnaUB8KtvmMMp56oA1kx1CRfBKbhZm2pJ+NBY+3eOboHxix8lfjWpHE0Ei5U8RbSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.3.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz", + "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/es-abstract": { + "version": "1.24.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz", + "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.2", + "arraybuffer.prototype.slice": "^1.0.4", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "data-view-buffer": "^1.0.2", + "data-view-byte-length": "^1.0.2", + "data-view-byte-offset": "^1.0.1", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "es-set-tostringtag": "^2.1.0", + "es-to-primitive": "^1.3.0", + "function.prototype.name": "^1.1.8", + "get-intrinsic": "^1.3.0", + "get-proto": "^1.0.1", + "get-symbol-description": "^1.1.0", + "globalthis": "^1.0.4", + "gopd": "^1.2.0", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "internal-slot": "^1.1.0", + "is-array-buffer": "^3.0.5", + "is-callable": "^1.2.7", + "is-data-view": "^1.0.2", + "is-negative-zero": "^2.0.3", + "is-regex": "^1.2.1", + "is-set": "^2.0.3", + "is-shared-array-buffer": "^1.0.4", + "is-string": "^1.1.1", + "is-typed-array": "^1.1.15", + "is-weakref": "^1.1.1", + "math-intrinsics": "^1.1.0", + "object-inspect": "^1.13.4", + "object-keys": "^1.1.1", + "object.assign": "^4.1.7", + "own-keys": "^1.0.1", + "regexp.prototype.flags": "^1.5.4", + "safe-array-concat": "^1.1.3", + "safe-push-apply": "^1.0.0", + "safe-regex-test": "^1.1.0", + "set-proto": "^1.0.0", + "stop-iteration-iterator": "^1.1.0", + "string.prototype.trim": "^1.2.10", + "string.prototype.trimend": "^1.0.9", + "string.prototype.trimstart": "^1.0.8", + "typed-array-buffer": "^1.0.3", + "typed-array-byte-length": "^1.0.3", + "typed-array-byte-offset": "^1.0.4", + "typed-array-length": "^1.0.7", + "unbox-primitive": "^1.1.0", + "which-typed-array": "^1.1.19" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.1.0.tgz", + "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz", + "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-to-primitive": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz", + "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7", + "is-date-object": "^1.0.5", + "is-symbol": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-toolkit": { + "version": "1.47.0", + "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.47.0.tgz", + "integrity": "sha512-n1GuoD0WEQZMBk5tttoZSqwgyLx01oqa5XsBmCHwPyNe1S9jPBEmtR2pSgp2kJuWE3ciFZ6yRHmY4pM4C3OOkw==", + "dev": true, + "license": "MIT", + "workspaces": [ + "docs", + "benchmarks" + ] + }, + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz", + "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.2", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.5", + "@eslint/js": "9.39.4", + "@eslint/plugin-kit": "^0.4.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-config-prettier": { + "version": "10.1.8", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz", + "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==", + "dev": true, + "license": "MIT", + "bin": { + "eslint-config-prettier": "bin/cli.js" + }, + "funding": { + "url": "https://opencollective.com/eslint-config-prettier" + }, + "peerDependencies": { + "eslint": ">=7.0.0" + } + }, + "node_modules/eslint-plugin-perfectionist": { + "version": "5.10.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-perfectionist/-/eslint-plugin-perfectionist-5.10.1.tgz", + "integrity": "sha512-Kprsp9Us0GqAesYaAIzUViw57xYp5WBqzXrcE0Mtww++E5fexWXYBipMuuD7yvyH4vvpBH0+oJ+OMAmZ0oYXkw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/utils": "^8.65.0", + "natural-orderby": "^5.0.0" + }, + "engines": { + "node": "^20.0.0 || >=22.0.0" + }, + "peerDependencies": { + "eslint": "^8.45.0 || ^9.0.0 || ^10.0.0" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/project-service": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.66.0.tgz", + "integrity": "sha512-7MthGPTt4BP69lSryqpqq8HQqxuzynssckL/jyDyk3+TNMQ3y2jFWkptCrktWvBrP+EH787Nl5N5Qpw7WZg+5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.66.0", + "@typescript-eslint/types": "^8.66.0", + "debug": "^4.4.3" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/scope-manager": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.66.0.tgz", + "integrity": "sha512-8TGcH25j9zqJ/IULB/ppyhRvxA8QYfFEZ7nfbg6/BN9spDgb8fPWQXlE5l8TWBL50EtUx007uZ1o9VOwrq2/9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.66.0", + "@typescript-eslint/visitor-keys": "8.66.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/tsconfig-utils": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.66.0.tgz", + "integrity": "sha512-9D5gLYZG4rOjcoag8MQ/fWI8WqA9wcPDyOGyWtWFhvM1lHRbliqUSPIY5J3zqCU1tvSwzXxnnjhQhz5Ne7mJ4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/types": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.66.0.tgz", + "integrity": "sha512-H6gcYaSDOyvL3AD/jHUtUFo2jqGgn/F6nuyuZSu0QTesxL+cP4dQoIMrODRofuJC09g64+WgZ6tE19Y1N2YIFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/typescript-estree": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.66.0.tgz", + "integrity": "sha512-8/x4INiiQb10jGgXYD7116/zQ+OL84ZIFn0za68wwFHCanT/VLbBEroWht8RV8fn0/ZCAoazHLQgwUC0UQcDfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/project-service": "8.66.0", + "@typescript-eslint/tsconfig-utils": "8.66.0", + "@typescript-eslint/types": "8.66.0", + "@typescript-eslint/visitor-keys": "8.66.0", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.5.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/utils": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.66.0.tgz", + "integrity": "sha512-jasearZPolBw5NJNYGMwxzHMF83niVWmMU1VdHzG1CyfI2VS7f7nZltnKtHcg20hW+7Uo5GfK4MeDPoU3qI8EA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.66.0", + "@typescript-eslint/types": "8.66.0", + "@typescript-eslint/typescript-estree": "8.66.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/@typescript-eslint/visitor-keys": { + "version": "8.66.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.66.0.tgz", + "integrity": "sha512-dkKR8q+lKciskj1Y3vthHktl+3cMLWGyVUP23bRiPZ5O9BRT++4EqDDV+TVeIKBL1VXVEqrJlz8MYbcnvJcAlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "8.66.0", + "eslint-visitor-keys": "^5.0.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/brace-expansion": { + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz", + "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/eslint-visitor-keys": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz", + "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-plugin-perfectionist/node_modules/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/eslint-plugin-simple-import-sort": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-simple-import-sort/-/eslint-plugin-simple-import-sort-14.0.0.tgz", + "integrity": "sha512-NUJO0+XFCkk+o5EsAJruTgnfMEpeWrPWeJS15UVF60GgXmqz1BJ9/3hzlvG7lkL8Bubzos5cCLptThbFfPnSMQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": ">=5.0.0" + } + }, + "node_modules/eslint-plugin-storybook": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/eslint-plugin-storybook/-/eslint-plugin-storybook-10.5.6.tgz", + "integrity": "sha512-uOXhNkIH+iTdyViSmWnCrwtapasL57M3nq5yfST1H7y9djRLyuAIfNcf9cPBedc2G1oqI8jn3up/VHdN3y3Btw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "^8.60.0", + "@typescript-eslint/utils": "^8.60.0" + }, + "peerDependencies": { + "eslint": ">=8", + "storybook": "^10.5.6" + } + }, + "node_modules/eslint-plugin-svelte": { + "version": "3.19.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-svelte/-/eslint-plugin-svelte-3.19.0.tgz", + "integrity": "sha512-t3rNaZeXz4d2gG4uJyMEYfJCFKf22+SWbSizIIXIWKu4wM+XPLiMWuSSr/C5821JmFeN9ogK+eExbG+z+twyxw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.6.1", + "@jridgewell/sourcemap-codec": "^1.5.0", + "esutils": "^2.0.3", + "globals": "^16.0.0", + "known-css-properties": "^0.37.0", + "postcss": "^8.4.49", + "postcss-load-config": "^3.1.4", + "postcss-safe-parser": "^7.0.0", + "semver": "^7.6.3", + "svelte-eslint-parser": "^1.7.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://github.com/sponsors/ota-meshi" + }, + "peerDependencies": { + "eslint": "^8.57.1 || ^9.0.0 || ^10.0.0", + "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "svelte": { + "optional": true + } + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/@eslint/js": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz", + "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/eslint/node_modules/ajv": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz", + "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==", + "dev": true, + "license": "MIT", + "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/eslint/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==", + "dev": true, + "license": "MIT" + }, + "node_modules/esm-env": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz", + "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrap": { + "version": "1.4.9", + "resolved": "https://registry.npmjs.org/esrap/-/esrap-1.4.9.tgz", + "integrity": "sha512-3OMlcd0a03UGuZpPeUC1HxR3nA23l+HEyCiZw3b3FumJIN9KphoGzDJKMXI1S72jVS1dsenDyQC0kJlO1U9E1g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.4.15" + } + }, + "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==", + "dev": true, + "license": "BSD-2-Clause", + "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==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.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==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eta": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/eta/-/eta-4.6.0.tgz", + "integrity": "sha512-lW6is4T1NFOYnmqGZIfvixqj7A7sSvScF+DN8EK6K58xI5MZ5UvYe0GjopxOXQtZvUn4eDdVuZ8XSoYWTMEKwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/bgub/eta?sponsor=1" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "dev": true, + "license": "MIT" + }, + "node_modules/eventsource": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz", + "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==", + "dev": true, + "license": "MIT", + "dependencies": { + "eventsource-parser": "^3.0.1" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/eventsource-parser": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz", + "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/express": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", + "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.1", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "depd": "^2.0.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "8.5.2", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.2.tgz", + "integrity": "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ip-address": "^10.2.0" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": ">= 4.11" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-uri": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz", + "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/fflate": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz", + "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==", + "dev": true, + "license": "MIT" + }, + "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/filelist": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz", + "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "minimatch": "^5.0.1" + } + }, + "node_modules/filelist/node_modules/brace-expansion": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz", + "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/filelist/node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/finalhandler": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", + "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "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==", + "dev": true, + "license": "MIT", + "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": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz", + "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==", + "dev": true, + "license": "ISC" + }, + "node_modules/follow-redirects": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz", + "integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/for-each": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", + "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/function.prototype.name": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz", + "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "functions-have-names": "^1.2.3", + "hasown": "^2.0.2", + "is-callable": "^1.2.7" + }, + "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==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/generator-function": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz", + "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-own-enumerable-property-symbols": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz", + "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==", + "dev": true, + "license": "ISC" + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-symbol-description": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "16.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz", + "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globalthis": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "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==", + "dev": true, + "license": "ISC" + }, + "node_modules/hachure-fill": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/hachure-fill/-/hachure-fill-0.5.2.tgz", + "integrity": "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg==", + "dev": true, + "license": "MIT" + }, + "node_modules/has-bigints": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", + "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", + "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hast-util-from-dom": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/hast-util-from-dom/-/hast-util-from-dom-5.0.1.tgz", + "integrity": "sha512-N+LqofjR2zuzTjCPzyDUdSshy4Ma6li7p/c3pA78uTwzFgENbgbUrm2ugwsOdcjI1muO+o6Dgzp9p8WHtn/39Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "@types/hast": "^3.0.0", + "hastscript": "^9.0.0", + "web-namespaces": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-html": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/hast-util-from-html/-/hast-util-from-html-2.0.3.tgz", + "integrity": "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "devlop": "^1.1.0", + "hast-util-from-parse5": "^8.0.0", + "parse5": "^7.0.0", + "vfile": "^6.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-html-isomorphic": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/hast-util-from-html-isomorphic/-/hast-util-from-html-isomorphic-2.0.0.tgz", + "integrity": "sha512-zJfpXq44yff2hmE0XmwEOzdWin5xwH+QIhMLOScpX91e/NSGPsAzNCvLQDIEPyO2TXi+lBmU6hjLIhV8MwP2kw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-from-dom": "^5.0.0", + "hast-util-from-html": "^2.0.0", + "unist-util-remove-position": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-html/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/hast-util-from-html/node_modules/vfile-message": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz", + "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-parse5": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz", + "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "devlop": "^1.0.0", + "hastscript": "^9.0.0", + "property-information": "^7.0.0", + "vfile": "^6.0.0", + "vfile-location": "^5.0.0", + "web-namespaces": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-parse5/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/hast-util-is-element": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz", + "integrity": "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-parse-selector": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz", + "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-sanitize": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-5.0.2.tgz", + "integrity": "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@ungap/structured-clone": "^1.0.0", + "unist-util-position": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-html": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz", + "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "ccount": "^2.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-whitespace": "^3.0.0", + "html-void-elements": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0", + "stringify-entities": "^4.0.0", + "zwitch": "^2.0.4" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-html/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/hast-util-to-text": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz", + "integrity": "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "hast-util-is-element": "^3.0.0", + "unist-util-find-after": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-text/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hastscript": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz", + "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-parse-selector": "^4.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "dev": true, + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/highlight.js": { + "version": "11.11.1", + "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-11.11.1.tgz", + "integrity": "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/hono": { + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.0.tgz", + "integrity": "sha512-jhunvfHWxd7J5EFfSgH4xsYJzSe/lfqbUCxiyyeaQasUsXeEHXtzVid+7EOGByc5JnFa23SSFL3Y2RV/z1T+eQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.9.0" + } + }, + "node_modules/html-encoding-sniffer": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-3.0.0.tgz", + "integrity": "sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA==", + "dev": true, + "license": "MIT", + "dependencies": { + "whatwg-encoding": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, + "node_modules/html-void-elements": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", + "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz", + "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-server": { + "version": "14.1.1", + "resolved": "https://registry.npmjs.org/http-server/-/http-server-14.1.1.tgz", + "integrity": "sha512-+cbxadF40UXd9T01zUHgA+rlo2Bg1Srer4+B4NwIHdaGxAGGv59nYRnGGDJ9LBk7alpS0US+J+bLLdQOOkJq4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "basic-auth": "^2.0.1", + "chalk": "^4.1.2", + "corser": "^2.0.1", + "he": "^1.2.0", + "html-encoding-sniffer": "^3.0.0", + "http-proxy": "^1.18.1", + "mime": "^1.6.0", + "minimist": "^1.2.6", + "opener": "^1.5.1", + "portfinder": "^1.0.28", + "secure-compare": "3.0.1", + "union": "~0.5.0", + "url-join": "^4.0.1" + }, + "bin": { + "http-server": "bin/http-server" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/ico-endec": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ico-endec/-/ico-endec-0.1.6.tgz", + "integrity": "sha512-ZdLU38ZoED3g1j3iEyzcQj+wAkY2xfWNkymszfJPoxucIUhK7NayQ+/C4Kv0nDFMIsbtbEHldv3V8PU494/ueQ==", + "dev": true, + "license": "MPL-2.0" + }, + "node_modules/iconv-lite": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz", + "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/idb": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz", + "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/immutable": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-5.1.9.tgz", + "integrity": "sha512-m8nVez3rwrgmWxtLMt1ZYXB2Lv7OKYn/disyxAlSDYAlKSlFoPPfIAmAM/M5xqL4m4C/wAPw7S2/CNaUii1Hxg==", + "dev": true, + "license": "MIT" + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-meta-resolve": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.2.0.tgz", + "integrity": "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/inline-style-parser": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz", + "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==", + "dev": true, + "license": "MIT" + }, + "node_modules/internal-slot": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "hasown": "^2.0.2", + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/ip-address": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.4.0.tgz", + "integrity": "sha512-oSK96Grm3aP6OrS263xVxbNDGVL7rzBtYdpGqlDG8iQdoenDoTs/nkki+DflYbAEE8Xl6o5YxhxlrKvI3nqKXQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-async-function": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz", + "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "async-function": "^1.0.0", + "call-bound": "^1.0.3", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-bigint": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-bigints": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-boolean-object": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz", + "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.16.2", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz", + "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-data-view": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-docker": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz", + "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==", + "dev": true, + "license": "MIT", + "bin": { + "is-docker": "cli.js" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-finalizationregistry": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-generator-function": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz", + "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.4", + "generator-function": "^2.0.0", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-inside-container": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz", + "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-docker": "^3.0.0" + }, + "bin": { + "is-inside-container": "cli.js" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-map": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz", + "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-negative-zero": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz", + "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number-object": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", + "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-reference": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz", + "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.6" + } + }, + "node_modules/is-regex": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz", + "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-set": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz", + "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", + "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakmap": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz", + "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz", + "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakset": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-wsl": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.1.tgz", + "integrity": "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-inside-container": "^1.0.0" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "dev": true, + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jake": { + "version": "10.9.4", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz", + "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "async": "^3.2.6", + "filelist": "^1.0.4", + "picocolors": "^1.1.1" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jiti": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz", + "integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==", + "dev": true, + "license": "MIT", + "bin": { + "jiti": "lib/jiti-cli.mjs" + } + }, + "node_modules/jose": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz", + "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/panva" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.1.tgz", + "integrity": "sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/puzrin" + }, + { + "type": "github", + "url": "https://github.com/sponsors/nodeca" + } + ], + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-rpc-2.0": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/json-rpc-2.0/-/json-rpc-2.0-1.7.1.tgz", + "integrity": "sha512-JqZjhjAanbpkXIzFE7u8mE/iFblawwlXtONaCvRqI+pyABVz7B4M1EUNpyVW+dZjqgQ2L5HFmZCmOCgUKm00hg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-typed": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz", + "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==", + "dev": true, + "license": "BSD-2-Clause" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonc-parser": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz", + "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsonfile": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz", + "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/jsonpointer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz", + "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/katex": { + "version": "0.16.47", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.47.tgz", + "integrity": "sha512-Eeo8Ys1doU1z+x8AZsPpQu+p/QcZBI5PeOo7QGQdy2x2m0MU/hYagBbGOmXwr5KVbEfVuWv9LpnQWeehogurjg==", + "dev": true, + "funding": [ + "https://opencollective.com/katex", + "https://github.com/sponsors/katex" + ], + "license": "MIT", + "dependencies": { + "commander": "^8.3.0" + }, + "bin": { + "katex": "cli.js" + } + }, + "node_modules/katex/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/khroma": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz", + "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==", + "dev": true + }, + "node_modules/kleur": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", + "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/known-css-properties": { + "version": "0.37.0", + "resolved": "https://registry.npmjs.org/known-css-properties/-/known-css-properties-0.37.0.tgz", + "integrity": "sha512-JCDrsP4Z1Sb9JwG0aJ8Eo2r7k4Ou5MwmThS/6lcIe1ICyb7UBJKGRIUUdqc2ASdE/42lgz6zFUnzAIhtXnBVrQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/kolorist": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz", + "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/layout-base": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-1.0.2.tgz", + "integrity": "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==", + "dev": true, + "license": "MIT" + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lightningcss": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.30.1.tgz", + "integrity": "sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-darwin-arm64": "1.30.1", + "lightningcss-darwin-x64": "1.30.1", + "lightningcss-freebsd-x64": "1.30.1", + "lightningcss-linux-arm-gnueabihf": "1.30.1", + "lightningcss-linux-arm64-gnu": "1.30.1", + "lightningcss-linux-arm64-musl": "1.30.1", + "lightningcss-linux-x64-gnu": "1.30.1", + "lightningcss-linux-x64-musl": "1.30.1", + "lightningcss-win32-arm64-msvc": "1.30.1", + "lightningcss-win32-x64-msvc": "1.30.1" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.30.1.tgz", + "integrity": "sha512-piWx3z4wN8J8z3+O5kO74+yr6ze/dKmPnI7vLqfSqI8bccaTGY5xiSGVIJBDd5K5BHlvVLpUB3S2YCfelyJ1bw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.30.1.tgz", + "integrity": "sha512-rRomAK7eIkL+tHY0YPxbc5Dra2gXlI63HL+v1Pdi1a3sC+tJTcFrHX+E86sulgAXeI7rSzDYhPSeHHjqFhqfeQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lilconfig": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/locate-character": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz", + "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash-es": { + "version": "4.18.1", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz", + "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.castarray": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz", + "integrity": "sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.sortby": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz", + "integrity": "sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==", + "dev": true, + "license": "MIT" + }, + "node_modules/longest-streak": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz", + "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/lowlight": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/lowlight/-/lowlight-3.3.0.tgz", + "integrity": "sha512-0JNhgFoPvP6U6lE/UdVsSq99tn6DhjjpAj5MxG49ewd2mOBVtwWYIT8ClyABhq198aXXODMU6Ox8DrGy/CpTZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "devlop": "^1.0.0", + "highlight.js": "~11.11.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/lz-string": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz", + "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==", + "dev": true, + "license": "MIT", + "bin": { + "lz-string": "bin/bin.js" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/magicast": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.3.tgz", + "integrity": "sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.3", + "@babel/types": "^7.29.0", + "source-map-js": "^1.2.1" + } + }, + "node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/markdown-table": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz", + "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/marked": { + "version": "16.4.2", + "resolved": "https://registry.npmjs.org/marked/-/marked-16.4.2.tgz", + "integrity": "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA==", + "dev": true, + "license": "MIT", + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 20" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/mdast": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mdast/-/mdast-3.0.0.tgz", + "integrity": "sha512-xySmf8g4fPKMeC07jXGz971EkLbWAJ83s4US2Tj9lEdnZ142UP5grN73H1Xd3HzrdbU5o9GYYP/y8F9ZSwLE9g==", + "deprecated": "`mdast` was renamed to `remark`", + "dev": true, + "license": "MIT" + }, + "node_modules/mdast-util-find-and-replace": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz", + "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "escape-string-regexp": "^5.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz", + "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mdast-util-from-markdown": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz", + "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark": "^4.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-decode-string": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-from-markdown/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/mdast-util-gfm": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz", + "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-gfm-autolink-literal": "^2.0.0", + "mdast-util-gfm-footnote": "^2.0.0", + "mdast-util-gfm-strikethrough": "^2.0.0", + "mdast-util-gfm-table": "^2.0.0", + "mdast-util-gfm-task-list-item": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-autolink-literal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz", + "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "ccount": "^2.0.0", + "devlop": "^1.0.0", + "mdast-util-find-and-replace": "^3.0.0", + "micromark-util-character": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-footnote": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz", + "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.1.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-strikethrough": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz", + "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-table": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz", + "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "markdown-table": "^3.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-task-list-item": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz", + "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-math": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-math/-/mdast-util-math-3.0.0.tgz", + "integrity": "sha512-Tl9GBNeG/AhJnQM221bJR2HPvLOSnLE/T9cJI9tlc6zwQk2nPk/4f0cHkOdEixQPC/j8UtKDdITswvLAy1OZ1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "longest-streak": "^3.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.1.0", + "unist-util-remove-position": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-newline-to-break": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-newline-to-break/-/mdast-util-newline-to-break-2.0.0.tgz", + "integrity": "sha512-MbgeFca0hLYIEx/2zGsszCSEJJ1JSCdiY5xQxRcLDDGa8EPvlLPupJ4DSajbMPAnC0je8jfb9TiUATnxxrHUog==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-find-and-replace": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-phrasing": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz", + "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-hast": { + "version": "13.2.1", + "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz", + "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@ungap/structured-clone": "^1.0.0", + "devlop": "^1.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "trim-lines": "^3.0.0", + "unist-util-position": "^5.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-markdown": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz", + "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "longest-streak": "^3.0.0", + "mdast-util-phrasing": "^4.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-decode-string": "^2.0.0", + "unist-util-visit": "^5.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-markdown/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/mdast-util-to-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz", + "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdsvex": { + "version": "0.12.7", + "resolved": "https://registry.npmjs.org/mdsvex/-/mdsvex-0.12.7.tgz", + "integrity": "sha512-gx4bReLCUvq+MPErHXYeyX+TEq1hsS2KfiZtEOMNTcbibSouFy8AHc5h04KbGCl+g5tLuo4/lbgRVYRnc7bJZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.4", + "@types/unist": "^2.0.3", + "prism-svelte": "^0.4.7", + "prismjs": "^1.17.1", + "unist-util-visit": "^2.0.1", + "vfile-message": "^2.0.4" + }, + "peerDependencies": { + "svelte": "^3.56.0 || ^4.0.0 || ^5.0.0-next.120" + } + }, + "node_modules/mdsvex/node_modules/unist-util-is": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz", + "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdsvex/node_modules/unist-util-visit": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz", + "integrity": "sha512-iJ4/RczbJMkD0712mGktuGpm/U4By4FfDonL7N/9tATGIF4imikjOuagyMY53tnZq3NP6BcmlrHhEKAfGWjh7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-is": "^4.0.0", + "unist-util-visit-parents": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdsvex/node_modules/unist-util-visit-parents": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-3.1.1.tgz", + "integrity": "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-is": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/media-typer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", + "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mermaid": { + "version": "11.15.0", + "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.15.0.tgz", + "integrity": "sha512-pTMbcf3rWdtLiYGpmoTjHEpeY8seiy6sR+9nD7LOs8KfUbHE4lOUAprTRqRAcWSQ6MQpdX+YEsxShtGsINtPtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@braintree/sanitize-url": "^7.1.1", + "@iconify/utils": "^3.0.2", + "@mermaid-js/parser": "^1.1.1", + "@types/d3": "^7.4.3", + "@upsetjs/venn.js": "^2.0.0", + "cytoscape": "^3.33.1", + "cytoscape-cose-bilkent": "^4.1.0", + "cytoscape-fcose": "^2.2.0", + "d3": "^7.9.0", + "d3-sankey": "^0.12.3", + "dagre-d3-es": "7.0.14", + "dayjs": "^1.11.19", + "dompurify": "^3.3.1", + "es-toolkit": "^1.45.1", + "katex": "^0.16.25", + "khroma": "^2.1.0", + "marked": "^16.3.0", + "roughjs": "^4.6.6", + "stylis": "^4.3.6", + "ts-dedent": "^2.2.0", + "uuid": "^11.1.0 || ^12 || ^13 || ^14.0.0" + } + }, + "node_modules/micromark": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz", + "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/debug": "^4.0.0", + "debug": "^4.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz", + "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-factory-destination": "^2.0.0", + "micromark-factory-label": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-factory-title": "^2.0.0", + "micromark-factory-whitespace": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-html-tag-name": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz", + "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "micromark-extension-gfm-autolink-literal": "^2.0.0", + "micromark-extension-gfm-footnote": "^2.0.0", + "micromark-extension-gfm-strikethrough": "^2.0.0", + "micromark-extension-gfm-table": "^2.0.0", + "micromark-extension-gfm-tagfilter": "^2.0.0", + "micromark-extension-gfm-task-list-item": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-autolink-literal": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz", + "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==", + "dev": true, + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-footnote": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz", + "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-strikethrough": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz", + "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==", + "dev": true, + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-table": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz", + "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==", + "dev": true, + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-tagfilter": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz", + "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-task-list-item": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz", + "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==", + "dev": true, + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-math": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-math/-/micromark-extension-math-3.1.0.tgz", + "integrity": "sha512-lvEqd+fHjATVs+2v/8kg9i5Q0AP2k85H0WUOwpIVvUML8BapsMvh1XAogmQjOCsLpoKRCVQqEkQBB3NhVBcsOg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/katex": "^0.16.0", + "devlop": "^1.0.0", + "katex": "^0.16.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-factory-destination": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz", + "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-label": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz", + "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-space": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz", + "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-title": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz", + "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-whitespace": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz", + "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-character": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-chunked": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz", + "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-classify-character": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz", + "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-combine-extensions": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz", + "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-chunked": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-numeric-character-reference": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz", + "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-string": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz", + "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-encode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz", + "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-html-tag-name": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz", + "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-normalize-identifier": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz", + "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-resolve-all": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz", + "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-sanitize-uri": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz", + "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-subtokenize": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz", + "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-types": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz", + "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "dev": true, + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-db": "^1.54.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/min-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", + "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/mini-svg-data-uri": { + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz", + "integrity": "sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==", + "dev": true, + "license": "MIT", + "bin": { + "mini-svg-data-uri": "cli.js" + } + }, + "node_modules/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "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==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/minizlib": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz", + "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==", + "dev": true, + "license": "MIT", + "dependencies": { + "minipass": "^7.1.2" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/mode-watcher": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mode-watcher/-/mode-watcher-1.1.0.tgz", + "integrity": "sha512-mUT9RRGPDYenk59qJauN1rhsIMKBmWA3xMF+uRwE8MW/tjhaDSCCARqkSuDTq8vr4/2KcAxIGVjACxTjdk5C3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "runed": "^0.25.0", + "svelte-toolbelt": "^0.7.1" + }, + "peerDependencies": { + "svelte": "^5.27.0" + } + }, + "node_modules/mode-watcher/node_modules/runed": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/runed/-/runed-0.25.0.tgz", + "integrity": "sha512-7+ma4AG9FT2sWQEA0Egf6mb7PBT2vHyuHail1ie8ropfSjvZGtEAx8YTmUjv/APCsdRRxEVvArNjALk9zFSOrg==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte", + "https://github.com/sponsors/tglide" + ], + "dependencies": { + "esm-env": "^1.0.0" + }, + "peerDependencies": { + "svelte": "^5.7.0" + } + }, + "node_modules/mode-watcher/node_modules/svelte-toolbelt": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.7.1.tgz", + "integrity": "sha512-HcBOcR17Vx9bjaOceUvxkY3nGmbBmCBBbuWLLEWO6jtmWH8f/QoWmbyUfQZrpDINH39en1b8mptfPQT9VKQ1xQ==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte" + ], + "dependencies": { + "clsx": "^2.1.1", + "runed": "^0.23.2", + "style-to-object": "^1.0.8" + }, + "engines": { + "node": ">=18", + "pnpm": ">=8.7.0" + }, + "peerDependencies": { + "svelte": "^5.0.0" + } + }, + "node_modules/mode-watcher/node_modules/svelte-toolbelt/node_modules/runed": { + "version": "0.23.4", + "resolved": "https://registry.npmjs.org/runed/-/runed-0.23.4.tgz", + "integrity": "sha512-9q8oUiBYeXIDLWNK5DfCWlkL0EW3oGbk845VdKlPeia28l751VpfesaB/+7pI6rnbx1I6rqoZ2fZxptOJLxILA==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte", + "https://github.com/sponsors/tglide" + ], + "dependencies": { + "esm-env": "^1.0.0" + }, + "peerDependencies": { + "svelte": "^5.7.0" + } + }, + "node_modules/mri": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz", + "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/mrmime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz", + "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.17", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.17.tgz", + "integrity": "sha512-xQLf0A3HOMlgHq0n247/LRuAOYmB7dXJ/DvAxGvsSBij45XtBSmQycu+F8ODbHwns/XyFZagyL1+J0Offw1E0g==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/natural-orderby": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/natural-orderby/-/natural-orderby-5.0.0.tgz", + "integrity": "sha512-kKHJhxwpR/Okycz4HhQKKlhWe4ASEfPgkSWNmKFHd7+ezuQlxkA5cM3+XkBPvm1gmHen3w53qsYAv+8GwRrBlg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/node-addon-api": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz", + "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/node-releases": { + "version": "2.0.47", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz", + "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.7", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz", + "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0", + "has-symbols": "^1.1.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obug": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.2.tgz", + "integrity": "sha512-AWGB9WFcRXOQs48Z/udjI5ZcZMHXwX8XPByNpOydgcGsDLIzjGizhoMWJyKAWze7AVW/2W1i+/gPX4YtKe5cyg==", + "dev": true, + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "license": "MIT", + "engines": { + "node": ">=12.20.0" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/opener": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz", + "integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==", + "dev": true, + "license": "(WTFPL OR MIT)", + "bin": { + "opener": "bin/opener-bin.js" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "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.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/own-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz", + "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.6", + "object-keys": "^1.1.1", + "safe-push-apply": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/oxc-parser": { + "version": "0.127.0", + "resolved": "https://registry.npmjs.org/oxc-parser/-/oxc-parser-0.127.0.tgz", + "integrity": "sha512-bkgD4qHlN7WxLdX8bLXdaU54TtQtAIg/ZBAfm0aje/mo3MRDo3P0hZSgr4U7O3xfX+fQmR5AP04JS/TGcZLcFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "^0.127.0" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/sponsors/Boshen" + }, + "optionalDependencies": { + "@oxc-parser/binding-android-arm-eabi": "0.127.0", + "@oxc-parser/binding-android-arm64": "0.127.0", + "@oxc-parser/binding-darwin-arm64": "0.127.0", + "@oxc-parser/binding-darwin-x64": "0.127.0", + "@oxc-parser/binding-freebsd-x64": "0.127.0", + "@oxc-parser/binding-linux-arm-gnueabihf": "0.127.0", + "@oxc-parser/binding-linux-arm-musleabihf": "0.127.0", + "@oxc-parser/binding-linux-arm64-gnu": "0.127.0", + "@oxc-parser/binding-linux-arm64-musl": "0.127.0", + "@oxc-parser/binding-linux-ppc64-gnu": "0.127.0", + "@oxc-parser/binding-linux-riscv64-gnu": "0.127.0", + "@oxc-parser/binding-linux-riscv64-musl": "0.127.0", + "@oxc-parser/binding-linux-s390x-gnu": "0.127.0", + "@oxc-parser/binding-linux-x64-gnu": "0.127.0", + "@oxc-parser/binding-linux-x64-musl": "0.127.0", + "@oxc-parser/binding-openharmony-arm64": "0.127.0", + "@oxc-parser/binding-wasm32-wasi": "0.127.0", + "@oxc-parser/binding-win32-arm64-msvc": "0.127.0", + "@oxc-parser/binding-win32-ia32-msvc": "0.127.0", + "@oxc-parser/binding-win32-x64-msvc": "0.127.0" + } + }, + "node_modules/oxc-resolver": { + "version": "11.20.0", + "resolved": "https://registry.npmjs.org/oxc-resolver/-/oxc-resolver-11.20.0.tgz", + "integrity": "sha512-CblytBiV/a/ZXY34dsVU2NxhIOxMXst8CvDCtyBelVITgd7PLrKzbEbA6oKLdPjvDKDzCiW48qzmzZ+mYaqn+g==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + }, + "optionalDependencies": { + "@oxc-resolver/binding-android-arm-eabi": "11.20.0", + "@oxc-resolver/binding-android-arm64": "11.20.0", + "@oxc-resolver/binding-darwin-arm64": "11.20.0", + "@oxc-resolver/binding-darwin-x64": "11.20.0", + "@oxc-resolver/binding-freebsd-x64": "11.20.0", + "@oxc-resolver/binding-linux-arm-gnueabihf": "11.20.0", + "@oxc-resolver/binding-linux-arm-musleabihf": "11.20.0", + "@oxc-resolver/binding-linux-arm64-gnu": "11.20.0", + "@oxc-resolver/binding-linux-arm64-musl": "11.20.0", + "@oxc-resolver/binding-linux-ppc64-gnu": "11.20.0", + "@oxc-resolver/binding-linux-riscv64-gnu": "11.20.0", + "@oxc-resolver/binding-linux-riscv64-musl": "11.20.0", + "@oxc-resolver/binding-linux-s390x-gnu": "11.20.0", + "@oxc-resolver/binding-linux-x64-gnu": "11.20.0", + "@oxc-resolver/binding-linux-x64-musl": "11.20.0", + "@oxc-resolver/binding-openharmony-arm64": "11.20.0", + "@oxc-resolver/binding-wasm32-wasi": "11.20.0", + "@oxc-resolver/binding-win32-arm64-msvc": "11.20.0", + "@oxc-resolver/binding-win32-x64-msvc": "11.20.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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "dev": true, + "license": "BlueOak-1.0.0" + }, + "node_modules/package-manager-detector": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.6.0.tgz", + "integrity": "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse5": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz", + "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "entities": "^6.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-data-parser": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/path-data-parser/-/path-data-parser-0.1.0.tgz", + "integrity": "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-to-regexp": { + "version": "8.4.2", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz", + "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/pdfjs-dist": { + "version": "5.4.54", + "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-5.4.54.tgz", + "integrity": "sha512-TBAiTfQw89gU/Z4LW98Vahzd2/LoCFprVGvGbTgFt+QCB1F+woyOPmNNVgLa6djX9Z9GGTnj7qE1UzpOVJiINw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=20.16.0 || >=22.3.0" + }, + "optionalDependencies": { + "@napi-rs/canvas": "^0.1.74" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz", + "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/picoquery": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/picoquery/-/picoquery-2.5.0.tgz", + "integrity": "sha512-j1kgOFxtaCyoFCkpoYG2Oj3OdGakadO7HZ7o5CqyRazlmBekKhbDoUnNnXASE07xSY4nDImWZkrZv7toSxMi/g==", + "dev": true, + "license": "MIT" + }, + "node_modules/pkce-challenge": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz", + "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/playwright": { + "version": "1.56.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.56.1.tgz", + "integrity": "sha512-aFi5B0WovBHTEvpM3DzXTUaeN6eN0qWnTkKx4NQaH4Wvcmc153PdaY2UBdSYKaGYw+UyWXSVyxDUg5DoPEttjw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.56.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "fsevents": "2.3.2" + } + }, + "node_modules/playwright-core": { + "version": "1.56.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.56.1.tgz", + "integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/pngjs": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz", + "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.19.0" + } + }, + "node_modules/points-on-curve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/points-on-curve/-/points-on-curve-0.2.0.tgz", + "integrity": "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==", + "dev": true, + "license": "MIT" + }, + "node_modules/points-on-path": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/points-on-path/-/points-on-path-0.2.1.tgz", + "integrity": "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-data-parser": "0.1.0", + "points-on-curve": "0.2.0" + } + }, + "node_modules/portfinder": { + "version": "1.0.38", + "resolved": "https://registry.npmjs.org/portfinder/-/portfinder-1.0.38.tgz", + "integrity": "sha512-rEwq/ZHlJIKw++XtLAO8PPuOQA/zaPJOZJ37BVuN97nLpMJeuDVLVGRwbFoBgLudgdTMP2hdRJP++H+8QOA3vg==", + "dev": true, + "license": "MIT", + "dependencies": { + "async": "^3.2.6", + "debug": "^4.3.6" + }, + "engines": { + "node": ">= 10.12" + } + }, + "node_modules/possible-typed-array-names": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", + "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/postcss": { + "version": "8.5.25", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.25.tgz", + "integrity": "sha512-DTPx3RWSSnWyzLxQnlH0rJP+EW5ekl16ZU4/psbIhA0e53kJfdgaN5vKM+xP7yJtXVu+nfdVFmlgFDEKAe4Pyw==", + "dev": true, + "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" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.16", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "lilconfig": "^2.0.5", + "yaml": "^1.10.2" + }, + "engines": { + "node": ">= 10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": ">=8.0.9", + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "postcss": { + "optional": true + }, + "ts-node": { + "optional": true + } + } + }, + "node_modules/postcss-load-config/node_modules/yaml": { + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz", + "integrity": "sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">= 6" + } + }, + "node_modules/postcss-safe-parser": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/postcss-safe-parser/-/postcss-safe-parser-7.0.1.tgz", + "integrity": "sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss-safe-parser" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-scss": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/postcss-scss/-/postcss-scss-4.0.9.tgz", + "integrity": "sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss-scss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "engines": { + "node": ">=12.0" + }, + "peerDependencies": { + "postcss": "^8.4.29" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.0.10", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz", + "integrity": "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prettier": { + "version": "3.8.3", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.3.tgz", + "integrity": "sha512-7igPTM53cGHMW8xWuVTydi2KO233VFiTNyF5hLJqpilHfmn8C8gPf+PS7dUT64YcXFbiMGZxS9pCSxL/Dxm/Jw==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/prettier-plugin-svelte": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/prettier-plugin-svelte/-/prettier-plugin-svelte-4.1.0.tgz", + "integrity": "sha512-YZkhA2Q9oOerFFG9tq+2f98WYT7Z2JgrybJrAyrB78jpsH9i/DdgplXemehuFPgsldetFNCcR/yCcYlDjPy94Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "peerDependencies": { + "prettier": "^3.0.0", + "svelte": "^5.0.0" + } + }, + "node_modules/prettier-plugin-tailwindcss": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/prettier-plugin-tailwindcss/-/prettier-plugin-tailwindcss-0.8.0.tgz", + "integrity": "sha512-V8ITGH87yuBDF6JpEZTOVlUz/saAwqb8f3HRgUj8Lh+tGCcrmorhsLpYqzygwFwK0PE2Ib6Mv3M7T/uE2tZV1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.19" + }, + "peerDependencies": { + "@ianvs/prettier-plugin-sort-imports": "*", + "@prettier/plugin-hermes": "*", + "@prettier/plugin-oxc": "*", + "@prettier/plugin-pug": "*", + "@shopify/prettier-plugin-liquid": "*", + "@trivago/prettier-plugin-sort-imports": "*", + "@zackad/prettier-plugin-twig": "*", + "prettier": "^3.0", + "prettier-plugin-astro": "*", + "prettier-plugin-css-order": "*", + "prettier-plugin-jsdoc": "*", + "prettier-plugin-marko": "*", + "prettier-plugin-multiline-arrays": "*", + "prettier-plugin-organize-attributes": "*", + "prettier-plugin-organize-imports": "*", + "prettier-plugin-sort-imports": "*", + "prettier-plugin-svelte": "*" + }, + "peerDependenciesMeta": { + "@ianvs/prettier-plugin-sort-imports": { + "optional": true + }, + "@prettier/plugin-hermes": { + "optional": true + }, + "@prettier/plugin-oxc": { + "optional": true + }, + "@prettier/plugin-pug": { + "optional": true + }, + "@shopify/prettier-plugin-liquid": { + "optional": true + }, + "@trivago/prettier-plugin-sort-imports": { + "optional": true + }, + "@zackad/prettier-plugin-twig": { + "optional": true + }, + "prettier-plugin-astro": { + "optional": true + }, + "prettier-plugin-css-order": { + "optional": true + }, + "prettier-plugin-jsdoc": { + "optional": true + }, + "prettier-plugin-marko": { + "optional": true + }, + "prettier-plugin-multiline-arrays": { + "optional": true + }, + "prettier-plugin-organize-attributes": { + "optional": true + }, + "prettier-plugin-organize-imports": { + "optional": true + }, + "prettier-plugin-sort-imports": { + "optional": true + }, + "prettier-plugin-svelte": { + "optional": true + } + } + }, + "node_modules/pretty-bytes": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-6.1.1.tgz", + "integrity": "sha512-mQUvGU6aUFQ+rNvTIAcZuWGRT9a6f6Yrg9bHs4ImKF+HZCEK+plBvnAZYSIQztknZF2qnzNtr6F8s0+IuptdlQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pretty-format": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz", + "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^17.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/prism-svelte": { + "version": "0.4.7", + "resolved": "https://registry.npmjs.org/prism-svelte/-/prism-svelte-0.4.7.tgz", + "integrity": "sha512-yABh19CYbM24V7aS7TuPYRNMqthxwbvx6FF/Rw920YbyBWO3tnyPIqRMgHuSVsLmuHkkBS1Akyof463FVdkeDQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/prismjs": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz", + "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/property-information": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz", + "integrity": "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/qs": { + "version": "6.15.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz", + "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/quansync": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/quansync/-/quansync-1.0.0.tgz", + "integrity": "sha512-5xZacEEufv3HSTPQuchrvV6soaiACMFnq1H8wkVioctoH3TRha9Sz66lOxRwPK/qZj7HPiSveih9yAyh98gvqA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/antfu" + }, + { + "type": "individual", + "url": "https://github.com/sponsors/sxzz" + } + ], + "license": "MIT" + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", + "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.7.0", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/react": { + "version": "19.2.7", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz", + "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.7", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz", + "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.7" + } + }, + "node_modules/react-is": { + "version": "17.0.2", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", + "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==", + "dev": true, + "license": "MIT" + }, + "node_modules/readdirp": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-5.0.0.tgz", + "integrity": "sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 20.19.0" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "node_modules/redent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz", + "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "indent-string": "^4.0.0", + "strip-indent": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/reflect.getprototypeof": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz", + "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.7", + "get-proto": "^1.0.1", + "which-builtin-type": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regenerate": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/regenerate-unicode-properties": { + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz", + "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz", + "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-errors": "^1.3.0", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "set-function-name": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regexpu-core": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz", + "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==", + "dev": true, + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.2.2", + "regjsgen": "^0.8.0", + "regjsparser": "^0.13.0", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.2.1" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/regjsparser": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.1.tgz", + "integrity": "sha512-dLsljMd9sqwRkby8zhO1gSg3PnJIBFid8f4CQj/sXx+7cKx+E7u0PKhZ+U4wmhx7EfmtvnA318oVaIkAB1lRJw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~3.1.0" + }, + "bin": { + "regjsparser": "bin/parser" + } + }, + "node_modules/rehype-highlight": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/rehype-highlight/-/rehype-highlight-7.0.2.tgz", + "integrity": "sha512-k158pK7wdC2qL3M5NcZROZ2tR/l7zOzjxXd5VGdcfIyoijjQqpHd3JKtYSBDpDZ38UI2WJWuFAtkMDxmx5kstA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-to-text": "^4.0.0", + "lowlight": "^3.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/rehype-katex": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/rehype-katex/-/rehype-katex-7.0.1.tgz", + "integrity": "sha512-OiM2wrZ/wuhKkigASodFoo8wimG3H12LWQaH8qSPVJn9apWKFSH3YOCtbKpBorTVw/eI7cuT21XBbvwEswbIOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/katex": "^0.16.0", + "hast-util-from-html-isomorphic": "^2.0.0", + "hast-util-to-text": "^4.0.0", + "katex": "^0.16.0", + "unist-util-visit-parents": "^6.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/rehype-stringify": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-10.0.1.tgz", + "integrity": "sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-to-html": "^9.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark": { + "version": "15.0.1", + "resolved": "https://registry.npmjs.org/remark/-/remark-15.0.1.tgz", + "integrity": "sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "remark-parse": "^11.0.0", + "remark-stringify": "^11.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-breaks": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/remark-breaks/-/remark-breaks-4.0.0.tgz", + "integrity": "sha512-IjEjJOkH4FuJvHZVIW0QCDWxcG96kCq7An/KVH2NfJe6rKZU2AsHeB3OEjPNRxi4QC34Xdx7I2KGYn6IpT7gxQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-newline-to-break": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-gfm": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz", + "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-gfm": "^3.0.0", + "micromark-extension-gfm": "^3.0.0", + "remark-parse": "^11.0.0", + "remark-stringify": "^11.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-html": { + "version": "16.0.1", + "resolved": "https://registry.npmjs.org/remark-html/-/remark-html-16.0.1.tgz", + "integrity": "sha512-B9JqA5i0qZe0Nsf49q3OXyGvyXuZFDzAP2iOFLEumymuYJITVpiH1IgsTEwTpdptDmZlMDMWeDmSawdaJIGCXQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "hast-util-sanitize": "^5.0.0", + "hast-util-to-html": "^9.0.0", + "mdast-util-to-hast": "^13.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-math": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/remark-math/-/remark-math-6.0.0.tgz", + "integrity": "sha512-MMqgnP74Igy+S3WwnhQ7kqGlEerTETXMvJhrUzDikVZ2/uogJCb+WHUg97hK9/jcfc0dkD73s3LN8zU49cTEtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-math": "^3.0.0", + "micromark-extension-math": "^3.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-parse": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz", + "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-rehype": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz", + "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "mdast-util-to-hast": "^13.0.0", + "unified": "^11.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-stringify": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz", + "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-to-markdown": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/resolve": { + "version": "1.22.12", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz", + "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/robust-predicates": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.3.tgz", + "integrity": "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA==", + "dev": true, + "license": "Unlicense" + }, + "node_modules/rollup": { + "version": "4.61.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.61.1.tgz", + "integrity": "sha512-I4KW6iuRpuu2uHBLraZ1wNZe0DP7lnRha+VJ9tNaYVaVgKhW0aI3h4RYnoRPeql0flHm/Co55b7snEDcOfOJrA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.9" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.61.1", + "@rollup/rollup-android-arm64": "4.61.1", + "@rollup/rollup-darwin-arm64": "4.61.1", + "@rollup/rollup-darwin-x64": "4.61.1", + "@rollup/rollup-freebsd-arm64": "4.61.1", + "@rollup/rollup-freebsd-x64": "4.61.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.61.1", + "@rollup/rollup-linux-arm-musleabihf": "4.61.1", + "@rollup/rollup-linux-arm64-gnu": "4.61.1", + "@rollup/rollup-linux-arm64-musl": "4.61.1", + "@rollup/rollup-linux-loong64-gnu": "4.61.1", + "@rollup/rollup-linux-loong64-musl": "4.61.1", + "@rollup/rollup-linux-ppc64-gnu": "4.61.1", + "@rollup/rollup-linux-ppc64-musl": "4.61.1", + "@rollup/rollup-linux-riscv64-gnu": "4.61.1", + "@rollup/rollup-linux-riscv64-musl": "4.61.1", + "@rollup/rollup-linux-s390x-gnu": "4.61.1", + "@rollup/rollup-linux-x64-gnu": "4.61.1", + "@rollup/rollup-linux-x64-musl": "4.61.1", + "@rollup/rollup-openbsd-x64": "4.61.1", + "@rollup/rollup-openharmony-arm64": "4.61.1", + "@rollup/rollup-win32-arm64-msvc": "4.61.1", + "@rollup/rollup-win32-ia32-msvc": "4.61.1", + "@rollup/rollup-win32-x64-gnu": "4.61.1", + "@rollup/rollup-win32-x64-msvc": "4.61.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/roughjs": { + "version": "4.6.6", + "resolved": "https://registry.npmjs.org/roughjs/-/roughjs-4.6.6.tgz", + "integrity": "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "hachure-fill": "^0.5.2", + "path-data-parser": "^0.1.0", + "points-on-curve": "^0.2.0", + "points-on-path": "^0.2.1" + } + }, + "node_modules/router": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", + "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "depd": "^2.0.0", + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/runed": { + "version": "0.35.1", + "resolved": "https://registry.npmjs.org/runed/-/runed-0.35.1.tgz", + "integrity": "sha512-2F4Q/FZzbeJTFdIS/PuOoPRSm92sA2LhzTnv6FXhCoENb3huf5+fDuNOg1LNvGOouy3u/225qxmuJvcV3IZK5Q==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte", + "https://github.com/sponsors/tglide" + ], + "license": "MIT", + "dependencies": { + "dequal": "^2.0.3", + "esm-env": "^1.0.0", + "lz-string": "^1.5.0" + }, + "peerDependencies": { + "@sveltejs/kit": "^2.21.0", + "svelte": "^5.7.0" + }, + "peerDependenciesMeta": { + "@sveltejs/kit": { + "optional": true + } + } + }, + "node_modules/rw": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz", + "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/sade": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz", + "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "mri": "^1.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/safe-array-concat": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.4.tgz", + "integrity": "sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "get-intrinsic": "^1.3.0", + "has-symbols": "^1.1.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true, + "license": "MIT" + }, + "node_modules/safe-push-apply": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz", + "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-regex-test": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-regex": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true, + "license": "MIT" + }, + "node_modules/sass": { + "version": "1.100.0", + "resolved": "https://registry.npmjs.org/sass/-/sass-1.100.0.tgz", + "integrity": "sha512-B5j0rYMlinhhOo9tjQebMVVn0TfyXAF+wB3b2ggZUuJ/is/Y+7+JGjirAMxHZ9Z3hIP98NPfamlAkBHa1lAaXQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "chokidar": "^5.0.0", + "immutable": "^5.1.5", + "source-map-js": ">=0.6.2 <2.0.0" + }, + "bin": { + "sass": "sass.js" + }, + "engines": { + "node": ">=20.19.0" + }, + "optionalDependencies": { + "@parcel/watcher": "^2.4.1" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/scule": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/scule/-/scule-1.3.0.tgz", + "integrity": "sha512-6FtHJEvt+pVMIB9IBY+IcCJ6Z5f1iQnytgyfKMhDKgmzYG+TeH/wx1y3l27rshSbLiSanrR9ffZDrEsmjlQF2g==", + "dev": true, + "license": "MIT" + }, + "node_modules/secure-compare": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/secure-compare/-/secure-compare-3.0.1.tgz", + "integrity": "sha512-AckIIV90rPDcBcglUwXPF3kg0P0qmPsPXAj6BBEENQE1p5yA1xfmDJzfi1Tappj37Pv2mVbKpL3Z1T+Nn7k1Qw==", + "dev": true, + "license": "MIT" + }, + "node_modules/semver": { + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/send": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz", + "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.4.3", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^2.0.0", + "http-errors": "^2.0.1", + "mime-types": "^3.0.2", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/serialize-javascript": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-7.0.5.tgz", + "integrity": "sha512-F4LcB0UqUl1zErq+1nYEEzSHJnIwb3AF2XWB94b+afhrekOUijwooAYqFyRbjYkm2PAKBabx6oYv/xDxNi8IBw==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/serve-static": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz", + "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==", + "dev": true, + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.2.0" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/set-cookie-parser": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-3.1.0.tgz", + "integrity": "sha512-kjnC1DXBHcxaOaOXBHBeRtltsDG2nUiUni+jP92M9gYdW12rsmx92UsfpH7o5tDRs7I1ZZPSQJQGv3UaRfCiuw==", + "dev": true, + "license": "MIT" + }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-function-name": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz", + "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-proto": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz", + "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "dev": true, + "license": "ISC" + }, + "node_modules/sharp": { + "version": "0.35.3", + "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.3.tgz", + "integrity": "sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@img/colour": "^1.1.0", + "detect-libc": "^2.1.2", + "semver": "^7.8.5" + }, + "engines": { + "node": ">=20.9.0" + }, + "funding": { + "url": "https://opencollective.com/libvips" + }, + "optionalDependencies": { + "@img/sharp-darwin-arm64": "0.35.3", + "@img/sharp-darwin-x64": "0.35.3", + "@img/sharp-freebsd-wasm32": "0.35.3", + "@img/sharp-libvips-darwin-arm64": "1.3.2", + "@img/sharp-libvips-darwin-x64": "1.3.2", + "@img/sharp-libvips-linux-arm": "1.3.2", + "@img/sharp-libvips-linux-arm64": "1.3.2", + "@img/sharp-libvips-linux-ppc64": "1.3.2", + "@img/sharp-libvips-linux-riscv64": "1.3.2", + "@img/sharp-libvips-linux-s390x": "1.3.2", + "@img/sharp-libvips-linux-x64": "1.3.2", + "@img/sharp-libvips-linuxmusl-arm64": "1.3.2", + "@img/sharp-libvips-linuxmusl-x64": "1.3.2", + "@img/sharp-linux-arm": "0.35.3", + "@img/sharp-linux-arm64": "0.35.3", + "@img/sharp-linux-ppc64": "0.35.3", + "@img/sharp-linux-riscv64": "0.35.3", + "@img/sharp-linux-s390x": "0.35.3", + "@img/sharp-linux-x64": "0.35.3", + "@img/sharp-linuxmusl-arm64": "0.35.3", + "@img/sharp-linuxmusl-x64": "0.35.3", + "@img/sharp-webcontainers-wasm32": "0.35.3", + "@img/sharp-win32-arm64": "0.35.3", + "@img/sharp-win32-ia32": "0.35.3", + "@img/sharp-win32-x64": "0.35.3" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/sharp-ico": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/sharp-ico/-/sharp-ico-0.1.5.tgz", + "integrity": "sha512-a3jODQl82NPp1d5OYb0wY+oFaPk7AvyxipIowCHk7pBsZCWgbe0yAkU2OOXdoH0ENyANhyOQbs9xkAiRHcF02Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "decode-ico": "*", + "ico-endec": "*", + "sharp": "*" + } + }, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz", + "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/sirv": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz", + "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@polka/url": "^1.0.0-next.24", + "mrmime": "^2.0.0", + "totalist": "^3.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/smob": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/smob/-/smob-1.6.2.tgz", + "integrity": "sha512-RQsvleCbF8cVHEv+xuDGaA4pOizFqJ0GgjtMSRo6oP8pnN7WsigHgVGey6aILRBKv4W2YOMHLqbKdnB6hpB9fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/sqids": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/sqids/-/sqids-0.3.0.tgz", + "integrity": "sha512-lOQK1ucVg+W6n3FhRwwSeUijxe93b51Bfz5PMRMihVf1iVkl82ePQG7V5vwrhzB11v0NtsR25PSZRGiSomJaJw==", + "dev": true, + "license": "MIT" + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/std-env": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.1.0.tgz", + "integrity": "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/stop-iteration-iterator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz", + "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "internal-slot": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/storybook": { + "version": "10.5.6", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.5.6.tgz", + "integrity": "sha512-VhYwqxPySa24CVXKoWD6gCZXx9//DTmo43YpusGuAoHDYj5Osjt8wuBRQVeGoaLUWnHiPWv8S+GYHrJEaBM6Rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.2", + "@testing-library/dom": "^10.4.1", + "@testing-library/jest-dom": "6.9.1", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "@webcontainer/env": "^1.1.1", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0 || ^0.28.0", + "jsonc-parser": "^3.3.1", + "open": "^10.2.0", + "oxc-parser": "^0.127.0", + "oxc-resolver": "^11.19.1", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.21.1" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "prettier": "^2 || ^3", + "vite-plus": "^0.1.15 || ^0.2.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "prettier": { + "optional": true + }, + "vite-plus": { + "optional": true + } + } + }, + "node_modules/storybook/node_modules/@vitest/spy": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz", + "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/string.prototype.matchall": { + "version": "4.0.12", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz", + "integrity": "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.6", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.6", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "internal-slot": "^1.1.0", + "regexp.prototype.flags": "^1.5.3", + "set-function-name": "^2.0.2", + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", + "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-data-property": "^1.1.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-object-atoms": "^1.0.0", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", + "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", + "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/stringify-entities": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz", + "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==", + "dev": true, + "license": "MIT", + "dependencies": { + "character-entities-html4": "^2.0.0", + "character-entities-legacy": "^3.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/stringify-object": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz", + "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "get-own-enumerable-property-symbols": "^3.0.0", + "is-obj": "^1.0.1", + "is-regexp": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-ansi": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.2.2" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-ansi/node_modules/ansi-regex": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/strip-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz", + "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/strip-indent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz", + "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "min-indent": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/style-to-object": { + "version": "1.0.14", + "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz", + "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==", + "dev": true, + "license": "MIT", + "dependencies": { + "inline-style-parser": "0.2.7" + } + }, + "node_modules/stylis": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.4.0.tgz", + "integrity": "sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/svelte": { + "version": "5.56.1", + "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.56.1.tgz", + "integrity": "sha512-eArsJmvl3xZVuTYD852PzIEdg2wgDdIZ1NEsIPbzAukHwi284B18No4nK2rCO9AwsWUDza4Cjvmoa4HaojTl5g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/remapping": "^2.3.4", + "@jridgewell/sourcemap-codec": "^1.5.0", + "@sveltejs/acorn-typescript": "^1.0.10", + "@types/estree": "^1.0.5", + "@types/trusted-types": "^2.0.7", + "acorn": "^8.12.1", + "aria-query": "5.3.1", + "axobject-query": "^4.1.0", + "clsx": "^2.1.1", + "devalue": "^5.8.1", + "esm-env": "^1.2.1", + "esrap": "^2.2.9", + "is-reference": "^3.0.3", + "locate-character": "^3.0.0", + "magic-string": "^0.30.11", + "zimmerframe": "^1.1.2" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/svelte-ast-print": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/svelte-ast-print/-/svelte-ast-print-0.4.2.tgz", + "integrity": "sha512-hRHHufbJoArFmDYQKCpCvc0xUuIEfwYksvyLYEQyH+1xb5LD5sM/IthfooCdXZQtOIqXz6xm7NmaqdfwG4kh6w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/xeho91" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/xeho91" + } + ], + "license": "MIT", + "dependencies": { + "esrap": "1.2.2", + "zimmerframe": "1.1.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "svelte": "^5.0.0" + } + }, + "node_modules/svelte-ast-print/node_modules/esrap": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/esrap/-/esrap-1.2.2.tgz", + "integrity": "sha512-F2pSJklxx1BlQIQgooczXCPHmcWpn6EsP5oo73LQfonG9fIlIENQ8vMmfGXeojP9MrkzUNAfyU5vdFlR9shHAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.4.15", + "@types/estree": "^1.0.1" + } + }, + "node_modules/svelte-ast-print/node_modules/zimmerframe": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.2.tgz", + "integrity": "sha512-rAbqEGa8ovJy4pyBxZM70hg4pE6gDgaQ0Sl9M3enG3I0d6H4XSAM3GeNGLKnsBpuijUow064sf7ww1nutC5/3w==", + "dev": true, + "license": "MIT" + }, + "node_modules/svelte-check": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.6.0.tgz", + "integrity": "sha512-KhVnDFDSid57mmZtHz8gfW8AAGylOZ0vPnOIzVmAL+urzwK8sBYXRss953gD8T0OdgAQ11mdWhE6uadmtOz8TQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.25", + "@sveltejs/load-config": "0.1.1", + "chokidar": "^4.0.1", + "fdir": "^6.2.0", + "picocolors": "^1.0.0", + "sade": "^1.7.4" + }, + "bin": { + "svelte-check": "bin/svelte-check" + }, + "engines": { + "node": ">= 18.0.0" + }, + "peerDependencies": { + "svelte": "^4.0.0 || ^5.0.0-next.0", + "typescript": ">=5.0.0" + } + }, + "node_modules/svelte-check/node_modules/chokidar": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", + "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "readdirp": "^4.0.1" + }, + "engines": { + "node": ">= 14.16.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/svelte-check/node_modules/readdirp": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", + "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.18.0" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/svelte-eslint-parser": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/svelte-eslint-parser/-/svelte-eslint-parser-1.8.0.tgz", + "integrity": "sha512-mikR1qwIVy3t5WthUoAXkMwxkXvabZP9FJgdx35Ei7EbGWmctva1Pih16Koeor/bdNNq8NXHlwKGS6NkYTawLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-scope": "^8.2.0", + "eslint-visitor-keys": "^4.0.0", + "espree": "^10.0.0", + "postcss": "^8.4.49", + "postcss-scss": "^4.0.9", + "postcss-selector-parser": "^7.0.0", + "semver": "^7.7.2" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0", + "pnpm": "10.34.1" + }, + "funding": { + "url": "https://github.com/sponsors/ota-meshi" + }, + "peerDependencies": { + "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "svelte": { + "optional": true + } + } + }, + "node_modules/svelte-eslint-parser/node_modules/postcss-selector-parser": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/svelte-sonner": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/svelte-sonner/-/svelte-sonner-1.1.1.tgz", + "integrity": "sha512-5cd3p7wa4cq0NsqslMwdlPb7x1JglEZ/GKrLePWNr5bCxR1nagAVrY01FRFrXfUGs41miLt3C327+8XJo5BzZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "runed": "^0.28.0" + }, + "peerDependencies": { + "svelte": "^5.0.0" + } + }, + "node_modules/svelte-sonner/node_modules/runed": { + "version": "0.28.0", + "resolved": "https://registry.npmjs.org/runed/-/runed-0.28.0.tgz", + "integrity": "sha512-k2xx7RuO9hWcdd9f+8JoBeqWtYrm5CALfgpkg2YDB80ds/QE4w0qqu34A7fqiAwiBBSBQOid7TLxwxVC27ymWQ==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte", + "https://github.com/sponsors/tglide" + ], + "license": "MIT", + "dependencies": { + "esm-env": "^1.0.0" + }, + "peerDependencies": { + "svelte": "^5.7.0" + } + }, + "node_modules/svelte-toolbelt": { + "version": "0.10.6", + "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.10.6.tgz", + "integrity": "sha512-YWuX+RE+CnWYx09yseAe4ZVMM7e7GRFZM6OYWpBKOb++s+SQ8RBIMMe+Bs/CznBMc0QPLjr+vDBxTAkozXsFXQ==", + "dev": true, + "funding": [ + "https://github.com/sponsors/huntabyte" + ], + "dependencies": { + "clsx": "^2.1.1", + "runed": "^0.35.1", + "style-to-object": "^1.0.8" + }, + "engines": { + "node": ">=18", + "pnpm": ">=8.7.0" + }, + "peerDependencies": { + "svelte": "^5.30.2" + } + }, + "node_modules/svelte/node_modules/aria-query": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.1.tgz", + "integrity": "sha512-Z/ZeOgVl7bcSYZ/u/rh0fOpvEpq//LZmdbkXyc7syVzjPAhfOa9ebsdTSjEBDU4vs5nC98Kfduj1uFo0qyET3g==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/svelte/node_modules/esrap": { + "version": "2.2.11", + "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.11.tgz", + "integrity": "sha512-gPdx+I+BjYEinNMQaBXFjbaJVyoPMU4ZODg5mE+M4DqVG9VusAVHHjcBX+zqyITlI0DIARwDMMzZwAWj36dRoQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.4.15" + }, + "peerDependencies": { + "@typescript-eslint/types": "^8.2.0" + }, + "peerDependenciesMeta": { + "@typescript-eslint/types": { + "optional": true + } + } + }, + "node_modules/svelte2tsx": { + "version": "0.7.59", + "resolved": "https://registry.npmjs.org/svelte2tsx/-/svelte2tsx-0.7.59.tgz", + "integrity": "sha512-Itj7Wz9WIiGFl/uJa58+rf43ajezaljKK/KTOHq5abUjto56xe+o5SOzLwSoeJ5hma9NZEstpZiazFW2q1nZPQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "dedent-js": "^1.0.1", + "scule": "^1.3.0" + }, + "peerDependencies": { + "svelte": "^3.55 || ^4.0.0-next.0 || ^4.0 || ^5.0.0-next.0", + "typescript": "^4.9.4 || ^5.0.0 || ^6.0.0" + } + }, + "node_modules/tabbable": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", + "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tagged-tag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz", + "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/tailwind-merge": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.6.0.tgz", + "integrity": "sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/dcastil" + } + }, + "node_modules/tailwind-variants": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/tailwind-variants/-/tailwind-variants-3.2.2.tgz", + "integrity": "sha512-Mi4kHeMTLvKlM98XPnK+7HoBPmf4gygdFmqQPaDivc3DpYS6aIY6KiG/PgThrGvii5YZJqRsPz0aPyhoFzmZgg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16.x", + "pnpm": ">=7.x" + }, + "peerDependencies": { + "tailwind-merge": ">=3.0.0", + "tailwindcss": "*" + }, + "peerDependenciesMeta": { + "tailwind-merge": { + "optional": true + } + } + }, + "node_modules/tailwindcss": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.3.0.tgz", + "integrity": "sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/tapable": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz", + "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/tar": { + "version": "7.5.22", + "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.22.tgz", + "integrity": "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/fs-minipass": "^4.0.0", + "chownr": "^3.0.0", + "minipass": "^7.1.2", + "minizlib": "^3.1.0", + "yallist": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/tar/node_modules/yallist": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz", + "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/temp-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz", + "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/tempy": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz", + "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-stream": "^2.0.0", + "temp-dir": "^2.0.0", + "type-fest": "^0.16.0", + "unique-string": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/tempy/node_modules/type-fest": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz", + "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terser": { + "version": "5.48.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.48.0.tgz", + "integrity": "sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.15.0", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz", + "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinyrainbow": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz", + "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz", + "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tmcp": { + "version": "1.19.4", + "resolved": "https://registry.npmjs.org/tmcp/-/tmcp-1.19.4.tgz", + "integrity": "sha512-fMoUJ3Gef9iA0yKZNeW2SQCCKTluCwghUyOz/qxPS8XxrQk6Jlw4lgql3S+s6L//FteLeSJ7erKxMWl727mZoQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "json-rpc-2.0": "^1.7.1", + "sqids": "^0.3.0", + "uri-template-matcher": "^1.1.1", + "valibot": "^1.1.0" + } + }, + "node_modules/to-data-view": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/to-data-view/-/to-data-view-1.1.0.tgz", + "integrity": "sha512-1eAdufMg6mwgmlojAx3QeMnzB/BTVp7Tbndi3U7ftcT2zCZadjxkkmLmd97zmaxWi+sgGcgWrokmpEoy0Dn0vQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/totalist": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", + "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/tr46": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz", + "integrity": "sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/trim-lines": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz", + "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/trough": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz", + "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/ts-api-utils": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz", + "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.12" + }, + "peerDependencies": { + "typescript": ">=4.8.4" + } + }, + "node_modules/ts-dedent": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz", + "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.10" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD" + }, + "node_modules/tw-animate-css": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/tw-animate-css/-/tw-animate-css-1.4.0.tgz", + "integrity": "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Wombosvideo" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "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==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/type-is": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz", + "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==", + "dev": true, + "license": "MIT", + "dependencies": { + "content-type": "^2.0.0", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/type-is/node_modules/content-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz", + "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/typed-array-byte-length": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", + "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "for-each": "^0.3.3", + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-byte-offset": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", + "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "for-each": "^0.3.3", + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.15", + "reflect.getprototypeof": "^1.0.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.8.tgz", + "integrity": "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.9", + "for-each": "^0.3.5", + "gopd": "^1.2.0", + "is-typed-array": "^1.1.15", + "possible-typed-array-names": "^1.1.0", + "reflect.getprototypeof": "^1.0.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/typescript-eslint": { + "version": "8.60.1", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.1.tgz", + "integrity": "sha512-6m5hkkRAp8lKvhVpcprAIn5KkehQEh+47oHH2VGnExEh7dhNxXlg6GPAOIu6TxbVQxhebrJDvjl3020ooiWCMA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/eslint-plugin": "8.60.1", + "@typescript-eslint/parser": "8.60.1", + "@typescript-eslint/typescript-estree": "8.60.1", + "@typescript-eslint/utils": "8.60.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0" + } + }, + "node_modules/unbox-primitive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-bigints": "^1.0.2", + "has-symbols": "^1.1.0", + "which-boxed-primitive": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/unconfig": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/unconfig/-/unconfig-7.5.0.tgz", + "integrity": "sha512-oi8Qy2JV4D3UQ0PsopR28CzdQ3S/5A1zwsUwp/rosSbfhJ5z7b90bIyTwi/F7hCLD4SGcZVjDzd4XoUQcEanvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@quansync/fs": "^1.0.0", + "defu": "^6.1.4", + "jiti": "^2.6.1", + "quansync": "^1.0.0", + "unconfig-core": "7.5.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/unconfig-core": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/unconfig-core/-/unconfig-core-7.5.0.tgz", + "integrity": "sha512-Su3FauozOGP44ZmKdHy2oE6LPjk51M/TRRjHv2HNCWiDvfvCoxC2lno6jevMA91MYAdCdwP05QnWdWpSbncX/w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@quansync/fs": "^1.0.0", + "quansync": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/undici-types": { + "version": "7.18.2", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz", + "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", + "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-value-ecmascript": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz", + "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-property-aliases-ecmascript": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz", + "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unified": { + "version": "11.0.5", + "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz", + "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "bail": "^2.0.0", + "devlop": "^1.0.0", + "extend": "^3.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unified/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/union": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/union/-/union-0.5.0.tgz", + "integrity": "sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==", + "dev": true, + "dependencies": { + "qs": "^6.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/unique-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", + "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "crypto-random-string": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/unist-util-find-after": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz", + "integrity": "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-find-after/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-is/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-position": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", + "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-remove-position": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-5.0.0.tgz", + "integrity": "sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-visit": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-remove-position/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-stringify-position": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz", + "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-visit": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz", + "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit-parents": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz", + "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit-parents/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/unist-util-visit/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/unplugin": { + "version": "2.3.11", + "resolved": "https://registry.npmjs.org/unplugin/-/unplugin-2.3.11.tgz", + "integrity": "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/remapping": "^2.3.5", + "acorn": "^8.15.0", + "picomatch": "^4.0.3", + "webpack-virtual-modules": "^0.6.2" + }, + "engines": { + "node": ">=18.12.0" + } + }, + "node_modules/upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4", + "yarn": "*" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "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" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "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==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/uri-template-matcher": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/uri-template-matcher/-/uri-template-matcher-1.1.2.tgz", + "integrity": "sha512-uZc1h12jdO3m/R77SfTEOuo6VbMhgWznaawKpBjRGSJb7i91x5PgI37NQJtG+Cerxkk0yr1pylBY2qG1kQ+aEQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/url-join": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/url-join/-/url-join-4.0.1.tgz", + "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==", + "dev": true, + "license": "MIT" + }, + "node_modules/use-sync-external-store": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz", + "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true, + "license": "MIT" + }, + "node_modules/uuid": { + "version": "13.0.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-13.0.2.tgz", + "integrity": "sha512-vzi9uRZ926x4XV73S/4qQaTwPXM2JBj6/6lI/byHH1jOpCzb0zDbfytgA9LcN/hzb2l7WQSQnxITOVx5un/wGw==", + "dev": true, + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist-node/bin/uuid" + } + }, + "node_modules/valibot": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.4.2.tgz", + "integrity": "sha512-gjdCvJ6d3RyHAneqxMYMW9QMCwYMb3jpOO0IyHZV1bnRHFBHrX3VkIILt5XYR0WhwHiH7Mty8ovuPZ/O3gamrg==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "typescript": ">=5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vfile": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz", + "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-location": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz", + "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-location/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/vfile-message": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.4.tgz", + "integrity": "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message/node_modules/unist-util-stringify-position": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz", + "integrity": "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.2" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/vfile/node_modules/vfile-message": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz", + "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vite": { + "version": "7.3.6", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz", + "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0 || ^0.28.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-plugin-devtools-json": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/vite-plugin-devtools-json/-/vite-plugin-devtools-json-0.2.1.tgz", + "integrity": "sha512-5aiNvf/iLTuLR1dUqoI5CLLGgeK2hd6u+tA+RIp7GUZDyAcM6ECaUEWOOtGpidbcxbkKq++KtmSqA3jhMbPwMA==", + "dev": true, + "license": "MIT", + "dependencies": { + "uuid": "^11.1.0" + }, + "peerDependencies": { + "vite": "^2.7.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/vite-plugin-devtools-json/node_modules/uuid": { + "version": "11.1.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.1.tgz", + "integrity": "sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ==", + "dev": true, + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/esm/bin/uuid" + } + }, + "node_modules/vite-plugin-pwa": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/vite-plugin-pwa/-/vite-plugin-pwa-1.3.0.tgz", + "integrity": "sha512-c5kMgN+ITrOtHXp8PAtk2uOIEea6XjP/unCGxOWWBzQ6qa65qj/awHg0wf+QF9E/2u9vh86LqxPwzEPNbM2r5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "^4.3.6", + "pretty-bytes": "^6.1.1", + "tinyglobby": "^0.2.10", + "workbox-build": "^7.4.1", + "workbox-window": "^7.4.1" + }, + "engines": { + "node": ">=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@vite-pwa/assets-generator": "^1.0.0", + "vite": "^3.1.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0", + "workbox-build": "^7.4.1", + "workbox-window": "^7.4.1" + }, + "peerDependenciesMeta": { + "@vite-pwa/assets-generator": { + "optional": true + } + } + }, + "node_modules/vitefu": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.3.tgz", + "integrity": "sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg==", + "dev": true, + "license": "MIT", + "workspaces": [ + "tests/deps/*", + "tests/projects/*", + "tests/projects/workspace/packages/*" + ], + "peerDependencies": { + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "vite": { + "optional": true + } + } + }, + "node_modules/vitest": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz", + "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/expect": "4.1.10", + "@vitest/mocker": "4.1.10", + "@vitest/pretty-format": "4.1.10", + "@vitest/runner": "4.1.10", + "@vitest/snapshot": "4.1.10", + "@vitest/spy": "4.1.10", + "@vitest/utils": "4.1.10", + "es-module-lexer": "^2.0.0", + "expect-type": "^1.3.0", + "magic-string": "^0.30.21", + "obug": "^2.1.1", + "pathe": "^2.0.3", + "picomatch": "^4.0.3", + "std-env": "^4.0.0-rc.1", + "tinybench": "^2.9.0", + "tinyexec": "^1.0.2", + "tinyglobby": "^0.2.15", + "tinyrainbow": "^3.1.0", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^20.0.0 || ^22.0.0 || >=24.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "4.1.10", + "@vitest/browser-preview": "4.1.10", + "@vitest/browser-webdriverio": "4.1.10", + "@vitest/coverage-istanbul": "4.1.10", + "@vitest/coverage-v8": "4.1.10", + "@vitest/ui": "4.1.10", + "happy-dom": "*", + "jsdom": "*", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@opentelemetry/api": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/browser-preview": { + "optional": true + }, + "@vitest/browser-webdriverio": { + "optional": true + }, + "@vitest/coverage-istanbul": { + "optional": true + }, + "@vitest/coverage-v8": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + }, + "vite": { + "optional": false + } + } + }, + "node_modules/vitest-browser-svelte": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/vitest-browser-svelte/-/vitest-browser-svelte-2.1.1.tgz", + "integrity": "sha512-qbunYRSm+N92r9bfTkdDTpBZESLmp4QFz2SluV3n/x8U7ysosfeXYJZ4vXbJ0Y0LzoqqDnV5LHprmFgn4Eo+Ug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@testing-library/svelte-core": "^1.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "svelte": "^3 || ^4 || ^5 || ^5.0.0-next.0", + "vitest": "^4.0.0" + } + }, + "node_modules/vitest/node_modules/@vitest/expect": { + "version": "4.1.10", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz", + "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.1.0", + "@types/chai": "^5.2.2", + "@vitest/spy": "4.1.10", + "@vitest/utils": "4.1.10", + "chai": "^6.2.2", + "tinyrainbow": "^3.1.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vitest/node_modules/chai": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz", + "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/web-namespaces": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz", + "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/webidl-conversions": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz", + "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==", + "dev": true, + "license": "BSD-2-Clause" + }, + "node_modules/webpack-virtual-modules": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz", + "integrity": "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/whatwg-encoding": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz", + "integrity": "sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==", + "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation", + "dev": true, + "license": "MIT", + "dependencies": { + "iconv-lite": "0.6.3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/whatwg-encoding/node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/whatwg-url": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz", + "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "lodash.sortby": "^4.7.0", + "tr46": "^1.0.1", + "webidl-conversions": "^4.0.2" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-bigint": "^1.1.0", + "is-boolean-object": "^1.2.1", + "is-number-object": "^1.1.1", + "is-string": "^1.1.1", + "is-symbol": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-builtin-type": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "function.prototype.name": "^1.1.6", + "has-tostringtag": "^1.0.2", + "is-async-function": "^2.0.0", + "is-date-object": "^1.1.0", + "is-finalizationregistry": "^1.1.0", + "is-generator-function": "^1.0.10", + "is-regex": "^1.2.1", + "is-weakref": "^1.0.2", + "isarray": "^2.0.5", + "which-boxed-primitive": "^1.1.0", + "which-collection": "^1.0.2", + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-collection": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz", + "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-map": "^2.0.3", + "is-set": "^2.0.3", + "is-weakmap": "^2.0.2", + "is-weakset": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.21", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.21.tgz", + "integrity": "sha512-zbRA8cVm6io/d5W8uIe2hblzN76/Wm3v/yiythQvr+dpBWeqhPSWIDNj4zOyHi4zKbMK6DN34Xsr9jPHJERAEw==", + "dev": true, + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.9", + "call-bound": "^1.0.4", + "for-each": "^0.3.5", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workbox-background-sync": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-7.4.1.tgz", + "integrity": "sha512-HhT7KE8tOWDm02wRNshXUnUPofMlhenF2DBdUnDPOubhizzPeItkYTmAB6td1Z2cjYPa98vzEiPLEuzn5hN66g==", + "dev": true, + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-broadcast-update": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-7.4.1.tgz", + "integrity": "sha512-uAlgslKLvbQY+suirIdnBCSYrcgBhjp81Nj4l1lj/Jmj0MJO2CJERnCJjT0GFVwmReV0N+zs78K6gqd5gr9/+A==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-build": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-7.4.1.tgz", + "integrity": "sha512-SDhxIvEAde9Gy/5w4Yo1Jh/M49Z0qE3q0oteyE8zGq0DScxFqVBcCtIXFuLtmtxRQZCMbf0prco4VyEu3KBQuw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@apideck/better-ajv-errors": "^0.3.1", + "@babel/core": "^7.24.4", + "@babel/preset-env": "^7.11.0", + "@babel/runtime": "^7.11.2", + "@rollup/plugin-babel": "^6.1.0", + "@rollup/plugin-node-resolve": "^16.0.3", + "@rollup/plugin-replace": "^6.0.3", + "@rollup/plugin-terser": "^1.0.0", + "@trickfilm400/rollup-plugin-off-main-thread": "^3.0.0-pre1", + "ajv": "^8.6.0", + "common-tags": "^1.8.0", + "eta": "^4.5.1", + "fast-json-stable-stringify": "^2.1.0", + "fs-extra": "^9.0.1", + "glob": "^11.0.1", + "pretty-bytes": "^5.3.0", + "rollup": "^4.53.3", + "source-map": "^0.8.0-beta.0", + "stringify-object": "^3.3.0", + "strip-comments": "^2.0.1", + "tempy": "^0.6.0", + "upath": "^1.2.0", + "workbox-background-sync": "7.4.1", + "workbox-broadcast-update": "7.4.1", + "workbox-cacheable-response": "7.4.1", + "workbox-core": "7.4.1", + "workbox-expiration": "7.4.1", + "workbox-google-analytics": "7.4.1", + "workbox-navigation-preload": "7.4.1", + "workbox-precaching": "7.4.1", + "workbox-range-requests": "7.4.1", + "workbox-recipes": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1", + "workbox-streams": "7.4.1", + "workbox-sw": "7.4.1", + "workbox-window": "7.4.1" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/workbox-build/node_modules/@isaacs/cliui": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz", + "integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/workbox-build/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/workbox-build/node_modules/brace-expansion": { + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz", + "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/workbox-build/node_modules/glob": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz", + "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==", + "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "foreground-child": "^3.3.1", + "jackspeak": "^4.1.1", + "minimatch": "^10.1.1", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^2.0.0" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/workbox-build/node_modules/jackspeak": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz", + "integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^9.0.0" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/workbox-build/node_modules/lru-cache": { + "version": "11.5.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz", + "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/workbox-build/node_modules/minimatch": { + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.5" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/workbox-build/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/workbox-build/node_modules/pretty-bytes": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz", + "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/workbox-build/node_modules/source-map": { + "version": "0.8.0-beta.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz", + "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==", + "deprecated": "The work that was done in this beta branch won't be included in future versions", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "whatwg-url": "^7.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/workbox-cacheable-response": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-7.4.1.tgz", + "integrity": "sha512-8xaFoJdDc2OjrlbbL3gEeBO1WKcMwRqwLRupgqahYXu75yXajPLuwrbXMrIGZuWYXrQwk0xDjOxZ/ujCy/oJYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-core": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-7.4.1.tgz", + "integrity": "sha512-DT+vu46eh/2vRsSHTY4Xmc32Z1rr9PRlQUXr1Dx30ZuXRWwOsvZgGgcwxcasubQLQmbTNYZjv44LkBAQ4tT5tQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/workbox-expiration": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-7.4.1.tgz", + "integrity": "sha512-lRKUF7b+OGbeXkQk1s6MHXOa3d7Xxf7Of31W6c6hCfipfIyrtdWZ89stq21AHZMaoG7VNFoHply4Ox+rU31TWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-google-analytics": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-7.4.1.tgz", + "integrity": "sha512-Mks1JwLEt++ZAkF6sS1OpSh9RtAMIsiDgRpK+codiHGIPXeaUOgi4cPc3GFadUl8V5QPeypEk8Oxgl3HlwVzHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-background-sync": "7.4.1", + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-navigation-preload": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-7.4.1.tgz", + "integrity": "sha512-C4KVsjPcYKJOhr631AxR9XoG2rLF3QiTk5aMv36MXOjtWvm8axwNFAtKUPGsWUwLXXAMgYM1En7fsvndaXeXRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-precaching": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-7.4.1.tgz", + "integrity": "sha512-cdr/9qByww7yzEp7zg/qI4ukUrrNjQLgN+ONQRpjy/VqGQXwkgHwr00KksGJK8v0VifwDXBb8a4cWNZH71jn3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-range-requests": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-7.4.1.tgz", + "integrity": "sha512-7i2oxAUE82gHdAJBCAQ04JzNOdRPqzuOzGfoUyJpFSmeqBNYGPrAH8GPoPjUQTfp+NycwrD2H68VtuF8qxv0vQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-recipes": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-7.4.1.tgz", + "integrity": "sha512-gnbVfmV4/TtmQaM4x9AtuXhcdstJsep3XMVeztOrQVPT+R6+6DeBjGTCQ7fFCXm+4GEHUA5VEBTyi5+4gWGeog==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-cacheable-response": "7.4.1", + "workbox-core": "7.4.1", + "workbox-expiration": "7.4.1", + "workbox-precaching": "7.4.1", + "workbox-routing": "7.4.1", + "workbox-strategies": "7.4.1" + } + }, + "node_modules/workbox-routing": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-7.4.1.tgz", + "integrity": "sha512-yubJGErZOusuidAenaL5ypfhQOa7urxP/f8E0ws7FPb4039RiWXUWBAyUkmUoOL/BcQGen3h0J8872d51IYxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-strategies": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-7.4.1.tgz", + "integrity": "sha512-GZxpaw9NbmOelj7667uZ2kpk5BFpOGbO4X0qjwh5ls8XQ8C+Lha5LQchTiUzsTFSS+NlUpftYAyOVXvQUrcqOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1" + } + }, + "node_modules/workbox-streams": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-7.4.1.tgz", + "integrity": "sha512-HWWtraKUbJknd9kgqGcpQ3G114HOPYvqs8HaJMDs2ebLNAimDkVDaWfAXE6Ybl+m8U6KsCE6pWyLYuigWmnAXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "workbox-core": "7.4.1", + "workbox-routing": "7.4.1" + } + }, + "node_modules/workbox-sw": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-7.4.1.tgz", + "integrity": "sha512-fez5f2DUlDJWTFYkCWQpY10N8gtztd849NswCbVFk0QlcSM4HT5A8x4g4ii650yem4I8tHY0R7JZahwp3ltIPw==", + "dev": true, + "license": "MIT" + }, + "node_modules/workbox-window": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-7.4.1.tgz", + "integrity": "sha512-notZDH2u8VXaqyuD7xaqIfEFi6SRM4SUSd7ewe9PDsVqADuepxX2ZMY3uvuZGxzY5ZOsGC/vD3A/3smFtJt4/A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/trusted-types": "^2.0.2", + "workbox-core": "7.4.1" + } + }, + "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==", + "dev": true, + "license": "ISC" + }, + "node_modules/ws": { + "version": "8.21.2", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.2.tgz", + "integrity": "sha512-54dMVAo4WIe6SKy3vBgN+9bJZqqQ8IMRevAkOLQALhi49qkkQDQfWdAZ8KQlXiEabw88ARXXdUrlvtbKQX+aKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/wsl-utils": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/wsl-utils/-/wsl-utils-0.1.0.tgz", + "integrity": "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-wsl": "^3.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zimmerframe": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz", + "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/zod": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz", + "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-to-json-schema": { + "version": "3.25.2", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz", + "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==", + "dev": true, + "license": "ISC", + "peerDependencies": { + "zod": "^3.25.28 || ^4" + } + }, + "node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + } + } +} diff --git a/tools/ui/node_modules/@adobe/css-tools/LICENSE b/tools/ui/node_modules/@adobe/css-tools/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e63de06c0b62aeb72dd761185a524d123bb0ed7b --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/LICENSE @@ -0,0 +1,10 @@ +(The MIT License) + +Copyright (c) 2012 TJ Holowaychuk +Copyright (c) 2022 Jean-Philippe Zolesio + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/@adobe/css-tools/README.md b/tools/ui/node_modules/@adobe/css-tools/README.md new file mode 100644 index 0000000000000000000000000000000000000000..13053ccdf3576f06199f441ae45b81dd79963c33 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/README.md @@ -0,0 +1,146 @@ +# @adobe/css-tools + +> A modern CSS parser and stringifier with TypeScript support + +[![npm version](https://badge.fury.io/js/%40adobe%2Fcss-tools.svg)](https://badge.fury.io/js/%40adobe%2Fcss-tools) +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) + +Parse CSS into an Abstract Syntax Tree (AST) and convert it back to CSS with configurable formatting. Built with TypeScript for type safety and modern JavaScript features. + +## Install + +```bash +npm install @adobe/css-tools +``` + +## Usage + +```js +import { parse, stringify } from '@adobe/css-tools' + +// Parse CSS to AST +const ast = parse('body { font-size: 12px; }') + +// Stringify AST back to CSS +const css = stringify(ast) +// => "body { font-size: 12px; }" + +// Pretty print with custom indentation +const formatted = stringify(ast, { indent: ' ' }) +// => "body {\n font-size: 12px;\n}" + +// Minify output +const minified = stringify(ast, { compress: true }) +// => "body{font-size:12px}" +``` + +## API + +### `parse(code, options?)` + +Parses CSS code and returns an Abstract Syntax Tree (AST). + +**Parameters:** +- `code` (string) - The CSS code to parse +- `options` (object, optional) - Parsing options + - `silent` (boolean) - Silently fail on parse errors instead of throwing + - `source` (string) - File path for better error reporting + +**Returns:** `CssStylesheetAST` - The parsed CSS as an AST + +### `stringify(ast, options?)` + +Converts a CSS AST back to CSS string with configurable formatting. + +**Parameters:** +- `ast` (CssStylesheetAST) - The CSS AST to stringify +- `options` (object, optional) - Stringification options + - `indent` (string) - Indentation string (default: `' '`) + - `compress` (boolean) - Whether to compress/minify the output (default: `false`) + +**Returns:** `string` - The formatted CSS string + +## Features + +- **Complete CSS Support**: All standard CSS features including selectors, properties, values, at-rules, and comments +- **TypeScript Support**: Full type definitions for all AST nodes and functions +- **Error Handling**: Configurable error handling with detailed position information +- **Formatting Options**: Pretty print, minify, or custom formatting +- **Performance Optimized**: Efficient parsing and stringification for large CSS files +- **Source Maps**: Track original source positions for debugging and tooling + +### Supported CSS Features + +- **Selectors**: Element, class, ID, attribute, pseudo-class, pseudo-element selectors +- **Properties**: All standard CSS properties and custom properties +- **Values**: Colors, lengths, percentages, functions, calc(), etc. +- **At-rules**: @media, @keyframes, @import, @charset, @namespace, @font-face, @page, @document, @supports, @container, @layer, @starting-style, @host, @custom-media +- **Comments**: Both /* */ and // comments +- **Whitespace**: Preserves formatting information +- **Vendor prefixes**: Supports vendor-prefixed at-rules and properties +- **Nested rules**: Media queries, supports, containers, etc. +- **Complex selectors**: Combinators, pseudo-selectors, attribute selectors + +## Examples + +### Error Handling + +```js +import { parse } from '@adobe/css-tools' + +const malformedCss = ` + body { color: red; } + { color: blue; } /* Missing selector */ + .valid { background: green; } +` + +// Parse with silent error handling +const result = parse(malformedCss, { silent: true }) + +// Check for parsing errors +if (result.stylesheet.parsingErrors) { + console.log('Parsing errors:', result.stylesheet.parsingErrors.length) + result.stylesheet.parsingErrors.forEach(error => { + console.log(`Error at line ${error.line}: ${error.message}`) + }) +} + +// Valid rules are still parsed +console.log('Valid rules:', result.stylesheet.rules.length) +``` + +### Source Tracking + +```js +import { parse } from '@adobe/css-tools' + +const css = 'body { color: red; }' +const ast = parse(css, { source: 'styles.css' }) + +// Position information is available +const rule = ast.stylesheet.rules[0] +console.log(rule.position?.source) // "styles.css" +console.log(rule.position?.start) // { line: 1, column: 1 } +console.log(rule.position?.end) // { line: 1, column: 20 } +``` + +For more examples, see the [Examples documentation](docs/EXAMPLES.md). + +## Performance + +The library is optimized for performance and can handle large CSS files efficiently. For benchmarking information, see the `benchmark/` directory in the source code. + +## Documentation + +- [API Reference](docs/API.md) - Complete API documentation +- [AST Structure](docs/AST.md) - Detailed AST node types and structure +- [Examples](docs/EXAMPLES.md) - Comprehensive usage examples +- [Changelog](docs/CHANGELOG.md) - Version history and changes + +## Background + +This is a fork of the npm `css` package, maintained by Adobe with modern improvements including TypeScript support, enhanced performance, and security updates. It provides a robust foundation for CSS tooling, preprocessing, and analysis. + +## License + +[MIT](LICENSE) diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs new file mode 100644 index 0000000000000000000000000000000000000000..4917e128e7c3f2c006163902f42dfa5a79390f08 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs @@ -0,0 +1,2 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0});class t extends Error{reason;filename;line;column;source;constructor(t,s,e,i,n){super(`${t}:${e}:${i}: ${s}`),this.reason=s,this.filename=t,this.line=e,this.column=i,this.source=n}}class s{start;end;source;constructor(t,s,e){this.start=t,this.end=s,this.source=e}}var e;exports.CssTypes=void 0,(e=exports.CssTypes||(exports.CssTypes={})).stylesheet="stylesheet",e.rule="rule",e.declaration="declaration",e.comment="comment",e.atRule="at-rule",e.container="container",e.charset="charset",e.counterStyle="counter-style",e.document="document",e.customMedia="custom-media",e.fontFace="font-face",e.fontFeatureValues="font-feature-values",e.host="host",e.import="import",e.keyframes="keyframes",e.keyframe="keyframe",e.layer="layer",e.media="media",e.namespace="namespace",e.page="page",e.pageMarginBox="page-margin-box",e.positionTry="position-try",e.property="property",e.scope="scope",e.startingStyle="starting-style",e.supports="supports",e.viewTransition="view-transition";const i=(t,s,e)=>{let i=e,n=1e4;do{const e=s.map(s=>t.indexOf(s,i));e.push(t.indexOf("\\",i));const r=e.filter(t=>-1!==t);if(0===r.length)return-1;const o=Math.min(...r);if("\\"!==t[o])return o;i=o+2,n--}while(n>0);throw new Error("Too many escaping")},n=(t,s,e)=>{let r=e,o=1e4;do{const e=s.map(s=>t.indexOf(s,r));e.push(t.indexOf("(",r)),e.push(t.indexOf('"',r)),e.push(t.indexOf("'",r)),e.push(t.indexOf("\\",r));const c=e.filter(t=>-1!==t);if(0===c.length)return-1;const p=Math.min(...c);switch(t[p]){case"\\":r=p+2;break;case"(":{const s=n(t,[")"],p+1);if(-1===s)return-1;r=s+1}break;case'"':{const s=i(t,['"'],p+1);if(-1===s)return-1;r=s+1}break;case"'":{const s=i(t,["'"],p+1);if(-1===s)return-1;r=s+1}break;default:return p}o--}while(o>0);throw new Error("Too many escaping")},r=/\/\*[^]*?(?:\*\/|$)/g;function o(t){return t?t.trim():""}function c(t,s){const e=t&&"string"==typeof t.type,i=e?t:s;for(const s in t){const e=t[s];Array.isArray(e)?e.forEach(t=>{c(t,i)}):e&&"object"==typeof e&&c(e,i)}return e&&Object.defineProperty(t,"parent",{configurable:!0,writable:!0,enumerable:!1,value:s||null}),t}class p{level=0;indentation=" ";compress=!1;constructor(t){"string"==typeof t?.indent&&(this.indentation=t?.indent),t?.compress&&(this.compress=!0)}emit(t,s){return t}indent(t){return this.level=this.level||1,t?(this.level+=t,""):Array(this.level).join(this.indentation)}visit(t){switch(t.type){case exports.CssTypes.stylesheet:return this.stylesheet(t);case exports.CssTypes.rule:return this.rule(t);case exports.CssTypes.declaration:return this.declaration(t);case exports.CssTypes.comment:return this.comment(t);case exports.CssTypes.container:return this.container(t);case exports.CssTypes.charset:return this.charset(t);case exports.CssTypes.counterStyle:return this.counterStyle(t);case exports.CssTypes.document:return this.document(t);case exports.CssTypes.customMedia:return this.customMedia(t);case exports.CssTypes.fontFace:return this.fontFace(t);case exports.CssTypes.fontFeatureValues:return this.fontFeatureValues(t);case exports.CssTypes.host:return this.host(t);case exports.CssTypes.import:return this.import(t);case exports.CssTypes.keyframes:return this.keyframes(t);case exports.CssTypes.keyframe:return this.keyframe(t);case exports.CssTypes.layer:return this.layer(t);case exports.CssTypes.media:return this.media(t);case exports.CssTypes.namespace:return this.namespace(t);case exports.CssTypes.page:return this.page(t);case exports.CssTypes.pageMarginBox:return this.pageMarginBox(t);case exports.CssTypes.positionTry:return this.positionTry(t);case exports.CssTypes.property:return this.property(t);case exports.CssTypes.scope:return this.scope(t);case exports.CssTypes.startingStyle:return this.startingStyle(t);case exports.CssTypes.supports:return this.supports(t);case exports.CssTypes.viewTransition:return this.viewTransition(t);case exports.CssTypes.atRule:return this.genericAtRule(t)}}mapVisit(t,s){let e="";s=s||"";for(let i=0,n=t.length;it.type!==exports.CssTypes.declaration&&t.type!==exports.CssTypes.comment),i=e?"\n\n":"\n";return this.emit(`${this.indent()}@${t.name}${s}`,t.position)+this.emit(e?` {\n${this.indent(1)}`:" {\n")+this.emit(e?"":this.indent(1))+this.mapVisit(t.rules,i)+this.emit(e?`\n${this.indent(-1)}${this.indent()}}`:`${this.indent(-1)}\n${this.indent()}}`)}rule(t){const s=t.declarations;if(!s.length)return"";if(this.compress)return this.emit(t.selectors.join(","),t.position)+this.emit("{")+this.mapVisit(s)+this.emit("}");const e=this.indent();return this.emit(t.selectors.map(t=>e+t).join(",\n"),t.position)+this.emit(" {\n")+this.emit(this.indent(1))+this.mapVisit(s,"\n")+this.emit(this.indent(-1))+this.emit(`\n${this.indent()}}`)}declaration(t){return this.compress?this.emit(`${t.property}:${t.value}`,t.position)+this.emit(";"):"grid-template-areas"===t.property?this.emit(this.indent())+this.emit(t.property+": "+t.value.split("\n").join("\n".padEnd(22)+this.indent()),t.position)+this.emit(";"):this.emit(this.indent())+this.emit(`${t.property}: ${t.value}`,t.position)+this.emit(";")}}const h=(e,i)=>{i=i||{};let p=1,h=1;function a(){const t={line:p,column:h};return e=>(e.position=new s(t,{line:p,column:h},i?.source||""),d(),e)}const m=[];function u(s){const n=new t(i?.source||"",s,p,h,e);if(!i?.silent)throw n;m.push(n)}function l(){const t=/^{\s*/.exec(e);return!!t&&(y(t),!0)}function f(){const t=/^}/.exec(e);return!!t&&(y(t),!0)}function y(t){const s=t[0];return function(t){const s=t.match(/\n/g);s&&(p+=s.length);const e=t.lastIndexOf("\n");h=~e?t.length-e:h+t.length}(s),e=e.slice(s.length),t}function d(){const t=/^\s*/.exec(e);t&&y(t)}function g(t){t=t||[];let s=x();for(;s;)t.push(s),s=x();return t}function x(){const t=a();if("/"!==e.charAt(0)||"*"!==e.charAt(1))return;const s=/^\/\*[^]*?\*\//.exec(e);return s?(y(s),t({type:exports.CssTypes.comment,comment:s[0].slice(2,-2)})):u("End of comment missing")}function $(){const t=n(e,["{"]);if(-1===t||0===t)return;const s=e.substring(0,t);y([s]);return((t,s)=>{const e=[];let i=0;for(;io(t))}function T(){const t=a(),s=/^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/.exec(e);if(!s)return;y(s);const i=o(s[0]),c=/^:\s*/.exec(e);if(!c)return u("property missing ':'");y(c);let p="";const h=n(e,[";","}"]);if(-1!==h){p=e.substring(0,h);y([p]),p=o(p).replace(r,"")}const m=t({type:exports.CssTypes.declaration,property:i.replace(r,""),value:p}),l=/^[;\s]*/.exec(e);return l&&y(l),m}function C(){const t=[];if(!l())return u("missing '{'");g(t);let s=T();for(;s;)t.push(s),g(t),s=T();for(;i?.silent&&e.length&&"}"!==e.charAt(0);){const i=e.indexOf(";"),n=e.indexOf("}");if(-1===i||!(-1===n||i{const i=a(),n=s.exec(e);if(!n)return;const r=y(n),o={type:t};return o[t]=r[1].trim(),i(o)}}function M(){if("@"===e[0])return function(){const t=a(),s=/^@([-\w]+)?keyframes\s*/.exec(e);if(!s)return;const i=y(s)[1],n=/^([-\w]+)\s*/.exec(e);if(!n)return u("@keyframes missing name");const r=y(n)[1];if(!l())return u("@keyframes missing '{'");let o=g(),c=b();for(;c;)o.push(c),o=o.concat(g()),c=b();return f()?t({type:exports.CssTypes.keyframes,name:r,vendor:i,keyframes:o}):u("@keyframes missing '}'")}()||function(){const t=a(),s=/^@media *([^{]+)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l())return u("@media missing '{'");const n=w();return f()?t({type:exports.CssTypes.media,media:i,rules:n}):u("@media missing '}'")}()||function(){const t=a(),s=/^@custom-media\s+(--\S+)\s+([^{;\s][^{;]*);/.exec(e);if(!s)return;const i=y(s);return t({type:exports.CssTypes.customMedia,name:o(i[1]),media:o(i[2])})}()||function(){const t=a(),s=/^@supports *([^{]+)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l())return u("@supports missing '{'");const n=w();return f()?t({type:exports.CssTypes.supports,supports:i,rules:n}):u("@supports missing '}'")}()||A()||O()||j()||function(){const t=a(),s=/^@([-\w]+)?document *([^{]+)/.exec(e);if(!s)return;const i=y(s),n=o(i[1]),r=o(i[2]);if(!l())return u("@document missing '{'");const c=w();return f()?t({type:exports.CssTypes.document,document:r,vendor:n,rules:c}):u("@document missing '}'")}()||function(){const t=a(),s=/^@page */.exec(e);if(!s)return;y(s);const i=$()||[];if(!l())return u("@page missing '{'");const n=[];for(g(n);e.length&&"}"!==e.charAt(0);){if("@"===e.charAt(0)){const t=M();if(t){n.push(t),g(n);continue}}const t=T();if(!t)break;n.push(t),g(n)}return f()?t({type:exports.CssTypes.page,selectors:i,declarations:n}):u("@page missing '}'")}()||function(){const t=a(),s=/^@host\s*/.exec(e);if(!s)return;if(y(s),!l())return u("@host missing '{'");const i=w();return f()?t({type:exports.CssTypes.host,rules:i}):u("@host missing '}'")}()||function(){const t=a(),s=/^@font-face\s*/.exec(e);if(!s)return;if(y(s),!l())return u("@font-face missing '{'");let i=g(),n=T();for(;n;)i.push(n),i=i.concat(g()),n=T();return f()?t({type:exports.CssTypes.fontFace,declarations:i}):u("@font-face missing '}'")}()||function(){const t=a(),s=/^@font-feature-values\s+([^{]+)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l())return u("@font-feature-values missing '{'");const n=w();return f()?t({type:exports.CssTypes.fontFeatureValues,fontFamily:i,rules:n}):u("@font-feature-values missing '}'")}()||function(){const t=a(),s=/^@container *([^{]+)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l())return u("@container missing '{'");const n=w();return f()?t({type:exports.CssTypes.container,container:i,rules:n}):u("@container missing '}'")}()||function(){const t=a(),s=/^@starting-style\s*/.exec(e);if(!s)return;if(y(s),!l())return u("@starting-style missing '{'");const i=w();return f()?t({type:exports.CssTypes.startingStyle,rules:i}):u("@starting-style missing '}'")}()||function(){const t=a(),s=/^@layer *([^{;@]+)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l()){const s=/^[;\s]*/.exec(e);return s&&y(s),t({type:exports.CssTypes.layer,layer:i})}const n=w();return f()?t({type:exports.CssTypes.layer,layer:i,rules:n}):u("@layer missing '}'")}()||function(){const t=a(),s=/^@property\s+(--[-\w]+)\s*/.exec(e);if(!s)return;const i=y(s)[1];if(!l())return u("@property missing '{'");let n=g(),r=T();for(;r;)n.push(r),n=n.concat(g()),r=T();return f()?t({type:exports.CssTypes.property,name:i,declarations:n}):u("@property missing '}'")}()||function(){const t=a(),s=/^@counter-style\s+([-\w]+)\s*/.exec(e);if(!s)return;const i=y(s)[1];if(!l())return u("@counter-style missing '{'");let n=g(),r=T();for(;r;)n.push(r),n=n.concat(g()),r=T();return f()?t({type:exports.CssTypes.counterStyle,name:i,declarations:n}):u("@counter-style missing '}'")}()||function(){const t=a(),s=/^@scope\s*([^{]*)/.exec(e);if(!s)return;const i=o(y(s)[1]);if(!l())return u("@scope missing '{'");const n=w();return f()?t({type:exports.CssTypes.scope,scope:i,rules:n}):u("@scope missing '}'")}()||function(){const t=a(),s=/^@view-transition\s*/.exec(e);if(!s)return;if(y(s),!l())return u("@view-transition missing '{'");let i=g(),n=T();for(;n;)i.push(n),i=i.concat(g()),n=T();return f()?t({type:exports.CssTypes.viewTransition,declarations:i}):u("@view-transition missing '}'")}()||function(){const t=a(),s=/^@position-try\s+(--[-\w]+)\s*/.exec(e);if(!s)return;const i=y(s)[1];if(!l())return u("@position-try missing '{'");let n=g(),r=T();for(;r;)n.push(r),n=n.concat(g()),r=T();return f()?t({type:exports.CssTypes.positionTry,name:i,declarations:n}):u("@position-try missing '}'")}()||function(){const t=a(),s=k.exec(e);if(!s)return;const i=y(s)[1];if(!l())return u(`@${i} missing '{'`);let n=g(),r=T();for(;r;)n.push(r),n=n.concat(g()),r=T();return f()?t({type:exports.CssTypes.pageMarginBox,name:i,declarations:n}):u(`@${i} missing '}'`)}()||function(){const t=a(),s=/^@([-\w]+)\s*/.exec(e);if(!s)return;const i=y(s)[1];let r="";const c=n(e,["{",";"]);-1!==c&&c>0&&(r=o(e.substring(0,c)),y([e.substring(0,c)]));if(l()){const s=w();return f()?t({type:exports.CssTypes.atRule,name:i,prelude:r,rules:s}):u(`@${i} missing '}'`)}const p=/^[;\s]*/.exec(e);return p&&y(p),t({type:exports.CssTypes.atRule,name:i,prelude:r})}()}function S(){const t=a(),s=$();return s?(g(),t({type:exports.CssTypes.rule,selectors:s,declarations:v()||[]})):u("selector missing")}return c(function(){const t=function(){let t;const s=[];d(),g(s);for(;e.length;){if("}"===e.charAt(0)){if(i?.silent){u("extra '}'");y(["}"]),d(),g(s);continue}break}if(t=M()||S(),!t){if(i?.silent){y([e.charAt(0)]),d(),g(s);continue}break}s.push(t),g(s)}return s}();return{type:exports.CssTypes.stylesheet,stylesheet:{source:i?.source,rules:t,parsingErrors:m}}}())},a=(t,s)=>new p(s||{}).compile(t);var m={parse:h,stringify:a};exports.default=m,exports.parse=h,exports.stringify=a; +//# sourceMappingURL=adobe-css-tools.cjs.map diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs.map b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs.map new file mode 100644 index 0000000000000000000000000000000000000000..5229a1e795f467b0c08e8c590b02b41551ef9da8 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"adobe-css-tools.cjs","sources":["../../src/CssParseError.ts","../../src/CssPosition.ts","../../src/type.ts","../../src/utils/stringSearch.ts","../../src/parse/index.ts","../../src/stringify/compiler.ts","../../src/index.ts","../../src/stringify/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":["CssParseError","Error","reason","filename","line","column","source","constructor","msg","lineno","css","super","this","Position","start","end","CssTypes","indexOfArrayNonEscaped","string","search","position","currentPosition","maxLoop","all","map","v","indexOf","push","foundAll","filter","length","found","Math","min","indexOfArrayWithBracketAndQuoteSupport","currentSearchPosition","firstMatchPos","endPosition","endQuotePosition","commentRegex","trim","str","addParent","obj","parent","isNode","type","childParent","k","value","Array","isArray","forEach","Object","defineProperty","configurable","writable","enumerable","Compiler","level","indentation","compress","options","indent","emit","_position","join","visit","node","stylesheet","rule","declaration","comment","container","charset","counterStyle","document","customMedia","fontFace","fontFeatureValues","host","import","keyframes","keyframe","layer","media","namespace","page","pageMarginBox","positionTry","property","scope","startingStyle","supports","viewTransition","atRule","genericAtRule","mapVisit","nodes","delim","buf","i","compile","rules","doc","vendor","name","decls","declarations","values","sel","selectors","fontFamily","prelude","hasNestedRules","some","r","s","split","padEnd","parse","whitespace","errorsList","error","err","silent","open","openMatch","exec","processMatch","close","closeMatch","m","lines","match","lastIndexOf","updatePosition","slice","comments","c","pos","charAt","selector","bracePos","selectorStr","substring","result","index","splitWithBracketAndQuoteSupport","replace","propMatch","propValue","separatorMatch","endValuePosition","ret","endMatch","decl","semiPos","looksLikeNestedRule","closePos","ruleBody","items","ar","nestedR","rulesOrDeclarations","vals","res","spacesMatch","pageMarginBoxRegex","RegExp","atImport","_compileAtRule","atCharset","atNamespace","re","m1","m2","frames","frame","concat","atKeyframes","style","atMedia","atCustomMedia","atSupports","atDocument","atPage","atHost","atFontFace","atFontFeatureValues","atContainer","atStartingStyle","atLayer","atProperty","atCounterStyle","atScope","atViewTransition","atPositionTry","atPageMarginBox","preludeEnd","atGeneric","rulesList","parsingErrors","stringify"],"mappings":"oEAAc,MAAOA,UAAsBC,MAChCC,OACAC,SACAC,KACAC,OACAC,OAET,WAAAC,CACEJ,EACAK,EACAC,EACAJ,EACAK,GAEAC,MAAM,GAAGR,KAAYM,KAAUJ,MAAWG,KAC1CI,KAAKV,OAASM,EACdI,KAAKT,SAAWA,EAChBS,KAAKR,KAAOK,EACZG,KAAKP,OAASA,EACdO,KAAKN,OAASI,CAChB,ECjBY,MAAOG,EACnBC,MACAC,IACAT,OAEA,WAAAC,CACEO,EACAC,EACAT,GAEAM,KAAKE,MAAQA,EACbF,KAAKG,IAAMA,EACXH,KAAKN,OAASA,CAChB,ECbF,IAAYU,EAAAA,QAAAA,cAAAA,GAAAA,EAAAA,QAAAA,WAAAA,iBAAQ,CAAA,IAClB,WAAA,aACAA,EAAA,KAAA,OACAA,EAAA,YAAA,cACAA,EAAA,QAAA,UACAA,EAAA,OAAA,UACAA,EAAA,UAAA,YACAA,EAAA,QAAA,UACAA,EAAA,aAAA,gBACAA,EAAA,SAAA,WACAA,EAAA,YAAA,eACAA,EAAA,SAAA,YACAA,EAAA,kBAAA,sBACAA,EAAA,KAAA,OACAA,EAAA,OAAA,SACAA,EAAA,UAAA,YACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,MAAA,QACAA,EAAA,UAAA,YACAA,EAAA,KAAA,OACAA,EAAA,cAAA,kBACAA,EAAA,YAAA,eACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,cAAA,iBACAA,EAAA,SAAA,WACAA,EAAA,eAAA,kBC9BK,MAkBMC,EAAyB,CACpCC,EACAC,EACAC,KAEA,IAAIC,EAAkBD,EAClBE,EAxBkB,IAyBtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGJ,IAChDE,EAAII,KAAKT,EAAOQ,QAAQ,KAAML,IAC9B,MAAMO,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMC,EAAQC,KAAKC,OAAOL,GAC1B,GAAsB,OAAlBV,EAAOa,GAIT,OAAOA,EAHPV,EAAkBU,EAAQ,EAC1BT,GAIJ,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBA0BLiC,EAAyC,CACpDhB,EACAC,EACAC,KAEA,IAAIe,EAAwBf,EACxBE,EA1EkB,IA4EtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGU,IAEhDZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,KAAMS,IAE9B,MAAMP,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMM,EAAgBJ,KAAKC,OAAOL,GAElC,OADaV,EAAOkB,IAElB,IAAK,KACHD,EAAwBC,EAAgB,EACxC,MACF,IAAK,IACH,CACE,MAAMC,EAAcH,EAClBhB,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAoB,IAAhBC,EACF,OAAO,EAETF,EAAwBE,EAAc,CACxC,CACA,MACF,IAAK,IACH,CACE,MAAMC,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,IAAK,IACH,CACE,MAAMA,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,QACE,OAAOF,EAEXd,GACF,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBCjGZsC,EAAe,uBAotCrB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAID,OAAS,EAC5B,CAKA,SAASE,EACPC,EACAC,GAEA,MAAMC,EAASF,GAA2B,iBAAbA,EAAIG,KAC3BC,EAAcF,EAASF,EAAMC,EAEnC,IAAK,MAAMI,KAAKL,EAAK,CACnB,MAAMM,EAAQN,EAAIK,GACdE,MAAMC,QAAQF,GAChBA,EAAMG,QAAS3B,IACbiB,EAAUjB,EAAGsB,KAENE,GAA0B,iBAAVA,GACzBP,EAAUO,EAAOF,EAErB,CAWA,OATIF,GACFQ,OAAOC,eAAeX,EAAK,SAAU,CACnCY,cAAc,EACdC,UAAU,EACVC,YAAY,EACZR,MAAOL,GAAU,OAIdD,CACT,CC5vCA,MAAMe,EACJC,MAAQ,EACRC,YAAc,KACdC,UAAW,EAEX,WAAAtD,CAAYuD,GACqB,iBAApBA,GAASC,SAClBnD,KAAKgD,YAAcE,GAASC,QAE1BD,GAASD,WACXjD,KAAKiD,UAAW,EAEpB,CAIA,IAAAG,CAAKvB,EAAawB,GAChB,OAAOxB,CACT,CAKA,MAAAsB,CAAOJ,GAGL,OAFA/C,KAAK+C,MAAQ/C,KAAK+C,OAAS,EAEvBA,GACF/C,KAAK+C,OAASA,EACP,IAGFT,MAAMtC,KAAK+C,OAAOO,KAAKtD,KAAKgD,YACrC,CAEA,KAAAO,CAAMC,GACJ,OAAQA,EAAKtB,MACX,KAAK9B,QAAAA,SAASqD,WACZ,OAAOzD,KAAKyD,WAAWD,GACzB,KAAKpD,QAAAA,SAASsD,KACZ,OAAO1D,KAAK0D,KAAKF,GACnB,KAAKpD,QAAAA,SAASuD,YACZ,OAAO3D,KAAK2D,YAAYH,GAC1B,KAAKpD,QAAAA,SAASwD,QACZ,OAAO5D,KAAK4D,QAAQJ,GACtB,KAAKpD,QAAAA,SAASyD,UACZ,OAAO7D,KAAK6D,UAAUL,GACxB,KAAKpD,QAAAA,SAAS0D,QACZ,OAAO9D,KAAK8D,QAAQN,GACtB,KAAKpD,QAAAA,SAAS2D,aACZ,OAAO/D,KAAK+D,aAAaP,GAC3B,KAAKpD,QAAAA,SAAS4D,SACZ,OAAOhE,KAAKgE,SAASR,GACvB,KAAKpD,QAAAA,SAAS6D,YACZ,OAAOjE,KAAKiE,YAAYT,GAC1B,KAAKpD,QAAAA,SAAS8D,SACZ,OAAOlE,KAAKkE,SAASV,GACvB,KAAKpD,QAAAA,SAAS+D,kBACZ,OAAOnE,KAAKmE,kBAAkBX,GAChC,KAAKpD,QAAAA,SAASgE,KACZ,OAAOpE,KAAKoE,KAAKZ,GACnB,KAAKpD,QAAAA,SAASiE,OACZ,OAAOrE,KAAKqE,OAAOb,GACrB,KAAKpD,QAAAA,SAASkE,UACZ,OAAOtE,KAAKsE,UAAUd,GACxB,KAAKpD,QAAAA,SAASmE,SACZ,OAAOvE,KAAKuE,SAASf,GACvB,KAAKpD,QAAAA,SAASoE,MACZ,OAAOxE,KAAKwE,MAAMhB,GACpB,KAAKpD,QAAAA,SAASqE,MACZ,OAAOzE,KAAKyE,MAAMjB,GACpB,KAAKpD,QAAAA,SAASsE,UACZ,OAAO1E,KAAK0E,UAAUlB,GACxB,KAAKpD,QAAAA,SAASuE,KACZ,OAAO3E,KAAK2E,KAAKnB,GACnB,KAAKpD,QAAAA,SAASwE,cACZ,OAAO5E,KAAK4E,cAAcpB,GAC5B,KAAKpD,QAAAA,SAASyE,YACZ,OAAO7E,KAAK6E,YAAYrB,GAC1B,KAAKpD,QAAAA,SAAS0E,SACZ,OAAO9E,KAAK8E,SAAStB,GACvB,KAAKpD,QAAAA,SAAS2E,MACZ,OAAO/E,KAAK+E,MAAMvB,GACpB,KAAKpD,QAAAA,SAAS4E,cACZ,OAAOhF,KAAKgF,cAAcxB,GAC5B,KAAKpD,QAAAA,SAAS6E,SACZ,OAAOjF,KAAKiF,SAASzB,GACvB,KAAKpD,QAAAA,SAAS8E,eACZ,OAAOlF,KAAKkF,eAAe1B,GAC7B,KAAKpD,QAAAA,SAAS+E,OACZ,OAAOnF,KAAKoF,cAAc5B,GAEhC,CAEA,QAAA6B,CAASC,EAA8BC,GACrC,IAAIC,EAAM,GACVD,EAAQA,GAAS,GAEjB,IAAK,IAAIE,EAAI,EAAGvE,EAASoE,EAAMpE,OAAQuE,EAAIvE,EAAQuE,IACjDD,GAAOxF,KAAKuD,MAAM+B,EAAMG,IACpBF,GAASE,EAAIvE,EAAS,IACxBsE,GAAOxF,KAAKoD,KAAKmC,IAIrB,OAAOC,CACT,CAEA,OAAAE,CAAQlC,GACN,OAAIxD,KAAKiD,SACAO,EAAKC,WAAWkC,MAAM/E,IAAIZ,KAAKuD,MAAOvD,MAAMsD,KAAK,IAGnDtD,KAAKyD,WAAWD,EACzB,CAKA,UAAAC,CAAWD,GACT,OAAOxD,KAAKqF,SAAS7B,EAAKC,WAAWkC,MAAO,OAC9C,CAKA,OAAA/B,CAAQJ,GACN,OAAIxD,KAAKiD,SACAjD,KAAKoD,KAAK,GAAII,EAAKhD,UAErBR,KAAKoD,KAAK,GAAGpD,KAAKmD,aAAaK,EAAKI,YAAaJ,EAAKhD,SAC/D,CAKA,SAAAqD,CAAUL,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,cAAcI,EAAKK,YAAaL,EAAKhD,UAC/CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,sBAAsBK,EAAKK,YAAaL,EAAKhD,UAC/DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAAqB,CAAMhB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKgB,QAAShB,EAAKhD,WACtCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAINpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKgB,QAAShB,EAAKhD,WACtDgD,EAAKmC,MACF3F,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAA2B7B,EAAKmC,MAAO,QAC5C3F,KAAKoD,KAAK,KAAKpD,KAAKmD,QAAO,KAAMnD,KAAKmD,aACtC,IAER,CAKA,MAAAkB,CAAOb,GACL,OAAOxD,KAAKoD,KAAK,WAAWI,EAAKa,UAAWb,EAAKhD,SACnD,CAKA,KAAAiE,CAAMjB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKiB,QAASjB,EAAKhD,UACvCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKiB,QAASjB,EAAKhD,UACvDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAAa,CAASR,GACP,MAAMoC,EAAM,IAAIpC,EAAKqC,QAAU,cAAcrC,EAAKQ,WAClD,OAAIhE,KAAKiD,SAELjD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,QAAQpD,KAAKmD,OAAO,MAC9BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,OAAAW,CAAQN,GACN,OAAOxD,KAAKoD,KAAK,YAAYI,EAAKM,WAAYN,EAAKhD,SACrD,CAKA,SAAAkE,CAAUlB,GACR,OAAOxD,KAAKoD,KAAK,cAAcI,EAAKkB,aAAclB,EAAKhD,SACzD,CAKA,aAAAwE,CAAcxB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAmBI,EAAKhD,UAClCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,0BAA2BK,EAAKhD,UAClDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAA8B,CAASzB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKyB,WAAYzB,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,qBAAqBK,EAAKyB,WAAYzB,EAAKhD,UAC7DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,SAAAmB,CAAUd,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KACH,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OACvCtC,EAAKhD,UAEPR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKc,WACnBtE,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OAAQtC,EAAKhD,UAC9DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKc,UAAW,MAC9BtE,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,MAE7B,CAKA,QAAAoB,CAASf,GACP,MAAMuC,EAAQvC,EAAKwC,aACnB,OAAIhG,KAAKiD,SAELjD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,KAAME,EAAKhD,UACtCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAKZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,MAAOE,EAAKhD,UACvCR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,OAAQnD,KAAKmD,cAE1C,CAKA,IAAAwB,CAAKnB,GACH,GAAIxD,KAAKiD,SAAU,CACjB,MAAMiD,EAAM1C,EAAK2C,UAAUjF,OAASsC,EAAK2C,UAAU7C,KAAK,MAAQ,GAEhE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,IAEd,CACA,MAAM8C,EAAM1C,EAAK2C,UAAUjF,OAAS,GAAGsC,EAAK2C,UAAU7C,KAAK,SAAW,GAEtE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAwB,CAAcpB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAQtC,EAAKhD,UAChCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,QAAStC,EAAKhD,UACjDR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,QAAAe,CAASV,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAcI,EAAKhD,UAC7BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,cAAeI,EAAKhD,UAC9BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,IAAAgB,CAAKZ,GACH,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,WAAAc,CAAYT,GACV,OAAOxD,KAAKoD,KACV,iBAAiBI,EAAKsC,QAAQtC,EAAKiB,SACnCjB,EAAKhD,SAET,CAKA,QAAAsE,CAAStB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKsC,OAAQtC,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,aAAaI,EAAKsC,QAAStC,EAAKhD,UAC1CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,YAAAW,CAAaP,GACX,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAkBI,EAAKsC,OAAQtC,EAAKhD,UAC9CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,kBAAkBI,EAAKsC,QAAStC,EAAKhD,UAC/CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,iBAAAe,CAAkBX,GAChB,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,wBAAwBI,EAAK4C,aAAc5C,EAAKhD,UAC1DR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KACH,GAAGpD,KAAKmD,gCAAgCK,EAAK4C,aAC7C5C,EAAKhD,UAEPR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAA4B,CAAMvB,GACJ,MAAM6C,EAAU7C,EAAKuB,MAAQ,IAAIvB,EAAKuB,QAAU,GAChD,OAAI/E,KAAKiD,SAELjD,KAAKoD,KAAK,SAASiD,IAAW7C,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,iBAAiBkD,IAAW7C,EAAKhD,UACnDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,cAAA+B,CAAe1B,GACb,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,mBAAoBI,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,oBAAqBI,EAAKhD,UACpCR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,WAAAyB,CAAYrB,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,iBAAiBI,EAAKsC,OAAQtC,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,iBAAiBI,EAAKsC,QAAStC,EAAKhD,UAC9CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAgC,CAAc5B,GACZ,MAAM6C,EAAU7C,EAAK6C,QAAU,IAAI7C,EAAK6C,UAAY,GACpD,GAAIrG,KAAKiD,SACP,OACEjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAOO,IAAW7C,EAAKhD,WACzCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAGR,IAAKI,EAAKmC,MACR,OAAO3F,KAAKoD,KACV,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,KAChC7C,EAAKhD,UAGT,MAAM8F,EAAiB9C,EAAKmC,MAAMY,KAC/BC,GAAMA,EAAEtE,OAAS9B,QAAAA,SAASuD,aAAe6C,EAAEtE,OAAS9B,QAAAA,SAASwD,SAE1D2B,EAAQe,EAAiB,OAAS,KACxC,OACEtG,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,IAAW7C,EAAKhD,UAC1DR,KAAKoD,KAAKkD,EAAiB,OAAOtG,KAAKmD,OAAO,KAAO,QACrDnD,KAAKoD,KAAKkD,EAAiB,GAAKtG,KAAKmD,OAAO,IAC5CnD,KAAKqF,SAA2B7B,EAAKmC,MAAOJ,GAC5CvF,KAAKoD,KACHkD,EACI,KAAKtG,KAAKmD,QAAO,KAAMnD,KAAKmD,YAC5B,GAAGnD,KAAKmD,eAAenD,KAAKmD,YAGtC,CAKA,IAAAO,CAAKF,GACH,MAAMuC,EAAQvC,EAAKwC,aACnB,IAAKD,EAAM7E,OACT,MAAO,GAGT,GAAIlB,KAAKiD,SACP,OACEjD,KAAKoD,KAAKI,EAAK2C,UAAU7C,KAAK,KAAME,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAGd,MAAMD,EAASnD,KAAKmD,SAEpB,OACEnD,KAAKoD,KACHI,EAAK2C,UACFvF,IAAK6F,GACGtD,EAASsD,GAEjBnD,KAAK,OACRE,EAAKhD,UAEPR,KAAKoD,KAAK,QACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,WAAAQ,CAAYH,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,GAAGI,EAAKsB,YAAYtB,EAAKnB,QAASmB,EAAKhD,UACjDR,KAAKoD,KAAK,KAGQ,wBAAlBI,EAAKsB,SAEL9E,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KACHI,EAAKsB,SACH,KACAtB,EAAKnB,MAAMqE,MAAM,MAAMpD,KAAK,KAAKqD,OAAO,IAAM3G,KAAKmD,UACrDK,EAAKhD,UAEPR,KAAKoD,KAAK,KAGZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAK,GAAGI,EAAKsB,aAAatB,EAAKnB,QAASmB,EAAKhD,UAClDR,KAAKoD,KAAK,IAEd,ECprBK,MAAMwD,EF2CQ,CACnB9G,EACAoD,KAEAA,EAAUA,GAAW,CAAA,EAKrB,IAAIrD,EAAS,EACTJ,EAAS,EAiBb,SAASe,IACP,MAAMN,EAAQ,CAAEV,KAAMK,EAAQJ,OAAQA,GACtC,OACE+D,IAECA,EAAYhD,SAAW,IAAIP,EAC1BC,EACA,CAAEV,KAAMK,EAAQJ,OAAQA,GACxByD,GAASxD,QAAU,IAErBmH,IACOrD,EAEX,CAKA,MAAMsD,EAAmC,GAEzC,SAASC,EAAMnH,GACb,MAAMoH,EAAM,IAAI5H,EACd8D,GAASxD,QAAU,GACnBE,EACAC,EACAJ,EACAK,GAGF,IAAIoD,GAAS+D,OAGX,MAAMD,EAFNF,EAAW/F,KAAKiG,EAIpB,CAuBA,SAASE,IACP,MAAMC,EAAY,QAAQC,KAAKtH,GAC/B,QAAIqH,IACFE,EAAaF,IACN,EAGX,CAKA,SAASG,IACP,MAAMC,EAAa,KAAKH,KAAKtH,GAC7B,QAAIyH,IACFF,EAAaE,IACN,EAGX,CA6CA,SAASF,EAAaG,GACpB,MAAM3F,EAAM2F,EAAE,GAGd,OAzIF,SAAwB3F,GACtB,MAAM4F,EAAQ5F,EAAI6F,MAAM,OACpBD,IACF5H,GAAU4H,EAAMvG,QAElB,MAAMuE,EAAI5D,EAAI8F,YAAY,MAC1BlI,GAAUgG,EAAI5D,EAAIX,OAASuE,EAAIhG,EAASoC,EAAIX,MAC9C,CAgIE0G,CAAe/F,GACf/B,EAAMA,EAAI+H,MAAMhG,EAAIX,QACbsG,CACT,CAKA,SAASX,IACP,MAAMW,EAAI,OAAOJ,KAAKtH,GAClB0H,GACFH,EAAaG,EAEjB,CAKA,SAASM,EACPnC,GAEAA,EAAQA,GAAS,GACjB,IAAIoC,EAA+BnE,IACnC,KAAOmE,GACLpC,EAAM5E,KAAKgH,GACXA,EAAInE,IAEN,OAAO+B,CACT,CAKA,SAAS/B,IACP,MAAMoE,EAAMxH,IACZ,GAAI,MAAQV,EAAImI,OAAO,IAAM,MAAQnI,EAAImI,OAAO,GAC9C,OAGF,MAAMT,EAAI,iBAAiBJ,KAAKtH,GAChC,OAAK0H,GAGLH,EAAaG,GAENQ,EAAmB,CACxB9F,KAAM9B,QAAAA,SAASwD,QACfA,QAAS4D,EAAE,GAAGK,MAAM,GAAG,MANhBd,EAAM,yBAQjB,CAKA,SAASmB,IACP,MAAMC,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,GAAgC,IAAbA,EACrB,OAEF,MAAMC,EAActI,EAAIuI,UAAU,EAAGF,GAErCd,EADkB,CAACe,IAMnB,MD5G2C,EAC7C9H,EACAC,KAEA,MAAM+H,EAAwB,GAC9B,IAAI7H,EAAkB,EACtB,KAAOA,EAAkBH,EAAOY,QAAQ,CACtC,MAAMqH,EAAQjH,EACZhB,EACAC,EACAE,GAEF,IAAc,IAAV8H,EAEF,OADAD,EAAOvH,KAAKT,EAAO+H,UAAU5H,IACtB6H,EAETA,EAAOvH,KAAKT,EAAO+H,UAAU5H,EAAiB8H,IAC9C9H,EAAkB8H,EAAQ,CAC5B,CACA,OAAOD,GCyFEE,CAFK5G,EAAKwG,GAAaK,QAAQ9G,EAAc,IAER,CAAC,MAAMf,IAAKC,GAAMe,EAAKf,GACrE,CAKA,SAAS8C,IACP,MAAMqE,EAAMxH,IAGNkI,EAAY,yCAAyCtB,KAAKtH,GAChE,IAAK4I,EACH,OAEFrB,EAAaqB,GACb,MAAMC,EAAY/G,EAAK8G,EAAU,IAG3BE,EAAiB,QAAQxB,KAAKtH,GACpC,IAAK8I,EACH,OAAO7B,EAAM,wBAEfM,EAAauB,GAGb,IAAIvG,EAAQ,GACZ,MAAMwG,EAAmBvH,EAAuCxB,EAAK,CACnE,IACA,MAEF,IAAyB,IAArB+I,EAAyB,CAC3BxG,EAAQvC,EAAIuI,UAAU,EAAGQ,GAEzBxB,EADkB,CAAChF,IAGnBA,EAAQT,EAAKS,GAAOoG,QAAQ9G,EAAc,GAC5C,CAEA,MAAMmH,EAAMd,EAAuB,CACjC9F,KAAM9B,QAAAA,SAASuD,YACfmB,SAAU6D,EAAUF,QAAQ9G,EAAc,IAC1CU,MAAOA,IAIH0G,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRD,CACT,CAMA,SAAS9C,IACP,MAAMD,EAAkD,GAExD,IAAKmB,IACH,OAAOH,EAAM,eAEfe,EAAS/B,GAGT,IAAIiD,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,IAGT,KAAOT,GAAS+D,QAAUnH,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC7D,MAAMgB,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,MAAgC,IAAbd,GAAmBc,EAAUd,GAclD,MANA,IAJAd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAAS/B,GACTiD,EAAOrF,IACAqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,GAKb,CAEA,OAAK2D,IAGEvB,EAFEgB,EAAM,cAGjB,CAMA,SAASmC,IACP,MAAMf,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,EACF,OAAO,EAET,MAAMc,EAAU3H,EAAuCxB,EAAK,CAAC,MACvDqJ,EAAW7H,EAAuCxB,EAAK,CAAC,MAE9D,SAAgB,IAAZmJ,GAAkBA,EAAUd,OAGf,IAAbgB,GAAmBA,EAAWhB,EAIpC,CAMA,SAASiB,IAGP,MAAMC,EAAiE,GAEvE,IAAKnC,IACH,OAAOH,EAAM,eAIf,IAFAe,EAASuB,GAEFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAMK,EAAU7F,IAChB,GAAI6F,EAAS,CACXF,EAAMtI,KAAKwI,GACXzB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CAEA,OAAK/B,IAGE+B,EAFEtC,EAAM,cAGjB,CAOA,SAASyC,IACP,MAAMH,EAAiE,GAGvE,IAFAxC,IACAiB,EAASuB,GACFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAM1C,EAAI9C,IACV,GAAI8C,EAAG,CACL6C,EAAMtI,KAAKyF,GACXsB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CACA,OAAOA,CACT,CAKA,SAAS9E,IACP,MAAMkF,EAAO,GACPzB,EAAMxH,IAEZ,IAAIgH,EAA4B,sCAAsCJ,KACpEtH,GAEF,KAAO0H,GAAG,CACR,MAAMkC,EAAMrC,EAAaG,GACzBiC,EAAK1I,KAAK2I,EAAI,IACd,MAAMC,EAAc,QAAQvC,KAAKtH,GAC7B6J,GACFtC,EAAasC,GAEfnC,EAAI,sCAAsCJ,KAAKtH,EACjD,CAEA,GAAK2J,EAAKvI,OAIV,OAAO8G,EAAoB,CACzB9F,KAAM9B,QAAAA,SAASmE,SACf0B,OAAQwD,EACRzD,aAAcA,KAAkB,IAEpC,CAyNA,MAkBM4D,EAAqB,IAAIC,OAC7B,MAnByB,CACzB,kBACA,WACA,aACA,YACA,mBACA,qBACA,cACA,gBACA,eACA,sBACA,WACA,cACA,cACA,YACA,eACA,gBAGyBvG,KAAK,uBAuWhC,MAAMwG,EAAWC,EAA6B,UAKxCC,EAAYD,EAA8B,WAK1CE,EAAcF,EAAgC,aAKpD,SAASA,EACPjE,GAEA,MAAMoE,EAAK,IAAIL,OACb,KACE/D,EACA,yEAKJ,MAAO,KACL,MAAMkC,EAAMxH,IACNgH,EAAI0C,EAAG9C,KAAKtH,GAClB,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GACnBsB,EAA8B,CAAE5G,KAAM4D,GAE5C,OADAgD,EAAIhD,GAAQ4D,EAAI,GAAG9H,OACZoG,EAAQc,GAEnB,CAyDA,SAAS3D,IACP,GAAe,MAAXrF,EAAI,GAIR,OAjrBF,WACE,MAAMkI,EAAMxH,IACN2J,EAAK,0BAA0B/C,KAAKtH,GAE1C,IAAKqK,EACH,OAEF,MAAMtE,EAASwB,EAAa8C,GAAI,GAG1BC,EAAK,eAAehD,KAAKtH,GAC/B,IAAKsK,EACH,OAAOrD,EAAM,2BAEf,MAAMjB,EAAOuB,EAAa+C,GAAI,GAE9B,IAAKlD,IACH,OAAOH,EAAM,0BAGf,IAAIsD,EAAgDvC,IAChDwC,EAAoC/F,IACxC,KAAO+F,GACLD,EAAOtJ,KAAKuJ,GACZD,EAASA,EAAOE,OAAOzC,KACvBwC,EAAQ/F,IAGV,OAAK+C,IAIEU,EAAqB,CAC1B9F,KAAM9B,QAAAA,SAASkE,UACfwB,KAAMA,EACND,OAAQA,EACRvB,UAAW+F,IAPJtD,EAAM,yBASjB,CA4oBIyD,IA7gBJ,WACE,MAAMxC,EAAMxH,IACNgH,EAAI,mBAAmBJ,KAAKtH,GAElC,IAAK0H,EACH,OAEF,MAAM/C,EAAQ7C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,QAAAA,SAASqE,MACfA,MAAOA,EACPkB,MAAO8E,IANA1D,EAAM,qBAQjB,CAsfI2D,IAjfJ,WACE,MAAM1C,EAAMxH,IACNgH,EAAI,8CAA8CJ,KAAKtH,GAC7D,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEzB,OAAOQ,EAAuB,CAC5B9F,KAAM9B,QAAAA,SAAS6D,YACf6B,KAAMlE,EAAK8H,EAAI,IACfjF,MAAO7C,EAAK8H,EAAI,KAEpB,CAqeIiB,IAzoBJ,WACE,MAAM3C,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GAErC,IAAK0H,EACH,OAEF,MAAMvC,EAAWrD,EAAKyF,EAAaG,GAAG,IAEtC,IAAKN,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,QAAAA,SAAS6E,SACfA,SAAUA,EACVU,MAAO8E,IANA1D,EAAM,wBAQjB,CAknBI6D,IACAd,KACAE,KACAC,KA7XJ,WACE,MAAMjC,EAAMxH,IACNgH,EAAI,+BAA+BJ,KAAKtH,GAC9C,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEnB3B,EAASjE,EAAK8H,EAAI,IAClB9D,EAAMhE,EAAK8H,EAAI,IAErB,IAAKxC,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,QAAAA,SAAS4D,SACfA,SAAU4B,EACVC,OAAQA,EACRF,MAAO8E,IAPA1D,EAAM,wBASjB,CAmWI8D,IA/aJ,WACE,MAAM7C,EAAMxH,IACNgH,EAAI,WAAWJ,KAAKtH,GAC1B,IAAK0H,EACH,OAEFH,EAAaG,GAEb,MAAMtB,EAAMgC,KAAc,GAE1B,IAAKhB,IACH,OAAOH,EAAM,qBAEf,MAAMhB,EAAiE,GAIvE,IAHA+B,EAAS/B,GAGFjG,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACNvD,EAAMhF,KAAKuI,GACXxB,EAAS/B,GACT,QACF,CACF,CACA,MAAMiD,EAAOrF,IACb,IAAIqF,EAKJ,MAJEjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,EAIb,CAEA,OAAKuB,IAIEU,EAAgB,CACrB9F,KAAM9B,QAAAA,SAASuE,KACfwB,UAAWD,EACXF,aAAcD,IANPgB,EAAM,oBAQjB,CAoYI+D,IAlnBJ,WACE,MAAM9C,EAAMxH,IACNgH,EAAI,YAAYJ,KAAKtH,GAE3B,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,qBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAgB,CACrB9F,KAAM9B,QAAAA,SAASgE,KACfuB,MAAO8E,IALA1D,EAAM,oBAOjB,CA4lBIgE,IAhWJ,WACE,MAAM/C,EAAMxH,IACNgH,EAAI,iBAAiBJ,KAAKtH,GAChC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,0BAEf,IAAIhB,EAAQ+B,IAGRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAGT,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,QAAAA,SAAS8D,SACf8B,aAAcD,IALPgB,EAAM,yBAOjB,CAoUIiE,IA/PJ,WACE,MAAMhD,EAAMxH,IACNgH,EAAI,kCAAkCJ,KAAKtH,GACjD,IAAK0H,EACH,OAEF,MAAMpB,EAAaxE,EAAKyF,EAAaG,GAAG,IAExC,IAAKN,IACH,OAAOH,EAAM,oCAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAA6B,CAClC9F,KAAM9B,QAAAA,SAAS+D,kBACfiC,WAAYA,EACZT,MAAO8E,IANA1D,EAAM,mCAQjB,CAyOIkE,IAzlBJ,WACE,MAAMjD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GAEtC,IAAK0H,EACH,OAEF,MAAM3D,EAAYjC,EAAKyF,EAAaG,GAAG,IAEvC,IAAKN,IACH,OAAOH,EAAM,0BAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAqB,CAC1B9F,KAAM9B,QAAAA,SAASyD,UACfA,UAAWA,EACX8B,MAAO8E,IANA1D,EAAM,yBAQjB,CAkkBImE,IA1IJ,WACE,MAAMlD,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GACrC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,+BAEf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,QAAAA,SAAS4E,cACfW,MAAO8E,IALA1D,EAAM,8BAOjB,CAsHIoE,IA9jBJ,WACE,MAAMnD,EAAMxH,IACNgH,EAAI,qBAAqBJ,KAAKtH,GAEpC,IAAK0H,EACH,OAEF,MAAMhD,EAAQ5C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IAAQ,CACX,MAAMkD,EAAK,UAAUhD,KAAKtH,GAI1B,OAHIsK,GACF/C,EAAa+C,GAERpC,EAAiB,CACtB9F,KAAM9B,QAAAA,SAASoE,MACfA,MAAOA,GAEX,CAEA,MAAMiG,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,QAAAA,SAASoE,MACfA,MAAOA,EACPmB,MAAO8E,IANA1D,EAAM,qBAQjB,CAgiBIqE,IAnUJ,WACE,MAAMpD,EAAMxH,IACNgH,EAAI,6BAA6BJ,KAAKtH,GAC5C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,yBAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,QAAAA,SAAS0E,SACfgB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,wBAQjB,CAySIsE,IApSJ,WACE,MAAMrD,EAAMxH,IACNgH,EAAI,gCAAgCJ,KAAKtH,GAC/C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,8BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAwB,CAC7B9F,KAAM9B,QAAAA,SAAS2D,aACf+B,KAAMA,EACNE,aAAcD,IANPgB,EAAM,6BAQjB,CA0QIuE,IAzOJ,WACE,MAAMtD,EAAMxH,IACNgH,EAAI,oBAAoBJ,KAAKtH,GACnC,IAAK0H,EACH,OAEF,MAAMzC,EAAQnD,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,QAAAA,SAAS2E,MACfA,MAAOA,EACPY,MAAO8E,IANA1D,EAAM,qBAQjB,CAmNIwE,IA9MJ,WACE,MAAMvD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GACtC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,gCAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAA0B,CAC/B9F,KAAM9B,QAAAA,SAAS8E,eACfc,aAAcD,IALPgB,EAAM,+BAOjB,CAqLIyE,IAhLJ,WACE,MAAMxD,EAAMxH,IACNgH,EAAI,iCAAiCJ,KAAKtH,GAChD,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,6BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAuB,CAC5B9F,KAAM9B,QAAAA,SAASyE,YACfiB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,4BAQjB,CAsJI0E,IA3dJ,WACE,MAAMzD,EAAMxH,IACNgH,EAAIoC,EAAmBxC,KAAKtH,GAClC,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,IAAIjB,iBAEnB,IAAIC,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAyB,CAC9B9F,KAAM9B,QAAAA,SAASwE,cACfkB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,IAAIjB,gBAQrB,CAicI4F,IA7EJ,WACE,MAAM1D,EAAMxH,IACNgH,EAAI,gBAAgBJ,KAAKtH,GAC/B,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAG7B,IAAInB,EAAU,GACd,MAAMsF,EAAarK,EAAuCxB,EAAK,CAAC,IAAK,OAClD,IAAf6L,GAAqBA,EAAa,IACpCtF,EAAUzE,EAAK9B,EAAIuI,UAAU,EAAGsD,IAIhCtE,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGsD,MAMrB,GAAIzE,IAAQ,CACV,MAAMuD,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,QAAAA,SAAS+E,OACfW,KAAMA,EACNO,QAASA,EACTV,MAAO8E,IAPA1D,EAAM,IAAIjB,gBASrB,CAGA,MAAMiD,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRf,EAAyB,CAC9B9F,KAAM9B,QAAAA,SAAS+E,OACfW,KAAMA,EACNO,QAASA,GAEb,CAgCIuF,EAEJ,CAKA,SAASlI,IACP,MAAMsE,EAAMxH,IACN0F,EAAMgC,IAEZ,OAAKhC,GAGL4B,IAEOE,EAAgB,CACrB9F,KAAM9B,QAAAA,SAASsD,KACfyC,UAAWD,EACXF,aAAcoD,KAAc,MAPrBrC,EAAM,mBASjB,CAEA,OAAOjF,EA1oCP,WACE,MAAM+J,EAyCR,WACE,IAAIrI,EACJ,MAAMmC,EAA0C,GAChDkB,IACAiB,EAASnC,GACT,KAAO7F,EAAIoB,QAAQ,CACjB,GAAsB,MAAlBpB,EAAImI,OAAO,GAAY,CACzB,GAAI/E,GAAS+D,OAAQ,CAEnBF,EAAM,aAENM,EADkB,CAAC,MAEnBR,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAEA,GADAnC,EAAO2B,KAAYzB,KACfF,EAGG,CACL,GAAIN,GAAS+D,OAAQ,CAGnBI,EADkB,CAACvH,EAAImI,OAAO,KAE9BpB,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAZEA,EAAM5E,KAAKyC,GACXsE,EAASnC,EAYb,CACA,OAAOA,CACT,CA5EoBA,GAWlB,MATiC,CAC/BzD,KAAM9B,QAAAA,SAASqD,WACfA,WAAY,CACV/D,OAAQwD,GAASxD,OACjBiG,MAAOkG,EACPC,cAAehF,GAKrB,CA6nCiBrD,KEtvCNsI,ECAE,CAACvI,EAAwBN,IACrB,IAAIJ,EAASI,GAAW,CAAA,GACzBwC,QAAQlC,GDE1B,IAAA+E,EAAe,CAAE3B,QAAOmF"} \ No newline at end of file diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.d.cts b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..208f4edf10bd077d23327a63e8f24c378191218f --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/cjs/adobe-css-tools.d.cts @@ -0,0 +1,224 @@ +declare class CssParseError extends Error { + readonly reason: string; + readonly filename?: string; + readonly line: number; + readonly column: number; + readonly source: string; + constructor(filename: string, msg: string, lineno: number, column: number, css: string); +} + +/** + * Store position information for a node + */ +declare class Position { + start: { + line: number; + column: number; + }; + end: { + line: number; + column: number; + }; + source?: string; + constructor(start: { + line: number; + column: number; + }, end: { + line: number; + column: number; + }, source: string); +} + +declare enum CssTypes { + stylesheet = "stylesheet", + rule = "rule", + declaration = "declaration", + comment = "comment", + atRule = "at-rule", + container = "container", + charset = "charset", + counterStyle = "counter-style", + document = "document", + customMedia = "custom-media", + fontFace = "font-face", + fontFeatureValues = "font-feature-values", + host = "host", + import = "import", + keyframes = "keyframes", + keyframe = "keyframe", + layer = "layer", + media = "media", + namespace = "namespace", + page = "page", + pageMarginBox = "page-margin-box", + positionTry = "position-try", + property = "property", + scope = "scope", + startingStyle = "starting-style", + supports = "supports", + viewTransition = "view-transition" +} +type CssCommonAST = { + type: CssTypes; +}; +type CssCommonPositionAST = CssCommonAST & { + position?: Position; + parent?: unknown; +}; +type CssStylesheetAST = CssCommonAST & { + type: CssTypes.stylesheet; + stylesheet: { + source?: string; + rules: Array; + parsingErrors?: Array; + }; +}; +type CssRuleAST = CssCommonPositionAST & { + type: CssTypes.rule; + selectors: Array; + declarations: Array; +}; +type CssDeclarationAST = CssCommonPositionAST & { + type: CssTypes.declaration; + property: string; + value: string; +}; +type CssCommentAST = CssCommonPositionAST & { + type: CssTypes.comment; + comment: string; +}; +type CssContainerAST = CssCommonPositionAST & { + type: CssTypes.container; + container: string; + rules: Array; +}; +type CssCharsetAST = CssCommonPositionAST & { + type: CssTypes.charset; + charset: string; +}; +type CssCustomMediaAST = CssCommonPositionAST & { + type: CssTypes.customMedia; + name: string; + media: string; +}; +type CssDocumentAST = CssCommonPositionAST & { + type: CssTypes.document; + document: string; + vendor?: string; + rules: Array; +}; +type CssFontFaceAST = CssCommonPositionAST & { + type: CssTypes.fontFace; + declarations: Array; +}; +type CssHostAST = CssCommonPositionAST & { + type: CssTypes.host; + rules: Array; +}; +type CssImportAST = CssCommonPositionAST & { + type: CssTypes.import; + import: string; +}; +type CssKeyframesAST = CssCommonPositionAST & { + type: CssTypes.keyframes; + name: string; + vendor?: string; + keyframes: Array; +}; +type CssKeyframeAST = CssCommonPositionAST & { + type: CssTypes.keyframe; + values: Array; + declarations: Array; +}; +type CssLayerAST = CssCommonPositionAST & { + type: CssTypes.layer; + layer: string; + rules?: Array; +}; +type CssMediaAST = CssCommonPositionAST & { + type: CssTypes.media; + media: string; + rules: Array; +}; +type CssNamespaceAST = CssCommonPositionAST & { + type: CssTypes.namespace; + namespace: string; +}; +type CssPageAST = CssCommonPositionAST & { + type: CssTypes.page; + selectors: Array; + declarations: Array; +}; +type CssSupportsAST = CssCommonPositionAST & { + type: CssTypes.supports; + supports: string; + rules: Array; +}; +type CssStartingStyleAST = CssCommonPositionAST & { + type: CssTypes.startingStyle; + rules: Array; +}; +type CssCounterStyleAST = CssCommonPositionAST & { + type: CssTypes.counterStyle; + name: string; + declarations: Array; +}; +type CssFontFeatureValuesAST = CssCommonPositionAST & { + type: CssTypes.fontFeatureValues; + fontFamily: string; + rules: Array; +}; +type CssPositionTryAST = CssCommonPositionAST & { + type: CssTypes.positionTry; + name: string; + declarations: Array; +}; +type CssPropertyAST = CssCommonPositionAST & { + type: CssTypes.property; + name: string; + declarations: Array; +}; +type CssScopeAST = CssCommonPositionAST & { + type: CssTypes.scope; + scope: string; + rules: Array; +}; +type CssViewTransitionAST = CssCommonPositionAST & { + type: CssTypes.viewTransition; + declarations: Array; +}; +type CssPageMarginBoxAST = CssCommonPositionAST & { + type: CssTypes.pageMarginBox; + name: string; + declarations: Array; +}; +type CssGenericAtRuleAST = CssCommonPositionAST & { + type: CssTypes.atRule; + name: string; + prelude: string; + rules?: Array; +}; +type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCounterStyleAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssFontFeatureValuesAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssPageMarginBoxAST | CssPositionTryAST | CssPropertyAST | CssScopeAST | CssSupportsAST | CssStartingStyleAST | CssViewTransitionAST | CssGenericAtRuleAST; +type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST; + +type CompilerOptions = { + indent?: string; + compress?: boolean; +}; + +declare const parse: (css: string, options?: { + source?: string; + silent?: boolean; +}) => CssStylesheetAST; +declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; + +declare const _default: { + parse: (css: string, options?: { + source?: string; + silent?: boolean; + }) => CssStylesheetAST; + stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; +}; + +export { CssTypes, _default as default, parse, stringify }; +export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCounterStyleAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssFontFeatureValuesAST, CssGenericAtRuleAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssPageMarginBoxAST, CssPositionTryAST, CssPropertyAST, CssRuleAST, CssScopeAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST, CssViewTransitionAST }; diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.d.mts b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..208f4edf10bd077d23327a63e8f24c378191218f --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.d.mts @@ -0,0 +1,224 @@ +declare class CssParseError extends Error { + readonly reason: string; + readonly filename?: string; + readonly line: number; + readonly column: number; + readonly source: string; + constructor(filename: string, msg: string, lineno: number, column: number, css: string); +} + +/** + * Store position information for a node + */ +declare class Position { + start: { + line: number; + column: number; + }; + end: { + line: number; + column: number; + }; + source?: string; + constructor(start: { + line: number; + column: number; + }, end: { + line: number; + column: number; + }, source: string); +} + +declare enum CssTypes { + stylesheet = "stylesheet", + rule = "rule", + declaration = "declaration", + comment = "comment", + atRule = "at-rule", + container = "container", + charset = "charset", + counterStyle = "counter-style", + document = "document", + customMedia = "custom-media", + fontFace = "font-face", + fontFeatureValues = "font-feature-values", + host = "host", + import = "import", + keyframes = "keyframes", + keyframe = "keyframe", + layer = "layer", + media = "media", + namespace = "namespace", + page = "page", + pageMarginBox = "page-margin-box", + positionTry = "position-try", + property = "property", + scope = "scope", + startingStyle = "starting-style", + supports = "supports", + viewTransition = "view-transition" +} +type CssCommonAST = { + type: CssTypes; +}; +type CssCommonPositionAST = CssCommonAST & { + position?: Position; + parent?: unknown; +}; +type CssStylesheetAST = CssCommonAST & { + type: CssTypes.stylesheet; + stylesheet: { + source?: string; + rules: Array; + parsingErrors?: Array; + }; +}; +type CssRuleAST = CssCommonPositionAST & { + type: CssTypes.rule; + selectors: Array; + declarations: Array; +}; +type CssDeclarationAST = CssCommonPositionAST & { + type: CssTypes.declaration; + property: string; + value: string; +}; +type CssCommentAST = CssCommonPositionAST & { + type: CssTypes.comment; + comment: string; +}; +type CssContainerAST = CssCommonPositionAST & { + type: CssTypes.container; + container: string; + rules: Array; +}; +type CssCharsetAST = CssCommonPositionAST & { + type: CssTypes.charset; + charset: string; +}; +type CssCustomMediaAST = CssCommonPositionAST & { + type: CssTypes.customMedia; + name: string; + media: string; +}; +type CssDocumentAST = CssCommonPositionAST & { + type: CssTypes.document; + document: string; + vendor?: string; + rules: Array; +}; +type CssFontFaceAST = CssCommonPositionAST & { + type: CssTypes.fontFace; + declarations: Array; +}; +type CssHostAST = CssCommonPositionAST & { + type: CssTypes.host; + rules: Array; +}; +type CssImportAST = CssCommonPositionAST & { + type: CssTypes.import; + import: string; +}; +type CssKeyframesAST = CssCommonPositionAST & { + type: CssTypes.keyframes; + name: string; + vendor?: string; + keyframes: Array; +}; +type CssKeyframeAST = CssCommonPositionAST & { + type: CssTypes.keyframe; + values: Array; + declarations: Array; +}; +type CssLayerAST = CssCommonPositionAST & { + type: CssTypes.layer; + layer: string; + rules?: Array; +}; +type CssMediaAST = CssCommonPositionAST & { + type: CssTypes.media; + media: string; + rules: Array; +}; +type CssNamespaceAST = CssCommonPositionAST & { + type: CssTypes.namespace; + namespace: string; +}; +type CssPageAST = CssCommonPositionAST & { + type: CssTypes.page; + selectors: Array; + declarations: Array; +}; +type CssSupportsAST = CssCommonPositionAST & { + type: CssTypes.supports; + supports: string; + rules: Array; +}; +type CssStartingStyleAST = CssCommonPositionAST & { + type: CssTypes.startingStyle; + rules: Array; +}; +type CssCounterStyleAST = CssCommonPositionAST & { + type: CssTypes.counterStyle; + name: string; + declarations: Array; +}; +type CssFontFeatureValuesAST = CssCommonPositionAST & { + type: CssTypes.fontFeatureValues; + fontFamily: string; + rules: Array; +}; +type CssPositionTryAST = CssCommonPositionAST & { + type: CssTypes.positionTry; + name: string; + declarations: Array; +}; +type CssPropertyAST = CssCommonPositionAST & { + type: CssTypes.property; + name: string; + declarations: Array; +}; +type CssScopeAST = CssCommonPositionAST & { + type: CssTypes.scope; + scope: string; + rules: Array; +}; +type CssViewTransitionAST = CssCommonPositionAST & { + type: CssTypes.viewTransition; + declarations: Array; +}; +type CssPageMarginBoxAST = CssCommonPositionAST & { + type: CssTypes.pageMarginBox; + name: string; + declarations: Array; +}; +type CssGenericAtRuleAST = CssCommonPositionAST & { + type: CssTypes.atRule; + name: string; + prelude: string; + rules?: Array; +}; +type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCounterStyleAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssFontFeatureValuesAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssPageMarginBoxAST | CssPositionTryAST | CssPropertyAST | CssScopeAST | CssSupportsAST | CssStartingStyleAST | CssViewTransitionAST | CssGenericAtRuleAST; +type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST; + +type CompilerOptions = { + indent?: string; + compress?: boolean; +}; + +declare const parse: (css: string, options?: { + source?: string; + silent?: boolean; +}) => CssStylesheetAST; +declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; + +declare const _default: { + parse: (css: string, options?: { + source?: string; + silent?: boolean; + }) => CssStylesheetAST; + stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; +}; + +export { CssTypes, _default as default, parse, stringify }; +export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCounterStyleAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssFontFeatureValuesAST, CssGenericAtRuleAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssPageMarginBoxAST, CssPositionTryAST, CssPropertyAST, CssRuleAST, CssScopeAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST, CssViewTransitionAST }; diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5e5f2ed189f96d57594acdb3971a9e7a1cf98234 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs @@ -0,0 +1,2 @@ +class t extends Error{reason;filename;line;column;source;constructor(t,i,e,s,n){super(`${t}:${e}:${s}: ${i}`),this.reason=i,this.filename=t,this.line=e,this.column=s,this.source=n}}class i{start;end;source;constructor(t,i,e){this.start=t,this.end=i,this.source=e}}var e;!function(t){t.stylesheet="stylesheet",t.rule="rule",t.declaration="declaration",t.comment="comment",t.atRule="at-rule",t.container="container",t.charset="charset",t.counterStyle="counter-style",t.document="document",t.customMedia="custom-media",t.fontFace="font-face",t.fontFeatureValues="font-feature-values",t.host="host",t.import="import",t.keyframes="keyframes",t.keyframe="keyframe",t.layer="layer",t.media="media",t.namespace="namespace",t.page="page",t.pageMarginBox="page-margin-box",t.positionTry="position-try",t.property="property",t.scope="scope",t.startingStyle="starting-style",t.supports="supports",t.viewTransition="view-transition"}(e||(e={}));const s=(t,i,e)=>{let s=e,n=1e4;do{const e=i.map(i=>t.indexOf(i,s));e.push(t.indexOf("\\",s));const r=e.filter(t=>-1!==t);if(0===r.length)return-1;const o=Math.min(...r);if("\\"!==t[o])return o;s=o+2,n--}while(n>0);throw new Error("Too many escaping")},n=(t,i,e)=>{let r=e,o=1e4;do{const e=i.map(i=>t.indexOf(i,r));e.push(t.indexOf("(",r)),e.push(t.indexOf('"',r)),e.push(t.indexOf("'",r)),e.push(t.indexOf("\\",r));const c=e.filter(t=>-1!==t);if(0===c.length)return-1;const h=Math.min(...c);switch(t[h]){case"\\":r=h+2;break;case"(":{const i=n(t,[")"],h+1);if(-1===i)return-1;r=i+1}break;case'"':{const i=s(t,['"'],h+1);if(-1===i)return-1;r=i+1}break;case"'":{const i=s(t,["'"],h+1);if(-1===i)return-1;r=i+1}break;default:return h}o--}while(o>0);throw new Error("Too many escaping")},r=/\/\*[^]*?(?:\*\/|$)/g;function o(t){return t?t.trim():""}function c(t,i){const e=t&&"string"==typeof t.type,s=e?t:i;for(const i in t){const e=t[i];Array.isArray(e)?e.forEach(t=>{c(t,s)}):e&&"object"==typeof e&&c(e,s)}return e&&Object.defineProperty(t,"parent",{configurable:!0,writable:!0,enumerable:!1,value:i||null}),t}class h{level=0;indentation=" ";compress=!1;constructor(t){"string"==typeof t?.indent&&(this.indentation=t?.indent),t?.compress&&(this.compress=!0)}emit(t,i){return t}indent(t){return this.level=this.level||1,t?(this.level+=t,""):Array(this.level).join(this.indentation)}visit(t){switch(t.type){case e.stylesheet:return this.stylesheet(t);case e.rule:return this.rule(t);case e.declaration:return this.declaration(t);case e.comment:return this.comment(t);case e.container:return this.container(t);case e.charset:return this.charset(t);case e.counterStyle:return this.counterStyle(t);case e.document:return this.document(t);case e.customMedia:return this.customMedia(t);case e.fontFace:return this.fontFace(t);case e.fontFeatureValues:return this.fontFeatureValues(t);case e.host:return this.host(t);case e.import:return this.import(t);case e.keyframes:return this.keyframes(t);case e.keyframe:return this.keyframe(t);case e.layer:return this.layer(t);case e.media:return this.media(t);case e.namespace:return this.namespace(t);case e.page:return this.page(t);case e.pageMarginBox:return this.pageMarginBox(t);case e.positionTry:return this.positionTry(t);case e.property:return this.property(t);case e.scope:return this.scope(t);case e.startingStyle:return this.startingStyle(t);case e.supports:return this.supports(t);case e.viewTransition:return this.viewTransition(t);case e.atRule:return this.genericAtRule(t)}}mapVisit(t,i){let e="";i=i||"";for(let s=0,n=t.length;st.type!==e.declaration&&t.type!==e.comment),n=s?"\n\n":"\n";return this.emit(`${this.indent()}@${t.name}${i}`,t.position)+this.emit(s?` {\n${this.indent(1)}`:" {\n")+this.emit(s?"":this.indent(1))+this.mapVisit(t.rules,n)+this.emit(s?`\n${this.indent(-1)}${this.indent()}}`:`${this.indent(-1)}\n${this.indent()}}`)}rule(t){const i=t.declarations;if(!i.length)return"";if(this.compress)return this.emit(t.selectors.join(","),t.position)+this.emit("{")+this.mapVisit(i)+this.emit("}");const e=this.indent();return this.emit(t.selectors.map(t=>e+t).join(",\n"),t.position)+this.emit(" {\n")+this.emit(this.indent(1))+this.mapVisit(i,"\n")+this.emit(this.indent(-1))+this.emit(`\n${this.indent()}}`)}declaration(t){return this.compress?this.emit(`${t.property}:${t.value}`,t.position)+this.emit(";"):"grid-template-areas"===t.property?this.emit(this.indent())+this.emit(t.property+": "+t.value.split("\n").join("\n".padEnd(22)+this.indent()),t.position)+this.emit(";"):this.emit(this.indent())+this.emit(`${t.property}: ${t.value}`,t.position)+this.emit(";")}}const a=(s,h)=>{h=h||{};let a=1,m=1;function u(){const t={line:a,column:m};return e=>(e.position=new i(t,{line:a,column:m},h?.source||""),g(),e)}const p=[];function l(i){const e=new t(h?.source||"",i,a,m,s);if(!h?.silent)throw e;p.push(e)}function f(){const t=/^{\s*/.exec(s);return!!t&&(y(t),!0)}function d(){const t=/^}/.exec(s);return!!t&&(y(t),!0)}function y(t){const i=t[0];return function(t){const i=t.match(/\n/g);i&&(a+=i.length);const e=t.lastIndexOf("\n");m=~e?t.length-e:m+t.length}(i),s=s.slice(i.length),t}function g(){const t=/^\s*/.exec(s);t&&y(t)}function $(t){t=t||[];let i=x();for(;i;)t.push(i),i=x();return t}function x(){const t=u();if("/"!==s.charAt(0)||"*"!==s.charAt(1))return;const i=/^\/\*[^]*?\*\//.exec(s);return i?(y(i),t({type:e.comment,comment:i[0].slice(2,-2)})):l("End of comment missing")}function V(){const t=n(s,["{"]);if(-1===t||0===t)return;const i=s.substring(0,t);y([i]);return((t,i)=>{const e=[];let s=0;for(;so(t))}function v(){const t=u(),i=/^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/.exec(s);if(!i)return;y(i);const c=o(i[0]),h=/^:\s*/.exec(s);if(!h)return l("property missing ':'");y(h);let a="";const m=n(s,[";","}"]);if(-1!==m){a=s.substring(0,m);y([a]),a=o(a).replace(r,"")}const p=t({type:e.declaration,property:c.replace(r,""),value:a}),f=/^[;\s]*/.exec(s);return f&&y(f),p}function w(){const t=[];if(!f())return l("missing '{'");$(t);let i=v();for(;i;)t.push(i),$(t),i=v();for(;h?.silent&&s.length&&"}"!==s.charAt(0);){const e=s.indexOf(";"),n=s.indexOf("}");if(-1===e||!(-1===n||e{const e=u(),n=i.exec(s);if(!n)return;const r=y(n),o={type:t};return o[t]=r[1].trim(),e(o)}}function E(){if("@"===s[0])return function(){const t=u(),i=/^@([-\w]+)?keyframes\s*/.exec(s);if(!i)return;const n=y(i)[1],r=/^([-\w]+)\s*/.exec(s);if(!r)return l("@keyframes missing name");const o=y(r)[1];if(!f())return l("@keyframes missing '{'");let c=$(),h=O();for(;h;)c.push(h),c=c.concat($()),h=O();return d()?t({type:e.keyframes,name:o,vendor:n,keyframes:c}):l("@keyframes missing '}'")}()||function(){const t=u(),i=/^@media *([^{]+)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f())return l("@media missing '{'");const r=A();return d()?t({type:e.media,media:n,rules:r}):l("@media missing '}'")}()||function(){const t=u(),i=/^@custom-media\s+(--\S+)\s+([^{;\s][^{;]*);/.exec(s);if(!i)return;const n=y(i);return t({type:e.customMedia,name:o(n[1]),media:o(n[2])})}()||function(){const t=u(),i=/^@supports *([^{]+)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f())return l("@supports missing '{'");const r=A();return d()?t({type:e.supports,supports:n,rules:r}):l("@supports missing '}'")}()||j()||M()||T()||function(){const t=u(),i=/^@([-\w]+)?document *([^{]+)/.exec(s);if(!i)return;const n=y(i),r=o(n[1]),c=o(n[2]);if(!f())return l("@document missing '{'");const h=A();return d()?t({type:e.document,document:c,vendor:r,rules:h}):l("@document missing '}'")}()||function(){const t=u(),i=/^@page */.exec(s);if(!i)return;y(i);const n=V()||[];if(!f())return l("@page missing '{'");const r=[];for($(r);s.length&&"}"!==s.charAt(0);){if("@"===s.charAt(0)){const t=E();if(t){r.push(t),$(r);continue}}const t=v();if(!t)break;r.push(t),$(r)}return d()?t({type:e.page,selectors:n,declarations:r}):l("@page missing '}'")}()||function(){const t=u(),i=/^@host\s*/.exec(s);if(!i)return;if(y(i),!f())return l("@host missing '{'");const n=A();return d()?t({type:e.host,rules:n}):l("@host missing '}'")}()||function(){const t=u(),i=/^@font-face\s*/.exec(s);if(!i)return;if(y(i),!f())return l("@font-face missing '{'");let n=$(),r=v();for(;r;)n.push(r),n=n.concat($()),r=v();return d()?t({type:e.fontFace,declarations:n}):l("@font-face missing '}'")}()||function(){const t=u(),i=/^@font-feature-values\s+([^{]+)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f())return l("@font-feature-values missing '{'");const r=A();return d()?t({type:e.fontFeatureValues,fontFamily:n,rules:r}):l("@font-feature-values missing '}'")}()||function(){const t=u(),i=/^@container *([^{]+)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f())return l("@container missing '{'");const r=A();return d()?t({type:e.container,container:n,rules:r}):l("@container missing '}'")}()||function(){const t=u(),i=/^@starting-style\s*/.exec(s);if(!i)return;if(y(i),!f())return l("@starting-style missing '{'");const n=A();return d()?t({type:e.startingStyle,rules:n}):l("@starting-style missing '}'")}()||function(){const t=u(),i=/^@layer *([^{;@]+)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f()){const i=/^[;\s]*/.exec(s);return i&&y(i),t({type:e.layer,layer:n})}const r=A();return d()?t({type:e.layer,layer:n,rules:r}):l("@layer missing '}'")}()||function(){const t=u(),i=/^@property\s+(--[-\w]+)\s*/.exec(s);if(!i)return;const n=y(i)[1];if(!f())return l("@property missing '{'");let r=$(),o=v();for(;o;)r.push(o),r=r.concat($()),o=v();return d()?t({type:e.property,name:n,declarations:r}):l("@property missing '}'")}()||function(){const t=u(),i=/^@counter-style\s+([-\w]+)\s*/.exec(s);if(!i)return;const n=y(i)[1];if(!f())return l("@counter-style missing '{'");let r=$(),o=v();for(;o;)r.push(o),r=r.concat($()),o=v();return d()?t({type:e.counterStyle,name:n,declarations:r}):l("@counter-style missing '}'")}()||function(){const t=u(),i=/^@scope\s*([^{]*)/.exec(s);if(!i)return;const n=o(y(i)[1]);if(!f())return l("@scope missing '{'");const r=A();return d()?t({type:e.scope,scope:n,rules:r}):l("@scope missing '}'")}()||function(){const t=u(),i=/^@view-transition\s*/.exec(s);if(!i)return;if(y(i),!f())return l("@view-transition missing '{'");let n=$(),r=v();for(;r;)n.push(r),n=n.concat($()),r=v();return d()?t({type:e.viewTransition,declarations:n}):l("@view-transition missing '}'")}()||function(){const t=u(),i=/^@position-try\s+(--[-\w]+)\s*/.exec(s);if(!i)return;const n=y(i)[1];if(!f())return l("@position-try missing '{'");let r=$(),o=v();for(;o;)r.push(o),r=r.concat($()),o=v();return d()?t({type:e.positionTry,name:n,declarations:r}):l("@position-try missing '}'")}()||function(){const t=u(),i=F.exec(s);if(!i)return;const n=y(i)[1];if(!f())return l(`@${n} missing '{'`);let r=$(),o=v();for(;o;)r.push(o),r=r.concat($()),o=v();return d()?t({type:e.pageMarginBox,name:n,declarations:r}):l(`@${n} missing '}'`)}()||function(){const t=u(),i=/^@([-\w]+)\s*/.exec(s);if(!i)return;const r=y(i)[1];let c="";const h=n(s,["{",";"]);-1!==h&&h>0&&(c=o(s.substring(0,h)),y([s.substring(0,h)]));if(f()){const i=A();return d()?t({type:e.atRule,name:r,prelude:c,rules:i}):l(`@${r} missing '}'`)}const a=/^[;\s]*/.exec(s);return a&&y(a),t({type:e.atRule,name:r,prelude:c})}()}function R(){const t=u(),i=V();return i?($(),t({type:e.rule,selectors:i,declarations:k()||[]})):l("selector missing")}return c(function(){const t=function(){let t;const i=[];g(),$(i);for(;s.length;){if("}"===s.charAt(0)){if(h?.silent){l("extra '}'");y(["}"]),g(),$(i);continue}break}if(t=E()||R(),!t){if(h?.silent){y([s.charAt(0)]),g(),$(i);continue}break}i.push(t),$(i)}return i}();return{type:e.stylesheet,stylesheet:{source:h?.source,rules:t,parsingErrors:p}}}())},m=(t,i)=>new h(i||{}).compile(t);var u={parse:a,stringify:m};export{e as CssTypes,u as default,a as parse,m as stringify}; +//# sourceMappingURL=adobe-css-tools.mjs.map diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs.map b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..c64582b8859dad2e9798f7c42c73c2242b3c63c0 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/esm/adobe-css-tools.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"adobe-css-tools.mjs","sources":["../../src/CssParseError.ts","../../src/CssPosition.ts","../../src/type.ts","../../src/utils/stringSearch.ts","../../src/parse/index.ts","../../src/stringify/compiler.ts","../../src/index.ts","../../src/stringify/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":["CssParseError","Error","reason","filename","line","column","source","constructor","msg","lineno","css","super","this","Position","start","end","CssTypes","indexOfArrayNonEscaped","string","search","position","currentPosition","maxLoop","all","map","v","indexOf","push","foundAll","filter","length","found","Math","min","indexOfArrayWithBracketAndQuoteSupport","currentSearchPosition","firstMatchPos","endPosition","endQuotePosition","commentRegex","trim","str","addParent","obj","parent","isNode","type","childParent","k","value","Array","isArray","forEach","Object","defineProperty","configurable","writable","enumerable","Compiler","level","indentation","compress","options","indent","emit","_position","join","visit","node","stylesheet","rule","declaration","comment","container","charset","counterStyle","document","customMedia","fontFace","fontFeatureValues","host","import","keyframes","keyframe","layer","media","namespace","page","pageMarginBox","positionTry","property","scope","startingStyle","supports","viewTransition","atRule","genericAtRule","mapVisit","nodes","delim","buf","i","compile","rules","doc","vendor","name","decls","declarations","values","sel","selectors","fontFamily","prelude","hasNestedRules","some","r","s","split","padEnd","parse","whitespace","errorsList","error","err","silent","open","openMatch","exec","processMatch","close","closeMatch","m","lines","match","lastIndexOf","updatePosition","slice","comments","c","pos","charAt","selector","bracePos","selectorStr","substring","result","index","splitWithBracketAndQuoteSupport","replace","propMatch","propValue","separatorMatch","endValuePosition","ret","endMatch","decl","semiPos","looksLikeNestedRule","closePos","ruleBody","items","ar","nestedR","rulesOrDeclarations","vals","res","spacesMatch","pageMarginBoxRegex","RegExp","atImport","_compileAtRule","atCharset","atNamespace","re","m1","m2","frames","frame","concat","atKeyframes","style","atMedia","atCustomMedia","atSupports","atDocument","atPage","atHost","atFontFace","atFontFeatureValues","atContainer","atStartingStyle","atLayer","atProperty","atCounterStyle","atScope","atViewTransition","atPositionTry","atPageMarginBox","preludeEnd","atGeneric","rulesList","parsingErrors","stringify"],"mappings":"AAAc,MAAOA,UAAsBC,MAChCC,OACAC,SACAC,KACAC,OACAC,OAET,WAAAC,CACEJ,EACAK,EACAC,EACAJ,EACAK,GAEAC,MAAM,GAAGR,KAAYM,KAAUJ,MAAWG,KAC1CI,KAAKV,OAASM,EACdI,KAAKT,SAAWA,EAChBS,KAAKR,KAAOK,EACZG,KAAKP,OAASA,EACdO,KAAKN,OAASI,CAChB,ECjBY,MAAOG,EACnBC,MACAC,IACAT,OAEA,WAAAC,CACEO,EACAC,EACAT,GAEAM,KAAKE,MAAQA,EACbF,KAAKG,IAAMA,EACXH,KAAKN,OAASA,CAChB,MCbUU,GAAZ,SAAYA,GACVA,EAAA,WAAA,aACAA,EAAA,KAAA,OACAA,EAAA,YAAA,cACAA,EAAA,QAAA,UACAA,EAAA,OAAA,UACAA,EAAA,UAAA,YACAA,EAAA,QAAA,UACAA,EAAA,aAAA,gBACAA,EAAA,SAAA,WACAA,EAAA,YAAA,eACAA,EAAA,SAAA,YACAA,EAAA,kBAAA,sBACAA,EAAA,KAAA,OACAA,EAAA,OAAA,SACAA,EAAA,UAAA,YACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,MAAA,QACAA,EAAA,UAAA,YACAA,EAAA,KAAA,OACAA,EAAA,cAAA,kBACAA,EAAA,YAAA,eACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,cAAA,iBACAA,EAAA,SAAA,WACAA,EAAA,eAAA,iBACD,CA5BD,CAAYA,IAAAA,EAAQ,CAAA,ICHb,MAkBMC,EAAyB,CACpCC,EACAC,EACAC,KAEA,IAAIC,EAAkBD,EAClBE,EAxBkB,IAyBtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGJ,IAChDE,EAAII,KAAKT,EAAOQ,QAAQ,KAAML,IAC9B,MAAMO,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMC,EAAQC,KAAKC,OAAOL,GAC1B,GAAsB,OAAlBV,EAAOa,GAIT,OAAOA,EAHPV,EAAkBU,EAAQ,EAC1BT,GAIJ,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBA0BLiC,EAAyC,CACpDhB,EACAC,EACAC,KAEA,IAAIe,EAAwBf,EACxBE,EA1EkB,IA4EtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGU,IAEhDZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,KAAMS,IAE9B,MAAMP,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMM,EAAgBJ,KAAKC,OAAOL,GAElC,OADaV,EAAOkB,IAElB,IAAK,KACHD,EAAwBC,EAAgB,EACxC,MACF,IAAK,IACH,CACE,MAAMC,EAAcH,EAClBhB,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAoB,IAAhBC,EACF,OAAO,EAETF,EAAwBE,EAAc,CACxC,CACA,MACF,IAAK,IACH,CACE,MAAMC,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,IAAK,IACH,CACE,MAAMA,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,QACE,OAAOF,EAEXd,GACF,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBCjGZsC,EAAe,uBAotCrB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAID,OAAS,EAC5B,CAKA,SAASE,EACPC,EACAC,GAEA,MAAMC,EAASF,GAA2B,iBAAbA,EAAIG,KAC3BC,EAAcF,EAASF,EAAMC,EAEnC,IAAK,MAAMI,KAAKL,EAAK,CACnB,MAAMM,EAAQN,EAAIK,GACdE,MAAMC,QAAQF,GAChBA,EAAMG,QAAS3B,IACbiB,EAAUjB,EAAGsB,KAENE,GAA0B,iBAAVA,GACzBP,EAAUO,EAAOF,EAErB,CAWA,OATIF,GACFQ,OAAOC,eAAeX,EAAK,SAAU,CACnCY,cAAc,EACdC,UAAU,EACVC,YAAY,EACZR,MAAOL,GAAU,OAIdD,CACT,CC5vCA,MAAMe,EACJC,MAAQ,EACRC,YAAc,KACdC,UAAW,EAEX,WAAAtD,CAAYuD,GACqB,iBAApBA,GAASC,SAClBnD,KAAKgD,YAAcE,GAASC,QAE1BD,GAASD,WACXjD,KAAKiD,UAAW,EAEpB,CAIA,IAAAG,CAAKvB,EAAawB,GAChB,OAAOxB,CACT,CAKA,MAAAsB,CAAOJ,GAGL,OAFA/C,KAAK+C,MAAQ/C,KAAK+C,OAAS,EAEvBA,GACF/C,KAAK+C,OAASA,EACP,IAGFT,MAAMtC,KAAK+C,OAAOO,KAAKtD,KAAKgD,YACrC,CAEA,KAAAO,CAAMC,GACJ,OAAQA,EAAKtB,MACX,KAAK9B,EAASqD,WACZ,OAAOzD,KAAKyD,WAAWD,GACzB,KAAKpD,EAASsD,KACZ,OAAO1D,KAAK0D,KAAKF,GACnB,KAAKpD,EAASuD,YACZ,OAAO3D,KAAK2D,YAAYH,GAC1B,KAAKpD,EAASwD,QACZ,OAAO5D,KAAK4D,QAAQJ,GACtB,KAAKpD,EAASyD,UACZ,OAAO7D,KAAK6D,UAAUL,GACxB,KAAKpD,EAAS0D,QACZ,OAAO9D,KAAK8D,QAAQN,GACtB,KAAKpD,EAAS2D,aACZ,OAAO/D,KAAK+D,aAAaP,GAC3B,KAAKpD,EAAS4D,SACZ,OAAOhE,KAAKgE,SAASR,GACvB,KAAKpD,EAAS6D,YACZ,OAAOjE,KAAKiE,YAAYT,GAC1B,KAAKpD,EAAS8D,SACZ,OAAOlE,KAAKkE,SAASV,GACvB,KAAKpD,EAAS+D,kBACZ,OAAOnE,KAAKmE,kBAAkBX,GAChC,KAAKpD,EAASgE,KACZ,OAAOpE,KAAKoE,KAAKZ,GACnB,KAAKpD,EAASiE,OACZ,OAAOrE,KAAKqE,OAAOb,GACrB,KAAKpD,EAASkE,UACZ,OAAOtE,KAAKsE,UAAUd,GACxB,KAAKpD,EAASmE,SACZ,OAAOvE,KAAKuE,SAASf,GACvB,KAAKpD,EAASoE,MACZ,OAAOxE,KAAKwE,MAAMhB,GACpB,KAAKpD,EAASqE,MACZ,OAAOzE,KAAKyE,MAAMjB,GACpB,KAAKpD,EAASsE,UACZ,OAAO1E,KAAK0E,UAAUlB,GACxB,KAAKpD,EAASuE,KACZ,OAAO3E,KAAK2E,KAAKnB,GACnB,KAAKpD,EAASwE,cACZ,OAAO5E,KAAK4E,cAAcpB,GAC5B,KAAKpD,EAASyE,YACZ,OAAO7E,KAAK6E,YAAYrB,GAC1B,KAAKpD,EAAS0E,SACZ,OAAO9E,KAAK8E,SAAStB,GACvB,KAAKpD,EAAS2E,MACZ,OAAO/E,KAAK+E,MAAMvB,GACpB,KAAKpD,EAAS4E,cACZ,OAAOhF,KAAKgF,cAAcxB,GAC5B,KAAKpD,EAAS6E,SACZ,OAAOjF,KAAKiF,SAASzB,GACvB,KAAKpD,EAAS8E,eACZ,OAAOlF,KAAKkF,eAAe1B,GAC7B,KAAKpD,EAAS+E,OACZ,OAAOnF,KAAKoF,cAAc5B,GAEhC,CAEA,QAAA6B,CAASC,EAA8BC,GACrC,IAAIC,EAAM,GACVD,EAAQA,GAAS,GAEjB,IAAK,IAAIE,EAAI,EAAGvE,EAASoE,EAAMpE,OAAQuE,EAAIvE,EAAQuE,IACjDD,GAAOxF,KAAKuD,MAAM+B,EAAMG,IACpBF,GAASE,EAAIvE,EAAS,IACxBsE,GAAOxF,KAAKoD,KAAKmC,IAIrB,OAAOC,CACT,CAEA,OAAAE,CAAQlC,GACN,OAAIxD,KAAKiD,SACAO,EAAKC,WAAWkC,MAAM/E,IAAIZ,KAAKuD,MAAOvD,MAAMsD,KAAK,IAGnDtD,KAAKyD,WAAWD,EACzB,CAKA,UAAAC,CAAWD,GACT,OAAOxD,KAAKqF,SAAS7B,EAAKC,WAAWkC,MAAO,OAC9C,CAKA,OAAA/B,CAAQJ,GACN,OAAIxD,KAAKiD,SACAjD,KAAKoD,KAAK,GAAII,EAAKhD,UAErBR,KAAKoD,KAAK,GAAGpD,KAAKmD,aAAaK,EAAKI,YAAaJ,EAAKhD,SAC/D,CAKA,SAAAqD,CAAUL,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,cAAcI,EAAKK,YAAaL,EAAKhD,UAC/CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,sBAAsBK,EAAKK,YAAaL,EAAKhD,UAC/DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAAqB,CAAMhB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKgB,QAAShB,EAAKhD,WACtCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAINpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKgB,QAAShB,EAAKhD,WACtDgD,EAAKmC,MACF3F,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAA2B7B,EAAKmC,MAAO,QAC5C3F,KAAKoD,KAAK,KAAKpD,KAAKmD,QAAO,KAAMnD,KAAKmD,aACtC,IAER,CAKA,MAAAkB,CAAOb,GACL,OAAOxD,KAAKoD,KAAK,WAAWI,EAAKa,UAAWb,EAAKhD,SACnD,CAKA,KAAAiE,CAAMjB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKiB,QAASjB,EAAKhD,UACvCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKiB,QAASjB,EAAKhD,UACvDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAAa,CAASR,GACP,MAAMoC,EAAM,IAAIpC,EAAKqC,QAAU,cAAcrC,EAAKQ,WAClD,OAAIhE,KAAKiD,SAELjD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,QAAQpD,KAAKmD,OAAO,MAC9BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,OAAAW,CAAQN,GACN,OAAOxD,KAAKoD,KAAK,YAAYI,EAAKM,WAAYN,EAAKhD,SACrD,CAKA,SAAAkE,CAAUlB,GACR,OAAOxD,KAAKoD,KAAK,cAAcI,EAAKkB,aAAclB,EAAKhD,SACzD,CAKA,aAAAwE,CAAcxB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAmBI,EAAKhD,UAClCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,0BAA2BK,EAAKhD,UAClDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAA8B,CAASzB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKyB,WAAYzB,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,qBAAqBK,EAAKyB,WAAYzB,EAAKhD,UAC7DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,SAAAmB,CAAUd,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KACH,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OACvCtC,EAAKhD,UAEPR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKc,WACnBtE,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OAAQtC,EAAKhD,UAC9DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKc,UAAW,MAC9BtE,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,MAE7B,CAKA,QAAAoB,CAASf,GACP,MAAMuC,EAAQvC,EAAKwC,aACnB,OAAIhG,KAAKiD,SAELjD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,KAAME,EAAKhD,UACtCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAKZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,MAAOE,EAAKhD,UACvCR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,OAAQnD,KAAKmD,cAE1C,CAKA,IAAAwB,CAAKnB,GACH,GAAIxD,KAAKiD,SAAU,CACjB,MAAMiD,EAAM1C,EAAK2C,UAAUjF,OAASsC,EAAK2C,UAAU7C,KAAK,MAAQ,GAEhE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,IAEd,CACA,MAAM8C,EAAM1C,EAAK2C,UAAUjF,OAAS,GAAGsC,EAAK2C,UAAU7C,KAAK,SAAW,GAEtE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAwB,CAAcpB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAQtC,EAAKhD,UAChCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,QAAStC,EAAKhD,UACjDR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,QAAAe,CAASV,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAcI,EAAKhD,UAC7BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,cAAeI,EAAKhD,UAC9BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,IAAAgB,CAAKZ,GACH,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,WAAAc,CAAYT,GACV,OAAOxD,KAAKoD,KACV,iBAAiBI,EAAKsC,QAAQtC,EAAKiB,SACnCjB,EAAKhD,SAET,CAKA,QAAAsE,CAAStB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKsC,OAAQtC,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,aAAaI,EAAKsC,QAAStC,EAAKhD,UAC1CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,YAAAW,CAAaP,GACX,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAkBI,EAAKsC,OAAQtC,EAAKhD,UAC9CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,kBAAkBI,EAAKsC,QAAStC,EAAKhD,UAC/CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,iBAAAe,CAAkBX,GAChB,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,wBAAwBI,EAAK4C,aAAc5C,EAAKhD,UAC1DR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KACH,GAAGpD,KAAKmD,gCAAgCK,EAAK4C,aAC7C5C,EAAKhD,UAEPR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAA4B,CAAMvB,GACJ,MAAM6C,EAAU7C,EAAKuB,MAAQ,IAAIvB,EAAKuB,QAAU,GAChD,OAAI/E,KAAKiD,SAELjD,KAAKoD,KAAK,SAASiD,IAAW7C,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,iBAAiBkD,IAAW7C,EAAKhD,UACnDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,cAAA+B,CAAe1B,GACb,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,mBAAoBI,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,oBAAqBI,EAAKhD,UACpCR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,WAAAyB,CAAYrB,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,iBAAiBI,EAAKsC,OAAQtC,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,iBAAiBI,EAAKsC,QAAStC,EAAKhD,UAC9CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAgC,CAAc5B,GACZ,MAAM6C,EAAU7C,EAAK6C,QAAU,IAAI7C,EAAK6C,UAAY,GACpD,GAAIrG,KAAKiD,SACP,OACEjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAOO,IAAW7C,EAAKhD,WACzCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAGR,IAAKI,EAAKmC,MACR,OAAO3F,KAAKoD,KACV,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,KAChC7C,EAAKhD,UAGT,MAAM8F,EAAiB9C,EAAKmC,MAAMY,KAC/BC,GAAMA,EAAEtE,OAAS9B,EAASuD,aAAe6C,EAAEtE,OAAS9B,EAASwD,SAE1D2B,EAAQe,EAAiB,OAAS,KACxC,OACEtG,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,IAAW7C,EAAKhD,UAC1DR,KAAKoD,KAAKkD,EAAiB,OAAOtG,KAAKmD,OAAO,KAAO,QACrDnD,KAAKoD,KAAKkD,EAAiB,GAAKtG,KAAKmD,OAAO,IAC5CnD,KAAKqF,SAA2B7B,EAAKmC,MAAOJ,GAC5CvF,KAAKoD,KACHkD,EACI,KAAKtG,KAAKmD,QAAO,KAAMnD,KAAKmD,YAC5B,GAAGnD,KAAKmD,eAAenD,KAAKmD,YAGtC,CAKA,IAAAO,CAAKF,GACH,MAAMuC,EAAQvC,EAAKwC,aACnB,IAAKD,EAAM7E,OACT,MAAO,GAGT,GAAIlB,KAAKiD,SACP,OACEjD,KAAKoD,KAAKI,EAAK2C,UAAU7C,KAAK,KAAME,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAGd,MAAMD,EAASnD,KAAKmD,SAEpB,OACEnD,KAAKoD,KACHI,EAAK2C,UACFvF,IAAK6F,GACGtD,EAASsD,GAEjBnD,KAAK,OACRE,EAAKhD,UAEPR,KAAKoD,KAAK,QACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,WAAAQ,CAAYH,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,GAAGI,EAAKsB,YAAYtB,EAAKnB,QAASmB,EAAKhD,UACjDR,KAAKoD,KAAK,KAGQ,wBAAlBI,EAAKsB,SAEL9E,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KACHI,EAAKsB,SACH,KACAtB,EAAKnB,MAAMqE,MAAM,MAAMpD,KAAK,KAAKqD,OAAO,IAAM3G,KAAKmD,UACrDK,EAAKhD,UAEPR,KAAKoD,KAAK,KAGZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAK,GAAGI,EAAKsB,aAAatB,EAAKnB,QAASmB,EAAKhD,UAClDR,KAAKoD,KAAK,IAEd,ECprBK,MAAMwD,EF2CQ,CACnB9G,EACAoD,KAEAA,EAAUA,GAAW,CAAA,EAKrB,IAAIrD,EAAS,EACTJ,EAAS,EAiBb,SAASe,IACP,MAAMN,EAAQ,CAAEV,KAAMK,EAAQJ,OAAQA,GACtC,OACE+D,IAECA,EAAYhD,SAAW,IAAIP,EAC1BC,EACA,CAAEV,KAAMK,EAAQJ,OAAQA,GACxByD,GAASxD,QAAU,IAErBmH,IACOrD,EAEX,CAKA,MAAMsD,EAAmC,GAEzC,SAASC,EAAMnH,GACb,MAAMoH,EAAM,IAAI5H,EACd8D,GAASxD,QAAU,GACnBE,EACAC,EACAJ,EACAK,GAGF,IAAIoD,GAAS+D,OAGX,MAAMD,EAFNF,EAAW/F,KAAKiG,EAIpB,CAuBA,SAASE,IACP,MAAMC,EAAY,QAAQC,KAAKtH,GAC/B,QAAIqH,IACFE,EAAaF,IACN,EAGX,CAKA,SAASG,IACP,MAAMC,EAAa,KAAKH,KAAKtH,GAC7B,QAAIyH,IACFF,EAAaE,IACN,EAGX,CA6CA,SAASF,EAAaG,GACpB,MAAM3F,EAAM2F,EAAE,GAGd,OAzIF,SAAwB3F,GACtB,MAAM4F,EAAQ5F,EAAI6F,MAAM,OACpBD,IACF5H,GAAU4H,EAAMvG,QAElB,MAAMuE,EAAI5D,EAAI8F,YAAY,MAC1BlI,GAAUgG,EAAI5D,EAAIX,OAASuE,EAAIhG,EAASoC,EAAIX,MAC9C,CAgIE0G,CAAe/F,GACf/B,EAAMA,EAAI+H,MAAMhG,EAAIX,QACbsG,CACT,CAKA,SAASX,IACP,MAAMW,EAAI,OAAOJ,KAAKtH,GAClB0H,GACFH,EAAaG,EAEjB,CAKA,SAASM,EACPnC,GAEAA,EAAQA,GAAS,GACjB,IAAIoC,EAA+BnE,IACnC,KAAOmE,GACLpC,EAAM5E,KAAKgH,GACXA,EAAInE,IAEN,OAAO+B,CACT,CAKA,SAAS/B,IACP,MAAMoE,EAAMxH,IACZ,GAAI,MAAQV,EAAImI,OAAO,IAAM,MAAQnI,EAAImI,OAAO,GAC9C,OAGF,MAAMT,EAAI,iBAAiBJ,KAAKtH,GAChC,OAAK0H,GAGLH,EAAaG,GAENQ,EAAmB,CACxB9F,KAAM9B,EAASwD,QACfA,QAAS4D,EAAE,GAAGK,MAAM,GAAG,MANhBd,EAAM,yBAQjB,CAKA,SAASmB,IACP,MAAMC,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,GAAgC,IAAbA,EACrB,OAEF,MAAMC,EAActI,EAAIuI,UAAU,EAAGF,GAErCd,EADkB,CAACe,IAMnB,MD5G2C,EAC7C9H,EACAC,KAEA,MAAM+H,EAAwB,GAC9B,IAAI7H,EAAkB,EACtB,KAAOA,EAAkBH,EAAOY,QAAQ,CACtC,MAAMqH,EAAQjH,EACZhB,EACAC,EACAE,GAEF,IAAc,IAAV8H,EAEF,OADAD,EAAOvH,KAAKT,EAAO+H,UAAU5H,IACtB6H,EAETA,EAAOvH,KAAKT,EAAO+H,UAAU5H,EAAiB8H,IAC9C9H,EAAkB8H,EAAQ,CAC5B,CACA,OAAOD,GCyFEE,CAFK5G,EAAKwG,GAAaK,QAAQ9G,EAAc,IAER,CAAC,MAAMf,IAAKC,GAAMe,EAAKf,GACrE,CAKA,SAAS8C,IACP,MAAMqE,EAAMxH,IAGNkI,EAAY,yCAAyCtB,KAAKtH,GAChE,IAAK4I,EACH,OAEFrB,EAAaqB,GACb,MAAMC,EAAY/G,EAAK8G,EAAU,IAG3BE,EAAiB,QAAQxB,KAAKtH,GACpC,IAAK8I,EACH,OAAO7B,EAAM,wBAEfM,EAAauB,GAGb,IAAIvG,EAAQ,GACZ,MAAMwG,EAAmBvH,EAAuCxB,EAAK,CACnE,IACA,MAEF,IAAyB,IAArB+I,EAAyB,CAC3BxG,EAAQvC,EAAIuI,UAAU,EAAGQ,GAEzBxB,EADkB,CAAChF,IAGnBA,EAAQT,EAAKS,GAAOoG,QAAQ9G,EAAc,GAC5C,CAEA,MAAMmH,EAAMd,EAAuB,CACjC9F,KAAM9B,EAASuD,YACfmB,SAAU6D,EAAUF,QAAQ9G,EAAc,IAC1CU,MAAOA,IAIH0G,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRD,CACT,CAMA,SAAS9C,IACP,MAAMD,EAAkD,GAExD,IAAKmB,IACH,OAAOH,EAAM,eAEfe,EAAS/B,GAGT,IAAIiD,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,IAGT,KAAOT,GAAS+D,QAAUnH,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC7D,MAAMgB,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,MAAgC,IAAbd,GAAmBc,EAAUd,GAclD,MANA,IAJAd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAAS/B,GACTiD,EAAOrF,IACAqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,GAKb,CAEA,OAAK2D,IAGEvB,EAFEgB,EAAM,cAGjB,CAMA,SAASmC,IACP,MAAMf,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,EACF,OAAO,EAET,MAAMc,EAAU3H,EAAuCxB,EAAK,CAAC,MACvDqJ,EAAW7H,EAAuCxB,EAAK,CAAC,MAE9D,SAAgB,IAAZmJ,GAAkBA,EAAUd,OAGf,IAAbgB,GAAmBA,EAAWhB,EAIpC,CAMA,SAASiB,IAGP,MAAMC,EAAiE,GAEvE,IAAKnC,IACH,OAAOH,EAAM,eAIf,IAFAe,EAASuB,GAEFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAMK,EAAU7F,IAChB,GAAI6F,EAAS,CACXF,EAAMtI,KAAKwI,GACXzB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CAEA,OAAK/B,IAGE+B,EAFEtC,EAAM,cAGjB,CAOA,SAASyC,IACP,MAAMH,EAAiE,GAGvE,IAFAxC,IACAiB,EAASuB,GACFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAM1C,EAAI9C,IACV,GAAI8C,EAAG,CACL6C,EAAMtI,KAAKyF,GACXsB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CACA,OAAOA,CACT,CAKA,SAAS9E,IACP,MAAMkF,EAAO,GACPzB,EAAMxH,IAEZ,IAAIgH,EAA4B,sCAAsCJ,KACpEtH,GAEF,KAAO0H,GAAG,CACR,MAAMkC,EAAMrC,EAAaG,GACzBiC,EAAK1I,KAAK2I,EAAI,IACd,MAAMC,EAAc,QAAQvC,KAAKtH,GAC7B6J,GACFtC,EAAasC,GAEfnC,EAAI,sCAAsCJ,KAAKtH,EACjD,CAEA,GAAK2J,EAAKvI,OAIV,OAAO8G,EAAoB,CACzB9F,KAAM9B,EAASmE,SACf0B,OAAQwD,EACRzD,aAAcA,KAAkB,IAEpC,CAyNA,MAkBM4D,EAAqB,IAAIC,OAC7B,MAnByB,CACzB,kBACA,WACA,aACA,YACA,mBACA,qBACA,cACA,gBACA,eACA,sBACA,WACA,cACA,cACA,YACA,eACA,gBAGyBvG,KAAK,uBAuWhC,MAAMwG,EAAWC,EAA6B,UAKxCC,EAAYD,EAA8B,WAK1CE,EAAcF,EAAgC,aAKpD,SAASA,EACPjE,GAEA,MAAMoE,EAAK,IAAIL,OACb,KACE/D,EACA,yEAKJ,MAAO,KACL,MAAMkC,EAAMxH,IACNgH,EAAI0C,EAAG9C,KAAKtH,GAClB,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GACnBsB,EAA8B,CAAE5G,KAAM4D,GAE5C,OADAgD,EAAIhD,GAAQ4D,EAAI,GAAG9H,OACZoG,EAAQc,GAEnB,CAyDA,SAAS3D,IACP,GAAe,MAAXrF,EAAI,GAIR,OAjrBF,WACE,MAAMkI,EAAMxH,IACN2J,EAAK,0BAA0B/C,KAAKtH,GAE1C,IAAKqK,EACH,OAEF,MAAMtE,EAASwB,EAAa8C,GAAI,GAG1BC,EAAK,eAAehD,KAAKtH,GAC/B,IAAKsK,EACH,OAAOrD,EAAM,2BAEf,MAAMjB,EAAOuB,EAAa+C,GAAI,GAE9B,IAAKlD,IACH,OAAOH,EAAM,0BAGf,IAAIsD,EAAgDvC,IAChDwC,EAAoC/F,IACxC,KAAO+F,GACLD,EAAOtJ,KAAKuJ,GACZD,EAASA,EAAOE,OAAOzC,KACvBwC,EAAQ/F,IAGV,OAAK+C,IAIEU,EAAqB,CAC1B9F,KAAM9B,EAASkE,UACfwB,KAAMA,EACND,OAAQA,EACRvB,UAAW+F,IAPJtD,EAAM,yBASjB,CA4oBIyD,IA7gBJ,WACE,MAAMxC,EAAMxH,IACNgH,EAAI,mBAAmBJ,KAAKtH,GAElC,IAAK0H,EACH,OAEF,MAAM/C,EAAQ7C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAASqE,MACfA,MAAOA,EACPkB,MAAO8E,IANA1D,EAAM,qBAQjB,CAsfI2D,IAjfJ,WACE,MAAM1C,EAAMxH,IACNgH,EAAI,8CAA8CJ,KAAKtH,GAC7D,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEzB,OAAOQ,EAAuB,CAC5B9F,KAAM9B,EAAS6D,YACf6B,KAAMlE,EAAK8H,EAAI,IACfjF,MAAO7C,EAAK8H,EAAI,KAEpB,CAqeIiB,IAzoBJ,WACE,MAAM3C,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GAErC,IAAK0H,EACH,OAEF,MAAMvC,EAAWrD,EAAKyF,EAAaG,GAAG,IAEtC,IAAKN,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAS6E,SACfA,SAAUA,EACVU,MAAO8E,IANA1D,EAAM,wBAQjB,CAknBI6D,IACAd,KACAE,KACAC,KA7XJ,WACE,MAAMjC,EAAMxH,IACNgH,EAAI,+BAA+BJ,KAAKtH,GAC9C,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEnB3B,EAASjE,EAAK8H,EAAI,IAClB9D,EAAMhE,EAAK8H,EAAI,IAErB,IAAKxC,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAS4D,SACfA,SAAU4B,EACVC,OAAQA,EACRF,MAAO8E,IAPA1D,EAAM,wBASjB,CAmWI8D,IA/aJ,WACE,MAAM7C,EAAMxH,IACNgH,EAAI,WAAWJ,KAAKtH,GAC1B,IAAK0H,EACH,OAEFH,EAAaG,GAEb,MAAMtB,EAAMgC,KAAc,GAE1B,IAAKhB,IACH,OAAOH,EAAM,qBAEf,MAAMhB,EAAiE,GAIvE,IAHA+B,EAAS/B,GAGFjG,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACNvD,EAAMhF,KAAKuI,GACXxB,EAAS/B,GACT,QACF,CACF,CACA,MAAMiD,EAAOrF,IACb,IAAIqF,EAKJ,MAJEjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,EAIb,CAEA,OAAKuB,IAIEU,EAAgB,CACrB9F,KAAM9B,EAASuE,KACfwB,UAAWD,EACXF,aAAcD,IANPgB,EAAM,oBAQjB,CAoYI+D,IAlnBJ,WACE,MAAM9C,EAAMxH,IACNgH,EAAI,YAAYJ,KAAKtH,GAE3B,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,qBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAgB,CACrB9F,KAAM9B,EAASgE,KACfuB,MAAO8E,IALA1D,EAAM,oBAOjB,CA4lBIgE,IAhWJ,WACE,MAAM/C,EAAMxH,IACNgH,EAAI,iBAAiBJ,KAAKtH,GAChC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,0BAEf,IAAIhB,EAAQ+B,IAGRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAGT,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAS8D,SACf8B,aAAcD,IALPgB,EAAM,yBAOjB,CAoUIiE,IA/PJ,WACE,MAAMhD,EAAMxH,IACNgH,EAAI,kCAAkCJ,KAAKtH,GACjD,IAAK0H,EACH,OAEF,MAAMpB,EAAaxE,EAAKyF,EAAaG,GAAG,IAExC,IAAKN,IACH,OAAOH,EAAM,oCAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAA6B,CAClC9F,KAAM9B,EAAS+D,kBACfiC,WAAYA,EACZT,MAAO8E,IANA1D,EAAM,mCAQjB,CAyOIkE,IAzlBJ,WACE,MAAMjD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GAEtC,IAAK0H,EACH,OAEF,MAAM3D,EAAYjC,EAAKyF,EAAaG,GAAG,IAEvC,IAAKN,IACH,OAAOH,EAAM,0BAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAqB,CAC1B9F,KAAM9B,EAASyD,UACfA,UAAWA,EACX8B,MAAO8E,IANA1D,EAAM,yBAQjB,CAkkBImE,IA1IJ,WACE,MAAMlD,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GACrC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,+BAEf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAAS4E,cACfW,MAAO8E,IALA1D,EAAM,8BAOjB,CAsHIoE,IA9jBJ,WACE,MAAMnD,EAAMxH,IACNgH,EAAI,qBAAqBJ,KAAKtH,GAEpC,IAAK0H,EACH,OAEF,MAAMhD,EAAQ5C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IAAQ,CACX,MAAMkD,EAAK,UAAUhD,KAAKtH,GAI1B,OAHIsK,GACF/C,EAAa+C,GAERpC,EAAiB,CACtB9F,KAAM9B,EAASoE,MACfA,MAAOA,GAEX,CAEA,MAAMiG,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAASoE,MACfA,MAAOA,EACPmB,MAAO8E,IANA1D,EAAM,qBAQjB,CAgiBIqE,IAnUJ,WACE,MAAMpD,EAAMxH,IACNgH,EAAI,6BAA6BJ,KAAKtH,GAC5C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,yBAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAS0E,SACfgB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,wBAQjB,CAySIsE,IApSJ,WACE,MAAMrD,EAAMxH,IACNgH,EAAI,gCAAgCJ,KAAKtH,GAC/C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,8BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAwB,CAC7B9F,KAAM9B,EAAS2D,aACf+B,KAAMA,EACNE,aAAcD,IANPgB,EAAM,6BAQjB,CA0QIuE,IAzOJ,WACE,MAAMtD,EAAMxH,IACNgH,EAAI,oBAAoBJ,KAAKtH,GACnC,IAAK0H,EACH,OAEF,MAAMzC,EAAQnD,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAAS2E,MACfA,MAAOA,EACPY,MAAO8E,IANA1D,EAAM,qBAQjB,CAmNIwE,IA9MJ,WACE,MAAMvD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GACtC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,gCAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAA0B,CAC/B9F,KAAM9B,EAAS8E,eACfc,aAAcD,IALPgB,EAAM,+BAOjB,CAqLIyE,IAhLJ,WACE,MAAMxD,EAAMxH,IACNgH,EAAI,iCAAiCJ,KAAKtH,GAChD,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,6BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAuB,CAC5B9F,KAAM9B,EAASyE,YACfiB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,4BAQjB,CAsJI0E,IA3dJ,WACE,MAAMzD,EAAMxH,IACNgH,EAAIoC,EAAmBxC,KAAKtH,GAClC,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,IAAIjB,iBAEnB,IAAIC,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAASwE,cACfkB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,IAAIjB,gBAQrB,CAicI4F,IA7EJ,WACE,MAAM1D,EAAMxH,IACNgH,EAAI,gBAAgBJ,KAAKtH,GAC/B,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAG7B,IAAInB,EAAU,GACd,MAAMsF,EAAarK,EAAuCxB,EAAK,CAAC,IAAK,OAClD,IAAf6L,GAAqBA,EAAa,IACpCtF,EAAUzE,EAAK9B,EAAIuI,UAAU,EAAGsD,IAIhCtE,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGsD,MAMrB,GAAIzE,IAAQ,CACV,MAAMuD,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAAS+E,OACfW,KAAMA,EACNO,QAASA,EACTV,MAAO8E,IAPA1D,EAAM,IAAIjB,gBASrB,CAGA,MAAMiD,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRf,EAAyB,CAC9B9F,KAAM9B,EAAS+E,OACfW,KAAMA,EACNO,QAASA,GAEb,CAgCIuF,EAEJ,CAKA,SAASlI,IACP,MAAMsE,EAAMxH,IACN0F,EAAMgC,IAEZ,OAAKhC,GAGL4B,IAEOE,EAAgB,CACrB9F,KAAM9B,EAASsD,KACfyC,UAAWD,EACXF,aAAcoD,KAAc,MAPrBrC,EAAM,mBASjB,CAEA,OAAOjF,EA1oCP,WACE,MAAM+J,EAyCR,WACE,IAAIrI,EACJ,MAAMmC,EAA0C,GAChDkB,IACAiB,EAASnC,GACT,KAAO7F,EAAIoB,QAAQ,CACjB,GAAsB,MAAlBpB,EAAImI,OAAO,GAAY,CACzB,GAAI/E,GAAS+D,OAAQ,CAEnBF,EAAM,aAENM,EADkB,CAAC,MAEnBR,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAEA,GADAnC,EAAO2B,KAAYzB,KACfF,EAGG,CACL,GAAIN,GAAS+D,OAAQ,CAGnBI,EADkB,CAACvH,EAAImI,OAAO,KAE9BpB,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAZEA,EAAM5E,KAAKyC,GACXsE,EAASnC,EAYb,CACA,OAAOA,CACT,CA5EoBA,GAWlB,MATiC,CAC/BzD,KAAM9B,EAASqD,WACfA,WAAY,CACV/D,OAAQwD,GAASxD,OACjBiG,MAAOkG,EACPC,cAAehF,GAKrB,CA6nCiBrD,KEtvCNsI,ECAE,CAACvI,EAAwBN,IACrB,IAAIJ,EAASI,GAAW,CAAA,GACzBwC,QAAQlC,GDE1B,IAAA+E,EAAe,CAAE3B,QAAOmF"} \ No newline at end of file diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.d.ts b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..208f4edf10bd077d23327a63e8f24c378191218f --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.d.ts @@ -0,0 +1,224 @@ +declare class CssParseError extends Error { + readonly reason: string; + readonly filename?: string; + readonly line: number; + readonly column: number; + readonly source: string; + constructor(filename: string, msg: string, lineno: number, column: number, css: string); +} + +/** + * Store position information for a node + */ +declare class Position { + start: { + line: number; + column: number; + }; + end: { + line: number; + column: number; + }; + source?: string; + constructor(start: { + line: number; + column: number; + }, end: { + line: number; + column: number; + }, source: string); +} + +declare enum CssTypes { + stylesheet = "stylesheet", + rule = "rule", + declaration = "declaration", + comment = "comment", + atRule = "at-rule", + container = "container", + charset = "charset", + counterStyle = "counter-style", + document = "document", + customMedia = "custom-media", + fontFace = "font-face", + fontFeatureValues = "font-feature-values", + host = "host", + import = "import", + keyframes = "keyframes", + keyframe = "keyframe", + layer = "layer", + media = "media", + namespace = "namespace", + page = "page", + pageMarginBox = "page-margin-box", + positionTry = "position-try", + property = "property", + scope = "scope", + startingStyle = "starting-style", + supports = "supports", + viewTransition = "view-transition" +} +type CssCommonAST = { + type: CssTypes; +}; +type CssCommonPositionAST = CssCommonAST & { + position?: Position; + parent?: unknown; +}; +type CssStylesheetAST = CssCommonAST & { + type: CssTypes.stylesheet; + stylesheet: { + source?: string; + rules: Array; + parsingErrors?: Array; + }; +}; +type CssRuleAST = CssCommonPositionAST & { + type: CssTypes.rule; + selectors: Array; + declarations: Array; +}; +type CssDeclarationAST = CssCommonPositionAST & { + type: CssTypes.declaration; + property: string; + value: string; +}; +type CssCommentAST = CssCommonPositionAST & { + type: CssTypes.comment; + comment: string; +}; +type CssContainerAST = CssCommonPositionAST & { + type: CssTypes.container; + container: string; + rules: Array; +}; +type CssCharsetAST = CssCommonPositionAST & { + type: CssTypes.charset; + charset: string; +}; +type CssCustomMediaAST = CssCommonPositionAST & { + type: CssTypes.customMedia; + name: string; + media: string; +}; +type CssDocumentAST = CssCommonPositionAST & { + type: CssTypes.document; + document: string; + vendor?: string; + rules: Array; +}; +type CssFontFaceAST = CssCommonPositionAST & { + type: CssTypes.fontFace; + declarations: Array; +}; +type CssHostAST = CssCommonPositionAST & { + type: CssTypes.host; + rules: Array; +}; +type CssImportAST = CssCommonPositionAST & { + type: CssTypes.import; + import: string; +}; +type CssKeyframesAST = CssCommonPositionAST & { + type: CssTypes.keyframes; + name: string; + vendor?: string; + keyframes: Array; +}; +type CssKeyframeAST = CssCommonPositionAST & { + type: CssTypes.keyframe; + values: Array; + declarations: Array; +}; +type CssLayerAST = CssCommonPositionAST & { + type: CssTypes.layer; + layer: string; + rules?: Array; +}; +type CssMediaAST = CssCommonPositionAST & { + type: CssTypes.media; + media: string; + rules: Array; +}; +type CssNamespaceAST = CssCommonPositionAST & { + type: CssTypes.namespace; + namespace: string; +}; +type CssPageAST = CssCommonPositionAST & { + type: CssTypes.page; + selectors: Array; + declarations: Array; +}; +type CssSupportsAST = CssCommonPositionAST & { + type: CssTypes.supports; + supports: string; + rules: Array; +}; +type CssStartingStyleAST = CssCommonPositionAST & { + type: CssTypes.startingStyle; + rules: Array; +}; +type CssCounterStyleAST = CssCommonPositionAST & { + type: CssTypes.counterStyle; + name: string; + declarations: Array; +}; +type CssFontFeatureValuesAST = CssCommonPositionAST & { + type: CssTypes.fontFeatureValues; + fontFamily: string; + rules: Array; +}; +type CssPositionTryAST = CssCommonPositionAST & { + type: CssTypes.positionTry; + name: string; + declarations: Array; +}; +type CssPropertyAST = CssCommonPositionAST & { + type: CssTypes.property; + name: string; + declarations: Array; +}; +type CssScopeAST = CssCommonPositionAST & { + type: CssTypes.scope; + scope: string; + rules: Array; +}; +type CssViewTransitionAST = CssCommonPositionAST & { + type: CssTypes.viewTransition; + declarations: Array; +}; +type CssPageMarginBoxAST = CssCommonPositionAST & { + type: CssTypes.pageMarginBox; + name: string; + declarations: Array; +}; +type CssGenericAtRuleAST = CssCommonPositionAST & { + type: CssTypes.atRule; + name: string; + prelude: string; + rules?: Array; +}; +type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCounterStyleAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssFontFeatureValuesAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssPageMarginBoxAST | CssPositionTryAST | CssPropertyAST | CssScopeAST | CssSupportsAST | CssStartingStyleAST | CssViewTransitionAST | CssGenericAtRuleAST; +type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST; + +type CompilerOptions = { + indent?: string; + compress?: boolean; +}; + +declare const parse: (css: string, options?: { + source?: string; + silent?: boolean; +}) => CssStylesheetAST; +declare const stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; + +declare const _default: { + parse: (css: string, options?: { + source?: string; + silent?: boolean; + }) => CssStylesheetAST; + stringify: (node: CssStylesheetAST, options?: CompilerOptions) => string; +}; + +export { CssTypes, _default as default, parse, stringify }; +export type { CssAllNodesAST, CssAtRuleAST, CssCharsetAST, CssCommentAST, CssCommonAST, CssCommonPositionAST, CssContainerAST, CssCounterStyleAST, CssCustomMediaAST, CssDeclarationAST, CssDocumentAST, CssFontFaceAST, CssFontFeatureValuesAST, CssGenericAtRuleAST, CssHostAST, CssImportAST, CssKeyframeAST, CssKeyframesAST, CssLayerAST, CssMediaAST, CssNamespaceAST, CssPageAST, CssPageMarginBoxAST, CssPositionTryAST, CssPropertyAST, CssRuleAST, CssScopeAST, CssStartingStyleAST, CssStylesheetAST, CssSupportsAST, CssViewTransitionAST }; diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js new file mode 100644 index 0000000000000000000000000000000000000000..10187775f95258e67df76f2e62add7dc11a5d52c --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js @@ -0,0 +1,2 @@ +!function(t,s){"object"==typeof exports&&"undefined"!=typeof module?s(exports):"function"==typeof define&&define.amd?define(["exports"],s):s((t="undefined"!=typeof globalThis?globalThis:t||self).cssTools={})}(this,function(t){"use strict";class s extends Error{reason;filename;line;column;source;constructor(t,s,e,i,n){super(`${t}:${e}:${i}: ${s}`),this.reason=s,this.filename=t,this.line=e,this.column=i,this.source=n}}class e{start;end;source;constructor(t,s,e){this.start=t,this.end=s,this.source=e}}var i;t.CssTypes=void 0,(i=t.CssTypes||(t.CssTypes={})).stylesheet="stylesheet",i.rule="rule",i.declaration="declaration",i.comment="comment",i.atRule="at-rule",i.container="container",i.charset="charset",i.counterStyle="counter-style",i.document="document",i.customMedia="custom-media",i.fontFace="font-face",i.fontFeatureValues="font-feature-values",i.host="host",i.import="import",i.keyframes="keyframes",i.keyframe="keyframe",i.layer="layer",i.media="media",i.namespace="namespace",i.page="page",i.pageMarginBox="page-margin-box",i.positionTry="position-try",i.property="property",i.scope="scope",i.startingStyle="starting-style",i.supports="supports",i.viewTransition="view-transition";const n=(t,s,e)=>{let i=e,n=1e4;do{const e=s.map(s=>t.indexOf(s,i));e.push(t.indexOf("\\",i));const r=e.filter(t=>-1!==t);if(0===r.length)return-1;const o=Math.min(...r);if("\\"!==t[o])return o;i=o+2,n--}while(n>0);throw new Error("Too many escaping")},r=(t,s,e)=>{let i=e,o=1e4;do{const e=s.map(s=>t.indexOf(s,i));e.push(t.indexOf("(",i)),e.push(t.indexOf('"',i)),e.push(t.indexOf("'",i)),e.push(t.indexOf("\\",i));const c=e.filter(t=>-1!==t);if(0===c.length)return-1;const h=Math.min(...c);switch(t[h]){case"\\":i=h+2;break;case"(":{const s=r(t,[")"],h+1);if(-1===s)return-1;i=s+1}break;case'"':{const s=n(t,['"'],h+1);if(-1===s)return-1;i=s+1}break;case"'":{const s=n(t,["'"],h+1);if(-1===s)return-1;i=s+1}break;default:return h}o--}while(o>0);throw new Error("Too many escaping")},o=/\/\*[^]*?(?:\*\/|$)/g;function c(t){return t?t.trim():""}function h(t,s){const e=t&&"string"==typeof t.type,i=e?t:s;for(const s in t){const e=t[s];Array.isArray(e)?e.forEach(t=>{h(t,i)}):e&&"object"==typeof e&&h(e,i)}return e&&Object.defineProperty(t,"parent",{configurable:!0,writable:!0,enumerable:!1,value:s||null}),t}class a{level=0;indentation=" ";compress=!1;constructor(t){"string"==typeof t?.indent&&(this.indentation=t?.indent),t?.compress&&(this.compress=!0)}emit(t,s){return t}indent(t){return this.level=this.level||1,t?(this.level+=t,""):Array(this.level).join(this.indentation)}visit(s){switch(s.type){case t.CssTypes.stylesheet:return this.stylesheet(s);case t.CssTypes.rule:return this.rule(s);case t.CssTypes.declaration:return this.declaration(s);case t.CssTypes.comment:return this.comment(s);case t.CssTypes.container:return this.container(s);case t.CssTypes.charset:return this.charset(s);case t.CssTypes.counterStyle:return this.counterStyle(s);case t.CssTypes.document:return this.document(s);case t.CssTypes.customMedia:return this.customMedia(s);case t.CssTypes.fontFace:return this.fontFace(s);case t.CssTypes.fontFeatureValues:return this.fontFeatureValues(s);case t.CssTypes.host:return this.host(s);case t.CssTypes.import:return this.import(s);case t.CssTypes.keyframes:return this.keyframes(s);case t.CssTypes.keyframe:return this.keyframe(s);case t.CssTypes.layer:return this.layer(s);case t.CssTypes.media:return this.media(s);case t.CssTypes.namespace:return this.namespace(s);case t.CssTypes.page:return this.page(s);case t.CssTypes.pageMarginBox:return this.pageMarginBox(s);case t.CssTypes.positionTry:return this.positionTry(s);case t.CssTypes.property:return this.property(s);case t.CssTypes.scope:return this.scope(s);case t.CssTypes.startingStyle:return this.startingStyle(s);case t.CssTypes.supports:return this.supports(s);case t.CssTypes.viewTransition:return this.viewTransition(s);case t.CssTypes.atRule:return this.genericAtRule(s)}}mapVisit(t,s){let e="";s=s||"";for(let i=0,n=t.length;is.type!==t.CssTypes.declaration&&s.type!==t.CssTypes.comment),n=i?"\n\n":"\n";return this.emit(`${this.indent()}@${s.name}${e}`,s.position)+this.emit(i?` {\n${this.indent(1)}`:" {\n")+this.emit(i?"":this.indent(1))+this.mapVisit(s.rules,n)+this.emit(i?`\n${this.indent(-1)}${this.indent()}}`:`${this.indent(-1)}\n${this.indent()}}`)}rule(t){const s=t.declarations;if(!s.length)return"";if(this.compress)return this.emit(t.selectors.join(","),t.position)+this.emit("{")+this.mapVisit(s)+this.emit("}");const e=this.indent();return this.emit(t.selectors.map(t=>e+t).join(",\n"),t.position)+this.emit(" {\n")+this.emit(this.indent(1))+this.mapVisit(s,"\n")+this.emit(this.indent(-1))+this.emit(`\n${this.indent()}}`)}declaration(t){return this.compress?this.emit(`${t.property}:${t.value}`,t.position)+this.emit(";"):"grid-template-areas"===t.property?this.emit(this.indent())+this.emit(t.property+": "+t.value.split("\n").join("\n".padEnd(22)+this.indent()),t.position)+this.emit(";"):this.emit(this.indent())+this.emit(`${t.property}: ${t.value}`,t.position)+this.emit(";")}}const m=(i,n)=>{n=n||{};let a=1,m=1;function u(){const t={line:a,column:m};return s=>(s.position=new e(t,{line:a,column:m},n?.source||""),g(),s)}const p=[];function l(t){const e=new s(n?.source||"",t,a,m,i);if(!n?.silent)throw e;p.push(e)}function f(){const t=/^{\s*/.exec(i);return!!t&&(d(t),!0)}function y(){const t=/^}/.exec(i);return!!t&&(d(t),!0)}function d(t){const s=t[0];return function(t){const s=t.match(/\n/g);s&&(a+=s.length);const e=t.lastIndexOf("\n");m=~e?t.length-e:m+t.length}(s),i=i.slice(s.length),t}function g(){const t=/^\s*/.exec(i);t&&d(t)}function $(t){t=t||[];let s=T();for(;s;)t.push(s),s=T();return t}function T(){const s=u();if("/"!==i.charAt(0)||"*"!==i.charAt(1))return;const e=/^\/\*[^]*?\*\//.exec(i);return e?(d(e),s({type:t.CssTypes.comment,comment:e[0].slice(2,-2)})):l("End of comment missing")}function x(){const t=r(i,["{"]);if(-1===t||0===t)return;const s=i.substring(0,t);d([s]);return((t,s)=>{const e=[];let i=0;for(;ic(t))}function C(){const s=u(),e=/^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/.exec(i);if(!e)return;d(e);const n=c(e[0]),h=/^:\s*/.exec(i);if(!h)return l("property missing ':'");d(h);let a="";const m=r(i,[";","}"]);if(-1!==m){a=i.substring(0,m);d([a]),a=c(a).replace(o,"")}const p=s({type:t.CssTypes.declaration,property:n.replace(o,""),value:a}),f=/^[;\s]*/.exec(i);return f&&d(f),p}function V(){const t=[];if(!f())return l("missing '{'");$(t);let s=C();for(;s;)t.push(s),$(t),s=C();for(;n?.silent&&i.length&&"}"!==i.charAt(0);){const e=i.indexOf(";"),n=i.indexOf("}");if(-1===e||!(-1===n||e{const e=u(),n=s.exec(i);if(!n)return;const r=d(n),o={type:t};return o[t]=r[1].trim(),e(o)}}function S(){if("@"===i[0])return function(){const s=u(),e=/^@([-\w]+)?keyframes\s*/.exec(i);if(!e)return;const n=d(e)[1],r=/^([-\w]+)\s*/.exec(i);if(!r)return l("@keyframes missing name");const o=d(r)[1];if(!f())return l("@keyframes missing '{'");let c=$(),h=k();for(;h;)c.push(h),c=c.concat($()),h=k();return y()?s({type:t.CssTypes.keyframes,name:o,vendor:n,keyframes:c}):l("@keyframes missing '}'")}()||function(){const s=u(),e=/^@media *([^{]+)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f())return l("@media missing '{'");const r=w();return y()?s({type:t.CssTypes.media,media:n,rules:r}):l("@media missing '}'")}()||function(){const s=u(),e=/^@custom-media\s+(--\S+)\s+([^{;\s][^{;]*);/.exec(i);if(!e)return;const n=d(e);return s({type:t.CssTypes.customMedia,name:c(n[1]),media:c(n[2])})}()||function(){const s=u(),e=/^@supports *([^{]+)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f())return l("@supports missing '{'");const r=w();return y()?s({type:t.CssTypes.supports,supports:n,rules:r}):l("@supports missing '}'")}()||O()||j()||F()||function(){const s=u(),e=/^@([-\w]+)?document *([^{]+)/.exec(i);if(!e)return;const n=d(e),r=c(n[1]),o=c(n[2]);if(!f())return l("@document missing '{'");const h=w();return y()?s({type:t.CssTypes.document,document:o,vendor:r,rules:h}):l("@document missing '}'")}()||function(){const s=u(),e=/^@page */.exec(i);if(!e)return;d(e);const n=x()||[];if(!f())return l("@page missing '{'");const r=[];for($(r);i.length&&"}"!==i.charAt(0);){if("@"===i.charAt(0)){const t=S();if(t){r.push(t),$(r);continue}}const t=C();if(!t)break;r.push(t),$(r)}return y()?s({type:t.CssTypes.page,selectors:n,declarations:r}):l("@page missing '}'")}()||function(){const s=u(),e=/^@host\s*/.exec(i);if(!e)return;if(d(e),!f())return l("@host missing '{'");const n=w();return y()?s({type:t.CssTypes.host,rules:n}):l("@host missing '}'")}()||function(){const s=u(),e=/^@font-face\s*/.exec(i);if(!e)return;if(d(e),!f())return l("@font-face missing '{'");let n=$(),r=C();for(;r;)n.push(r),n=n.concat($()),r=C();return y()?s({type:t.CssTypes.fontFace,declarations:n}):l("@font-face missing '}'")}()||function(){const s=u(),e=/^@font-feature-values\s+([^{]+)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f())return l("@font-feature-values missing '{'");const r=w();return y()?s({type:t.CssTypes.fontFeatureValues,fontFamily:n,rules:r}):l("@font-feature-values missing '}'")}()||function(){const s=u(),e=/^@container *([^{]+)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f())return l("@container missing '{'");const r=w();return y()?s({type:t.CssTypes.container,container:n,rules:r}):l("@container missing '}'")}()||function(){const s=u(),e=/^@starting-style\s*/.exec(i);if(!e)return;if(d(e),!f())return l("@starting-style missing '{'");const n=w();return y()?s({type:t.CssTypes.startingStyle,rules:n}):l("@starting-style missing '}'")}()||function(){const s=u(),e=/^@layer *([^{;@]+)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f()){const e=/^[;\s]*/.exec(i);return e&&d(e),s({type:t.CssTypes.layer,layer:n})}const r=w();return y()?s({type:t.CssTypes.layer,layer:n,rules:r}):l("@layer missing '}'")}()||function(){const s=u(),e=/^@property\s+(--[-\w]+)\s*/.exec(i);if(!e)return;const n=d(e)[1];if(!f())return l("@property missing '{'");let r=$(),o=C();for(;o;)r.push(o),r=r.concat($()),o=C();return y()?s({type:t.CssTypes.property,name:n,declarations:r}):l("@property missing '}'")}()||function(){const s=u(),e=/^@counter-style\s+([-\w]+)\s*/.exec(i);if(!e)return;const n=d(e)[1];if(!f())return l("@counter-style missing '{'");let r=$(),o=C();for(;o;)r.push(o),r=r.concat($()),o=C();return y()?s({type:t.CssTypes.counterStyle,name:n,declarations:r}):l("@counter-style missing '}'")}()||function(){const s=u(),e=/^@scope\s*([^{]*)/.exec(i);if(!e)return;const n=c(d(e)[1]);if(!f())return l("@scope missing '{'");const r=w();return y()?s({type:t.CssTypes.scope,scope:n,rules:r}):l("@scope missing '}'")}()||function(){const s=u(),e=/^@view-transition\s*/.exec(i);if(!e)return;if(d(e),!f())return l("@view-transition missing '{'");let n=$(),r=C();for(;r;)n.push(r),n=n.concat($()),r=C();return y()?s({type:t.CssTypes.viewTransition,declarations:n}):l("@view-transition missing '}'")}()||function(){const s=u(),e=/^@position-try\s+(--[-\w]+)\s*/.exec(i);if(!e)return;const n=d(e)[1];if(!f())return l("@position-try missing '{'");let r=$(),o=C();for(;o;)r.push(o),r=r.concat($()),o=C();return y()?s({type:t.CssTypes.positionTry,name:n,declarations:r}):l("@position-try missing '}'")}()||function(){const s=u(),e=A.exec(i);if(!e)return;const n=d(e)[1];if(!f())return l(`@${n} missing '{'`);let r=$(),o=C();for(;o;)r.push(o),r=r.concat($()),o=C();return y()?s({type:t.CssTypes.pageMarginBox,name:n,declarations:r}):l(`@${n} missing '}'`)}()||function(){const s=u(),e=/^@([-\w]+)\s*/.exec(i);if(!e)return;const n=d(e)[1];let o="";const h=r(i,["{",";"]);-1!==h&&h>0&&(o=c(i.substring(0,h)),d([i.substring(0,h)]));if(f()){const e=w();return y()?s({type:t.CssTypes.atRule,name:n,prelude:o,rules:e}):l(`@${n} missing '}'`)}const a=/^[;\s]*/.exec(i);return a&&d(a),s({type:t.CssTypes.atRule,name:n,prelude:o})}()}function E(){const s=u(),e=x();return e?($(),s({type:t.CssTypes.rule,selectors:e,declarations:b()||[]})):l("selector missing")}return h(function(){const s=function(){let t;const s=[];g(),$(s);for(;i.length;){if("}"===i.charAt(0)){if(n?.silent){l("extra '}'");d(["}"]),g(),$(s);continue}break}if(t=S()||E(),!t){if(n?.silent){d([i.charAt(0)]),g(),$(s);continue}break}s.push(t),$(s)}return s}();return{type:t.CssTypes.stylesheet,stylesheet:{source:n?.source,rules:s,parsingErrors:p}}}())},u=(t,s)=>new a(s||{}).compile(t);var p={parse:m,stringify:u};t.default=p,t.parse=m,t.stringify=u,Object.defineProperty(t,"__esModule",{value:!0})}); +//# sourceMappingURL=adobe-css-tools.js.map diff --git a/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js.map b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js.map new file mode 100644 index 0000000000000000000000000000000000000000..bd51aebfc2fbad1e40192255505c65a7d1d72216 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/dist/umd/adobe-css-tools.js.map @@ -0,0 +1 @@ +{"version":3,"file":"adobe-css-tools.js","sources":["../../src/CssParseError.ts","../../src/CssPosition.ts","../../src/type.ts","../../src/utils/stringSearch.ts","../../src/parse/index.ts","../../src/stringify/compiler.ts","../../src/index.ts","../../src/stringify/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":["CssParseError","Error","reason","filename","line","column","source","constructor","msg","lineno","css","super","this","Position","start","end","CssTypes","indexOfArrayNonEscaped","string","search","position","currentPosition","maxLoop","all","map","v","indexOf","push","foundAll","filter","length","found","Math","min","indexOfArrayWithBracketAndQuoteSupport","currentSearchPosition","firstMatchPos","endPosition","endQuotePosition","commentRegex","trim","str","addParent","obj","parent","isNode","type","childParent","k","value","Array","isArray","forEach","Object","defineProperty","configurable","writable","enumerable","Compiler","level","indentation","compress","options","indent","emit","_position","join","visit","node","stylesheet","rule","declaration","comment","container","charset","counterStyle","document","customMedia","fontFace","fontFeatureValues","host","import","keyframes","keyframe","layer","media","namespace","page","pageMarginBox","positionTry","property","scope","startingStyle","supports","viewTransition","atRule","genericAtRule","mapVisit","nodes","delim","buf","i","compile","rules","doc","vendor","name","decls","declarations","values","sel","selectors","fontFamily","prelude","hasNestedRules","some","r","s","split","padEnd","parse","whitespace","errorsList","error","err","silent","open","openMatch","exec","processMatch","close","closeMatch","m","lines","match","lastIndexOf","updatePosition","slice","comments","c","pos","charAt","selector","bracePos","selectorStr","substring","result","index","splitWithBracketAndQuoteSupport","replace","propMatch","propValue","separatorMatch","endValuePosition","ret","endMatch","decl","semiPos","looksLikeNestedRule","closePos","ruleBody","items","ar","nestedR","rulesOrDeclarations","vals","res","spacesMatch","pageMarginBoxRegex","RegExp","atImport","_compileAtRule","atCharset","atNamespace","re","m1","m2","frames","frame","concat","atKeyframes","style","atMedia","atCustomMedia","atSupports","atDocument","atPage","atHost","atFontFace","atFontFeatureValues","atContainer","atStartingStyle","atLayer","atProperty","atCounterStyle","atScope","atViewTransition","atPositionTry","atPageMarginBox","preludeEnd","atGeneric","rulesList","parsingErrors","stringify"],"mappings":"+OAAc,MAAOA,UAAsBC,MAChCC,OACAC,SACAC,KACAC,OACAC,OAET,WAAAC,CACEJ,EACAK,EACAC,EACAJ,EACAK,GAEAC,MAAM,GAAGR,KAAYM,KAAUJ,MAAWG,KAC1CI,KAAKV,OAASM,EACdI,KAAKT,SAAWA,EAChBS,KAAKR,KAAOK,EACZG,KAAKP,OAASA,EACdO,KAAKN,OAASI,CAChB,ECjBY,MAAOG,EACnBC,MACAC,IACAT,OAEA,WAAAC,CACEO,EACAC,EACAT,GAEAM,KAAKE,MAAQA,EACbF,KAAKG,IAAMA,EACXH,KAAKN,OAASA,CAChB,ECbF,IAAYU,EAAAA,EAAAA,cAAAA,GAAAA,EAAAA,EAAAA,WAAAA,WAAQ,CAAA,IAClB,WAAA,aACAA,EAAA,KAAA,OACAA,EAAA,YAAA,cACAA,EAAA,QAAA,UACAA,EAAA,OAAA,UACAA,EAAA,UAAA,YACAA,EAAA,QAAA,UACAA,EAAA,aAAA,gBACAA,EAAA,SAAA,WACAA,EAAA,YAAA,eACAA,EAAA,SAAA,YACAA,EAAA,kBAAA,sBACAA,EAAA,KAAA,OACAA,EAAA,OAAA,SACAA,EAAA,UAAA,YACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,MAAA,QACAA,EAAA,UAAA,YACAA,EAAA,KAAA,OACAA,EAAA,cAAA,kBACAA,EAAA,YAAA,eACAA,EAAA,SAAA,WACAA,EAAA,MAAA,QACAA,EAAA,cAAA,iBACAA,EAAA,SAAA,WACAA,EAAA,eAAA,kBC9BK,MAkBMC,EAAyB,CACpCC,EACAC,EACAC,KAEA,IAAIC,EAAkBD,EAClBE,EAxBkB,IAyBtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGJ,IAChDE,EAAII,KAAKT,EAAOQ,QAAQ,KAAML,IAC9B,MAAMO,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMC,EAAQC,KAAKC,OAAOL,GAC1B,GAAsB,OAAlBV,EAAOa,GAIT,OAAOA,EAHPV,EAAkBU,EAAQ,EAC1BT,GAIJ,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBA0BLiC,EAAyC,CACpDhB,EACAC,EACAC,KAEA,IAAIe,EAAwBf,EACxBE,EA1EkB,IA4EtB,EAAG,CACD,MAAMC,EAAMJ,EAAOK,IAAKC,GAAMP,EAAOQ,QAAQD,EAAGU,IAEhDZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,IAAKS,IAC7BZ,EAAII,KAAKT,EAAOQ,QAAQ,KAAMS,IAE9B,MAAMP,EAAWL,EAAIM,OAAQJ,QAAMA,GACnC,GAAwB,IAApBG,EAASE,OACX,OAAO,EAGT,MAAMM,EAAgBJ,KAAKC,OAAOL,GAElC,OADaV,EAAOkB,IAElB,IAAK,KACHD,EAAwBC,EAAgB,EACxC,MACF,IAAK,IACH,CACE,MAAMC,EAAcH,EAClBhB,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAoB,IAAhBC,EACF,OAAO,EAETF,EAAwBE,EAAc,CACxC,CACA,MACF,IAAK,IACH,CACE,MAAMC,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,IAAK,IACH,CACE,MAAMA,EAAmBrB,EACvBC,EACA,CAAC,KACDkB,EAAgB,GAElB,IAAyB,IAArBE,EACF,OAAO,EAETH,EAAwBG,EAAmB,CAC7C,CACA,MACF,QACE,OAAOF,EAEXd,GACF,OAASA,EAAU,GAEnB,MAAM,IAAIrB,MAAM,sBCjGZsC,EAAe,uBAotCrB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAID,OAAS,EAC5B,CAKA,SAASE,EACPC,EACAC,GAEA,MAAMC,EAASF,GAA2B,iBAAbA,EAAIG,KAC3BC,EAAcF,EAASF,EAAMC,EAEnC,IAAK,MAAMI,KAAKL,EAAK,CACnB,MAAMM,EAAQN,EAAIK,GACdE,MAAMC,QAAQF,GAChBA,EAAMG,QAAS3B,IACbiB,EAAUjB,EAAGsB,KAENE,GAA0B,iBAAVA,GACzBP,EAAUO,EAAOF,EAErB,CAWA,OATIF,GACFQ,OAAOC,eAAeX,EAAK,SAAU,CACnCY,cAAc,EACdC,UAAU,EACVC,YAAY,EACZR,MAAOL,GAAU,OAIdD,CACT,CC5vCA,MAAMe,EACJC,MAAQ,EACRC,YAAc,KACdC,UAAW,EAEX,WAAAtD,CAAYuD,GACqB,iBAApBA,GAASC,SAClBnD,KAAKgD,YAAcE,GAASC,QAE1BD,GAASD,WACXjD,KAAKiD,UAAW,EAEpB,CAIA,IAAAG,CAAKvB,EAAawB,GAChB,OAAOxB,CACT,CAKA,MAAAsB,CAAOJ,GAGL,OAFA/C,KAAK+C,MAAQ/C,KAAK+C,OAAS,EAEvBA,GACF/C,KAAK+C,OAASA,EACP,IAGFT,MAAMtC,KAAK+C,OAAOO,KAAKtD,KAAKgD,YACrC,CAEA,KAAAO,CAAMC,GACJ,OAAQA,EAAKtB,MACX,KAAK9B,EAAAA,SAASqD,WACZ,OAAOzD,KAAKyD,WAAWD,GACzB,KAAKpD,EAAAA,SAASsD,KACZ,OAAO1D,KAAK0D,KAAKF,GACnB,KAAKpD,EAAAA,SAASuD,YACZ,OAAO3D,KAAK2D,YAAYH,GAC1B,KAAKpD,EAAAA,SAASwD,QACZ,OAAO5D,KAAK4D,QAAQJ,GACtB,KAAKpD,EAAAA,SAASyD,UACZ,OAAO7D,KAAK6D,UAAUL,GACxB,KAAKpD,EAAAA,SAAS0D,QACZ,OAAO9D,KAAK8D,QAAQN,GACtB,KAAKpD,EAAAA,SAAS2D,aACZ,OAAO/D,KAAK+D,aAAaP,GAC3B,KAAKpD,EAAAA,SAAS4D,SACZ,OAAOhE,KAAKgE,SAASR,GACvB,KAAKpD,EAAAA,SAAS6D,YACZ,OAAOjE,KAAKiE,YAAYT,GAC1B,KAAKpD,EAAAA,SAAS8D,SACZ,OAAOlE,KAAKkE,SAASV,GACvB,KAAKpD,EAAAA,SAAS+D,kBACZ,OAAOnE,KAAKmE,kBAAkBX,GAChC,KAAKpD,EAAAA,SAASgE,KACZ,OAAOpE,KAAKoE,KAAKZ,GACnB,KAAKpD,EAAAA,SAASiE,OACZ,OAAOrE,KAAKqE,OAAOb,GACrB,KAAKpD,EAAAA,SAASkE,UACZ,OAAOtE,KAAKsE,UAAUd,GACxB,KAAKpD,EAAAA,SAASmE,SACZ,OAAOvE,KAAKuE,SAASf,GACvB,KAAKpD,EAAAA,SAASoE,MACZ,OAAOxE,KAAKwE,MAAMhB,GACpB,KAAKpD,EAAAA,SAASqE,MACZ,OAAOzE,KAAKyE,MAAMjB,GACpB,KAAKpD,EAAAA,SAASsE,UACZ,OAAO1E,KAAK0E,UAAUlB,GACxB,KAAKpD,EAAAA,SAASuE,KACZ,OAAO3E,KAAK2E,KAAKnB,GACnB,KAAKpD,EAAAA,SAASwE,cACZ,OAAO5E,KAAK4E,cAAcpB,GAC5B,KAAKpD,EAAAA,SAASyE,YACZ,OAAO7E,KAAK6E,YAAYrB,GAC1B,KAAKpD,EAAAA,SAAS0E,SACZ,OAAO9E,KAAK8E,SAAStB,GACvB,KAAKpD,EAAAA,SAAS2E,MACZ,OAAO/E,KAAK+E,MAAMvB,GACpB,KAAKpD,EAAAA,SAAS4E,cACZ,OAAOhF,KAAKgF,cAAcxB,GAC5B,KAAKpD,EAAAA,SAAS6E,SACZ,OAAOjF,KAAKiF,SAASzB,GACvB,KAAKpD,EAAAA,SAAS8E,eACZ,OAAOlF,KAAKkF,eAAe1B,GAC7B,KAAKpD,EAAAA,SAAS+E,OACZ,OAAOnF,KAAKoF,cAAc5B,GAEhC,CAEA,QAAA6B,CAASC,EAA8BC,GACrC,IAAIC,EAAM,GACVD,EAAQA,GAAS,GAEjB,IAAK,IAAIE,EAAI,EAAGvE,EAASoE,EAAMpE,OAAQuE,EAAIvE,EAAQuE,IACjDD,GAAOxF,KAAKuD,MAAM+B,EAAMG,IACpBF,GAASE,EAAIvE,EAAS,IACxBsE,GAAOxF,KAAKoD,KAAKmC,IAIrB,OAAOC,CACT,CAEA,OAAAE,CAAQlC,GACN,OAAIxD,KAAKiD,SACAO,EAAKC,WAAWkC,MAAM/E,IAAIZ,KAAKuD,MAAOvD,MAAMsD,KAAK,IAGnDtD,KAAKyD,WAAWD,EACzB,CAKA,UAAAC,CAAWD,GACT,OAAOxD,KAAKqF,SAAS7B,EAAKC,WAAWkC,MAAO,OAC9C,CAKA,OAAA/B,CAAQJ,GACN,OAAIxD,KAAKiD,SACAjD,KAAKoD,KAAK,GAAII,EAAKhD,UAErBR,KAAKoD,KAAK,GAAGpD,KAAKmD,aAAaK,EAAKI,YAAaJ,EAAKhD,SAC/D,CAKA,SAAAqD,CAAUL,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,cAAcI,EAAKK,YAAaL,EAAKhD,UAC/CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,sBAAsBK,EAAKK,YAAaL,EAAKhD,UAC/DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAAqB,CAAMhB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKgB,QAAShB,EAAKhD,WACtCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAINpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKgB,QAAShB,EAAKhD,WACtDgD,EAAKmC,MACF3F,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAA2B7B,EAAKmC,MAAO,QAC5C3F,KAAKoD,KAAK,KAAKpD,KAAKmD,QAAO,KAAMnD,KAAKmD,aACtC,IAER,CAKA,MAAAkB,CAAOb,GACL,OAAOxD,KAAKoD,KAAK,WAAWI,EAAKa,UAAWb,EAAKhD,SACnD,CAKA,KAAAiE,CAAMjB,GACJ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,UAAUI,EAAKiB,QAASjB,EAAKhD,UACvCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,kBAAkBK,EAAKiB,QAASjB,EAAKhD,UACvDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAAa,CAASR,GACP,MAAMoC,EAAM,IAAIpC,EAAKqC,QAAU,cAAcrC,EAAKQ,WAClD,OAAIhE,KAAKiD,SAELjD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAKwC,EAAKpC,EAAKhD,UACpBR,KAAKoD,KAAK,QAAQpD,KAAKmD,OAAO,MAC9BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,OAAAW,CAAQN,GACN,OAAOxD,KAAKoD,KAAK,YAAYI,EAAKM,WAAYN,EAAKhD,SACrD,CAKA,SAAAkE,CAAUlB,GACR,OAAOxD,KAAKoD,KAAK,cAAcI,EAAKkB,aAAclB,EAAKhD,SACzD,CAKA,aAAAwE,CAAcxB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAmBI,EAAKhD,UAClCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,0BAA2BK,EAAKhD,UAClDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,QAAA8B,CAASzB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKyB,WAAYzB,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,qBAAqBK,EAAKyB,WAAYzB,EAAKhD,UAC7DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,SAAAmB,CAAUd,GACR,OAAIxD,KAAKiD,SAELjD,KAAKoD,KACH,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OACvCtC,EAAKhD,UAEPR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKc,WACnBtE,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,IAAII,EAAKqC,QAAU,eAAerC,EAAKsC,OAAQtC,EAAKhD,UAC9DR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKc,UAAW,MAC9BtE,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,MAE7B,CAKA,QAAAoB,CAASf,GACP,MAAMuC,EAAQvC,EAAKwC,aACnB,OAAIhG,KAAKiD,SAELjD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,KAAME,EAAKhD,UACtCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAKZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAKI,EAAKyC,OAAO3C,KAAK,MAAOE,EAAKhD,UACvCR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,OAAQnD,KAAKmD,cAE1C,CAKA,IAAAwB,CAAKnB,GACH,GAAIxD,KAAKiD,SAAU,CACjB,MAAMiD,EAAM1C,EAAK2C,UAAUjF,OAASsC,EAAK2C,UAAU7C,KAAK,MAAQ,GAEhE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,IAEd,CACA,MAAM8C,EAAM1C,EAAK2C,UAAUjF,OAAS,GAAGsC,EAAK2C,UAAU7C,KAAK,SAAW,GAEtE,OACEtD,KAAKoD,KAAK,SAAS8C,IAAO1C,EAAKhD,UAC/BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAwB,CAAcpB,GACZ,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAQtC,EAAKhD,UAChCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,QAAStC,EAAKhD,UACjDR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,QAAAe,CAASV,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAcI,EAAKhD,UAC7BR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,cAAeI,EAAKhD,UAC9BR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,IAAAgB,CAAKZ,GACH,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,QAASI,EAAKhD,UACxBR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,GAAGpD,KAAKmD,QAAO,QAE7B,CAKA,WAAAc,CAAYT,GACV,OAAOxD,KAAKoD,KACV,iBAAiBI,EAAKsC,QAAQtC,EAAKiB,SACnCjB,EAAKhD,SAET,CAKA,QAAAsE,CAAStB,GACP,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,aAAaI,EAAKsC,OAAQtC,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,aAAaI,EAAKsC,QAAStC,EAAKhD,UAC1CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,YAAAW,CAAaP,GACX,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,kBAAkBI,EAAKsC,OAAQtC,EAAKhD,UAC9CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,kBAAkBI,EAAKsC,QAAStC,EAAKhD,UAC/CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,iBAAAe,CAAkBX,GAChB,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,wBAAwBI,EAAK4C,aAAc5C,EAAKhD,UAC1DR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KACH,GAAGpD,KAAKmD,gCAAgCK,EAAK4C,aAC7C5C,EAAKhD,UAEPR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,KAAA4B,CAAMvB,GACJ,MAAM6C,EAAU7C,EAAKuB,MAAQ,IAAIvB,EAAKuB,QAAU,GAChD,OAAI/E,KAAKiD,SAELjD,KAAKoD,KAAK,SAASiD,IAAW7C,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKmC,OACnB3F,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,GAAGpD,KAAKmD,iBAAiBkD,IAAW7C,EAAKhD,UACnDR,KAAKoD,KAAK,OAAOpD,KAAKmD,OAAO,MAC7BnD,KAAKqF,SAAS7B,EAAKmC,MAAO,QAC1B3F,KAAKoD,KAAK,KAAKpD,KAAKmD,aAAanD,KAAKmD,YAE1C,CAKA,cAAA+B,CAAe1B,GACb,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,mBAAoBI,EAAKhD,UACnCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,oBAAqBI,EAAKhD,UACpCR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,WAAAyB,CAAYrB,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,iBAAiBI,EAAKsC,OAAQtC,EAAKhD,UAC7CR,KAAKoD,KAAK,KACVpD,KAAKqF,SAAS7B,EAAKwC,cACnBhG,KAAKoD,KAAK,KAIZpD,KAAKoD,KAAK,iBAAiBI,EAAKsC,QAAStC,EAAKhD,UAC9CR,KAAKoD,KAAK,OACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAAS7B,EAAKwC,aAAc,MACjChG,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,MAEd,CAKA,aAAAgC,CAAc5B,GACZ,MAAM6C,EAAU7C,EAAK6C,QAAU,IAAI7C,EAAK6C,UAAY,GACpD,GAAIrG,KAAKiD,SACP,OACEjD,KAAKoD,KAAK,IAAII,EAAKsC,OAAOO,IAAW7C,EAAKhD,WACzCgD,EAAKmC,MACF3F,KAAKoD,KAAK,KACVpD,KAAKqF,SAA2B7B,EAAKmC,OACrC3F,KAAKoD,KAAK,KACV,KAGR,IAAKI,EAAKmC,MACR,OAAO3F,KAAKoD,KACV,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,KAChC7C,EAAKhD,UAGT,MAAM8F,EAAiB9C,EAAKmC,MAAMY,KAC/BC,GAAMA,EAAEtE,OAAS9B,EAAAA,SAASuD,aAAe6C,EAAEtE,OAAS9B,EAAAA,SAASwD,SAE1D2B,EAAQe,EAAiB,OAAS,KACxC,OACEtG,KAAKoD,KAAK,GAAGpD,KAAKmD,YAAYK,EAAKsC,OAAOO,IAAW7C,EAAKhD,UAC1DR,KAAKoD,KAAKkD,EAAiB,OAAOtG,KAAKmD,OAAO,KAAO,QACrDnD,KAAKoD,KAAKkD,EAAiB,GAAKtG,KAAKmD,OAAO,IAC5CnD,KAAKqF,SAA2B7B,EAAKmC,MAAOJ,GAC5CvF,KAAKoD,KACHkD,EACI,KAAKtG,KAAKmD,QAAO,KAAMnD,KAAKmD,YAC5B,GAAGnD,KAAKmD,eAAenD,KAAKmD,YAGtC,CAKA,IAAAO,CAAKF,GACH,MAAMuC,EAAQvC,EAAKwC,aACnB,IAAKD,EAAM7E,OACT,MAAO,GAGT,GAAIlB,KAAKiD,SACP,OACEjD,KAAKoD,KAAKI,EAAK2C,UAAU7C,KAAK,KAAME,EAAKhD,UACzCR,KAAKoD,KAAK,KACVpD,KAAKqF,SAASU,GACd/F,KAAKoD,KAAK,KAGd,MAAMD,EAASnD,KAAKmD,SAEpB,OACEnD,KAAKoD,KACHI,EAAK2C,UACFvF,IAAK6F,GACGtD,EAASsD,GAEjBnD,KAAK,OACRE,EAAKhD,UAEPR,KAAKoD,KAAK,QACVpD,KAAKoD,KAAKpD,KAAKmD,OAAO,IACtBnD,KAAKqF,SAASU,EAAO,MACrB/F,KAAKoD,KAAKpD,KAAKmD,QAAO,IACtBnD,KAAKoD,KAAK,KAAKpD,KAAKmD,YAExB,CAKA,WAAAQ,CAAYH,GACV,OAAIxD,KAAKiD,SAELjD,KAAKoD,KAAK,GAAGI,EAAKsB,YAAYtB,EAAKnB,QAASmB,EAAKhD,UACjDR,KAAKoD,KAAK,KAGQ,wBAAlBI,EAAKsB,SAEL9E,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KACHI,EAAKsB,SACH,KACAtB,EAAKnB,MAAMqE,MAAM,MAAMpD,KAAK,KAAKqD,OAAO,IAAM3G,KAAKmD,UACrDK,EAAKhD,UAEPR,KAAKoD,KAAK,KAGZpD,KAAKoD,KAAKpD,KAAKmD,UACfnD,KAAKoD,KAAK,GAAGI,EAAKsB,aAAatB,EAAKnB,QAASmB,EAAKhD,UAClDR,KAAKoD,KAAK,IAEd,ECprBK,MAAMwD,EF2CQ,CACnB9G,EACAoD,KAEAA,EAAUA,GAAW,CAAA,EAKrB,IAAIrD,EAAS,EACTJ,EAAS,EAiBb,SAASe,IACP,MAAMN,EAAQ,CAAEV,KAAMK,EAAQJ,OAAQA,GACtC,OACE+D,IAECA,EAAYhD,SAAW,IAAIP,EAC1BC,EACA,CAAEV,KAAMK,EAAQJ,OAAQA,GACxByD,GAASxD,QAAU,IAErBmH,IACOrD,EAEX,CAKA,MAAMsD,EAAmC,GAEzC,SAASC,EAAMnH,GACb,MAAMoH,EAAM,IAAI5H,EACd8D,GAASxD,QAAU,GACnBE,EACAC,EACAJ,EACAK,GAGF,IAAIoD,GAAS+D,OAGX,MAAMD,EAFNF,EAAW/F,KAAKiG,EAIpB,CAuBA,SAASE,IACP,MAAMC,EAAY,QAAQC,KAAKtH,GAC/B,QAAIqH,IACFE,EAAaF,IACN,EAGX,CAKA,SAASG,IACP,MAAMC,EAAa,KAAKH,KAAKtH,GAC7B,QAAIyH,IACFF,EAAaE,IACN,EAGX,CA6CA,SAASF,EAAaG,GACpB,MAAM3F,EAAM2F,EAAE,GAGd,OAzIF,SAAwB3F,GACtB,MAAM4F,EAAQ5F,EAAI6F,MAAM,OACpBD,IACF5H,GAAU4H,EAAMvG,QAElB,MAAMuE,EAAI5D,EAAI8F,YAAY,MAC1BlI,GAAUgG,EAAI5D,EAAIX,OAASuE,EAAIhG,EAASoC,EAAIX,MAC9C,CAgIE0G,CAAe/F,GACf/B,EAAMA,EAAI+H,MAAMhG,EAAIX,QACbsG,CACT,CAKA,SAASX,IACP,MAAMW,EAAI,OAAOJ,KAAKtH,GAClB0H,GACFH,EAAaG,EAEjB,CAKA,SAASM,EACPnC,GAEAA,EAAQA,GAAS,GACjB,IAAIoC,EAA+BnE,IACnC,KAAOmE,GACLpC,EAAM5E,KAAKgH,GACXA,EAAInE,IAEN,OAAO+B,CACT,CAKA,SAAS/B,IACP,MAAMoE,EAAMxH,IACZ,GAAI,MAAQV,EAAImI,OAAO,IAAM,MAAQnI,EAAImI,OAAO,GAC9C,OAGF,MAAMT,EAAI,iBAAiBJ,KAAKtH,GAChC,OAAK0H,GAGLH,EAAaG,GAENQ,EAAmB,CACxB9F,KAAM9B,EAAAA,SAASwD,QACfA,QAAS4D,EAAE,GAAGK,MAAM,GAAG,MANhBd,EAAM,yBAQjB,CAKA,SAASmB,IACP,MAAMC,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,GAAgC,IAAbA,EACrB,OAEF,MAAMC,EAActI,EAAIuI,UAAU,EAAGF,GAErCd,EADkB,CAACe,IAMnB,MD5G2C,EAC7C9H,EACAC,KAEA,MAAM+H,EAAwB,GAC9B,IAAI7H,EAAkB,EACtB,KAAOA,EAAkBH,EAAOY,QAAQ,CACtC,MAAMqH,EAAQjH,EACZhB,EACAC,EACAE,GAEF,IAAc,IAAV8H,EAEF,OADAD,EAAOvH,KAAKT,EAAO+H,UAAU5H,IACtB6H,EAETA,EAAOvH,KAAKT,EAAO+H,UAAU5H,EAAiB8H,IAC9C9H,EAAkB8H,EAAQ,CAC5B,CACA,OAAOD,GCyFEE,CAFK5G,EAAKwG,GAAaK,QAAQ9G,EAAc,IAER,CAAC,MAAMf,IAAKC,GAAMe,EAAKf,GACrE,CAKA,SAAS8C,IACP,MAAMqE,EAAMxH,IAGNkI,EAAY,yCAAyCtB,KAAKtH,GAChE,IAAK4I,EACH,OAEFrB,EAAaqB,GACb,MAAMC,EAAY/G,EAAK8G,EAAU,IAG3BE,EAAiB,QAAQxB,KAAKtH,GACpC,IAAK8I,EACH,OAAO7B,EAAM,wBAEfM,EAAauB,GAGb,IAAIvG,EAAQ,GACZ,MAAMwG,EAAmBvH,EAAuCxB,EAAK,CACnE,IACA,MAEF,IAAyB,IAArB+I,EAAyB,CAC3BxG,EAAQvC,EAAIuI,UAAU,EAAGQ,GAEzBxB,EADkB,CAAChF,IAGnBA,EAAQT,EAAKS,GAAOoG,QAAQ9G,EAAc,GAC5C,CAEA,MAAMmH,EAAMd,EAAuB,CACjC9F,KAAM9B,EAAAA,SAASuD,YACfmB,SAAU6D,EAAUF,QAAQ9G,EAAc,IAC1CU,MAAOA,IAIH0G,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRD,CACT,CAMA,SAAS9C,IACP,MAAMD,EAAkD,GAExD,IAAKmB,IACH,OAAOH,EAAM,eAEfe,EAAS/B,GAGT,IAAIiD,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,IAGT,KAAOT,GAAS+D,QAAUnH,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC7D,MAAMgB,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,MAAgC,IAAbd,GAAmBc,EAAUd,GAclD,MANA,IAJAd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAAS/B,GACTiD,EAAOrF,IACAqF,GACLjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,GACTiD,EAAOrF,GAKb,CAEA,OAAK2D,IAGEvB,EAFEgB,EAAM,cAGjB,CAMA,SAASmC,IACP,MAAMf,EAAW7G,EAAuCxB,EAAK,CAAC,MAC9D,IAAiB,IAAbqI,EACF,OAAO,EAET,MAAMc,EAAU3H,EAAuCxB,EAAK,CAAC,MACvDqJ,EAAW7H,EAAuCxB,EAAK,CAAC,MAE9D,SAAgB,IAAZmJ,GAAkBA,EAAUd,OAGf,IAAbgB,GAAmBA,EAAWhB,EAIpC,CAMA,SAASiB,IAGP,MAAMC,EAAiE,GAEvE,IAAKnC,IACH,OAAOH,EAAM,eAIf,IAFAe,EAASuB,GAEFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAMK,EAAU7F,IAChB,GAAI6F,EAAS,CACXF,EAAMtI,KAAKwI,GACXzB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CAEA,OAAK/B,IAGE+B,EAFEtC,EAAM,cAGjB,CAOA,SAASyC,IACP,MAAMH,EAAiE,GAGvE,IAFAxC,IACAiB,EAASuB,GACFvJ,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAE1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACND,EAAMtI,KAAKuI,GACXxB,EAASuB,GACT,QACF,CACF,CAGA,GAAIH,IAAuB,CACzB,MAAM1C,EAAI9C,IACV,GAAI8C,EAAG,CACL6C,EAAMtI,KAAKyF,GACXsB,EAASuB,GACT,QACF,CACF,CAGA,MAAML,EAAOrF,IACb,IAAIqF,EAAJ,CAOA,GAAI9F,GAAS+D,OAAQ,CACnB,MAAMgC,EAAUnJ,EAAIgB,QAAQ,KACtBqH,EAAWrI,EAAIgB,QAAQ,KAC7B,IAAgB,IAAZmI,KAAgC,IAAbd,GAAmBc,EAAUd,GAAW,CAI7Dd,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGY,EAAU,KAG7BpC,IACAiB,EAASuB,GACT,QACF,CACF,CACA,KAhBA,CAHEA,EAAMtI,KAAKiI,GACXlB,EAASuB,EAmBb,CACA,OAAOA,CACT,CAKA,SAAS9E,IACP,MAAMkF,EAAO,GACPzB,EAAMxH,IAEZ,IAAIgH,EAA4B,sCAAsCJ,KACpEtH,GAEF,KAAO0H,GAAG,CACR,MAAMkC,EAAMrC,EAAaG,GACzBiC,EAAK1I,KAAK2I,EAAI,IACd,MAAMC,EAAc,QAAQvC,KAAKtH,GAC7B6J,GACFtC,EAAasC,GAEfnC,EAAI,sCAAsCJ,KAAKtH,EACjD,CAEA,GAAK2J,EAAKvI,OAIV,OAAO8G,EAAoB,CACzB9F,KAAM9B,EAAAA,SAASmE,SACf0B,OAAQwD,EACRzD,aAAcA,KAAkB,IAEpC,CAyNA,MAkBM4D,EAAqB,IAAIC,OAC7B,MAnByB,CACzB,kBACA,WACA,aACA,YACA,mBACA,qBACA,cACA,gBACA,eACA,sBACA,WACA,cACA,cACA,YACA,eACA,gBAGyBvG,KAAK,uBAuWhC,MAAMwG,EAAWC,EAA6B,UAKxCC,EAAYD,EAA8B,WAK1CE,EAAcF,EAAgC,aAKpD,SAASA,EACPjE,GAEA,MAAMoE,EAAK,IAAIL,OACb,KACE/D,EACA,yEAKJ,MAAO,KACL,MAAMkC,EAAMxH,IACNgH,EAAI0C,EAAG9C,KAAKtH,GAClB,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GACnBsB,EAA8B,CAAE5G,KAAM4D,GAE5C,OADAgD,EAAIhD,GAAQ4D,EAAI,GAAG9H,OACZoG,EAAQc,GAEnB,CAyDA,SAAS3D,IACP,GAAe,MAAXrF,EAAI,GAIR,OAjrBF,WACE,MAAMkI,EAAMxH,IACN2J,EAAK,0BAA0B/C,KAAKtH,GAE1C,IAAKqK,EACH,OAEF,MAAMtE,EAASwB,EAAa8C,GAAI,GAG1BC,EAAK,eAAehD,KAAKtH,GAC/B,IAAKsK,EACH,OAAOrD,EAAM,2BAEf,MAAMjB,EAAOuB,EAAa+C,GAAI,GAE9B,IAAKlD,IACH,OAAOH,EAAM,0BAGf,IAAIsD,EAAgDvC,IAChDwC,EAAoC/F,IACxC,KAAO+F,GACLD,EAAOtJ,KAAKuJ,GACZD,EAASA,EAAOE,OAAOzC,KACvBwC,EAAQ/F,IAGV,OAAK+C,IAIEU,EAAqB,CAC1B9F,KAAM9B,EAAAA,SAASkE,UACfwB,KAAMA,EACND,OAAQA,EACRvB,UAAW+F,IAPJtD,EAAM,yBASjB,CA4oBIyD,IA7gBJ,WACE,MAAMxC,EAAMxH,IACNgH,EAAI,mBAAmBJ,KAAKtH,GAElC,IAAK0H,EACH,OAEF,MAAM/C,EAAQ7C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAAAA,SAASqE,MACfA,MAAOA,EACPkB,MAAO8E,IANA1D,EAAM,qBAQjB,CAsfI2D,IAjfJ,WACE,MAAM1C,EAAMxH,IACNgH,EAAI,8CAA8CJ,KAAKtH,GAC7D,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEzB,OAAOQ,EAAuB,CAC5B9F,KAAM9B,EAAAA,SAAS6D,YACf6B,KAAMlE,EAAK8H,EAAI,IACfjF,MAAO7C,EAAK8H,EAAI,KAEpB,CAqeIiB,IAzoBJ,WACE,MAAM3C,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GAErC,IAAK0H,EACH,OAEF,MAAMvC,EAAWrD,EAAKyF,EAAaG,GAAG,IAEtC,IAAKN,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAAA,SAAS6E,SACfA,SAAUA,EACVU,MAAO8E,IANA1D,EAAM,wBAQjB,CAknBI6D,IACAd,KACAE,KACAC,KA7XJ,WACE,MAAMjC,EAAMxH,IACNgH,EAAI,+BAA+BJ,KAAKtH,GAC9C,IAAK0H,EACH,OAEF,MAAMkC,EAAMrC,EAAaG,GAEnB3B,EAASjE,EAAK8H,EAAI,IAClB9D,EAAMhE,EAAK8H,EAAI,IAErB,IAAKxC,IACH,OAAOH,EAAM,yBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAAA,SAAS4D,SACfA,SAAU4B,EACVC,OAAQA,EACRF,MAAO8E,IAPA1D,EAAM,wBASjB,CAmWI8D,IA/aJ,WACE,MAAM7C,EAAMxH,IACNgH,EAAI,WAAWJ,KAAKtH,GAC1B,IAAK0H,EACH,OAEFH,EAAaG,GAEb,MAAMtB,EAAMgC,KAAc,GAE1B,IAAKhB,IACH,OAAOH,EAAM,qBAEf,MAAMhB,EAAiE,GAIvE,IAHA+B,EAAS/B,GAGFjG,EAAIoB,QAA4B,MAAlBpB,EAAImI,OAAO,IAAY,CAC1C,GAAsB,MAAlBnI,EAAImI,OAAO,GAAY,CACzB,MAAMqB,EAAKnE,IACX,GAAImE,EAAI,CACNvD,EAAMhF,KAAKuI,GACXxB,EAAS/B,GACT,QACF,CACF,CACA,MAAMiD,EAAOrF,IACb,IAAIqF,EAKJ,MAJEjD,EAAMhF,KAAKiI,GACXlB,EAAS/B,EAIb,CAEA,OAAKuB,IAIEU,EAAgB,CACrB9F,KAAM9B,EAAAA,SAASuE,KACfwB,UAAWD,EACXF,aAAcD,IANPgB,EAAM,oBAQjB,CAoYI+D,IAlnBJ,WACE,MAAM9C,EAAMxH,IACNgH,EAAI,YAAYJ,KAAKtH,GAE3B,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,qBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAgB,CACrB9F,KAAM9B,EAAAA,SAASgE,KACfuB,MAAO8E,IALA1D,EAAM,oBAOjB,CA4lBIgE,IAhWJ,WACE,MAAM/C,EAAMxH,IACNgH,EAAI,iBAAiBJ,KAAKtH,GAChC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,0BAEf,IAAIhB,EAAQ+B,IAGRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAGT,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAAA,SAAS8D,SACf8B,aAAcD,IALPgB,EAAM,yBAOjB,CAoUIiE,IA/PJ,WACE,MAAMhD,EAAMxH,IACNgH,EAAI,kCAAkCJ,KAAKtH,GACjD,IAAK0H,EACH,OAEF,MAAMpB,EAAaxE,EAAKyF,EAAaG,GAAG,IAExC,IAAKN,IACH,OAAOH,EAAM,oCAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAA6B,CAClC9F,KAAM9B,EAAAA,SAAS+D,kBACfiC,WAAYA,EACZT,MAAO8E,IANA1D,EAAM,mCAQjB,CAyOIkE,IAzlBJ,WACE,MAAMjD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GAEtC,IAAK0H,EACH,OAEF,MAAM3D,EAAYjC,EAAKyF,EAAaG,GAAG,IAEvC,IAAKN,IACH,OAAOH,EAAM,0BAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAqB,CAC1B9F,KAAM9B,EAAAA,SAASyD,UACfA,UAAWA,EACX8B,MAAO8E,IANA1D,EAAM,yBAQjB,CAkkBImE,IA1IJ,WACE,MAAMlD,EAAMxH,IACNgH,EAAI,sBAAsBJ,KAAKtH,GACrC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,+BAEf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAAAA,SAAS4E,cACfW,MAAO8E,IALA1D,EAAM,8BAOjB,CAsHIoE,IA9jBJ,WACE,MAAMnD,EAAMxH,IACNgH,EAAI,qBAAqBJ,KAAKtH,GAEpC,IAAK0H,EACH,OAEF,MAAMhD,EAAQ5C,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IAAQ,CACX,MAAMkD,EAAK,UAAUhD,KAAKtH,GAI1B,OAHIsK,GACF/C,EAAa+C,GAERpC,EAAiB,CACtB9F,KAAM9B,EAAAA,SAASoE,MACfA,MAAOA,GAEX,CAEA,MAAMiG,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAAAA,SAASoE,MACfA,MAAOA,EACPmB,MAAO8E,IANA1D,EAAM,qBAQjB,CAgiBIqE,IAnUJ,WACE,MAAMpD,EAAMxH,IACNgH,EAAI,6BAA6BJ,KAAKtH,GAC5C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,yBAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAoB,CACzB9F,KAAM9B,EAAAA,SAAS0E,SACfgB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,wBAQjB,CAySIsE,IApSJ,WACE,MAAMrD,EAAMxH,IACNgH,EAAI,gCAAgCJ,KAAKtH,GAC/C,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,8BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAwB,CAC7B9F,KAAM9B,EAAAA,SAAS2D,aACf+B,KAAMA,EACNE,aAAcD,IANPgB,EAAM,6BAQjB,CA0QIuE,IAzOJ,WACE,MAAMtD,EAAMxH,IACNgH,EAAI,oBAAoBJ,KAAKtH,GACnC,IAAK0H,EACH,OAEF,MAAMzC,EAAQnD,EAAKyF,EAAaG,GAAG,IAEnC,IAAKN,IACH,OAAOH,EAAM,sBAGf,MAAM0D,EAAQjB,IAEd,OAAKlC,IAIEU,EAAiB,CACtB9F,KAAM9B,EAAAA,SAAS2E,MACfA,MAAOA,EACPY,MAAO8E,IANA1D,EAAM,qBAQjB,CAmNIwE,IA9MJ,WACE,MAAMvD,EAAMxH,IACNgH,EAAI,uBAAuBJ,KAAKtH,GACtC,IAAK0H,EACH,OAIF,GAFAH,EAAaG,IAERN,IACH,OAAOH,EAAM,gCAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAA0B,CAC/B9F,KAAM9B,EAAAA,SAAS8E,eACfc,aAAcD,IALPgB,EAAM,+BAOjB,CAqLIyE,IAhLJ,WACE,MAAMxD,EAAMxH,IACNgH,EAAI,iCAAiCJ,KAAKtH,GAChD,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,6BAEf,IAAIhB,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAuB,CAC5B9F,KAAM9B,EAAAA,SAASyE,YACfiB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,4BAQjB,CAsJI0E,IA3dJ,WACE,MAAMzD,EAAMxH,IACNgH,EAAIoC,EAAmBxC,KAAKtH,GAClC,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAE7B,IAAKN,IACH,OAAOH,EAAM,IAAIjB,iBAEnB,IAAIC,EAAQ+B,IACRkB,EAAsCrF,IAC1C,KAAOqF,GACLjD,EAAMhF,KAAKiI,GACXjD,EAAQA,EAAMwE,OAAOzC,KACrBkB,EAAOrF,IAET,OAAK2D,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAAAA,SAASwE,cACfkB,KAAMA,EACNE,aAAcD,IANPgB,EAAM,IAAIjB,gBAQrB,CAicI4F,IA7EJ,WACE,MAAM1D,EAAMxH,IACNgH,EAAI,gBAAgBJ,KAAKtH,GAC/B,IAAK0H,EACH,OAEF,MAAM1B,EAAOuB,EAAaG,GAAG,GAG7B,IAAInB,EAAU,GACd,MAAMsF,EAAarK,EAAuCxB,EAAK,CAAC,IAAK,OAClD,IAAf6L,GAAqBA,EAAa,IACpCtF,EAAUzE,EAAK9B,EAAIuI,UAAU,EAAGsD,IAIhCtE,EAHkB,CAChBvH,EAAIuI,UAAU,EAAGsD,MAMrB,GAAIzE,IAAQ,CACV,MAAMuD,EAAQjB,IAEd,OAAKlC,IAIEU,EAAyB,CAC9B9F,KAAM9B,EAAAA,SAAS+E,OACfW,KAAMA,EACNO,QAASA,EACTV,MAAO8E,IAPA1D,EAAM,IAAIjB,gBASrB,CAGA,MAAMiD,EAAW,UAAU3B,KAAKtH,GAKhC,OAJIiJ,GACF1B,EAAa0B,GAGRf,EAAyB,CAC9B9F,KAAM9B,EAAAA,SAAS+E,OACfW,KAAMA,EACNO,QAASA,GAEb,CAgCIuF,EAEJ,CAKA,SAASlI,IACP,MAAMsE,EAAMxH,IACN0F,EAAMgC,IAEZ,OAAKhC,GAGL4B,IAEOE,EAAgB,CACrB9F,KAAM9B,EAAAA,SAASsD,KACfyC,UAAWD,EACXF,aAAcoD,KAAc,MAPrBrC,EAAM,mBASjB,CAEA,OAAOjF,EA1oCP,WACE,MAAM+J,EAyCR,WACE,IAAIrI,EACJ,MAAMmC,EAA0C,GAChDkB,IACAiB,EAASnC,GACT,KAAO7F,EAAIoB,QAAQ,CACjB,GAAsB,MAAlBpB,EAAImI,OAAO,GAAY,CACzB,GAAI/E,GAAS+D,OAAQ,CAEnBF,EAAM,aAENM,EADkB,CAAC,MAEnBR,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAEA,GADAnC,EAAO2B,KAAYzB,KACfF,EAGG,CACL,GAAIN,GAAS+D,OAAQ,CAGnBI,EADkB,CAACvH,EAAImI,OAAO,KAE9BpB,IACAiB,EAASnC,GACT,QACF,CACA,KACF,CAZEA,EAAM5E,KAAKyC,GACXsE,EAASnC,EAYb,CACA,OAAOA,CACT,CA5EoBA,GAWlB,MATiC,CAC/BzD,KAAM9B,EAAAA,SAASqD,WACfA,WAAY,CACV/D,OAAQwD,GAASxD,OACjBiG,MAAOkG,EACPC,cAAehF,GAKrB,CA6nCiBrD,KEtvCNsI,ECAE,CAACvI,EAAwBN,IACrB,IAAIJ,EAASI,GAAW,CAAA,GACzBwC,QAAQlC,GDE1B,IAAA+E,EAAe,CAAE3B,QAAOmF"} \ No newline at end of file diff --git a/tools/ui/node_modules/@adobe/css-tools/docs/API.md b/tools/ui/node_modules/@adobe/css-tools/docs/API.md new file mode 100644 index 0000000000000000000000000000000000000000..35f178c72a80d140778567fc36ee89cc052cc95b --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/docs/API.md @@ -0,0 +1,314 @@ +# API Reference + +## Overview + +`@adobe/css-tools` provides a modern CSS parser and stringifier with comprehensive TypeScript support. It can parse CSS into an Abstract Syntax Tree (AST) and convert the AST back to CSS with various formatting options. + +## Installation + +```bash +npm install @adobe/css-tools +``` + +## Core Functions + +### `parse(code, options?)` + +Parses CSS code and returns an Abstract Syntax Tree (AST). + +#### Parameters + +- `code` (string) - The CSS code to parse +- `options` (object, optional) - Parsing options + - `silent` (boolean) - Silently fail on parse errors instead of throwing. When `true`, errors are collected in `ast.stylesheet.parsingErrors` + - `source` (string) - File path for better error reporting + +#### Returns + +- `CssStylesheetAST` - The parsed CSS as an AST + +#### Example + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = ` + .example { + color: red; + font-size: 16px; + } +`; + +const ast = parse(css); +console.log(ast.stylesheet.rules); +``` + +### `stringify(ast, options?)` + +Converts a CSS AST back to CSS string with configurable formatting. + +#### Parameters + +- `ast` (CssStylesheetAST) - The CSS AST to stringify +- `options` (CompilerOptions, optional) - Stringification options + - `indent` (string) - Indentation string (default: `' '`) + - `compress` (boolean) - Whether to compress/minify the output (default: `false`) + +#### Returns + +- `string` - The formatted CSS string + +#### Example + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = '.example { color: red; }'; +const ast = parse(css); + +// Pretty print +const formatted = stringify(ast, { indent: ' ' }); +console.log(formatted); +// Output: +// .example { +// color: red; +// } + +// Compressed +const minified = stringify(ast, { compress: true }); +console.log(minified); +// Output: .example{color:red} +``` + +## Type Definitions + +### Core Types + +#### `CssStylesheetAST` +The root AST node representing a complete CSS stylesheet. + +```typescript +type CssStylesheetAST = { + type: CssTypes.stylesheet; + stylesheet: { + source?: string; + rules: CssRuleAST[]; + parsingErrors?: CssParseError[]; + }; +}; +``` + +#### `CssRuleAST` +Represents a CSS rule (selector + declarations). + +```typescript +type CssRuleAST = { + type: CssTypes.rule; + selectors: string[]; + declarations: CssDeclarationAST[]; + position?: CssPosition; + parent?: CssStylesheetAST; +}; +``` + +#### `CssDeclarationAST` +Represents a CSS property declaration. + +```typescript +type CssDeclarationAST = { + type: CssTypes.declaration; + property: string; + value: string; + position?: CssPosition; + parent?: CssRuleAST; +}; +``` + +#### `CssMediaAST` +Represents a CSS @media rule. + +```typescript +type CssMediaAST = { + type: CssTypes.media; + media: string; + rules: CssRuleAST[]; + position?: CssPosition; + parent?: CssStylesheetAST; +}; +``` + +#### `CssKeyframesAST` +Represents a CSS @keyframes rule. + +```typescript +type CssKeyframesAST = { + type: CssTypes.keyframes; + name: string; + keyframes: CssKeyframeAST[]; + position?: CssPosition; + parent?: CssStylesheetAST; +}; +``` + +#### `CssPosition` +Represents source position information. + +```typescript +type CssPosition = { + source?: string; + start: { + line: number; + column: number; + }; + end: { + line: number; + column: number; + }; +}; +``` + +#### `CssParseError` +Represents a parsing error. + +```typescript +type CssParseError = { + message: string; + reason: string; + filename?: string; + line: number; + column: number; + source?: string; +}; +``` + +### Compiler Options + +#### `CompilerOptions` +Options for the stringifier. + +```typescript +type CompilerOptions = { + indent?: string; // Default: ' ' + compress?: boolean; // Default: false +}; +``` + +## Error Handling + +### Silent Parsing + +When parsing malformed CSS, you can use the `silent` option to collect errors instead of throwing: + +```javascript +import { parse } from '@adobe/css-tools'; + +const malformedCss = ` + body { color: red; } + { color: blue; } /* Missing selector */ + .valid { background: green; } +`; + +const result = parse(malformedCss, { silent: true }); + +if (result.stylesheet.parsingErrors) { + result.stylesheet.parsingErrors.forEach(error => { + console.log(`Error at line ${error.line}: ${error.message}`); + }); +} + +// Valid rules are still parsed +console.log('Valid rules:', result.stylesheet.rules.length); +``` + +### Source Tracking + +Enable source tracking for better error reporting: + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = 'body { color: red; }'; +const ast = parse(css, { source: 'styles.css' }); + +const rule = ast.stylesheet.rules[0]; +console.log(rule.position?.source); // "styles.css" +console.log(rule.position?.start); // { line: 1, column: 1 } +console.log(rule.position?.end); // { line: 1, column: 20 } +``` + +## Advanced Usage + +### Working with At-Rules + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = ` + @media (max-width: 768px) { + .container { + padding: 10px; + } + } + + @keyframes fadeIn { + from { opacity: 0; } + to { opacity: 1; } + } +`; + +const ast = parse(css); + +// Access media rules +const mediaRule = ast.stylesheet.rules.find(rule => rule.type === 'media'); +console.log(mediaRule.media); // "(max-width: 768px)" + +// Access keyframes +const keyframesRule = ast.stylesheet.rules.find(rule => rule.type === 'keyframes'); +console.log(keyframesRule.name); // "fadeIn" +``` + +### Custom Formatting + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = '.example{color:red;font-size:16px}'; +const ast = parse(css); + +// Custom indentation +const formatted = stringify(ast, { indent: ' ' }); +console.log(formatted); +// Output: +// .example { +// color: red; +// font-size: 16px; +// } + +// Compressed with no spaces +const compressed = stringify(ast, { compress: true }); +console.log(compressed); +// Output: .example{color:red;font-size:16px} +``` + +## TypeScript Integration + +The library provides comprehensive TypeScript support with full type definitions for all AST nodes and functions: + +```typescript +import { parse, stringify, type CssStylesheetAST } from '@adobe/css-tools'; + +const css: string = '.example { color: red; }'; +const ast: CssStylesheetAST = parse(css); +const output: string = stringify(ast); +``` + +## Performance Considerations + +- The parser is optimized for large CSS files +- AST nodes are lightweight and memory-efficient +- Stringification is fast and supports streaming for large outputs +- Consider using `compress: true` for production builds to reduce file size + +## Browser Support + +The library works in all modern browsers and Node.js environments. For older environments, you may need to use a bundler with appropriate polyfills. diff --git a/tools/ui/node_modules/@adobe/css-tools/docs/AST.md b/tools/ui/node_modules/@adobe/css-tools/docs/AST.md new file mode 100644 index 0000000000000000000000000000000000000000..eaac3dd17190a2bd3a13c27ab284cda2c385349a --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/docs/AST.md @@ -0,0 +1,366 @@ +# Abstract Syntax Tree (AST) + +## Overview + +The AST represents CSS as a tree structure where each node has a specific type and properties. All nodes share common properties and have type-specific properties. + +## Common Properties + +All AST nodes have these properties: + +### `type` + +The node type as a string. See [Node Types](#node-types) for all possible values. + +### `position` (optional) + +Position information for the node in the source code: + +```typescript +{ + start: { line: number; column: number }; + end: { line: number; column: number }; + source?: string; +} +``` + +### `parent` (optional) + +Reference to the parent node in the AST. + +## Node Types + +### `stylesheet` + +The root node representing an entire CSS document. + +**Properties:** +- `stylesheet.source` (optional): Source file path +- `stylesheet.rules`: Array of top-level rules +- `stylesheet.parsingErrors` (optional): Array of parse errors when `silent` option is used + +**Example:** +```json +{ + "type": "stylesheet", + "stylesheet": { + "rules": [ + // ... other nodes + ] + } +} +``` + +### `rule` + +A CSS rule with selectors and declarations. + +**Properties:** +- `selectors`: Array of CSS selectors as strings +- `declarations`: Array of declarations and comments + +**Example:** +```json +{ + "type": "rule", + "selectors": ["body", "html"], + "declarations": [ + { + "type": "declaration", + "property": "color", + "value": "red" + } + ] +} +``` + +### `declaration` + +A CSS property declaration. + +**Properties:** +- `property`: The CSS property name +- `value`: The CSS property value as a string + +**Example:** +```json +{ + "type": "declaration", + "property": "background-color", + "value": "#ffffff" +} +``` + +### `comment` + +A CSS comment. + +**Properties:** +- `comment`: The comment text (without `/*` and `*/`) + +**Example:** +```json +{ + "type": "comment", + "comment": " This is a comment " +} +``` + +### `media` + +A `@media` rule. + +**Properties:** +- `media`: The media query string +- `rules`: Array of rules within the media block + +**Example:** +```json +{ + "type": "media", + "media": "screen and (max-width: 768px)", + "rules": [ + // ... nested rules + ] +} +``` + +### `keyframes` + +A `@keyframes` rule. + +**Properties:** +- `name`: The keyframes name +- `vendor` (optional): Vendor prefix (e.g., "-webkit-") +- `keyframes`: Array of keyframe rules and comments + +**Example:** +```json +{ + "type": "keyframes", + "name": "fade", + "keyframes": [ + { + "type": "keyframe", + "values": ["from"], + "declarations": [ + { + "type": "declaration", + "property": "opacity", + "value": "0" + } + ] + } + ] +} +``` + +### `keyframe` + +A keyframe within a `@keyframes` rule. + +**Properties:** +- `values`: Array of keyframe selectors (e.g., `["from"]`, `["to"]`, `["50%"]`) +- `declarations`: Array of declarations and comments + +### `import` + +An `@import` rule. + +**Properties:** +- `import`: The import string (URL or media query) + +**Example:** +```json +{ + "type": "import", + "import": "url('styles.css')" +} +``` + +### `charset` + +A `@charset` rule. + +**Properties:** +- `charset`: The character encoding + +**Example:** +```json +{ + "type": "charset", + "charset": "utf-8" +} +``` + +### `namespace` + +A `@namespace` rule. + +**Properties:** +- `namespace`: The namespace declaration + +**Example:** +```json +{ + "type": "namespace", + "namespace": "url(http://www.w3.org/1999/xhtml)" +} +``` + +### `supports` + +A `@supports` rule. + +**Properties:** +- `supports`: The supports condition +- `rules`: Array of rules within the supports block + +**Example:** +```json +{ + "type": "supports", + "supports": "(display: grid)", + "rules": [ + // ... nested rules + ] +} +``` + +### `document` + +A `@document` rule. + +**Properties:** +- `document`: The document condition +- `vendor` (optional): Vendor prefix +- `rules`: Array of rules within the document block + +### `page` + +A `@page` rule. + +**Properties:** +- `selectors`: Array of page selectors +- `declarations`: Array of declarations and comments + +### `font-face` + +A `@font-face` rule. + +**Properties:** +- `declarations`: Array of font declarations and comments + +### `host` + +A `:host` rule. + +**Properties:** +- `rules`: Array of rules within the host block + +### `container` + +A `@container` rule. + +**Properties:** +- `container`: The container query +- `rules`: Array of rules within the container block + +### `layer` + +A `@layer` rule. + +**Properties:** +- `layer`: The layer name +- `rules` (optional): Array of rules within the layer block + +### `custom-media` + +A `@custom-media` rule. + +**Properties:** +- `name`: The custom media query name +- `media`: The media query definition + +### `starting-style` + +A `@starting-style` rule. + +**Properties:** +- `rules`: Array of rules within the starting-style block + +## Type Hierarchy + +The AST nodes are organized in the following hierarchy: + +- `CssStylesheetAST` - Root node +- `CssAtRuleAST` - Union of all at-rule and rule nodes +- `CssAllNodesAST` - Union of all possible node types + +## Working with the AST + +### Traversing Nodes + +```typescript +import { parse, CssStylesheetAST } from '@adobe/css-tools'; + +const ast: CssStylesheetAST = parse('body { color: red; }'); + +// Access top-level rules +ast.stylesheet.rules.forEach(rule => { + if (rule.type === 'rule') { + console.log('Selectors:', rule.selectors); + rule.declarations.forEach(decl => { + if (decl.type === 'declaration') { + console.log(`${decl.property}: ${decl.value}`); + } + }); + } +}); +``` + +### Modifying Nodes + +```typescript +// Add a new declaration +const newDecl = { + type: 'declaration' as const, + property: 'font-size', + value: '16px' +}; + +// Find a rule and add the declaration +ast.stylesheet.rules.forEach(rule => { + if (rule.type === 'rule' && rule.selectors.includes('body')) { + rule.declarations.push(newDecl); + } +}); +``` + +### Error Handling + +When parsing with the `silent` option, errors are collected in the AST: + +```typescript +const ast = parse('invalid css {', { silent: true }); + +if (ast.stylesheet.parsingErrors) { + ast.stylesheet.parsingErrors.forEach(error => { + console.error('Parse error:', error.message); + }); +} +``` + +## Position Information + +Position information is available on most nodes and includes: + +- `start.line` and `start.column`: Beginning of the node +- `end.line` and `end.column`: End of the node +- `source`: Source file path (if provided during parsing) + +This is useful for: +- Error reporting +- Source mapping +- Code analysis tools +- IDE integration diff --git a/tools/ui/node_modules/@adobe/css-tools/docs/CHANGELOG.md b/tools/ui/node_modules/@adobe/css-tools/docs/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..392767b69dadc3f3cc19327c7a3e5ad67b12c04c --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/docs/CHANGELOG.md @@ -0,0 +1,216 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [4.5.0] - 2026-05-20 + +### Added +- Add support for CSS Nesting — rules nested inside other rules (#621 by @jogibear9988) +- Add support for `@container` container queries with nested rule body +- Add support for Page Margin Boxes (`@top-left`, `@bottom-right`, `@left-middle`, etc.) inside `@page` +- Add generic at-rule fallback — unknown `@foo { ... }` and `@foo ...;` rules are preserved as `CssGenericAtRuleAST` instead of being dropped +- Add support for `@counter-style`, `@font-feature-values`, `@scope`, `@view-transition`, `@position-try` +- Export new TypeScript types: `CssGenericAtRuleAST`, `CssPageMarginBoxAST`, `CssPositionTryAST`, `CssScopeAST`, `CssViewTransitionAST`, `CssCounterStyleAST`, `CssFontFeatureValuesAST` + +### Fixed +- Fix selector parsing for complex nested selectors including `:is()`, `:has()`, `:not()` +- Fix `@page` to correctly accept margin-box at-rule children +- Fix bracket- and quote-aware position tracking for pseudo-functions + +### Changed +- Upgrade to TypeScript 6.0.2 +- Upgrade to `@rollup/plugin-terser` 1.0.0 +- Drop Node 18 from CI (EOL April 2025) — minimum supported runtime is now Node 20 + +### Security +- Update lodash to 4.18.1 +- Update minimatch to 3.1.5 +- Update picomatch to 4.0.4 + +## [4.4.4] - 2025-07-22 + +### Changed +- Switch from yarn to npm for package management +- Switch from eslint to biome for code formatting and linting +- Reformat codebase to comply with biome recommendations +- Switch from webpack to rollup for bundling + +### Fixed +- Fix module exports to ensure proper compatibility with bundlers +- Add validation check to prevent future export issues + +## [4.4.3] - 2025-05-15 + +### Security +- Fix polynomial regular expression vulnerability on uncontrolled data +- Refactor code to enable GitHub security static analysis + +### Performance +- Improve parsing performance with minor optimizations +- Replace regex patterns with string search (indexOf-based) for better performance + +### Added +- Add new utility functions with comprehensive unit tests +- Add improved formatting for CSS Grid template areas (#283 by @jogibear9988) + +### Fixed +- Fix TypeScript error with ConstructorParameters in Parcel bundler (#444) + +## [4.4.2] - 2025-02-12 + +### Fixed +- Fix regular expression for parsing quoted values in parentheses + +## [4.4.0] - 2024-06-05 + +### Added +- Add support for CSS `@starting-style` at-rule (#319) + +## [4.3.3] - 2024-01-24 + +### Changed +- Update package export configuration (#271) + +## [4.3.2] - 2023-11-28 + +### Security +- Fix ReDoS vulnerability with crafted CSS strings - CVE-2023-48631 + +### Fixed +- Fix parsing issues with `:is()` and nested `:nth-child()` selectors (#211) + +## [4.3.1] - 2023-03-14 + +### Security +- Fix ReDoS vulnerability with crafted CSS strings - CVE-2023-26364 + +## [4.3.0] - 2023-03-07 + +### Changed +- Update build toolchain and dependencies +- Update package exports configuration and file structure + +## [4.2.0] - 2023-02-21 + +### Added +- Add support for CSS `@container` at-rule +- Add support for CSS `@layer` at-rule + +## [4.1.0] - 2023-01-25 + +### Added +- Add support for ES Modules (ESM) + +## [4.0.2] - 2023-01-12 + +### Fixed +- Fix `@import` parsing when URL contains semicolons (#71) +- Fix regression in selector parsing for attribute selectors (#77) + +## [4.0.1] - 2022-08-03 + +### Fixed +- Fix `globalThis` configuration for webpack to enable UMD module usage in Node.js environments + +## [4.0.0] - 2022-06-09 + +### Changed +- Fork from original css library to Adobe's `@adobe/css-tools` package +- Convert codebase from JavaScript to TypeScript +- Improve parsing performance by approximately 25% +- Update all dependencies to latest versions +- Remove source map support + +--- + +## Legacy Versions (Pre-Adobe Fork) + +## [3.0.0] - 2020-07-01 + +### Changed +- Bump major version due to major dependency updates and Node.js version requirement changes + +## [2.2.1] - 2015-06-17 + +### Fixed +- Fix parsing of escaped quotes in quoted strings + +## [2.2.0] - 2015-02-18 + +### Added +- Add `parsingErrors` property to list errors when parsing with `silent: true` +- Accept EOL characters and all whitespace characters in at-rules such as `@media` + +## [2.1.0] - 2014-08-05 + +### Added +- Add `inputSourcemaps` option to disable input source map processing +- Add `sourcemap: 'generator'` option to return the `SourceMapGenerator` object +- Use `inherits` package for inheritance (fixes browser compatibility issues) + +### Changed +- Change error message format and add `.reason` property to error objects + +## [2.0.0] - 2014-06-18 + +### Added +- Add non-enumerable parent reference to each AST node +- Add support for `@custom-media`, `@host`, and `@font-face` at-rules +- Allow commas inside selector functions +- Allow empty property values +- Add `node.position.content` property +- Integrate css-parse and css-stringify libraries +- Apply original source maps from source files + +### Changed +- Change default `options.position` value to `true` +- Remove comments from properties and values + +### Removed +- Drop Component(1) support + +### Fixed +- Fix assertion errors when selectors are missing + +## [1.6.1] - 2014-01-02 + +### Fixed +- Fix component.json configuration + +## [1.6.0] - 2013-12-21 + +### Changed +- Update dependencies + +## [1.5.0] - 2013-12-03 + +### Changed +- Update dependencies + +## [1.1.0] - 2013-04-04 + +### Changed +- Update dependencies + +## [1.0.7] - 2012-11-21 + +### Fixed +- Fix component.json configuration + +## [1.0.4] - 2012-11-15 + +### Changed +- Update css-stringify dependency + +## [1.0.3] - 2012-09-01 + +### Added +- Add Component support + +## [0.0.1] - 2010-01-03 + +### Added +- Initial release diff --git a/tools/ui/node_modules/@adobe/css-tools/docs/EXAMPLES.md b/tools/ui/node_modules/@adobe/css-tools/docs/EXAMPLES.md new file mode 100644 index 0000000000000000000000000000000000000000..81565c678920c768c3dfd69a9791fc547a0e7b3f --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/docs/EXAMPLES.md @@ -0,0 +1,450 @@ +# Usage Examples + +## Basic Usage + +### Parsing CSS + +```javascript +import { parse } from '@adobe/css-tools'; + +// Basic CSS parsing +const css = ` + body { + font-size: 12px; + color: #333; + } + + .container { + max-width: 1200px; + margin: 0 auto; + } +`; + +const ast = parse(css); +console.log(ast); +``` + +### Stringifying AST + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = 'body { font-size: 12px; color: #333; }'; +const ast = parse(css); + +// Convert back to CSS +const output = stringify(ast); +console.log(output); // "body { font-size: 12px; color: #333; }" +``` + +## Advanced Parsing Options + +### Source Tracking + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = 'body { color: red; }'; +const ast = parse(css, { source: 'styles.css' }); + +// Position information is available +const rule = ast.stylesheet.rules[0]; +console.log(rule.position?.source); // "styles.css" +console.log(rule.position?.start); // { line: 1, column: 1 } +console.log(rule.position?.end); // { line: 1, column: 20 } +``` + +### Silent Error Handling + +```javascript +import { parse } from '@adobe/css-tools'; + +const malformedCss = ` + body { color: red; } + { color: blue; } /* Missing selector */ + .valid { background: green; } +`; + +// Parse with silent error handling +const result = parse(malformedCss, { silent: true }); + +// Check for parsing errors +if (result.stylesheet.parsingErrors) { + console.log('Parsing errors:', result.stylesheet.parsingErrors.length); + result.stylesheet.parsingErrors.forEach(error => { + console.log(`Error at line ${error.line}: ${error.message}`); + }); +} + +// Valid rules are still parsed +console.log('Valid rules:', result.stylesheet.rules.length); +``` + +## AST Structure Examples + +### Basic Rule + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = ` + .header { + background: #f0f0f0; + padding: 20px; + border-bottom: 1px solid #ccc; + } +`; + +const ast = parse(css); +const rule = ast.stylesheet.rules[0]; + +console.log(rule.type); // "rule" +console.log(rule.selectors); // [".header"] +console.log(rule.declarations.length); // 3 + +rule.declarations.forEach(decl => { + console.log(`${decl.property}: ${decl.value}`); +}); +// Output: +// background: #f0f0f0 +// padding: 20px +// border-bottom: 1px solid #ccc +``` + +### Media Queries + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = ` + @media screen and (max-width: 768px) { + .container { + padding: 10px; + } + + .sidebar { + display: none; + } + } +`; + +const ast = parse(css); +const mediaRule = ast.stylesheet.rules[0]; + +console.log(mediaRule.type); // "media" +console.log(mediaRule.media); // "screen and (max-width: 768px)" +console.log(mediaRule.rules.length); // 2 +``` + +### Keyframes + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = ` + @keyframes fadeIn { + from { + opacity: 0; + } + to { + opacity: 1; + } + } +`; + +const ast = parse(css); +const keyframesRule = ast.stylesheet.rules[0]; + +console.log(keyframesRule.type); // "keyframes" +console.log(keyframesRule.name); // "fadeIn" +console.log(keyframesRule.keyframes.length); // 2 + +keyframesRule.keyframes.forEach(keyframe => { + console.log(`Keyframe: ${keyframe.values.join(', ')}`); + keyframe.declarations.forEach(decl => { + console.log(` ${decl.property}: ${decl.value}`); + }); +}); +``` + +### Comments + +```javascript +import { parse } from '@adobe/css-tools'; + +const css = ` + /* Header styles */ + .header { + background: red; /* Fallback color */ + } + + /* Footer styles */ + .footer { + background: blue; + } +`; + +const ast = parse(css); + +ast.stylesheet.rules.forEach(rule => { + if (rule.type === 'comment') { + console.log(`Comment: ${rule.comment}`); + } else if (rule.type === 'rule') { + console.log(`Rule: ${rule.selectors.join(', ')}`); + + rule.declarations.forEach(decl => { + if (decl.type === 'comment') { + console.log(` Comment: ${decl.comment}`); + } else { + console.log(` ${decl.property}: ${decl.value}`); + } + }); + } +}); +``` + +## Stringifying Options + +### Compressed Output + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = ` + body { + font-size: 12px; + color: #333; + margin: 0; + padding: 0; + } +`; + +const ast = parse(css); + +// Compressed output +const compressed = stringify(ast, { compress: true }); +console.log(compressed); +// Output: "body{font-size:12px;color:#333;margin:0;padding:0}" +``` + +### Custom Indentation + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = 'body { font-size: 12px; color: #333; }'; +const ast = parse(css); + +// Custom indentation +const formatted = stringify(ast, { indent: ' ' }); +console.log(formatted); +// Output: +// body { +// font-size: 12px; +// color: #333; +// } +``` + +## Working with Complex CSS + +### Nested Rules and At-Rules + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const complexCss = ` + @import url('https://fonts.googleapis.com/css2?family=Roboto'); + + @charset "UTF-8"; + + @media print { + body { + font-size: 12pt; + } + } + + @supports (display: grid) { + .grid { + display: grid; + } + } + + @keyframes slideIn { + 0% { transform: translateX(-100%); } + 100% { transform: translateX(0); } + } + + @font-face { + font-family: 'CustomFont'; + src: url('custom-font.woff2') format('woff2'); + } +`; + +const ast = parse(complexCss); + +ast.stylesheet.rules.forEach(rule => { + switch (rule.type) { + case 'import': + console.log(`Import: ${rule.import}`); + break; + case 'charset': + console.log(`Charset: ${rule.charset}`); + break; + case 'media': + console.log(`Media query: ${rule.media}`); + break; + case 'supports': + console.log(`Supports: ${rule.supports}`); + break; + case 'keyframes': + console.log(`Keyframes: ${rule.name}`); + break; + case 'font-face': + console.log('Font-face rule'); + break; + } +}); +``` + +### Manipulating the AST + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +const css = ` + .button { + background: blue; + color: white; + padding: 10px; + } +`; + +const ast = parse(css); +const rule = ast.stylesheet.rules[0]; + +// Add a new declaration +rule.declarations.push({ + type: 'declaration', + property: 'border-radius', + value: '5px' +}); + +// Modify existing declaration +const backgroundDecl = rule.declarations.find(d => d.property === 'background'); +if (backgroundDecl) { + backgroundDecl.value = 'red'; +} + +// Add a new selector +rule.selectors.push('.btn'); + +const modifiedCss = stringify(ast); +console.log(modifiedCss); +``` + +## Error Handling + +### Catching Parse Errors + +```javascript +import { parse, CssParseError } from '@adobe/css-tools'; + +try { + const ast = parse('body { color: red; } { invalid }'); +} catch (error) { + if (error instanceof CssParseError) { + console.log(`Parse error at line ${error.line}, column ${error.column}:`); + console.log(error.message); + console.log(`Source: ${error.filename}`); + } +} +``` + +### Working with Silent Errors + +```javascript +import { parse } from '@adobe/css-tools'; + +const problematicCss = ` + body { color: red; } + { color: blue; } /* Missing selector */ + .valid { background: green; } + .another { border: 1px solid; } /* Missing closing brace */ +`; + +const result = parse(problematicCss, { + silent: true, + source: 'problematic.css' +}); + +// Process valid rules +const validRules = result.stylesheet.rules.filter(rule => rule.type === 'rule'); +console.log(`Found ${validRules.length} valid rules`); + +// Log errors for debugging +if (result.stylesheet.parsingErrors) { + result.stylesheet.parsingErrors.forEach(error => { + console.log(`Error: ${error.message} at line ${error.line}`); + }); +} +``` + +### CSS Minification + +```javascript +import { parse, stringify } from '@adobe/css-tools'; + +function minifyCSS(css) { + const ast = parse(css); + return stringify(ast, { compress: true }); +} + +const css = ` + body { + font-size: 12px; + color: #333; + margin: 0; + padding: 0; + } + + .container { + max-width: 1200px; + margin: 0 auto; + } +`; + +const minified = minifyCSS(css); +console.log(minified); +// Output: "body{font-size:12px;color:#333;margin:0;padding:0}.container{max-width:1200px;margin:0 auto}" +``` + +### CSS Validation + +```javascript +import { parse } from '@adobe/css-tools'; + +function validateCSS(css, filename = 'unknown') { + try { + const ast = parse(css, { source: filename }); + return { + valid: true, + rules: ast.stylesheet.rules.length, + errors: [] + }; + } catch (error) { + return { + valid: false, + rules: 0, + errors: [{ + message: error.message, + line: error.line, + column: error.column, + source: error.filename + }] + }; + } +} + +const result = validateCSS('body { color: red; } { invalid }', 'test.css'); +console.log(result); +``` diff --git a/tools/ui/node_modules/@adobe/css-tools/package.json b/tools/ui/node_modules/@adobe/css-tools/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4b8f1dc096c8ed92cd47a0b882e26a2da455a213 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/package.json @@ -0,0 +1,83 @@ +{ + "name": "@adobe/css-tools", + "version": "4.5.0", + "description": "A modern CSS parser and stringifier with TypeScript support", + "source": "src/index.ts", + "main": "./dist/cjs/adobe-css-tools.cjs", + "module": "./dist/esm/adobe-css-tools.mjs", + "browser": "./dist/umd/adobe-css-tools.js", + "sideEffects": false, + "exports": { + ".": { + "import": "./dist/esm/adobe-css-tools.mjs", + "require": "./dist/cjs/adobe-css-tools.cjs" + }, + "./package.json": "./package.json" + }, + "types": "./dist/esm/adobe-css-tools.d.mts", + "type": "module", + "files": [ + "dist/cjs", + "dist/esm", + "dist/umd", + "src", + "README.md", + "docs/" + ], + "devDependencies": { + "@arethetypeswrong/cli": "^0.18.2", + "@biomejs/biome": "^2.1.2", + "@rollup/plugin-commonjs": "^29.0.0", + "@rollup/plugin-node-resolve": "^16.0.1", + "@rollup/plugin-terser": "^1.0.0", + "@rollup/plugin-typescript": "^12.1.4", + "@types/benchmark": "^2.1.1", + "@types/bytes": "^3.1.5", + "@types/jest": "^30.0.0", + "@types/node": "^25.0.3", + "benchmark": "^2.1.4", + "bytes": "^3.1.0", + "jest": "^30.0.5", + "rollup": "^4.45.1", + "rollup-plugin-dts": "^6.2.1", + "ts-jest": "^29.4.10", + "tslib": "^2.8.1", + "typescript": "^6.0.2" + }, + "scripts": { + "benchmark": "npm run build && node benchmark/index.mjs", + "test": "jest", + "clean": "rm -rf ./dist", + "build": "rollup -c", + "fix": "biome check --write", + "check-package-bundle": "attw --pack .", + "lint": "biome check", + "prebuild": "npm run clean", + "prepack": "rollup -c", + "posttest": "npm run lint", + "postbuild": "tar -czf dist/archive.tgz LICENSE README.md dist/cjs dist/esm dist/umd docs package.json && npx attw --format ascii dist/archive.tgz && rm dist/archive.tgz" + }, + "author": "TJ Holowaychuk ", + "contributors": [ + "Jean-Philippe Zolesio " + ], + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/adobe/css-tools.git" + }, + "keywords": [ + "css", + "parser", + "stringifier", + "stylesheet", + "ast", + "typescript", + "css-parser", + "css-ast", + "css-tools", + "minify", + "format", + "preprocessor" + ] +} diff --git a/tools/ui/node_modules/@adobe/css-tools/src/CssParseError.ts b/tools/ui/node_modules/@adobe/css-tools/src/CssParseError.ts new file mode 100644 index 0000000000000000000000000000000000000000..7909a5a370d85628bc528b26ea45b63be028ddc0 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/CssParseError.ts @@ -0,0 +1,22 @@ +export default class CssParseError extends Error { + readonly reason: string; + readonly filename?: string; + readonly line: number; + readonly column: number; + readonly source: string; + + constructor( + filename: string, + msg: string, + lineno: number, + column: number, + css: string, + ) { + super(`${filename}:${lineno}:${column}: ${msg}`); + this.reason = msg; + this.filename = filename; + this.line = lineno; + this.column = column; + this.source = css; + } +} diff --git a/tools/ui/node_modules/@adobe/css-tools/src/CssPosition.ts b/tools/ui/node_modules/@adobe/css-tools/src/CssPosition.ts new file mode 100644 index 0000000000000000000000000000000000000000..9c55cb56f63fa28e9fcbf3da08587baf8b5c4f9a --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/CssPosition.ts @@ -0,0 +1,18 @@ +/** + * Store position information for a node + */ +export default class Position { + start: { line: number; column: number }; + end: { line: number; column: number }; + source?: string; + + constructor( + start: { line: number; column: number }, + end: { line: number; column: number }, + source: string, + ) { + this.start = start; + this.end = end; + this.source = source; + } +} diff --git a/tools/ui/node_modules/@adobe/css-tools/src/index.ts b/tools/ui/node_modules/@adobe/css-tools/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..ca821e3ffc1b810e1dd3134acb71f9192bf250fe --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/index.ts @@ -0,0 +1,8 @@ +import { default as parseFn } from './parse'; +import { default as stringifyFn } from './stringify'; +export const parse = parseFn; +export const stringify = stringifyFn; +export * from './CssParseError'; +export * from './CssPosition'; +export * from './type'; +export default { parse, stringify }; diff --git a/tools/ui/node_modules/@adobe/css-tools/src/parse/index.ts b/tools/ui/node_modules/@adobe/css-tools/src/parse/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..32a3a1ad3e702e60ec65aeee6b41db4e136b1745 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/parse/index.ts @@ -0,0 +1,1317 @@ +import CssParseError from '../CssParseError'; +import Position from '../CssPosition'; +import { + type CssAtRuleAST, + type CssCharsetAST, + type CssCommentAST, + type CssCommonPositionAST, + type CssContainerAST, + type CssCounterStyleAST, + type CssCustomMediaAST, + type CssDeclarationAST, + type CssDocumentAST, + type CssFontFaceAST, + type CssFontFeatureValuesAST, + type CssGenericAtRuleAST, + type CssHostAST, + type CssImportAST, + type CssKeyframeAST, + type CssKeyframesAST, + type CssLayerAST, + type CssMediaAST, + type CssNamespaceAST, + type CssPageAST, + type CssPageMarginBoxAST, + type CssPositionTryAST, + type CssPropertyAST, + type CssRuleAST, + type CssScopeAST, + type CssStartingStyleAST, + type CssStylesheetAST, + type CssSupportsAST, + CssTypes, + type CssViewTransitionAST, +} from '../type'; +import { + indexOfArrayWithBracketAndQuoteSupport, + splitWithBracketAndQuoteSupport, +} from '../utils/stringSearch'; + +// http://www.w3.org/TR/CSS21/grammar.html +// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027 +// New rule => https://www.w3.org/TR/CSS22/syndata.html#comments +// [^] is equivalent to [.\n\r] +const commentRegex = /\/\*[^]*?(?:\*\/|$)/g; + +export const parse = ( + css: string, + options?: { source?: string; silent?: boolean }, +): CssStylesheetAST => { + options = options || {}; + + /** + * Positional. + */ + let lineno = 1; + let column = 1; + + /** + * Update lineno and column based on `str`. + */ + function updatePosition(str: string) { + const lines = str.match(/\n/g); + if (lines) { + lineno += lines.length; + } + const i = str.lastIndexOf('\n'); + column = ~i ? str.length - i : column + str.length; + } + + /** + * Mark position and patch `node.position`. + */ + function position() { + const start = { line: lineno, column: column }; + return ( + node: Omit, + ): T1 => { + (node as T1).position = new Position( + start, + { line: lineno, column: column }, + options?.source || '', + ); + whitespace(); + return node as T1; + }; + } + + /** + * Error `msg`. + */ + const errorsList: Array = []; + + function error(msg: string): undefined { + const err = new CssParseError( + options?.source || '', + msg, + lineno, + column, + css, + ); + + if (options?.silent) { + errorsList.push(err); + } else { + throw err; + } + } + + /** + * Parse stylesheet. + */ + function stylesheet(): CssStylesheetAST { + const rulesList = rules(); + + const result: CssStylesheetAST = { + type: CssTypes.stylesheet, + stylesheet: { + source: options?.source, + rules: rulesList, + parsingErrors: errorsList, + }, + }; + + return result; + } + + /** + * Opening brace. + */ + function open(): boolean { + const openMatch = /^{\s*/.exec(css); + if (openMatch) { + processMatch(openMatch); + return true; + } + return false; + } + + /** + * Closing brace. + */ + function close() { + const closeMatch = /^}/.exec(css); + if (closeMatch) { + processMatch(closeMatch); + return true; + } + return false; + } + + /** + * Parse ruleset. + */ + function rules() { + let node: CssRuleAST | CssAtRuleAST | undefined; + const rules: Array = []; + whitespace(); + comments(rules); + while (css.length) { + if (css.charAt(0) === '}') { + if (options?.silent) { + // Skip stray closing braces at top level + error("extra '}'"); + const fakeMatch = ['}'] as unknown as RegExpExecArray; + processMatch(fakeMatch); + whitespace(); + comments(rules); + continue; + } + break; + } + node = atRule() || rule(); + if (node) { + rules.push(node); + comments(rules); + } else { + if (options?.silent) { + // Skip unrecognized character to recover + const fakeMatch = [css.charAt(0)] as unknown as RegExpExecArray; + processMatch(fakeMatch); + whitespace(); + comments(rules); + continue; + } + break; + } + } + return rules; + } + + /** + * Update position and css string. Return the matches + */ + function processMatch(m: RegExpExecArray) { + const str = m[0]; + updatePosition(str); + css = css.slice(str.length); + return m; + } + + /** + * Parse whitespace. + */ + function whitespace() { + const m = /^\s*/.exec(css); + if (m) { + processMatch(m); + } + } + + /** + * Parse comments; + */ + function comments( + rules?: Array, + ) { + rules = rules || []; + let c: CssCommentAST | undefined = comment(); + while (c) { + rules.push(c); + c = comment(); + } + return rules; + } + + /** + * Parse comment. + */ + function comment(): CssCommentAST | undefined { + const pos = position(); + if ('/' !== css.charAt(0) || '*' !== css.charAt(1)) { + return; + } + + const m = /^\/\*[^]*?\*\//.exec(css); + if (!m) { + return error('End of comment missing'); + } + processMatch(m); + + return pos({ + type: CssTypes.comment, + comment: m[0].slice(2, -2), + }); + } + + /** + * Parse selector. + */ + function selector() { + const bracePos = indexOfArrayWithBracketAndQuoteSupport(css, ['{']); + if (bracePos === -1 || bracePos === 0) { + return; + } + const selectorStr = css.substring(0, bracePos); + const fakeMatch = [selectorStr] as unknown as RegExpExecArray; + processMatch(fakeMatch); + + // remove comment in selector; + const res = trim(selectorStr).replace(commentRegex, ''); + + return splitWithBracketAndQuoteSupport(res, [',']).map((v) => trim(v)); + } + + /** + * Parse declaration. + */ + function declaration(): CssDeclarationAST | undefined { + const pos = position(); + + // prop + const propMatch = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/.exec(css); + if (!propMatch) { + return; + } + processMatch(propMatch); + const propValue = trim(propMatch[0]); + + // : + const separatorMatch = /^:\s*/.exec(css); + if (!separatorMatch) { + return error("property missing ':'"); + } + processMatch(separatorMatch); + + // val + let value = ''; + const endValuePosition = indexOfArrayWithBracketAndQuoteSupport(css, [ + ';', + '}', + ]); + if (endValuePosition !== -1) { + value = css.substring(0, endValuePosition); + const fakeMatch = [value] as unknown as RegExpExecArray; + processMatch(fakeMatch); + + value = trim(value).replace(commentRegex, ''); + } + + const ret = pos({ + type: CssTypes.declaration, + property: propValue.replace(commentRegex, ''), + value: value, + }); + + // ; + const endMatch = /^[;\s]*/.exec(css); + if (endMatch) { + processMatch(endMatch); + } + + return ret; + } + + /** + * Parse declarations (without nesting support). + * Used by @font-face, @page, keyframes. + */ + function declarations() { + const decls: Array = []; + + if (!open()) { + return error("missing '{'"); + } + comments(decls); + + // declarations + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + comments(decls); + decl = declaration(); + } + // In silent mode, try to recover from errors by skipping to next semicolon + while (options?.silent && css.length && css.charAt(0) !== '}') { + const semiPos = css.indexOf(';'); + const bracePos = css.indexOf('}'); + if (semiPos !== -1 && (bracePos === -1 || semiPos < bracePos)) { + const fakeMatch = [ + css.substring(0, semiPos + 1), + ] as unknown as RegExpExecArray; + processMatch(fakeMatch); + whitespace(); + comments(decls); + decl = declaration(); + while (decl) { + decls.push(decl); + comments(decls); + decl = declaration(); + } + } else { + break; + } + } + + if (!close()) { + return error("missing '}'"); + } + return decls; + } + + /** + * Check if the current position looks like a nested rule + * ('{' appears before ';' and '}' at the top level). + */ + function looksLikeNestedRule(): boolean { + const bracePos = indexOfArrayWithBracketAndQuoteSupport(css, ['{']); + if (bracePos === -1) { + return false; + } + const semiPos = indexOfArrayWithBracketAndQuoteSupport(css, [';']); + const closePos = indexOfArrayWithBracketAndQuoteSupport(css, ['}']); + + if (semiPos !== -1 && semiPos < bracePos) { + return false; + } + if (closePos !== -1 && closePos < bracePos) { + return false; + } + return true; + } + + /** + * Parse rule body with CSS nesting support. + * Handles declarations, comments, nested rules, and nested at-rules. + */ + function ruleBody(): + | Array + | undefined { + const items: Array = []; + + if (!open()) { + return error("missing '{'"); + } + comments(items); + + while (css.length && css.charAt(0) !== '}') { + // nested at-rule + if (css.charAt(0) === '@') { + const ar = atRule(); + if (ar) { + items.push(ar); + comments(items); + continue; + } + } + + // nested rule ('{' comes before ';' and '}') + if (looksLikeNestedRule()) { + const nestedR = rule(); + if (nestedR) { + items.push(nestedR); + comments(items); + continue; + } + } + + // declaration + const decl = declaration(); + if (decl) { + items.push(decl); + comments(items); + continue; + } + + // nothing matched — skip to next semicolon or closing brace to recover + if (options?.silent) { + const semiPos = css.indexOf(';'); + const bracePos = css.indexOf('}'); + if (semiPos !== -1 && (bracePos === -1 || semiPos < bracePos)) { + const fakeMatch = [ + css.substring(0, semiPos + 1), + ] as unknown as RegExpExecArray; + processMatch(fakeMatch); + whitespace(); + comments(items); + continue; + } + } + break; + } + + if (!close()) { + return error("missing '}'"); + } + return items; + } + + /** + * Parse rules, declarations, and nested rules. + * Used by block at-rules (media, supports, etc.) to support + * both top-level rules and declarations when nested inside a rule. + */ + function rulesOrDeclarations() { + const items: Array = []; + whitespace(); + comments(items); + while (css.length && css.charAt(0) !== '}') { + // at-rule + if (css.charAt(0) === '@') { + const ar = atRule(); + if (ar) { + items.push(ar); + comments(items); + continue; + } + } + + // nested rule ('{' comes before ';' and '}') + if (looksLikeNestedRule()) { + const r = rule(); + if (r) { + items.push(r); + comments(items); + continue; + } + } + + // declaration + const decl = declaration(); + if (decl) { + items.push(decl); + comments(items); + continue; + } + + // nothing matched — skip to next semicolon or closing brace to recover + if (options?.silent) { + const semiPos = css.indexOf(';'); + const bracePos = css.indexOf('}'); + if (semiPos !== -1 && (bracePos === -1 || semiPos < bracePos)) { + const fakeMatch = [ + css.substring(0, semiPos + 1), + ] as unknown as RegExpExecArray; + processMatch(fakeMatch); + whitespace(); + comments(items); + continue; + } + } + break; + } + return items; + } + + /** + * Parse keyframe. + */ + function keyframe() { + const vals = []; + const pos = position(); + + let m: RegExpExecArray | null = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/.exec( + css, + ); + while (m) { + const res = processMatch(m); + vals.push(res[1]); + const spacesMatch = /^,\s*/.exec(css); + if (spacesMatch) { + processMatch(spacesMatch); + } + m = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/.exec(css); + } + + if (!vals.length) { + return; + } + + return pos({ + type: CssTypes.keyframe, + values: vals, + declarations: declarations() || [], + }); + } + + /** + * Parse keyframes. + */ + function atKeyframes(): CssKeyframesAST | undefined { + const pos = position(); + const m1 = /^@([-\w]+)?keyframes\s*/.exec(css); + + if (!m1) { + return; + } + const vendor = processMatch(m1)[1]; + + // identifier + const m2 = /^([-\w]+)\s*/.exec(css); + if (!m2) { + return error('@keyframes missing name'); + } + const name = processMatch(m2)[1]; + + if (!open()) { + return error("@keyframes missing '{'"); + } + + let frames: Array = comments(); + let frame: CssKeyframeAST | undefined = keyframe(); + while (frame) { + frames.push(frame); + frames = frames.concat(comments()); + frame = keyframe(); + } + + if (!close()) { + return error("@keyframes missing '}'"); + } + + return pos({ + type: CssTypes.keyframes, + name: name, + vendor: vendor, + keyframes: frames, + }); + } + + /** + * Parse supports. + */ + function atSupports(): CssSupportsAST | undefined { + const pos = position(); + const m = /^@supports *([^{]+)/.exec(css); + + if (!m) { + return; + } + const supports = trim(processMatch(m)[1]); + + if (!open()) { + return error("@supports missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@supports missing '}'"); + } + + return pos({ + type: CssTypes.supports, + supports: supports, + rules: style, + }); + } + + /** + * Parse host. + */ + function atHost() { + const pos = position(); + const m = /^@host\s*/.exec(css); + + if (!m) { + return; + } + processMatch(m); + + if (!open()) { + return error("@host missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@host missing '}'"); + } + + return pos({ + type: CssTypes.host, + rules: style, + }); + } + + /** + * Parse container. + */ + function atContainer(): CssContainerAST | undefined { + const pos = position(); + const m = /^@container *([^{]+)/.exec(css); + + if (!m) { + return; + } + const container = trim(processMatch(m)[1]); + + if (!open()) { + return error("@container missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@container missing '}'"); + } + + return pos({ + type: CssTypes.container, + container: container, + rules: style, + }); + } + + /** + * Parse container. + */ + function atLayer(): CssLayerAST | undefined { + const pos = position(); + const m = /^@layer *([^{;@]+)/.exec(css); + + if (!m) { + return; + } + const layer = trim(processMatch(m)[1]); + + if (!open()) { + const m2 = /^[;\s]*/.exec(css); + if (m2) { + processMatch(m2); + } + return pos({ + type: CssTypes.layer, + layer: layer, + }); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@layer missing '}'"); + } + + return pos({ + type: CssTypes.layer, + layer: layer, + rules: style, + }); + } + + /** + * Parse media. + */ + function atMedia(): CssMediaAST | undefined { + const pos = position(); + const m = /^@media *([^{]+)/.exec(css); + + if (!m) { + return; + } + const media = trim(processMatch(m)[1]); + + if (!open()) { + return error("@media missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@media missing '}'"); + } + + return pos({ + type: CssTypes.media, + media: media, + rules: style, + }); + } + + /** + * Parse custom-media. + */ + function atCustomMedia(): CssCustomMediaAST | undefined { + const pos = position(); + const m = /^@custom-media\s+(--\S+)\s+([^{;\s][^{;]*);/.exec(css); + if (!m) { + return; + } + const res = processMatch(m); + + return pos({ + type: CssTypes.customMedia, + name: trim(res[1]), + media: trim(res[2]), + }); + } + + /** + * Parse @page margin box at-rules (@top-left, @bottom-right, @left-middle, etc.). + */ + const pageMarginBoxNames = [ + 'top-left-corner', + 'top-left', + 'top-center', + 'top-right', + 'top-right-corner', + 'bottom-left-corner', + 'bottom-left', + 'bottom-center', + 'bottom-right', + 'bottom-right-corner', + 'left-top', + 'left-middle', + 'left-bottom', + 'right-top', + 'right-middle', + 'right-bottom', + ]; + const pageMarginBoxRegex = new RegExp( + `^@(${pageMarginBoxNames.join('|')})(?![\\w-])\\s*`, + ); + + function atPageMarginBox(): CssPageMarginBoxAST | undefined { + const pos = position(); + const m = pageMarginBoxRegex.exec(css); + if (!m) { + return; + } + const name = processMatch(m)[1]; + + if (!open()) { + return error(`@${name} missing '{'`); + } + let decls = comments(); + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + if (!close()) { + return error(`@${name} missing '}'`); + } + + return pos({ + type: CssTypes.pageMarginBox, + name: name, + declarations: decls, + }); + } + + /** + * Parse paged media. + */ + function atPage(): CssPageAST | undefined { + const pos = position(); + const m = /^@page */.exec(css); + if (!m) { + return; + } + processMatch(m); + + const sel = selector() || []; + + if (!open()) { + return error("@page missing '{'"); + } + const decls: Array = []; + comments(decls); + + // declarations and nested at-rules (margin boxes) + while (css.length && css.charAt(0) !== '}') { + if (css.charAt(0) === '@') { + const ar = atRule(); + if (ar) { + decls.push(ar); + comments(decls); + continue; + } + } + const decl = declaration(); + if (decl) { + decls.push(decl); + comments(decls); + continue; + } + break; + } + + if (!close()) { + return error("@page missing '}'"); + } + + return pos({ + type: CssTypes.page, + selectors: sel, + declarations: decls, + }); + } + + /** + * Parse document. + */ + function atDocument(): CssDocumentAST | undefined { + const pos = position(); + const m = /^@([-\w]+)?document *([^{]+)/.exec(css); + if (!m) { + return; + } + const res = processMatch(m); + + const vendor = trim(res[1]); + const doc = trim(res[2]); + + if (!open()) { + return error("@document missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@document missing '}'"); + } + + return pos({ + type: CssTypes.document, + document: doc, + vendor: vendor, + rules: style, + }); + } + + /** + * Parse font-face. + */ + function atFontFace(): CssFontFaceAST | undefined { + const pos = position(); + const m = /^@font-face\s*/.exec(css); + if (!m) { + return; + } + processMatch(m); + + if (!open()) { + return error("@font-face missing '{'"); + } + let decls = comments(); + + // declarations + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + + if (!close()) { + return error("@font-face missing '}'"); + } + + return pos({ + type: CssTypes.fontFace, + declarations: decls, + }); + } + + /** + * Parse @property. + */ + function atProperty(): CssPropertyAST | undefined { + const pos = position(); + const m = /^@property\s+(--[-\w]+)\s*/.exec(css); + if (!m) { + return; + } + const name = processMatch(m)[1]; + + if (!open()) { + return error("@property missing '{'"); + } + let decls = comments(); + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + if (!close()) { + return error("@property missing '}'"); + } + + return pos({ + type: CssTypes.property, + name: name, + declarations: decls, + }); + } + + /** + * Parse @counter-style. + */ + function atCounterStyle(): CssCounterStyleAST | undefined { + const pos = position(); + const m = /^@counter-style\s+([-\w]+)\s*/.exec(css); + if (!m) { + return; + } + const name = processMatch(m)[1]; + + if (!open()) { + return error("@counter-style missing '{'"); + } + let decls = comments(); + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + if (!close()) { + return error("@counter-style missing '}'"); + } + + return pos({ + type: CssTypes.counterStyle, + name: name, + declarations: decls, + }); + } + + /** + * Parse @font-feature-values. + */ + function atFontFeatureValues(): CssFontFeatureValuesAST | undefined { + const pos = position(); + const m = /^@font-feature-values\s+([^{]+)/.exec(css); + if (!m) { + return; + } + const fontFamily = trim(processMatch(m)[1]); + + if (!open()) { + return error("@font-feature-values missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@font-feature-values missing '}'"); + } + + return pos({ + type: CssTypes.fontFeatureValues, + fontFamily: fontFamily, + rules: style, + }); + } + + /** + * Parse @scope. + */ + function atScope(): CssScopeAST | undefined { + const pos = position(); + const m = /^@scope\s*([^{]*)/.exec(css); + if (!m) { + return; + } + const scope = trim(processMatch(m)[1]); + + if (!open()) { + return error("@scope missing '{'"); + } + + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@scope missing '}'"); + } + + return pos({ + type: CssTypes.scope, + scope: scope, + rules: style, + }); + } + + /** + * Parse @view-transition. + */ + function atViewTransition(): CssViewTransitionAST | undefined { + const pos = position(); + const m = /^@view-transition\s*/.exec(css); + if (!m) { + return; + } + processMatch(m); + + if (!open()) { + return error("@view-transition missing '{'"); + } + let decls = comments(); + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + if (!close()) { + return error("@view-transition missing '}'"); + } + + return pos({ + type: CssTypes.viewTransition, + declarations: decls, + }); + } + + /** + * Parse @position-try. + */ + function atPositionTry(): CssPositionTryAST | undefined { + const pos = position(); + const m = /^@position-try\s+(--[-\w]+)\s*/.exec(css); + if (!m) { + return; + } + const name = processMatch(m)[1]; + + if (!open()) { + return error("@position-try missing '{'"); + } + let decls = comments(); + let decl: CssDeclarationAST | undefined = declaration(); + while (decl) { + decls.push(decl); + decls = decls.concat(comments()); + decl = declaration(); + } + if (!close()) { + return error("@position-try missing '}'"); + } + + return pos({ + type: CssTypes.positionTry, + name: name, + declarations: decls, + }); + } + + /** + * Parse starting style. + */ + function atStartingStyle(): CssStartingStyleAST | undefined { + const pos = position(); + const m = /^@starting-style\s*/.exec(css); + if (!m) { + return; + } + processMatch(m); + + if (!open()) { + return error("@starting-style missing '{'"); + } + const style = rulesOrDeclarations(); + + if (!close()) { + return error("@starting-style missing '}'"); + } + + return pos({ + type: CssTypes.startingStyle, + rules: style, + }); + } + + /** + * Parse import + */ + const atImport = _compileAtRule('import'); + + /** + * Parse charset + */ + const atCharset = _compileAtRule('charset'); + + /** + * Parse namespace + */ + const atNamespace = _compileAtRule('namespace'); + + /** + * Parse non-block at-rules + */ + function _compileAtRule( + name: string, + ): () => T1 | undefined { + const re = new RegExp( + '^@' + + name + + '\\s*((?::?[^;\'"]|"(?:\\\\"|[^"])*?"|\'(?:\\\\\'|[^\'])*?\')+)(?:;|$)', + ); + + // ^@import\s*([^;"']|("|')(?:\\\2|.)*?\2)+(;|$) + + return (): T1 | undefined => { + const pos = position(); + const m = re.exec(css); + if (!m) { + return; + } + const res = processMatch(m); + const ret: Record = { type: name }; + ret[name] = res[1].trim(); + return pos(ret as unknown as T1) as T1; + }; + } + + /** + * Parse generic/unknown at-rule (fallback for any unrecognized at-rule). + * Handles both block at-rules (@scope { ... }) and statement at-rules (@foo ...;). + */ + function atGeneric(): CssGenericAtRuleAST | undefined { + const pos = position(); + const m = /^@([-\w]+)\s*/.exec(css); + if (!m) { + return; + } + const name = processMatch(m)[1]; + + // Capture prelude (everything between the name and '{' or ';') + let prelude = ''; + const preludeEnd = indexOfArrayWithBracketAndQuoteSupport(css, ['{', ';']); + if (preludeEnd !== -1 && preludeEnd > 0) { + prelude = trim(css.substring(0, preludeEnd)); + const fakeMatch = [ + css.substring(0, preludeEnd), + ] as unknown as RegExpExecArray; + processMatch(fakeMatch); + } + + // Block at-rule + if (open()) { + const style = rulesOrDeclarations(); + + if (!close()) { + return error(`@${name} missing '}'`); + } + + return pos({ + type: CssTypes.atRule, + name: name, + prelude: prelude, + rules: style, + }); + } + + // Statement at-rule (ends with ';') + const endMatch = /^[;\s]*/.exec(css); + if (endMatch) { + processMatch(endMatch); + } + + return pos({ + type: CssTypes.atRule, + name: name, + prelude: prelude, + }); + } + + /** + * Parse at rule. + */ + function atRule(): CssAtRuleAST | undefined { + if (css[0] !== '@') { + return; + } + + return ( + atKeyframes() || + atMedia() || + atCustomMedia() || + atSupports() || + atImport() || + atCharset() || + atNamespace() || + atDocument() || + atPage() || + atHost() || + atFontFace() || + atFontFeatureValues() || + atContainer() || + atStartingStyle() || + atLayer() || + atProperty() || + atCounterStyle() || + atScope() || + atViewTransition() || + atPositionTry() || + atPageMarginBox() || + atGeneric() + ); + } + + /** + * Parse rule. + */ + function rule() { + const pos = position(); + const sel = selector(); + + if (!sel) { + return error('selector missing'); + } + comments(); + + return pos({ + type: CssTypes.rule, + selectors: sel, + declarations: ruleBody() || [], + }); + } + + return addParent(stylesheet()); +}; + +/** + * Trim `str`. + */ +function trim(str: string) { + return str ? str.trim() : ''; +} + +/** + * Adds non-enumerable parent node reference to each node. + */ +function addParent( + obj: T1, + parent?: unknown, +): T1 { + const isNode = obj && typeof obj.type === 'string'; + const childParent = isNode ? obj : parent; + + for (const k in obj) { + const value = obj[k]; + if (Array.isArray(value)) { + value.forEach((v) => { + addParent(v, childParent); + }); + } else if (value && typeof value === 'object') { + addParent(value, childParent); + } + } + + if (isNode) { + Object.defineProperty(obj, 'parent', { + configurable: true, + writable: true, + enumerable: false, + value: parent || null, + }); + } + + return obj; +} + +export default parse; diff --git a/tools/ui/node_modules/@adobe/css-tools/src/stringify/compiler.ts b/tools/ui/node_modules/@adobe/css-tools/src/stringify/compiler.ts new file mode 100644 index 0000000000000000000000000000000000000000..960788ea5f361dfd8d36c1bd05845b1942f7afdc --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/stringify/compiler.ts @@ -0,0 +1,698 @@ +import { + type CssAllNodesAST, + type CssCharsetAST, + type CssCommentAST, + type CssCommonPositionAST, + type CssContainerAST, + type CssCounterStyleAST, + type CssCustomMediaAST, + type CssDeclarationAST, + type CssDocumentAST, + type CssFontFaceAST, + type CssFontFeatureValuesAST, + type CssGenericAtRuleAST, + type CssHostAST, + type CssImportAST, + type CssKeyframeAST, + type CssKeyframesAST, + type CssLayerAST, + type CssMediaAST, + type CssNamespaceAST, + type CssPageAST, + type CssPageMarginBoxAST, + type CssPositionTryAST, + type CssPropertyAST, + type CssRuleAST, + type CssScopeAST, + type CssStartingStyleAST, + type CssStylesheetAST, + type CssSupportsAST, + CssTypes, + type CssViewTransitionAST, +} from '../type'; + +export type CompilerOptions = { + indent?: string; + compress?: boolean; +}; + +class Compiler { + level = 0; + indentation = ' '; + compress = false; + + constructor(options?: CompilerOptions) { + if (typeof options?.indent === 'string') { + this.indentation = options?.indent; + } + if (options?.compress) { + this.compress = true; + } + } + + // We disable no-unused-vars for _position. We keep position for potential reintroduction of source-map + // eslint-disable-next-line @typescript-eslint/no-unused-vars + emit(str: string, _position?: CssCommonPositionAST['position']) { + return str; + } + + /** + * Increase, decrease or return current indentation. + */ + indent(level?: number) { + this.level = this.level || 1; + + if (level) { + this.level += level; + return ''; + } + + return Array(this.level).join(this.indentation); + } + + visit(node: CssAllNodesAST): string { + switch (node.type) { + case CssTypes.stylesheet: + return this.stylesheet(node); + case CssTypes.rule: + return this.rule(node); + case CssTypes.declaration: + return this.declaration(node); + case CssTypes.comment: + return this.comment(node); + case CssTypes.container: + return this.container(node); + case CssTypes.charset: + return this.charset(node); + case CssTypes.counterStyle: + return this.counterStyle(node); + case CssTypes.document: + return this.document(node); + case CssTypes.customMedia: + return this.customMedia(node); + case CssTypes.fontFace: + return this.fontFace(node); + case CssTypes.fontFeatureValues: + return this.fontFeatureValues(node); + case CssTypes.host: + return this.host(node); + case CssTypes.import: + return this.import(node); + case CssTypes.keyframes: + return this.keyframes(node); + case CssTypes.keyframe: + return this.keyframe(node); + case CssTypes.layer: + return this.layer(node); + case CssTypes.media: + return this.media(node); + case CssTypes.namespace: + return this.namespace(node); + case CssTypes.page: + return this.page(node); + case CssTypes.pageMarginBox: + return this.pageMarginBox(node); + case CssTypes.positionTry: + return this.positionTry(node); + case CssTypes.property: + return this.property(node); + case CssTypes.scope: + return this.scope(node); + case CssTypes.startingStyle: + return this.startingStyle(node); + case CssTypes.supports: + return this.supports(node); + case CssTypes.viewTransition: + return this.viewTransition(node); + case CssTypes.atRule: + return this.genericAtRule(node); + } + } + + mapVisit(nodes: Array, delim?: string) { + let buf = ''; + delim = delim || ''; + + for (let i = 0, length = nodes.length; i < length; i++) { + buf += this.visit(nodes[i]); + if (delim && i < length - 1) { + buf += this.emit(delim); + } + } + + return buf; + } + + compile(node: CssStylesheetAST) { + if (this.compress) { + return node.stylesheet.rules.map(this.visit, this).join(''); + } + + return this.stylesheet(node); + } + + /** + * Visit stylesheet node. + */ + stylesheet(node: CssStylesheetAST) { + return this.mapVisit(node.stylesheet.rules, '\n\n'); + } + + /** + * Visit comment node. + */ + comment(node: CssCommentAST) { + if (this.compress) { + return this.emit('', node.position); + } + return this.emit(`${this.indent()}/*${node.comment}*/`, node.position); + } + + /** + * Visit container node. + */ + container(node: CssContainerAST) { + if (this.compress) { + return ( + this.emit(`@container ${node.container}`, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@container ${node.container}`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit container node. + */ + layer(node: CssLayerAST) { + if (this.compress) { + return ( + this.emit(`@layer ${node.layer}`, node.position) + + (node.rules + ? this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + : ';') + ); + } + return ( + this.emit(`${this.indent()}@layer ${node.layer}`, node.position) + + (node.rules + ? this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + : ';') + ); + } + + /** + * Visit import node. + */ + import(node: CssImportAST) { + return this.emit(`@import ${node.import};`, node.position); + } + + /** + * Visit media node. + */ + media(node: CssMediaAST) { + if (this.compress) { + return ( + this.emit(`@media ${node.media}`, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@media ${node.media}`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit document node. + */ + document(node: CssDocumentAST) { + const doc = `@${node.vendor || ''}document ${node.document}`; + if (this.compress) { + return ( + this.emit(doc, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(doc, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`${this.indent(-1)}\n}`) + ); + } + + /** + * Visit charset node. + */ + charset(node: CssCharsetAST) { + return this.emit(`@charset ${node.charset};`, node.position); + } + + /** + * Visit namespace node. + */ + namespace(node: CssNamespaceAST) { + return this.emit(`@namespace ${node.namespace};`, node.position); + } + + /** + * Visit container node. + */ + startingStyle(node: CssStartingStyleAST) { + if (this.compress) { + return ( + this.emit('@starting-style', node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@starting-style`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit supports node. + */ + supports(node: CssSupportsAST) { + if (this.compress) { + return ( + this.emit(`@supports ${node.supports}`, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@supports ${node.supports}`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit keyframes node. + */ + keyframes(node: CssKeyframesAST) { + if (this.compress) { + return ( + this.emit( + `@${node.vendor || ''}keyframes ${node.name}`, + node.position, + ) + + this.emit('{') + + this.mapVisit(node.keyframes) + + this.emit('}') + ); + } + return ( + this.emit(`@${node.vendor || ''}keyframes ${node.name}`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.keyframes, '\n') + + this.emit(`${this.indent(-1)}}`) + ); + } + + /** + * Visit keyframe node. + */ + keyframe(node: CssKeyframeAST) { + const decls = node.declarations; + if (this.compress) { + return ( + this.emit(node.values.join(','), node.position) + + this.emit('{') + + this.mapVisit(decls) + + this.emit('}') + ); + } + + return ( + this.emit(this.indent()) + + this.emit(node.values.join(', '), node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(decls, '\n') + + this.emit(`${this.indent(-1)}\n${this.indent()}}\n`) + ); + } + + /** + * Visit page node. + */ + page(node: CssPageAST) { + if (this.compress) { + const sel = node.selectors.length ? node.selectors.join(', ') : ''; + + return ( + this.emit(`@page ${sel}`, node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + const sel = node.selectors.length ? `${node.selectors.join(', ')} ` : ''; + + return ( + this.emit(`@page ${sel}`, node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit @page margin box node (@top-left, @bottom-right, etc.). + */ + pageMarginBox(node: CssPageMarginBoxAST) { + if (this.compress) { + return ( + this.emit(`@${node.name}`, node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@${node.name} `, node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit(`\n${this.indent()}}`) + ); + } + + /** + * Visit font-face node. + */ + fontFace(node: CssFontFaceAST) { + if (this.compress) { + return ( + this.emit('@font-face', node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit('@font-face ', node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit host node. + */ + host(node: CssHostAST) { + if (this.compress) { + return ( + this.emit('@host', node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit('@host', node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`${this.indent(-1)}\n}`) + ); + } + + /** + * Visit custom-media node. + */ + customMedia(node: CssCustomMediaAST) { + return this.emit( + `@custom-media ${node.name} ${node.media};`, + node.position, + ); + } + + /** + * Visit @property node. + */ + property(node: CssPropertyAST) { + if (this.compress) { + return ( + this.emit(`@property ${node.name}`, node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit(`@property ${node.name} `, node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit @counter-style node. + */ + counterStyle(node: CssCounterStyleAST) { + if (this.compress) { + return ( + this.emit(`@counter-style ${node.name}`, node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit(`@counter-style ${node.name} `, node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit @font-feature-values node. + */ + fontFeatureValues(node: CssFontFeatureValuesAST) { + if (this.compress) { + return ( + this.emit(`@font-feature-values ${node.fontFamily}`, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit( + `${this.indent()}@font-feature-values ${node.fontFamily}`, + node.position, + ) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit @scope node. + */ + scope(node: CssScopeAST) { + const prelude = node.scope ? ` ${node.scope}` : ''; + if (this.compress) { + return ( + this.emit(`@scope${prelude}`, node.position) + + this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + ); + } + return ( + this.emit(`${this.indent()}@scope${prelude}`, node.position) + + this.emit(` {\n${this.indent(1)}`) + + this.mapVisit(node.rules, '\n\n') + + this.emit(`\n${this.indent(-1)}${this.indent()}}`) + ); + } + + /** + * Visit @view-transition node. + */ + viewTransition(node: CssViewTransitionAST) { + if (this.compress) { + return ( + this.emit('@view-transition', node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit('@view-transition ', node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit @position-try node. + */ + positionTry(node: CssPositionTryAST) { + if (this.compress) { + return ( + this.emit(`@position-try ${node.name}`, node.position) + + this.emit('{') + + this.mapVisit(node.declarations) + + this.emit('}') + ); + } + return ( + this.emit(`@position-try ${node.name} `, node.position) + + this.emit('{\n') + + this.emit(this.indent(1)) + + this.mapVisit(node.declarations, '\n') + + this.emit(this.indent(-1)) + + this.emit('\n}') + ); + } + + /** + * Visit generic at-rule node (fallback for any unrecognized at-rule). + */ + genericAtRule(node: CssGenericAtRuleAST) { + const prelude = node.prelude ? ` ${node.prelude}` : ''; + if (this.compress) { + return ( + this.emit(`@${node.name}${prelude}`, node.position) + + (node.rules + ? this.emit('{') + + this.mapVisit(node.rules) + + this.emit('}') + : ';') + ); + } + if (!node.rules) { + return this.emit( + `${this.indent()}@${node.name}${prelude};`, + node.position, + ); + } + const hasNestedRules = node.rules.some( + (r) => r.type !== CssTypes.declaration && r.type !== CssTypes.comment, + ); + const delim = hasNestedRules ? '\n\n' : '\n'; + return ( + this.emit(`${this.indent()}@${node.name}${prelude}`, node.position) + + this.emit(hasNestedRules ? ` {\n${this.indent(1)}` : ' {\n') + + this.emit(hasNestedRules ? '' : this.indent(1)) + + this.mapVisit(node.rules, delim) + + this.emit( + hasNestedRules + ? `\n${this.indent(-1)}${this.indent()}}` + : `${this.indent(-1)}\n${this.indent()}}`, + ) + ); + } + + /** + * Visit rule node. + */ + rule(node: CssRuleAST) { + const decls = node.declarations; + if (!decls.length) { + return ''; + } + + if (this.compress) { + return ( + this.emit(node.selectors.join(','), node.position) + + this.emit('{') + + this.mapVisit(decls) + + this.emit('}') + ); + } + const indent = this.indent(); + + return ( + this.emit( + node.selectors + .map((s) => { + return indent + s; + }) + .join(',\n'), + node.position, + ) + + this.emit(' {\n') + + this.emit(this.indent(1)) + + this.mapVisit(decls, '\n') + + this.emit(this.indent(-1)) + + this.emit(`\n${this.indent()}}`) + ); + } + + /** + * Visit declaration node. + */ + declaration(node: CssDeclarationAST) { + if (this.compress) { + return ( + this.emit(`${node.property}:${node.value}`, node.position) + + this.emit(';') + ); + } + if (node.property === 'grid-template-areas') + return ( + this.emit(this.indent()) + + this.emit( + node.property + + ': ' + + node.value.split('\n').join('\n'.padEnd(22) + this.indent()), + node.position, + ) + + this.emit(';') + ); + return ( + this.emit(this.indent()) + + this.emit(`${node.property}: ${node.value}`, node.position) + + this.emit(';') + ); + } +} + +export default Compiler; diff --git a/tools/ui/node_modules/@adobe/css-tools/src/stringify/index.ts b/tools/ui/node_modules/@adobe/css-tools/src/stringify/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..ffbd35264e4ddc553438e2f3351769dab4f371c6 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/stringify/index.ts @@ -0,0 +1,7 @@ +import type { CssStylesheetAST } from '../type'; +import Compiler, { type CompilerOptions } from './compiler'; + +export default (node: CssStylesheetAST, options?: CompilerOptions) => { + const compiler = new Compiler(options || {}); + return compiler.compile(node); +}; diff --git a/tools/ui/node_modules/@adobe/css-tools/src/type.ts b/tools/ui/node_modules/@adobe/css-tools/src/type.ts new file mode 100644 index 0000000000000000000000000000000000000000..c390046396b53ceaf3857761d3e3917e3f22c7f6 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/type.ts @@ -0,0 +1,213 @@ +import type CssParseError from './CssParseError'; +import type Position from './CssPosition'; + +export enum CssTypes { + stylesheet = 'stylesheet', + rule = 'rule', + declaration = 'declaration', + comment = 'comment', + atRule = 'at-rule', + container = 'container', + charset = 'charset', + counterStyle = 'counter-style', + document = 'document', + customMedia = 'custom-media', + fontFace = 'font-face', + fontFeatureValues = 'font-feature-values', + host = 'host', + import = 'import', + keyframes = 'keyframes', + keyframe = 'keyframe', + layer = 'layer', + media = 'media', + namespace = 'namespace', + page = 'page', + pageMarginBox = 'page-margin-box', + positionTry = 'position-try', + property = 'property', + scope = 'scope', + startingStyle = 'starting-style', + supports = 'supports', + viewTransition = 'view-transition', +} + +export type CssCommonAST = { + type: CssTypes; +}; + +export type CssCommonPositionAST = CssCommonAST & { + position?: Position; + parent?: unknown; +}; + +export type CssStylesheetAST = CssCommonAST & { + type: CssTypes.stylesheet; + stylesheet: { + source?: string; + rules: Array; + parsingErrors?: Array; + }; +}; + +export type CssRuleAST = CssCommonPositionAST & { + type: CssTypes.rule; + selectors: Array; + declarations: Array; +}; + +export type CssDeclarationAST = CssCommonPositionAST & { + type: CssTypes.declaration; + property: string; + value: string; +}; + +export type CssCommentAST = CssCommonPositionAST & { + type: CssTypes.comment; + comment: string; +}; +export type CssContainerAST = CssCommonPositionAST & { + type: CssTypes.container; + container: string; + rules: Array; +}; + +export type CssCharsetAST = CssCommonPositionAST & { + type: CssTypes.charset; + charset: string; +}; +export type CssCustomMediaAST = CssCommonPositionAST & { + type: CssTypes.customMedia; + name: string; + media: string; +}; +export type CssDocumentAST = CssCommonPositionAST & { + type: CssTypes.document; + document: string; + vendor?: string; + rules: Array; +}; +export type CssFontFaceAST = CssCommonPositionAST & { + type: CssTypes.fontFace; + declarations: Array; +}; +export type CssHostAST = CssCommonPositionAST & { + type: CssTypes.host; + rules: Array; +}; +export type CssImportAST = CssCommonPositionAST & { + type: CssTypes.import; + import: string; +}; +export type CssKeyframesAST = CssCommonPositionAST & { + type: CssTypes.keyframes; + name: string; + vendor?: string; + keyframes: Array; +}; +export type CssKeyframeAST = CssCommonPositionAST & { + type: CssTypes.keyframe; + values: Array; + declarations: Array; +}; +export type CssLayerAST = CssCommonPositionAST & { + type: CssTypes.layer; + layer: string; + rules?: Array; +}; +export type CssMediaAST = CssCommonPositionAST & { + type: CssTypes.media; + media: string; + rules: Array; +}; +export type CssNamespaceAST = CssCommonPositionAST & { + type: CssTypes.namespace; + namespace: string; +}; +export type CssPageAST = CssCommonPositionAST & { + type: CssTypes.page; + selectors: Array; + declarations: Array; +}; +export type CssSupportsAST = CssCommonPositionAST & { + type: CssTypes.supports; + supports: string; + rules: Array; +}; + +export type CssStartingStyleAST = CssCommonPositionAST & { + type: CssTypes.startingStyle; + rules: Array; +}; + +export type CssCounterStyleAST = CssCommonPositionAST & { + type: CssTypes.counterStyle; + name: string; + declarations: Array; +}; +export type CssFontFeatureValuesAST = CssCommonPositionAST & { + type: CssTypes.fontFeatureValues; + fontFamily: string; + rules: Array; +}; +export type CssPositionTryAST = CssCommonPositionAST & { + type: CssTypes.positionTry; + name: string; + declarations: Array; +}; +export type CssPropertyAST = CssCommonPositionAST & { + type: CssTypes.property; + name: string; + declarations: Array; +}; +export type CssScopeAST = CssCommonPositionAST & { + type: CssTypes.scope; + scope: string; + rules: Array; +}; +export type CssViewTransitionAST = CssCommonPositionAST & { + type: CssTypes.viewTransition; + declarations: Array; +}; +export type CssPageMarginBoxAST = CssCommonPositionAST & { + type: CssTypes.pageMarginBox; + name: string; + declarations: Array; +}; +export type CssGenericAtRuleAST = CssCommonPositionAST & { + type: CssTypes.atRule; + name: string; + prelude: string; + rules?: Array; +}; + +export type CssAtRuleAST = + | CssRuleAST + | CssCommentAST + | CssContainerAST + | CssCharsetAST + | CssCounterStyleAST + | CssCustomMediaAST + | CssDocumentAST + | CssFontFaceAST + | CssFontFeatureValuesAST + | CssHostAST + | CssImportAST + | CssKeyframesAST + | CssLayerAST + | CssMediaAST + | CssNamespaceAST + | CssPageAST + | CssPageMarginBoxAST + | CssPositionTryAST + | CssPropertyAST + | CssScopeAST + | CssSupportsAST + | CssStartingStyleAST + | CssViewTransitionAST + | CssGenericAtRuleAST; + +export type CssAllNodesAST = + | CssAtRuleAST + | CssStylesheetAST + | CssDeclarationAST + | CssKeyframeAST; diff --git a/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.test.ts b/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..70777284787d207e9a900cc0a5a7699e634c3772 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.test.ts @@ -0,0 +1,139 @@ +import { + indexOfArrayNonEscaped, + indexOfArrayWithBracketAndQuoteSupport, + MAX_LOOP, + splitWithBracketAndQuoteSupport, +} from './stringSearch'; + +describe('indexOfArrayNonEscaped', () => { + it('should find first non-escaped occurrence', () => { + expect(indexOfArrayNonEscaped('abc def', ['d'])).toBe(4); + expect(indexOfArrayNonEscaped('abc \\def ghi def', ['d'])).toBe(13); + }); + + it('should handle multiple search strings', () => { + expect(indexOfArrayNonEscaped('abc def ghi', ['d', 'g'])).toBe(4); + expect(indexOfArrayNonEscaped('abc ghi def', ['d', 'g'])).toBe(4); + }); + + it('should return -1 when not found', () => { + expect(indexOfArrayNonEscaped('abc def', ['x'])).toBe(-1); + expect(indexOfArrayNonEscaped('abc \\xyz def', ['x'])).toBe(-1); + }); + + it('should respect start position', () => { + expect(indexOfArrayNonEscaped('abc def def', ['def'], 5)).toBe(8); + }); + + it('should throw error on too many escapes', () => { + const tooManyEscapes = '\\a\\b\\c\\d'.repeat(MAX_LOOP / 2); + expect(() => indexOfArrayNonEscaped(tooManyEscapes, ['x'])).toThrow( + 'Too many escaping', + ); + }); +}); + +describe('indexOfArrayWithBracketAndQuoteSupport', () => { + it('should find first non-escaped occurrence', () => { + expect(indexOfArrayWithBracketAndQuoteSupport('abc def', ['d'])).toBe(4); + expect( + indexOfArrayWithBracketAndQuoteSupport('abc \\def ghi def', ['d']), + ).toBe(13); + }); + + it('should handle brackets correctly', () => { + expect(indexOfArrayWithBracketAndQuoteSupport('abc (def) ghi', ['g'])).toBe( + 10, + ); + expect( + indexOfArrayWithBracketAndQuoteSupport('abc (d(e)f) ghi', ['g']), + ).toBe(12); + expect(indexOfArrayWithBracketAndQuoteSupport('abc (def ghi', ['g'])).toBe( + -1, + ); + }); + + it('should handle double quotes correctly', () => { + expect(indexOfArrayWithBracketAndQuoteSupport('abc "def" ghi', ['g'])).toBe( + 10, + ); + expect( + indexOfArrayWithBracketAndQuoteSupport('abc "d\\"ef" ghi', ['g']), + ).toBe(12); + expect(indexOfArrayWithBracketAndQuoteSupport('abc "def ghi', ['g'])).toBe( + -1, + ); + }); + + it('should handle single quotes correctly', () => { + expect(indexOfArrayWithBracketAndQuoteSupport("abc 'def' ghi", ['g'])).toBe( + 10, + ); + expect( + indexOfArrayWithBracketAndQuoteSupport("abc 'd\\'ef' ghi", ['g']), + ).toBe(12); + expect(indexOfArrayWithBracketAndQuoteSupport("abc 'def ghi", ['g'])).toBe( + -1, + ); + }); + + it('should handle multiple search strings', () => { + expect( + indexOfArrayWithBracketAndQuoteSupport('abc def ghi', ['d', 'g']), + ).toBe(4); + expect( + indexOfArrayWithBracketAndQuoteSupport('abc (def) ghi', ['d', 'g']), + ).toBe(10); + }); + + it('should throw error on too many escapes or nested structures', () => { + const tooManyEscapes = '\\a\\b\\c\\d'.repeat(MAX_LOOP / 2); + expect(() => + indexOfArrayWithBracketAndQuoteSupport(tooManyEscapes, ['x']), + ).toThrow('Too many escaping'); + + const tooManyBrackets = '()'.repeat(MAX_LOOP + 1); + expect(() => + indexOfArrayWithBracketAndQuoteSupport(tooManyBrackets, [')']), + ).toThrow('Too many escaping'); + }); +}); + +describe('splitWithBracketAndQuoteSupport', () => { + test('splits string by search tokens', () => { + expect(splitWithBracketAndQuoteSupport('a,b', [','])).toEqual(['a', 'b']); + }); + + test('respects brackets', () => { + expect(splitWithBracketAndQuoteSupport('a,(b,c)', [','])).toEqual([ + 'a', + '(b,c)', + ]); + }); + + test('respects double quotes', () => { + expect(splitWithBracketAndQuoteSupport('a,"b,c"', [','])).toEqual([ + 'a', + '"b,c"', + ]); + }); + + test('respects single quotes', () => { + expect(splitWithBracketAndQuoteSupport("a,'b,c'", [','])).toEqual([ + 'a', + "'b,c'", + ]); + }); + + test('handles multiple search tokens', () => { + expect(splitWithBracketAndQuoteSupport('a;b,c', [';', ','])).toEqual([ + 'a', + 'b', + 'c', + ]); + }); + + test('handles empty strings', () => { + expect(splitWithBracketAndQuoteSupport('', [','])).toEqual([]); + }); +}); diff --git a/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.ts b/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d99c3ba4291534c4a03092a927e9587f563d519 --- /dev/null +++ b/tools/ui/node_modules/@adobe/css-tools/src/utils/stringSearch.ts @@ -0,0 +1,174 @@ +export const MAX_LOOP = 10000; + +/** + * Find the first occurrence of any search string in the input string, ignoring escaped characters + * @param string - The input string to search in + * @param search - Array of strings to search for + * @param position - Optional starting position for the search + * @returns The index of the first match, or -1 if not found + * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP) + * @example + * ```ts + * // Basic search + * indexOfArrayNonEscaped('a,b,c', [',']) // 1 + * + * // Handles escaped characters + * indexOfArrayNonEscaped('a\\,b,c', [',']) // 4, the first comma is escaped + * ``` + */ +export const indexOfArrayNonEscaped = ( + string: string, + search: Array, + position?: number, +): number => { + let currentPosition = position; + let maxLoop = MAX_LOOP; + do { + const all = search.map((v) => string.indexOf(v, currentPosition)); + all.push(string.indexOf('\\', currentPosition)); + const foundAll = all.filter((v) => v !== -1); + if (foundAll.length === 0) { + return -1; + } + + const found = Math.min(...foundAll); + if (string[found] === '\\') { + currentPosition = found + 2; + maxLoop--; + } else { + return found; + } + } while (maxLoop > 0); + + throw new Error('Too many escaping'); +}; + +/** + * Find the first occurrence of any search string in the input string, respecting brackets and quotes + * @param string - The input string to search in + * @param search - Array of strings to search for + * @param position - Optional starting position for the search + * @returns The index of the first match, or -1 if not found + * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP) + * @example + * ```ts + * // Basic search + * indexOfArrayWithBracketAndQuoteSupport('a,b,c', [',']) // 1 + * + * // Respects brackets - won't match inside () + * indexOfArrayWithBracketAndQuoteSupport('(a,b),c', [',']) // 4, ignores the comma inside () + * + * // Respects quotes - won't match inside quotes + * indexOfArrayWithBracketAndQuoteSupport('"a,b",c', [',']) // 4, ignores the comma inside quotes + * indexOfArrayWithBracketAndQuoteSupport("'a,b',c", [',']) // 4, ignores the comma inside quotes + * + * // Handles escaped characters + * indexOfArrayWithBracketAndQuoteSupport('a\\,b,c', [',']) // 4, the first comma is escaped + * ``` + */ +export const indexOfArrayWithBracketAndQuoteSupport = ( + string: string, + search: Array, + position?: number, +): number => { + let currentSearchPosition = position; + let maxLoop = MAX_LOOP; + + do { + const all = search.map((v) => string.indexOf(v, currentSearchPosition)); + + all.push(string.indexOf('(', currentSearchPosition)); + all.push(string.indexOf('"', currentSearchPosition)); + all.push(string.indexOf("'", currentSearchPosition)); + all.push(string.indexOf('\\', currentSearchPosition)); + + const foundAll = all.filter((v) => v !== -1); + if (foundAll.length === 0) { + return -1; + } + + const firstMatchPos = Math.min(...foundAll); + const char = string[firstMatchPos]; + switch (char) { + case '\\': + currentSearchPosition = firstMatchPos + 2; + break; + case '(': + { + const endPosition = indexOfArrayWithBracketAndQuoteSupport( + string, + [')'], + firstMatchPos + 1, + ); + if (endPosition === -1) { + return -1; + } + currentSearchPosition = endPosition + 1; + } + break; + case '"': + { + const endQuotePosition = indexOfArrayNonEscaped( + string, + ['"'], + firstMatchPos + 1, + ); + if (endQuotePosition === -1) { + return -1; + } + currentSearchPosition = endQuotePosition + 1; + } + break; + case "'": + { + const endQuotePosition = indexOfArrayNonEscaped( + string, + ["'"], + firstMatchPos + 1, + ); + if (endQuotePosition === -1) { + return -1; + } + currentSearchPosition = endQuotePosition + 1; + } + break; + default: + return firstMatchPos; + } + maxLoop--; + } while (maxLoop > 0); + + throw new Error('Too many escaping'); +}; + +/** + * Split a string by search tokens, respecting brackets and quotes + * @example + * ```ts + * splitWithBracketAndQuoteSupport('a,b', [',']) // ['a', 'b'] + * splitWithBracketAndQuoteSupport('a,(b,c)', [',']) // ['a', '(b,c)'] + * splitWithBracketAndQuoteSupport('a,"b,c"', [',']) // ['a', '"b,c"'] + * splitWithBracketAndQuoteSupport("a,'b,c'", [',']) // ['a', "'b,c'"] + * ``` + */ +export const splitWithBracketAndQuoteSupport = ( + string: string, + search: Array, +): Array => { + const result: Array = []; + let currentPosition = 0; + while (currentPosition < string.length) { + const index = indexOfArrayWithBracketAndQuoteSupport( + string, + search, + currentPosition, + ); + if (index === -1) { + result.push(string.substring(currentPosition)); + return result; + } + result.push(string.substring(currentPosition, index)); + currentPosition = index + 1; + } + return result; +}; diff --git a/tools/ui/node_modules/@ampproject/remapping/LICENSE b/tools/ui/node_modules/@ampproject/remapping/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tools/ui/node_modules/@ampproject/remapping/README.md b/tools/ui/node_modules/@ampproject/remapping/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1463c9f6289d6aec71987d5299b8806af4821fb4 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/README.md @@ -0,0 +1,218 @@ +# @ampproject/remapping + +> Remap sequential sourcemaps through transformations to point at the original source code + +Remapping allows you to take the sourcemaps generated through transforming your code and "remap" +them to the original source locations. Think "my minified code, transformed with babel and bundled +with webpack", all pointing to the correct location in your original source code. + +With remapping, none of your source code transformations need to be aware of the input's sourcemap, +they only need to generate an output sourcemap. This greatly simplifies building custom +transformations (think a find-and-replace). + +## Installation + +```sh +npm install @ampproject/remapping +``` + +## Usage + +```typescript +function remapping( + map: SourceMap | SourceMap[], + loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined), + options?: { excludeContent: boolean, decodedMappings: boolean } +): SourceMap; + +// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the +// "source" location (where child sources are resolved relative to, or the location of original +// source), and the ability to override the "content" of an original source for inclusion in the +// output sourcemap. +type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; +} +``` + +`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer +in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents +a transformed file (it has a sourcmap associated with it), then the `loader` should return that +sourcemap. If not, the path will be treated as an original, untransformed source code. + +```js +// Babel transformed "helloworld.js" into "transformed.js" +const transformedMap = JSON.stringify({ + file: 'transformed.js', + // 1st column of 2nd line of output file translates into the 1st source + // file, line 3, column 2 + mappings: ';CAEE', + sources: ['helloworld.js'], + version: 3, +}); + +// Uglify minified "transformed.js" into "transformed.min.js" +const minifiedTransformedMap = JSON.stringify({ + file: 'transformed.min.js', + // 0th column of 1st line of output file translates into the 1st source + // file, line 2, column 1. + mappings: 'AACC', + names: [], + sources: ['transformed.js'], + version: 3, +}); + +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + // The "transformed.js" file is an transformed file. + if (file === 'transformed.js') { + // The root importer is empty. + console.assert(ctx.importer === ''); + // The depth in the sourcemap tree we're currently loading. + // The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc. + console.assert(ctx.depth === 1); + + return transformedMap; + } + + // Loader will be called to load transformedMap's source file pointers as well. + console.assert(file === 'helloworld.js'); + // `transformed.js`'s sourcemap points into `helloworld.js`. + console.assert(ctx.importer === 'transformed.js'); + // This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`. + console.assert(ctx.depth === 2); + return null; + } +); + +console.log(remapped); +// { +// file: 'transpiled.min.js', +// mappings: 'AAEE', +// sources: ['helloworld.js'], +// version: 3, +// }; +``` + +In this example, `loader` will be called twice: + +1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the + associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can + be traced through it into the source files it represents. +2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so + we return `null`. + +The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If +you were to read the `mappings`, it says "0th column of the first line output line points to the 1st +column of the 2nd line of the file `helloworld.js`". + +### Multiple transformations of a file + +As a convenience, if you have multiple single-source transformations of a file, you may pass an +array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this +changes the `importer` and `depth` of each call to our loader. So our above example could have been +written as: + +```js +const remapped = remapping( + [minifiedTransformedMap, transformedMap], + () => null +); + +console.log(remapped); +// { +// file: 'transpiled.min.js', +// mappings: 'AAEE', +// sources: ['helloworld.js'], +// version: 3, +// }; +``` + +### Advanced control of the loading graph + +#### `source` + +The `source` property can overridden to any value to change the location of the current load. Eg, +for an original source file, it allows us to change the location to the original source regardless +of what the sourcemap source entry says. And for transformed files, it allows us to change the +relative resolving location for child sources of the loaded sourcemap. + +```js +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + if (file === 'transformed.js') { + // We pretend the transformed.js file actually exists in the 'src/' directory. When the nested + // source files are loaded, they will now be relative to `src/`. + ctx.source = 'src/transformed.js'; + return transformedMap; + } + + console.assert(file === 'src/helloworld.js'); + // We could futher change the source of this original file, eg, to be inside a nested directory + // itself. This will be reflected in the remapped sourcemap. + ctx.source = 'src/nested/transformed.js'; + return null; + } +); + +console.log(remapped); +// { +// …, +// sources: ['src/nested/helloworld.js'], +// }; +``` + + +#### `content` + +The `content` property can be overridden when we encounter an original source file. Eg, this allows +you to manually provide the source content of the original file regardless of whether the +`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove +the source content. + +```js +const remapped = remapping( + minifiedTransformedMap, + (file, ctx) => { + + if (file === 'transformed.js') { + // transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap + // would not include any `sourcesContent` values. + return transformedMap; + } + + console.assert(file === 'helloworld.js'); + // We can read the file to provide the source content. + ctx.content = fs.readFileSync(file, 'utf8'); + return null; + } +); + +console.log(remapped); +// { +// …, +// sourcesContent: [ +// 'console.log("Hello world!")', +// ], +// }; +``` + +### Options + +#### excludeContent + +By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the +`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce +the size out the sourcemap. + +#### decodedMappings + +By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the +`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of +encoding into a VLQ string. diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f3875999c027f75f69e1b22f7d8fedb1eceef63e --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs @@ -0,0 +1,197 @@ +import { decodedMappings, traceSegment, TraceMap } from '@jridgewell/trace-mapping'; +import { GenMapping, maybeAddSegment, setSourceContent, setIgnore, toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping'; + +const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false); +const EMPTY_SOURCES = []; +function SegmentObject(source, line, column, name, content, ignore) { + return { source, line, column, name, content, ignore }; +} +function Source(map, sources, source, content, ignore) { + return { + map, + sources, + source, + content, + ignore, + }; +} +/** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ +function MapSource(map, sources) { + return Source(map, sources, '', null, false); +} +/** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ +function OriginalSource(source, content, ignore) { + return Source(null, EMPTY_SOURCES, source, content, ignore); +} +/** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ +function traceMappings(tree) { + // TODO: Eventually support sourceRoot, which has to be removed because the sources are already + // fully resolved. We'll need to make sources relative to the sourceRoot before adding them. + const gen = new GenMapping({ file: tree.map.file }); + const { sources: rootSources, map } = tree; + const rootNames = map.names; + const rootMappings = decodedMappings(map); + for (let i = 0; i < rootMappings.length; i++) { + const segments = rootMappings[i]; + for (let j = 0; j < segments.length; j++) { + const segment = segments[j]; + const genCol = segment[0]; + let traced = SOURCELESS_MAPPING; + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length !== 1) { + const source = rootSources[segment[1]]; + traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : ''); + // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a + // respective segment into an original source. + if (traced == null) + continue; + } + const { column, line, name, content, source, ignore } = traced; + maybeAddSegment(gen, i, genCol, source, line, column, name); + if (source && content != null) + setSourceContent(gen, source, content); + if (ignore) + setIgnore(gen, source, true); + } + } + return gen; +} +/** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ +function originalPositionFor(source, line, column, name) { + if (!source.map) { + return SegmentObject(source.source, line, column, name, source.content, source.ignore); + } + const segment = traceSegment(source.map, line, column); + // If we couldn't find a segment, then this doesn't exist in the sourcemap. + if (segment == null) + return null; + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length === 1) + return SOURCELESS_MAPPING; + return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name); +} + +function asArray(value) { + if (Array.isArray(value)) + return value; + return [value]; +} +/** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ +function buildSourceMapTree(input, loader) { + const maps = asArray(input).map((m) => new TraceMap(m, '')); + const map = maps.pop(); + for (let i = 0; i < maps.length; i++) { + if (maps[i].sources.length > 1) { + throw new Error(`Transformation map ${i} must have exactly one source file.\n` + + 'Did you specify these with the most recent transformation maps first?'); + } + } + let tree = build(map, loader, '', 0); + for (let i = maps.length - 1; i >= 0; i--) { + tree = MapSource(maps[i], [tree]); + } + return tree; +} +function build(map, loader, importer, importerDepth) { + const { resolvedSources, sourcesContent, ignoreList } = map; + const depth = importerDepth + 1; + const children = resolvedSources.map((sourceFile, i) => { + // The loading context gives the loader more information about why this file is being loaded + // (eg, from which importer). It also allows the loader to override the location of the loaded + // sourcemap/original source, or to override the content in the sourcesContent field if it's + // an unmodified source file. + const ctx = { + importer, + depth, + source: sourceFile || '', + content: undefined, + ignore: undefined, + }; + // Use the provided loader callback to retrieve the file's sourcemap. + // TODO: We should eventually support async loading of sourcemap files. + const sourceMap = loader(ctx.source, ctx); + const { source, content, ignore } = ctx; + // If there is a sourcemap, then we need to recurse into it to load its source files. + if (sourceMap) + return build(new TraceMap(sourceMap, source), loader, source, depth); + // Else, it's an unmodified source file. + // The contents of this unmodified source file can be overridden via the loader context, + // allowing it to be explicitly null or a string. If it remains undefined, we fall back to + // the importing sourcemap's `sourcesContent` field. + const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null; + const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false; + return OriginalSource(source, sourceContent, ignored); + }); + return MapSource(map, children); +} + +/** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ +class SourceMap { + constructor(map, options) { + const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map); + this.version = out.version; // SourceMap spec says this should be first. + this.file = out.file; + this.mappings = out.mappings; + this.names = out.names; + this.ignoreList = out.ignoreList; + this.sourceRoot = out.sourceRoot; + this.sources = out.sources; + if (!options.excludeContent) { + this.sourcesContent = out.sourcesContent; + } + } + toString() { + return JSON.stringify(this); + } +} + +/** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ +function remapping(input, loader, options) { + const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false }; + const tree = buildSourceMapTree(input, loader); + return new SourceMap(traceMappings(tree), opts); +} + +export { remapping as default }; +//# sourceMappingURL=remapping.mjs.map diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..0eb007bfdf5fd31d2d2292e7e24fbd7e859a06d8 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"remapping.mjs","sources":["../src/source-map-tree.ts","../src/build-source-map-tree.ts","../src/source-map.ts","../src/remapping.ts"],"sourcesContent":["import { GenMapping, maybeAddSegment, setIgnore, setSourceContent } from '@jridgewell/gen-mapping';\nimport { traceSegment, decodedMappings } from '@jridgewell/trace-mapping';\n\nimport type { TraceMap } from '@jridgewell/trace-mapping';\n\nexport type SourceMapSegmentObject = {\n column: number;\n line: number;\n name: string;\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type OriginalSource = {\n map: null;\n sources: Sources[];\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type MapSource = {\n map: TraceMap;\n sources: Sources[];\n source: string;\n content: null;\n ignore: false;\n};\n\nexport type Sources = OriginalSource | MapSource;\n\nconst SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);\nconst EMPTY_SOURCES: Sources[] = [];\n\nfunction SegmentObject(\n source: string,\n line: number,\n column: number,\n name: string,\n content: string | null,\n ignore: boolean\n): SourceMapSegmentObject {\n return { source, line, column, name, content, ignore };\n}\n\nfunction Source(\n map: TraceMap,\n sources: Sources[],\n source: '',\n content: null,\n ignore: false\n): MapSource;\nfunction Source(\n map: null,\n sources: Sources[],\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource;\nfunction Source(\n map: TraceMap | null,\n sources: Sources[],\n source: string | '',\n content: string | null,\n ignore: boolean\n): Sources {\n return {\n map,\n sources,\n source,\n content,\n ignore,\n } as any;\n}\n\n/**\n * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes\n * (which may themselves be SourceMapTrees).\n */\nexport function MapSource(map: TraceMap, sources: Sources[]): MapSource {\n return Source(map, sources, '', null, false);\n}\n\n/**\n * A \"leaf\" node in the sourcemap tree, representing an original, unmodified source file. Recursive\n * segment tracing ends at the `OriginalSource`.\n */\nexport function OriginalSource(\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource {\n return Source(null, EMPTY_SOURCES, source, content, ignore);\n}\n\n/**\n * traceMappings is only called on the root level SourceMapTree, and begins the process of\n * resolving each mapping in terms of the original source files.\n */\nexport function traceMappings(tree: MapSource): GenMapping {\n // TODO: Eventually support sourceRoot, which has to be removed because the sources are already\n // fully resolved. We'll need to make sources relative to the sourceRoot before adding them.\n const gen = new GenMapping({ file: tree.map.file });\n const { sources: rootSources, map } = tree;\n const rootNames = map.names;\n const rootMappings = decodedMappings(map);\n\n for (let i = 0; i < rootMappings.length; i++) {\n const segments = rootMappings[i];\n\n for (let j = 0; j < segments.length; j++) {\n const segment = segments[j];\n const genCol = segment[0];\n let traced: SourceMapSegmentObject | null = SOURCELESS_MAPPING;\n\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length !== 1) {\n const source = rootSources[segment[1]];\n traced = originalPositionFor(\n source,\n segment[2],\n segment[3],\n segment.length === 5 ? rootNames[segment[4]] : ''\n );\n\n // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a\n // respective segment into an original source.\n if (traced == null) continue;\n }\n\n const { column, line, name, content, source, ignore } = traced;\n\n maybeAddSegment(gen, i, genCol, source, line, column, name);\n if (source && content != null) setSourceContent(gen, source, content);\n if (ignore) setIgnore(gen, source, true);\n }\n }\n\n return gen;\n}\n\n/**\n * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own\n * child SourceMapTrees, until we find the original source map.\n */\nexport function originalPositionFor(\n source: Sources,\n line: number,\n column: number,\n name: string\n): SourceMapSegmentObject | null {\n if (!source.map) {\n return SegmentObject(source.source, line, column, name, source.content, source.ignore);\n }\n\n const segment = traceSegment(source.map, line, column);\n\n // If we couldn't find a segment, then this doesn't exist in the sourcemap.\n if (segment == null) return null;\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length === 1) return SOURCELESS_MAPPING;\n\n return originalPositionFor(\n source.sources[segment[1]],\n segment[2],\n segment[3],\n segment.length === 5 ? source.map.names[segment[4]] : name\n );\n}\n","import { TraceMap } from '@jridgewell/trace-mapping';\n\nimport { OriginalSource, MapSource } from './source-map-tree';\n\nimport type { Sources, MapSource as MapSourceType } from './source-map-tree';\nimport type { SourceMapInput, SourceMapLoader, LoaderContext } from './types';\n\nfunction asArray(value: T | T[]): T[] {\n if (Array.isArray(value)) return value;\n return [value];\n}\n\n/**\n * Recursively builds a tree structure out of sourcemap files, with each node\n * being either an `OriginalSource` \"leaf\" or a `SourceMapTree` composed of\n * `OriginalSource`s and `SourceMapTree`s.\n *\n * Every sourcemap is composed of a collection of source files and mappings\n * into locations of those source files. When we generate a `SourceMapTree` for\n * the sourcemap, we attempt to load each source file's own sourcemap. If it\n * does not have an associated sourcemap, it is considered an original,\n * unmodified source file.\n */\nexport default function buildSourceMapTree(\n input: SourceMapInput | SourceMapInput[],\n loader: SourceMapLoader\n): MapSourceType {\n const maps = asArray(input).map((m) => new TraceMap(m, ''));\n const map = maps.pop()!;\n\n for (let i = 0; i < maps.length; i++) {\n if (maps[i].sources.length > 1) {\n throw new Error(\n `Transformation map ${i} must have exactly one source file.\\n` +\n 'Did you specify these with the most recent transformation maps first?'\n );\n }\n }\n\n let tree = build(map, loader, '', 0);\n for (let i = maps.length - 1; i >= 0; i--) {\n tree = MapSource(maps[i], [tree]);\n }\n return tree;\n}\n\nfunction build(\n map: TraceMap,\n loader: SourceMapLoader,\n importer: string,\n importerDepth: number\n): MapSourceType {\n const { resolvedSources, sourcesContent, ignoreList } = map;\n\n const depth = importerDepth + 1;\n const children = resolvedSources.map((sourceFile: string | null, i: number): Sources => {\n // The loading context gives the loader more information about why this file is being loaded\n // (eg, from which importer). It also allows the loader to override the location of the loaded\n // sourcemap/original source, or to override the content in the sourcesContent field if it's\n // an unmodified source file.\n const ctx: LoaderContext = {\n importer,\n depth,\n source: sourceFile || '',\n content: undefined,\n ignore: undefined,\n };\n\n // Use the provided loader callback to retrieve the file's sourcemap.\n // TODO: We should eventually support async loading of sourcemap files.\n const sourceMap = loader(ctx.source, ctx);\n\n const { source, content, ignore } = ctx;\n\n // If there is a sourcemap, then we need to recurse into it to load its source files.\n if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);\n\n // Else, it's an unmodified source file.\n // The contents of this unmodified source file can be overridden via the loader context,\n // allowing it to be explicitly null or a string. If it remains undefined, we fall back to\n // the importing sourcemap's `sourcesContent` field.\n const sourceContent =\n content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;\n const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;\n return OriginalSource(source, sourceContent, ignored);\n });\n\n return MapSource(map, children);\n}\n","import { toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping';\n\nimport type { GenMapping } from '@jridgewell/gen-mapping';\nimport type { DecodedSourceMap, EncodedSourceMap, Options } from './types';\n\n/**\n * A SourceMap v3 compatible sourcemap, which only includes fields that were\n * provided to it.\n */\nexport default class SourceMap {\n declare file?: string | null;\n declare mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings'];\n declare sourceRoot?: string;\n declare names: string[];\n declare sources: (string | null)[];\n declare sourcesContent?: (string | null)[];\n declare version: 3;\n declare ignoreList: number[] | undefined;\n\n constructor(map: GenMapping, options: Options) {\n const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);\n this.version = out.version; // SourceMap spec says this should be first.\n this.file = out.file;\n this.mappings = out.mappings as SourceMap['mappings'];\n this.names = out.names as SourceMap['names'];\n this.ignoreList = out.ignoreList as SourceMap['ignoreList'];\n this.sourceRoot = out.sourceRoot;\n\n this.sources = out.sources as SourceMap['sources'];\n if (!options.excludeContent) {\n this.sourcesContent = out.sourcesContent as SourceMap['sourcesContent'];\n }\n }\n\n toString(): string {\n return JSON.stringify(this);\n }\n}\n","import buildSourceMapTree from './build-source-map-tree';\nimport { traceMappings } from './source-map-tree';\nimport SourceMap from './source-map';\n\nimport type { SourceMapInput, SourceMapLoader, Options } from './types';\nexport type {\n SourceMapSegment,\n EncodedSourceMap,\n EncodedSourceMap as RawSourceMap,\n DecodedSourceMap,\n SourceMapInput,\n SourceMapLoader,\n LoaderContext,\n Options,\n} from './types';\nexport type { SourceMap };\n\n/**\n * Traces through all the mappings in the root sourcemap, through the sources\n * (and their sourcemaps), all the way back to the original source location.\n *\n * `loader` will be called every time we encounter a source file. If it returns\n * a sourcemap, we will recurse into that sourcemap to continue the trace. If\n * it returns a falsey value, that source file is treated as an original,\n * unmodified source file.\n *\n * Pass `excludeContent` to exclude any self-containing source file content\n * from the output sourcemap.\n *\n * Pass `decodedMappings` to receive a SourceMap with decoded (instead of\n * VLQ encoded) mappings.\n */\nexport default function remapping(\n input: SourceMapInput | SourceMapInput[],\n loader: SourceMapLoader,\n options?: boolean | Options\n): SourceMap {\n const opts =\n typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };\n const tree = buildSourceMapTree(input, loader);\n return new SourceMap(traceMappings(tree), opts);\n}\n"],"names":[],"mappings":";;;AAgCA,MAAM,kBAAkB,mBAAmB,aAAa,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AACtF,MAAM,aAAa,GAAc,EAAE,CAAC;AAEpC,SAAS,aAAa,CACpB,MAAc,EACd,IAAY,EACZ,MAAc,EACd,IAAY,EACZ,OAAsB,EACtB,MAAe,EAAA;AAEf,IAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACzD,CAAC;AAgBD,SAAS,MAAM,CACb,GAAoB,EACpB,OAAkB,EAClB,MAAmB,EACnB,OAAsB,EACtB,MAAe,EAAA;IAEf,OAAO;QACL,GAAG;QACH,OAAO;QACP,MAAM;QACN,OAAO;QACP,MAAM;KACA,CAAC;AACX,CAAC;AAED;;;AAGG;AACa,SAAA,SAAS,CAAC,GAAa,EAAE,OAAkB,EAAA;AACzD,IAAA,OAAO,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC;AAED;;;AAGG;SACa,cAAc,CAC5B,MAAc,EACd,OAAsB,EACtB,MAAe,EAAA;AAEf,IAAA,OAAO,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAC9D,CAAC;AAED;;;AAGG;AACG,SAAU,aAAa,CAAC,IAAe,EAAA;;;AAG3C,IAAA,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IACpD,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAC3C,IAAA,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC;AAC5B,IAAA,MAAM,YAAY,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;AAE1C,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AAC5C,QAAA,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAEjC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACxC,YAAA,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC5B,YAAA,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,IAAI,MAAM,GAAkC,kBAAkB,CAAC;;;AAI/D,YAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxB,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AACvC,gBAAA,MAAM,GAAG,mBAAmB,CAC1B,MAAM,EACN,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAClD,CAAC;;;gBAIF,IAAI,MAAM,IAAI,IAAI;oBAAE,SAAS;AAC9B,aAAA;AAED,YAAA,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;AAE/D,YAAA,eAAe,CAAC,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAC5D,YAAA,IAAI,MAAM,IAAI,OAAO,IAAI,IAAI;AAAE,gBAAA,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACtE,YAAA,IAAI,MAAM;AAAE,gBAAA,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAC1C,SAAA;AACF,KAAA;AAED,IAAA,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;AAGG;AACG,SAAU,mBAAmB,CACjC,MAAe,EACf,IAAY,EACZ,MAAc,EACd,IAAY,EAAA;AAEZ,IAAA,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;QACf,OAAO,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;AACxF,KAAA;AAED,IAAA,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;;IAGvD,IAAI,OAAO,IAAI,IAAI;AAAE,QAAA,OAAO,IAAI,CAAC;;;AAGjC,IAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;AAAE,QAAA,OAAO,kBAAkB,CAAC;IAEpD,OAAO,mBAAmB,CACxB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAC3D,CAAC;AACJ;;ACpKA,SAAS,OAAO,CAAI,KAAc,EAAA;AAChC,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,KAAK,CAAC;IACvC,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAED;;;;;;;;;;AAUG;AACW,SAAU,kBAAkB,CACxC,KAAwC,EACxC,MAAuB,EAAA;IAEvB,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAC5D,IAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAG,CAAC;AAExB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACpC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;AAC9B,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,mBAAA,EAAsB,CAAC,CAAuC,qCAAA,CAAA;AAC5D,gBAAA,uEAAuE,CAC1E,CAAC;AACH,SAAA;AACF,KAAA;AAED,IAAA,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;AACrC,IAAA,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;AACzC,QAAA,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,KAAA;AACD,IAAA,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,KAAK,CACZ,GAAa,EACb,MAAuB,EACvB,QAAgB,EAChB,aAAqB,EAAA;IAErB,MAAM,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;AAE5D,IAAA,MAAM,KAAK,GAAG,aAAa,GAAG,CAAC,CAAC;IAChC,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,UAAyB,EAAE,CAAS,KAAa;;;;;AAKrF,QAAA,MAAM,GAAG,GAAkB;YACzB,QAAQ;YACR,KAAK;YACL,MAAM,EAAE,UAAU,IAAI,EAAE;AACxB,YAAA,OAAO,EAAE,SAAS;AAClB,YAAA,MAAM,EAAE,SAAS;SAClB,CAAC;;;QAIF,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAE1C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;;AAGxC,QAAA,IAAI,SAAS;AAAE,YAAA,OAAO,KAAK,CAAC,IAAI,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;;;;;QAMpF,MAAM,aAAa,GACjB,OAAO,KAAK,SAAS,GAAG,OAAO,GAAG,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QAC9E,MAAM,OAAO,GAAG,MAAM,KAAK,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;QAC5F,OAAO,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;AACxD,KAAC,CAAC,CAAC;AAEH,IAAA,OAAO,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;AAClC;;ACnFA;;;AAGG;AACW,MAAO,SAAS,CAAA;IAU5B,WAAY,CAAA,GAAe,EAAE,OAAgB,EAAA;AAC3C,QAAA,MAAM,GAAG,GAAG,OAAO,CAAC,eAAe,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;AAC3B,QAAA,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;AACrB,QAAA,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAiC,CAAC;AACtD,QAAA,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,KAA2B,CAAC;AAC7C,QAAA,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAqC,CAAC;AAC5D,QAAA,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;AAEjC,QAAA,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAA+B,CAAC;AACnD,QAAA,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;AAC3B,YAAA,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,cAA6C,CAAC;AACzE,SAAA;KACF;IAED,QAAQ,GAAA;AACN,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;KAC7B;AACF;;ACpBD;;;;;;;;;;;;;;AAcG;AACqB,SAAA,SAAS,CAC/B,KAAwC,EACxC,MAAuB,EACvB,OAA2B,EAAA;IAE3B,MAAM,IAAI,GACR,OAAO,OAAO,KAAK,QAAQ,GAAG,OAAO,GAAG,EAAE,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;IAChG,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/C,OAAO,IAAI,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;AAClD;;;;"} \ No newline at end of file diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..6b7b3bb520a45dc796f569274695bc9690a31cd5 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js @@ -0,0 +1,202 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@jridgewell/trace-mapping'), require('@jridgewell/gen-mapping')) : + typeof define === 'function' && define.amd ? define(['@jridgewell/trace-mapping', '@jridgewell/gen-mapping'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.remapping = factory(global.traceMapping, global.genMapping)); +})(this, (function (traceMapping, genMapping) { 'use strict'; + + const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false); + const EMPTY_SOURCES = []; + function SegmentObject(source, line, column, name, content, ignore) { + return { source, line, column, name, content, ignore }; + } + function Source(map, sources, source, content, ignore) { + return { + map, + sources, + source, + content, + ignore, + }; + } + /** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ + function MapSource(map, sources) { + return Source(map, sources, '', null, false); + } + /** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ + function OriginalSource(source, content, ignore) { + return Source(null, EMPTY_SOURCES, source, content, ignore); + } + /** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ + function traceMappings(tree) { + // TODO: Eventually support sourceRoot, which has to be removed because the sources are already + // fully resolved. We'll need to make sources relative to the sourceRoot before adding them. + const gen = new genMapping.GenMapping({ file: tree.map.file }); + const { sources: rootSources, map } = tree; + const rootNames = map.names; + const rootMappings = traceMapping.decodedMappings(map); + for (let i = 0; i < rootMappings.length; i++) { + const segments = rootMappings[i]; + for (let j = 0; j < segments.length; j++) { + const segment = segments[j]; + const genCol = segment[0]; + let traced = SOURCELESS_MAPPING; + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length !== 1) { + const source = rootSources[segment[1]]; + traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : ''); + // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a + // respective segment into an original source. + if (traced == null) + continue; + } + const { column, line, name, content, source, ignore } = traced; + genMapping.maybeAddSegment(gen, i, genCol, source, line, column, name); + if (source && content != null) + genMapping.setSourceContent(gen, source, content); + if (ignore) + genMapping.setIgnore(gen, source, true); + } + } + return gen; + } + /** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ + function originalPositionFor(source, line, column, name) { + if (!source.map) { + return SegmentObject(source.source, line, column, name, source.content, source.ignore); + } + const segment = traceMapping.traceSegment(source.map, line, column); + // If we couldn't find a segment, then this doesn't exist in the sourcemap. + if (segment == null) + return null; + // 1-length segments only move the current generated column, there's no source information + // to gather from it. + if (segment.length === 1) + return SOURCELESS_MAPPING; + return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name); + } + + function asArray(value) { + if (Array.isArray(value)) + return value; + return [value]; + } + /** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ + function buildSourceMapTree(input, loader) { + const maps = asArray(input).map((m) => new traceMapping.TraceMap(m, '')); + const map = maps.pop(); + for (let i = 0; i < maps.length; i++) { + if (maps[i].sources.length > 1) { + throw new Error(`Transformation map ${i} must have exactly one source file.\n` + + 'Did you specify these with the most recent transformation maps first?'); + } + } + let tree = build(map, loader, '', 0); + for (let i = maps.length - 1; i >= 0; i--) { + tree = MapSource(maps[i], [tree]); + } + return tree; + } + function build(map, loader, importer, importerDepth) { + const { resolvedSources, sourcesContent, ignoreList } = map; + const depth = importerDepth + 1; + const children = resolvedSources.map((sourceFile, i) => { + // The loading context gives the loader more information about why this file is being loaded + // (eg, from which importer). It also allows the loader to override the location of the loaded + // sourcemap/original source, or to override the content in the sourcesContent field if it's + // an unmodified source file. + const ctx = { + importer, + depth, + source: sourceFile || '', + content: undefined, + ignore: undefined, + }; + // Use the provided loader callback to retrieve the file's sourcemap. + // TODO: We should eventually support async loading of sourcemap files. + const sourceMap = loader(ctx.source, ctx); + const { source, content, ignore } = ctx; + // If there is a sourcemap, then we need to recurse into it to load its source files. + if (sourceMap) + return build(new traceMapping.TraceMap(sourceMap, source), loader, source, depth); + // Else, it's an unmodified source file. + // The contents of this unmodified source file can be overridden via the loader context, + // allowing it to be explicitly null or a string. If it remains undefined, we fall back to + // the importing sourcemap's `sourcesContent` field. + const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null; + const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false; + return OriginalSource(source, sourceContent, ignored); + }); + return MapSource(map, children); + } + + /** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ + class SourceMap { + constructor(map, options) { + const out = options.decodedMappings ? genMapping.toDecodedMap(map) : genMapping.toEncodedMap(map); + this.version = out.version; // SourceMap spec says this should be first. + this.file = out.file; + this.mappings = out.mappings; + this.names = out.names; + this.ignoreList = out.ignoreList; + this.sourceRoot = out.sourceRoot; + this.sources = out.sources; + if (!options.excludeContent) { + this.sourcesContent = out.sourcesContent; + } + } + toString() { + return JSON.stringify(this); + } + } + + /** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ + function remapping(input, loader, options) { + const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false }; + const tree = buildSourceMapTree(input, loader); + return new SourceMap(traceMappings(tree), opts); + } + + return remapping; + +})); +//# sourceMappingURL=remapping.umd.js.map diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js.map b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d3f0f87d00345dd1e6494cbcb0179afec02f1900 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/remapping.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"remapping.umd.js","sources":["../src/source-map-tree.ts","../src/build-source-map-tree.ts","../src/source-map.ts","../src/remapping.ts"],"sourcesContent":["import { GenMapping, maybeAddSegment, setIgnore, setSourceContent } from '@jridgewell/gen-mapping';\nimport { traceSegment, decodedMappings } from '@jridgewell/trace-mapping';\n\nimport type { TraceMap } from '@jridgewell/trace-mapping';\n\nexport type SourceMapSegmentObject = {\n column: number;\n line: number;\n name: string;\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type OriginalSource = {\n map: null;\n sources: Sources[];\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type MapSource = {\n map: TraceMap;\n sources: Sources[];\n source: string;\n content: null;\n ignore: false;\n};\n\nexport type Sources = OriginalSource | MapSource;\n\nconst SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);\nconst EMPTY_SOURCES: Sources[] = [];\n\nfunction SegmentObject(\n source: string,\n line: number,\n column: number,\n name: string,\n content: string | null,\n ignore: boolean\n): SourceMapSegmentObject {\n return { source, line, column, name, content, ignore };\n}\n\nfunction Source(\n map: TraceMap,\n sources: Sources[],\n source: '',\n content: null,\n ignore: false\n): MapSource;\nfunction Source(\n map: null,\n sources: Sources[],\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource;\nfunction Source(\n map: TraceMap | null,\n sources: Sources[],\n source: string | '',\n content: string | null,\n ignore: boolean\n): Sources {\n return {\n map,\n sources,\n source,\n content,\n ignore,\n } as any;\n}\n\n/**\n * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes\n * (which may themselves be SourceMapTrees).\n */\nexport function MapSource(map: TraceMap, sources: Sources[]): MapSource {\n return Source(map, sources, '', null, false);\n}\n\n/**\n * A \"leaf\" node in the sourcemap tree, representing an original, unmodified source file. Recursive\n * segment tracing ends at the `OriginalSource`.\n */\nexport function OriginalSource(\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource {\n return Source(null, EMPTY_SOURCES, source, content, ignore);\n}\n\n/**\n * traceMappings is only called on the root level SourceMapTree, and begins the process of\n * resolving each mapping in terms of the original source files.\n */\nexport function traceMappings(tree: MapSource): GenMapping {\n // TODO: Eventually support sourceRoot, which has to be removed because the sources are already\n // fully resolved. We'll need to make sources relative to the sourceRoot before adding them.\n const gen = new GenMapping({ file: tree.map.file });\n const { sources: rootSources, map } = tree;\n const rootNames = map.names;\n const rootMappings = decodedMappings(map);\n\n for (let i = 0; i < rootMappings.length; i++) {\n const segments = rootMappings[i];\n\n for (let j = 0; j < segments.length; j++) {\n const segment = segments[j];\n const genCol = segment[0];\n let traced: SourceMapSegmentObject | null = SOURCELESS_MAPPING;\n\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length !== 1) {\n const source = rootSources[segment[1]];\n traced = originalPositionFor(\n source,\n segment[2],\n segment[3],\n segment.length === 5 ? rootNames[segment[4]] : ''\n );\n\n // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a\n // respective segment into an original source.\n if (traced == null) continue;\n }\n\n const { column, line, name, content, source, ignore } = traced;\n\n maybeAddSegment(gen, i, genCol, source, line, column, name);\n if (source && content != null) setSourceContent(gen, source, content);\n if (ignore) setIgnore(gen, source, true);\n }\n }\n\n return gen;\n}\n\n/**\n * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own\n * child SourceMapTrees, until we find the original source map.\n */\nexport function originalPositionFor(\n source: Sources,\n line: number,\n column: number,\n name: string\n): SourceMapSegmentObject | null {\n if (!source.map) {\n return SegmentObject(source.source, line, column, name, source.content, source.ignore);\n }\n\n const segment = traceSegment(source.map, line, column);\n\n // If we couldn't find a segment, then this doesn't exist in the sourcemap.\n if (segment == null) return null;\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length === 1) return SOURCELESS_MAPPING;\n\n return originalPositionFor(\n source.sources[segment[1]],\n segment[2],\n segment[3],\n segment.length === 5 ? source.map.names[segment[4]] : name\n );\n}\n","import { TraceMap } from '@jridgewell/trace-mapping';\n\nimport { OriginalSource, MapSource } from './source-map-tree';\n\nimport type { Sources, MapSource as MapSourceType } from './source-map-tree';\nimport type { SourceMapInput, SourceMapLoader, LoaderContext } from './types';\n\nfunction asArray(value: T | T[]): T[] {\n if (Array.isArray(value)) return value;\n return [value];\n}\n\n/**\n * Recursively builds a tree structure out of sourcemap files, with each node\n * being either an `OriginalSource` \"leaf\" or a `SourceMapTree` composed of\n * `OriginalSource`s and `SourceMapTree`s.\n *\n * Every sourcemap is composed of a collection of source files and mappings\n * into locations of those source files. When we generate a `SourceMapTree` for\n * the sourcemap, we attempt to load each source file's own sourcemap. If it\n * does not have an associated sourcemap, it is considered an original,\n * unmodified source file.\n */\nexport default function buildSourceMapTree(\n input: SourceMapInput | SourceMapInput[],\n loader: SourceMapLoader\n): MapSourceType {\n const maps = asArray(input).map((m) => new TraceMap(m, ''));\n const map = maps.pop()!;\n\n for (let i = 0; i < maps.length; i++) {\n if (maps[i].sources.length > 1) {\n throw new Error(\n `Transformation map ${i} must have exactly one source file.\\n` +\n 'Did you specify these with the most recent transformation maps first?'\n );\n }\n }\n\n let tree = build(map, loader, '', 0);\n for (let i = maps.length - 1; i >= 0; i--) {\n tree = MapSource(maps[i], [tree]);\n }\n return tree;\n}\n\nfunction build(\n map: TraceMap,\n loader: SourceMapLoader,\n importer: string,\n importerDepth: number\n): MapSourceType {\n const { resolvedSources, sourcesContent, ignoreList } = map;\n\n const depth = importerDepth + 1;\n const children = resolvedSources.map((sourceFile: string | null, i: number): Sources => {\n // The loading context gives the loader more information about why this file is being loaded\n // (eg, from which importer). It also allows the loader to override the location of the loaded\n // sourcemap/original source, or to override the content in the sourcesContent field if it's\n // an unmodified source file.\n const ctx: LoaderContext = {\n importer,\n depth,\n source: sourceFile || '',\n content: undefined,\n ignore: undefined,\n };\n\n // Use the provided loader callback to retrieve the file's sourcemap.\n // TODO: We should eventually support async loading of sourcemap files.\n const sourceMap = loader(ctx.source, ctx);\n\n const { source, content, ignore } = ctx;\n\n // If there is a sourcemap, then we need to recurse into it to load its source files.\n if (sourceMap) return build(new TraceMap(sourceMap, source), loader, source, depth);\n\n // Else, it's an unmodified source file.\n // The contents of this unmodified source file can be overridden via the loader context,\n // allowing it to be explicitly null or a string. If it remains undefined, we fall back to\n // the importing sourcemap's `sourcesContent` field.\n const sourceContent =\n content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;\n const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;\n return OriginalSource(source, sourceContent, ignored);\n });\n\n return MapSource(map, children);\n}\n","import { toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping';\n\nimport type { GenMapping } from '@jridgewell/gen-mapping';\nimport type { DecodedSourceMap, EncodedSourceMap, Options } from './types';\n\n/**\n * A SourceMap v3 compatible sourcemap, which only includes fields that were\n * provided to it.\n */\nexport default class SourceMap {\n declare file?: string | null;\n declare mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings'];\n declare sourceRoot?: string;\n declare names: string[];\n declare sources: (string | null)[];\n declare sourcesContent?: (string | null)[];\n declare version: 3;\n declare ignoreList: number[] | undefined;\n\n constructor(map: GenMapping, options: Options) {\n const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);\n this.version = out.version; // SourceMap spec says this should be first.\n this.file = out.file;\n this.mappings = out.mappings as SourceMap['mappings'];\n this.names = out.names as SourceMap['names'];\n this.ignoreList = out.ignoreList as SourceMap['ignoreList'];\n this.sourceRoot = out.sourceRoot;\n\n this.sources = out.sources as SourceMap['sources'];\n if (!options.excludeContent) {\n this.sourcesContent = out.sourcesContent as SourceMap['sourcesContent'];\n }\n }\n\n toString(): string {\n return JSON.stringify(this);\n }\n}\n","import buildSourceMapTree from './build-source-map-tree';\nimport { traceMappings } from './source-map-tree';\nimport SourceMap from './source-map';\n\nimport type { SourceMapInput, SourceMapLoader, Options } from './types';\nexport type {\n SourceMapSegment,\n EncodedSourceMap,\n EncodedSourceMap as RawSourceMap,\n DecodedSourceMap,\n SourceMapInput,\n SourceMapLoader,\n LoaderContext,\n Options,\n} from './types';\nexport type { SourceMap };\n\n/**\n * Traces through all the mappings in the root sourcemap, through the sources\n * (and their sourcemaps), all the way back to the original source location.\n *\n * `loader` will be called every time we encounter a source file. If it returns\n * a sourcemap, we will recurse into that sourcemap to continue the trace. If\n * it returns a falsey value, that source file is treated as an original,\n * unmodified source file.\n *\n * Pass `excludeContent` to exclude any self-containing source file content\n * from the output sourcemap.\n *\n * Pass `decodedMappings` to receive a SourceMap with decoded (instead of\n * VLQ encoded) mappings.\n */\nexport default function remapping(\n input: SourceMapInput | SourceMapInput[],\n loader: SourceMapLoader,\n options?: boolean | Options\n): SourceMap {\n const opts =\n typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };\n const tree = buildSourceMapTree(input, loader);\n return new SourceMap(traceMappings(tree), opts);\n}\n"],"names":["GenMapping","decodedMappings","maybeAddSegment","setSourceContent","setIgnore","traceSegment","TraceMap","toDecodedMap","toEncodedMap"],"mappings":";;;;;;IAgCA,MAAM,kBAAkB,mBAAmB,aAAa,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACtF,MAAM,aAAa,GAAc,EAAE,CAAC;IAEpC,SAAS,aAAa,CACpB,MAAc,EACd,IAAY,EACZ,MAAc,EACd,IAAY,EACZ,OAAsB,EACtB,MAAe,EAAA;IAEf,IAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IACzD,CAAC;IAgBD,SAAS,MAAM,CACb,GAAoB,EACpB,OAAkB,EAClB,MAAmB,EACnB,OAAsB,EACtB,MAAe,EAAA;QAEf,OAAO;YACL,GAAG;YACH,OAAO;YACP,MAAM;YACN,OAAO;YACP,MAAM;SACA,CAAC;IACX,CAAC;IAED;;;IAGG;IACa,SAAA,SAAS,CAAC,GAAa,EAAE,OAAkB,EAAA;IACzD,IAAA,OAAO,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED;;;IAGG;aACa,cAAc,CAC5B,MAAc,EACd,OAAsB,EACtB,MAAe,EAAA;IAEf,IAAA,OAAO,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC9D,CAAC;IAED;;;IAGG;IACG,SAAU,aAAa,CAAC,IAAe,EAAA;;;IAG3C,IAAA,MAAM,GAAG,GAAG,IAAIA,qBAAU,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;QACpD,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC3C,IAAA,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC;IAC5B,IAAA,MAAM,YAAY,GAAGC,4BAAe,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;IAC5C,QAAA,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAEjC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;IACxC,YAAA,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC5B,YAAA,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC1B,IAAI,MAAM,GAAkC,kBAAkB,CAAC;;;IAI/D,YAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;oBACxB,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACvC,gBAAA,MAAM,GAAG,mBAAmB,CAC1B,MAAM,EACN,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAClD,CAAC;;;oBAIF,IAAI,MAAM,IAAI,IAAI;wBAAE,SAAS;IAC9B,aAAA;IAED,YAAA,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAE/D,YAAAC,0BAAe,CAAC,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5D,YAAA,IAAI,MAAM,IAAI,OAAO,IAAI,IAAI;IAAE,gBAAAC,2BAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACtE,YAAA,IAAI,MAAM;IAAE,gBAAAC,oBAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1C,SAAA;IACF,KAAA;IAED,IAAA,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;IAGG;IACG,SAAU,mBAAmB,CACjC,MAAe,EACf,IAAY,EACZ,MAAc,EACd,IAAY,EAAA;IAEZ,IAAA,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;YACf,OAAO,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IACxF,KAAA;IAED,IAAA,MAAM,OAAO,GAAGC,yBAAY,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;;QAGvD,IAAI,OAAO,IAAI,IAAI;IAAE,QAAA,OAAO,IAAI,CAAC;;;IAGjC,IAAA,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;IAAE,QAAA,OAAO,kBAAkB,CAAC;QAEpD,OAAO,mBAAmB,CACxB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAC3D,CAAC;IACJ;;ICpKA,SAAS,OAAO,CAAI,KAAc,EAAA;IAChC,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;IAAE,QAAA,OAAO,KAAK,CAAC;QACvC,OAAO,CAAC,KAAK,CAAC,CAAC;IACjB,CAAC;IAED;;;;;;;;;;IAUG;IACW,SAAU,kBAAkB,CACxC,KAAwC,EACxC,MAAuB,EAAA;QAEvB,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAIC,qBAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC5D,IAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAG,CAAC;IAExB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACpC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;IAC9B,YAAA,MAAM,IAAI,KAAK,CACb,CAAA,mBAAA,EAAsB,CAAC,CAAuC,qCAAA,CAAA;IAC5D,gBAAA,uEAAuE,CAC1E,CAAC;IACH,SAAA;IACF,KAAA;IAED,IAAA,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACrC,IAAA,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;IACzC,QAAA,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,KAAA;IACD,IAAA,OAAO,IAAI,CAAC;IACd,CAAC;IAED,SAAS,KAAK,CACZ,GAAa,EACb,MAAuB,EACvB,QAAgB,EAChB,aAAqB,EAAA;QAErB,MAAM,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,GAAG,GAAG,CAAC;IAE5D,IAAA,MAAM,KAAK,GAAG,aAAa,GAAG,CAAC,CAAC;QAChC,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,UAAyB,EAAE,CAAS,KAAa;;;;;IAKrF,QAAA,MAAM,GAAG,GAAkB;gBACzB,QAAQ;gBACR,KAAK;gBACL,MAAM,EAAE,UAAU,IAAI,EAAE;IACxB,YAAA,OAAO,EAAE,SAAS;IAClB,YAAA,MAAM,EAAE,SAAS;aAClB,CAAC;;;YAIF,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAE1C,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;;IAGxC,QAAA,IAAI,SAAS;IAAE,YAAA,OAAO,KAAK,CAAC,IAAIA,qBAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;;;;;YAMpF,MAAM,aAAa,GACjB,OAAO,KAAK,SAAS,GAAG,OAAO,GAAG,cAAc,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YAC9E,MAAM,OAAO,GAAG,MAAM,KAAK,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;YAC5F,OAAO,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACxD,KAAC,CAAC,CAAC;IAEH,IAAA,OAAO,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAClC;;ICnFA;;;IAGG;IACW,MAAO,SAAS,CAAA;QAU5B,WAAY,CAAA,GAAe,EAAE,OAAgB,EAAA;IAC3C,QAAA,MAAM,GAAG,GAAG,OAAO,CAAC,eAAe,GAAGC,uBAAY,CAAC,GAAG,CAAC,GAAGC,uBAAY,CAAC,GAAG,CAAC,CAAC;YAC5E,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IAC3B,QAAA,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACrB,QAAA,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAiC,CAAC;IACtD,QAAA,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,KAA2B,CAAC;IAC7C,QAAA,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAqC,CAAC;IAC5D,QAAA,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;IAEjC,QAAA,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAA+B,CAAC;IACnD,QAAA,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;IAC3B,YAAA,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,cAA6C,CAAC;IACzE,SAAA;SACF;QAED,QAAQ,GAAA;IACN,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SAC7B;IACF;;ICpBD;;;;;;;;;;;;;;IAcG;IACqB,SAAA,SAAS,CAC/B,KAAwC,EACxC,MAAuB,EACvB,OAA2B,EAAA;QAE3B,MAAM,IAAI,GACR,OAAO,OAAO,KAAK,QAAQ,GAAG,OAAO,GAAG,EAAE,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;QAChG,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC/C,OAAO,IAAI,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAClD;;;;;;;;"} \ No newline at end of file diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/types/build-source-map-tree.d.ts b/tools/ui/node_modules/@ampproject/remapping/dist/types/build-source-map-tree.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f87fceab779ab635c51c3c74248e3bdfedf22e4e --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/types/build-source-map-tree.d.ts @@ -0,0 +1,14 @@ +import type { MapSource as MapSourceType } from './source-map-tree'; +import type { SourceMapInput, SourceMapLoader } from './types'; +/** + * Recursively builds a tree structure out of sourcemap files, with each node + * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of + * `OriginalSource`s and `SourceMapTree`s. + * + * Every sourcemap is composed of a collection of source files and mappings + * into locations of those source files. When we generate a `SourceMapTree` for + * the sourcemap, we attempt to load each source file's own sourcemap. If it + * does not have an associated sourcemap, it is considered an original, + * unmodified source file. + */ +export default function buildSourceMapTree(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader): MapSourceType; diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/types/remapping.d.ts b/tools/ui/node_modules/@ampproject/remapping/dist/types/remapping.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..771fe30711abc13773e931edf8339d89ad0b5c4d --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/types/remapping.d.ts @@ -0,0 +1,20 @@ +import SourceMap from './source-map'; +import type { SourceMapInput, SourceMapLoader, Options } from './types'; +export type { SourceMapSegment, EncodedSourceMap, EncodedSourceMap as RawSourceMap, DecodedSourceMap, SourceMapInput, SourceMapLoader, LoaderContext, Options, } from './types'; +export type { SourceMap }; +/** + * Traces through all the mappings in the root sourcemap, through the sources + * (and their sourcemaps), all the way back to the original source location. + * + * `loader` will be called every time we encounter a source file. If it returns + * a sourcemap, we will recurse into that sourcemap to continue the trace. If + * it returns a falsey value, that source file is treated as an original, + * unmodified source file. + * + * Pass `excludeContent` to exclude any self-containing source file content + * from the output sourcemap. + * + * Pass `decodedMappings` to receive a SourceMap with decoded (instead of + * VLQ encoded) mappings. + */ +export default function remapping(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader, options?: boolean | Options): SourceMap; diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map-tree.d.ts b/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map-tree.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..935bc698fd386327dea9e47ee862aade7e4224ca --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map-tree.d.ts @@ -0,0 +1,45 @@ +import { GenMapping } from '@jridgewell/gen-mapping'; +import type { TraceMap } from '@jridgewell/trace-mapping'; +export declare type SourceMapSegmentObject = { + column: number; + line: number; + name: string; + source: string; + content: string | null; + ignore: boolean; +}; +export declare type OriginalSource = { + map: null; + sources: Sources[]; + source: string; + content: string | null; + ignore: boolean; +}; +export declare type MapSource = { + map: TraceMap; + sources: Sources[]; + source: string; + content: null; + ignore: false; +}; +export declare type Sources = OriginalSource | MapSource; +/** + * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes + * (which may themselves be SourceMapTrees). + */ +export declare function MapSource(map: TraceMap, sources: Sources[]): MapSource; +/** + * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive + * segment tracing ends at the `OriginalSource`. + */ +export declare function OriginalSource(source: string, content: string | null, ignore: boolean): OriginalSource; +/** + * traceMappings is only called on the root level SourceMapTree, and begins the process of + * resolving each mapping in terms of the original source files. + */ +export declare function traceMappings(tree: MapSource): GenMapping; +/** + * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own + * child SourceMapTrees, until we find the original source map. + */ +export declare function originalPositionFor(source: Sources, line: number, column: number, name: string): SourceMapSegmentObject | null; diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map.d.ts b/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cbd7f0afd08703134d12ed1238f374cc4f04cfd9 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/types/source-map.d.ts @@ -0,0 +1,18 @@ +import type { GenMapping } from '@jridgewell/gen-mapping'; +import type { DecodedSourceMap, EncodedSourceMap, Options } from './types'; +/** + * A SourceMap v3 compatible sourcemap, which only includes fields that were + * provided to it. + */ +export default class SourceMap { + file?: string | null; + mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings']; + sourceRoot?: string; + names: string[]; + sources: (string | null)[]; + sourcesContent?: (string | null)[]; + version: 3; + ignoreList: number[] | undefined; + constructor(map: GenMapping, options: Options); + toString(): string; +} diff --git a/tools/ui/node_modules/@ampproject/remapping/dist/types/types.d.ts b/tools/ui/node_modules/@ampproject/remapping/dist/types/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4d78c4bc763e33881f8f070362b0c70a9a3876be --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/dist/types/types.d.ts @@ -0,0 +1,15 @@ +import type { SourceMapInput } from '@jridgewell/trace-mapping'; +export type { SourceMapSegment, DecodedSourceMap, EncodedSourceMap, } from '@jridgewell/trace-mapping'; +export type { SourceMapInput }; +export declare type LoaderContext = { + readonly importer: string; + readonly depth: number; + source: string; + content: string | null | undefined; + ignore: boolean | undefined; +}; +export declare type SourceMapLoader = (file: string, ctx: LoaderContext) => SourceMapInput | null | undefined | void; +export declare type Options = { + excludeContent?: boolean; + decodedMappings?: boolean; +}; diff --git a/tools/ui/node_modules/@ampproject/remapping/package.json b/tools/ui/node_modules/@ampproject/remapping/package.json new file mode 100644 index 0000000000000000000000000000000000000000..091224c6730b07ca7ed7a42d2804edb0e73a9219 --- /dev/null +++ b/tools/ui/node_modules/@ampproject/remapping/package.json @@ -0,0 +1,75 @@ +{ + "name": "@ampproject/remapping", + "version": "2.3.0", + "description": "Remap sequential sourcemaps through transformations to point at the original source code", + "keywords": [ + "source", + "map", + "remap" + ], + "main": "dist/remapping.umd.js", + "module": "dist/remapping.mjs", + "types": "dist/types/remapping.d.ts", + "exports": { + ".": [ + { + "types": "./dist/types/remapping.d.ts", + "browser": "./dist/remapping.umd.js", + "require": "./dist/remapping.umd.js", + "import": "./dist/remapping.mjs" + }, + "./dist/remapping.umd.js" + ], + "./package.json": "./package.json" + }, + "files": [ + "dist" + ], + "author": "Justin Ridgewell ", + "repository": { + "type": "git", + "url": "git+https://github.com/ampproject/remapping.git" + }, + "license": "Apache-2.0", + "engines": { + "node": ">=6.0.0" + }, + "scripts": { + "build": "run-s -n build:*", + "build:rollup": "rollup -c rollup.config.js", + "build:ts": "tsc --project tsconfig.build.json", + "lint": "run-s -n lint:*", + "lint:prettier": "npm run test:lint:prettier -- --write", + "lint:ts": "npm run test:lint:ts -- --fix", + "prebuild": "rm -rf dist", + "prepublishOnly": "npm run preversion", + "preversion": "run-s test build", + "test": "run-s -n test:lint test:only", + "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand", + "test:lint": "run-s -n test:lint:*", + "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'", + "test:lint:ts": "eslint '{src,test}/**/*.ts'", + "test:only": "jest --coverage", + "test:watch": "jest --coverage --watch" + }, + "devDependencies": { + "@rollup/plugin-typescript": "8.3.2", + "@types/jest": "27.4.1", + "@typescript-eslint/eslint-plugin": "5.20.0", + "@typescript-eslint/parser": "5.20.0", + "eslint": "8.14.0", + "eslint-config-prettier": "8.5.0", + "jest": "27.5.1", + "jest-config": "27.5.1", + "npm-run-all": "4.1.5", + "prettier": "2.6.2", + "rollup": "2.70.2", + "ts-jest": "27.1.4", + "tslib": "2.4.0", + "typescript": "4.6.3" + }, + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } +} diff --git a/tools/ui/node_modules/@antfu/install-pkg/LICENSE b/tools/ui/node_modules/@antfu/install-pkg/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d47cea55b87848029cce30f4ce7dfb0c7c1c5394 --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Anthony Fu + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/@antfu/install-pkg/README.md b/tools/ui/node_modules/@antfu/install-pkg/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b1d1a563c8b7e4d75c7c6e74b4ccefbaa742f738 --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/README.md @@ -0,0 +1,27 @@ +# install-pkg + +[![NPM version](https://img.shields.io/npm/v/@antfu/install-pkg?color=a1b858&label=)](https://www.npmjs.com/package/@antfu/install-pkg) + +Install package programmatically. Detect package managers automatically (`npm`, `yarn`, `bun` and `pnpm`). + +```bash +npm i @antfu/install-pkg +``` + +```ts +import { installPackage } from '@antfu/install-pkg' + +await installPackage('vite', { silent: true }) +``` + +## Sponsors + +

      + + + +

      + +## License + +[MIT](./LICENSE) License © 2021 [Anthony Fu](https://github.com/antfu) diff --git a/tools/ui/node_modules/@antfu/install-pkg/dist/index.cjs b/tools/ui/node_modules/@antfu/install-pkg/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..0f4e9d6c6e1075372165c0f658c311754f179d64 --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/dist/index.cjs @@ -0,0 +1,135 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// src/index.ts +var index_exports = {}; +__export(index_exports, { + detectPackageManager: () => detectPackageManager, + installPackage: () => installPackage, + uninstallPackage: () => uninstallPackage +}); +module.exports = __toCommonJS(index_exports); + +// src/detect.ts +var import_node_process = __toESM(require("process"), 1); +var import_detect = require("package-manager-detector/detect"); +async function detectPackageManager(cwd = import_node_process.default.cwd()) { + const result = await (0, import_detect.detect)({ + cwd, + onUnknown(packageManager) { + console.warn("[@antfu/install-pkg] Unknown packageManager:", packageManager); + return void 0; + } + }); + return result?.agent || null; +} + +// src/install.ts +var import_node_fs = require("fs"); +var import_node_path = require("path"); +var import_node_process2 = __toESM(require("process"), 1); +var import_tinyexec = require("tinyexec"); +async function installPackage(names, options = {}) { + const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm"; + const [agent] = detectedAgent.split("@"); + if (!Array.isArray(names)) + names = [names]; + const args = (typeof options.additionalArgs === "function" ? options.additionalArgs(agent, detectedAgent) : options.additionalArgs) || []; + if (options.preferOffline) { + if (detectedAgent === "yarn@berry") + args.unshift("--cached"); + else + args.unshift("--prefer-offline"); + } + if (agent === "pnpm") { + args.unshift( + /** + * Prevent pnpm from removing installed devDeps while `NODE_ENV` is `production` + * @see https://pnpm.io/cli/install#--prod--p + */ + "--prod=false" + ); + if ((0, import_node_fs.existsSync)((0, import_node_path.resolve)(options.cwd ?? import_node_process2.default.cwd(), "pnpm-workspace.yaml"))) { + args.unshift("-w"); + } + } + return (0, import_tinyexec.x)( + agent, + [ + agent === "yarn" ? "add" : "install", + options.dev ? "-D" : "", + ...args, + ...names + ].filter(Boolean), + { + nodeOptions: { + stdio: options.silent ? "ignore" : "inherit", + cwd: options.cwd + }, + throwOnError: true + } + ); +} + +// src/uninstall.ts +var import_node_fs2 = require("fs"); +var import_node_process3 = __toESM(require("process"), 1); +var import_node_path2 = require("path"); +var import_tinyexec2 = require("tinyexec"); +async function uninstallPackage(names, options = {}) { + const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm"; + const [agent] = detectedAgent.split("@"); + if (!Array.isArray(names)) + names = [names]; + const args = options.additionalArgs || []; + if (agent === "pnpm" && (0, import_node_fs2.existsSync)((0, import_node_path2.resolve)(options.cwd ?? import_node_process3.default.cwd(), "pnpm-workspace.yaml"))) + args.unshift("-w"); + return (0, import_tinyexec2.x)( + agent, + [ + agent === "yarn" ? "remove" : "uninstall", + options.dev ? "-D" : "", + ...args, + ...names + ].filter(Boolean), + { + nodeOptions: { + stdio: options.silent ? "ignore" : "inherit", + cwd: options.cwd + }, + throwOnError: true + } + ); +} +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + detectPackageManager, + installPackage, + uninstallPackage +}); diff --git a/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.cts b/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..f6be2088e882fc4d7001dfc0f7a12d2f2be2136e --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.cts @@ -0,0 +1,27 @@ +import { Agent } from 'package-manager-detector'; +export { Agent } from 'package-manager-detector'; +import * as tinyexec from 'tinyexec'; + +type PackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun'; +declare function detectPackageManager(cwd?: string): Promise; + +interface InstallPackageOptions { + cwd?: string; + dev?: boolean; + silent?: boolean; + packageManager?: string; + preferOffline?: boolean; + additionalArgs?: string[] | ((agent: string, detectedAgent: string) => string[] | undefined); +} +declare function installPackage(names: string | string[], options?: InstallPackageOptions): Promise; + +interface UninstallPackageOptions { + cwd?: string; + dev?: boolean; + silent?: boolean; + packageManager?: string; + additionalArgs?: string[]; +} +declare function uninstallPackage(names: string | string[], options?: UninstallPackageOptions): Promise; + +export { type InstallPackageOptions, type PackageManager, type UninstallPackageOptions, detectPackageManager, installPackage, uninstallPackage }; diff --git a/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.ts b/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f6be2088e882fc4d7001dfc0f7a12d2f2be2136e --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/dist/index.d.ts @@ -0,0 +1,27 @@ +import { Agent } from 'package-manager-detector'; +export { Agent } from 'package-manager-detector'; +import * as tinyexec from 'tinyexec'; + +type PackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun'; +declare function detectPackageManager(cwd?: string): Promise; + +interface InstallPackageOptions { + cwd?: string; + dev?: boolean; + silent?: boolean; + packageManager?: string; + preferOffline?: boolean; + additionalArgs?: string[] | ((agent: string, detectedAgent: string) => string[] | undefined); +} +declare function installPackage(names: string | string[], options?: InstallPackageOptions): Promise; + +interface UninstallPackageOptions { + cwd?: string; + dev?: boolean; + silent?: boolean; + packageManager?: string; + additionalArgs?: string[]; +} +declare function uninstallPackage(names: string | string[], options?: UninstallPackageOptions): Promise; + +export { type InstallPackageOptions, type PackageManager, type UninstallPackageOptions, detectPackageManager, installPackage, uninstallPackage }; diff --git a/tools/ui/node_modules/@antfu/install-pkg/dist/index.js b/tools/ui/node_modules/@antfu/install-pkg/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d116bd97a3a383f23648dea9437d3e33794ead04 --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/dist/index.js @@ -0,0 +1,96 @@ +// src/detect.ts +import process from "node:process"; +import { detect } from "package-manager-detector/detect"; +async function detectPackageManager(cwd = process.cwd()) { + const result = await detect({ + cwd, + onUnknown(packageManager) { + console.warn("[@antfu/install-pkg] Unknown packageManager:", packageManager); + return void 0; + } + }); + return result?.agent || null; +} + +// src/install.ts +import { existsSync } from "node:fs"; +import { resolve } from "node:path"; +import process2 from "node:process"; +import { x } from "tinyexec"; +async function installPackage(names, options = {}) { + const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm"; + const [agent] = detectedAgent.split("@"); + if (!Array.isArray(names)) + names = [names]; + const args = (typeof options.additionalArgs === "function" ? options.additionalArgs(agent, detectedAgent) : options.additionalArgs) || []; + if (options.preferOffline) { + if (detectedAgent === "yarn@berry") + args.unshift("--cached"); + else + args.unshift("--prefer-offline"); + } + if (agent === "pnpm") { + args.unshift( + /** + * Prevent pnpm from removing installed devDeps while `NODE_ENV` is `production` + * @see https://pnpm.io/cli/install#--prod--p + */ + "--prod=false" + ); + if (existsSync(resolve(options.cwd ?? process2.cwd(), "pnpm-workspace.yaml"))) { + args.unshift("-w"); + } + } + return x( + agent, + [ + agent === "yarn" ? "add" : "install", + options.dev ? "-D" : "", + ...args, + ...names + ].filter(Boolean), + { + nodeOptions: { + stdio: options.silent ? "ignore" : "inherit", + cwd: options.cwd + }, + throwOnError: true + } + ); +} + +// src/uninstall.ts +import { existsSync as existsSync2 } from "node:fs"; +import process3 from "node:process"; +import { resolve as resolve2 } from "node:path"; +import { x as x2 } from "tinyexec"; +async function uninstallPackage(names, options = {}) { + const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm"; + const [agent] = detectedAgent.split("@"); + if (!Array.isArray(names)) + names = [names]; + const args = options.additionalArgs || []; + if (agent === "pnpm" && existsSync2(resolve2(options.cwd ?? process3.cwd(), "pnpm-workspace.yaml"))) + args.unshift("-w"); + return x2( + agent, + [ + agent === "yarn" ? "remove" : "uninstall", + options.dev ? "-D" : "", + ...args, + ...names + ].filter(Boolean), + { + nodeOptions: { + stdio: options.silent ? "ignore" : "inherit", + cwd: options.cwd + }, + throwOnError: true + } + ); +} +export { + detectPackageManager, + installPackage, + uninstallPackage +}; diff --git a/tools/ui/node_modules/@antfu/install-pkg/package.json b/tools/ui/node_modules/@antfu/install-pkg/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2e61fe0bd271d2a44220bf32d34d1d25eae5623c --- /dev/null +++ b/tools/ui/node_modules/@antfu/install-pkg/package.json @@ -0,0 +1,58 @@ +{ + "name": "@antfu/install-pkg", + "type": "module", + "version": "1.1.0", + "description": "Install package programmatically.", + "author": "Anthony Fu ", + "license": "MIT", + "funding": "https://github.com/sponsors/antfu", + "homepage": "https://github.com/antfu/install-pkg#readme", + "repository": { + "type": "git", + "url": "git+https://github.com/antfu/install-pkg.git" + }, + "bugs": { + "url": "https://github.com/antfu/install-pkg/issues" + }, + "sideEffects": false, + "exports": { + ".": { + "import": { + "types": "./dist/index.d.ts", + "default": "./dist/index.js" + }, + "require": { + "types": "./dist/index.d.cts", + "default": "./dist/index.cjs" + } + } + }, + "main": "dist/index.cjs", + "module": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "dist" + ], + "dependencies": { + "package-manager-detector": "^1.3.0", + "tinyexec": "^1.0.1" + }, + "devDependencies": { + "@antfu/eslint-config": "^4.12.1", + "@antfu/ni": "^24.3.0", + "@types/node": "^22.15.12", + "bumpp": "^10.1.0", + "eslint": "^9.26.0", + "publint": "^0.3.12", + "tsup": "^8.4.0", + "tsx": "^4.19.4", + "typescript": "^5.8.3" + }, + "scripts": { + "dev": "nr build --watch", + "start": "tsx src/index.ts", + "build": "tsup src/index.ts --format cjs,esm --dts --no-splitting", + "release": "bumpp --commit --push --tag && pnpm publish", + "lint": "eslint ." + } +} \ No newline at end of file diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/LICENSE b/tools/ui/node_modules/@apideck/better-ajv-errors/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..8cfa032ca87af5b2e9bc8f240d9a9305d17ccffa --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Apideck + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/README.md b/tools/ui/node_modules/@apideck/better-ajv-errors/README.md new file mode 100644 index 0000000000000000000000000000000000000000..45b91b2e3001fcc8c56ef1c22fa2b8c3cfe36862 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/README.md @@ -0,0 +1,71 @@ +[![npm (scoped)](https://img.shields.io/npm/v/@apideck/better-ajv-errors?color=brightgreen)](https://npmjs.com/@apideck/better-ajv-errors) [![npm](https://img.shields.io/npm/dm/@apideck/better-ajv-errors)](https://npmjs.com/@apideck/better-ajv-errors) [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/apideck-libraries/better-ajv-errors/CI)](https://github.com/apideck-libraries/better-ajv-errors/actions/workflows/main.yml?query=branch%3Amain++) + +# @apideck/better-ajv-errors 👮‍♀️ + +> Human-friendly JSON Schema validation for APIs + + +- Readable and helpful [ajv](https://github.com/ajv-validator/ajv) errors +- API-friendly format +- Suggestions for spelling mistakes +- Minimal footprint: 1.56 kB (gzip + minified) + +![better-ajv-errors output Example](https://user-images.githubusercontent.com/8850410/118274790-e0529e80-b4c5-11eb-8188-9097c8064c61.png) + +## Install + +```bash +$ yarn add @apideck/better-ajv-errors +``` + +or + +```bash +$ npm i @apideck/better-ajv-errors +``` + +Also make sure that you've installed [ajv](https://www.npmjs.com/package/ajv) at version 8 or higher. + +## Usage + +After validating some data with ajv, pass the errors to `betterAjvErrors` + +```ts +import Ajv from 'ajv'; +import { betterAjvErrors } from '@apideck/better-ajv-errors'; + +// Without allErrors: true, ajv will only return the first error +const ajv = new Ajv({ allErrors: true }); + +const valid = ajv.validate(schema, data); + +if (!valid) { + const betterErrors = betterAjvErrors({ schema, data, errors: ajv.errors }); +} +``` + +## API + +### betterAjvErrors + +Function that formats ajv validation errors in a human-friendly format. + +#### Parameters + +- `options: BetterAjvErrorsOptions` + - `errors: ErrorObject[] | null | undefined` Your ajv errors, you will find these in the `errors` property of your ajv instance (`ErrorObject` is a type from the ajv package). + - `data: Object` The data you passed to ajv to be validated. + - `schema: JSONSchema` The schema you passed to ajv to validate against. + - `basePath?: string` An optional base path to prefix paths returned by `betterAjvErrors`. For example, in APIs, it could be useful to use `'{requestBody}'` or `'{queryParemeters}'` as a basePath. This will make it clear to users where exactly the error occurred. + +#### Return Value + +- `ValidationError[]` Array of formatted errors (properties of `ValidationError` below) + - `message: string` Formatted error message + - `suggestion?: string` Optional suggestion based on provided data and schema + - `path: string` Object path where the error occurred (example: `.foo.bar.0.quz`) + - `context: { errorType: DefinedError['keyword']; [additionalContext: string]: unknown }` `errorType` is `error.keyword` proxied from `ajv`. `errorType` can be used as a key for i18n if needed. There might be additional properties on context, based on the type of error. + +## Related + +- [atlassian/better-ajv-errors](https://github.com/atlassian/better-ajv-errors) was the inspiration for this library. Atlassian's library is more focused on CLI errors, this library is focused on developer-friendly API error messages. diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js new file mode 100644 index 0000000000000000000000000000000000000000..bc958ae9e729398540fd95e2d73894aa6fa42c43 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js @@ -0,0 +1,246 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var leven = _interopDefault(require('leven')); +var pointer = _interopDefault(require('jsonpointer')); + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +var AJV_ERROR_KEYWORD_WEIGHT_MAP = { + "enum": 1, + type: 0 +}; +var QUOTES_REGEX = /"/g; +var NOT_REGEX = /NOT/g; +var SLASH_REGEX = /\//g; + +var filterSingleErrorPerProperty = function filterSingleErrorPerProperty(errors) { + var errorsPerProperty = errors.reduce(function (acc, error) { + var _ref, _error$params$additio, _error$params, _error$params2, _AJV_ERROR_KEYWORD_WE, _AJV_ERROR_KEYWORD_WE2; + + var prop = error.instancePath + ((_ref = (_error$params$additio = (_error$params = error.params) == null ? void 0 : _error$params.additionalProperty) != null ? _error$params$additio : (_error$params2 = error.params) == null ? void 0 : _error$params2.missingProperty) != null ? _ref : ''); + var existingError = acc[prop]; + + if (!existingError) { + acc[prop] = error; + return acc; + } + + var weight = (_AJV_ERROR_KEYWORD_WE = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword]) != null ? _AJV_ERROR_KEYWORD_WE : 0; + var existingWeight = (_AJV_ERROR_KEYWORD_WE2 = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword]) != null ? _AJV_ERROR_KEYWORD_WE2 : 0; + + if (weight > existingWeight) { + acc[prop] = error; + } + + return acc; + }, {}); + return Object.values(errorsPerProperty); +}; + +var getSuggestion = function getSuggestion(_ref) { + var value = _ref.value, + suggestions = _ref.suggestions, + _ref$format = _ref.format, + format = _ref$format === void 0 ? function (suggestion) { + return "Did you mean '" + suggestion + "'?"; + } : _ref$format; + if (!value) return ''; + var bestSuggestion = suggestions.reduce(function (best, current) { + var distance = leven(value, current); + + if (best.distance > distance) { + return { + value: current, + distance: distance + }; + } + + return best; + }, { + distance: Infinity, + value: '' + }); + return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : ''; +}; + +var pointerToDotNotation = function pointerToDotNotation(pointer) { + return pointer.replace(SLASH_REGEX, '.'); +}; +var cleanAjvMessage = function cleanAjvMessage(message) { + return message.replace(QUOTES_REGEX, "'").replace(NOT_REGEX, 'not'); +}; +var getLastSegment = function getLastSegment(path) { + var segments = path.split('/'); + return segments.pop(); +}; +var safeJsonPointer = function safeJsonPointer(_ref) { + var object = _ref.object, + pnter = _ref.pnter, + fallback = _ref.fallback; + + try { + return pointer.get(object, pnter); + } catch (err) { + return fallback; + } +}; + +var betterAjvErrors = function betterAjvErrors(_ref) { + var errors = _ref.errors, + data = _ref.data, + schema = _ref.schema, + _ref$basePath = _ref.basePath, + basePath = _ref$basePath === void 0 ? '{base}' : _ref$basePath; + + if (!Array.isArray(errors) || errors.length === 0) { + return []; + } + + var definedErrors = filterSingleErrorPerProperty(errors); + return definedErrors.map(function (error) { + var path = pointerToDotNotation(basePath + error.instancePath); + var prop = getLastSegment(error.instancePath); + var defaultContext = { + errorType: error.keyword + }; + var defaultMessage = (prop ? "property '" + prop + "'" : path) + " " + cleanAjvMessage(error.message); + var validationError; + + switch (error.keyword) { + case 'additionalProperties': + { + var additionalProp = error.params.additionalProperty; + var suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', ''); + + var _safeJsonPointer = safeJsonPointer({ + object: schema, + pnter: suggestionPointer, + fallback: { + properties: {} + } + }), + properties = _safeJsonPointer.properties; + + validationError = { + message: "'" + additionalProp + "' property is not expected to be here", + suggestion: getSuggestion({ + value: additionalProp, + suggestions: Object.keys(properties != null ? properties : {}), + format: function format(suggestion) { + return "Did you mean property '" + suggestion + "'?"; + } + }), + path: path, + context: defaultContext + }; + break; + } + + case 'enum': + { + var suggestions = error.params.allowedValues.map(function (value) { + return String(value != null ? value : ''); + }); + + var _prop = getLastSegment(error.instancePath); + + var value = safeJsonPointer({ + object: data, + pnter: error.instancePath, + fallback: '' + }); + validationError = { + message: "'" + _prop + "' property must be equal to one of the allowed values", + suggestion: getSuggestion({ + value: value, + suggestions: suggestions + }), + path: path, + context: _extends({}, defaultContext, { + allowedValues: error.params.allowedValues + }) + }; + break; + } + + case 'type': + { + var _prop2 = getLastSegment(error.instancePath); + + var type = error.params.type; + validationError = { + message: "'" + _prop2 + "' property type must be " + type, + path: path, + context: defaultContext + }; + break; + } + + case 'required': + { + validationError = { + message: path + " must have required property '" + error.params.missingProperty + "'", + path: path, + context: defaultContext + }; + break; + } + + case 'const': + { + return { + message: "'" + prop + "' property must be equal to the allowed value", + path: path, + context: _extends({}, defaultContext, { + allowedValue: error.params.allowedValue + }) + }; + } + + default: + return { + message: defaultMessage, + path: path, + context: defaultContext + }; + } // Remove empty properties + + + var errorEntries = Object.entries(validationError); + + for (var _i = 0, _errorEntries = errorEntries; _i < _errorEntries.length; _i++) { + var _errorEntries$_i = _errorEntries[_i], + key = _errorEntries$_i[0], + _value = _errorEntries$_i[1]; + + if (_value === null || _value === undefined || _value === '') { + delete validationError[key]; + } + } + + return validationError; + }); +}; + +exports.betterAjvErrors = betterAjvErrors; +//# sourceMappingURL=better-ajv-errors.cjs.development.js.map diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js.map b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b022d856aa1e979e8fd2edb7784de2c9d6b7b13b --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.development.js.map @@ -0,0 +1 @@ +{"version":3,"file":"better-ajv-errors.cjs.development.js","sources":["../src/constants.ts","../src/lib/filter.ts","../src/lib/suggestions.ts","../src/lib/utils.ts","../src/index.ts"],"sourcesContent":["import { DefinedError } from 'ajv';\n\nexport const AJV_ERROR_KEYWORD_WEIGHT_MAP: Partial> = {\n enum: 1,\n type: 0,\n};\n\nexport const QUOTES_REGEX = /\"/g;\nexport const NOT_REGEX = /NOT/g;\nexport const SLASH_REGEX = /\\//g;\n","import { DefinedError } from 'ajv';\nimport { AJV_ERROR_KEYWORD_WEIGHT_MAP } from '../constants';\n\nexport const filterSingleErrorPerProperty = (errors: DefinedError[]): DefinedError[] => {\n const errorsPerProperty = errors.reduce>((acc, error) => {\n const prop =\n error.instancePath + ((error.params as any)?.additionalProperty ?? (error.params as any)?.missingProperty ?? '');\n const existingError = acc[prop];\n if (!existingError) {\n acc[prop] = error;\n return acc;\n }\n const weight = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword] ?? 0;\n const existingWeight = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword] ?? 0;\n\n if (weight > existingWeight) {\n acc[prop] = error;\n }\n return acc;\n }, {});\n\n return Object.values(errorsPerProperty);\n};\n","import leven from 'leven';\n\nexport const getSuggestion = ({\n value,\n suggestions,\n format = (suggestion) => `Did you mean '${suggestion}'?`,\n}: {\n value: string | null;\n suggestions: string[];\n format?: (suggestion: string) => string;\n}): string => {\n if (!value) return '';\n const bestSuggestion = suggestions.reduce(\n (best, current) => {\n const distance = leven(value, current);\n if (best.distance > distance) {\n return { value: current, distance };\n }\n\n return best;\n },\n {\n distance: Infinity,\n value: '',\n }\n );\n\n return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : '';\n};\n","import { NOT_REGEX, QUOTES_REGEX, SLASH_REGEX } from '../constants';\nimport pointer from 'jsonpointer';\n\nexport const pointerToDotNotation = (pointer: string): string => {\n return pointer.replace(SLASH_REGEX, '.');\n};\n\nexport const cleanAjvMessage = (message: string): string => {\n return message.replace(QUOTES_REGEX, \"'\").replace(NOT_REGEX, 'not');\n};\n\nexport const getLastSegment = (path: string): string => {\n const segments = path.split('/');\n return segments.pop() as string;\n};\n\nexport const safeJsonPointer = ({ object, pnter, fallback }: { object: any; pnter: string; fallback: T }): T => {\n try {\n return pointer.get(object, pnter);\n } catch (err) {\n return fallback;\n }\n};\n","import { DefinedError, ErrorObject } from 'ajv';\nimport { ValidationError } from './types/ValidationError';\nimport { filterSingleErrorPerProperty } from './lib/filter';\nimport { getSuggestion } from './lib/suggestions';\nimport { cleanAjvMessage, getLastSegment, pointerToDotNotation, safeJsonPointer } from './lib/utils';\n\nexport interface BetterAjvErrorsOptions {\n errors: ErrorObject[] | null | undefined;\n data: any;\n schema: S;\n basePath?: string;\n}\n\nexport const betterAjvErrors = ({\n errors,\n data,\n schema,\n basePath = '{base}',\n}: BetterAjvErrorsOptions): ValidationError[] => {\n if (!Array.isArray(errors) || errors.length === 0) {\n return [];\n }\n\n const definedErrors = filterSingleErrorPerProperty(errors as DefinedError[]);\n\n return definedErrors.map((error) => {\n const path = pointerToDotNotation(basePath + error.instancePath);\n const prop = getLastSegment(error.instancePath);\n const defaultContext = {\n errorType: error.keyword,\n };\n const defaultMessage = `${prop ? `property '${prop}'` : path} ${cleanAjvMessage(error.message as string)}`;\n\n let validationError: ValidationError;\n\n switch (error.keyword) {\n case 'additionalProperties': {\n const additionalProp = error.params.additionalProperty;\n const suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', '');\n const { properties } = safeJsonPointer({\n object: schema,\n pnter: suggestionPointer,\n fallback: { properties: {} },\n });\n validationError = {\n message: `'${additionalProp}' property is not expected to be here`,\n suggestion: getSuggestion({\n value: additionalProp,\n suggestions: Object.keys(properties ?? {}),\n format: (suggestion) => `Did you mean property '${suggestion}'?`,\n }),\n path,\n context: defaultContext,\n };\n break;\n }\n case 'enum': {\n const suggestions = error.params.allowedValues.map((value) => String(value ?? ''));\n const prop = getLastSegment(error.instancePath);\n const value = safeJsonPointer({ object: data, pnter: error.instancePath, fallback: '' });\n validationError = {\n message: `'${prop}' property must be equal to one of the allowed values`,\n suggestion: getSuggestion({\n value,\n suggestions,\n }),\n path,\n context: {\n ...defaultContext,\n allowedValues: error.params.allowedValues,\n },\n };\n break;\n }\n case 'type': {\n const prop = getLastSegment(error.instancePath);\n const type = error.params.type;\n validationError = {\n message: `'${prop}' property type must be ${type}`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'required': {\n validationError = {\n message: `${path} must have required property '${error.params.missingProperty}'`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'const': {\n return {\n message: `'${prop}' property must be equal to the allowed value`,\n path,\n context: {\n ...defaultContext,\n allowedValue: error.params.allowedValue,\n },\n };\n }\n\n default:\n return { message: defaultMessage, path, context: defaultContext };\n }\n\n // Remove empty properties\n const errorEntries = Object.entries(validationError);\n for (const [key, value] of errorEntries as [keyof ValidationError, unknown][]) {\n if (value === null || value === undefined || value === '') {\n delete validationError[key];\n }\n }\n\n return validationError;\n });\n};\n\nexport { ValidationError };\n"],"names":["AJV_ERROR_KEYWORD_WEIGHT_MAP","type","QUOTES_REGEX","NOT_REGEX","SLASH_REGEX","filterSingleErrorPerProperty","errors","errorsPerProperty","reduce","acc","error","prop","instancePath","params","additionalProperty","missingProperty","existingError","weight","keyword","existingWeight","Object","values","getSuggestion","value","suggestions","format","suggestion","bestSuggestion","best","current","distance","leven","Infinity","length","pointerToDotNotation","pointer","replace","cleanAjvMessage","message","getLastSegment","path","segments","split","pop","safeJsonPointer","object","pnter","fallback","get","err","betterAjvErrors","data","schema","basePath","Array","isArray","definedErrors","map","defaultContext","errorType","defaultMessage","validationError","additionalProp","suggestionPointer","schemaPath","properties","keys","context","allowedValues","String","allowedValue","errorEntries","entries","key","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAEO,IAAMA,4BAA4B,GAAqD;EAC5F,QAAM,CADsF;EAE5FC,IAAI,EAAE;AAFsF,CAAvF;AAKA,IAAMC,YAAY,GAAG,IAArB;AACA,IAAMC,SAAS,GAAG,MAAlB;AACA,IAAMC,WAAW,GAAG,KAApB;;ACNA,IAAMC,4BAA4B,GAAG,SAA/BA,4BAA+B,CAACC,MAAD;EAC1C,IAAMC,iBAAiB,GAAGD,MAAM,CAACE,MAAP,CAA4C,UAACC,GAAD,EAAMC,KAAN;;;IACpE,IAAMC,IAAI,GACRD,KAAK,CAACE,YAAN,sDAAuBF,KAAK,CAACG,MAA7B,qBAAuB,cAAsBC,kBAA7C,sDAAoEJ,KAAK,CAACG,MAA1E,qBAAoE,eAAsBE,eAA1F,mBAA6G,EAA7G,CADF;IAEA,IAAMC,aAAa,GAAGP,GAAG,CAACE,IAAD,CAAzB;;IACA,IAAI,CAACK,aAAL,EAAoB;MAClBP,GAAG,CAACE,IAAD,CAAH,GAAYD,KAAZ;MACA,OAAOD,GAAP;;;IAEF,IAAMQ,MAAM,4BAAGjB,4BAA4B,CAACU,KAAK,CAACQ,OAAP,CAA/B,oCAAkD,CAA9D;IACA,IAAMC,cAAc,6BAAGnB,4BAA4B,CAACgB,aAAa,CAACE,OAAf,CAA/B,qCAA0D,CAA9E;;IAEA,IAAID,MAAM,GAAGE,cAAb,EAA6B;MAC3BV,GAAG,CAACE,IAAD,CAAH,GAAYD,KAAZ;;;IAEF,OAAOD,GAAP;GAdwB,EAevB,EAfuB,CAA1B;EAiBA,OAAOW,MAAM,CAACC,MAAP,CAAcd,iBAAd,CAAP;AACD,CAnBM;;ACDA,IAAMe,aAAa,GAAG,SAAhBA,aAAgB;MAC3BC,aAAAA;MACAC,mBAAAA;yBACAC;MAAAA,kCAAS,UAACC,UAAD;IAAA,0BAAiCA,UAAjC;;EAMT,IAAI,CAACH,KAAL,EAAY,OAAO,EAAP;EACZ,IAAMI,cAAc,GAAGH,WAAW,CAAChB,MAAZ,CACrB,UAACoB,IAAD,EAAOC,OAAP;IACE,IAAMC,QAAQ,GAAGC,KAAK,CAACR,KAAD,EAAQM,OAAR,CAAtB;;IACA,IAAID,IAAI,CAACE,QAAL,GAAgBA,QAApB,EAA8B;MAC5B,OAAO;QAAEP,KAAK,EAAEM,OAAT;QAAkBC,QAAQ,EAARA;OAAzB;;;IAGF,OAAOF,IAAP;GAPmB,EASrB;IACEE,QAAQ,EAAEE,QADZ;IAEET,KAAK,EAAE;GAXY,CAAvB;EAeA,OAAOI,cAAc,CAACG,QAAf,GAA0BP,KAAK,CAACU,MAAhC,GAAyCR,MAAM,CAACE,cAAc,CAACJ,KAAhB,CAA/C,GAAwE,EAA/E;AACD,CA1BM;;ACCA,IAAMW,oBAAoB,GAAG,SAAvBA,oBAAuB,CAACC,OAAD;EAClC,OAAOA,OAAO,CAACC,OAAR,CAAgBhC,WAAhB,EAA6B,GAA7B,CAAP;AACD,CAFM;AAIP,AAAO,IAAMiC,eAAe,GAAG,SAAlBA,eAAkB,CAACC,OAAD;EAC7B,OAAOA,OAAO,CAACF,OAAR,CAAgBlC,YAAhB,EAA8B,GAA9B,EAAmCkC,OAAnC,CAA2CjC,SAA3C,EAAsD,KAAtD,CAAP;AACD,CAFM;AAIP,AAAO,IAAMoC,cAAc,GAAG,SAAjBA,cAAiB,CAACC,IAAD;EAC5B,IAAMC,QAAQ,GAAGD,IAAI,CAACE,KAAL,CAAW,GAAX,CAAjB;EACA,OAAOD,QAAQ,CAACE,GAAT,EAAP;AACD,CAHM;AAKP,AAAO,IAAMC,eAAe,GAAG,SAAlBA,eAAkB;MAAMC,cAAAA;MAAQC,aAAAA;MAAOC,gBAAAA;;EAClD,IAAI;IACF,OAAOZ,OAAO,CAACa,GAAR,CAAYH,MAAZ,EAAoBC,KAApB,CAAP;GADF,CAEE,OAAOG,GAAP,EAAY;IACZ,OAAOF,QAAP;;AAEH,CANM;;ICHMG,eAAe,GAAG,SAAlBA,eAAkB;MAC7B5C,cAAAA;MACA6C,YAAAA;MACAC,cAAAA;2BACAC;MAAAA,sCAAW;;EAEX,IAAI,CAACC,KAAK,CAACC,OAAN,CAAcjD,MAAd,CAAD,IAA0BA,MAAM,CAAC2B,MAAP,KAAkB,CAAhD,EAAmD;IACjD,OAAO,EAAP;;;EAGF,IAAMuB,aAAa,GAAGnD,4BAA4B,CAACC,MAAD,CAAlD;EAEA,OAAOkD,aAAa,CAACC,GAAd,CAAkB,UAAC/C,KAAD;IACvB,IAAM8B,IAAI,GAAGN,oBAAoB,CAACmB,QAAQ,GAAG3C,KAAK,CAACE,YAAlB,CAAjC;IACA,IAAMD,IAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;IACA,IAAM8C,cAAc,GAAG;MACrBC,SAAS,EAAEjD,KAAK,CAACQ;KADnB;IAGA,IAAM0C,cAAc,IAAMjD,IAAI,kBAAgBA,IAAhB,SAA0B6B,IAApC,UAA4CH,eAAe,CAAC3B,KAAK,CAAC4B,OAAP,CAA/E;IAEA,IAAIuB,eAAJ;;IAEA,QAAQnD,KAAK,CAACQ,OAAd;MACE,KAAK,sBAAL;QAA6B;UAC3B,IAAM4C,cAAc,GAAGpD,KAAK,CAACG,MAAN,CAAaC,kBAApC;UACA,IAAMiD,iBAAiB,GAAGrD,KAAK,CAACsD,UAAN,CAAiB5B,OAAjB,CAAyB,GAAzB,EAA8B,EAA9B,EAAkCA,OAAlC,CAA0C,uBAA1C,EAAmE,EAAnE,CAA1B;;UACA,uBAAuBQ,eAAe,CAAC;YACrCC,MAAM,EAAEO,MAD6B;YAErCN,KAAK,EAAEiB,iBAF8B;YAGrChB,QAAQ,EAAE;cAAEkB,UAAU,EAAE;;WAHY,CAAtC;cAAQA,UAAR,oBAAQA,UAAR;;UAKAJ,eAAe,GAAG;YAChBvB,OAAO,QAAMwB,cAAN,0CADS;YAEhBpC,UAAU,EAAEJ,aAAa,CAAC;cACxBC,KAAK,EAAEuC,cADiB;cAExBtC,WAAW,EAAEJ,MAAM,CAAC8C,IAAP,CAAYD,UAAZ,WAAYA,UAAZ,GAA0B,EAA1B,CAFW;cAGxBxC,MAAM,EAAE,gBAACC,UAAD;gBAAA,mCAA0CA,UAA1C;;aAHe,CAFT;YAOhBc,IAAI,EAAJA,IAPgB;YAQhB2B,OAAO,EAAET;WARX;UAUA;;;MAEF,KAAK,MAAL;QAAa;UACX,IAAMlC,WAAW,GAAGd,KAAK,CAACG,MAAN,CAAauD,aAAb,CAA2BX,GAA3B,CAA+B,UAAClC,KAAD;YAAA,OAAW8C,MAAM,CAAC9C,KAAD,WAACA,KAAD,GAAU,EAAV,CAAjB;WAA/B,CAApB;;UACA,IAAMZ,KAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;;UACA,IAAMW,KAAK,GAAGqB,eAAe,CAAC;YAAEC,MAAM,EAAEM,IAAV;YAAgBL,KAAK,EAAEpC,KAAK,CAACE,YAA7B;YAA2CmC,QAAQ,EAAE;WAAtD,CAA7B;UACAc,eAAe,GAAG;YAChBvB,OAAO,QAAM3B,KAAN,0DADS;YAEhBe,UAAU,EAAEJ,aAAa,CAAC;cACxBC,KAAK,EAALA,KADwB;cAExBC,WAAW,EAAXA;aAFuB,CAFT;YAMhBgB,IAAI,EAAJA,IANgB;YAOhB2B,OAAO,eACFT,cADE;cAELU,aAAa,EAAE1D,KAAK,CAACG,MAAN,CAAauD;;WAThC;UAYA;;;MAEF,KAAK,MAAL;QAAa;UACX,IAAMzD,MAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;;UACA,IAAMX,IAAI,GAAGS,KAAK,CAACG,MAAN,CAAaZ,IAA1B;UACA4D,eAAe,GAAG;YAChBvB,OAAO,QAAM3B,MAAN,gCAAqCV,IAD5B;YAEhBuC,IAAI,EAAJA,IAFgB;YAGhB2B,OAAO,EAAET;WAHX;UAKA;;;MAEF,KAAK,UAAL;QAAiB;UACfG,eAAe,GAAG;YAChBvB,OAAO,EAAKE,IAAL,sCAA0C9B,KAAK,CAACG,MAAN,CAAaE,eAAvD,MADS;YAEhByB,IAAI,EAAJA,IAFgB;YAGhB2B,OAAO,EAAET;WAHX;UAKA;;;MAEF,KAAK,OAAL;QAAc;UACZ,OAAO;YACLpB,OAAO,QAAM3B,IAAN,kDADF;YAEL6B,IAAI,EAAJA,IAFK;YAGL2B,OAAO,eACFT,cADE;cAELY,YAAY,EAAE5D,KAAK,CAACG,MAAN,CAAayD;;WAL/B;;;MAUF;QACE,OAAO;UAAEhC,OAAO,EAAEsB,cAAX;UAA2BpB,IAAI,EAAJA,IAA3B;UAAiC2B,OAAO,EAAET;SAAjD;;;;IAIJ,IAAMa,YAAY,GAAGnD,MAAM,CAACoD,OAAP,CAAeX,eAAf,CAArB;;IACA,iCAA2BU,YAA3B,mCAA+E;MAA1E;UAAOE,GAAP;UAAYlD,MAAZ;;MACH,IAAIA,MAAK,KAAK,IAAV,IAAkBA,MAAK,KAAKmD,SAA5B,IAAyCnD,MAAK,KAAK,EAAvD,EAA2D;QACzD,OAAOsC,eAAe,CAACY,GAAD,CAAtB;;;;IAIJ,OAAOZ,eAAP;GA1FK,CAAP;AA4FD,CAxGM;;;;"} \ No newline at end of file diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.production.min.js b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.production.min.js new file mode 100644 index 0000000000000000000000000000000000000000..4822665cf665c9615bd3c864df01af574184d4ba --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.cjs.production.min.js @@ -0,0 +1,2 @@ +"use strict";function e(e){return e&&"object"==typeof e&&"default"in e?e.default:e}Object.defineProperty(exports,"__esModule",{value:!0});var t=e(require("leven")),r=e(require("jsonpointer"));function a(){return(a=Object.assign||function(e){for(var t=1;tn?{value:a,distance:n}:e}),{distance:Infinity,value:""});return o.distance(null!=(l=n[p.keyword])?l:0)&&(e[i]=t),e):(e[i]=t,e)}),{});return Object.values(t)}(t).map((function(e){var t,n=function(e){return e.replace(u,".")}(v+e.instancePath),d=i(e.instancePath),y={errorType:e.keyword},f=(d?"property '"+d+"'":n)+" "+e.message.replace(o,"'").replace(s,"not");switch(e.keyword){case"additionalProperties":var m=e.params.additionalProperty,g=e.schemaPath.replace("#","").replace("/additionalProperties",""),h=p({object:c,pnter:g,fallback:{properties:{}}}).properties;t={message:"'"+m+"' property is not expected to be here",suggestion:l({value:m,suggestions:Object.keys(null!=h?h:{}),format:function(e){return"Did you mean property '"+e+"'?"}}),path:n,context:y};break;case"enum":var b=e.params.allowedValues.map((function(e){return String(null!=e?e:"")})),P=i(e.instancePath),w=p({object:r,pnter:e.instancePath,fallback:""});t={message:"'"+P+"' property must be equal to one of the allowed values",suggestion:l({value:w,suggestions:b}),path:n,context:a({},y,{allowedValues:e.params.allowedValues})};break;case"type":t={message:"'"+i(e.instancePath)+"' property type must be "+e.params.type,path:n,context:y};break;case"required":t={message:n+" must have required property '"+e.params.missingProperty+"'",path:n,context:y};break;case"const":return{message:"'"+d+"' property must be equal to the allowed value",path:n,context:a({},y,{allowedValue:e.params.allowedValue})};default:return{message:f,path:n,context:y}}for(var j=0,k=Object.entries(t);j> = {\n enum: 1,\n type: 0,\n};\n\nexport const QUOTES_REGEX = /\"/g;\nexport const NOT_REGEX = /NOT/g;\nexport const SLASH_REGEX = /\\//g;\n","import leven from 'leven';\n\nexport const getSuggestion = ({\n value,\n suggestions,\n format = (suggestion) => `Did you mean '${suggestion}'?`,\n}: {\n value: string | null;\n suggestions: string[];\n format?: (suggestion: string) => string;\n}): string => {\n if (!value) return '';\n const bestSuggestion = suggestions.reduce(\n (best, current) => {\n const distance = leven(value, current);\n if (best.distance > distance) {\n return { value: current, distance };\n }\n\n return best;\n },\n {\n distance: Infinity,\n value: '',\n }\n );\n\n return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : '';\n};\n","import { NOT_REGEX, QUOTES_REGEX, SLASH_REGEX } from '../constants';\nimport pointer from 'jsonpointer';\n\nexport const pointerToDotNotation = (pointer: string): string => {\n return pointer.replace(SLASH_REGEX, '.');\n};\n\nexport const cleanAjvMessage = (message: string): string => {\n return message.replace(QUOTES_REGEX, \"'\").replace(NOT_REGEX, 'not');\n};\n\nexport const getLastSegment = (path: string): string => {\n const segments = path.split('/');\n return segments.pop() as string;\n};\n\nexport const safeJsonPointer = ({ object, pnter, fallback }: { object: any; pnter: string; fallback: T }): T => {\n try {\n return pointer.get(object, pnter);\n } catch (err) {\n return fallback;\n }\n};\n","import { DefinedError, ErrorObject } from 'ajv';\nimport { ValidationError } from './types/ValidationError';\nimport { filterSingleErrorPerProperty } from './lib/filter';\nimport { getSuggestion } from './lib/suggestions';\nimport { cleanAjvMessage, getLastSegment, pointerToDotNotation, safeJsonPointer } from './lib/utils';\n\nexport interface BetterAjvErrorsOptions {\n errors: ErrorObject[] | null | undefined;\n data: any;\n schema: S;\n basePath?: string;\n}\n\nexport const betterAjvErrors = ({\n errors,\n data,\n schema,\n basePath = '{base}',\n}: BetterAjvErrorsOptions): ValidationError[] => {\n if (!Array.isArray(errors) || errors.length === 0) {\n return [];\n }\n\n const definedErrors = filterSingleErrorPerProperty(errors as DefinedError[]);\n\n return definedErrors.map((error) => {\n const path = pointerToDotNotation(basePath + error.instancePath);\n const prop = getLastSegment(error.instancePath);\n const defaultContext = {\n errorType: error.keyword,\n };\n const defaultMessage = `${prop ? `property '${prop}'` : path} ${cleanAjvMessage(error.message as string)}`;\n\n let validationError: ValidationError;\n\n switch (error.keyword) {\n case 'additionalProperties': {\n const additionalProp = error.params.additionalProperty;\n const suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', '');\n const { properties } = safeJsonPointer({\n object: schema,\n pnter: suggestionPointer,\n fallback: { properties: {} },\n });\n validationError = {\n message: `'${additionalProp}' property is not expected to be here`,\n suggestion: getSuggestion({\n value: additionalProp,\n suggestions: Object.keys(properties ?? {}),\n format: (suggestion) => `Did you mean property '${suggestion}'?`,\n }),\n path,\n context: defaultContext,\n };\n break;\n }\n case 'enum': {\n const suggestions = error.params.allowedValues.map((value) => String(value ?? ''));\n const prop = getLastSegment(error.instancePath);\n const value = safeJsonPointer({ object: data, pnter: error.instancePath, fallback: '' });\n validationError = {\n message: `'${prop}' property must be equal to one of the allowed values`,\n suggestion: getSuggestion({\n value,\n suggestions,\n }),\n path,\n context: {\n ...defaultContext,\n allowedValues: error.params.allowedValues,\n },\n };\n break;\n }\n case 'type': {\n const prop = getLastSegment(error.instancePath);\n const type = error.params.type;\n validationError = {\n message: `'${prop}' property type must be ${type}`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'required': {\n validationError = {\n message: `${path} must have required property '${error.params.missingProperty}'`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'const': {\n return {\n message: `'${prop}' property must be equal to the allowed value`,\n path,\n context: {\n ...defaultContext,\n allowedValue: error.params.allowedValue,\n },\n };\n }\n\n default:\n return { message: defaultMessage, path, context: defaultContext };\n }\n\n // Remove empty properties\n const errorEntries = Object.entries(validationError);\n for (const [key, value] of errorEntries as [keyof ValidationError, unknown][]) {\n if (value === null || value === undefined || value === '') {\n delete validationError[key];\n }\n }\n\n return validationError;\n });\n};\n\nexport { ValidationError };\n","import { DefinedError } from 'ajv';\nimport { AJV_ERROR_KEYWORD_WEIGHT_MAP } from '../constants';\n\nexport const filterSingleErrorPerProperty = (errors: DefinedError[]): DefinedError[] => {\n const errorsPerProperty = errors.reduce>((acc, error) => {\n const prop =\n error.instancePath + ((error.params as any)?.additionalProperty ?? (error.params as any)?.missingProperty ?? '');\n const existingError = acc[prop];\n if (!existingError) {\n acc[prop] = error;\n return acc;\n }\n const weight = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword] ?? 0;\n const existingWeight = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword] ?? 0;\n\n if (weight > existingWeight) {\n acc[prop] = error;\n }\n return acc;\n }, {});\n\n return Object.values(errorsPerProperty);\n};\n"],"names":["AJV_ERROR_KEYWORD_WEIGHT_MAP","enum","type","QUOTES_REGEX","NOT_REGEX","SLASH_REGEX","getSuggestion","value","format","suggestion","bestSuggestion","suggestions","reduce","best","current","distance","leven","Infinity","length","getLastSegment","path","split","pop","safeJsonPointer","object","pnter","fallback","pointer","get","err","errors","data","schema","basePath","Array","isArray","errorsPerProperty","acc","error","prop","instancePath","params","_error$params","additionalProperty","_error$params2","missingProperty","existingError","keyword","Object","values","filterSingleErrorPerProperty","map","validationError","replace","pointerToDotNotation","defaultContext","errorType","defaultMessage","message","additionalProp","suggestionPointer","schemaPath","properties","keys","context","allowedValues","String","allowedValue","entries"],"mappings":"+YAEO,IAAMA,EAAiF,CAC5FC,KAAM,EACNC,KAAM,GAGKC,EAAe,KACfC,EAAY,OACZC,EAAc,MCPdC,EAAgB,gBAC3BC,IAAAA,UAEAC,OAAAA,aAAS,SAACC,GAAD,uBAAiCA,UAM1C,IAAKF,EAAO,MAAO,GACnB,IAAMG,IARNC,YAQmCC,QACjC,SAACC,EAAMC,GACL,IAAMC,EAAWC,EAAMT,EAAOO,GAC9B,OAAID,EAAKE,SAAWA,EACX,CAAER,MAAOO,EAASC,SAAAA,GAGpBF,IAET,CACEE,SAAUE,SACVV,MAAO,KAIX,OAAOG,EAAeK,SAAWR,EAAMW,OAASV,EAAOE,EAAeH,OAAS,IChBpEY,EAAiB,SAACC,GAE7B,OADiBA,EAAKC,MAAM,KACZC,OAGLC,EAAkB,gBAAMC,IAAAA,OAAQC,IAAAA,MAAOC,IAAAA,SAClD,IACE,OAAOC,EAAQC,IAAIJ,EAAQC,GAC3B,MAAOI,GACP,OAAOH,4BCPoB,gBAC7BI,IAAAA,OACAC,IAAAA,KACAC,IAAAA,WACAC,SAAAA,aAAW,WAEX,OAAKC,MAAMC,QAAQL,IAA6B,IAAlBA,EAAOZ,OChBK,SAACY,GAC3C,IAAMM,EAAoBN,EAAOlB,QAAqC,SAACyB,EAAKC,mBACpEC,EACJD,EAAME,yCAAiBF,EAAMG,eAANC,EAAsBC,+BAAuBL,EAAMG,eAANG,EAAsBC,mBAAmB,IACzGC,EAAgBT,EAAIE,GAC1B,OAAKO,aAIU9C,EAA6BsC,EAAMS,YAAY,aACvC/C,EAA6B8C,EAAcC,YAAY,KAG5EV,EAAIE,GAAQD,GAEPD,IATLA,EAAIE,GAAQD,EACLD,KASR,IAEH,OAAOW,OAAOC,OAAOb,GDECc,CAA6BpB,GAE9BqB,KAAI,SAACb,GACxB,IAOIc,EAPEhC,EDvB0B,SAACO,GACnC,OAAOA,EAAQ0B,QAAQhD,EAAa,KCsBrBiD,CAAqBrB,EAAWK,EAAME,cAC7CD,EAAOpB,EAAemB,EAAME,cAC5Be,EAAiB,CACrBC,UAAWlB,EAAMS,SAEbU,GAAoBlB,eAAoBA,MAAUnB,OAAwBkB,EAAMoB,QDvBzEL,QAAQlD,EAAc,KAAKkD,QAAQjD,EAAW,OC2B3D,OAAQkC,EAAMS,SACZ,IAAK,uBACH,IAAMY,EAAiBrB,EAAMG,OAAOE,mBAC9BiB,EAAoBtB,EAAMuB,WAAWR,QAAQ,IAAK,IAAIA,QAAQ,wBAAyB,IACrFS,EAAevC,EAAgB,CACrCC,OAAQQ,EACRP,MAAOmC,EACPlC,SAAU,CAAEoC,WAAY,MAHlBA,WAKRV,EAAkB,CAChBM,YAAaC,0CACblD,WAAYH,EAAc,CACxBC,MAAOoD,EACPhD,YAAaqC,OAAOe,WAAKD,EAAAA,EAAc,IACvCtD,OAAQ,SAACC,GAAD,gCAA0CA,UAEpDW,KAAAA,EACA4C,QAAST,GAEX,MAEF,IAAK,OACH,IAAM5C,EAAc2B,EAAMG,OAAOwB,cAAcd,KAAI,SAAC5C,GAAD,OAAW2D,aAAO3D,EAAAA,EAAS,OACxEgC,EAAOpB,EAAemB,EAAME,cAC5BjC,EAAQgB,EAAgB,CAAEC,OAAQO,EAAMN,MAAOa,EAAME,aAAcd,SAAU,KACnF0B,EAAkB,CAChBM,YAAanB,0DACb9B,WAAYH,EAAc,CACxBC,MAAAA,EACAI,YAAAA,IAEFS,KAAAA,EACA4C,aACKT,GACHU,cAAe3B,EAAMG,OAAOwB,iBAGhC,MAEF,IAAK,OAGHb,EAAkB,CAChBM,YAHWvC,EAAemB,EAAME,yCACrBF,EAAMG,OAAOvC,KAGxBkB,KAAAA,EACA4C,QAAST,GAEX,MAEF,IAAK,WACHH,EAAkB,CAChBM,QAAYtC,mCAAqCkB,EAAMG,OAAOI,oBAC9DzB,KAAAA,EACA4C,QAAST,GAEX,MAEF,IAAK,QACH,MAAO,CACLG,YAAanB,kDACbnB,KAAAA,EACA4C,aACKT,GACHY,aAAc7B,EAAMG,OAAO0B,gBAKjC,QACE,MAAO,CAAET,QAASD,EAAgBrC,KAAAA,EAAM4C,QAAST,GAKrD,IADA,UAAqBP,OAAOoB,QAAQhB,kBAC2C,CAA1E,WAAY7C,OACXA,MAAAA,GAAmD,KAAVA,UACpC6C,QAIX,OAAOA,KA/FA"} \ No newline at end of file diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..5dfcfdf4090c8cc6463072e69b44c1538d8652e3 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js @@ -0,0 +1,240 @@ +import leven from 'leven'; +import pointer from 'jsonpointer'; + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +var AJV_ERROR_KEYWORD_WEIGHT_MAP = { + "enum": 1, + type: 0 +}; +var QUOTES_REGEX = /"/g; +var NOT_REGEX = /NOT/g; +var SLASH_REGEX = /\//g; + +var filterSingleErrorPerProperty = function filterSingleErrorPerProperty(errors) { + var errorsPerProperty = errors.reduce(function (acc, error) { + var _ref, _error$params$additio, _error$params, _error$params2, _AJV_ERROR_KEYWORD_WE, _AJV_ERROR_KEYWORD_WE2; + + var prop = error.instancePath + ((_ref = (_error$params$additio = (_error$params = error.params) == null ? void 0 : _error$params.additionalProperty) != null ? _error$params$additio : (_error$params2 = error.params) == null ? void 0 : _error$params2.missingProperty) != null ? _ref : ''); + var existingError = acc[prop]; + + if (!existingError) { + acc[prop] = error; + return acc; + } + + var weight = (_AJV_ERROR_KEYWORD_WE = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword]) != null ? _AJV_ERROR_KEYWORD_WE : 0; + var existingWeight = (_AJV_ERROR_KEYWORD_WE2 = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword]) != null ? _AJV_ERROR_KEYWORD_WE2 : 0; + + if (weight > existingWeight) { + acc[prop] = error; + } + + return acc; + }, {}); + return Object.values(errorsPerProperty); +}; + +var getSuggestion = function getSuggestion(_ref) { + var value = _ref.value, + suggestions = _ref.suggestions, + _ref$format = _ref.format, + format = _ref$format === void 0 ? function (suggestion) { + return "Did you mean '" + suggestion + "'?"; + } : _ref$format; + if (!value) return ''; + var bestSuggestion = suggestions.reduce(function (best, current) { + var distance = leven(value, current); + + if (best.distance > distance) { + return { + value: current, + distance: distance + }; + } + + return best; + }, { + distance: Infinity, + value: '' + }); + return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : ''; +}; + +var pointerToDotNotation = function pointerToDotNotation(pointer) { + return pointer.replace(SLASH_REGEX, '.'); +}; +var cleanAjvMessage = function cleanAjvMessage(message) { + return message.replace(QUOTES_REGEX, "'").replace(NOT_REGEX, 'not'); +}; +var getLastSegment = function getLastSegment(path) { + var segments = path.split('/'); + return segments.pop(); +}; +var safeJsonPointer = function safeJsonPointer(_ref) { + var object = _ref.object, + pnter = _ref.pnter, + fallback = _ref.fallback; + + try { + return pointer.get(object, pnter); + } catch (err) { + return fallback; + } +}; + +var betterAjvErrors = function betterAjvErrors(_ref) { + var errors = _ref.errors, + data = _ref.data, + schema = _ref.schema, + _ref$basePath = _ref.basePath, + basePath = _ref$basePath === void 0 ? '{base}' : _ref$basePath; + + if (!Array.isArray(errors) || errors.length === 0) { + return []; + } + + var definedErrors = filterSingleErrorPerProperty(errors); + return definedErrors.map(function (error) { + var path = pointerToDotNotation(basePath + error.instancePath); + var prop = getLastSegment(error.instancePath); + var defaultContext = { + errorType: error.keyword + }; + var defaultMessage = (prop ? "property '" + prop + "'" : path) + " " + cleanAjvMessage(error.message); + var validationError; + + switch (error.keyword) { + case 'additionalProperties': + { + var additionalProp = error.params.additionalProperty; + var suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', ''); + + var _safeJsonPointer = safeJsonPointer({ + object: schema, + pnter: suggestionPointer, + fallback: { + properties: {} + } + }), + properties = _safeJsonPointer.properties; + + validationError = { + message: "'" + additionalProp + "' property is not expected to be here", + suggestion: getSuggestion({ + value: additionalProp, + suggestions: Object.keys(properties != null ? properties : {}), + format: function format(suggestion) { + return "Did you mean property '" + suggestion + "'?"; + } + }), + path: path, + context: defaultContext + }; + break; + } + + case 'enum': + { + var suggestions = error.params.allowedValues.map(function (value) { + return String(value != null ? value : ''); + }); + + var _prop = getLastSegment(error.instancePath); + + var value = safeJsonPointer({ + object: data, + pnter: error.instancePath, + fallback: '' + }); + validationError = { + message: "'" + _prop + "' property must be equal to one of the allowed values", + suggestion: getSuggestion({ + value: value, + suggestions: suggestions + }), + path: path, + context: _extends({}, defaultContext, { + allowedValues: error.params.allowedValues + }) + }; + break; + } + + case 'type': + { + var _prop2 = getLastSegment(error.instancePath); + + var type = error.params.type; + validationError = { + message: "'" + _prop2 + "' property type must be " + type, + path: path, + context: defaultContext + }; + break; + } + + case 'required': + { + validationError = { + message: path + " must have required property '" + error.params.missingProperty + "'", + path: path, + context: defaultContext + }; + break; + } + + case 'const': + { + return { + message: "'" + prop + "' property must be equal to the allowed value", + path: path, + context: _extends({}, defaultContext, { + allowedValue: error.params.allowedValue + }) + }; + } + + default: + return { + message: defaultMessage, + path: path, + context: defaultContext + }; + } // Remove empty properties + + + var errorEntries = Object.entries(validationError); + + for (var _i = 0, _errorEntries = errorEntries; _i < _errorEntries.length; _i++) { + var _errorEntries$_i = _errorEntries[_i], + key = _errorEntries$_i[0], + _value = _errorEntries$_i[1]; + + if (_value === null || _value === undefined || _value === '') { + delete validationError[key]; + } + } + + return validationError; + }); +}; + +export { betterAjvErrors }; +//# sourceMappingURL=better-ajv-errors.esm.js.map diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js.map b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js.map new file mode 100644 index 0000000000000000000000000000000000000000..459dfbf2161e615c3376cc406f0b95ea11c231a5 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/better-ajv-errors.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"better-ajv-errors.esm.js","sources":["../src/constants.ts","../src/lib/filter.ts","../src/lib/suggestions.ts","../src/lib/utils.ts","../src/index.ts"],"sourcesContent":["import { DefinedError } from 'ajv';\n\nexport const AJV_ERROR_KEYWORD_WEIGHT_MAP: Partial> = {\n enum: 1,\n type: 0,\n};\n\nexport const QUOTES_REGEX = /\"/g;\nexport const NOT_REGEX = /NOT/g;\nexport const SLASH_REGEX = /\\//g;\n","import { DefinedError } from 'ajv';\nimport { AJV_ERROR_KEYWORD_WEIGHT_MAP } from '../constants';\n\nexport const filterSingleErrorPerProperty = (errors: DefinedError[]): DefinedError[] => {\n const errorsPerProperty = errors.reduce>((acc, error) => {\n const prop =\n error.instancePath + ((error.params as any)?.additionalProperty ?? (error.params as any)?.missingProperty ?? '');\n const existingError = acc[prop];\n if (!existingError) {\n acc[prop] = error;\n return acc;\n }\n const weight = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword] ?? 0;\n const existingWeight = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword] ?? 0;\n\n if (weight > existingWeight) {\n acc[prop] = error;\n }\n return acc;\n }, {});\n\n return Object.values(errorsPerProperty);\n};\n","import leven from 'leven';\n\nexport const getSuggestion = ({\n value,\n suggestions,\n format = (suggestion) => `Did you mean '${suggestion}'?`,\n}: {\n value: string | null;\n suggestions: string[];\n format?: (suggestion: string) => string;\n}): string => {\n if (!value) return '';\n const bestSuggestion = suggestions.reduce(\n (best, current) => {\n const distance = leven(value, current);\n if (best.distance > distance) {\n return { value: current, distance };\n }\n\n return best;\n },\n {\n distance: Infinity,\n value: '',\n }\n );\n\n return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : '';\n};\n","import { NOT_REGEX, QUOTES_REGEX, SLASH_REGEX } from '../constants';\nimport pointer from 'jsonpointer';\n\nexport const pointerToDotNotation = (pointer: string): string => {\n return pointer.replace(SLASH_REGEX, '.');\n};\n\nexport const cleanAjvMessage = (message: string): string => {\n return message.replace(QUOTES_REGEX, \"'\").replace(NOT_REGEX, 'not');\n};\n\nexport const getLastSegment = (path: string): string => {\n const segments = path.split('/');\n return segments.pop() as string;\n};\n\nexport const safeJsonPointer = ({ object, pnter, fallback }: { object: any; pnter: string; fallback: T }): T => {\n try {\n return pointer.get(object, pnter);\n } catch (err) {\n return fallback;\n }\n};\n","import { DefinedError, ErrorObject } from 'ajv';\nimport { ValidationError } from './types/ValidationError';\nimport { filterSingleErrorPerProperty } from './lib/filter';\nimport { getSuggestion } from './lib/suggestions';\nimport { cleanAjvMessage, getLastSegment, pointerToDotNotation, safeJsonPointer } from './lib/utils';\n\nexport interface BetterAjvErrorsOptions {\n errors: ErrorObject[] | null | undefined;\n data: any;\n schema: S;\n basePath?: string;\n}\n\nexport const betterAjvErrors = ({\n errors,\n data,\n schema,\n basePath = '{base}',\n}: BetterAjvErrorsOptions): ValidationError[] => {\n if (!Array.isArray(errors) || errors.length === 0) {\n return [];\n }\n\n const definedErrors = filterSingleErrorPerProperty(errors as DefinedError[]);\n\n return definedErrors.map((error) => {\n const path = pointerToDotNotation(basePath + error.instancePath);\n const prop = getLastSegment(error.instancePath);\n const defaultContext = {\n errorType: error.keyword,\n };\n const defaultMessage = `${prop ? `property '${prop}'` : path} ${cleanAjvMessage(error.message as string)}`;\n\n let validationError: ValidationError;\n\n switch (error.keyword) {\n case 'additionalProperties': {\n const additionalProp = error.params.additionalProperty;\n const suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', '');\n const { properties } = safeJsonPointer({\n object: schema,\n pnter: suggestionPointer,\n fallback: { properties: {} },\n });\n validationError = {\n message: `'${additionalProp}' property is not expected to be here`,\n suggestion: getSuggestion({\n value: additionalProp,\n suggestions: Object.keys(properties ?? {}),\n format: (suggestion) => `Did you mean property '${suggestion}'?`,\n }),\n path,\n context: defaultContext,\n };\n break;\n }\n case 'enum': {\n const suggestions = error.params.allowedValues.map((value) => String(value ?? ''));\n const prop = getLastSegment(error.instancePath);\n const value = safeJsonPointer({ object: data, pnter: error.instancePath, fallback: '' });\n validationError = {\n message: `'${prop}' property must be equal to one of the allowed values`,\n suggestion: getSuggestion({\n value,\n suggestions,\n }),\n path,\n context: {\n ...defaultContext,\n allowedValues: error.params.allowedValues,\n },\n };\n break;\n }\n case 'type': {\n const prop = getLastSegment(error.instancePath);\n const type = error.params.type;\n validationError = {\n message: `'${prop}' property type must be ${type}`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'required': {\n validationError = {\n message: `${path} must have required property '${error.params.missingProperty}'`,\n path,\n context: defaultContext,\n };\n break;\n }\n case 'const': {\n return {\n message: `'${prop}' property must be equal to the allowed value`,\n path,\n context: {\n ...defaultContext,\n allowedValue: error.params.allowedValue,\n },\n };\n }\n\n default:\n return { message: defaultMessage, path, context: defaultContext };\n }\n\n // Remove empty properties\n const errorEntries = Object.entries(validationError);\n for (const [key, value] of errorEntries as [keyof ValidationError, unknown][]) {\n if (value === null || value === undefined || value === '') {\n delete validationError[key];\n }\n }\n\n return validationError;\n });\n};\n\nexport { ValidationError };\n"],"names":["AJV_ERROR_KEYWORD_WEIGHT_MAP","type","QUOTES_REGEX","NOT_REGEX","SLASH_REGEX","filterSingleErrorPerProperty","errors","errorsPerProperty","reduce","acc","error","prop","instancePath","params","additionalProperty","missingProperty","existingError","weight","keyword","existingWeight","Object","values","getSuggestion","value","suggestions","format","suggestion","bestSuggestion","best","current","distance","leven","Infinity","length","pointerToDotNotation","pointer","replace","cleanAjvMessage","message","getLastSegment","path","segments","split","pop","safeJsonPointer","object","pnter","fallback","get","err","betterAjvErrors","data","schema","basePath","Array","isArray","definedErrors","map","defaultContext","errorType","defaultMessage","validationError","additionalProp","suggestionPointer","schemaPath","properties","keys","context","allowedValues","String","allowedValue","errorEntries","entries","key","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAEO,IAAMA,4BAA4B,GAAqD;EAC5F,QAAM,CADsF;EAE5FC,IAAI,EAAE;AAFsF,CAAvF;AAKA,IAAMC,YAAY,GAAG,IAArB;AACA,IAAMC,SAAS,GAAG,MAAlB;AACA,IAAMC,WAAW,GAAG,KAApB;;ACNA,IAAMC,4BAA4B,GAAG,SAA/BA,4BAA+B,CAACC,MAAD;EAC1C,IAAMC,iBAAiB,GAAGD,MAAM,CAACE,MAAP,CAA4C,UAACC,GAAD,EAAMC,KAAN;;;IACpE,IAAMC,IAAI,GACRD,KAAK,CAACE,YAAN,sDAAuBF,KAAK,CAACG,MAA7B,qBAAuB,cAAsBC,kBAA7C,sDAAoEJ,KAAK,CAACG,MAA1E,qBAAoE,eAAsBE,eAA1F,mBAA6G,EAA7G,CADF;IAEA,IAAMC,aAAa,GAAGP,GAAG,CAACE,IAAD,CAAzB;;IACA,IAAI,CAACK,aAAL,EAAoB;MAClBP,GAAG,CAACE,IAAD,CAAH,GAAYD,KAAZ;MACA,OAAOD,GAAP;;;IAEF,IAAMQ,MAAM,4BAAGjB,4BAA4B,CAACU,KAAK,CAACQ,OAAP,CAA/B,oCAAkD,CAA9D;IACA,IAAMC,cAAc,6BAAGnB,4BAA4B,CAACgB,aAAa,CAACE,OAAf,CAA/B,qCAA0D,CAA9E;;IAEA,IAAID,MAAM,GAAGE,cAAb,EAA6B;MAC3BV,GAAG,CAACE,IAAD,CAAH,GAAYD,KAAZ;;;IAEF,OAAOD,GAAP;GAdwB,EAevB,EAfuB,CAA1B;EAiBA,OAAOW,MAAM,CAACC,MAAP,CAAcd,iBAAd,CAAP;AACD,CAnBM;;ACDA,IAAMe,aAAa,GAAG,SAAhBA,aAAgB;MAC3BC,aAAAA;MACAC,mBAAAA;yBACAC;MAAAA,kCAAS,UAACC,UAAD;IAAA,0BAAiCA,UAAjC;;EAMT,IAAI,CAACH,KAAL,EAAY,OAAO,EAAP;EACZ,IAAMI,cAAc,GAAGH,WAAW,CAAChB,MAAZ,CACrB,UAACoB,IAAD,EAAOC,OAAP;IACE,IAAMC,QAAQ,GAAGC,KAAK,CAACR,KAAD,EAAQM,OAAR,CAAtB;;IACA,IAAID,IAAI,CAACE,QAAL,GAAgBA,QAApB,EAA8B;MAC5B,OAAO;QAAEP,KAAK,EAAEM,OAAT;QAAkBC,QAAQ,EAARA;OAAzB;;;IAGF,OAAOF,IAAP;GAPmB,EASrB;IACEE,QAAQ,EAAEE,QADZ;IAEET,KAAK,EAAE;GAXY,CAAvB;EAeA,OAAOI,cAAc,CAACG,QAAf,GAA0BP,KAAK,CAACU,MAAhC,GAAyCR,MAAM,CAACE,cAAc,CAACJ,KAAhB,CAA/C,GAAwE,EAA/E;AACD,CA1BM;;ACCA,IAAMW,oBAAoB,GAAG,SAAvBA,oBAAuB,CAACC,OAAD;EAClC,OAAOA,OAAO,CAACC,OAAR,CAAgBhC,WAAhB,EAA6B,GAA7B,CAAP;AACD,CAFM;AAIP,AAAO,IAAMiC,eAAe,GAAG,SAAlBA,eAAkB,CAACC,OAAD;EAC7B,OAAOA,OAAO,CAACF,OAAR,CAAgBlC,YAAhB,EAA8B,GAA9B,EAAmCkC,OAAnC,CAA2CjC,SAA3C,EAAsD,KAAtD,CAAP;AACD,CAFM;AAIP,AAAO,IAAMoC,cAAc,GAAG,SAAjBA,cAAiB,CAACC,IAAD;EAC5B,IAAMC,QAAQ,GAAGD,IAAI,CAACE,KAAL,CAAW,GAAX,CAAjB;EACA,OAAOD,QAAQ,CAACE,GAAT,EAAP;AACD,CAHM;AAKP,AAAO,IAAMC,eAAe,GAAG,SAAlBA,eAAkB;MAAMC,cAAAA;MAAQC,aAAAA;MAAOC,gBAAAA;;EAClD,IAAI;IACF,OAAOZ,OAAO,CAACa,GAAR,CAAYH,MAAZ,EAAoBC,KAApB,CAAP;GADF,CAEE,OAAOG,GAAP,EAAY;IACZ,OAAOF,QAAP;;AAEH,CANM;;ICHMG,eAAe,GAAG,SAAlBA,eAAkB;MAC7B5C,cAAAA;MACA6C,YAAAA;MACAC,cAAAA;2BACAC;MAAAA,sCAAW;;EAEX,IAAI,CAACC,KAAK,CAACC,OAAN,CAAcjD,MAAd,CAAD,IAA0BA,MAAM,CAAC2B,MAAP,KAAkB,CAAhD,EAAmD;IACjD,OAAO,EAAP;;;EAGF,IAAMuB,aAAa,GAAGnD,4BAA4B,CAACC,MAAD,CAAlD;EAEA,OAAOkD,aAAa,CAACC,GAAd,CAAkB,UAAC/C,KAAD;IACvB,IAAM8B,IAAI,GAAGN,oBAAoB,CAACmB,QAAQ,GAAG3C,KAAK,CAACE,YAAlB,CAAjC;IACA,IAAMD,IAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;IACA,IAAM8C,cAAc,GAAG;MACrBC,SAAS,EAAEjD,KAAK,CAACQ;KADnB;IAGA,IAAM0C,cAAc,IAAMjD,IAAI,kBAAgBA,IAAhB,SAA0B6B,IAApC,UAA4CH,eAAe,CAAC3B,KAAK,CAAC4B,OAAP,CAA/E;IAEA,IAAIuB,eAAJ;;IAEA,QAAQnD,KAAK,CAACQ,OAAd;MACE,KAAK,sBAAL;QAA6B;UAC3B,IAAM4C,cAAc,GAAGpD,KAAK,CAACG,MAAN,CAAaC,kBAApC;UACA,IAAMiD,iBAAiB,GAAGrD,KAAK,CAACsD,UAAN,CAAiB5B,OAAjB,CAAyB,GAAzB,EAA8B,EAA9B,EAAkCA,OAAlC,CAA0C,uBAA1C,EAAmE,EAAnE,CAA1B;;UACA,uBAAuBQ,eAAe,CAAC;YACrCC,MAAM,EAAEO,MAD6B;YAErCN,KAAK,EAAEiB,iBAF8B;YAGrChB,QAAQ,EAAE;cAAEkB,UAAU,EAAE;;WAHY,CAAtC;cAAQA,UAAR,oBAAQA,UAAR;;UAKAJ,eAAe,GAAG;YAChBvB,OAAO,QAAMwB,cAAN,0CADS;YAEhBpC,UAAU,EAAEJ,aAAa,CAAC;cACxBC,KAAK,EAAEuC,cADiB;cAExBtC,WAAW,EAAEJ,MAAM,CAAC8C,IAAP,CAAYD,UAAZ,WAAYA,UAAZ,GAA0B,EAA1B,CAFW;cAGxBxC,MAAM,EAAE,gBAACC,UAAD;gBAAA,mCAA0CA,UAA1C;;aAHe,CAFT;YAOhBc,IAAI,EAAJA,IAPgB;YAQhB2B,OAAO,EAAET;WARX;UAUA;;;MAEF,KAAK,MAAL;QAAa;UACX,IAAMlC,WAAW,GAAGd,KAAK,CAACG,MAAN,CAAauD,aAAb,CAA2BX,GAA3B,CAA+B,UAAClC,KAAD;YAAA,OAAW8C,MAAM,CAAC9C,KAAD,WAACA,KAAD,GAAU,EAAV,CAAjB;WAA/B,CAApB;;UACA,IAAMZ,KAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;;UACA,IAAMW,KAAK,GAAGqB,eAAe,CAAC;YAAEC,MAAM,EAAEM,IAAV;YAAgBL,KAAK,EAAEpC,KAAK,CAACE,YAA7B;YAA2CmC,QAAQ,EAAE;WAAtD,CAA7B;UACAc,eAAe,GAAG;YAChBvB,OAAO,QAAM3B,KAAN,0DADS;YAEhBe,UAAU,EAAEJ,aAAa,CAAC;cACxBC,KAAK,EAALA,KADwB;cAExBC,WAAW,EAAXA;aAFuB,CAFT;YAMhBgB,IAAI,EAAJA,IANgB;YAOhB2B,OAAO,eACFT,cADE;cAELU,aAAa,EAAE1D,KAAK,CAACG,MAAN,CAAauD;;WAThC;UAYA;;;MAEF,KAAK,MAAL;QAAa;UACX,IAAMzD,MAAI,GAAG4B,cAAc,CAAC7B,KAAK,CAACE,YAAP,CAA3B;;UACA,IAAMX,IAAI,GAAGS,KAAK,CAACG,MAAN,CAAaZ,IAA1B;UACA4D,eAAe,GAAG;YAChBvB,OAAO,QAAM3B,MAAN,gCAAqCV,IAD5B;YAEhBuC,IAAI,EAAJA,IAFgB;YAGhB2B,OAAO,EAAET;WAHX;UAKA;;;MAEF,KAAK,UAAL;QAAiB;UACfG,eAAe,GAAG;YAChBvB,OAAO,EAAKE,IAAL,sCAA0C9B,KAAK,CAACG,MAAN,CAAaE,eAAvD,MADS;YAEhByB,IAAI,EAAJA,IAFgB;YAGhB2B,OAAO,EAAET;WAHX;UAKA;;;MAEF,KAAK,OAAL;QAAc;UACZ,OAAO;YACLpB,OAAO,QAAM3B,IAAN,kDADF;YAEL6B,IAAI,EAAJA,IAFK;YAGL2B,OAAO,eACFT,cADE;cAELY,YAAY,EAAE5D,KAAK,CAACG,MAAN,CAAayD;;WAL/B;;;MAUF;QACE,OAAO;UAAEhC,OAAO,EAAEsB,cAAX;UAA2BpB,IAAI,EAAJA,IAA3B;UAAiC2B,OAAO,EAAET;SAAjD;;;;IAIJ,IAAMa,YAAY,GAAGnD,MAAM,CAACoD,OAAP,CAAeX,eAAf,CAArB;;IACA,iCAA2BU,YAA3B,mCAA+E;MAA1E;UAAOE,GAAP;UAAYlD,MAAZ;;MACH,IAAIA,MAAK,KAAK,IAAV,IAAkBA,MAAK,KAAKmD,SAA5B,IAAyCnD,MAAK,KAAK,EAAvD,EAA2D;QACzD,OAAOsC,eAAe,CAACY,GAAD,CAAtB;;;;IAIJ,OAAOZ,eAAP;GA1FK,CAAP;AA4FD,CAxGM;;;;"} \ No newline at end of file diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/constants.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/constants.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..93196934e19a272c118bb0a36a935ec553b7df58 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/constants.d.ts @@ -0,0 +1,5 @@ +import { DefinedError } from 'ajv'; +export declare const AJV_ERROR_KEYWORD_WEIGHT_MAP: Partial>; +export declare const QUOTES_REGEX: RegExp; +export declare const NOT_REGEX: RegExp; +export declare const SLASH_REGEX: RegExp; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..952aa481e351034cfe9ee428eadd44bedc62226e --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.d.ts @@ -0,0 +1,10 @@ +import { ErrorObject } from 'ajv'; +import { ValidationError } from './types/ValidationError'; +export interface BetterAjvErrorsOptions { + errors: ErrorObject[] | null | undefined; + data: any; + schema: S; + basePath?: string; +} +export declare const betterAjvErrors: ({ errors, data, schema, basePath, }: BetterAjvErrorsOptions) => ValidationError[]; +export { ValidationError }; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.js b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..90749be7fc314ffcdb1b91477a433790219ff9f4 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/index.js @@ -0,0 +1,8 @@ + +'use strict' + +if (process.env.NODE_ENV === 'production') { + module.exports = require('./better-ajv-errors.cjs.production.min.js') +} else { + module.exports = require('./better-ajv-errors.cjs.development.js') +} diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/filter.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/filter.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e7191f7d12d125c2d90d2f3fb12551d0f1d0033f --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/filter.d.ts @@ -0,0 +1,2 @@ +import { DefinedError } from 'ajv'; +export declare const filterSingleErrorPerProperty: (errors: DefinedError[]) => DefinedError[]; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/suggestions.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/suggestions.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..94f77b6fdeff00db682ad079051d983641d43d31 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/suggestions.d.ts @@ -0,0 +1,5 @@ +export declare const getSuggestion: ({ value, suggestions, format, }: { + value: string | null; + suggestions: string[]; + format?: ((suggestion: string) => string) | undefined; +}) => string; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/utils.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/utils.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02a0f0871eab1065e0f1983ef2199e6f5d15bcb0 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/lib/utils.d.ts @@ -0,0 +1,8 @@ +export declare const pointerToDotNotation: (pointer: string) => string; +export declare const cleanAjvMessage: (message: string) => string; +export declare const getLastSegment: (path: string) => string; +export declare const safeJsonPointer: ({ object, pnter, fallback }: { + object: any; + pnter: string; + fallback: T; +}) => T; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/dist/types/ValidationError.d.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/types/ValidationError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..65ad6fc739bbbae083298d90c89c738bd94aeb35 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/dist/types/ValidationError.d.ts @@ -0,0 +1,10 @@ +import { DefinedError } from 'ajv'; +export interface ValidationError { + message: string; + path: string; + suggestion?: string; + context: { + errorType: DefinedError['keyword']; + [additionalContext: string]: unknown; + }; +} diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/package.json b/tools/ui/node_modules/@apideck/better-ajv-errors/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1d2ceb3170d2697ed4420979b660a7a5e42e6f7a --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/package.json @@ -0,0 +1,88 @@ +{ + "name": "@apideck/better-ajv-errors", + "description": "Human-friendly JSON Schema validation for APIs", + "version": "0.3.7", + "author": "Apideck (https://apideck.com/)", + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/apideck-libraries/better-ajv-errors" + }, + "bugs": { + "url": "https://github.com/apideck-libraries/better-ajv-errors/issues" + }, + "contributors": [ + "Elias Meire " + ], + "main": "dist/index.js", + "module": "dist/better-ajv-errors.esm.js", + "typings": "dist/index.d.ts", + "files": [ + "dist", + "src" + ], + "engines": { + "node": ">=10" + }, + "scripts": { + "start": "tsdx watch", + "build": "tsdx build", + "test": "tsdx test", + "lint": "tsdx lint", + "prepare": "tsdx build", + "size": "size-limit", + "release": "np --no-publish && npm publish --access public --registry https://registry.npmjs.org", + "analyze": "size-limit --why" + }, + "husky": { + "hooks": { + "pre-commit": "tsdx lint" + } + }, + "prettier": { + "printWidth": 120, + "singleQuote": true, + "trailingComma": "es5" + }, + "size-limit": [ + { + "path": "dist/better-ajv-errors.cjs.production.min.js", + "limit": "2 KB" + }, + { + "path": "dist/better-ajv-errors.esm.js", + "limit": "2.5 KB" + } + ], + "devDependencies": { + "@size-limit/preset-small-lib": "^7.0.8", + "ajv": "^8.11.0", + "eslint-plugin-prettier": "^4.0.0", + "husky": "^8.0.1", + "np": "^7.6.1", + "size-limit": "^7.0.8", + "tsdx": "^0.14.1", + "json-schema": "^0.4.0", + "tslib": "^2.4.0", + "typescript": "^4.7.2" + }, + "peerDependencies": { + "ajv": ">=8" + }, + "dependencies": { + "jsonpointer": "^5.0.1", + "leven": "^3.1.0" + }, + "resolutions": { + "prettier": "^2.3.0" + }, + "keywords": [ + "apideck", + "ajv", + "json", + "schema", + "json-schema", + "errors", + "human" + ] +} diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/constants.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/constants.ts new file mode 100644 index 0000000000000000000000000000000000000000..947296b6580cf8f6562713b2c86e8a65dd423ffa --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/constants.ts @@ -0,0 +1,10 @@ +import { DefinedError } from 'ajv'; + +export const AJV_ERROR_KEYWORD_WEIGHT_MAP: Partial> = { + enum: 1, + type: 0, +}; + +export const QUOTES_REGEX = /"/g; +export const NOT_REGEX = /NOT/g; +export const SLASH_REGEX = /\//g; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.test.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..191c407f9ca8d668402587ae8feaa3d205130448 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.test.ts @@ -0,0 +1,484 @@ +import Ajv from 'ajv'; +import { JSONSchema6 } from 'json-schema'; +import { betterAjvErrors } from './index'; + +describe('betterAjvErrors', () => { + let ajv: Ajv; + let schema: JSONSchema6; + let data: Record; + + beforeEach(() => { + ajv = new Ajv({ allErrors: true }); + schema = { + type: 'object', + required: ['str'], + properties: { + str: { + type: 'string', + }, + enum: { + type: 'string', + enum: ['one', 'two'], + }, + bounds: { + type: 'number', + minimum: 2, + maximum: 4, + }, + nested: { + type: 'object', + required: ['deepReq'], + properties: { + deepReq: { + type: 'boolean', + }, + deep: { + type: 'string', + }, + }, + additionalProperties: false, + }, + }, + additionalProperties: false, + }; + }); + + describe('combined schemas', () => { + it('should handle type errors', () => { + data = { + str: 123, + }; + const combinedSchema = {type: 'boolean'}; + const validateCombined = ajv.addSchema(combinedSchema).compile(schema); + validateCombined(data); + const betterErrors = betterAjvErrors({ data, schema, errors: validateCombined.errors }); + expect(betterErrors).toEqual([ + { + context: { + errorType: 'type', + }, + message: "'str' property type must be string", + path: '{base}.str', + }, + ]); + }); + }); + describe('additionalProperties', () => { + it('should handle additionalProperties=false', () => { + data = { + str: 'str', + foo: 'bar', + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'additionalProperties', + }, + message: "'foo' property is not expected to be here", + path: '{base}', + }, + ]); + }); + + it('should handle additionalProperties=true', () => { + data = { + str: 'str', + foo: 'bar', + }; + schema.additionalProperties = true; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([]); + }); + + it('should give suggestions when relevant', () => { + data = { + str: 'str', + bonds: 'bar', + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'additionalProperties', + }, + message: "'bonds' property is not expected to be here", + path: '{base}', + suggestion: "Did you mean property 'bounds'?", + }, + ]); + }); + + it('should handle object schemas without properties', () => { + data = { + empty: { foo: 1 }, + }; + schema = { + type: 'object', + properties: { + empty: { + type: 'object', + additionalProperties: false, + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'additionalProperties', + }, + message: "'foo' property is not expected to be here", + path: '{base}.empty', + }, + ]); + }); + }); + + describe('required', () => { + it('should handle required properties', () => { + data = { + nested: {}, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'required', + }, + message: "{base} must have required property 'str'", + path: '{base}', + }, + { + context: { + errorType: 'required', + }, + message: "{base}.nested must have required property 'deepReq'", + path: '{base}.nested', + }, + ]); + }); + + it('should handle multiple required properties', () => { + schema = { + type: 'object', + required: ['req1', 'req2'], + properties: { + req1: { + type: 'string', + }, + req2: { + type: 'string', + }, + }, + }; + data = {}; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'required', + }, + message: "{base} must have required property 'req1'", + path: '{base}', + }, + { + context: { + errorType: 'required', + }, + message: "{base} must have required property 'req2'", + path: '{base}', + }, + ]); + }); + }); + + describe('type', () => { + it('should handle type errors', () => { + data = { + str: 123, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'type', + }, + message: "'str' property type must be string", + path: '{base}.str', + }, + ]); + }); + }); + + describe('minimum/maximum', () => { + it('should handle minimum/maximum errors', () => { + data = { + str: 'str', + bounds: 123, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'maximum', + }, + message: "property 'bounds' must be <= 4", + path: '{base}.bounds', + }, + ]); + }); + }); + + describe('enum', () => { + it('should handle enum errors', () => { + data = { + str: 'str', + enum: 'zzzz', + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'enum', + allowedValues: ['one', 'two'], + }, + message: "'enum' property must be equal to one of the allowed values", + path: '{base}.enum', + }, + ]); + }); + + it('should provide suggestions when relevant', () => { + data = { + str: 'str', + enum: 'pne', + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'enum', + allowedValues: ['one', 'two'], + }, + message: "'enum' property must be equal to one of the allowed values", + path: '{base}.enum', + suggestion: "Did you mean 'one'?", + }, + ]); + }); + + it('should not crash when allowedValues contains null', () => { + data = { + str: 'str', + enum: 'invalid', + }; + schema = { + type: 'object', + properties: { + str: { type: 'string' }, + enum: { + type: ['string', 'null'], + enum: ['one', 'two', null], + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'enum', + allowedValues: ['one', 'two', null], + }, + message: "'enum' property must be equal to one of the allowed values", + path: '{base}.enum', + suggestion: "Did you mean 'one'?", + }, + ]); + }); + + it('should not crash on null value', () => { + data = { + type: null, + }; + schema = { + type: 'object', + properties: { + type: { + type: 'string', + enum: ['primary', 'secondary'], + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + allowedValues: ['primary', 'secondary'], + errorType: 'enum', + }, + message: "'type' property must be equal to one of the allowed values", + path: '{base}.type', + }, + ]); + }); + }); + + it('should handle array paths', () => { + data = { + custom: [{ foo: 'bar' }, { aaa: 'zzz' }], + }; + schema = { + type: 'object', + properties: { + custom: { + type: 'array', + items: { + type: 'object', + additionalProperties: false, + properties: { + id: { + type: 'string', + }, + title: { + type: 'string', + }, + }, + }, + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'additionalProperties', + }, + message: "'foo' property is not expected to be here", + path: '{base}.custom.0', + }, + { + context: { + errorType: 'additionalProperties', + }, + message: "'aaa' property is not expected to be here", + path: '{base}.custom.1', + }, + ]); + }); + + it('should handle file $refs', () => { + data = { + child: [{ foo: 'bar' }, { aaa: 'zzz' }], + }; + schema = { + $id: 'http://example.com/schemas/Main.json', + type: 'object', + properties: { + child: { + type: 'array', + items: { + $ref: './Child.json', + }, + }, + }, + }; + ajv.addSchema({ + $id: 'http://example.com/schemas/Child.json', + additionalProperties: false, + type: 'object', + properties: { + id: { + type: 'string', + }, + }, + }); + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + errorType: 'additionalProperties', + }, + message: "'foo' property is not expected to be here", + path: '{base}.child.0', + }, + { + context: { + errorType: 'additionalProperties', + }, + message: "'aaa' property is not expected to be here", + path: '{base}.child.1', + }, + ]); + }); + + it('should handle number enums', () => { + data = { + isLive: 2, + }; + schema = { + type: 'object', + properties: { + isLive: { + type: 'integer', + enum: [0, 1], + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + allowedValues: [0, 1], + errorType: 'enum', + }, + message: "'isLive' property must be equal to one of the allowed values", + path: '{base}.isLive', + }, + ]); + }); + + describe('const', () => { + it('should handle const errors', () => { + data = { + const: 2, + }; + schema = { + type: 'object', + properties: { + const: { + type: 'integer', + const: 42, + }, + }, + }; + ajv.validate(schema, data); + const errors = betterAjvErrors({ data, schema, errors: ajv.errors }); + expect(errors).toEqual([ + { + context: { + allowedValue: 42, + errorType: 'const', + }, + message: "'const' property must be equal to the allowed value", + path: '{base}.const', + }, + ]); + }); + }); +}); diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..bd53d69077038c353a5a8b339dc38ed76480f1fb --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/index.ts @@ -0,0 +1,120 @@ +import { DefinedError, ErrorObject } from 'ajv'; +import { ValidationError } from './types/ValidationError'; +import { filterSingleErrorPerProperty } from './lib/filter'; +import { getSuggestion } from './lib/suggestions'; +import { cleanAjvMessage, getLastSegment, pointerToDotNotation, safeJsonPointer } from './lib/utils'; + +export interface BetterAjvErrorsOptions { + errors: ErrorObject[] | null | undefined; + data: any; + schema: S; + basePath?: string; +} + +export const betterAjvErrors = ({ + errors, + data, + schema, + basePath = '{base}', +}: BetterAjvErrorsOptions): ValidationError[] => { + if (!Array.isArray(errors) || errors.length === 0) { + return []; + } + + const definedErrors = filterSingleErrorPerProperty(errors as DefinedError[]); + + return definedErrors.map((error) => { + const path = pointerToDotNotation(basePath + error.instancePath); + const prop = getLastSegment(error.instancePath); + const defaultContext = { + errorType: error.keyword, + }; + const defaultMessage = `${prop ? `property '${prop}'` : path} ${cleanAjvMessage(error.message as string)}`; + + let validationError: ValidationError; + + switch (error.keyword) { + case 'additionalProperties': { + const additionalProp = error.params.additionalProperty; + const suggestionPointer = error.schemaPath.replace('#', '').replace('/additionalProperties', ''); + const { properties } = safeJsonPointer({ + object: schema, + pnter: suggestionPointer, + fallback: { properties: {} }, + }); + validationError = { + message: `'${additionalProp}' property is not expected to be here`, + suggestion: getSuggestion({ + value: additionalProp, + suggestions: Object.keys(properties ?? {}), + format: (suggestion) => `Did you mean property '${suggestion}'?`, + }), + path, + context: defaultContext, + }; + break; + } + case 'enum': { + const suggestions = error.params.allowedValues.map((value) => String(value ?? '')); + const prop = getLastSegment(error.instancePath); + const value = safeJsonPointer({ object: data, pnter: error.instancePath, fallback: '' }); + validationError = { + message: `'${prop}' property must be equal to one of the allowed values`, + suggestion: getSuggestion({ + value, + suggestions, + }), + path, + context: { + ...defaultContext, + allowedValues: error.params.allowedValues, + }, + }; + break; + } + case 'type': { + const prop = getLastSegment(error.instancePath); + const type = error.params.type; + validationError = { + message: `'${prop}' property type must be ${type}`, + path, + context: defaultContext, + }; + break; + } + case 'required': { + validationError = { + message: `${path} must have required property '${error.params.missingProperty}'`, + path, + context: defaultContext, + }; + break; + } + case 'const': { + return { + message: `'${prop}' property must be equal to the allowed value`, + path, + context: { + ...defaultContext, + allowedValue: error.params.allowedValue, + }, + }; + } + + default: + return { message: defaultMessage, path, context: defaultContext }; + } + + // Remove empty properties + const errorEntries = Object.entries(validationError); + for (const [key, value] of errorEntries as [keyof ValidationError, unknown][]) { + if (value === null || value === undefined || value === '') { + delete validationError[key]; + } + } + + return validationError; + }); +}; + +export { ValidationError }; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/filter.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/filter.ts new file mode 100644 index 0000000000000000000000000000000000000000..8110ce211c201d7401f4a95bd2ec967a787f3fa2 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/filter.ts @@ -0,0 +1,23 @@ +import { DefinedError } from 'ajv'; +import { AJV_ERROR_KEYWORD_WEIGHT_MAP } from '../constants'; + +export const filterSingleErrorPerProperty = (errors: DefinedError[]): DefinedError[] => { + const errorsPerProperty = errors.reduce>((acc, error) => { + const prop = + error.instancePath + ((error.params as any)?.additionalProperty ?? (error.params as any)?.missingProperty ?? ''); + const existingError = acc[prop]; + if (!existingError) { + acc[prop] = error; + return acc; + } + const weight = AJV_ERROR_KEYWORD_WEIGHT_MAP[error.keyword] ?? 0; + const existingWeight = AJV_ERROR_KEYWORD_WEIGHT_MAP[existingError.keyword] ?? 0; + + if (weight > existingWeight) { + acc[prop] = error; + } + return acc; + }, {}); + + return Object.values(errorsPerProperty); +}; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/suggestions.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/suggestions.ts new file mode 100644 index 0000000000000000000000000000000000000000..07688670a2026aacbbb2eb4b296d89fe6560e49a --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/suggestions.ts @@ -0,0 +1,29 @@ +import leven from 'leven'; + +export const getSuggestion = ({ + value, + suggestions, + format = (suggestion) => `Did you mean '${suggestion}'?`, +}: { + value: string | null; + suggestions: string[]; + format?: (suggestion: string) => string; +}): string => { + if (!value) return ''; + const bestSuggestion = suggestions.reduce( + (best, current) => { + const distance = leven(value, current); + if (best.distance > distance) { + return { value: current, distance }; + } + + return best; + }, + { + distance: Infinity, + value: '', + } + ); + + return bestSuggestion.distance < value.length ? format(bestSuggestion.value) : ''; +}; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/utils.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..2baf5d9bed8cdac8e3b328e89d9848d384787cda --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/lib/utils.ts @@ -0,0 +1,23 @@ +import { NOT_REGEX, QUOTES_REGEX, SLASH_REGEX } from '../constants'; +import pointer from 'jsonpointer'; + +export const pointerToDotNotation = (pointer: string): string => { + return pointer.replace(SLASH_REGEX, '.'); +}; + +export const cleanAjvMessage = (message: string): string => { + return message.replace(QUOTES_REGEX, "'").replace(NOT_REGEX, 'not'); +}; + +export const getLastSegment = (path: string): string => { + const segments = path.split('/'); + return segments.pop() as string; +}; + +export const safeJsonPointer = ({ object, pnter, fallback }: { object: any; pnter: string; fallback: T }): T => { + try { + return pointer.get(object, pnter); + } catch (err) { + return fallback; + } +}; diff --git a/tools/ui/node_modules/@apideck/better-ajv-errors/src/types/ValidationError.ts b/tools/ui/node_modules/@apideck/better-ajv-errors/src/types/ValidationError.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f8e4c3a46a6f0900ce52f0607f222a853b683d9 --- /dev/null +++ b/tools/ui/node_modules/@apideck/better-ajv-errors/src/types/ValidationError.ts @@ -0,0 +1,11 @@ +import { DefinedError } from 'ajv'; + +export interface ValidationError { + message: string; + path: string; + suggestion?: string; + context: { + errorType: DefinedError['keyword']; + [additionalContext: string]: unknown; + }; +} diff --git a/tools/ui/node_modules/@babel/code-frame/LICENSE b/tools/ui/node_modules/@babel/code-frame/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/tools/ui/node_modules/@babel/code-frame/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/@babel/code-frame/README.md b/tools/ui/node_modules/@babel/code-frame/README.md new file mode 100644 index 0000000000000000000000000000000000000000..7160755113aaa771161a0626a7a9c7b6a99ac8d8 --- /dev/null +++ b/tools/ui/node_modules/@babel/code-frame/README.md @@ -0,0 +1,19 @@ +# @babel/code-frame + +> Generate errors that contain a code frame that point to source locations. + +See our website [@babel/code-frame](https://babeljs.io/docs/babel-code-frame) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/code-frame +``` + +or using yarn: + +```sh +yarn add @babel/code-frame --dev +``` diff --git a/tools/ui/node_modules/@babel/code-frame/lib/index.js b/tools/ui/node_modules/@babel/code-frame/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9c5db40650ce1a02ad39ad125e1b32f01e4eea64 --- /dev/null +++ b/tools/ui/node_modules/@babel/code-frame/lib/index.js @@ -0,0 +1,217 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var picocolors = require('picocolors'); +var jsTokens = require('js-tokens'); +var helperValidatorIdentifier = require('@babel/helper-validator-identifier'); + +function isColorSupported() { + return (typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported + ); +} +const compose = (f, g) => v => f(g(v)); +function buildDefs(colors) { + return { + keyword: colors.cyan, + capitalized: colors.yellow, + jsxIdentifier: colors.yellow, + punctuator: colors.yellow, + number: colors.magenta, + string: colors.green, + regex: colors.magenta, + comment: colors.gray, + invalid: compose(compose(colors.white, colors.bgRed), colors.bold), + gutter: colors.gray, + marker: compose(colors.red, colors.bold), + message: compose(colors.red, colors.bold), + reset: colors.reset + }; +} +const defsOn = buildDefs(picocolors.createColors(true)); +const defsOff = buildDefs(picocolors.createColors(false)); +function getDefs(enabled) { + return enabled ? defsOn : defsOff; +} + +const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]); +const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/; +const BRACKET = /^[()[\]{}]$/; +let tokenize; +const JSX_TAG = /^[a-z][\w-]*$/i; +const getTokenType = function (token, offset, text) { + if (token.type === "name") { + const tokenValue = token.value; + if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) { + return "keyword"; + } + if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === " defs[type](str)).join("\n"); + } else { + highlighted += value; + } + } + return highlighted; +} + +let deprecationWarningShown = false; +const NEWLINE = /\r\n|[\n\r\u2028\u2029]/; +function getMarkerLines(loc, source, opts, startLineBaseZero) { + const startLoc = Object.assign({ + column: 0, + line: -1 + }, loc.start); + const endLoc = Object.assign({}, startLoc, loc.end); + const { + linesAbove = 2, + linesBelow = 3 + } = opts || {}; + const startLine = startLoc.line - startLineBaseZero; + const startColumn = startLoc.column; + const endLine = endLoc.line - startLineBaseZero; + const endColumn = endLoc.column; + let start = Math.max(startLine - (linesAbove + 1), 0); + let end = Math.min(source.length, endLine + linesBelow); + if (startLine === -1) { + start = 0; + } + if (endLine === -1) { + end = source.length; + } + const lineDiff = endLine - startLine; + const markerLines = {}; + if (lineDiff) { + for (let i = 0; i <= lineDiff; i++) { + const lineNumber = i + startLine; + if (!startColumn) { + markerLines[lineNumber] = true; + } else if (i === 0) { + const sourceLength = source[lineNumber - 1].length; + markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1]; + } else if (i === lineDiff) { + markerLines[lineNumber] = [0, endColumn]; + } else { + const sourceLength = source[lineNumber - i].length; + markerLines[lineNumber] = [0, sourceLength]; + } + } + } else { + if (startColumn === endColumn) { + if (startColumn) { + markerLines[startLine] = [startColumn, 0]; + } else { + markerLines[startLine] = true; + } + } else { + markerLines[startLine] = [startColumn, endColumn - startColumn]; + } + } + return { + start, + end, + markerLines + }; +} +function codeFrameColumns(rawLines, loc, opts = {}) { + const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode; + const startLineBaseZero = (opts.startLine || 1) - 1; + const defs = getDefs(shouldHighlight); + const lines = rawLines.split(NEWLINE); + const { + start, + end, + markerLines + } = getMarkerLines(loc, lines, opts, startLineBaseZero); + const hasColumns = loc.start && typeof loc.start.column === "number"; + const numberMaxWidth = String(end + startLineBaseZero).length; + const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines; + let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => { + const number = start + 1 + index; + const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth); + const gutter = ` ${paddedNumber} |`; + const hasMarker = markerLines[number]; + const lastMarkerLine = !markerLines[number + 1]; + if (hasMarker) { + let markerLine = ""; + if (Array.isArray(hasMarker)) { + const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " "); + const numberOfMarkers = hasMarker[1] || 1; + markerLine = ["\n ", defs.gutter(gutter.replace(/\d/g, " ")), " ", markerSpacing, defs.marker("^").repeat(numberOfMarkers)].join(""); + if (lastMarkerLine && opts.message) { + markerLine += " " + defs.message(opts.message); + } + } + return [defs.marker(">"), defs.gutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join(""); + } else { + return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`; + } + }).join("\n"); + if (opts.message && !hasColumns) { + frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`; + } + if (shouldHighlight) { + return defs.reset(frame); + } else { + return frame; + } +} +function index (rawLines, lineNumber, colNumber, opts = {}) { + if (!deprecationWarningShown) { + deprecationWarningShown = true; + const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`."; + if (process.emitWarning) { + process.emitWarning(message, "DeprecationWarning"); + } else { + const deprecationError = new Error(message); + deprecationError.name = "DeprecationWarning"; + console.warn(new Error(message)); + } + } + colNumber = Math.max(colNumber, 0); + const location = { + start: { + column: colNumber, + line: lineNumber + } + }; + return codeFrameColumns(rawLines, location, opts); +} + +exports.codeFrameColumns = codeFrameColumns; +exports.default = index; +exports.highlight = highlight; +//# sourceMappingURL=index.js.map diff --git a/tools/ui/node_modules/@babel/code-frame/lib/index.js.map b/tools/ui/node_modules/@babel/code-frame/lib/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..6b85ae4957d58fb4115f8713e9c66639dffb50d9 --- /dev/null +++ b/tools/ui/node_modules/@babel/code-frame/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["../src/defs.ts","../src/highlight.ts","../src/index.ts"],"sourcesContent":["import picocolors, { createColors } from \"picocolors\";\nimport type { Colors, Formatter } from \"picocolors/types\";\n\nexport function isColorSupported() {\n return (\n // See https://github.com/alexeyraspopov/picocolors/issues/62\n typeof process === \"object\" &&\n (process.env.FORCE_COLOR === \"0\" || process.env.FORCE_COLOR === \"false\")\n ? false\n : picocolors.isColorSupported\n );\n}\n\nexport type InternalTokenType =\n | \"keyword\"\n | \"capitalized\"\n | \"jsxIdentifier\"\n | \"punctuator\"\n | \"number\"\n | \"string\"\n | \"regex\"\n | \"comment\"\n | \"invalid\";\n\ntype UITokens = \"gutter\" | \"marker\" | \"message\";\n\nexport type Defs = Record;\n\nconst compose: (f: (gv: U) => V, g: (v: T) => U) => (v: T) => V =\n (f, g) => v =>\n f(g(v));\n\n/**\n * Styles for token types.\n */\nfunction buildDefs(colors: Colors): Defs {\n return {\n keyword: colors.cyan,\n capitalized: colors.yellow,\n jsxIdentifier: colors.yellow,\n punctuator: colors.yellow,\n number: colors.magenta,\n string: colors.green,\n regex: colors.magenta,\n comment: colors.gray,\n invalid: compose(compose(colors.white, colors.bgRed), colors.bold),\n\n gutter: colors.gray,\n marker: compose(colors.red, colors.bold),\n message: compose(colors.red, colors.bold),\n\n reset: colors.reset,\n };\n}\n\nconst defsOn = buildDefs(createColors(true));\nconst defsOff = buildDefs(createColors(false));\n\nexport function getDefs(enabled: boolean): Defs {\n return enabled ? defsOn : defsOff;\n}\n","import type { Token as JSToken, JSXToken } from \"js-tokens\";\nimport jsTokens from \"js-tokens\";\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nimport {\n isStrictReservedWord,\n isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\nimport { getDefs, type InternalTokenType } from \"./defs.ts\";\n\n/**\n * Names that are always allowed as identifiers, but also appear as keywords\n * within certain syntactic productions.\n *\n * https://tc39.es/ecma262/#sec-keywords-and-reserved-words\n *\n * `target` has been omitted since it is very likely going to be a false\n * positive.\n */\nconst sometimesKeywords = new Set([\"as\", \"async\", \"from\", \"get\", \"of\", \"set\"]);\n\ntype Token = {\n type: InternalTokenType | \"uncolored\";\n value: string;\n};\n\n/**\n * RegExp to test for newlines in terminal.\n */\nconst NEWLINE = /\\r\\n|[\\n\\r\\u2028\\u2029]/;\n\n/**\n * RegExp to test for the three types of brackets.\n */\nconst BRACKET = /^[()[\\]{}]$/;\n\nlet tokenize: (\n text: string,\n) => Generator<{ type: InternalTokenType | \"uncolored\"; value: string }>;\n\nif (process.env.BABEL_8_BREAKING) {\n /**\n * Get the type of token, specifying punctuator type.\n */\n const getTokenType = function (\n token: JSToken | JSXToken,\n ): InternalTokenType | \"uncolored\" {\n if (token.type === \"IdentifierName\") {\n const tokenValue = token.value;\n if (\n isKeyword(tokenValue) ||\n isStrictReservedWord(tokenValue, true) ||\n sometimesKeywords.has(tokenValue)\n ) {\n return \"keyword\";\n }\n\n const firstChar = tokenValue.charCodeAt(0);\n if (firstChar < 128) {\n // ASCII characters\n if (\n firstChar >= charCodes.uppercaseA &&\n firstChar <= charCodes.uppercaseZ\n ) {\n return \"capitalized\";\n }\n } else {\n const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));\n if (firstChar !== firstChar.toLowerCase()) {\n return \"capitalized\";\n }\n }\n }\n\n if (token.type === \"Punctuator\" && BRACKET.test(token.value)) {\n return \"uncolored\";\n }\n\n if (token.type === \"Invalid\" && token.value === \"@\") {\n return \"punctuator\";\n }\n\n switch (token.type) {\n case \"NumericLiteral\":\n return \"number\";\n\n case \"StringLiteral\":\n case \"JSXString\":\n case \"NoSubstitutionTemplate\":\n return \"string\";\n\n case \"RegularExpressionLiteral\":\n return \"regex\";\n\n case \"Punctuator\":\n case \"JSXPunctuator\":\n return \"punctuator\";\n\n case \"MultiLineComment\":\n case \"SingleLineComment\":\n return \"comment\";\n\n case \"Invalid\":\n case \"JSXInvalid\":\n return \"invalid\";\n\n case \"JSXIdentifier\":\n return \"jsxIdentifier\";\n\n default:\n return \"uncolored\";\n }\n };\n\n /**\n * Turn a string of JS into an array of objects.\n */\n tokenize = function* (text: string): Generator {\n for (const token of jsTokens(text, { jsx: true })) {\n switch (token.type) {\n case \"TemplateHead\":\n yield { type: \"string\", value: token.value.slice(0, -2) };\n yield { type: \"punctuator\", value: \"${\" };\n break;\n\n case \"TemplateMiddle\":\n yield { type: \"punctuator\", value: \"}\" };\n yield { type: \"string\", value: token.value.slice(1, -2) };\n yield { type: \"punctuator\", value: \"${\" };\n break;\n\n case \"TemplateTail\":\n yield { type: \"punctuator\", value: \"}\" };\n yield { type: \"string\", value: token.value.slice(1) };\n break;\n\n default:\n yield {\n type: getTokenType(token),\n value: token.value,\n };\n }\n }\n };\n} else {\n /**\n * RegExp to test for what seems to be a JSX tag name.\n */\n const JSX_TAG = /^[a-z][\\w-]*$/i;\n\n // The token here is defined in js-tokens@4. However we don't bother\n // typing it since the whole block will be removed in Babel 8\n const getTokenType = function (token: any, offset: number, text: string) {\n if (token.type === \"name\") {\n const tokenValue = token.value;\n if (\n isKeyword(tokenValue) ||\n isStrictReservedWord(tokenValue, true) ||\n sometimesKeywords.has(tokenValue)\n ) {\n return \"keyword\";\n }\n\n if (\n JSX_TAG.test(tokenValue) &&\n (text[offset - 1] === \"<\" || text.slice(offset - 2, offset) === \" defs[type as InternalTokenType](str))\n .join(\"\\n\");\n } else {\n highlighted += value;\n }\n }\n\n return highlighted;\n}\n","import { getDefs, isColorSupported } from \"./defs.ts\";\nimport { highlight } from \"./highlight.ts\";\n\nexport { highlight };\n\nlet deprecationWarningShown = false;\n\ntype Location = {\n column: number;\n line: number;\n};\n\ntype NodeLocation = {\n end?: Location;\n start: Location;\n};\n\nexport interface Options {\n /** Syntax highlight the code as JavaScript for terminals. default: false */\n highlightCode?: boolean;\n /** The number of lines to show above the error. default: 2 */\n linesAbove?: number;\n /** The number of lines to show below the error. default: 3 */\n linesBelow?: number;\n /** The line number corresponding to the first line in `rawLines`. default: 1 */\n startLine?: number;\n /**\n * Forcibly syntax highlight the code as JavaScript (for non-terminals);\n * overrides highlightCode.\n * default: false\n */\n forceColor?: boolean;\n /**\n * Pass in a string to be displayed inline (if possible) next to the\n * highlighted location in the code. If it can't be positioned inline,\n * it will be placed above the code frame.\n * default: nothing\n */\n message?: string;\n}\n\n/**\n * RegExp to test for newlines in terminal.\n */\n\nconst NEWLINE = /\\r\\n|[\\n\\r\\u2028\\u2029]/;\n\n/**\n * Extract what lines should be marked and highlighted.\n */\n\ntype MarkerLines = Record;\n\nfunction getMarkerLines(\n loc: NodeLocation,\n source: string[],\n opts: Options,\n startLineBaseZero: number,\n): {\n start: number;\n end: number;\n markerLines: MarkerLines;\n} {\n const startLoc: Location = {\n column: 0,\n line: -1,\n ...loc.start,\n };\n const endLoc: Location = {\n ...startLoc,\n ...loc.end,\n };\n const { linesAbove = 2, linesBelow = 3 } = opts || {};\n const startLine = startLoc.line - startLineBaseZero;\n const startColumn = startLoc.column;\n const endLine = endLoc.line - startLineBaseZero;\n const endColumn = endLoc.column;\n\n let start = Math.max(startLine - (linesAbove + 1), 0);\n let end = Math.min(source.length, endLine + linesBelow);\n\n if (startLine === -1) {\n start = 0;\n }\n\n if (endLine === -1) {\n end = source.length;\n }\n\n const lineDiff = endLine - startLine;\n const markerLines: MarkerLines = {};\n\n if (lineDiff) {\n for (let i = 0; i <= lineDiff; i++) {\n const lineNumber = i + startLine;\n\n if (!startColumn) {\n markerLines[lineNumber] = true;\n } else if (i === 0) {\n const sourceLength = source[lineNumber - 1].length;\n\n markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];\n } else if (i === lineDiff) {\n markerLines[lineNumber] = [0, endColumn];\n } else {\n const sourceLength = source[lineNumber - i].length;\n\n markerLines[lineNumber] = [0, sourceLength];\n }\n }\n } else {\n if (startColumn === endColumn) {\n if (startColumn) {\n markerLines[startLine] = [startColumn, 0];\n } else {\n markerLines[startLine] = true;\n }\n } else {\n markerLines[startLine] = [startColumn, endColumn - startColumn];\n }\n }\n\n return { start, end, markerLines };\n}\n\nexport function codeFrameColumns(\n rawLines: string,\n loc: NodeLocation,\n opts: Options = {},\n): string {\n const shouldHighlight =\n opts.forceColor || (isColorSupported() && opts.highlightCode);\n const startLineBaseZero = (opts.startLine || 1) - 1;\n const defs = getDefs(shouldHighlight);\n\n const lines = rawLines.split(NEWLINE);\n const { start, end, markerLines } = getMarkerLines(\n loc,\n lines,\n opts,\n startLineBaseZero,\n );\n const hasColumns = loc.start && typeof loc.start.column === \"number\";\n\n const numberMaxWidth = String(end + startLineBaseZero).length;\n\n const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;\n\n let frame = highlightedLines\n .split(NEWLINE, end)\n .slice(start, end)\n .map((line, index) => {\n const number = start + 1 + index;\n const paddedNumber = ` ${number + startLineBaseZero}`.slice(\n -numberMaxWidth,\n );\n const gutter = ` ${paddedNumber} |`;\n const hasMarker = markerLines[number];\n const lastMarkerLine = !markerLines[number + 1];\n if (hasMarker) {\n let markerLine = \"\";\n if (Array.isArray(hasMarker)) {\n const markerSpacing = line\n .slice(0, Math.max(hasMarker[0] - 1, 0))\n .replace(/[^\\t]/g, \" \");\n const numberOfMarkers = hasMarker[1] || 1;\n\n markerLine = [\n \"\\n \",\n defs.gutter(gutter.replace(/\\d/g, \" \")),\n \" \",\n markerSpacing,\n defs.marker(\"^\").repeat(numberOfMarkers),\n ].join(\"\");\n\n if (lastMarkerLine && opts.message) {\n markerLine += \" \" + defs.message(opts.message);\n }\n }\n return [\n defs.marker(\">\"),\n defs.gutter(gutter),\n line.length > 0 ? ` ${line}` : \"\",\n markerLine,\n ].join(\"\");\n } else {\n return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : \"\"}`;\n }\n })\n .join(\"\\n\");\n\n if (opts.message && !hasColumns) {\n frame = `${\" \".repeat(numberMaxWidth + 1)}${opts.message}\\n${frame}`;\n }\n\n if (shouldHighlight) {\n return defs.reset(frame);\n } else {\n return frame;\n }\n}\n\n/**\n * Create a code frame, adding line numbers, code highlighting, and pointing to a given position.\n */\n\nexport default function (\n rawLines: string,\n lineNumber: number,\n colNumber?: number | null,\n opts: Options = {},\n): string {\n if (!deprecationWarningShown) {\n deprecationWarningShown = true;\n\n const message =\n \"Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.\";\n\n if (process.emitWarning) {\n // A string is directly supplied to emitWarning, because when supplying an\n // Error object node throws in the tests because of different contexts\n process.emitWarning(message, \"DeprecationWarning\");\n } else {\n const deprecationError = new Error(message);\n deprecationError.name = \"DeprecationWarning\";\n console.warn(new Error(message));\n }\n }\n\n colNumber = Math.max(colNumber, 0);\n\n const location: NodeLocation = {\n start: { column: colNumber, line: lineNumber },\n };\n\n return codeFrameColumns(rawLines, location, opts);\n}\n"],"names":["isColorSupported","process","env","FORCE_COLOR","picocolors","compose","f","g","v","buildDefs","colors","keyword","cyan","capitalized","yellow","jsxIdentifier","punctuator","number","magenta","string","green","regex","comment","gray","invalid","white","bgRed","bold","gutter","marker","red","message","reset","defsOn","createColors","defsOff","getDefs","enabled","sometimesKeywords","Set","NEWLINE","BRACKET","tokenize","JSX_TAG","getTokenType","token","offset","text","type","tokenValue","value","isKeyword","isStrictReservedWord","has","test","slice","firstChar","String","fromCodePoint","codePointAt","toLowerCase","match","jsTokens","default","exec","matchToToken","index","highlight","defs","highlighted","split","map","str","join","deprecationWarningShown","getMarkerLines","loc","source","opts","startLineBaseZero","startLoc","Object","assign","column","line","start","endLoc","end","linesAbove","linesBelow","startLine","startColumn","endLine","endColumn","Math","max","min","length","lineDiff","markerLines","i","lineNumber","sourceLength","codeFrameColumns","rawLines","shouldHighlight","forceColor","highlightCode","lines","hasColumns","numberMaxWidth","highlightedLines","frame","paddedNumber","hasMarker","lastMarkerLine","markerLine","Array","isArray","markerSpacing","replace","numberOfMarkers","repeat","colNumber","emitWarning","deprecationError","Error","name","console","warn","location"],"mappings":";;;;;;;;AAGO,SAASA,gBAAgBA,GAAG;EACjC,QAEE,OAAOC,OAAO,KAAK,QAAQ,KACxBA,OAAO,CAACC,GAAG,CAACC,WAAW,KAAK,GAAG,IAAIF,OAAO,CAACC,GAAG,CAACC,WAAW,KAAK,OAAO,CAAC,GACtE,KAAK,GACLC,UAAU,CAACJ,gBAAAA;AAAgB,IAAA;AAEnC,CAAA;AAiBA,MAAMK,OAAkE,GACtEA,CAACC,CAAC,EAAEC,CAAC,KAAKC,CAAC,IACTF,CAAC,CAACC,CAAC,CAACC,CAAC,CAAC,CAAC,CAAA;AAKX,SAASC,SAASA,CAACC,MAAc,EAAQ;EACvC,OAAO;IACLC,OAAO,EAAED,MAAM,CAACE,IAAI;IACpBC,WAAW,EAAEH,MAAM,CAACI,MAAM;IAC1BC,aAAa,EAAEL,MAAM,CAACI,MAAM;IAC5BE,UAAU,EAAEN,MAAM,CAACI,MAAM;IACzBG,MAAM,EAAEP,MAAM,CAACQ,OAAO;IACtBC,MAAM,EAAET,MAAM,CAACU,KAAK;IACpBC,KAAK,EAAEX,MAAM,CAACQ,OAAO;IACrBI,OAAO,EAAEZ,MAAM,CAACa,IAAI;AACpBC,IAAAA,OAAO,EAAEnB,OAAO,CAACA,OAAO,CAACK,MAAM,CAACe,KAAK,EAAEf,MAAM,CAACgB,KAAK,CAAC,EAAEhB,MAAM,CAACiB,IAAI,CAAC;IAElEC,MAAM,EAAElB,MAAM,CAACa,IAAI;IACnBM,MAAM,EAAExB,OAAO,CAACK,MAAM,CAACoB,GAAG,EAAEpB,MAAM,CAACiB,IAAI,CAAC;IACxCI,OAAO,EAAE1B,OAAO,CAACK,MAAM,CAACoB,GAAG,EAAEpB,MAAM,CAACiB,IAAI,CAAC;IAEzCK,KAAK,EAAEtB,MAAM,CAACsB,KAAAA;GACf,CAAA;AACH,CAAA;AAEA,MAAMC,MAAM,GAAGxB,SAAS,CAACyB,uBAAY,CAAC,IAAI,CAAC,CAAC,CAAA;AAC5C,MAAMC,OAAO,GAAG1B,SAAS,CAACyB,uBAAY,CAAC,KAAK,CAAC,CAAC,CAAA;AAEvC,SAASE,OAAOA,CAACC,OAAgB,EAAQ;AAC9C,EAAA,OAAOA,OAAO,GAAGJ,MAAM,GAAGE,OAAO,CAAA;AACnC;;ACtCA,MAAMG,iBAAiB,GAAG,IAAIC,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;AAU9E,MAAMC,SAAO,GAAG,yBAAyB,CAAA;AAKzC,MAAMC,OAAO,GAAG,aAAa,CAAA;AAE7B,IAAIC,QAEoE,CAAA;AA8GtE,MAAMC,OAAO,GAAG,gBAAgB,CAAA;AAIhC,MAAMC,YAAY,GAAG,UAAUC,KAAU,EAAEC,MAAc,EAAEC,IAAY,EAAE;AACvE,EAAA,IAAIF,KAAK,CAACG,IAAI,KAAK,MAAM,EAAE;AACzB,IAAA,MAAMC,UAAU,GAAGJ,KAAK,CAACK,KAAK,CAAA;AAC9B,IAAA,IACEC,mCAAS,CAACF,UAAU,CAAC,IACrBG,8CAAoB,CAACH,UAAU,EAAE,IAAI,CAAC,IACtCX,iBAAiB,CAACe,GAAG,CAACJ,UAAU,CAAC,EACjC;AACA,MAAA,OAAO,SAAS,CAAA;AAClB,KAAA;AAEA,IAAA,IACEN,OAAO,CAACW,IAAI,CAACL,UAAU,CAAC,KACvBF,IAAI,CAACD,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,IAAIC,IAAI,CAACQ,KAAK,CAACT,MAAM,GAAG,CAAC,EAAEA,MAAM,CAAC,KAAK,IAAI,CAAC,EACrE;AACA,MAAA,OAAO,eAAe,CAAA;AACxB,KAAA;AAEA,IAAA,MAAMU,SAAS,GAAGC,MAAM,CAACC,aAAa,CAACT,UAAU,CAACU,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;AACjE,IAAA,IAAIH,SAAS,KAAKA,SAAS,CAACI,WAAW,EAAE,EAAE;AACzC,MAAA,OAAO,aAAa,CAAA;AACtB,KAAA;AACF,GAAA;AAEA,EAAA,IAAIf,KAAK,CAACG,IAAI,KAAK,YAAY,IAAIP,OAAO,CAACa,IAAI,CAACT,KAAK,CAACK,KAAK,CAAC,EAAE;AAC5D,IAAA,OAAO,SAAS,CAAA;AAClB,GAAA;AAEA,EAAA,IACEL,KAAK,CAACG,IAAI,KAAK,SAAS,KACvBH,KAAK,CAACK,KAAK,KAAK,GAAG,IAAIL,KAAK,CAACK,KAAK,KAAK,GAAG,CAAC,EAC5C;AACA,IAAA,OAAO,YAAY,CAAA;AACrB,GAAA;EAEA,OAAOL,KAAK,CAACG,IAAI,CAAA;AACnB,CAAC,CAAA;AAEDN,QAAQ,GAAG,WAAWK,IAAY,EAAE;AAClC,EAAA,IAAIc,KAAK,CAAA;EACT,OAAQA,KAAK,GAAIC,QAAQ,CAASC,OAAO,CAACC,IAAI,CAACjB,IAAI,CAAC,EAAG;AACrD,IAAA,MAAMF,KAAK,GAAIiB,QAAQ,CAASG,YAAY,CAACJ,KAAK,CAAC,CAAA;IAEnD,MAAM;MACJb,IAAI,EAAEJ,YAAY,CAACC,KAAK,EAAEgB,KAAK,CAACK,KAAK,EAAEnB,IAAI,CAAC;MAC5CG,KAAK,EAAEL,KAAK,CAACK,KAAAA;KACd,CAAA;AACH,GAAA;AACF,CAAC,CAAA;AAGI,SAASiB,SAASA,CAACpB,IAAY,EAAE;AACtC,EAAA,IAAIA,IAAI,KAAK,EAAE,EAAE,OAAO,EAAE,CAAA;AAE1B,EAAA,MAAMqB,IAAI,GAAGhC,OAAO,CAAC,IAAI,CAAC,CAAA;EAE1B,IAAIiC,WAAW,GAAG,EAAE,CAAA;AAEpB,EAAA,KAAK,MAAM;IAAErB,IAAI;AAAEE,IAAAA,KAAAA;AAAM,GAAC,IAAIR,QAAQ,CAACK,IAAI,CAAC,EAAE;IAC5C,IAAIC,IAAI,IAAIoB,IAAI,EAAE;MAChBC,WAAW,IAAInB,KAAK,CACjBoB,KAAK,CAAC9B,SAAO,CAAC,CACd+B,GAAG,CAACC,GAAG,IAAIJ,IAAI,CAACpB,IAAI,CAAsB,CAACwB,GAAG,CAAC,CAAC,CAChDC,IAAI,CAAC,IAAI,CAAC,CAAA;AACf,KAAC,MAAM;AACLJ,MAAAA,WAAW,IAAInB,KAAK,CAAA;AACtB,KAAA;AACF,GAAA;AAEA,EAAA,OAAOmB,WAAW,CAAA;AACpB;;AC5NA,IAAIK,uBAAuB,GAAG,KAAK,CAAA;AAwCnC,MAAMlC,OAAO,GAAG,yBAAyB,CAAA;AAQzC,SAASmC,cAAcA,CACrBC,GAAiB,EACjBC,MAAgB,EAChBC,IAAa,EACbC,iBAAyB,EAKzB;AACA,EAAA,MAAMC,QAAkB,GAAAC,MAAA,CAAAC,MAAA,CAAA;AACtBC,IAAAA,MAAM,EAAE,CAAC;AACTC,IAAAA,IAAI,EAAE,CAAC,CAAA;GACJR,EAAAA,GAAG,CAACS,KAAK,CACb,CAAA;EACD,MAAMC,MAAgB,GAAAL,MAAA,CAAAC,MAAA,CACjBF,EAAAA,EAAAA,QAAQ,EACRJ,GAAG,CAACW,GAAG,CACX,CAAA;EACD,MAAM;AAAEC,IAAAA,UAAU,GAAG,CAAC;AAAEC,IAAAA,UAAU,GAAG,CAAA;AAAE,GAAC,GAAGX,IAAI,IAAI,EAAE,CAAA;AACrD,EAAA,MAAMY,SAAS,GAAGV,QAAQ,CAACI,IAAI,GAAGL,iBAAiB,CAAA;AACnD,EAAA,MAAMY,WAAW,GAAGX,QAAQ,CAACG,MAAM,CAAA;AACnC,EAAA,MAAMS,OAAO,GAAGN,MAAM,CAACF,IAAI,GAAGL,iBAAiB,CAAA;AAC/C,EAAA,MAAMc,SAAS,GAAGP,MAAM,CAACH,MAAM,CAAA;AAE/B,EAAA,IAAIE,KAAK,GAAGS,IAAI,CAACC,GAAG,CAACL,SAAS,IAAIF,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACrD,EAAA,IAAID,GAAG,GAAGO,IAAI,CAACE,GAAG,CAACnB,MAAM,CAACoB,MAAM,EAAEL,OAAO,GAAGH,UAAU,CAAC,CAAA;AAEvD,EAAA,IAAIC,SAAS,KAAK,CAAC,CAAC,EAAE;AACpBL,IAAAA,KAAK,GAAG,CAAC,CAAA;AACX,GAAA;AAEA,EAAA,IAAIO,OAAO,KAAK,CAAC,CAAC,EAAE;IAClBL,GAAG,GAAGV,MAAM,CAACoB,MAAM,CAAA;AACrB,GAAA;AAEA,EAAA,MAAMC,QAAQ,GAAGN,OAAO,GAAGF,SAAS,CAAA;EACpC,MAAMS,WAAwB,GAAG,EAAE,CAAA;AAEnC,EAAA,IAAID,QAAQ,EAAE;IACZ,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,IAAIF,QAAQ,EAAEE,CAAC,EAAE,EAAE;AAClC,MAAA,MAAMC,UAAU,GAAGD,CAAC,GAAGV,SAAS,CAAA;MAEhC,IAAI,CAACC,WAAW,EAAE;AAChBQ,QAAAA,WAAW,CAACE,UAAU,CAAC,GAAG,IAAI,CAAA;AAChC,OAAC,MAAM,IAAID,CAAC,KAAK,CAAC,EAAE;QAClB,MAAME,YAAY,GAAGzB,MAAM,CAACwB,UAAU,GAAG,CAAC,CAAC,CAACJ,MAAM,CAAA;AAElDE,QAAAA,WAAW,CAACE,UAAU,CAAC,GAAG,CAACV,WAAW,EAAEW,YAAY,GAAGX,WAAW,GAAG,CAAC,CAAC,CAAA;AACzE,OAAC,MAAM,IAAIS,CAAC,KAAKF,QAAQ,EAAE;QACzBC,WAAW,CAACE,UAAU,CAAC,GAAG,CAAC,CAAC,EAAER,SAAS,CAAC,CAAA;AAC1C,OAAC,MAAM;QACL,MAAMS,YAAY,GAAGzB,MAAM,CAACwB,UAAU,GAAGD,CAAC,CAAC,CAACH,MAAM,CAAA;QAElDE,WAAW,CAACE,UAAU,CAAC,GAAG,CAAC,CAAC,EAAEC,YAAY,CAAC,CAAA;AAC7C,OAAA;AACF,KAAA;AACF,GAAC,MAAM;IACL,IAAIX,WAAW,KAAKE,SAAS,EAAE;AAC7B,MAAA,IAAIF,WAAW,EAAE;QACfQ,WAAW,CAACT,SAAS,CAAC,GAAG,CAACC,WAAW,EAAE,CAAC,CAAC,CAAA;AAC3C,OAAC,MAAM;AACLQ,QAAAA,WAAW,CAACT,SAAS,CAAC,GAAG,IAAI,CAAA;AAC/B,OAAA;AACF,KAAC,MAAM;MACLS,WAAW,CAACT,SAAS,CAAC,GAAG,CAACC,WAAW,EAAEE,SAAS,GAAGF,WAAW,CAAC,CAAA;AACjE,KAAA;AACF,GAAA;EAEA,OAAO;IAAEN,KAAK;IAAEE,GAAG;AAAEY,IAAAA,WAAAA;GAAa,CAAA;AACpC,CAAA;AAEO,SAASI,gBAAgBA,CAC9BC,QAAgB,EAChB5B,GAAiB,EACjBE,IAAa,GAAG,EAAE,EACV;AACR,EAAA,MAAM2B,eAAe,GACnB3B,IAAI,CAAC4B,UAAU,IAAK1G,gBAAgB,EAAE,IAAI8E,IAAI,CAAC6B,aAAc,CAAA;EAC/D,MAAM5B,iBAAiB,GAAG,CAACD,IAAI,CAACY,SAAS,IAAI,CAAC,IAAI,CAAC,CAAA;AACnD,EAAA,MAAMtB,IAAI,GAAGhC,OAAO,CAACqE,eAAe,CAAC,CAAA;AAErC,EAAA,MAAMG,KAAK,GAAGJ,QAAQ,CAAClC,KAAK,CAAC9B,OAAO,CAAC,CAAA;EACrC,MAAM;IAAE6C,KAAK;IAAEE,GAAG;AAAEY,IAAAA,WAAAA;GAAa,GAAGxB,cAAc,CAChDC,GAAG,EACHgC,KAAK,EACL9B,IAAI,EACJC,iBACF,CAAC,CAAA;AACD,EAAA,MAAM8B,UAAU,GAAGjC,GAAG,CAACS,KAAK,IAAI,OAAOT,GAAG,CAACS,KAAK,CAACF,MAAM,KAAK,QAAQ,CAAA;EAEpE,MAAM2B,cAAc,GAAGrD,MAAM,CAAC8B,GAAG,GAAGR,iBAAiB,CAAC,CAACkB,MAAM,CAAA;EAE7D,MAAMc,gBAAgB,GAAGN,eAAe,GAAGtC,SAAS,CAACqC,QAAQ,CAAC,GAAGA,QAAQ,CAAA;EAEzE,IAAIQ,KAAK,GAAGD,gBAAgB,CACzBzC,KAAK,CAAC9B,OAAO,EAAE+C,GAAG,CAAC,CACnBhC,KAAK,CAAC8B,KAAK,EAAEE,GAAG,CAAC,CACjBhB,GAAG,CAAC,CAACa,IAAI,EAAElB,KAAK,KAAK;AACpB,IAAA,MAAMjD,MAAM,GAAGoE,KAAK,GAAG,CAAC,GAAGnB,KAAK,CAAA;AAChC,IAAA,MAAM+C,YAAY,GAAG,CAAIhG,CAAAA,EAAAA,MAAM,GAAG8D,iBAAiB,CAAE,CAAA,CAACxB,KAAK,CACzD,CAACuD,cACH,CAAC,CAAA;AACD,IAAA,MAAMlF,MAAM,GAAG,CAAIqF,CAAAA,EAAAA,YAAY,CAAI,EAAA,CAAA,CAAA;AACnC,IAAA,MAAMC,SAAS,GAAGf,WAAW,CAAClF,MAAM,CAAC,CAAA;IACrC,MAAMkG,cAAc,GAAG,CAAChB,WAAW,CAAClF,MAAM,GAAG,CAAC,CAAC,CAAA;AAC/C,IAAA,IAAIiG,SAAS,EAAE;MACb,IAAIE,UAAU,GAAG,EAAE,CAAA;AACnB,MAAA,IAAIC,KAAK,CAACC,OAAO,CAACJ,SAAS,CAAC,EAAE;AAC5B,QAAA,MAAMK,aAAa,GAAGnC,IAAI,CACvB7B,KAAK,CAAC,CAAC,EAAEuC,IAAI,CAACC,GAAG,CAACmB,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CACvCM,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAA;AACzB,QAAA,MAAMC,eAAe,GAAGP,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;AAEzCE,QAAAA,UAAU,GAAG,CACX,KAAK,EACLhD,IAAI,CAACxC,MAAM,CAACA,MAAM,CAAC4F,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,EACvC,GAAG,EACHD,aAAa,EACbnD,IAAI,CAACvC,MAAM,CAAC,GAAG,CAAC,CAAC6F,MAAM,CAACD,eAAe,CAAC,CACzC,CAAChD,IAAI,CAAC,EAAE,CAAC,CAAA;AAEV,QAAA,IAAI0C,cAAc,IAAIrC,IAAI,CAAC/C,OAAO,EAAE;UAClCqF,UAAU,IAAI,GAAG,GAAGhD,IAAI,CAACrC,OAAO,CAAC+C,IAAI,CAAC/C,OAAO,CAAC,CAAA;AAChD,SAAA;AACF,OAAA;AACA,MAAA,OAAO,CACLqC,IAAI,CAACvC,MAAM,CAAC,GAAG,CAAC,EAChBuC,IAAI,CAACxC,MAAM,CAACA,MAAM,CAAC,EACnBwD,IAAI,CAACa,MAAM,GAAG,CAAC,GAAG,CAAA,CAAA,EAAIb,IAAI,CAAE,CAAA,GAAG,EAAE,EACjCgC,UAAU,CACX,CAAC3C,IAAI,CAAC,EAAE,CAAC,CAAA;AACZ,KAAC,MAAM;AACL,MAAA,OAAO,IAAIL,IAAI,CAACxC,MAAM,CAACA,MAAM,CAAC,CAAGwD,EAAAA,IAAI,CAACa,MAAM,GAAG,CAAC,GAAG,CAAA,CAAA,EAAIb,IAAI,CAAE,CAAA,GAAG,EAAE,CAAE,CAAA,CAAA;AACtE,KAAA;AACF,GAAC,CAAC,CACDX,IAAI,CAAC,IAAI,CAAC,CAAA;AAEb,EAAA,IAAIK,IAAI,CAAC/C,OAAO,IAAI,CAAC8E,UAAU,EAAE;AAC/BG,IAAAA,KAAK,GAAG,CAAG,EAAA,GAAG,CAACU,MAAM,CAACZ,cAAc,GAAG,CAAC,CAAC,GAAGhC,IAAI,CAAC/C,OAAO,CAAA,EAAA,EAAKiF,KAAK,CAAE,CAAA,CAAA;AACtE,GAAA;AAEA,EAAA,IAAIP,eAAe,EAAE;AACnB,IAAA,OAAOrC,IAAI,CAACpC,KAAK,CAACgF,KAAK,CAAC,CAAA;AAC1B,GAAC,MAAM;AACL,IAAA,OAAOA,KAAK,CAAA;AACd,GAAA;AACF,CAAA;AAMe,cAAA,EACbR,QAAgB,EAChBH,UAAkB,EAClBsB,SAAyB,EACzB7C,IAAa,GAAG,EAAE,EACV;EACR,IAAI,CAACJ,uBAAuB,EAAE;AAC5BA,IAAAA,uBAAuB,GAAG,IAAI,CAAA;IAE9B,MAAM3C,OAAO,GACX,qGAAqG,CAAA;IAEvG,IAAI9B,OAAO,CAAC2H,WAAW,EAAE;AAGvB3H,MAAAA,OAAO,CAAC2H,WAAW,CAAC7F,OAAO,EAAE,oBAAoB,CAAC,CAAA;AACpD,KAAC,MAAM;AACL,MAAA,MAAM8F,gBAAgB,GAAG,IAAIC,KAAK,CAAC/F,OAAO,CAAC,CAAA;MAC3C8F,gBAAgB,CAACE,IAAI,GAAG,oBAAoB,CAAA;MAC5CC,OAAO,CAACC,IAAI,CAAC,IAAIH,KAAK,CAAC/F,OAAO,CAAC,CAAC,CAAA;AAClC,KAAA;AACF,GAAA;EAEA4F,SAAS,GAAG7B,IAAI,CAACC,GAAG,CAAC4B,SAAS,EAAE,CAAC,CAAC,CAAA;AAElC,EAAA,MAAMO,QAAsB,GAAG;AAC7B7C,IAAAA,KAAK,EAAE;AAAEF,MAAAA,MAAM,EAAEwC,SAAS;AAAEvC,MAAAA,IAAI,EAAEiB,UAAAA;AAAW,KAAA;GAC9C,CAAA;AAED,EAAA,OAAOE,gBAAgB,CAACC,QAAQ,EAAE0B,QAAQ,EAAEpD,IAAI,CAAC,CAAA;AACnD;;;;;;"} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/code-frame/package.json b/tools/ui/node_modules/@babel/code-frame/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1f21a379df39479bc38dedc221ef6d18927cf0df --- /dev/null +++ b/tools/ui/node_modules/@babel/code-frame/package.json @@ -0,0 +1,32 @@ +{ + "name": "@babel/code-frame", + "version": "7.29.7", + "description": "Generate errors that contain a code frame that point to source locations.", + "author": "The Babel Team (https://babel.dev/team)", + "homepage": "https://babel.dev/docs/en/next/babel-code-frame", + "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-code-frame" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/helper-validator-identifier": "^7.29.7", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "devDependencies": { + "charcodes": "^0.2.0", + "import-meta-resolve": "^4.1.0", + "strip-ansi": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/compat-data/LICENSE b/tools/ui/node_modules/@babel/compat-data/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/@babel/compat-data/README.md b/tools/ui/node_modules/@babel/compat-data/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c19189872ec7139957f70c5f933ca0572db8d6a1 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/README.md @@ -0,0 +1,19 @@ +# @babel/compat-data + +> The compat-data to determine required Babel plugins + +See our website [@babel/compat-data](https://babeljs.io/docs/babel-compat-data) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/compat-data +``` + +or using yarn: + +```sh +yarn add @babel/compat-data +``` diff --git a/tools/ui/node_modules/@babel/compat-data/corejs2-built-ins.js b/tools/ui/node_modules/@babel/compat-data/corejs2-built-ins.js new file mode 100644 index 0000000000000000000000000000000000000000..ed19e0b8a4ffd6bf191602c04d7c9308038f5562 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/corejs2-built-ins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file as Babel 8 drop support of core-js 2 +module.exports = require("./data/corejs2-built-ins.json"); diff --git a/tools/ui/node_modules/@babel/compat-data/corejs3-shipped-proposals.js b/tools/ui/node_modules/@babel/compat-data/corejs3-shipped-proposals.js new file mode 100644 index 0000000000000000000000000000000000000000..7909b8c46d3717def2168c9a1e8cc6a068b29541 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/corejs3-shipped-proposals.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file now that it is included in babel-plugin-polyfill-corejs3 +module.exports = require("./data/corejs3-shipped-proposals.json"); diff --git a/tools/ui/node_modules/@babel/compat-data/data/corejs2-built-ins.json b/tools/ui/node_modules/@babel/compat-data/data/corejs2-built-ins.json new file mode 100644 index 0000000000000000000000000000000000000000..c7fd1889bddc30127e94be2bc035794866cd3871 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/corejs2-built-ins.json @@ -0,0 +1,2120 @@ +{ + "es6.array.copy-within": { + "chrome": "45", + "opera": "32", + "edge": "12", + "firefox": "32", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.31" + }, + "es6.array.every": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.fill": { + "chrome": "45", + "opera": "32", + "edge": "12", + "firefox": "31", + "safari": "7.1", + "node": "4", + "deno": "1", + "ios": "8", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.31" + }, + "es6.array.filter": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.array.find": { + "chrome": "45", + "opera": "32", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "4", + "deno": "1", + "ios": "8", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.31" + }, + "es6.array.find-index": { + "chrome": "45", + "opera": "32", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "4", + "deno": "1", + "ios": "8", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.31" + }, + "es7.array.flat-map": { + "chrome": "69", + "opera": "56", + "edge": "79", + "firefox": "62", + "safari": "12", + "node": "11", + "deno": "1", + "ios": "12", + "samsung": "10", + "rhino": "1.7.15", + "opera_mobile": "48", + "electron": "4.0" + }, + "es6.array.for-each": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.from": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "36", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "41", + "electron": "1.2" + }, + "es7.array.includes": { + "chrome": "47", + "opera": "34", + "edge": "14", + "firefox": "102", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "34", + "electron": "0.36" + }, + "es6.array.index-of": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.is-array": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.iterator": { + "chrome": "66", + "opera": "53", + "edge": "12", + "firefox": "60", + "safari": "9", + "node": "10", + "deno": "1", + "ios": "9", + "samsung": "9", + "rhino": "1.7.13", + "opera_mobile": "47", + "electron": "3.0" + }, + "es6.array.last-index-of": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.map": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.array.of": { + "chrome": "45", + "opera": "32", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.31" + }, + "es6.array.reduce": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.reduce-right": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.slice": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.array.some": { + "chrome": "5", + "opera": "10.10", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.array.sort": { + "chrome": "63", + "opera": "50", + "edge": "12", + "firefox": "5", + "safari": "12", + "node": "10", + "deno": "1", + "ie": "9", + "ios": "12", + "samsung": "8", + "rhino": "1.7.13", + "opera_mobile": "46", + "electron": "3.0" + }, + "es6.array.species": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.date.now": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.date.to-iso-string": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3.5", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.date.to-json": { + "chrome": "5", + "opera": "12.10", + "edge": "12", + "firefox": "4", + "safari": "10", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "10", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12.1", + "electron": "0.20" + }, + "es6.date.to-primitive": { + "chrome": "47", + "opera": "34", + "edge": "15", + "firefox": "44", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "34", + "electron": "0.36" + }, + "es6.date.to-string": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.4", + "deno": "1", + "ie": "10", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.function.bind": { + "chrome": "7", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "5.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "es6.function.has-instance": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "50", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.function.name": { + "chrome": "5", + "opera": "10.50", + "edge": "14", + "firefox": "2", + "safari": "4", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es6.map": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.math.acosh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.asinh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.atanh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.cbrt": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.clz32": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.cosh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.expm1": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.fround": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "26", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.hypot": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "27", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.imul": { + "chrome": "30", + "opera": "17", + "edge": "12", + "firefox": "23", + "safari": "7", + "node": "0.12", + "deno": "1", + "android": "4.4", + "ios": "7", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "18", + "electron": "0.20" + }, + "es6.math.log1p": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.log10": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.log2": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.sign": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.sinh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.tanh": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.math.trunc": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "25", + "safari": "7.1", + "node": "0.12", + "deno": "1", + "ios": "8", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.number.constructor": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "36", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.number.epsilon": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.14", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.is-finite": { + "chrome": "19", + "opera": "15", + "edge": "12", + "firefox": "16", + "safari": "9", + "node": "0.8", + "deno": "1", + "android": "4.1", + "ios": "9", + "samsung": "1.5", + "rhino": "1.7.13", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.number.is-integer": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "16", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.is-nan": { + "chrome": "19", + "opera": "15", + "edge": "12", + "firefox": "15", + "safari": "9", + "node": "0.8", + "deno": "1", + "android": "4.1", + "ios": "9", + "samsung": "1.5", + "rhino": "1.7.13", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.number.is-safe-integer": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "32", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.max-safe-integer": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.min-safe-integer": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.parse-float": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.14", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.number.parse-int": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "25", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "2", + "rhino": "1.7.14", + "opera_mobile": "21", + "electron": "0.20" + }, + "es6.object.assign": { + "chrome": "49", + "opera": "36", + "edge": "13", + "firefox": "36", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.object.create": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "es7.object.define-getter": { + "chrome": "62", + "opera": "49", + "edge": "16", + "firefox": "48", + "safari": "9", + "node": "8.10", + "deno": "1", + "ios": "9", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es7.object.define-setter": { + "chrome": "62", + "opera": "49", + "edge": "16", + "firefox": "48", + "safari": "9", + "node": "8.10", + "deno": "1", + "ios": "9", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es6.object.define-property": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "5.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "es6.object.define-properties": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "4", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "es7.object.entries": { + "chrome": "54", + "opera": "41", + "edge": "14", + "firefox": "47", + "safari": "10.1", + "node": "7", + "deno": "1", + "ios": "10.3", + "samsung": "6", + "rhino": "1.7.14", + "opera_mobile": "41", + "electron": "1.4" + }, + "es6.object.freeze": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.get-own-property-descriptor": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es7.object.get-own-property-descriptors": { + "chrome": "54", + "opera": "41", + "edge": "15", + "firefox": "50", + "safari": "10.1", + "node": "7", + "deno": "1", + "ios": "10.3", + "samsung": "6", + "rhino": "1.8", + "opera_mobile": "41", + "electron": "1.4" + }, + "es6.object.get-own-property-names": { + "chrome": "40", + "opera": "27", + "edge": "12", + "firefox": "33", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "27", + "electron": "0.21" + }, + "es6.object.get-prototype-of": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es7.object.lookup-getter": { + "chrome": "62", + "opera": "49", + "edge": "79", + "firefox": "36", + "safari": "9", + "node": "8.10", + "deno": "1", + "ios": "9", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es7.object.lookup-setter": { + "chrome": "62", + "opera": "49", + "edge": "79", + "firefox": "36", + "safari": "9", + "node": "8.10", + "deno": "1", + "ios": "9", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es6.object.prevent-extensions": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.to-string": { + "chrome": "57", + "opera": "44", + "edge": "15", + "firefox": "51", + "safari": "10", + "node": "8", + "deno": "1", + "ios": "10", + "samsung": "7", + "rhino": "1.9", + "opera_mobile": "43", + "electron": "1.7" + }, + "es6.object.is": { + "chrome": "19", + "opera": "15", + "edge": "12", + "firefox": "22", + "safari": "9", + "node": "0.8", + "deno": "1", + "android": "4.1", + "ios": "9", + "samsung": "1.5", + "rhino": "1.7.13", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.object.is-frozen": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.is-sealed": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.is-extensible": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.keys": { + "chrome": "40", + "opera": "27", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "27", + "electron": "0.21" + }, + "es6.object.seal": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "35", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.13", + "opera_mobile": "32", + "electron": "0.30" + }, + "es6.object.set-prototype-of": { + "chrome": "34", + "opera": "21", + "edge": "12", + "firefox": "31", + "safari": "9", + "node": "0.12", + "deno": "1", + "ie": "11", + "ios": "9", + "samsung": "2", + "rhino": "1.7.13", + "opera_mobile": "21", + "electron": "0.20" + }, + "es7.object.values": { + "chrome": "54", + "opera": "41", + "edge": "14", + "firefox": "47", + "safari": "10.1", + "node": "7", + "deno": "1", + "ios": "10.3", + "samsung": "6", + "rhino": "1.7.14", + "opera_mobile": "41", + "electron": "1.4" + }, + "es6.promise": { + "chrome": "51", + "opera": "38", + "edge": "14", + "firefox": "45", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "41", + "electron": "1.2" + }, + "es7.promise.finally": { + "chrome": "63", + "opera": "50", + "edge": "18", + "firefox": "58", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es6.reflect.apply": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.construct": { + "chrome": "49", + "opera": "36", + "edge": "13", + "firefox": "49", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.define-property": { + "chrome": "49", + "opera": "36", + "edge": "13", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.delete-property": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.get": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.get-own-property-descriptor": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.get-prototype-of": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.has": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.is-extensible": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.own-keys": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.prevent-extensions": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.set": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.reflect.set-prototype-of": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "42", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.regexp.constructor": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "40", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.regexp.flags": { + "chrome": "49", + "opera": "36", + "edge": "79", + "firefox": "37", + "safari": "9", + "node": "6", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "36", + "electron": "0.37" + }, + "es6.regexp.match": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "49", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.regexp.replace": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "49", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.regexp.split": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "49", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.regexp.search": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "49", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.regexp.to-string": { + "chrome": "50", + "opera": "37", + "edge": "79", + "firefox": "39", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "37", + "electron": "1.1" + }, + "es6.set": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.symbol": { + "chrome": "51", + "opera": "38", + "edge": "79", + "firefox": "51", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "es7.symbol.async-iterator": { + "chrome": "63", + "opera": "50", + "edge": "79", + "firefox": "57", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "es6.string.anchor": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.big": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.blink": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.bold": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.code-point-at": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.ends-with": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.fixed": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.fontcolor": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.fontsize": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.from-code-point": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.includes": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "40", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.italics": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.iterator": { + "chrome": "38", + "opera": "25", + "edge": "12", + "firefox": "36", + "safari": "9", + "node": "0.12", + "deno": "1", + "ios": "9", + "samsung": "3", + "rhino": "1.7.13", + "opera_mobile": "25", + "electron": "0.20" + }, + "es6.string.link": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es7.string.pad-start": { + "chrome": "57", + "opera": "44", + "edge": "15", + "firefox": "48", + "safari": "10", + "node": "8", + "deno": "1", + "ios": "10", + "samsung": "7", + "rhino": "1.7.13", + "opera_mobile": "43", + "electron": "1.7" + }, + "es7.string.pad-end": { + "chrome": "57", + "opera": "44", + "edge": "15", + "firefox": "48", + "safari": "10", + "node": "8", + "deno": "1", + "ios": "10", + "samsung": "7", + "rhino": "1.7.13", + "opera_mobile": "43", + "electron": "1.7" + }, + "es6.string.raw": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "34", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.14", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.repeat": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "24", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.small": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.starts-with": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "29", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.7.13", + "opera_mobile": "28", + "electron": "0.21" + }, + "es6.string.strike": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.sub": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.sup": { + "chrome": "5", + "opera": "15", + "edge": "12", + "firefox": "17", + "safari": "6", + "node": "0.4", + "deno": "1", + "android": "4", + "ios": "7", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.14", + "opera_mobile": "14", + "electron": "0.20" + }, + "es6.string.trim": { + "chrome": "5", + "opera": "10.50", + "edge": "12", + "firefox": "3.5", + "safari": "4", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "es7.string.trim-left": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "61", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "9", + "rhino": "1.7.13", + "opera_mobile": "47", + "electron": "3.0" + }, + "es7.string.trim-right": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "61", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "9", + "rhino": "1.7.13", + "opera_mobile": "47", + "electron": "3.0" + }, + "es6.typed.array-buffer": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.data-view": { + "chrome": "5", + "opera": "12", + "edge": "12", + "firefox": "15", + "safari": "5.1", + "node": "0.4", + "deno": "1", + "ie": "10", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "es6.typed.int8-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.uint8-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.uint8-clamped-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.int16-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.uint16-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.int32-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.uint32-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.float32-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.typed.float64-array": { + "chrome": "51", + "opera": "38", + "edge": "13", + "firefox": "48", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.weak-map": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "9", + "node": "6.5", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "41", + "electron": "1.2" + }, + "es6.weak-set": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "9", + "node": "6.5", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "41", + "electron": "1.2" + } +} diff --git a/tools/ui/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json b/tools/ui/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json new file mode 100644 index 0000000000000000000000000000000000000000..d03b698ff0c18a2e55ff3df2414e4bc366962515 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json @@ -0,0 +1,5 @@ +[ + "esnext.promise.all-settled", + "esnext.string.match-all", + "esnext.global-this" +] diff --git a/tools/ui/node_modules/@babel/compat-data/data/native-modules.json b/tools/ui/node_modules/@babel/compat-data/data/native-modules.json new file mode 100644 index 0000000000000000000000000000000000000000..2328d2138bd513cde3d1fe009ef41f969226f023 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/native-modules.json @@ -0,0 +1,18 @@ +{ + "es6.module": { + "chrome": "61", + "and_chr": "61", + "edge": "16", + "firefox": "60", + "and_ff": "60", + "node": "13.2.0", + "opera": "48", + "op_mob": "45", + "safari": "10.1", + "ios": "10.3", + "samsung": "8.2", + "android": "61", + "electron": "2.0", + "ios_saf": "10.3" + } +} diff --git a/tools/ui/node_modules/@babel/compat-data/data/overlapping-plugins.json b/tools/ui/node_modules/@babel/compat-data/data/overlapping-plugins.json new file mode 100644 index 0000000000000000000000000000000000000000..c0df4bd445ed52b2138b0b7c228cda5ebe713609 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/overlapping-plugins.json @@ -0,0 +1,38 @@ +{ + "transform-async-to-generator": [ + "bugfix/transform-async-arrows-in-class" + ], + "transform-parameters": [ + "bugfix/transform-edge-default-parameters", + "bugfix/transform-safari-id-destructuring-collision-in-function-expression" + ], + "transform-function-name": [ + "bugfix/transform-edge-function-name" + ], + "transform-block-scoping": [ + "bugfix/transform-safari-block-shadowing", + "bugfix/transform-safari-for-shadowing" + ], + "transform-destructuring": [ + "bugfix/transform-safari-rest-destructuring-rhs-array" + ], + "transform-template-literals": [ + "bugfix/transform-tagged-template-caching" + ], + "transform-optional-chaining": [ + "bugfix/transform-v8-spread-parameters-in-optional-chaining" + ], + "proposal-optional-chaining": [ + "bugfix/transform-v8-spread-parameters-in-optional-chaining" + ], + "transform-class-properties": [ + "bugfix/transform-v8-static-class-fields-redefine-readonly", + "bugfix/transform-firefox-class-in-computed-class-key", + "bugfix/transform-safari-class-field-initializer-scope" + ], + "proposal-class-properties": [ + "bugfix/transform-v8-static-class-fields-redefine-readonly", + "bugfix/transform-firefox-class-in-computed-class-key", + "bugfix/transform-safari-class-field-initializer-scope" + ] +} diff --git a/tools/ui/node_modules/@babel/compat-data/data/plugin-bugfixes.json b/tools/ui/node_modules/@babel/compat-data/data/plugin-bugfixes.json new file mode 100644 index 0000000000000000000000000000000000000000..7b6589ae7f8936a45c1b6efbd370cf4d502253d8 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/plugin-bugfixes.json @@ -0,0 +1,231 @@ +{ + "bugfix/transform-async-arrows-in-class": { + "chrome": "55", + "opera": "42", + "edge": "15", + "firefox": "52", + "safari": "11", + "node": "7.6", + "deno": "1", + "ios": "11", + "samsung": "6", + "opera_mobile": "42", + "electron": "1.6" + }, + "bugfix/transform-edge-default-parameters": { + "chrome": "49", + "opera": "36", + "edge": "18", + "firefox": "52", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "bugfix/transform-edge-function-name": { + "chrome": "51", + "opera": "38", + "edge": "79", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.9", + "opera_mobile": "41", + "electron": "1.2" + }, + "bugfix/transform-safari-block-shadowing": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "44", + "safari": "11", + "node": "6", + "deno": "1", + "ie": "11", + "ios": "11", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "bugfix/transform-safari-for-shadowing": { + "chrome": "49", + "opera": "36", + "edge": "12", + "firefox": "4", + "safari": "11", + "node": "6", + "deno": "1", + "ie": "11", + "ios": "11", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "36", + "electron": "0.37" + }, + "bugfix/transform-safari-id-destructuring-collision-in-function-expression": { + "chrome": "49", + "opera": "36", + "edge": "14", + "firefox": "2", + "safari": "16.3", + "node": "6", + "deno": "1", + "ios": "16.3", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "bugfix/transform-safari-rest-destructuring-rhs-array": { + "chrome": "49", + "opera": "36", + "edge": "14", + "firefox": "34", + "safari": "14.1", + "node": "6", + "deno": "1", + "ios": "14.5", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "bugfix/transform-tagged-template-caching": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "34", + "safari": "13", + "node": "4", + "deno": "1", + "ios": "13", + "samsung": "3.4", + "rhino": "1.7.14", + "opera_mobile": "28", + "electron": "0.21" + }, + "bugfix/transform-v8-spread-parameters-in-optional-chaining": { + "chrome": "91", + "opera": "77", + "edge": "91", + "firefox": "74", + "safari": "13.1", + "node": "16.9", + "deno": "1.9", + "ios": "13.4", + "samsung": "16", + "opera_mobile": "64", + "electron": "13.0" + }, + "transform-optional-chaining": { + "chrome": "80", + "opera": "67", + "edge": "80", + "firefox": "74", + "safari": "13.1", + "node": "14", + "deno": "1", + "ios": "13.4", + "samsung": "13", + "rhino": "1.8", + "opera_mobile": "57", + "electron": "8.0" + }, + "proposal-optional-chaining": { + "chrome": "80", + "opera": "67", + "edge": "80", + "firefox": "74", + "safari": "13.1", + "node": "14", + "deno": "1", + "ios": "13.4", + "samsung": "13", + "rhino": "1.8", + "opera_mobile": "57", + "electron": "8.0" + }, + "transform-parameters": { + "chrome": "49", + "opera": "36", + "edge": "15", + "firefox": "52", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "transform-async-to-generator": { + "chrome": "55", + "opera": "42", + "edge": "15", + "firefox": "52", + "safari": "10.1", + "node": "7.6", + "deno": "1", + "ios": "10.3", + "samsung": "6", + "opera_mobile": "42", + "electron": "1.6" + }, + "transform-template-literals": { + "chrome": "41", + "opera": "28", + "edge": "13", + "firefox": "34", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "rhino": "1.9", + "opera_mobile": "28", + "electron": "0.21" + }, + "transform-function-name": { + "chrome": "51", + "opera": "38", + "edge": "14", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "transform-destructuring": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "transform-block-scoping": { + "chrome": "50", + "opera": "37", + "edge": "14", + "firefox": "53", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "37", + "electron": "1.1" + } +} diff --git a/tools/ui/node_modules/@babel/compat-data/data/plugins.json b/tools/ui/node_modules/@babel/compat-data/data/plugins.json new file mode 100644 index 0000000000000000000000000000000000000000..81e6de4ef58a38bccac0bc6628392f8d41a08edb --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/data/plugins.json @@ -0,0 +1,843 @@ +{ + "transform-explicit-resource-management": { + "chrome": "141", + "edge": "141", + "firefox": "141", + "node": "25", + "electron": "39.0" + }, + "transform-duplicate-named-capturing-groups-regex": { + "chrome": "126", + "opera": "112", + "edge": "126", + "firefox": "129", + "safari": "17.4", + "node": "23", + "ios": "17.4", + "rhino": "1.9", + "electron": "31.0" + }, + "transform-regexp-modifiers": { + "chrome": "125", + "opera": "111", + "edge": "125", + "firefox": "132", + "node": "23", + "samsung": "27", + "electron": "31.0" + }, + "transform-unicode-sets-regex": { + "chrome": "112", + "opera": "98", + "edge": "112", + "firefox": "116", + "safari": "17", + "node": "20", + "deno": "1.32", + "ios": "17", + "samsung": "23", + "opera_mobile": "75", + "electron": "24.0" + }, + "bugfix/transform-v8-static-class-fields-redefine-readonly": { + "chrome": "98", + "opera": "84", + "edge": "98", + "firefox": "75", + "safari": "15", + "node": "12", + "deno": "1.18", + "ios": "15", + "samsung": "11", + "opera_mobile": "52", + "electron": "17.0" + }, + "bugfix/transform-firefox-class-in-computed-class-key": { + "chrome": "74", + "opera": "62", + "edge": "79", + "firefox": "126", + "safari": "16", + "node": "12", + "deno": "1", + "ios": "16", + "samsung": "11", + "opera_mobile": "53", + "electron": "6.0" + }, + "bugfix/transform-safari-class-field-initializer-scope": { + "chrome": "74", + "opera": "62", + "edge": "79", + "firefox": "69", + "safari": "16", + "node": "12", + "deno": "1", + "ios": "16", + "samsung": "11", + "opera_mobile": "53", + "electron": "6.0" + }, + "transform-class-static-block": { + "chrome": "94", + "opera": "80", + "edge": "94", + "firefox": "93", + "safari": "16.4", + "node": "16.11", + "deno": "1.14", + "ios": "16.4", + "samsung": "17", + "opera_mobile": "66", + "electron": "15.0" + }, + "proposal-class-static-block": { + "chrome": "94", + "opera": "80", + "edge": "94", + "firefox": "93", + "safari": "16.4", + "node": "16.11", + "deno": "1.14", + "ios": "16.4", + "samsung": "17", + "opera_mobile": "66", + "electron": "15.0" + }, + "transform-private-property-in-object": { + "chrome": "91", + "opera": "77", + "edge": "91", + "firefox": "90", + "safari": "15", + "node": "16.9", + "deno": "1.9", + "ios": "15", + "samsung": "16", + "opera_mobile": "64", + "electron": "13.0" + }, + "proposal-private-property-in-object": { + "chrome": "91", + "opera": "77", + "edge": "91", + "firefox": "90", + "safari": "15", + "node": "16.9", + "deno": "1.9", + "ios": "15", + "samsung": "16", + "opera_mobile": "64", + "electron": "13.0" + }, + "transform-class-properties": { + "chrome": "74", + "opera": "62", + "edge": "79", + "firefox": "90", + "safari": "14.1", + "node": "12", + "deno": "1", + "ios": "14.5", + "samsung": "11", + "opera_mobile": "53", + "electron": "6.0" + }, + "proposal-class-properties": { + "chrome": "74", + "opera": "62", + "edge": "79", + "firefox": "90", + "safari": "14.1", + "node": "12", + "deno": "1", + "ios": "14.5", + "samsung": "11", + "opera_mobile": "53", + "electron": "6.0" + }, + "transform-private-methods": { + "chrome": "84", + "opera": "70", + "edge": "84", + "firefox": "90", + "safari": "15", + "node": "14.6", + "deno": "1", + "ios": "15", + "samsung": "14", + "opera_mobile": "60", + "electron": "10.0" + }, + "proposal-private-methods": { + "chrome": "84", + "opera": "70", + "edge": "84", + "firefox": "90", + "safari": "15", + "node": "14.6", + "deno": "1", + "ios": "15", + "samsung": "14", + "opera_mobile": "60", + "electron": "10.0" + }, + "transform-numeric-separator": { + "chrome": "75", + "opera": "62", + "edge": "79", + "firefox": "70", + "safari": "13", + "node": "12.5", + "deno": "1", + "ios": "13", + "samsung": "11", + "rhino": "1.7.14", + "opera_mobile": "54", + "electron": "6.0" + }, + "proposal-numeric-separator": { + "chrome": "75", + "opera": "62", + "edge": "79", + "firefox": "70", + "safari": "13", + "node": "12.5", + "deno": "1", + "ios": "13", + "samsung": "11", + "rhino": "1.7.14", + "opera_mobile": "54", + "electron": "6.0" + }, + "transform-logical-assignment-operators": { + "chrome": "85", + "opera": "71", + "edge": "85", + "firefox": "79", + "safari": "14", + "node": "15", + "deno": "1.2", + "ios": "14", + "samsung": "14", + "opera_mobile": "60", + "electron": "10.0" + }, + "proposal-logical-assignment-operators": { + "chrome": "85", + "opera": "71", + "edge": "85", + "firefox": "79", + "safari": "14", + "node": "15", + "deno": "1.2", + "ios": "14", + "samsung": "14", + "opera_mobile": "60", + "electron": "10.0" + }, + "transform-nullish-coalescing-operator": { + "chrome": "80", + "opera": "67", + "edge": "80", + "firefox": "72", + "safari": "13.1", + "node": "14", + "deno": "1", + "ios": "13.4", + "samsung": "13", + "rhino": "1.8", + "opera_mobile": "57", + "electron": "8.0" + }, + "proposal-nullish-coalescing-operator": { + "chrome": "80", + "opera": "67", + "edge": "80", + "firefox": "72", + "safari": "13.1", + "node": "14", + "deno": "1", + "ios": "13.4", + "samsung": "13", + "rhino": "1.8", + "opera_mobile": "57", + "electron": "8.0" + }, + "transform-optional-chaining": { + "chrome": "91", + "opera": "77", + "edge": "91", + "firefox": "74", + "safari": "13.1", + "node": "16.9", + "deno": "1.9", + "ios": "13.4", + "samsung": "16", + "opera_mobile": "64", + "electron": "13.0" + }, + "proposal-optional-chaining": { + "chrome": "91", + "opera": "77", + "edge": "91", + "firefox": "74", + "safari": "13.1", + "node": "16.9", + "deno": "1.9", + "ios": "13.4", + "samsung": "16", + "opera_mobile": "64", + "electron": "13.0" + }, + "transform-json-strings": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "62", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "9", + "rhino": "1.7.14", + "opera_mobile": "47", + "electron": "3.0" + }, + "proposal-json-strings": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "62", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "9", + "rhino": "1.7.14", + "opera_mobile": "47", + "electron": "3.0" + }, + "transform-optional-catch-binding": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "58", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "9", + "opera_mobile": "47", + "electron": "3.0" + }, + "proposal-optional-catch-binding": { + "chrome": "66", + "opera": "53", + "edge": "79", + "firefox": "58", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "9", + "opera_mobile": "47", + "electron": "3.0" + }, + "transform-parameters": { + "chrome": "49", + "opera": "36", + "edge": "18", + "firefox": "52", + "safari": "16.3", + "node": "6", + "deno": "1", + "ios": "16.3", + "samsung": "5", + "opera_mobile": "36", + "electron": "0.37" + }, + "transform-async-generator-functions": { + "chrome": "63", + "opera": "50", + "edge": "79", + "firefox": "57", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "proposal-async-generator-functions": { + "chrome": "63", + "opera": "50", + "edge": "79", + "firefox": "57", + "safari": "12", + "node": "10", + "deno": "1", + "ios": "12", + "samsung": "8", + "opera_mobile": "46", + "electron": "3.0" + }, + "transform-object-rest-spread": { + "chrome": "60", + "opera": "47", + "edge": "79", + "firefox": "55", + "safari": "11.1", + "node": "8.3", + "deno": "1", + "ios": "11.3", + "samsung": "8", + "opera_mobile": "44", + "electron": "2.0" + }, + "proposal-object-rest-spread": { + "chrome": "60", + "opera": "47", + "edge": "79", + "firefox": "55", + "safari": "11.1", + "node": "8.3", + "deno": "1", + "ios": "11.3", + "samsung": "8", + "opera_mobile": "44", + "electron": "2.0" + }, + "transform-dotall-regex": { + "chrome": "62", + "opera": "49", + "edge": "79", + "firefox": "78", + "safari": "11.1", + "node": "8.10", + "deno": "1", + "ios": "11.3", + "samsung": "8", + "rhino": "1.7.15", + "opera_mobile": "46", + "electron": "3.0" + }, + "transform-unicode-property-regex": { + "chrome": "64", + "opera": "51", + "edge": "79", + "firefox": "78", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "9", + "rhino": "1.9", + "opera_mobile": "47", + "electron": "3.0" + }, + "proposal-unicode-property-regex": { + "chrome": "64", + "opera": "51", + "edge": "79", + "firefox": "78", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "9", + "rhino": "1.9", + "opera_mobile": "47", + "electron": "3.0" + }, + "transform-named-capturing-groups-regex": { + "chrome": "64", + "opera": "51", + "edge": "79", + "firefox": "78", + "safari": "11.1", + "node": "10", + "deno": "1", + "ios": "11.3", + "samsung": "9", + "rhino": "1.9", + "opera_mobile": "47", + "electron": "3.0" + }, + "transform-async-to-generator": { + "chrome": "55", + "opera": "42", + "edge": "15", + "firefox": "52", + "safari": "11", + "node": "7.6", + "deno": "1", + "ios": "11", + "samsung": "6", + "opera_mobile": "42", + "electron": "1.6" + }, + "transform-exponentiation-operator": { + "chrome": "52", + "opera": "39", + "edge": "14", + "firefox": "52", + "safari": "10.1", + "node": "7", + "deno": "1", + "ios": "10.3", + "samsung": "6", + "rhino": "1.7.14", + "opera_mobile": "41", + "electron": "1.3" + }, + "transform-template-literals": { + "chrome": "41", + "opera": "28", + "edge": "13", + "firefox": "34", + "safari": "13", + "node": "4", + "deno": "1", + "ios": "13", + "samsung": "3.4", + "rhino": "1.9", + "opera_mobile": "28", + "electron": "0.21" + }, + "transform-literals": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "53", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.15", + "opera_mobile": "32", + "electron": "0.30" + }, + "transform-function-name": { + "chrome": "51", + "opera": "38", + "edge": "79", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "transform-arrow-functions": { + "chrome": "47", + "opera": "34", + "edge": "13", + "firefox": "43", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.13", + "opera_mobile": "34", + "electron": "0.36" + }, + "transform-block-scoped-functions": { + "chrome": "41", + "opera": "28", + "edge": "12", + "firefox": "46", + "safari": "10", + "node": "4", + "deno": "1", + "ie": "11", + "ios": "10", + "samsung": "3.4", + "opera_mobile": "28", + "electron": "0.21" + }, + "transform-classes": { + "chrome": "46", + "opera": "33", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "33", + "electron": "0.36" + }, + "transform-object-super": { + "chrome": "46", + "opera": "33", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "33", + "electron": "0.36" + }, + "transform-shorthand-properties": { + "chrome": "43", + "opera": "30", + "edge": "12", + "firefox": "33", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.14", + "opera_mobile": "30", + "electron": "0.27" + }, + "transform-duplicate-keys": { + "chrome": "42", + "opera": "29", + "edge": "12", + "firefox": "34", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "3.4", + "opera_mobile": "29", + "electron": "0.25" + }, + "transform-computed-properties": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "34", + "safari": "7.1", + "node": "4", + "deno": "1", + "ios": "8", + "samsung": "4", + "rhino": "1.8", + "opera_mobile": "32", + "electron": "0.30" + }, + "transform-for-of": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "10", + "node": "6.5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "transform-sticky-regex": { + "chrome": "49", + "opera": "36", + "edge": "13", + "firefox": "3", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "rhino": "1.7.15", + "opera_mobile": "36", + "electron": "0.37" + }, + "transform-unicode-escapes": { + "chrome": "44", + "opera": "31", + "edge": "12", + "firefox": "53", + "safari": "9", + "node": "4", + "deno": "1", + "ios": "9", + "samsung": "4", + "rhino": "1.7.15", + "opera_mobile": "32", + "electron": "0.30" + }, + "transform-unicode-regex": { + "chrome": "50", + "opera": "37", + "edge": "13", + "firefox": "46", + "safari": "12", + "node": "6", + "deno": "1", + "ios": "12", + "samsung": "5", + "opera_mobile": "37", + "electron": "1.1" + }, + "transform-spread": { + "chrome": "46", + "opera": "33", + "edge": "13", + "firefox": "45", + "safari": "10", + "node": "5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "33", + "electron": "0.36" + }, + "transform-destructuring": { + "chrome": "51", + "opera": "38", + "edge": "15", + "firefox": "53", + "safari": "14.1", + "node": "6.5", + "deno": "1", + "ios": "14.5", + "samsung": "5", + "opera_mobile": "41", + "electron": "1.2" + }, + "transform-block-scoping": { + "chrome": "50", + "opera": "37", + "edge": "14", + "firefox": "53", + "safari": "11", + "node": "6", + "deno": "1", + "ios": "11", + "samsung": "5", + "opera_mobile": "37", + "electron": "1.1" + }, + "transform-typeof-symbol": { + "chrome": "48", + "opera": "35", + "edge": "12", + "firefox": "36", + "safari": "9", + "node": "6", + "deno": "1", + "ios": "9", + "samsung": "5", + "rhino": "1.8", + "opera_mobile": "35", + "electron": "0.37" + }, + "transform-new-target": { + "chrome": "46", + "opera": "33", + "edge": "14", + "firefox": "41", + "safari": "10", + "node": "5", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "33", + "electron": "0.36" + }, + "transform-regenerator": { + "chrome": "50", + "opera": "37", + "edge": "13", + "firefox": "53", + "safari": "10", + "node": "6", + "deno": "1", + "ios": "10", + "samsung": "5", + "opera_mobile": "37", + "electron": "1.1" + }, + "transform-member-expression-literals": { + "chrome": "7", + "opera": "12", + "edge": "12", + "firefox": "2", + "safari": "5.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "transform-property-literals": { + "chrome": "7", + "opera": "12", + "edge": "12", + "firefox": "2", + "safari": "5.1", + "node": "0.4", + "deno": "1", + "ie": "9", + "android": "4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "12", + "electron": "0.20" + }, + "transform-reserved-words": { + "chrome": "13", + "opera": "10.50", + "edge": "12", + "firefox": "2", + "safari": "3.1", + "node": "0.6", + "deno": "1", + "ie": "9", + "android": "4.4", + "ios": "6", + "phantom": "1.9", + "samsung": "1", + "rhino": "1.7.13", + "opera_mobile": "10.1", + "electron": "0.20" + }, + "transform-export-namespace-from": { + "chrome": "72", + "deno": "1.0", + "edge": "79", + "firefox": "80", + "node": "13.2.0", + "opera": "60", + "opera_mobile": "51", + "safari": "14.1", + "ios": "14.5", + "samsung": "11.0", + "android": "72", + "electron": "5.0" + }, + "proposal-export-namespace-from": { + "chrome": "72", + "deno": "1.0", + "edge": "79", + "firefox": "80", + "node": "13.2.0", + "opera": "60", + "opera_mobile": "51", + "safari": "14.1", + "ios": "14.5", + "samsung": "11.0", + "android": "72", + "electron": "5.0" + } +} diff --git a/tools/ui/node_modules/@babel/compat-data/native-modules.js b/tools/ui/node_modules/@babel/compat-data/native-modules.js new file mode 100644 index 0000000000000000000000000000000000000000..f8c25fa37c725bf198ca05821ec0515e377fe137 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/native-modules.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/native-modules.json"); diff --git a/tools/ui/node_modules/@babel/compat-data/overlapping-plugins.js b/tools/ui/node_modules/@babel/compat-data/overlapping-plugins.js new file mode 100644 index 0000000000000000000000000000000000000000..0dd35f1573f98ceb7d2c947e658b8bd0fcf639bb --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/overlapping-plugins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/overlapping-plugins.json"); diff --git a/tools/ui/node_modules/@babel/compat-data/package.json b/tools/ui/node_modules/@babel/compat-data/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9a59bd07b6c4f9557ad3d9bd74fd9398e87a096e --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/package.json @@ -0,0 +1,40 @@ +{ + "name": "@babel/compat-data", + "version": "7.29.7", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "description": "The compat-data to determine required Babel plugins", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-compat-data" + }, + "publishConfig": { + "access": "public" + }, + "exports": { + "./plugins": "./plugins.js", + "./native-modules": "./native-modules.js", + "./corejs2-built-ins": "./corejs2-built-ins.js", + "./corejs3-shipped-proposals": "./corejs3-shipped-proposals.js", + "./overlapping-plugins": "./overlapping-plugins.js", + "./plugin-bugfixes": "./plugin-bugfixes.js" + }, + "scripts": { + "build-data": "./scripts/download-compat-table.sh && node ./scripts/build-data.mjs && node ./scripts/build-modules-support.mjs && node ./scripts/build-bugfixes-targets.mjs" + }, + "keywords": [ + "babel", + "compat-table", + "compat-data" + ], + "devDependencies": { + "@mdn/browser-compat-data": "^6.0.8", + "core-js-compat": "^3.48.0", + "electron-to-chromium": "^1.5.278" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/compat-data/plugin-bugfixes.js b/tools/ui/node_modules/@babel/compat-data/plugin-bugfixes.js new file mode 100644 index 0000000000000000000000000000000000000000..9aaf3641701370ff57b1a2866a0e5c811cf7ac04 --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/plugin-bugfixes.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/plugin-bugfixes.json"); diff --git a/tools/ui/node_modules/@babel/compat-data/plugins.js b/tools/ui/node_modules/@babel/compat-data/plugins.js new file mode 100644 index 0000000000000000000000000000000000000000..b191017be6a865bb2760ca351d9f1e610693468c --- /dev/null +++ b/tools/ui/node_modules/@babel/compat-data/plugins.js @@ -0,0 +1,2 @@ +// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly +module.exports = require("./data/plugins.json"); diff --git a/tools/ui/node_modules/@babel/core/LICENSE b/tools/ui/node_modules/@babel/core/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/@babel/core/README.md b/tools/ui/node_modules/@babel/core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2903543469699795279ec0c977ee56114bd21e01 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/README.md @@ -0,0 +1,19 @@ +# @babel/core + +> Babel compiler core. + +See our website [@babel/core](https://babeljs.io/docs/babel-core) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/core +``` + +or using yarn: + +```sh +yarn add @babel/core --dev +``` diff --git a/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js b/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js new file mode 100644 index 0000000000000000000000000000000000000000..f2ececdae59d09ca55a8961edd77db7baf7b8bd5 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js @@ -0,0 +1,5 @@ +"use strict"; + +0 && 0; + +//# sourceMappingURL=cache-contexts.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js.map b/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js.map new file mode 100644 index 0000000000000000000000000000000000000000..39b1898d30e8184fd5d489488be517e50f0a75bf --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/cache-contexts.js.map @@ -0,0 +1 @@ +{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { ConfigContext } from \"./config-chain.ts\";\nimport type {\n CallerMetadata,\n TargetsListOrObject,\n} from \"./validation/options.ts\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n targets: TargetsListOrObject;\n} & ConfigContext;\nexport type FullPlugin = {\n assumptions: Record;\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n envName: string;\n caller: CallerMetadata | undefined;\n};\nexport type SimplePreset = {\n targets: TargetsListOrObject;\n} & SimpleConfig;\nexport type SimplePlugin = {\n assumptions: Record;\n} & SimplePreset;\n"],"mappings":"","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/caching.js b/tools/ui/node_modules/@babel/core/lib/config/caching.js new file mode 100644 index 0000000000000000000000000000000000000000..344c8390e3d054513e7c797fef4cfa98f0ba30f7 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/caching.js @@ -0,0 +1,261 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.assertSimpleType = assertSimpleType; +exports.makeStrongCache = makeStrongCache; +exports.makeStrongCacheSync = makeStrongCacheSync; +exports.makeWeakCache = makeWeakCache; +exports.makeWeakCacheSync = makeWeakCacheSync; +function _gensync() { + const data = require("gensync"); + _gensync = function () { + return data; + }; + return data; +} +var _async = require("../gensync-utils/async.js"); +var _util = require("./util.js"); +const synchronize = gen => { + return _gensync()(gen).sync; +}; +function* genTrue() { + return true; +} +function makeWeakCache(handler) { + return makeCachedFunction(WeakMap, handler); +} +function makeWeakCacheSync(handler) { + return synchronize(makeWeakCache(handler)); +} +function makeStrongCache(handler) { + return makeCachedFunction(Map, handler); +} +function makeStrongCacheSync(handler) { + return synchronize(makeStrongCache(handler)); +} +function makeCachedFunction(CallCache, handler) { + const callCacheSync = new CallCache(); + const callCacheAsync = new CallCache(); + const futureCache = new CallCache(); + return function* cachedFunction(arg, data) { + const asyncContext = yield* (0, _async.isAsync)(); + const callCache = asyncContext ? callCacheAsync : callCacheSync; + const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data); + if (cached.valid) return cached.value; + const cache = new CacheConfigurator(data); + const handlerResult = handler(arg, cache); + let finishLock; + let value; + if ((0, _util.isIterableIterator)(handlerResult)) { + value = yield* (0, _async.onFirstPause)(handlerResult, () => { + finishLock = setupAsyncLocks(cache, futureCache, arg); + }); + } else { + value = handlerResult; + } + updateFunctionCache(callCache, cache, arg, value); + if (finishLock) { + futureCache.delete(arg); + finishLock.release(value); + } + return value; + }; +} +function* getCachedValue(cache, arg, data) { + const cachedValue = cache.get(arg); + if (cachedValue) { + for (const { + value, + valid + } of cachedValue) { + if (yield* valid(data)) return { + valid: true, + value + }; + } + } + return { + valid: false, + value: null + }; +} +function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) { + const cached = yield* getCachedValue(callCache, arg, data); + if (cached.valid) { + return cached; + } + if (asyncContext) { + const cached = yield* getCachedValue(futureCache, arg, data); + if (cached.valid) { + const value = yield* (0, _async.waitFor)(cached.value.promise); + return { + valid: true, + value + }; + } + } + return { + valid: false, + value: null + }; +} +function setupAsyncLocks(config, futureCache, arg) { + const finishLock = new Lock(); + updateFunctionCache(futureCache, config, arg, finishLock); + return finishLock; +} +function updateFunctionCache(cache, config, arg, value) { + if (!config.configured()) config.forever(); + let cachedValue = cache.get(arg); + config.deactivate(); + switch (config.mode()) { + case "forever": + cachedValue = [{ + value, + valid: genTrue + }]; + cache.set(arg, cachedValue); + break; + case "invalidate": + cachedValue = [{ + value, + valid: config.validator() + }]; + cache.set(arg, cachedValue); + break; + case "valid": + if (cachedValue) { + cachedValue.push({ + value, + valid: config.validator() + }); + } else { + cachedValue = [{ + value, + valid: config.validator() + }]; + cache.set(arg, cachedValue); + } + } +} +class CacheConfigurator { + constructor(data) { + this._active = true; + this._never = false; + this._forever = false; + this._invalidate = false; + this._configured = false; + this._pairs = []; + this._data = void 0; + this._data = data; + } + simple() { + return makeSimpleConfigurator(this); + } + mode() { + if (this._never) return "never"; + if (this._forever) return "forever"; + if (this._invalidate) return "invalidate"; + return "valid"; + } + forever() { + if (!this._active) { + throw new Error("Cannot change caching after evaluation has completed."); + } + if (this._never) { + throw new Error("Caching has already been configured with .never()"); + } + this._forever = true; + this._configured = true; + } + never() { + if (!this._active) { + throw new Error("Cannot change caching after evaluation has completed."); + } + if (this._forever) { + throw new Error("Caching has already been configured with .forever()"); + } + this._never = true; + this._configured = true; + } + using(handler) { + if (!this._active) { + throw new Error("Cannot change caching after evaluation has completed."); + } + if (this._never || this._forever) { + throw new Error("Caching has already been configured with .never or .forever()"); + } + this._configured = true; + const key = handler(this._data); + const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`); + if ((0, _async.isThenable)(key)) { + return key.then(key => { + this._pairs.push([key, fn]); + return key; + }); + } + this._pairs.push([key, fn]); + return key; + } + invalidate(handler) { + this._invalidate = true; + return this.using(handler); + } + validator() { + const pairs = this._pairs; + return function* (data) { + for (const [key, fn] of pairs) { + if (key !== (yield* fn(data))) return false; + } + return true; + }; + } + deactivate() { + this._active = false; + } + configured() { + return this._configured; + } +} +function makeSimpleConfigurator(cache) { + function cacheFn(val) { + if (typeof val === "boolean") { + if (val) cache.forever();else cache.never(); + return; + } + return cache.using(() => assertSimpleType(val())); + } + cacheFn.forever = () => cache.forever(); + cacheFn.never = () => cache.never(); + cacheFn.using = cb => cache.using(() => assertSimpleType(cb())); + cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb())); + return cacheFn; +} +function assertSimpleType(value) { + if ((0, _async.isThenable)(value)) { + throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`); + } + if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") { + throw new Error("Cache keys must be either string, boolean, number, null, or undefined."); + } + return value; +} +class Lock { + constructor() { + this.released = false; + this.promise = void 0; + this._resolve = void 0; + this.promise = new Promise(resolve => { + this._resolve = resolve; + }); + } + release(value) { + this.released = true; + this._resolve(value); + } +} +0 && 0; + +//# sourceMappingURL=caching.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/caching.js.map b/tools/ui/node_modules/@babel/core/lib/config/caching.js.map new file mode 100644 index 0000000000000000000000000000000000000000..c9a69fd65d4727620da46808e2112a1e76eb7a38 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/caching.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_gensync","data","require","_async","_util","synchronize","gen","gensync","sync","genTrue","makeWeakCache","handler","makeCachedFunction","WeakMap","makeWeakCacheSync","makeStrongCache","Map","makeStrongCacheSync","CallCache","callCacheSync","callCacheAsync","futureCache","cachedFunction","arg","asyncContext","isAsync","callCache","cached","getCachedValueOrWait","valid","value","cache","CacheConfigurator","handlerResult","finishLock","isIterableIterator","onFirstPause","setupAsyncLocks","updateFunctionCache","delete","release","getCachedValue","cachedValue","get","waitFor","promise","config","Lock","configured","forever","deactivate","mode","set","validator","push","constructor","_active","_never","_forever","_invalidate","_configured","_pairs","_data","simple","makeSimpleConfigurator","Error","never","using","key","fn","maybeAsync","isThenable","then","invalidate","pairs","cacheFn","val","assertSimpleType","cb","released","_resolve","Promise","resolve"],"sources":["../../src/config/caching.ts"],"sourcesContent":["import gensync from \"gensync\";\nimport type { Handler } from \"gensync\";\nimport {\n maybeAsync,\n isAsync,\n onFirstPause,\n waitFor,\n isThenable,\n} from \"../gensync-utils/async.ts\";\nimport { isIterableIterator } from \"./util.ts\";\n\nexport type { CacheConfigurator };\n\nexport type SimpleCacheConfigurator = {\n (forever: boolean): void;\n (handler: () => T): T;\n\n forever: () => void;\n never: () => void;\n using: (handler: () => T) => T;\n invalidate: (handler: () => T) => T;\n};\n\nexport type CacheEntry = {\n value: ResultT;\n valid: (channel: SideChannel) => Handler;\n}[];\n\nconst synchronize = (\n gen: (...args: ArgsT) => Handler,\n): ((...args: ArgsT) => ResultT) => {\n return gensync(gen).sync;\n};\n\n// eslint-disable-next-line require-yield\nfunction* genTrue() {\n return true;\n}\n\nexport function makeWeakCache(\n handler: (\n arg: ArgT,\n cache: CacheConfigurator,\n ) => Handler | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler {\n return makeCachedFunction(WeakMap, handler);\n}\n\nexport function makeWeakCacheSync(\n handler: (arg: ArgT, cache?: CacheConfigurator) => ResultT,\n): (arg: ArgT, data?: SideChannel) => ResultT {\n return synchronize<[ArgT, SideChannel], ResultT>(\n makeWeakCache(handler),\n );\n}\n\nexport function makeStrongCache(\n handler: (\n arg: ArgT,\n cache: CacheConfigurator,\n ) => Handler | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler {\n return makeCachedFunction(Map, handler);\n}\n\nexport function makeStrongCacheSync(\n handler: (arg: ArgT, cache?: CacheConfigurator) => ResultT,\n): (arg: ArgT, data?: SideChannel) => ResultT {\n return synchronize<[ArgT, SideChannel], ResultT>(\n makeStrongCache(handler),\n );\n}\n\n/* NOTE: Part of the logic explained in this comment is explained in the\n * getCachedValueOrWait and setupAsyncLocks functions.\n *\n * > There are only two hard things in Computer Science: cache invalidation and naming things.\n * > -- Phil Karlton\n *\n * I don't know if Phil was also thinking about handling a cache whose invalidation function is\n * defined asynchronously is considered, but it is REALLY hard to do correctly.\n *\n * The implemented logic (only when gensync is run asynchronously) is the following:\n * 1. If there is a valid cache associated to the current \"arg\" parameter,\n * a. RETURN the cached value\n * 3. If there is a FinishLock associated to the current \"arg\" parameter representing a valid cache,\n * a. Wait for that lock to be released\n * b. RETURN the value associated with that lock\n * 5. Start executing the function to be cached\n * a. If it pauses on a promise, then\n * i. Let FinishLock be a new lock\n * ii. Store FinishLock as associated to the current \"arg\" parameter\n * iii. Wait for the function to finish executing\n * iv. Release FinishLock\n * v. Send the function result to anyone waiting on FinishLock\n * 6. Store the result in the cache\n * 7. RETURN the result\n */\nfunction makeCachedFunction(\n CallCache: new () => CacheMap,\n handler: (\n arg: ArgT,\n cache: CacheConfigurator,\n ) => Handler | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler {\n const callCacheSync = new CallCache();\n const callCacheAsync = new CallCache();\n const futureCache = new CallCache>();\n\n return function* cachedFunction(arg: ArgT, data: SideChannel) {\n const asyncContext = yield* isAsync();\n const callCache = asyncContext ? callCacheAsync : callCacheSync;\n\n const cached = yield* getCachedValueOrWait(\n asyncContext,\n callCache,\n futureCache,\n arg,\n data,\n );\n if (cached.valid) return cached.value;\n\n const cache = new CacheConfigurator(data);\n\n const handlerResult: Handler | ResultT = handler(arg, cache);\n\n let finishLock: Lock;\n let value: ResultT;\n\n if (isIterableIterator(handlerResult)) {\n value = yield* onFirstPause(handlerResult, () => {\n finishLock = setupAsyncLocks(cache, futureCache, arg);\n });\n } else {\n value = handlerResult;\n }\n\n updateFunctionCache(callCache, cache, arg, value);\n\n if (finishLock) {\n futureCache.delete(arg);\n finishLock.release(value);\n }\n\n return value;\n };\n}\n\ntype CacheMap =\n | Map>\n // @ts-expect-error todo(flow->ts): add `extends object` constraint to ArgT\n | WeakMap>;\n\nfunction* getCachedValue(\n cache: CacheMap,\n arg: ArgT,\n data: SideChannel,\n): Handler<{ valid: true; value: ResultT } | { valid: false; value: null }> {\n const cachedValue: CacheEntry | void = cache.get(arg);\n\n if (cachedValue) {\n for (const { value, valid } of cachedValue) {\n if (yield* valid(data)) return { valid: true, value };\n }\n }\n\n return { valid: false, value: null };\n}\n\nfunction* getCachedValueOrWait(\n asyncContext: boolean,\n callCache: CacheMap,\n futureCache: CacheMap, SideChannel>,\n arg: ArgT,\n data: SideChannel,\n): Handler<{ valid: true; value: ResultT } | { valid: false; value: null }> {\n const cached = yield* getCachedValue(callCache, arg, data);\n if (cached.valid) {\n return cached;\n }\n\n if (asyncContext) {\n const cached = yield* getCachedValue(futureCache, arg, data);\n if (cached.valid) {\n const value = yield* waitFor(cached.value.promise);\n return { valid: true, value };\n }\n }\n\n return { valid: false, value: null };\n}\n\nfunction setupAsyncLocks(\n config: CacheConfigurator,\n futureCache: CacheMap, SideChannel>,\n arg: ArgT,\n): Lock {\n const finishLock = new Lock();\n\n updateFunctionCache(futureCache, config, arg, finishLock);\n\n return finishLock;\n}\n\nfunction updateFunctionCache<\n ArgT,\n ResultT,\n SideChannel,\n Cache extends CacheMap,\n>(\n cache: Cache,\n config: CacheConfigurator,\n arg: ArgT,\n value: ResultT,\n) {\n if (!config.configured()) config.forever();\n\n let cachedValue: CacheEntry | void = cache.get(arg);\n\n config.deactivate();\n\n switch (config.mode()) {\n case \"forever\":\n cachedValue = [{ value, valid: genTrue }];\n cache.set(arg, cachedValue);\n break;\n case \"invalidate\":\n cachedValue = [{ value, valid: config.validator() }];\n cache.set(arg, cachedValue);\n break;\n case \"valid\":\n if (cachedValue) {\n cachedValue.push({ value, valid: config.validator() });\n } else {\n cachedValue = [{ value, valid: config.validator() }];\n cache.set(arg, cachedValue);\n }\n }\n}\n\nclass CacheConfigurator {\n _active: boolean = true;\n _never: boolean = false;\n _forever: boolean = false;\n _invalidate: boolean = false;\n\n _configured: boolean = false;\n\n _pairs: [\n cachedValue: unknown,\n handler: (data: SideChannel) => Handler,\n ][] = [];\n\n _data: SideChannel;\n\n constructor(data: SideChannel) {\n this._data = data;\n }\n\n simple() {\n return makeSimpleConfigurator(this);\n }\n\n mode() {\n if (this._never) return \"never\";\n if (this._forever) return \"forever\";\n if (this._invalidate) return \"invalidate\";\n return \"valid\";\n }\n\n forever() {\n if (!this._active) {\n throw new Error(\"Cannot change caching after evaluation has completed.\");\n }\n if (this._never) {\n throw new Error(\"Caching has already been configured with .never()\");\n }\n this._forever = true;\n this._configured = true;\n }\n\n never() {\n if (!this._active) {\n throw new Error(\"Cannot change caching after evaluation has completed.\");\n }\n if (this._forever) {\n throw new Error(\"Caching has already been configured with .forever()\");\n }\n this._never = true;\n this._configured = true;\n }\n\n using(handler: (data: SideChannel) => T): T {\n if (!this._active) {\n throw new Error(\"Cannot change caching after evaluation has completed.\");\n }\n if (this._never || this._forever) {\n throw new Error(\n \"Caching has already been configured with .never or .forever()\",\n );\n }\n this._configured = true;\n\n const key = handler(this._data);\n\n const fn = maybeAsync(\n handler,\n `You appear to be using an async cache handler, but Babel has been called synchronously`,\n );\n\n if (isThenable(key)) {\n // @ts-expect-error todo(flow->ts): improve function return type annotation\n return key.then((key: unknown) => {\n this._pairs.push([key, fn]);\n return key;\n });\n }\n\n this._pairs.push([key, fn]);\n return key;\n }\n\n invalidate(handler: (data: SideChannel) => T): T {\n this._invalidate = true;\n return this.using(handler);\n }\n\n validator(): (data: SideChannel) => Handler {\n const pairs = this._pairs;\n return function* (data: SideChannel) {\n for (const [key, fn] of pairs) {\n if (key !== (yield* fn(data))) return false;\n }\n return true;\n };\n }\n\n deactivate() {\n this._active = false;\n }\n\n configured() {\n return this._configured;\n }\n}\n\nfunction makeSimpleConfigurator(\n cache: CacheConfigurator,\n): SimpleCacheConfigurator {\n function cacheFn(val: any) {\n if (typeof val === \"boolean\") {\n if (val) cache.forever();\n else cache.never();\n return;\n }\n\n return cache.using(() => assertSimpleType(val()));\n }\n cacheFn.forever = () => cache.forever();\n cacheFn.never = () => cache.never();\n cacheFn.using = (cb: () => SimpleType) =>\n cache.using(() => assertSimpleType(cb()));\n cacheFn.invalidate = (cb: () => SimpleType) =>\n cache.invalidate(() => assertSimpleType(cb()));\n\n return cacheFn as any;\n}\n\n// Types are limited here so that in the future these values can be used\n// as part of Babel's caching logic.\nexport type SimpleType =\n | string\n | boolean\n | number\n | null\n | void\n | Promise;\nexport function assertSimpleType(value: unknown): SimpleType {\n if (isThenable(value)) {\n throw new Error(\n `You appear to be using an async cache handler, ` +\n `which your current version of Babel does not support. ` +\n `We may add support for this in the future, ` +\n `but if you're on the most recent version of @babel/core and still ` +\n `seeing this error, then you'll need to synchronously handle your caching logic.`,\n );\n }\n\n if (\n value != null &&\n typeof value !== \"string\" &&\n typeof value !== \"boolean\" &&\n typeof value !== \"number\"\n ) {\n throw new Error(\n \"Cache keys must be either string, boolean, number, null, or undefined.\",\n );\n }\n // @ts-expect-error Type 'unknown' is not assignable to type 'SimpleType'. This can be removed\n // when strictNullCheck is enabled\n return value;\n}\n\nclass Lock {\n released: boolean = false;\n promise: Promise;\n _resolve: (value: T) => void;\n\n constructor() {\n this.promise = new Promise(resolve => {\n this._resolve = resolve;\n });\n }\n\n release(value: T) {\n this.released = true;\n this._resolve(value);\n }\n}\n"],"mappings":";;;;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,IAAAE,MAAA,GAAAD,OAAA;AAOA,IAAAE,KAAA,GAAAF,OAAA;AAmBA,MAAMG,WAAW,GACfC,GAAyC,IACP;EAClC,OAAOC,SAAMA,CAAC,CAACD,GAAG,CAAC,CAACE,IAAI;AAC1B,CAAC;AAGD,UAAUC,OAAOA,CAAA,EAAG;EAClB,OAAO,IAAI;AACb;AAEO,SAASC,aAAaA,CAC3BC,OAG+B,EACqB;EACpD,OAAOC,kBAAkB,CAA6BC,OAAO,EAAEF,OAAO,CAAC;AACzE;AAEO,SAASG,iBAAiBA,CAC/BH,OAAuE,EAC3B;EAC5C,OAAON,WAAW,CAChBK,aAAa,CAA6BC,OAAO,CACnD,CAAC;AACH;AAEO,SAASI,eAAeA,CAC7BJ,OAG+B,EACqB;EACpD,OAAOC,kBAAkB,CAA6BI,GAAG,EAAEL,OAAO,CAAC;AACrE;AAEO,SAASM,mBAAmBA,CACjCN,OAAuE,EAC3B;EAC5C,OAAON,WAAW,CAChBU,eAAe,CAA6BJ,OAAO,CACrD,CAAC;AACH;AA2BA,SAASC,kBAAkBA,CACzBM,SAAgE,EAChEP,OAG+B,EACqB;EACpD,MAAMQ,aAAa,GAAG,IAAID,SAAS,CAAU,CAAC;EAC9C,MAAME,cAAc,GAAG,IAAIF,SAAS,CAAU,CAAC;EAC/C,MAAMG,WAAW,GAAG,IAAIH,SAAS,CAAgB,CAAC;EAElD,OAAO,UAAUI,cAAcA,CAACC,GAAS,EAAEtB,IAAiB,EAAE;IAC5D,MAAMuB,YAAY,GAAG,OAAO,IAAAC,cAAO,EAAC,CAAC;IACrC,MAAMC,SAAS,GAAGF,YAAY,GAAGJ,cAAc,GAAGD,aAAa;IAE/D,MAAMQ,MAAM,GAAG,OAAOC,oBAAoB,CACxCJ,YAAY,EACZE,SAAS,EACTL,WAAW,EACXE,GAAG,EACHtB,IACF,CAAC;IACD,IAAI0B,MAAM,CAACE,KAAK,EAAE,OAAOF,MAAM,CAACG,KAAK;IAErC,MAAMC,KAAK,GAAG,IAAIC,iBAAiB,CAAC/B,IAAI,CAAC;IAEzC,MAAMgC,aAAyC,GAAGtB,OAAO,CAACY,GAAG,EAAEQ,KAAK,CAAC;IAErE,IAAIG,UAAyB;IAC7B,IAAIJ,KAAc;IAElB,IAAI,IAAAK,wBAAkB,EAACF,aAAa,CAAC,EAAE;MACrCH,KAAK,GAAG,OAAO,IAAAM,mBAAY,EAACH,aAAa,EAAE,MAAM;QAC/CC,UAAU,GAAGG,eAAe,CAACN,KAAK,EAAEV,WAAW,EAAEE,GAAG,CAAC;MACvD,CAAC,CAAC;IACJ,CAAC,MAAM;MACLO,KAAK,GAAGG,aAAa;IACvB;IAEAK,mBAAmB,CAACZ,SAAS,EAAEK,KAAK,EAAER,GAAG,EAAEO,KAAK,CAAC;IAEjD,IAAII,UAAU,EAAE;MACdb,WAAW,CAACkB,MAAM,CAAChB,GAAG,CAAC;MACvBW,UAAU,CAACM,OAAO,CAACV,KAAK,CAAC;IAC3B;IAEA,OAAOA,KAAK;EACd,CAAC;AACH;AAOA,UAAUW,cAAcA,CACtBV,KAA2C,EAC3CR,GAAS,EACTtB,IAAiB,EACyD;EAC1E,MAAMyC,WAAoD,GAAGX,KAAK,CAACY,GAAG,CAACpB,GAAG,CAAC;EAE3E,IAAImB,WAAW,EAAE;IACf,KAAK,MAAM;MAAEZ,KAAK;MAAED;IAAM,CAAC,IAAIa,WAAW,EAAE;MAC1C,IAAI,OAAOb,KAAK,CAAC5B,IAAI,CAAC,EAAE,OAAO;QAAE4B,KAAK,EAAE,IAAI;QAAEC;MAAM,CAAC;IACvD;EACF;EAEA,OAAO;IAAED,KAAK,EAAE,KAAK;IAAEC,KAAK,EAAE;EAAK,CAAC;AACtC;AAEA,UAAUF,oBAAoBA,CAC5BJ,YAAqB,EACrBE,SAA+C,EAC/CL,WAAuD,EACvDE,GAAS,EACTtB,IAAiB,EACyD;EAC1E,MAAM0B,MAAM,GAAG,OAAOc,cAAc,CAACf,SAAS,EAAEH,GAAG,EAAEtB,IAAI,CAAC;EAC1D,IAAI0B,MAAM,CAACE,KAAK,EAAE;IAChB,OAAOF,MAAM;EACf;EAEA,IAAIH,YAAY,EAAE;IAChB,MAAMG,MAAM,GAAG,OAAOc,cAAc,CAACpB,WAAW,EAAEE,GAAG,EAAEtB,IAAI,CAAC;IAC5D,IAAI0B,MAAM,CAACE,KAAK,EAAE;MAChB,MAAMC,KAAK,GAAG,OAAO,IAAAc,cAAO,EAAUjB,MAAM,CAACG,KAAK,CAACe,OAAO,CAAC;MAC3D,OAAO;QAAEhB,KAAK,EAAE,IAAI;QAAEC;MAAM,CAAC;IAC/B;EACF;EAEA,OAAO;IAAED,KAAK,EAAE,KAAK;IAAEC,KAAK,EAAE;EAAK,CAAC;AACtC;AAEA,SAASO,eAAeA,CACtBS,MAAsC,EACtCzB,WAAuD,EACvDE,GAAS,EACM;EACf,MAAMW,UAAU,GAAG,IAAIa,IAAI,CAAU,CAAC;EAEtCT,mBAAmB,CAACjB,WAAW,EAAEyB,MAAM,EAAEvB,GAAG,EAAEW,UAAU,CAAC;EAEzD,OAAOA,UAAU;AACnB;AAEA,SAASI,mBAAmBA,CAM1BP,KAAY,EACZe,MAAsC,EACtCvB,GAAS,EACTO,KAAc,EACd;EACA,IAAI,CAACgB,MAAM,CAACE,UAAU,CAAC,CAAC,EAAEF,MAAM,CAACG,OAAO,CAAC,CAAC;EAE1C,IAAIP,WAAoD,GAAGX,KAAK,CAACY,GAAG,CAACpB,GAAG,CAAC;EAEzEuB,MAAM,CAACI,UAAU,CAAC,CAAC;EAEnB,QAAQJ,MAAM,CAACK,IAAI,CAAC,CAAC;IACnB,KAAK,SAAS;MACZT,WAAW,GAAG,CAAC;QAAEZ,KAAK;QAAED,KAAK,EAAEpB;MAAQ,CAAC,CAAC;MACzCsB,KAAK,CAACqB,GAAG,CAAC7B,GAAG,EAAEmB,WAAW,CAAC;MAC3B;IACF,KAAK,YAAY;MACfA,WAAW,GAAG,CAAC;QAAEZ,KAAK;QAAED,KAAK,EAAEiB,MAAM,CAACO,SAAS,CAAC;MAAE,CAAC,CAAC;MACpDtB,KAAK,CAACqB,GAAG,CAAC7B,GAAG,EAAEmB,WAAW,CAAC;MAC3B;IACF,KAAK,OAAO;MACV,IAAIA,WAAW,EAAE;QACfA,WAAW,CAACY,IAAI,CAAC;UAAExB,KAAK;UAAED,KAAK,EAAEiB,MAAM,CAACO,SAAS,CAAC;QAAE,CAAC,CAAC;MACxD,CAAC,MAAM;QACLX,WAAW,GAAG,CAAC;UAAEZ,KAAK;UAAED,KAAK,EAAEiB,MAAM,CAACO,SAAS,CAAC;QAAE,CAAC,CAAC;QACpDtB,KAAK,CAACqB,GAAG,CAAC7B,GAAG,EAAEmB,WAAW,CAAC;MAC7B;EACJ;AACF;AAEA,MAAMV,iBAAiB,CAAqB;EAe1CuB,WAAWA,CAACtD,IAAiB,EAAE;IAAA,KAd/BuD,OAAO,GAAY,IAAI;IAAA,KACvBC,MAAM,GAAY,KAAK;IAAA,KACvBC,QAAQ,GAAY,KAAK;IAAA,KACzBC,WAAW,GAAY,KAAK;IAAA,KAE5BC,WAAW,GAAY,KAAK;IAAA,KAE5BC,MAAM,GAGA,EAAE;IAAA,KAERC,KAAK;IAGH,IAAI,CAACA,KAAK,GAAG7D,IAAI;EACnB;EAEA8D,MAAMA,CAAA,EAAG;IACP,OAAOC,sBAAsB,CAAC,IAAI,CAAC;EACrC;EAEAb,IAAIA,CAAA,EAAG;IACL,IAAI,IAAI,CAACM,MAAM,EAAE,OAAO,OAAO;IAC/B,IAAI,IAAI,CAACC,QAAQ,EAAE,OAAO,SAAS;IACnC,IAAI,IAAI,CAACC,WAAW,EAAE,OAAO,YAAY;IACzC,OAAO,OAAO;EAChB;EAEAV,OAAOA,CAAA,EAAG;IACR,IAAI,CAAC,IAAI,CAACO,OAAO,EAAE;MACjB,MAAM,IAAIS,KAAK,CAAC,uDAAuD,CAAC;IAC1E;IACA,IAAI,IAAI,CAACR,MAAM,EAAE;MACf,MAAM,IAAIQ,KAAK,CAAC,mDAAmD,CAAC;IACtE;IACA,IAAI,CAACP,QAAQ,GAAG,IAAI;IACpB,IAAI,CAACE,WAAW,GAAG,IAAI;EACzB;EAEAM,KAAKA,CAAA,EAAG;IACN,IAAI,CAAC,IAAI,CAACV,OAAO,EAAE;MACjB,MAAM,IAAIS,KAAK,CAAC,uDAAuD,CAAC;IAC1E;IACA,IAAI,IAAI,CAACP,QAAQ,EAAE;MACjB,MAAM,IAAIO,KAAK,CAAC,qDAAqD,CAAC;IACxE;IACA,IAAI,CAACR,MAAM,GAAG,IAAI;IAClB,IAAI,CAACG,WAAW,GAAG,IAAI;EACzB;EAEAO,KAAKA,CAAIxD,OAAiC,EAAK;IAC7C,IAAI,CAAC,IAAI,CAAC6C,OAAO,EAAE;MACjB,MAAM,IAAIS,KAAK,CAAC,uDAAuD,CAAC;IAC1E;IACA,IAAI,IAAI,CAACR,MAAM,IAAI,IAAI,CAACC,QAAQ,EAAE;MAChC,MAAM,IAAIO,KAAK,CACb,+DACF,CAAC;IACH;IACA,IAAI,CAACL,WAAW,GAAG,IAAI;IAEvB,MAAMQ,GAAG,GAAGzD,OAAO,CAAC,IAAI,CAACmD,KAAK,CAAC;IAE/B,MAAMO,EAAE,GAAG,IAAAC,iBAAU,EACnB3D,OAAO,EACP,wFACF,CAAC;IAED,IAAI,IAAA4D,iBAAU,EAACH,GAAG,CAAC,EAAE;MAEnB,OAAOA,GAAG,CAACI,IAAI,CAAEJ,GAAY,IAAK;QAChC,IAAI,CAACP,MAAM,CAACP,IAAI,CAAC,CAACc,GAAG,EAAEC,EAAE,CAAC,CAAC;QAC3B,OAAOD,GAAG;MACZ,CAAC,CAAC;IACJ;IAEA,IAAI,CAACP,MAAM,CAACP,IAAI,CAAC,CAACc,GAAG,EAAEC,EAAE,CAAC,CAAC;IAC3B,OAAOD,GAAG;EACZ;EAEAK,UAAUA,CAAI9D,OAAiC,EAAK;IAClD,IAAI,CAACgD,WAAW,GAAG,IAAI;IACvB,OAAO,IAAI,CAACQ,KAAK,CAACxD,OAAO,CAAC;EAC5B;EAEA0C,SAASA,CAAA,EAA4C;IACnD,MAAMqB,KAAK,GAAG,IAAI,CAACb,MAAM;IACzB,OAAO,WAAW5D,IAAiB,EAAE;MACnC,KAAK,MAAM,CAACmE,GAAG,EAAEC,EAAE,CAAC,IAAIK,KAAK,EAAE;QAC7B,IAAIN,GAAG,MAAM,OAAOC,EAAE,CAACpE,IAAI,CAAC,CAAC,EAAE,OAAO,KAAK;MAC7C;MACA,OAAO,IAAI;IACb,CAAC;EACH;EAEAiD,UAAUA,CAAA,EAAG;IACX,IAAI,CAACM,OAAO,GAAG,KAAK;EACtB;EAEAR,UAAUA,CAAA,EAAG;IACX,OAAO,IAAI,CAACY,WAAW;EACzB;AACF;AAEA,SAASI,sBAAsBA,CAC7BjC,KAA6B,EACJ;EACzB,SAAS4C,OAAOA,CAACC,GAAQ,EAAE;IACzB,IAAI,OAAOA,GAAG,KAAK,SAAS,EAAE;MAC5B,IAAIA,GAAG,EAAE7C,KAAK,CAACkB,OAAO,CAAC,CAAC,CAAC,KACpBlB,KAAK,CAACmC,KAAK,CAAC,CAAC;MAClB;IACF;IAEA,OAAOnC,KAAK,CAACoC,KAAK,CAAC,MAAMU,gBAAgB,CAACD,GAAG,CAAC,CAAC,CAAC,CAAC;EACnD;EACAD,OAAO,CAAC1B,OAAO,GAAG,MAAMlB,KAAK,CAACkB,OAAO,CAAC,CAAC;EACvC0B,OAAO,CAACT,KAAK,GAAG,MAAMnC,KAAK,CAACmC,KAAK,CAAC,CAAC;EACnCS,OAAO,CAACR,KAAK,GAAIW,EAAoB,IACnC/C,KAAK,CAACoC,KAAK,CAAC,MAAMU,gBAAgB,CAACC,EAAE,CAAC,CAAC,CAAC,CAAC;EAC3CH,OAAO,CAACF,UAAU,GAAIK,EAAoB,IACxC/C,KAAK,CAAC0C,UAAU,CAAC,MAAMI,gBAAgB,CAACC,EAAE,CAAC,CAAC,CAAC,CAAC;EAEhD,OAAOH,OAAO;AAChB;AAWO,SAASE,gBAAgBA,CAAC/C,KAAc,EAAc;EAC3D,IAAI,IAAAyC,iBAAU,EAACzC,KAAK,CAAC,EAAE;IACrB,MAAM,IAAImC,KAAK,CACb,iDAAiD,GAC/C,wDAAwD,GACxD,6CAA6C,GAC7C,oEAAoE,GACpE,iFACJ,CAAC;EACH;EAEA,IACEnC,KAAK,IAAI,IAAI,IACb,OAAOA,KAAK,KAAK,QAAQ,IACzB,OAAOA,KAAK,KAAK,SAAS,IAC1B,OAAOA,KAAK,KAAK,QAAQ,EACzB;IACA,MAAM,IAAImC,KAAK,CACb,wEACF,CAAC;EACH;EAGA,OAAOnC,KAAK;AACd;AAEA,MAAMiB,IAAI,CAAI;EAKZQ,WAAWA,CAAA,EAAG;IAAA,KAJdwB,QAAQ,GAAY,KAAK;IAAA,KACzBlC,OAAO;IAAA,KACPmC,QAAQ;IAGN,IAAI,CAACnC,OAAO,GAAG,IAAIoC,OAAO,CAACC,OAAO,IAAI;MACpC,IAAI,CAACF,QAAQ,GAAGE,OAAO;IACzB,CAAC,CAAC;EACJ;EAEA1C,OAAOA,CAACV,KAAQ,EAAE;IAChB,IAAI,CAACiD,QAAQ,GAAG,IAAI;IACpB,IAAI,CAACC,QAAQ,CAAClD,KAAK,CAAC;EACtB;AACF;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/config-chain.js b/tools/ui/node_modules/@babel/core/lib/config/config-chain.js new file mode 100644 index 0000000000000000000000000000000000000000..5fded8e6b84cbc073667b8788e880f7b07025c6e --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/config-chain.js @@ -0,0 +1,469 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.buildPresetChain = buildPresetChain; +exports.buildPresetChainWalker = void 0; +exports.buildRootChain = buildRootChain; +function _path() { + const data = require("path"); + _path = function () { + return data; + }; + return data; +} +function _debug() { + const data = require("debug"); + _debug = function () { + return data; + }; + return data; +} +var _options = require("./validation/options.js"); +var _patternToRegex = require("./pattern-to-regex.js"); +var _printer = require("./printer.js"); +var _rewriteStackTrace = require("../errors/rewrite-stack-trace.js"); +var _configError = require("../errors/config-error.js"); +var _index = require("./files/index.js"); +var _caching = require("./caching.js"); +var _configDescriptors = require("./config-descriptors.js"); +const debug = _debug()("babel:config:config-chain"); +function* buildPresetChain(arg, context) { + const chain = yield* buildPresetChainWalker(arg, context); + if (!chain) return null; + return { + plugins: dedupDescriptors(chain.plugins), + presets: dedupDescriptors(chain.presets), + options: chain.options.map(o => createConfigChainOptions(o)), + files: new Set() + }; +} +const buildPresetChainWalker = exports.buildPresetChainWalker = makeChainWalker({ + root: preset => loadPresetDescriptors(preset), + env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName), + overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index), + overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName), + createLogger: () => () => {} +}); +const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors)); +const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName))); +const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index))); +const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName)))); +function* buildRootChain(opts, context) { + let configReport, babelRcReport; + const programmaticLogger = new _printer.ConfigPrinter(); + const programmaticChain = yield* loadProgrammaticChain({ + options: opts, + dirname: context.cwd + }, context, undefined, programmaticLogger); + if (!programmaticChain) return null; + const programmaticReport = yield* programmaticLogger.output(); + let configFile; + if (typeof opts.configFile === "string") { + configFile = yield* (0, _index.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller); + } else if (opts.configFile !== false) { + configFile = yield* (0, _index.findRootConfig)(context.root, context.envName, context.caller); + } + let { + babelrc, + babelrcRoots + } = opts; + let babelrcRootsDirectory = context.cwd; + const configFileChain = emptyChain(); + const configFileLogger = new _printer.ConfigPrinter(); + if (configFile) { + const validatedFile = validateConfigFile(configFile); + const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger); + if (!result) return null; + configReport = yield* configFileLogger.output(); + if (babelrc === undefined) { + babelrc = validatedFile.options.babelrc; + } + if (babelrcRoots === undefined) { + babelrcRootsDirectory = validatedFile.dirname; + babelrcRoots = validatedFile.options.babelrcRoots; + } + mergeChain(configFileChain, result); + } + let ignoreFile, babelrcFile; + let isIgnored = false; + const fileChain = emptyChain(); + if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") { + const pkgData = yield* (0, _index.findPackageData)(context.filename); + if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) { + ({ + ignore: ignoreFile, + config: babelrcFile + } = yield* (0, _index.findRelativeConfig)(pkgData, context.envName, context.caller)); + if (ignoreFile) { + fileChain.files.add(ignoreFile.filepath); + } + if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) { + isIgnored = true; + } + if (babelrcFile && !isIgnored) { + const validatedFile = validateBabelrcFile(babelrcFile); + const babelrcLogger = new _printer.ConfigPrinter(); + const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger); + if (!result) { + isIgnored = true; + } else { + babelRcReport = yield* babelrcLogger.output(); + mergeChain(fileChain, result); + } + } + if (babelrcFile && isIgnored) { + fileChain.files.add(babelrcFile.filepath); + } + } + } + if (context.showConfig) { + console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----"); + } + const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain); + return { + plugins: isIgnored ? [] : dedupDescriptors(chain.plugins), + presets: isIgnored ? [] : dedupDescriptors(chain.presets), + options: isIgnored ? [] : chain.options.map(o => createConfigChainOptions(o)), + fileHandling: isIgnored ? "ignored" : "transpile", + ignore: ignoreFile || undefined, + babelrc: babelrcFile || undefined, + config: configFile || undefined, + files: chain.files + }; +} +function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) { + if (typeof babelrcRoots === "boolean") return babelrcRoots; + const absoluteRoot = context.root; + if (babelrcRoots === undefined) { + return pkgData.directories.includes(absoluteRoot); + } + let babelrcPatterns = babelrcRoots; + if (!Array.isArray(babelrcPatterns)) { + babelrcPatterns = [babelrcPatterns]; + } + babelrcPatterns = babelrcPatterns.map(pat => { + return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat; + }); + if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) { + return pkgData.directories.includes(absoluteRoot); + } + return babelrcPatterns.some(pat => { + if (typeof pat === "string") { + pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory); + } + return pkgData.directories.some(directory => { + return matchPattern(pat, babelrcRootsDirectory, directory, context); + }); + }); +} +const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({ + filepath: file.filepath, + dirname: file.dirname, + options: (0, _options.validate)("configfile", file.options, file.filepath) +})); +const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({ + filepath: file.filepath, + dirname: file.dirname, + options: (0, _options.validate)("babelrcfile", file.options, file.filepath) +})); +const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({ + filepath: file.filepath, + dirname: file.dirname, + options: (0, _options.validate)("extendsfile", file.options, file.filepath) +})); +const loadProgrammaticChain = makeChainWalker({ + root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors), + env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName), + overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index), + overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName), + createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger) +}); +const loadFileChainWalker = makeChainWalker({ + root: file => loadFileDescriptors(file), + env: (file, envName) => loadFileEnvDescriptors(file)(envName), + overrides: (file, index) => loadFileOverridesDescriptors(file)(index), + overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName), + createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger) +}); +function* loadFileChain(input, context, files, baseLogger) { + const chain = yield* loadFileChainWalker(input, context, files, baseLogger); + chain == null || chain.files.add(input.filepath); + return chain; +} +const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors)); +const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName))); +const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index))); +const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName)))); +function buildFileLogger(filepath, context, baseLogger) { + if (!baseLogger) { + return () => {}; + } + return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, { + filepath + }); +} +function buildRootDescriptors({ + dirname, + options +}, alias, descriptors) { + return descriptors(dirname, options, alias); +} +function buildProgrammaticLogger(_, context, baseLogger) { + var _context$caller; + if (!baseLogger) { + return () => {}; + } + return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, { + callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name + }); +} +function buildEnvDescriptors({ + dirname, + options +}, alias, descriptors, envName) { + var _options$env; + const opts = (_options$env = options.env) == null ? void 0 : _options$env[envName]; + return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null; +} +function buildOverrideDescriptors({ + dirname, + options +}, alias, descriptors, index) { + var _options$overrides; + const opts = (_options$overrides = options.overrides) == null ? void 0 : _options$overrides[index]; + if (!opts) throw new Error("Assertion failure - missing override"); + return descriptors(dirname, opts, `${alias}.overrides[${index}]`); +} +function buildOverrideEnvDescriptors({ + dirname, + options +}, alias, descriptors, index, envName) { + var _options$overrides2, _override$env; + const override = (_options$overrides2 = options.overrides) == null ? void 0 : _options$overrides2[index]; + if (!override) throw new Error("Assertion failure - missing override"); + const opts = (_override$env = override.env) == null ? void 0 : _override$env[envName]; + return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null; +} +function makeChainWalker({ + root, + env, + overrides, + overridesEnv, + createLogger +}) { + return function* chainWalker(input, context, files = new Set(), baseLogger) { + const { + dirname + } = input; + const flattenedConfigs = []; + const rootOpts = root(input); + if (configIsApplicable(rootOpts, dirname, context, input.filepath)) { + flattenedConfigs.push({ + config: rootOpts, + envName: undefined, + index: undefined + }); + const envOpts = env(input, context.envName); + if (envOpts && configIsApplicable(envOpts, dirname, context, input.filepath)) { + flattenedConfigs.push({ + config: envOpts, + envName: context.envName, + index: undefined + }); + } + (rootOpts.options.overrides || []).forEach((_, index) => { + const overrideOps = overrides(input, index); + if (configIsApplicable(overrideOps, dirname, context, input.filepath)) { + flattenedConfigs.push({ + config: overrideOps, + index, + envName: undefined + }); + const overrideEnvOpts = overridesEnv(input, index, context.envName); + if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context, input.filepath)) { + flattenedConfigs.push({ + config: overrideEnvOpts, + index, + envName: context.envName + }); + } + } + }); + } + if (flattenedConfigs.some(({ + config: { + options: { + ignore, + only + } + } + }) => shouldIgnore(context, ignore, only, dirname))) { + return null; + } + const chain = emptyChain(); + const logger = createLogger(input, context, baseLogger); + for (const { + config, + index, + envName + } of flattenedConfigs) { + if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) { + return null; + } + logger(config, index, envName); + yield* mergeChainOpts(chain, config); + } + return chain; + }; +} +function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) { + if (opts.extends === undefined) return true; + const file = yield* (0, _index.loadConfig)(opts.extends, dirname, context.envName, context.caller); + if (files.has(file)) { + throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n")); + } + files.add(file); + const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger); + files.delete(file); + if (!fileChain) return false; + mergeChain(chain, fileChain); + return true; +} +function mergeChain(target, source) { + target.options.push(...source.options); + target.plugins.push(...source.plugins); + target.presets.push(...source.presets); + for (const file of source.files) { + target.files.add(file); + } + return target; +} +function* mergeChainOpts(target, { + options, + plugins, + presets +}) { + target.options.push(options); + target.plugins.push(...(yield* plugins())); + target.presets.push(...(yield* presets())); + return target; +} +function emptyChain() { + return { + options: [], + presets: [], + plugins: [], + files: new Set() + }; +} +function createConfigChainOptions(opts) { + const options = Object.assign({}, opts); + delete options.extends; + delete options.env; + delete options.overrides; + delete options.plugins; + delete options.presets; + delete options.passPerPreset; + delete options.ignore; + delete options.only; + delete options.test; + delete options.include; + delete options.exclude; + if (hasOwnProperty.call(options, "sourceMap")) { + options.sourceMaps = options.sourceMap; + delete options.sourceMap; + } + return options; +} +function dedupDescriptors(items) { + const map = new Map(); + const descriptors = []; + for (const item of items) { + if (typeof item.value === "function") { + const fnKey = item.value; + let nameMap = map.get(fnKey); + if (!nameMap) { + nameMap = new Map(); + map.set(fnKey, nameMap); + } + let desc = nameMap.get(item.name); + if (!desc) { + desc = { + value: item + }; + descriptors.push(desc); + if (!item.ownPass) nameMap.set(item.name, desc); + } else { + desc.value = item; + } + } else { + descriptors.push({ + value: item + }); + } + } + return descriptors.reduce((acc, desc) => { + acc.push(desc.value); + return acc; + }, []); +} +function configIsApplicable({ + options +}, dirname, context, configName) { + return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname, configName)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname, configName)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname, configName)); +} +function configFieldIsApplicable(context, test, dirname, configName) { + const patterns = Array.isArray(test) ? test : [test]; + return matchesPatterns(context, patterns, dirname, configName); +} +function ignoreListReplacer(_key, value) { + if (value instanceof RegExp) { + return String(value); + } + return value; +} +function shouldIgnore(context, ignore, only, dirname) { + if (ignore && matchesPatterns(context, ignore, dirname)) { + var _context$filename; + const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore, ignoreListReplacer)}\` from "${dirname}"`; + debug(message); + if (context.showConfig) { + console.log(message); + } + return true; + } + if (only && !matchesPatterns(context, only, dirname)) { + var _context$filename2; + const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only, ignoreListReplacer)}\` from "${dirname}"`; + debug(message); + if (context.showConfig) { + console.log(message); + } + return true; + } + return false; +} +function matchesPatterns(context, patterns, dirname, configName) { + return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context, configName)); +} +function matchPattern(pattern, dirname, pathToTest, context, configName) { + if (typeof pattern === "function") { + return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, { + dirname, + envName: context.envName, + caller: context.caller + }); + } + if (typeof pathToTest !== "string") { + throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName); + } + if (typeof pattern === "string") { + pattern = (0, _patternToRegex.default)(pattern, dirname); + } + return pattern.test(pathToTest); +} +0 && 0; + +//# sourceMappingURL=config-chain.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/config-chain.js.map b/tools/ui/node_modules/@babel/core/lib/config/config-chain.js.map new file mode 100644 index 0000000000000000000000000000000000000000..92414e53a24b3b0cf89092347a6dbf16a1a8ee48 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/config-chain.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_path","data","require","_debug","_options","_patternToRegex","_printer","_rewriteStackTrace","_configError","_index","_caching","_configDescriptors","debug","buildDebug","buildPresetChain","arg","context","chain","buildPresetChainWalker","plugins","dedupDescriptors","presets","options","map","o","createConfigChainOptions","files","Set","exports","makeChainWalker","root","preset","loadPresetDescriptors","env","envName","loadPresetEnvDescriptors","overrides","index","loadPresetOverridesDescriptors","overridesEnv","loadPresetOverridesEnvDescriptors","createLogger","makeWeakCacheSync","buildRootDescriptors","alias","createUncachedDescriptors","makeStrongCacheSync","buildEnvDescriptors","buildOverrideDescriptors","buildOverrideEnvDescriptors","buildRootChain","opts","configReport","babelRcReport","programmaticLogger","ConfigPrinter","programmaticChain","loadProgrammaticChain","dirname","cwd","undefined","programmaticReport","output","configFile","loadConfig","caller","findRootConfig","babelrc","babelrcRoots","babelrcRootsDirectory","configFileChain","emptyChain","configFileLogger","validatedFile","validateConfigFile","result","loadFileChain","mergeChain","ignoreFile","babelrcFile","isIgnored","fileChain","filename","pkgData","findPackageData","babelrcLoadEnabled","ignore","config","findRelativeConfig","add","filepath","shouldIgnore","validateBabelrcFile","babelrcLogger","showConfig","console","log","filter","x","join","fileHandling","absoluteRoot","directories","includes","babelrcPatterns","Array","isArray","pat","path","resolve","length","some","pathPatternToRegex","directory","matchPattern","file","validate","validateExtendFile","input","createCachedDescriptors","baseLogger","buildProgrammaticLogger","loadFileChainWalker","loadFileDescriptors","loadFileEnvDescriptors","loadFileOverridesDescriptors","loadFileOverridesEnvDescriptors","buildFileLogger","configure","ChainFormatter","Config","descriptors","_","_context$caller","Programmatic","callerName","name","_options$env","_options$overrides","Error","_options$overrides2","_override$env","override","chainWalker","flattenedConfigs","rootOpts","configIsApplicable","push","envOpts","forEach","overrideOps","overrideEnvOpts","only","logger","mergeExtendsChain","mergeChainOpts","extends","has","from","delete","target","source","Object","assign","passPerPreset","test","include","exclude","hasOwnProperty","call","sourceMaps","sourceMap","items","Map","item","value","fnKey","nameMap","get","set","desc","ownPass","reduce","acc","configName","configFieldIsApplicable","patterns","matchesPatterns","ignoreListReplacer","_key","RegExp","String","_context$filename","message","JSON","stringify","_context$filename2","pattern","pathToTest","endHiddenCallStack","ConfigError"],"sources":["../../src/config/config-chain.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-use-before-define */\n\nimport path from \"node:path\";\nimport buildDebug from \"debug\";\nimport type { Handler } from \"gensync\";\nimport { validate } from \"./validation/options.ts\";\nimport type {\n ConfigApplicableTest,\n BabelrcSearch,\n CallerMetadata,\n MatchItem,\n InputOptions,\n ConfigChainOptions,\n} from \"./validation/options.ts\";\nimport pathPatternToRegex from \"./pattern-to-regex.ts\";\nimport { ConfigPrinter, ChainFormatter } from \"./printer.ts\";\nimport type { ReadonlyDeepArray } from \"./helpers/deep-array.ts\";\n\nimport { endHiddenCallStack } from \"../errors/rewrite-stack-trace.ts\";\nimport ConfigError from \"../errors/config-error.ts\";\nimport type { PluginAPI, PresetAPI } from \"./helpers/config-api.ts\";\n\nconst debug = buildDebug(\"babel:config:config-chain\");\n\nimport {\n findPackageData,\n findRelativeConfig,\n findRootConfig,\n loadConfig,\n} from \"./files/index.ts\";\nimport type { ConfigFile, IgnoreFile, FilePackageData } from \"./files/index.ts\";\n\nimport { makeWeakCacheSync, makeStrongCacheSync } from \"./caching.ts\";\n\nimport {\n createCachedDescriptors,\n createUncachedDescriptors,\n} from \"./config-descriptors.ts\";\nimport type {\n UnloadedDescriptor,\n OptionsAndDescriptors,\n ValidatedFile,\n} from \"./config-descriptors.ts\";\n\nexport type ConfigChain = {\n plugins: UnloadedDescriptor[];\n presets: UnloadedDescriptor[];\n options: ConfigChainOptions[];\n files: Set;\n};\n\nexport type PresetInstance = {\n options: InputOptions;\n alias: string;\n dirname: string;\n externalDependencies: ReadonlyDeepArray;\n};\n\nexport type ConfigContext = {\n filename: string | undefined;\n cwd: string;\n root: string;\n envName: string;\n caller: CallerMetadata | undefined;\n showConfig: boolean;\n};\n\n/**\n * Build a config chain for a given preset.\n */\nexport function* buildPresetChain(\n arg: PresetInstance,\n context: any,\n): Handler {\n const chain = yield* buildPresetChainWalker(arg, context);\n if (!chain) return null;\n\n return {\n plugins: dedupDescriptors(chain.plugins),\n presets: dedupDescriptors(chain.presets),\n options: chain.options.map(o => createConfigChainOptions(o)),\n files: new Set(),\n };\n}\n\nexport const buildPresetChainWalker = makeChainWalker({\n root: preset => loadPresetDescriptors(preset),\n env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),\n overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),\n overridesEnv: (preset, index, envName) =>\n loadPresetOverridesEnvDescriptors(preset)(index)(envName),\n createLogger: () => () => {}, // Currently we don't support logging how preset is expanded\n});\nconst loadPresetDescriptors = makeWeakCacheSync((preset: PresetInstance) =>\n buildRootDescriptors(preset, preset.alias, createUncachedDescriptors),\n);\nconst loadPresetEnvDescriptors = makeWeakCacheSync((preset: PresetInstance) =>\n makeStrongCacheSync((envName: string) =>\n buildEnvDescriptors(\n preset,\n preset.alias,\n createUncachedDescriptors,\n envName,\n ),\n ),\n);\nconst loadPresetOverridesDescriptors = makeWeakCacheSync(\n (preset: PresetInstance) =>\n makeStrongCacheSync((index: number) =>\n buildOverrideDescriptors(\n preset,\n preset.alias,\n createUncachedDescriptors,\n index,\n ),\n ),\n);\nconst loadPresetOverridesEnvDescriptors = makeWeakCacheSync(\n (preset: PresetInstance) =>\n makeStrongCacheSync((index: number) =>\n makeStrongCacheSync((envName: string) =>\n buildOverrideEnvDescriptors(\n preset,\n preset.alias,\n createUncachedDescriptors,\n index,\n envName,\n ),\n ),\n ),\n);\n\nexport type FileHandling = \"transpile\" | \"ignored\" | \"unsupported\";\nexport type RootConfigChain = ConfigChain & {\n babelrc: ConfigFile | undefined;\n config: ConfigFile | undefined;\n ignore: IgnoreFile | undefined;\n fileHandling: FileHandling;\n files: Set;\n};\n\n/**\n * Build a config chain for Babel's full root configuration.\n */\nexport function* buildRootChain(\n opts: InputOptions,\n context: ConfigContext,\n): Handler {\n let configReport, babelRcReport;\n const programmaticLogger = new ConfigPrinter();\n const programmaticChain = yield* loadProgrammaticChain(\n {\n options: opts,\n dirname: context.cwd,\n },\n context,\n undefined,\n programmaticLogger,\n );\n if (!programmaticChain) return null;\n const programmaticReport = yield* programmaticLogger.output();\n\n let configFile;\n if (typeof opts.configFile === \"string\") {\n configFile = yield* loadConfig(\n opts.configFile,\n context.cwd,\n context.envName,\n context.caller,\n );\n } else if (opts.configFile !== false) {\n configFile = yield* findRootConfig(\n context.root,\n context.envName,\n context.caller,\n );\n }\n\n let { babelrc, babelrcRoots } = opts;\n let babelrcRootsDirectory = context.cwd;\n\n const configFileChain = emptyChain();\n const configFileLogger = new ConfigPrinter();\n if (configFile) {\n const validatedFile = validateConfigFile(configFile);\n const result = yield* loadFileChain(\n validatedFile,\n context,\n undefined,\n configFileLogger,\n );\n if (!result) return null;\n configReport = yield* configFileLogger.output();\n\n // Allow config files to toggle `.babelrc` resolution on and off and\n // specify where the roots are.\n if (babelrc === undefined) {\n babelrc = validatedFile.options.babelrc;\n }\n if (babelrcRoots === undefined) {\n babelrcRootsDirectory = validatedFile.dirname;\n babelrcRoots = validatedFile.options.babelrcRoots;\n }\n\n mergeChain(configFileChain, result);\n }\n\n let ignoreFile, babelrcFile;\n let isIgnored = false;\n const fileChain = emptyChain();\n // resolve all .babelrc files\n if (\n (babelrc === true || babelrc === undefined) &&\n typeof context.filename === \"string\"\n ) {\n const pkgData = yield* findPackageData(context.filename);\n\n if (\n pkgData &&\n babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)\n ) {\n ({ ignore: ignoreFile, config: babelrcFile } = yield* findRelativeConfig(\n pkgData,\n context.envName,\n context.caller,\n ));\n\n if (ignoreFile) {\n fileChain.files.add(ignoreFile.filepath);\n }\n\n if (\n ignoreFile &&\n shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)\n ) {\n isIgnored = true;\n }\n\n if (babelrcFile && !isIgnored) {\n const validatedFile = validateBabelrcFile(babelrcFile);\n const babelrcLogger = new ConfigPrinter();\n const result = yield* loadFileChain(\n validatedFile,\n context,\n undefined,\n babelrcLogger,\n );\n if (!result) {\n isIgnored = true;\n } else {\n babelRcReport = yield* babelrcLogger.output();\n mergeChain(fileChain, result);\n }\n }\n\n if (babelrcFile && isIgnored) {\n fileChain.files.add(babelrcFile.filepath);\n }\n }\n }\n\n if (context.showConfig) {\n console.log(\n `Babel configs on \"${context.filename}\" (ascending priority):\\n` +\n // print config by the order of ascending priority\n [configReport, babelRcReport, programmaticReport]\n .filter(x => !!x)\n .join(\"\\n\\n\") +\n \"\\n-----End Babel configs-----\",\n );\n }\n // Insert file chain in front so programmatic options have priority\n // over configuration file chain items.\n const chain = mergeChain(\n mergeChain(mergeChain(emptyChain(), configFileChain), fileChain),\n programmaticChain,\n );\n\n return {\n plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),\n presets: isIgnored ? [] : dedupDescriptors(chain.presets),\n options: isIgnored\n ? []\n : chain.options.map(o => createConfigChainOptions(o)),\n fileHandling: isIgnored ? \"ignored\" : \"transpile\",\n ignore: ignoreFile || undefined,\n babelrc: babelrcFile || undefined,\n config: configFile || undefined,\n files: chain.files,\n };\n}\n\nfunction babelrcLoadEnabled(\n context: ConfigContext,\n pkgData: FilePackageData,\n babelrcRoots: BabelrcSearch | undefined,\n babelrcRootsDirectory: string,\n): boolean {\n if (typeof babelrcRoots === \"boolean\") return babelrcRoots;\n\n const absoluteRoot = context.root;\n\n // Fast path to avoid having to match patterns if the babelrc is just\n // loading in the standard root directory.\n if (babelrcRoots === undefined) {\n return pkgData.directories.includes(absoluteRoot);\n }\n\n let babelrcPatterns = babelrcRoots;\n if (!Array.isArray(babelrcPatterns)) {\n babelrcPatterns = [babelrcPatterns];\n }\n babelrcPatterns = babelrcPatterns.map(pat => {\n return typeof pat === \"string\"\n ? path.resolve(babelrcRootsDirectory, pat)\n : pat;\n });\n\n // Fast path to avoid having to match patterns if the babelrc is just\n // loading in the standard root directory.\n if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {\n return pkgData.directories.includes(absoluteRoot);\n }\n\n return babelrcPatterns.some(pat => {\n if (typeof pat === \"string\") {\n pat = pathPatternToRegex(pat, babelrcRootsDirectory);\n }\n\n return pkgData.directories.some(directory => {\n return matchPattern(pat, babelrcRootsDirectory, directory, context);\n });\n });\n}\n\nconst validateConfigFile = makeWeakCacheSync(\n (file: ConfigFile): ValidatedFile => ({\n filepath: file.filepath,\n dirname: file.dirname,\n options: validate(\"configfile\", file.options, file.filepath),\n }),\n);\n\nconst validateBabelrcFile = makeWeakCacheSync(\n (file: ConfigFile): ValidatedFile => ({\n filepath: file.filepath,\n dirname: file.dirname,\n options: validate(\"babelrcfile\", file.options, file.filepath),\n }),\n);\n\nconst validateExtendFile = makeWeakCacheSync(\n (file: ConfigFile): ValidatedFile => ({\n filepath: file.filepath,\n dirname: file.dirname,\n options: validate(\"extendsfile\", file.options, file.filepath),\n }),\n);\n\n/**\n * Build a config chain for just the programmatic options passed into Babel.\n */\nconst loadProgrammaticChain = makeChainWalker({\n root: input => buildRootDescriptors(input, \"base\", createCachedDescriptors),\n env: (input, envName) =>\n buildEnvDescriptors(input, \"base\", createCachedDescriptors, envName),\n overrides: (input, index) =>\n buildOverrideDescriptors(input, \"base\", createCachedDescriptors, index),\n overridesEnv: (input, index, envName) =>\n buildOverrideEnvDescriptors(\n input,\n \"base\",\n createCachedDescriptors,\n index,\n envName,\n ),\n createLogger: (input, context, baseLogger) =>\n buildProgrammaticLogger(input, context, baseLogger),\n});\n\n/**\n * Build a config chain for a given file.\n */\nconst loadFileChainWalker = makeChainWalker({\n root: file => loadFileDescriptors(file),\n env: (file, envName) => loadFileEnvDescriptors(file)(envName),\n overrides: (file, index) => loadFileOverridesDescriptors(file)(index),\n overridesEnv: (file, index, envName) =>\n loadFileOverridesEnvDescriptors(file)(index)(envName),\n createLogger: (file, context, baseLogger) =>\n buildFileLogger(file.filepath, context, baseLogger),\n});\n\nfunction* loadFileChain(\n input: ValidatedFile,\n context: ConfigContext,\n files: Set,\n baseLogger: ConfigPrinter,\n) {\n const chain = yield* loadFileChainWalker(input, context, files, baseLogger);\n chain?.files.add(input.filepath);\n\n return chain;\n}\n\nconst loadFileDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n buildRootDescriptors(file, file.filepath, createUncachedDescriptors),\n);\nconst loadFileEnvDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n makeStrongCacheSync((envName: string) =>\n buildEnvDescriptors(\n file,\n file.filepath,\n createUncachedDescriptors,\n envName,\n ),\n ),\n);\nconst loadFileOverridesDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n makeStrongCacheSync((index: number) =>\n buildOverrideDescriptors(\n file,\n file.filepath,\n createUncachedDescriptors,\n index,\n ),\n ),\n);\nconst loadFileOverridesEnvDescriptors = makeWeakCacheSync(\n (file: ValidatedFile) =>\n makeStrongCacheSync((index: number) =>\n makeStrongCacheSync((envName: string) =>\n buildOverrideEnvDescriptors(\n file,\n file.filepath,\n createUncachedDescriptors,\n index,\n envName,\n ),\n ),\n ),\n);\n\nfunction buildFileLogger(\n filepath: string,\n context: ConfigContext,\n baseLogger: ConfigPrinter | void,\n) {\n if (!baseLogger) {\n return () => {};\n }\n return baseLogger.configure(context.showConfig, ChainFormatter.Config, {\n filepath,\n });\n}\n\nfunction buildRootDescriptors(\n { dirname, options }: Partial,\n alias: string,\n descriptors: (\n dirname: string,\n options: InputOptions,\n alias: string,\n ) => OptionsAndDescriptors,\n) {\n return descriptors(dirname, options, alias);\n}\n\nfunction buildProgrammaticLogger(\n _: unknown,\n context: ConfigContext,\n baseLogger: ConfigPrinter | void,\n) {\n if (!baseLogger) {\n return () => {};\n }\n return baseLogger.configure(context.showConfig, ChainFormatter.Programmatic, {\n callerName: context.caller?.name,\n });\n}\n\nfunction buildEnvDescriptors(\n { dirname, options }: Partial,\n alias: string,\n descriptors: (\n dirname: string,\n options: InputOptions,\n alias: string,\n ) => OptionsAndDescriptors,\n envName: string,\n) {\n const opts = options.env?.[envName];\n return opts ? descriptors(dirname, opts, `${alias}.env[\"${envName}\"]`) : null;\n}\n\nfunction buildOverrideDescriptors(\n { dirname, options }: Partial,\n alias: string,\n descriptors: (\n dirname: string,\n options: InputOptions,\n alias: string,\n ) => OptionsAndDescriptors,\n index: number,\n) {\n const opts = options.overrides?.[index];\n if (!opts) throw new Error(\"Assertion failure - missing override\");\n\n return descriptors(dirname, opts, `${alias}.overrides[${index}]`);\n}\n\nfunction buildOverrideEnvDescriptors(\n { dirname, options }: Partial,\n alias: string,\n descriptors: (\n dirname: string,\n options: InputOptions,\n alias: string,\n ) => OptionsAndDescriptors,\n index: number,\n envName: string,\n) {\n const override = options.overrides?.[index];\n if (!override) throw new Error(\"Assertion failure - missing override\");\n\n const opts = override.env?.[envName];\n return opts\n ? descriptors(\n dirname,\n opts,\n `${alias}.overrides[${index}].env[\"${envName}\"]`,\n )\n : null;\n}\n\nfunction makeChainWalker<\n ArgT extends {\n options: InputOptions;\n dirname: string;\n filepath?: string;\n },\n>({\n root,\n env,\n overrides,\n overridesEnv,\n createLogger,\n}: {\n root: (configEntry: ArgT) => OptionsAndDescriptors;\n env: (configEntry: ArgT, env: string) => OptionsAndDescriptors | null;\n overrides: (configEntry: ArgT, index: number) => OptionsAndDescriptors;\n overridesEnv: (\n configEntry: ArgT,\n index: number,\n env: string,\n ) => OptionsAndDescriptors | null;\n createLogger: (\n configEntry: ArgT,\n context: ConfigContext,\n printer: ConfigPrinter | void,\n ) => (\n opts: OptionsAndDescriptors,\n index?: number | null,\n env?: string | null,\n ) => void;\n}): (\n configEntry: ArgT,\n context: ConfigContext,\n files?: Set,\n baseLogger?: ConfigPrinter,\n) => Handler {\n return function* chainWalker(input, context, files = new Set(), baseLogger) {\n const { dirname } = input;\n\n const flattenedConfigs: {\n config: OptionsAndDescriptors;\n index: number | undefined | null;\n envName: string | undefined | null;\n }[] = [];\n\n const rootOpts = root(input);\n if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {\n flattenedConfigs.push({\n config: rootOpts,\n envName: undefined,\n index: undefined,\n });\n\n const envOpts = env(input, context.envName);\n if (\n envOpts &&\n configIsApplicable(envOpts, dirname, context, input.filepath)\n ) {\n flattenedConfigs.push({\n config: envOpts,\n envName: context.envName,\n index: undefined,\n });\n }\n\n (rootOpts.options.overrides || []).forEach((_, index) => {\n const overrideOps = overrides(input, index);\n if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {\n flattenedConfigs.push({\n config: overrideOps,\n index,\n envName: undefined,\n });\n\n const overrideEnvOpts = overridesEnv(input, index, context.envName);\n if (\n overrideEnvOpts &&\n configIsApplicable(\n overrideEnvOpts,\n dirname,\n context,\n input.filepath,\n )\n ) {\n flattenedConfigs.push({\n config: overrideEnvOpts,\n index,\n envName: context.envName,\n });\n }\n }\n });\n }\n\n // Process 'ignore' and 'only' before 'extends' items are processed so\n // that we don't do extra work loading extended configs if a file is\n // ignored.\n if (\n flattenedConfigs.some(\n ({\n config: {\n options: { ignore, only },\n },\n }) => shouldIgnore(context, ignore, only, dirname),\n )\n ) {\n return null;\n }\n\n const chain = emptyChain();\n const logger = createLogger(input, context, baseLogger);\n\n for (const { config, index, envName } of flattenedConfigs) {\n if (\n !(yield* mergeExtendsChain(\n chain,\n config.options,\n dirname,\n context,\n files,\n baseLogger,\n ))\n ) {\n return null;\n }\n\n logger(config, index, envName);\n yield* mergeChainOpts(chain, config);\n }\n return chain;\n };\n}\n\nfunction* mergeExtendsChain(\n chain: ConfigChain,\n opts: InputOptions,\n dirname: string,\n context: ConfigContext,\n files: Set,\n baseLogger?: ConfigPrinter,\n): Handler {\n if (opts.extends === undefined) return true;\n\n const file = yield* loadConfig(\n opts.extends,\n dirname,\n context.envName,\n context.caller,\n );\n\n if (files.has(file)) {\n throw new Error(\n `Configuration cycle detected loading ${file.filepath}.\\n` +\n `File already loaded following the config chain:\\n` +\n Array.from(files, file => ` - ${file.filepath}`).join(\"\\n\"),\n );\n }\n\n files.add(file);\n const fileChain = yield* loadFileChain(\n validateExtendFile(file),\n context,\n files,\n baseLogger,\n );\n files.delete(file);\n\n if (!fileChain) return false;\n\n mergeChain(chain, fileChain);\n\n return true;\n}\n\nfunction mergeChain(target: ConfigChain, source: ConfigChain): ConfigChain {\n target.options.push(...source.options);\n target.plugins.push(...source.plugins);\n target.presets.push(...source.presets);\n for (const file of source.files) {\n target.files.add(file);\n }\n\n return target;\n}\n\nfunction* mergeChainOpts(\n target: ConfigChain,\n { options, plugins, presets }: OptionsAndDescriptors,\n): Handler {\n target.options.push(options);\n target.plugins.push(...(yield* plugins()));\n target.presets.push(...(yield* presets()));\n\n return target;\n}\n\nfunction emptyChain(): ConfigChain {\n return {\n options: [],\n presets: [],\n plugins: [],\n files: new Set(),\n };\n}\n\nfunction createConfigChainOptions(opts: InputOptions): ConfigChainOptions {\n const options = {\n ...opts,\n };\n delete options.extends;\n delete options.env;\n delete options.overrides;\n delete options.plugins;\n delete options.presets;\n delete options.passPerPreset;\n delete options.ignore;\n delete options.only;\n delete options.test;\n delete options.include;\n delete options.exclude;\n\n // \"sourceMap\" is just aliased to sourceMap, so copy it over as\n // we merge the options together.\n if (Object.hasOwn(options, \"sourceMap\")) {\n options.sourceMaps = options.sourceMap;\n delete options.sourceMap;\n }\n return options;\n}\n\nfunction dedupDescriptors(\n items: UnloadedDescriptor[],\n): UnloadedDescriptor[] {\n const map = new Map<\n Function,\n Map }>\n >();\n\n const descriptors = [];\n\n for (const item of items) {\n if (typeof item.value === \"function\") {\n const fnKey = item.value;\n let nameMap = map.get(fnKey);\n if (!nameMap) {\n nameMap = new Map();\n map.set(fnKey, nameMap);\n }\n let desc = nameMap.get(item.name);\n if (!desc) {\n desc = { value: item };\n descriptors.push(desc);\n\n // Treat passPerPreset presets as unique, skipping them\n // in the merge processing steps.\n if (!item.ownPass) nameMap.set(item.name, desc);\n } else {\n desc.value = item;\n }\n } else {\n descriptors.push({ value: item });\n }\n }\n\n return descriptors.reduce((acc, desc) => {\n acc.push(desc.value);\n return acc;\n }, []);\n}\n\nfunction configIsApplicable(\n { options }: OptionsAndDescriptors,\n dirname: string,\n context: ConfigContext,\n configName: string,\n): boolean {\n return (\n (options.test === undefined ||\n configFieldIsApplicable(context, options.test, dirname, configName)) &&\n (options.include === undefined ||\n configFieldIsApplicable(context, options.include, dirname, configName)) &&\n (options.exclude === undefined ||\n !configFieldIsApplicable(context, options.exclude, dirname, configName))\n );\n}\n\nfunction configFieldIsApplicable(\n context: ConfigContext,\n test: ConfigApplicableTest,\n dirname: string,\n configName: string,\n): boolean {\n const patterns = Array.isArray(test) ? test : [test];\n\n return matchesPatterns(context, patterns, dirname, configName);\n}\n\n/**\n * Print the ignoreList-values in a more helpful way than the default.\n */\nfunction ignoreListReplacer(\n _key: string,\n value: MatchItem[] | MatchItem,\n): MatchItem[] | MatchItem | string {\n if (value instanceof RegExp) {\n return String(value);\n }\n\n return value;\n}\n\n/**\n * Tests if a filename should be ignored based on \"ignore\" and \"only\" options.\n */\nfunction shouldIgnore(\n context: ConfigContext,\n ignore: MatchItem[] | undefined | null,\n only: MatchItem[] | undefined | null,\n dirname: string,\n): boolean {\n if (ignore && matchesPatterns(context, ignore, dirname)) {\n const message = `No config is applied to \"${\n context.filename ?? \"(unknown)\"\n }\" because it matches one of \\`ignore: ${JSON.stringify(\n ignore,\n ignoreListReplacer,\n )}\\` from \"${dirname}\"`;\n debug(message);\n if (context.showConfig) {\n console.log(message);\n }\n return true;\n }\n\n if (only && !matchesPatterns(context, only, dirname)) {\n const message = `No config is applied to \"${\n context.filename ?? \"(unknown)\"\n }\" because it fails to match one of \\`only: ${JSON.stringify(\n only,\n ignoreListReplacer,\n )}\\` from \"${dirname}\"`;\n debug(message);\n if (context.showConfig) {\n console.log(message);\n }\n return true;\n }\n\n return false;\n}\n\n/**\n * Returns result of calling function with filename if pattern is a function.\n * Otherwise returns result of matching pattern Regex with filename.\n */\nfunction matchesPatterns(\n context: ConfigContext,\n patterns: MatchItem[],\n dirname: string,\n configName?: string,\n): boolean {\n return patterns.some(pattern =>\n matchPattern(pattern, dirname, context.filename, context, configName),\n );\n}\n\nfunction matchPattern(\n pattern: MatchItem,\n dirname: string,\n pathToTest: string | undefined,\n context: ConfigContext,\n configName?: string,\n): boolean {\n if (typeof pattern === \"function\") {\n return !!endHiddenCallStack(pattern)(pathToTest, {\n dirname,\n envName: context.envName,\n caller: context.caller,\n });\n }\n\n if (typeof pathToTest !== \"string\") {\n throw new ConfigError(\n `Configuration contains string/RegExp pattern, but no filename was passed to Babel`,\n configName,\n );\n }\n\n if (typeof pattern === \"string\") {\n pattern = pathPatternToRegex(pattern, dirname);\n }\n return pattern.test(pathToTest);\n}\n"],"mappings":";;;;;;;;AAEA,SAAAA,MAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,KAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,OAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,MAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,IAAAG,QAAA,GAAAF,OAAA;AASA,IAAAG,eAAA,GAAAH,OAAA;AACA,IAAAI,QAAA,GAAAJ,OAAA;AAGA,IAAAK,kBAAA,GAAAL,OAAA;AACA,IAAAM,YAAA,GAAAN,OAAA;AAKA,IAAAO,MAAA,GAAAP,OAAA;AAQA,IAAAQ,QAAA,GAAAR,OAAA;AAEA,IAAAS,kBAAA,GAAAT,OAAA;AAZA,MAAMU,KAAK,GAAGC,OAASA,CAAC,CAAC,2BAA2B,CAAC;AAgD9C,UAAUC,gBAAgBA,CAC/BC,GAAmB,EACnBC,OAAY,EACiB;EAC7B,MAAMC,KAAK,GAAG,OAAOC,sBAAsB,CAACH,GAAG,EAAEC,OAAO,CAAC;EACzD,IAAI,CAACC,KAAK,EAAE,OAAO,IAAI;EAEvB,OAAO;IACLE,OAAO,EAAEC,gBAAgB,CAACH,KAAK,CAACE,OAAO,CAAC;IACxCE,OAAO,EAAED,gBAAgB,CAACH,KAAK,CAACI,OAAO,CAAC;IACxCC,OAAO,EAAEL,KAAK,CAACK,OAAO,CAACC,GAAG,CAACC,CAAC,IAAIC,wBAAwB,CAACD,CAAC,CAAC,CAAC;IAC5DE,KAAK,EAAE,IAAIC,GAAG,CAAC;EACjB,CAAC;AACH;AAEO,MAAMT,sBAAsB,GAAAU,OAAA,CAAAV,sBAAA,GAAGW,eAAe,CAAiB;EACpEC,IAAI,EAAEC,MAAM,IAAIC,qBAAqB,CAACD,MAAM,CAAC;EAC7CE,GAAG,EAAEA,CAACF,MAAM,EAAEG,OAAO,KAAKC,wBAAwB,CAACJ,MAAM,CAAC,CAACG,OAAO,CAAC;EACnEE,SAAS,EAAEA,CAACL,MAAM,EAAEM,KAAK,KAAKC,8BAA8B,CAACP,MAAM,CAAC,CAACM,KAAK,CAAC;EAC3EE,YAAY,EAAEA,CAACR,MAAM,EAAEM,KAAK,EAAEH,OAAO,KACnCM,iCAAiC,CAACT,MAAM,CAAC,CAACM,KAAK,CAAC,CAACH,OAAO,CAAC;EAC3DO,YAAY,EAAEA,CAAA,KAAM,MAAM,CAAC;AAC7B,CAAC,CAAC;AACF,MAAMT,qBAAqB,GAAG,IAAAU,0BAAiB,EAAEX,MAAsB,IACrEY,oBAAoB,CAACZ,MAAM,EAAEA,MAAM,CAACa,KAAK,EAAEC,4CAAyB,CACtE,CAAC;AACD,MAAMV,wBAAwB,GAAG,IAAAO,0BAAiB,EAAEX,MAAsB,IACxE,IAAAe,4BAAmB,EAAEZ,OAAe,IAClCa,mBAAmB,CACjBhB,MAAM,EACNA,MAAM,CAACa,KAAK,EACZC,4CAAyB,EACzBX,OACF,CACF,CACF,CAAC;AACD,MAAMI,8BAA8B,GAAG,IAAAI,0BAAiB,EACrDX,MAAsB,IACrB,IAAAe,4BAAmB,EAAET,KAAa,IAChCW,wBAAwB,CACtBjB,MAAM,EACNA,MAAM,CAACa,KAAK,EACZC,4CAAyB,EACzBR,KACF,CACF,CACJ,CAAC;AACD,MAAMG,iCAAiC,GAAG,IAAAE,0BAAiB,EACxDX,MAAsB,IACrB,IAAAe,4BAAmB,EAAET,KAAa,IAChC,IAAAS,4BAAmB,EAAEZ,OAAe,IAClCe,2BAA2B,CACzBlB,MAAM,EACNA,MAAM,CAACa,KAAK,EACZC,4CAAyB,EACzBR,KAAK,EACLH,OACF,CACF,CACF,CACJ,CAAC;AAcM,UAAUgB,cAAcA,CAC7BC,IAAkB,EAClBnC,OAAsB,EACW;EACjC,IAAIoC,YAAY,EAAEC,aAAa;EAC/B,MAAMC,kBAAkB,GAAG,IAAIC,sBAAa,CAAC,CAAC;EAC9C,MAAMC,iBAAiB,GAAG,OAAOC,qBAAqB,CACpD;IACEnC,OAAO,EAAE6B,IAAI;IACbO,OAAO,EAAE1C,OAAO,CAAC2C;EACnB,CAAC,EACD3C,OAAO,EACP4C,SAAS,EACTN,kBACF,CAAC;EACD,IAAI,CAACE,iBAAiB,EAAE,OAAO,IAAI;EACnC,MAAMK,kBAAkB,GAAG,OAAOP,kBAAkB,CAACQ,MAAM,CAAC,CAAC;EAE7D,IAAIC,UAAU;EACd,IAAI,OAAOZ,IAAI,CAACY,UAAU,KAAK,QAAQ,EAAE;IACvCA,UAAU,GAAG,OAAO,IAAAC,iBAAU,EAC5Bb,IAAI,CAACY,UAAU,EACf/C,OAAO,CAAC2C,GAAG,EACX3C,OAAO,CAACkB,OAAO,EACflB,OAAO,CAACiD,MACV,CAAC;EACH,CAAC,MAAM,IAAId,IAAI,CAACY,UAAU,KAAK,KAAK,EAAE;IACpCA,UAAU,GAAG,OAAO,IAAAG,qBAAc,EAChClD,OAAO,CAACc,IAAI,EACZd,OAAO,CAACkB,OAAO,EACflB,OAAO,CAACiD,MACV,CAAC;EACH;EAEA,IAAI;IAAEE,OAAO;IAAEC;EAAa,CAAC,GAAGjB,IAAI;EACpC,IAAIkB,qBAAqB,GAAGrD,OAAO,CAAC2C,GAAG;EAEvC,MAAMW,eAAe,GAAGC,UAAU,CAAC,CAAC;EACpC,MAAMC,gBAAgB,GAAG,IAAIjB,sBAAa,CAAC,CAAC;EAC5C,IAAIQ,UAAU,EAAE;IACd,MAAMU,aAAa,GAAGC,kBAAkB,CAACX,UAAU,CAAC;IACpD,MAAMY,MAAM,GAAG,OAAOC,aAAa,CACjCH,aAAa,EACbzD,OAAO,EACP4C,SAAS,EACTY,gBACF,CAAC;IACD,IAAI,CAACG,MAAM,EAAE,OAAO,IAAI;IACxBvB,YAAY,GAAG,OAAOoB,gBAAgB,CAACV,MAAM,CAAC,CAAC;IAI/C,IAAIK,OAAO,KAAKP,SAAS,EAAE;MACzBO,OAAO,GAAGM,aAAa,CAACnD,OAAO,CAAC6C,OAAO;IACzC;IACA,IAAIC,YAAY,KAAKR,SAAS,EAAE;MAC9BS,qBAAqB,GAAGI,aAAa,CAACf,OAAO;MAC7CU,YAAY,GAAGK,aAAa,CAACnD,OAAO,CAAC8C,YAAY;IACnD;IAEAS,UAAU,CAACP,eAAe,EAAEK,MAAM,CAAC;EACrC;EAEA,IAAIG,UAAU,EAAEC,WAAW;EAC3B,IAAIC,SAAS,GAAG,KAAK;EACrB,MAAMC,SAAS,GAAGV,UAAU,CAAC,CAAC;EAE9B,IACE,CAACJ,OAAO,KAAK,IAAI,IAAIA,OAAO,KAAKP,SAAS,KAC1C,OAAO5C,OAAO,CAACkE,QAAQ,KAAK,QAAQ,EACpC;IACA,MAAMC,OAAO,GAAG,OAAO,IAAAC,sBAAe,EAACpE,OAAO,CAACkE,QAAQ,CAAC;IAExD,IACEC,OAAO,IACPE,kBAAkB,CAACrE,OAAO,EAAEmE,OAAO,EAAEf,YAAY,EAAEC,qBAAqB,CAAC,EACzE;MACA,CAAC;QAAEiB,MAAM,EAAER,UAAU;QAAES,MAAM,EAAER;MAAY,CAAC,GAAG,OAAO,IAAAS,yBAAkB,EACtEL,OAAO,EACPnE,OAAO,CAACkB,OAAO,EACflB,OAAO,CAACiD,MACV,CAAC;MAED,IAAIa,UAAU,EAAE;QACdG,SAAS,CAACvD,KAAK,CAAC+D,GAAG,CAACX,UAAU,CAACY,QAAQ,CAAC;MAC1C;MAEA,IACEZ,UAAU,IACVa,YAAY,CAAC3E,OAAO,EAAE8D,UAAU,CAACQ,MAAM,EAAE,IAAI,EAAER,UAAU,CAACpB,OAAO,CAAC,EAClE;QACAsB,SAAS,GAAG,IAAI;MAClB;MAEA,IAAID,WAAW,IAAI,CAACC,SAAS,EAAE;QAC7B,MAAMP,aAAa,GAAGmB,mBAAmB,CAACb,WAAW,CAAC;QACtD,MAAMc,aAAa,GAAG,IAAItC,sBAAa,CAAC,CAAC;QACzC,MAAMoB,MAAM,GAAG,OAAOC,aAAa,CACjCH,aAAa,EACbzD,OAAO,EACP4C,SAAS,EACTiC,aACF,CAAC;QACD,IAAI,CAAClB,MAAM,EAAE;UACXK,SAAS,GAAG,IAAI;QAClB,CAAC,MAAM;UACL3B,aAAa,GAAG,OAAOwC,aAAa,CAAC/B,MAAM,CAAC,CAAC;UAC7Ce,UAAU,CAACI,SAAS,EAAEN,MAAM,CAAC;QAC/B;MACF;MAEA,IAAII,WAAW,IAAIC,SAAS,EAAE;QAC5BC,SAAS,CAACvD,KAAK,CAAC+D,GAAG,CAACV,WAAW,CAACW,QAAQ,CAAC;MAC3C;IACF;EACF;EAEA,IAAI1E,OAAO,CAAC8E,UAAU,EAAE;IACtBC,OAAO,CAACC,GAAG,CACT,qBAAqBhF,OAAO,CAACkE,QAAQ,2BAA2B,GAE9D,CAAC9B,YAAY,EAAEC,aAAa,EAAEQ,kBAAkB,CAAC,CAC9CoC,MAAM,CAACC,CAAC,IAAI,CAAC,CAACA,CAAC,CAAC,CAChBC,IAAI,CAAC,MAAM,CAAC,GACf,+BACJ,CAAC;EACH;EAGA,MAAMlF,KAAK,GAAG4D,UAAU,CACtBA,UAAU,CAACA,UAAU,CAACN,UAAU,CAAC,CAAC,EAAED,eAAe,CAAC,EAAEW,SAAS,CAAC,EAChEzB,iBACF,CAAC;EAED,OAAO;IACLrC,OAAO,EAAE6D,SAAS,GAAG,EAAE,GAAG5D,gBAAgB,CAACH,KAAK,CAACE,OAAO,CAAC;IACzDE,OAAO,EAAE2D,SAAS,GAAG,EAAE,GAAG5D,gBAAgB,CAACH,KAAK,CAACI,OAAO,CAAC;IACzDC,OAAO,EAAE0D,SAAS,GACd,EAAE,GACF/D,KAAK,CAACK,OAAO,CAACC,GAAG,CAACC,CAAC,IAAIC,wBAAwB,CAACD,CAAC,CAAC,CAAC;IACvD4E,YAAY,EAAEpB,SAAS,GAAG,SAAS,GAAG,WAAW;IACjDM,MAAM,EAAER,UAAU,IAAIlB,SAAS;IAC/BO,OAAO,EAAEY,WAAW,IAAInB,SAAS;IACjC2B,MAAM,EAAExB,UAAU,IAAIH,SAAS;IAC/BlC,KAAK,EAAET,KAAK,CAACS;EACf,CAAC;AACH;AAEA,SAAS2D,kBAAkBA,CACzBrE,OAAsB,EACtBmE,OAAwB,EACxBf,YAAuC,EACvCC,qBAA6B,EACpB;EACT,IAAI,OAAOD,YAAY,KAAK,SAAS,EAAE,OAAOA,YAAY;EAE1D,MAAMiC,YAAY,GAAGrF,OAAO,CAACc,IAAI;EAIjC,IAAIsC,YAAY,KAAKR,SAAS,EAAE;IAC9B,OAAOuB,OAAO,CAACmB,WAAW,CAACC,QAAQ,CAACF,YAAY,CAAC;EACnD;EAEA,IAAIG,eAAe,GAAGpC,YAAY;EAClC,IAAI,CAACqC,KAAK,CAACC,OAAO,CAACF,eAAe,CAAC,EAAE;IACnCA,eAAe,GAAG,CAACA,eAAe,CAAC;EACrC;EACAA,eAAe,GAAGA,eAAe,CAACjF,GAAG,CAACoF,GAAG,IAAI;IAC3C,OAAO,OAAOA,GAAG,KAAK,QAAQ,GAC1BC,MAAGA,CAAC,CAACC,OAAO,CAACxC,qBAAqB,EAAEsC,GAAG,CAAC,GACxCA,GAAG;EACT,CAAC,CAAC;EAIF,IAAIH,eAAe,CAACM,MAAM,KAAK,CAAC,IAAIN,eAAe,CAAC,CAAC,CAAC,KAAKH,YAAY,EAAE;IACvE,OAAOlB,OAAO,CAACmB,WAAW,CAACC,QAAQ,CAACF,YAAY,CAAC;EACnD;EAEA,OAAOG,eAAe,CAACO,IAAI,CAACJ,GAAG,IAAI;IACjC,IAAI,OAAOA,GAAG,KAAK,QAAQ,EAAE;MAC3BA,GAAG,GAAG,IAAAK,uBAAkB,EAACL,GAAG,EAAEtC,qBAAqB,CAAC;IACtD;IAEA,OAAOc,OAAO,CAACmB,WAAW,CAACS,IAAI,CAACE,SAAS,IAAI;MAC3C,OAAOC,YAAY,CAACP,GAAG,EAAEtC,qBAAqB,EAAE4C,SAAS,EAAEjG,OAAO,CAAC;IACrE,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ;AAEA,MAAM0D,kBAAkB,GAAG,IAAAhC,0BAAiB,EACzCyE,IAAgB,KAAqB;EACpCzB,QAAQ,EAAEyB,IAAI,CAACzB,QAAQ;EACvBhC,OAAO,EAAEyD,IAAI,CAACzD,OAAO;EACrBpC,OAAO,EAAE,IAAA8F,iBAAQ,EAAC,YAAY,EAAED,IAAI,CAAC7F,OAAO,EAAE6F,IAAI,CAACzB,QAAQ;AAC7D,CAAC,CACH,CAAC;AAED,MAAME,mBAAmB,GAAG,IAAAlD,0BAAiB,EAC1CyE,IAAgB,KAAqB;EACpCzB,QAAQ,EAAEyB,IAAI,CAACzB,QAAQ;EACvBhC,OAAO,EAAEyD,IAAI,CAACzD,OAAO;EACrBpC,OAAO,EAAE,IAAA8F,iBAAQ,EAAC,aAAa,EAAED,IAAI,CAAC7F,OAAO,EAAE6F,IAAI,CAACzB,QAAQ;AAC9D,CAAC,CACH,CAAC;AAED,MAAM2B,kBAAkB,GAAG,IAAA3E,0BAAiB,EACzCyE,IAAgB,KAAqB;EACpCzB,QAAQ,EAAEyB,IAAI,CAACzB,QAAQ;EACvBhC,OAAO,EAAEyD,IAAI,CAACzD,OAAO;EACrBpC,OAAO,EAAE,IAAA8F,iBAAQ,EAAC,aAAa,EAAED,IAAI,CAAC7F,OAAO,EAAE6F,IAAI,CAACzB,QAAQ;AAC9D,CAAC,CACH,CAAC;AAKD,MAAMjC,qBAAqB,GAAG5B,eAAe,CAAC;EAC5CC,IAAI,EAAEwF,KAAK,IAAI3E,oBAAoB,CAAC2E,KAAK,EAAE,MAAM,EAAEC,0CAAuB,CAAC;EAC3EtF,GAAG,EAAEA,CAACqF,KAAK,EAAEpF,OAAO,KAClBa,mBAAmB,CAACuE,KAAK,EAAE,MAAM,EAAEC,0CAAuB,EAAErF,OAAO,CAAC;EACtEE,SAAS,EAAEA,CAACkF,KAAK,EAAEjF,KAAK,KACtBW,wBAAwB,CAACsE,KAAK,EAAE,MAAM,EAAEC,0CAAuB,EAAElF,KAAK,CAAC;EACzEE,YAAY,EAAEA,CAAC+E,KAAK,EAAEjF,KAAK,EAAEH,OAAO,KAClCe,2BAA2B,CACzBqE,KAAK,EACL,MAAM,EACNC,0CAAuB,EACvBlF,KAAK,EACLH,OACF,CAAC;EACHO,YAAY,EAAEA,CAAC6E,KAAK,EAAEtG,OAAO,EAAEwG,UAAU,KACvCC,uBAAuB,CAACH,KAAK,EAAEtG,OAAO,EAAEwG,UAAU;AACtD,CAAC,CAAC;AAKF,MAAME,mBAAmB,GAAG7F,eAAe,CAAgB;EACzDC,IAAI,EAAEqF,IAAI,IAAIQ,mBAAmB,CAACR,IAAI,CAAC;EACvClF,GAAG,EAAEA,CAACkF,IAAI,EAAEjF,OAAO,KAAK0F,sBAAsB,CAACT,IAAI,CAAC,CAACjF,OAAO,CAAC;EAC7DE,SAAS,EAAEA,CAAC+E,IAAI,EAAE9E,KAAK,KAAKwF,4BAA4B,CAACV,IAAI,CAAC,CAAC9E,KAAK,CAAC;EACrEE,YAAY,EAAEA,CAAC4E,IAAI,EAAE9E,KAAK,EAAEH,OAAO,KACjC4F,+BAA+B,CAACX,IAAI,CAAC,CAAC9E,KAAK,CAAC,CAACH,OAAO,CAAC;EACvDO,YAAY,EAAEA,CAAC0E,IAAI,EAAEnG,OAAO,EAAEwG,UAAU,KACtCO,eAAe,CAACZ,IAAI,CAACzB,QAAQ,EAAE1E,OAAO,EAAEwG,UAAU;AACtD,CAAC,CAAC;AAEF,UAAU5C,aAAaA,CACrB0C,KAAoB,EACpBtG,OAAsB,EACtBU,KAAsB,EACtB8F,UAAyB,EACzB;EACA,MAAMvG,KAAK,GAAG,OAAOyG,mBAAmB,CAACJ,KAAK,EAAEtG,OAAO,EAAEU,KAAK,EAAE8F,UAAU,CAAC;EAC3EvG,KAAK,YAALA,KAAK,CAAES,KAAK,CAAC+D,GAAG,CAAC6B,KAAK,CAAC5B,QAAQ,CAAC;EAEhC,OAAOzE,KAAK;AACd;AAEA,MAAM0G,mBAAmB,GAAG,IAAAjF,0BAAiB,EAAEyE,IAAmB,IAChExE,oBAAoB,CAACwE,IAAI,EAAEA,IAAI,CAACzB,QAAQ,EAAE7C,4CAAyB,CACrE,CAAC;AACD,MAAM+E,sBAAsB,GAAG,IAAAlF,0BAAiB,EAAEyE,IAAmB,IACnE,IAAArE,4BAAmB,EAAEZ,OAAe,IAClCa,mBAAmB,CACjBoE,IAAI,EACJA,IAAI,CAACzB,QAAQ,EACb7C,4CAAyB,EACzBX,OACF,CACF,CACF,CAAC;AACD,MAAM2F,4BAA4B,GAAG,IAAAnF,0BAAiB,EAAEyE,IAAmB,IACzE,IAAArE,4BAAmB,EAAET,KAAa,IAChCW,wBAAwB,CACtBmE,IAAI,EACJA,IAAI,CAACzB,QAAQ,EACb7C,4CAAyB,EACzBR,KACF,CACF,CACF,CAAC;AACD,MAAMyF,+BAA+B,GAAG,IAAApF,0BAAiB,EACtDyE,IAAmB,IAClB,IAAArE,4BAAmB,EAAET,KAAa,IAChC,IAAAS,4BAAmB,EAAEZ,OAAe,IAClCe,2BAA2B,CACzBkE,IAAI,EACJA,IAAI,CAACzB,QAAQ,EACb7C,4CAAyB,EACzBR,KAAK,EACLH,OACF,CACF,CACF,CACJ,CAAC;AAED,SAAS6F,eAAeA,CACtBrC,QAAgB,EAChB1E,OAAsB,EACtBwG,UAAgC,EAChC;EACA,IAAI,CAACA,UAAU,EAAE;IACf,OAAO,MAAM,CAAC,CAAC;EACjB;EACA,OAAOA,UAAU,CAACQ,SAAS,CAAChH,OAAO,CAAC8E,UAAU,EAAEmC,uBAAc,CAACC,MAAM,EAAE;IACrExC;EACF,CAAC,CAAC;AACJ;AAEA,SAAS/C,oBAAoBA,CAC3B;EAAEe,OAAO;EAAEpC;AAAgC,CAAC,EAC5CsB,KAAa,EACbuF,WAI0B,EAC1B;EACA,OAAOA,WAAW,CAACzE,OAAO,EAAEpC,OAAO,EAAEsB,KAAK,CAAC;AAC7C;AAEA,SAAS6E,uBAAuBA,CAC9BW,CAAU,EACVpH,OAAsB,EACtBwG,UAAgC,EAChC;EAAA,IAAAa,eAAA;EACA,IAAI,CAACb,UAAU,EAAE;IACf,OAAO,MAAM,CAAC,CAAC;EACjB;EACA,OAAOA,UAAU,CAACQ,SAAS,CAAChH,OAAO,CAAC8E,UAAU,EAAEmC,uBAAc,CAACK,YAAY,EAAE;IAC3EC,UAAU,GAAAF,eAAA,GAAErH,OAAO,CAACiD,MAAM,qBAAdoE,eAAA,CAAgBG;EAC9B,CAAC,CAAC;AACJ;AAEA,SAASzF,mBAAmBA,CAC1B;EAAEW,OAAO;EAAEpC;AAAgC,CAAC,EAC5CsB,KAAa,EACbuF,WAI0B,EAC1BjG,OAAe,EACf;EAAA,IAAAuG,YAAA;EACA,MAAMtF,IAAI,IAAAsF,YAAA,GAAGnH,OAAO,CAACW,GAAG,qBAAXwG,YAAA,CAAcvG,OAAO,CAAC;EACnC,OAAOiB,IAAI,GAAGgF,WAAW,CAACzE,OAAO,EAAEP,IAAI,EAAE,GAAGP,KAAK,SAASV,OAAO,IAAI,CAAC,GAAG,IAAI;AAC/E;AAEA,SAASc,wBAAwBA,CAC/B;EAAEU,OAAO;EAAEpC;AAAgC,CAAC,EAC5CsB,KAAa,EACbuF,WAI0B,EAC1B9F,KAAa,EACb;EAAA,IAAAqG,kBAAA;EACA,MAAMvF,IAAI,IAAAuF,kBAAA,GAAGpH,OAAO,CAACc,SAAS,qBAAjBsG,kBAAA,CAAoBrG,KAAK,CAAC;EACvC,IAAI,CAACc,IAAI,EAAE,MAAM,IAAIwF,KAAK,CAAC,sCAAsC,CAAC;EAElE,OAAOR,WAAW,CAACzE,OAAO,EAAEP,IAAI,EAAE,GAAGP,KAAK,cAAcP,KAAK,GAAG,CAAC;AACnE;AAEA,SAASY,2BAA2BA,CAClC;EAAES,OAAO;EAAEpC;AAAgC,CAAC,EAC5CsB,KAAa,EACbuF,WAI0B,EAC1B9F,KAAa,EACbH,OAAe,EACf;EAAA,IAAA0G,mBAAA,EAAAC,aAAA;EACA,MAAMC,QAAQ,IAAAF,mBAAA,GAAGtH,OAAO,CAACc,SAAS,qBAAjBwG,mBAAA,CAAoBvG,KAAK,CAAC;EAC3C,IAAI,CAACyG,QAAQ,EAAE,MAAM,IAAIH,KAAK,CAAC,sCAAsC,CAAC;EAEtE,MAAMxF,IAAI,IAAA0F,aAAA,GAAGC,QAAQ,CAAC7G,GAAG,qBAAZ4G,aAAA,CAAe3G,OAAO,CAAC;EACpC,OAAOiB,IAAI,GACPgF,WAAW,CACTzE,OAAO,EACPP,IAAI,EACJ,GAAGP,KAAK,cAAcP,KAAK,UAAUH,OAAO,IAC9C,CAAC,GACD,IAAI;AACV;AAEA,SAASL,eAAeA,CAMtB;EACAC,IAAI;EACJG,GAAG;EACHG,SAAS;EACTG,YAAY;EACZE;AAmBF,CAAC,EAKgC;EAC/B,OAAO,UAAUsG,WAAWA,CAACzB,KAAK,EAAEtG,OAAO,EAAEU,KAAK,GAAG,IAAIC,GAAG,CAAC,CAAC,EAAE6F,UAAU,EAAE;IAC1E,MAAM;MAAE9D;IAAQ,CAAC,GAAG4D,KAAK;IAEzB,MAAM0B,gBAIH,GAAG,EAAE;IAER,MAAMC,QAAQ,GAAGnH,IAAI,CAACwF,KAAK,CAAC;IAC5B,IAAI4B,kBAAkB,CAACD,QAAQ,EAAEvF,OAAO,EAAE1C,OAAO,EAAEsG,KAAK,CAAC5B,QAAQ,CAAC,EAAE;MAClEsD,gBAAgB,CAACG,IAAI,CAAC;QACpB5D,MAAM,EAAE0D,QAAQ;QAChB/G,OAAO,EAAE0B,SAAS;QAClBvB,KAAK,EAAEuB;MACT,CAAC,CAAC;MAEF,MAAMwF,OAAO,GAAGnH,GAAG,CAACqF,KAAK,EAAEtG,OAAO,CAACkB,OAAO,CAAC;MAC3C,IACEkH,OAAO,IACPF,kBAAkB,CAACE,OAAO,EAAE1F,OAAO,EAAE1C,OAAO,EAAEsG,KAAK,CAAC5B,QAAQ,CAAC,EAC7D;QACAsD,gBAAgB,CAACG,IAAI,CAAC;UACpB5D,MAAM,EAAE6D,OAAO;UACflH,OAAO,EAAElB,OAAO,CAACkB,OAAO;UACxBG,KAAK,EAAEuB;QACT,CAAC,CAAC;MACJ;MAEA,CAACqF,QAAQ,CAAC3H,OAAO,CAACc,SAAS,IAAI,EAAE,EAAEiH,OAAO,CAAC,CAACjB,CAAC,EAAE/F,KAAK,KAAK;QACvD,MAAMiH,WAAW,GAAGlH,SAAS,CAACkF,KAAK,EAAEjF,KAAK,CAAC;QAC3C,IAAI6G,kBAAkB,CAACI,WAAW,EAAE5F,OAAO,EAAE1C,OAAO,EAAEsG,KAAK,CAAC5B,QAAQ,CAAC,EAAE;UACrEsD,gBAAgB,CAACG,IAAI,CAAC;YACpB5D,MAAM,EAAE+D,WAAW;YACnBjH,KAAK;YACLH,OAAO,EAAE0B;UACX,CAAC,CAAC;UAEF,MAAM2F,eAAe,GAAGhH,YAAY,CAAC+E,KAAK,EAAEjF,KAAK,EAAErB,OAAO,CAACkB,OAAO,CAAC;UACnE,IACEqH,eAAe,IACfL,kBAAkB,CAChBK,eAAe,EACf7F,OAAO,EACP1C,OAAO,EACPsG,KAAK,CAAC5B,QACR,CAAC,EACD;YACAsD,gBAAgB,CAACG,IAAI,CAAC;cACpB5D,MAAM,EAAEgE,eAAe;cACvBlH,KAAK;cACLH,OAAO,EAAElB,OAAO,CAACkB;YACnB,CAAC,CAAC;UACJ;QACF;MACF,CAAC,CAAC;IACJ;IAKA,IACE8G,gBAAgB,CAACjC,IAAI,CACnB,CAAC;MACCxB,MAAM,EAAE;QACNjE,OAAO,EAAE;UAAEgE,MAAM;UAAEkE;QAAK;MAC1B;IACF,CAAC,KAAK7D,YAAY,CAAC3E,OAAO,EAAEsE,MAAM,EAAEkE,IAAI,EAAE9F,OAAO,CACnD,CAAC,EACD;MACA,OAAO,IAAI;IACb;IAEA,MAAMzC,KAAK,GAAGsD,UAAU,CAAC,CAAC;IAC1B,MAAMkF,MAAM,GAAGhH,YAAY,CAAC6E,KAAK,EAAEtG,OAAO,EAAEwG,UAAU,CAAC;IAEvD,KAAK,MAAM;MAAEjC,MAAM;MAAElD,KAAK;MAAEH;IAAQ,CAAC,IAAI8G,gBAAgB,EAAE;MACzD,IACE,EAAE,OAAOU,iBAAiB,CACxBzI,KAAK,EACLsE,MAAM,CAACjE,OAAO,EACdoC,OAAO,EACP1C,OAAO,EACPU,KAAK,EACL8F,UACF,CAAC,CAAC,EACF;QACA,OAAO,IAAI;MACb;MAEAiC,MAAM,CAAClE,MAAM,EAAElD,KAAK,EAAEH,OAAO,CAAC;MAC9B,OAAOyH,cAAc,CAAC1I,KAAK,EAAEsE,MAAM,CAAC;IACtC;IACA,OAAOtE,KAAK;EACd,CAAC;AACH;AAEA,UAAUyI,iBAAiBA,CACzBzI,KAAkB,EAClBkC,IAAkB,EAClBO,OAAe,EACf1C,OAAsB,EACtBU,KAAsB,EACtB8F,UAA0B,EACR;EAClB,IAAIrE,IAAI,CAACyG,OAAO,KAAKhG,SAAS,EAAE,OAAO,IAAI;EAE3C,MAAMuD,IAAI,GAAG,OAAO,IAAAnD,iBAAU,EAC5Bb,IAAI,CAACyG,OAAO,EACZlG,OAAO,EACP1C,OAAO,CAACkB,OAAO,EACflB,OAAO,CAACiD,MACV,CAAC;EAED,IAAIvC,KAAK,CAACmI,GAAG,CAAC1C,IAAI,CAAC,EAAE;IACnB,MAAM,IAAIwB,KAAK,CACb,wCAAwCxB,IAAI,CAACzB,QAAQ,KAAK,GACxD,mDAAmD,GACnDe,KAAK,CAACqD,IAAI,CAACpI,KAAK,EAAEyF,IAAI,IAAI,MAAMA,IAAI,CAACzB,QAAQ,EAAE,CAAC,CAACS,IAAI,CAAC,IAAI,CAC9D,CAAC;EACH;EAEAzE,KAAK,CAAC+D,GAAG,CAAC0B,IAAI,CAAC;EACf,MAAMlC,SAAS,GAAG,OAAOL,aAAa,CACpCyC,kBAAkB,CAACF,IAAI,CAAC,EACxBnG,OAAO,EACPU,KAAK,EACL8F,UACF,CAAC;EACD9F,KAAK,CAACqI,MAAM,CAAC5C,IAAI,CAAC;EAElB,IAAI,CAAClC,SAAS,EAAE,OAAO,KAAK;EAE5BJ,UAAU,CAAC5D,KAAK,EAAEgE,SAAS,CAAC;EAE5B,OAAO,IAAI;AACb;AAEA,SAASJ,UAAUA,CAACmF,MAAmB,EAAEC,MAAmB,EAAe;EACzED,MAAM,CAAC1I,OAAO,CAAC6H,IAAI,CAAC,GAAGc,MAAM,CAAC3I,OAAO,CAAC;EACtC0I,MAAM,CAAC7I,OAAO,CAACgI,IAAI,CAAC,GAAGc,MAAM,CAAC9I,OAAO,CAAC;EACtC6I,MAAM,CAAC3I,OAAO,CAAC8H,IAAI,CAAC,GAAGc,MAAM,CAAC5I,OAAO,CAAC;EACtC,KAAK,MAAM8F,IAAI,IAAI8C,MAAM,CAACvI,KAAK,EAAE;IAC/BsI,MAAM,CAACtI,KAAK,CAAC+D,GAAG,CAAC0B,IAAI,CAAC;EACxB;EAEA,OAAO6C,MAAM;AACf;AAEA,UAAUL,cAAcA,CACtBK,MAAmB,EACnB;EAAE1I,OAAO;EAAEH,OAAO;EAAEE;AAA+B,CAAC,EAC9B;EACtB2I,MAAM,CAAC1I,OAAO,CAAC6H,IAAI,CAAC7H,OAAO,CAAC;EAC5B0I,MAAM,CAAC7I,OAAO,CAACgI,IAAI,CAAC,IAAI,OAAOhI,OAAO,CAAC,CAAC,CAAC,CAAC;EAC1C6I,MAAM,CAAC3I,OAAO,CAAC8H,IAAI,CAAC,IAAI,OAAO9H,OAAO,CAAC,CAAC,CAAC,CAAC;EAE1C,OAAO2I,MAAM;AACf;AAEA,SAASzF,UAAUA,CAAA,EAAgB;EACjC,OAAO;IACLjD,OAAO,EAAE,EAAE;IACXD,OAAO,EAAE,EAAE;IACXF,OAAO,EAAE,EAAE;IACXO,KAAK,EAAE,IAAIC,GAAG,CAAC;EACjB,CAAC;AACH;AAEA,SAASF,wBAAwBA,CAAC0B,IAAkB,EAAsB;EACxE,MAAM7B,OAAO,GAAA4I,MAAA,CAAAC,MAAA,KACRhH,IAAI,CACR;EACD,OAAO7B,OAAO,CAACsI,OAAO;EACtB,OAAOtI,OAAO,CAACW,GAAG;EAClB,OAAOX,OAAO,CAACc,SAAS;EACxB,OAAOd,OAAO,CAACH,OAAO;EACtB,OAAOG,OAAO,CAACD,OAAO;EACtB,OAAOC,OAAO,CAAC8I,aAAa;EAC5B,OAAO9I,OAAO,CAACgE,MAAM;EACrB,OAAOhE,OAAO,CAACkI,IAAI;EACnB,OAAOlI,OAAO,CAAC+I,IAAI;EACnB,OAAO/I,OAAO,CAACgJ,OAAO;EACtB,OAAOhJ,OAAO,CAACiJ,OAAO;EAItB,IAAIC,cAAA,CAAAC,IAAA,CAAcnJ,OAAO,EAAE,WAAW,CAAC,EAAE;IACvCA,OAAO,CAACoJ,UAAU,GAAGpJ,OAAO,CAACqJ,SAAS;IACtC,OAAOrJ,OAAO,CAACqJ,SAAS;EAC1B;EACA,OAAOrJ,OAAO;AAChB;AAEA,SAASF,gBAAgBA,CACvBwJ,KAAgC,EACL;EAC3B,MAAMrJ,GAAG,GAAG,IAAIsJ,GAAG,CAGjB,CAAC;EAEH,MAAM1C,WAAW,GAAG,EAAE;EAEtB,KAAK,MAAM2C,IAAI,IAAIF,KAAK,EAAE;IACxB,IAAI,OAAOE,IAAI,CAACC,KAAK,KAAK,UAAU,EAAE;MACpC,MAAMC,KAAK,GAAGF,IAAI,CAACC,KAAK;MACxB,IAAIE,OAAO,GAAG1J,GAAG,CAAC2J,GAAG,CAACF,KAAK,CAAC;MAC5B,IAAI,CAACC,OAAO,EAAE;QACZA,OAAO,GAAG,IAAIJ,GAAG,CAAC,CAAC;QACnBtJ,GAAG,CAAC4J,GAAG,CAACH,KAAK,EAAEC,OAAO,CAAC;MACzB;MACA,IAAIG,IAAI,GAAGH,OAAO,CAACC,GAAG,CAACJ,IAAI,CAACtC,IAAI,CAAC;MACjC,IAAI,CAAC4C,IAAI,EAAE;QACTA,IAAI,GAAG;UAAEL,KAAK,EAAED;QAAK,CAAC;QACtB3C,WAAW,CAACgB,IAAI,CAACiC,IAAI,CAAC;QAItB,IAAI,CAACN,IAAI,CAACO,OAAO,EAAEJ,OAAO,CAACE,GAAG,CAACL,IAAI,CAACtC,IAAI,EAAE4C,IAAI,CAAC;MACjD,CAAC,MAAM;QACLA,IAAI,CAACL,KAAK,GAAGD,IAAI;MACnB;IACF,CAAC,MAAM;MACL3C,WAAW,CAACgB,IAAI,CAAC;QAAE4B,KAAK,EAAED;MAAK,CAAC,CAAC;IACnC;EACF;EAEA,OAAO3C,WAAW,CAACmD,MAAM,CAAC,CAACC,GAAG,EAAEH,IAAI,KAAK;IACvCG,GAAG,CAACpC,IAAI,CAACiC,IAAI,CAACL,KAAK,CAAC;IACpB,OAAOQ,GAAG;EACZ,CAAC,EAAE,EAAE,CAAC;AACR;AAEA,SAASrC,kBAAkBA,CACzB;EAAE5H;AAA+B,CAAC,EAClCoC,OAAe,EACf1C,OAAsB,EACtBwK,UAAkB,EACT;EACT,OACE,CAAClK,OAAO,CAAC+I,IAAI,KAAKzG,SAAS,IACzB6H,uBAAuB,CAACzK,OAAO,EAAEM,OAAO,CAAC+I,IAAI,EAAE3G,OAAO,EAAE8H,UAAU,CAAC,MACpElK,OAAO,CAACgJ,OAAO,KAAK1G,SAAS,IAC5B6H,uBAAuB,CAACzK,OAAO,EAAEM,OAAO,CAACgJ,OAAO,EAAE5G,OAAO,EAAE8H,UAAU,CAAC,CAAC,KACxElK,OAAO,CAACiJ,OAAO,KAAK3G,SAAS,IAC5B,CAAC6H,uBAAuB,CAACzK,OAAO,EAAEM,OAAO,CAACiJ,OAAO,EAAE7G,OAAO,EAAE8H,UAAU,CAAC,CAAC;AAE9E;AAEA,SAASC,uBAAuBA,CAC9BzK,OAAsB,EACtBqJ,IAA0B,EAC1B3G,OAAe,EACf8H,UAAkB,EACT;EACT,MAAME,QAAQ,GAAGjF,KAAK,CAACC,OAAO,CAAC2D,IAAI,CAAC,GAAGA,IAAI,GAAG,CAACA,IAAI,CAAC;EAEpD,OAAOsB,eAAe,CAAC3K,OAAO,EAAE0K,QAAQ,EAAEhI,OAAO,EAAE8H,UAAU,CAAC;AAChE;AAKA,SAASI,kBAAkBA,CACzBC,IAAY,EACZd,KAA8B,EACI;EAClC,IAAIA,KAAK,YAAYe,MAAM,EAAE;IAC3B,OAAOC,MAAM,CAAChB,KAAK,CAAC;EACtB;EAEA,OAAOA,KAAK;AACd;AAKA,SAASpF,YAAYA,CACnB3E,OAAsB,EACtBsE,MAAsC,EACtCkE,IAAoC,EACpC9F,OAAe,EACN;EACT,IAAI4B,MAAM,IAAIqG,eAAe,CAAC3K,OAAO,EAAEsE,MAAM,EAAE5B,OAAO,CAAC,EAAE;IAAA,IAAAsI,iBAAA;IACvD,MAAMC,OAAO,GAAG,6BAAAD,iBAAA,GACdhL,OAAO,CAACkE,QAAQ,YAAA8G,iBAAA,GAAI,WAAW,yCACQE,IAAI,CAACC,SAAS,CACrD7G,MAAM,EACNsG,kBACF,CAAC,YAAYlI,OAAO,GAAG;IACvB9C,KAAK,CAACqL,OAAO,CAAC;IACd,IAAIjL,OAAO,CAAC8E,UAAU,EAAE;MACtBC,OAAO,CAACC,GAAG,CAACiG,OAAO,CAAC;IACtB;IACA,OAAO,IAAI;EACb;EAEA,IAAIzC,IAAI,IAAI,CAACmC,eAAe,CAAC3K,OAAO,EAAEwI,IAAI,EAAE9F,OAAO,CAAC,EAAE;IAAA,IAAA0I,kBAAA;IACpD,MAAMH,OAAO,GAAG,6BAAAG,kBAAA,GACdpL,OAAO,CAACkE,QAAQ,YAAAkH,kBAAA,GAAI,WAAW,8CACaF,IAAI,CAACC,SAAS,CAC1D3C,IAAI,EACJoC,kBACF,CAAC,YAAYlI,OAAO,GAAG;IACvB9C,KAAK,CAACqL,OAAO,CAAC;IACd,IAAIjL,OAAO,CAAC8E,UAAU,EAAE;MACtBC,OAAO,CAACC,GAAG,CAACiG,OAAO,CAAC;IACtB;IACA,OAAO,IAAI;EACb;EAEA,OAAO,KAAK;AACd;AAMA,SAASN,eAAeA,CACtB3K,OAAsB,EACtB0K,QAAqB,EACrBhI,OAAe,EACf8H,UAAmB,EACV;EACT,OAAOE,QAAQ,CAAC3E,IAAI,CAACsF,OAAO,IAC1BnF,YAAY,CAACmF,OAAO,EAAE3I,OAAO,EAAE1C,OAAO,CAACkE,QAAQ,EAAElE,OAAO,EAAEwK,UAAU,CACtE,CAAC;AACH;AAEA,SAAStE,YAAYA,CACnBmF,OAAkB,EAClB3I,OAAe,EACf4I,UAA8B,EAC9BtL,OAAsB,EACtBwK,UAAmB,EACV;EACT,IAAI,OAAOa,OAAO,KAAK,UAAU,EAAE;IACjC,OAAO,CAAC,CAAC,IAAAE,qCAAkB,EAACF,OAAO,CAAC,CAACC,UAAU,EAAE;MAC/C5I,OAAO;MACPxB,OAAO,EAAElB,OAAO,CAACkB,OAAO;MACxB+B,MAAM,EAAEjD,OAAO,CAACiD;IAClB,CAAC,CAAC;EACJ;EAEA,IAAI,OAAOqI,UAAU,KAAK,QAAQ,EAAE;IAClC,MAAM,IAAIE,oBAAW,CACnB,mFAAmF,EACnFhB,UACF,CAAC;EACH;EAEA,IAAI,OAAOa,OAAO,KAAK,QAAQ,EAAE;IAC/BA,OAAO,GAAG,IAAArF,uBAAkB,EAACqF,OAAO,EAAE3I,OAAO,CAAC;EAChD;EACA,OAAO2I,OAAO,CAAChC,IAAI,CAACiC,UAAU,CAAC;AACjC;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js b/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js new file mode 100644 index 0000000000000000000000000000000000000000..21fb4146b7f3dcb802756eaf3141d6e424e8a399 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js @@ -0,0 +1,190 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.createCachedDescriptors = createCachedDescriptors; +exports.createDescriptor = createDescriptor; +exports.createUncachedDescriptors = createUncachedDescriptors; +function _gensync() { + const data = require("gensync"); + _gensync = function () { + return data; + }; + return data; +} +var _functional = require("../gensync-utils/functional.js"); +var _index = require("./files/index.js"); +var _item = require("./item.js"); +var _caching = require("./caching.js"); +var _resolveTargets = require("./resolve-targets.js"); +function isEqualDescriptor(a, b) { + var _a$file, _b$file, _a$file2, _b$file2; + return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && ((_a$file = a.file) == null ? void 0 : _a$file.request) === ((_b$file = b.file) == null ? void 0 : _b$file.request) && ((_a$file2 = a.file) == null ? void 0 : _a$file2.resolved) === ((_b$file2 = b.file) == null ? void 0 : _b$file2.resolved); +} +function* handlerOf(value) { + return value; +} +function optionsWithResolvedBrowserslistConfigFile(options, dirname) { + if (typeof options.browserslistConfigFile === "string") { + options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname); + } + return options; +} +function createCachedDescriptors(dirname, options, alias) { + const { + plugins, + presets, + passPerPreset + } = options; + return { + options: optionsWithResolvedBrowserslistConfigFile(options, dirname), + plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]), + presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([]) + }; +} +function createUncachedDescriptors(dirname, options, alias) { + return { + options: optionsWithResolvedBrowserslistConfigFile(options, dirname), + plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)), + presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset)) + }; +} +const PRESET_DESCRIPTOR_CACHE = new WeakMap(); +const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => { + const dirname = cache.using(dir => dir); + return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) { + const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset); + return descriptors.map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc)); + })); +}); +const PLUGIN_DESCRIPTOR_CACHE = new WeakMap(); +const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => { + const dirname = cache.using(dir => dir); + return (0, _caching.makeStrongCache)(function* (alias) { + const descriptors = yield* createPluginDescriptors(items, dirname, alias); + return descriptors.map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc)); + }); +}); +const DEFAULT_OPTIONS = {}; +function loadCachedDescriptor(cache, desc) { + const { + value, + options = DEFAULT_OPTIONS + } = desc; + if (options === false) return desc; + let cacheByOptions = cache.get(value); + if (!cacheByOptions) { + cacheByOptions = new WeakMap(); + cache.set(value, cacheByOptions); + } + let possibilities = cacheByOptions.get(options); + if (!possibilities) { + possibilities = []; + cacheByOptions.set(options, possibilities); + } + if (!possibilities.includes(desc)) { + const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc)); + if (matches.length > 0) { + return matches[0]; + } + possibilities.push(desc); + } + return desc; +} +function* createPresetDescriptors(items, dirname, alias, passPerPreset) { + return yield* createDescriptors("preset", items, dirname, alias, passPerPreset); +} +function* createPluginDescriptors(items, dirname, alias) { + return yield* createDescriptors("plugin", items, dirname, alias); +} +function* createDescriptors(type, items, dirname, alias, ownPass) { + const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, { + type, + alias: `${alias}$${index}`, + ownPass: !!ownPass + }))); + assertNoDuplicates(descriptors); + return descriptors; +} +function* createDescriptor(pair, dirname, { + type, + alias, + ownPass +}) { + const desc = (0, _item.getItemDescriptor)(pair); + if (desc) { + return desc; + } + let name; + let options; + let value = pair; + if (Array.isArray(value)) { + if (value.length === 3) { + [value, options, name] = value; + } else { + [value, options] = value; + } + } + let file = undefined; + let filepath = null; + if (typeof value === "string") { + if (typeof type !== "string") { + throw new Error("To resolve a string-based item, the type of item must be given"); + } + const resolver = type === "plugin" ? _index.loadPlugin : _index.loadPreset; + const request = value; + ({ + filepath, + value + } = yield* resolver(value, dirname)); + file = { + request, + resolved: filepath + }; + } + if (!value) { + throw new Error(`Unexpected falsy value: ${String(value)}`); + } + if (typeof value === "object" && value.__esModule) { + if (value.default) { + value = value.default; + } else { + throw new Error("Must export a default export when using ES6 modules."); + } + } + if (typeof value !== "object" && typeof value !== "function") { + throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`); + } + if (filepath !== null && typeof value === "object" && value) { + throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`); + } + return { + name, + alias: filepath || alias, + value, + options, + dirname, + ownPass, + file + }; +} +function assertNoDuplicates(items) { + const map = new Map(); + for (const item of items) { + if (typeof item.value !== "function") continue; + let nameMap = map.get(item.value); + if (!nameMap) { + nameMap = new Set(); + map.set(item.value, nameMap); + } + if (nameMap.has(item.name)) { + const conflicts = items.filter(i => i.value === item.value); + throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, ` plugins: [`, ` ['some-plugin', {}],`, ` ['some-plugin', {}, 'some unique name'],`, ` ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n")); + } + nameMap.add(item.name); + } +} +0 && 0; + +//# sourceMappingURL=config-descriptors.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js.map b/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js.map new file mode 100644 index 0000000000000000000000000000000000000000..b51b2cbd362407cf3f2ce7e210977eaf4e16ecab --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/config-descriptors.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_gensync","data","require","_functional","_index","_item","_caching","_resolveTargets","isEqualDescriptor","a","b","_a$file","_b$file","_a$file2","_b$file2","name","value","options","dirname","alias","ownPass","file","request","resolved","handlerOf","optionsWithResolvedBrowserslistConfigFile","browserslistConfigFile","resolveBrowserslistConfigFile","createCachedDescriptors","plugins","presets","passPerPreset","createCachedPluginDescriptors","createCachedPresetDescriptors","createUncachedDescriptors","once","createPluginDescriptors","createPresetDescriptors","PRESET_DESCRIPTOR_CACHE","WeakMap","makeWeakCacheSync","items","cache","using","dir","makeStrongCacheSync","makeStrongCache","descriptors","map","desc","loadCachedDescriptor","PLUGIN_DESCRIPTOR_CACHE","DEFAULT_OPTIONS","cacheByOptions","get","set","possibilities","includes","matches","filter","possibility","length","push","createDescriptors","type","gensync","all","item","index","createDescriptor","assertNoDuplicates","pair","getItemDescriptor","Array","isArray","undefined","filepath","Error","resolver","loadPlugin","loadPreset","String","__esModule","default","Map","nameMap","Set","has","conflicts","i","JSON","stringify","join","add"],"sources":["../../src/config/config-descriptors.ts"],"sourcesContent":["import gensync, { type Handler } from \"gensync\";\nimport { once } from \"../gensync-utils/functional.ts\";\n\nimport { loadPlugin, loadPreset } from \"./files/index.ts\";\n\nimport { getItemDescriptor } from \"./item.ts\";\n\nimport {\n makeWeakCacheSync,\n makeStrongCacheSync,\n makeStrongCache,\n} from \"./caching.ts\";\nimport type { CacheConfigurator } from \"./caching.ts\";\n\nimport type {\n PluginItem,\n InputOptions,\n PresetItem,\n} from \"./validation/options.ts\";\n\nimport { resolveBrowserslistConfigFile } from \"./resolve-targets.ts\";\nimport type { PluginAPI, PresetAPI } from \"./helpers/config-api.ts\";\n\n// Represents a config object and functions to lazily load the descriptors\n// for the plugins and presets so we don't load the plugins/presets unless\n// the options object actually ends up being applicable.\nexport type OptionsAndDescriptors = {\n options: InputOptions;\n plugins: () => Handler[]>;\n presets: () => Handler[]>;\n};\n\n// Represents a plugin or presets at a given location in a config object.\n// At this point these have been resolved to a specific object or function,\n// but have not yet been executed to call functions with options.\nexport interface UnloadedDescriptor {\n name: string | undefined;\n value: object | ((api: API, options: Options, dirname: string) => unknown);\n options: Options;\n dirname: string;\n alias: string;\n ownPass?: boolean;\n file?: {\n request: string;\n resolved: string;\n };\n}\n\nfunction isEqualDescriptor(\n a: UnloadedDescriptor,\n b: UnloadedDescriptor,\n): boolean {\n return (\n a.name === b.name &&\n a.value === b.value &&\n a.options === b.options &&\n a.dirname === b.dirname &&\n a.alias === b.alias &&\n a.ownPass === b.ownPass &&\n a.file?.request === b.file?.request &&\n a.file?.resolved === b.file?.resolved\n );\n}\n\nexport type ValidatedFile = {\n filepath: string;\n dirname: string;\n options: InputOptions;\n};\n\n// eslint-disable-next-line require-yield\nfunction* handlerOf(value: T): Handler {\n return value;\n}\n\nfunction optionsWithResolvedBrowserslistConfigFile(\n options: InputOptions,\n dirname: string,\n): InputOptions {\n if (typeof options.browserslistConfigFile === \"string\") {\n options.browserslistConfigFile = resolveBrowserslistConfigFile(\n options.browserslistConfigFile,\n dirname,\n );\n }\n return options;\n}\n\n/**\n * Create a set of descriptors from a given options object, preserving\n * descriptor identity based on the identity of the plugin/preset arrays\n * themselves, and potentially on the identity of the plugins/presets + options.\n */\nexport function createCachedDescriptors(\n dirname: string,\n options: InputOptions,\n alias: string,\n): OptionsAndDescriptors {\n const { plugins, presets, passPerPreset } = options;\n return {\n options: optionsWithResolvedBrowserslistConfigFile(options, dirname),\n plugins: plugins\n ? () =>\n // @ts-expect-error todo(flow->ts) ts complains about incorrect arguments\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n createCachedPluginDescriptors(plugins, dirname)(alias)\n : () => handlerOf([]),\n presets: presets\n ? () =>\n // @ts-expect-error todo(flow->ts) ts complains about incorrect arguments\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n createCachedPresetDescriptors(presets, dirname)(alias)(\n !!passPerPreset,\n )\n : () => handlerOf([]),\n };\n}\n\n/**\n * Create a set of descriptors from a given options object, with consistent\n * identity for the descriptors, but not caching based on any specific identity.\n */\nexport function createUncachedDescriptors(\n dirname: string,\n options: InputOptions,\n alias: string,\n): OptionsAndDescriptors {\n return {\n options: optionsWithResolvedBrowserslistConfigFile(options, dirname),\n // The returned result here is cached to represent a config object in\n // memory, so we build and memoize the descriptors to ensure the same\n // values are returned consistently.\n plugins: once(() =>\n createPluginDescriptors(options.plugins || [], dirname, alias),\n ),\n presets: once(() =>\n createPresetDescriptors(\n options.presets || [],\n dirname,\n alias,\n !!options.passPerPreset,\n ),\n ),\n };\n}\n\nconst PRESET_DESCRIPTOR_CACHE = new WeakMap();\nconst createCachedPresetDescriptors = makeWeakCacheSync(\n (items: PresetItem[], cache: CacheConfigurator) => {\n const dirname = cache.using(dir => dir);\n return makeStrongCacheSync((alias: string) =>\n makeStrongCache(function* (\n passPerPreset: boolean,\n ): Handler[]> {\n const descriptors = yield* createPresetDescriptors(\n items,\n dirname,\n alias,\n passPerPreset,\n );\n return descriptors.map(\n // Items are cached using the overall preset array identity when\n // possibly, but individual descriptors are also cached if a match\n // can be found in the previously-used descriptor lists.\n desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc),\n );\n }),\n );\n },\n);\n\nconst PLUGIN_DESCRIPTOR_CACHE = new WeakMap();\nconst createCachedPluginDescriptors = makeWeakCacheSync(\n (items: PluginItem[], cache: CacheConfigurator) => {\n const dirname = cache.using(dir => dir);\n return makeStrongCache(function* (\n alias: string,\n ): Handler[]> {\n const descriptors = yield* createPluginDescriptors(items, dirname, alias);\n return descriptors.map(\n // Items are cached using the overall plugin array identity when\n // possibly, but individual descriptors are also cached if a match\n // can be found in the previously-used descriptor lists.\n desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc),\n );\n });\n },\n);\n\n/**\n * When no options object is given in a descriptor, this object is used\n * as a WeakMap key in order to have consistent identity.\n */\nconst DEFAULT_OPTIONS = {};\n\n/**\n * Given the cache and a descriptor, returns a matching descriptor from the\n * cache, or else returns the input descriptor and adds it to the cache for\n * next time.\n */\nfunction loadCachedDescriptor(\n cache: WeakMap[]>>,\n desc: UnloadedDescriptor,\n) {\n const { value, options = DEFAULT_OPTIONS } = desc;\n if (options === false) return desc;\n\n let cacheByOptions = cache.get(value);\n if (!cacheByOptions) {\n cacheByOptions = new WeakMap();\n cache.set(value, cacheByOptions);\n }\n\n let possibilities = cacheByOptions.get(options);\n if (!possibilities) {\n possibilities = [];\n cacheByOptions.set(options, possibilities);\n }\n\n if (!possibilities.includes(desc)) {\n const matches = possibilities.filter(possibility =>\n isEqualDescriptor(possibility, desc),\n );\n if (matches.length > 0) {\n return matches[0];\n }\n\n possibilities.push(desc);\n }\n\n return desc;\n}\n\nfunction* createPresetDescriptors(\n items: PresetItem[],\n dirname: string,\n alias: string,\n passPerPreset: boolean,\n): Handler[]> {\n return yield* createDescriptors(\n \"preset\",\n items,\n dirname,\n alias,\n passPerPreset,\n );\n}\n\nfunction* createPluginDescriptors(\n items: PluginItem[],\n dirname: string,\n alias: string,\n): Handler[]> {\n return yield* createDescriptors(\"plugin\", items, dirname, alias);\n}\n\nfunction* createDescriptors(\n type: Type,\n items: Type extends \"plugin\" ? PluginItem[] : PresetItem[],\n dirname: string,\n alias: string,\n ownPass?: boolean,\n): Handler<\n UnloadedDescriptor[]\n> {\n const descriptors = yield* gensync.all(\n items.map((item, index) =>\n createDescriptor(item, dirname, {\n type,\n alias: `${alias}$${index}`,\n ownPass: !!ownPass,\n }),\n ),\n );\n\n assertNoDuplicates(descriptors);\n\n return descriptors;\n}\n\n/**\n * Given a plugin/preset item, resolve it into a standard format.\n */\nexport function* createDescriptor(\n pair: PluginItem | PresetItem,\n dirname: string,\n {\n type,\n alias,\n ownPass,\n }: {\n type?: \"plugin\" | \"preset\";\n alias: string;\n ownPass?: boolean;\n },\n): Handler> {\n const desc = getItemDescriptor(pair);\n if (desc) {\n return desc;\n }\n\n let name;\n let options;\n let value = pair;\n if (Array.isArray(value)) {\n if (value.length === 3) {\n [value, options, name] = value;\n } else {\n [value, options] = value;\n }\n }\n\n let file = undefined;\n let filepath = null;\n if (typeof value === \"string\") {\n if (typeof type !== \"string\") {\n throw new Error(\n \"To resolve a string-based item, the type of item must be given\",\n );\n }\n const resolver = type === \"plugin\" ? loadPlugin : loadPreset;\n const request = value;\n\n // @ts-expect-error value must be a PluginItem\n ({ filepath, value } = yield* resolver(value, dirname));\n\n file = {\n request,\n resolved: filepath,\n };\n }\n\n if (!value) {\n // eslint-disable-next-line @typescript-eslint/no-base-to-string\n throw new Error(`Unexpected falsy value: ${String(value)}`);\n }\n\n // @ts-expect-error Handle transpiled ES6 modules.\n if (typeof value === \"object\" && value.__esModule) {\n // @ts-expect-error Handle transpiled ES6 modules.\n if (value.default) {\n // @ts-expect-error Handle transpiled ES6 modules.\n value = value.default;\n } else {\n throw new Error(\"Must export a default export when using ES6 modules.\");\n }\n }\n\n if (typeof value !== \"object\" && typeof value !== \"function\") {\n throw new Error(\n `Unsupported format: ${typeof value}. Expected an object or a function.`,\n );\n }\n\n if (filepath !== null && typeof value === \"object\" && value) {\n // We allow object values for plugins/presets nested directly within a\n // config object, because it can be useful to define them in nested\n // configuration contexts.\n throw new Error(\n `Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`,\n );\n }\n\n return {\n name,\n alias: filepath || alias,\n value,\n options,\n dirname,\n ownPass,\n file,\n };\n}\n\nfunction assertNoDuplicates(items: UnloadedDescriptor[]): void {\n const map = new Map();\n\n for (const item of items) {\n if (typeof item.value !== \"function\") continue;\n\n let nameMap = map.get(item.value);\n if (!nameMap) {\n nameMap = new Set();\n map.set(item.value, nameMap);\n }\n\n if (nameMap.has(item.name)) {\n const conflicts = items.filter(i => i.value === item.value);\n throw new Error(\n [\n `Duplicate plugin/preset detected.`,\n `If you'd like to use two separate instances of a plugin,`,\n `they need separate names, e.g.`,\n ``,\n ` plugins: [`,\n ` ['some-plugin', {}],`,\n ` ['some-plugin', {}, 'some unique name'],`,\n ` ]`,\n ``,\n `Duplicates detected are:`,\n `${JSON.stringify(conflicts, null, 2)}`,\n ].join(\"\\n\"),\n );\n }\n\n nameMap.add(item.name);\n }\n}\n"],"mappings":";;;;;;;;AAAA,SAAAA,SAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,QAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,IAAAE,WAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAEA,IAAAG,KAAA,GAAAH,OAAA;AAEA,IAAAI,QAAA,GAAAJ,OAAA;AAaA,IAAAK,eAAA,GAAAL,OAAA;AA4BA,SAASM,iBAAiBA,CACxBC,CAA0B,EAC1BC,CAA0B,EACjB;EAAA,IAAAC,OAAA,EAAAC,OAAA,EAAAC,QAAA,EAAAC,QAAA;EACT,OACEL,CAAC,CAACM,IAAI,KAAKL,CAAC,CAACK,IAAI,IACjBN,CAAC,CAACO,KAAK,KAAKN,CAAC,CAACM,KAAK,IACnBP,CAAC,CAACQ,OAAO,KAAKP,CAAC,CAACO,OAAO,IACvBR,CAAC,CAACS,OAAO,KAAKR,CAAC,CAACQ,OAAO,IACvBT,CAAC,CAACU,KAAK,KAAKT,CAAC,CAACS,KAAK,IACnBV,CAAC,CAACW,OAAO,KAAKV,CAAC,CAACU,OAAO,IACvB,EAAAT,OAAA,GAAAF,CAAC,CAACY,IAAI,qBAANV,OAAA,CAAQW,OAAO,QAAAV,OAAA,GAAKF,CAAC,CAACW,IAAI,qBAANT,OAAA,CAAQU,OAAO,KACnC,EAAAT,QAAA,GAAAJ,CAAC,CAACY,IAAI,qBAANR,QAAA,CAAQU,QAAQ,QAAAT,QAAA,GAAKJ,CAAC,CAACW,IAAI,qBAANP,QAAA,CAAQS,QAAQ;AAEzC;AASA,UAAUC,SAASA,CAAIR,KAAQ,EAAc;EAC3C,OAAOA,KAAK;AACd;AAEA,SAASS,yCAAyCA,CAChDR,OAAqB,EACrBC,OAAe,EACD;EACd,IAAI,OAAOD,OAAO,CAACS,sBAAsB,KAAK,QAAQ,EAAE;IACtDT,OAAO,CAACS,sBAAsB,GAAG,IAAAC,6CAA6B,EAC5DV,OAAO,CAACS,sBAAsB,EAC9BR,OACF,CAAC;EACH;EACA,OAAOD,OAAO;AAChB;AAOO,SAASW,uBAAuBA,CACrCV,OAAe,EACfD,OAAqB,EACrBE,KAAa,EACU;EACvB,MAAM;IAAEU,OAAO;IAAEC,OAAO;IAAEC;EAAc,CAAC,GAAGd,OAAO;EACnD,OAAO;IACLA,OAAO,EAAEQ,yCAAyC,CAACR,OAAO,EAAEC,OAAO,CAAC;IACpEW,OAAO,EAAEA,OAAO,GACZ,MAGEG,6BAA6B,CAACH,OAAO,EAAEX,OAAO,CAAC,CAACC,KAAK,CAAC,GACxD,MAAMK,SAAS,CAAC,EAAE,CAAC;IACvBM,OAAO,EAAEA,OAAO,GACZ,MAGEG,6BAA6B,CAACH,OAAO,EAAEZ,OAAO,CAAC,CAACC,KAAK,CAAC,CACpD,CAAC,CAACY,aACJ,CAAC,GACH,MAAMP,SAAS,CAAC,EAAE;EACxB,CAAC;AACH;AAMO,SAASU,yBAAyBA,CACvChB,OAAe,EACfD,OAAqB,EACrBE,KAAa,EACU;EACvB,OAAO;IACLF,OAAO,EAAEQ,yCAAyC,CAACR,OAAO,EAAEC,OAAO,CAAC;IAIpEW,OAAO,EAAE,IAAAM,gBAAI,EAAC,MACZC,uBAAuB,CAACnB,OAAO,CAACY,OAAO,IAAI,EAAE,EAAEX,OAAO,EAAEC,KAAK,CAC/D,CAAC;IACDW,OAAO,EAAE,IAAAK,gBAAI,EAAC,MACZE,uBAAuB,CACrBpB,OAAO,CAACa,OAAO,IAAI,EAAE,EACrBZ,OAAO,EACPC,KAAK,EACL,CAAC,CAACF,OAAO,CAACc,aACZ,CACF;EACF,CAAC;AACH;AAEA,MAAMO,uBAAuB,GAAG,IAAIC,OAAO,CAAC,CAAC;AAC7C,MAAMN,6BAA6B,GAAG,IAAAO,0BAAiB,EACrD,CAACC,KAAmB,EAAEC,KAAgC,KAAK;EACzD,MAAMxB,OAAO,GAAGwB,KAAK,CAACC,KAAK,CAACC,GAAG,IAAIA,GAAG,CAAC;EACvC,OAAO,IAAAC,4BAAmB,EAAE1B,KAAa,IACvC,IAAA2B,wBAAe,EAAC,WACdf,aAAsB,EACoB;IAC1C,MAAMgB,WAAW,GAAG,OAAOV,uBAAuB,CAChDI,KAAK,EACLvB,OAAO,EACPC,KAAK,EACLY,aACF,CAAC;IACD,OAAOgB,WAAW,CAACC,GAAG,CAIpBC,IAAI,IAAIC,oBAAoB,CAACZ,uBAAuB,EAAEW,IAAI,CAC5D,CAAC;EACH,CAAC,CACH,CAAC;AACH,CACF,CAAC;AAED,MAAME,uBAAuB,GAAG,IAAIZ,OAAO,CAAC,CAAC;AAC7C,MAAMP,6BAA6B,GAAG,IAAAQ,0BAAiB,EACrD,CAACC,KAAmB,EAAEC,KAAgC,KAAK;EACzD,MAAMxB,OAAO,GAAGwB,KAAK,CAACC,KAAK,CAACC,GAAG,IAAIA,GAAG,CAAC;EACvC,OAAO,IAAAE,wBAAe,EAAC,WACrB3B,KAAa,EAC6B;IAC1C,MAAM4B,WAAW,GAAG,OAAOX,uBAAuB,CAACK,KAAK,EAAEvB,OAAO,EAAEC,KAAK,CAAC;IACzE,OAAO4B,WAAW,CAACC,GAAG,CAIpBC,IAAI,IAAIC,oBAAoB,CAACC,uBAAuB,EAAEF,IAAI,CAC5D,CAAC;EACH,CAAC,CAAC;AACJ,CACF,CAAC;AAMD,MAAMG,eAAe,GAAG,CAAC,CAAC;AAO1B,SAASF,oBAAoBA,CAC3BR,KAA6E,EAC7EO,IAA6B,EAC7B;EACA,MAAM;IAAEjC,KAAK;IAAEC,OAAO,GAAGmC;EAAgB,CAAC,GAAGH,IAAI;EACjD,IAAIhC,OAAO,KAAK,KAAK,EAAE,OAAOgC,IAAI;EAElC,IAAII,cAAc,GAAGX,KAAK,CAACY,GAAG,CAACtC,KAAK,CAAC;EACrC,IAAI,CAACqC,cAAc,EAAE;IACnBA,cAAc,GAAG,IAAId,OAAO,CAAC,CAAC;IAC9BG,KAAK,CAACa,GAAG,CAACvC,KAAK,EAAEqC,cAAc,CAAC;EAClC;EAEA,IAAIG,aAAa,GAAGH,cAAc,CAACC,GAAG,CAACrC,OAAO,CAAC;EAC/C,IAAI,CAACuC,aAAa,EAAE;IAClBA,aAAa,GAAG,EAAE;IAClBH,cAAc,CAACE,GAAG,CAACtC,OAAO,EAAEuC,aAAa,CAAC;EAC5C;EAEA,IAAI,CAACA,aAAa,CAACC,QAAQ,CAACR,IAAI,CAAC,EAAE;IACjC,MAAMS,OAAO,GAAGF,aAAa,CAACG,MAAM,CAACC,WAAW,IAC9CpD,iBAAiB,CAACoD,WAAW,EAAEX,IAAI,CACrC,CAAC;IACD,IAAIS,OAAO,CAACG,MAAM,GAAG,CAAC,EAAE;MACtB,OAAOH,OAAO,CAAC,CAAC,CAAC;IACnB;IAEAF,aAAa,CAACM,IAAI,CAACb,IAAI,CAAC;EAC1B;EAEA,OAAOA,IAAI;AACb;AAEA,UAAUZ,uBAAuBA,CAC/BI,KAAmB,EACnBvB,OAAe,EACfC,KAAa,EACbY,aAAsB,EACoB;EAC1C,OAAO,OAAOgC,iBAAiB,CAC7B,QAAQ,EACRtB,KAAK,EACLvB,OAAO,EACPC,KAAK,EACLY,aACF,CAAC;AACH;AAEA,UAAUK,uBAAuBA,CAC/BK,KAAmB,EACnBvB,OAAe,EACfC,KAAa,EAC6B;EAC1C,OAAO,OAAO4C,iBAAiB,CAAC,QAAQ,EAAEtB,KAAK,EAAEvB,OAAO,EAAEC,KAAK,CAAC;AAClE;AAEA,UAAU4C,iBAAiBA,CACzBC,IAAU,EACVvB,KAA0D,EAC1DvB,OAAe,EACfC,KAAa,EACbC,OAAiB,EAGjB;EACA,MAAM2B,WAAW,GAAG,OAAOkB,SAAMA,CAAC,CAACC,GAAG,CACpCzB,KAAK,CAACO,GAAG,CAAC,CAACmB,IAAI,EAAEC,KAAK,KACpBC,gBAAgB,CAACF,IAAI,EAAEjD,OAAO,EAAE;IAC9B8C,IAAI;IACJ7C,KAAK,EAAE,GAAGA,KAAK,IAAIiD,KAAK,EAAE;IAC1BhD,OAAO,EAAE,CAAC,CAACA;EACb,CAAC,CACH,CACF,CAAC;EAEDkD,kBAAkB,CAACvB,WAAW,CAAC;EAE/B,OAAOA,WAAW;AACpB;AAKO,UAAUsB,gBAAgBA,CAC/BE,IAA6B,EAC7BrD,OAAe,EACf;EACE8C,IAAI;EACJ7C,KAAK;EACLC;AAKF,CAAC,EACiC;EAClC,MAAM6B,IAAI,GAAG,IAAAuB,uBAAiB,EAACD,IAAI,CAAC;EACpC,IAAItB,IAAI,EAAE;IACR,OAAOA,IAAI;EACb;EAEA,IAAIlC,IAAI;EACR,IAAIE,OAAO;EACX,IAAID,KAAK,GAAGuD,IAAI;EAChB,IAAIE,KAAK,CAACC,OAAO,CAAC1D,KAAK,CAAC,EAAE;IACxB,IAAIA,KAAK,CAAC6C,MAAM,KAAK,CAAC,EAAE;MACtB,CAAC7C,KAAK,EAAEC,OAAO,EAAEF,IAAI,CAAC,GAAGC,KAAK;IAChC,CAAC,MAAM;MACL,CAACA,KAAK,EAAEC,OAAO,CAAC,GAAGD,KAAK;IAC1B;EACF;EAEA,IAAIK,IAAI,GAAGsD,SAAS;EACpB,IAAIC,QAAQ,GAAG,IAAI;EACnB,IAAI,OAAO5D,KAAK,KAAK,QAAQ,EAAE;IAC7B,IAAI,OAAOgD,IAAI,KAAK,QAAQ,EAAE;MAC5B,MAAM,IAAIa,KAAK,CACb,gEACF,CAAC;IACH;IACA,MAAMC,QAAQ,GAAGd,IAAI,KAAK,QAAQ,GAAGe,iBAAU,GAAGC,iBAAU;IAC5D,MAAM1D,OAAO,GAAGN,KAAK;IAGrB,CAAC;MAAE4D,QAAQ;MAAE5D;IAAM,CAAC,GAAG,OAAO8D,QAAQ,CAAC9D,KAAK,EAAEE,OAAO,CAAC;IAEtDG,IAAI,GAAG;MACLC,OAAO;MACPC,QAAQ,EAAEqD;IACZ,CAAC;EACH;EAEA,IAAI,CAAC5D,KAAK,EAAE;IAEV,MAAM,IAAI6D,KAAK,CAAC,2BAA2BI,MAAM,CAACjE,KAAK,CAAC,EAAE,CAAC;EAC7D;EAGA,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,CAACkE,UAAU,EAAE;IAEjD,IAAIlE,KAAK,CAACmE,OAAO,EAAE;MAEjBnE,KAAK,GAAGA,KAAK,CAACmE,OAAO;IACvB,CAAC,MAAM;MACL,MAAM,IAAIN,KAAK,CAAC,sDAAsD,CAAC;IACzE;EACF;EAEA,IAAI,OAAO7D,KAAK,KAAK,QAAQ,IAAI,OAAOA,KAAK,KAAK,UAAU,EAAE;IAC5D,MAAM,IAAI6D,KAAK,CACb,uBAAuB,OAAO7D,KAAK,qCACrC,CAAC;EACH;EAEA,IAAI4D,QAAQ,KAAK,IAAI,IAAI,OAAO5D,KAAK,KAAK,QAAQ,IAAIA,KAAK,EAAE;IAI3D,MAAM,IAAI6D,KAAK,CACb,6EAA6ED,QAAQ,EACvF,CAAC;EACH;EAEA,OAAO;IACL7D,IAAI;IACJI,KAAK,EAAEyD,QAAQ,IAAIzD,KAAK;IACxBH,KAAK;IACLC,OAAO;IACPC,OAAO;IACPE,OAAO;IACPC;EACF,CAAC;AACH;AAEA,SAASiD,kBAAkBA,CAAM7B,KAAgC,EAAQ;EACvE,MAAMO,GAAG,GAAG,IAAIoC,GAAG,CAAC,CAAC;EAErB,KAAK,MAAMjB,IAAI,IAAI1B,KAAK,EAAE;IACxB,IAAI,OAAO0B,IAAI,CAACnD,KAAK,KAAK,UAAU,EAAE;IAEtC,IAAIqE,OAAO,GAAGrC,GAAG,CAACM,GAAG,CAACa,IAAI,CAACnD,KAAK,CAAC;IACjC,IAAI,CAACqE,OAAO,EAAE;MACZA,OAAO,GAAG,IAAIC,GAAG,CAAC,CAAC;MACnBtC,GAAG,CAACO,GAAG,CAACY,IAAI,CAACnD,KAAK,EAAEqE,OAAO,CAAC;IAC9B;IAEA,IAAIA,OAAO,CAACE,GAAG,CAACpB,IAAI,CAACpD,IAAI,CAAC,EAAE;MAC1B,MAAMyE,SAAS,GAAG/C,KAAK,CAACkB,MAAM,CAAC8B,CAAC,IAAIA,CAAC,CAACzE,KAAK,KAAKmD,IAAI,CAACnD,KAAK,CAAC;MAC3D,MAAM,IAAI6D,KAAK,CACb,CACE,mCAAmC,EACnC,0DAA0D,EAC1D,gCAAgC,EAChC,EAAE,EACF,cAAc,EACd,0BAA0B,EAC1B,8CAA8C,EAC9C,KAAK,EACL,EAAE,EACF,0BAA0B,EAC1B,GAAGa,IAAI,CAACC,SAAS,CAACH,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CACxC,CAACI,IAAI,CAAC,IAAI,CACb,CAAC;IACH;IAEAP,OAAO,CAACQ,GAAG,CAAC1B,IAAI,CAACpD,IAAI,CAAC;EACxB;AACF;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js b/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js new file mode 100644 index 0000000000000000000000000000000000000000..582fc327e173fefad09fa07c9c1866eb41067282 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js @@ -0,0 +1,290 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ROOT_CONFIG_FILENAMES = void 0; +exports.findConfigUpwards = findConfigUpwards; +exports.findRelativeConfig = findRelativeConfig; +exports.findRootConfig = findRootConfig; +exports.loadConfig = loadConfig; +exports.resolveShowConfigPath = resolveShowConfigPath; +function _debug() { + const data = require("debug"); + _debug = function () { + return data; + }; + return data; +} +function _fs() { + const data = require("fs"); + _fs = function () { + return data; + }; + return data; +} +function _path() { + const data = require("path"); + _path = function () { + return data; + }; + return data; +} +function _json() { + const data = require("json5"); + _json = function () { + return data; + }; + return data; +} +function _gensync() { + const data = require("gensync"); + _gensync = function () { + return data; + }; + return data; +} +var _caching = require("../caching.js"); +var _configApi = require("../helpers/config-api.js"); +var _utils = require("./utils.js"); +var _moduleTypes = require("./module-types.js"); +var _patternToRegex = require("../pattern-to-regex.js"); +var _configError = require("../../errors/config-error.js"); +var fs = require("../../gensync-utils/fs.js"); +require("module"); +var _rewriteStackTrace = require("../../errors/rewrite-stack-trace.js"); +var _async = require("../../gensync-utils/async.js"); +const debug = _debug()("babel:config:loading:files:configuration"); +const ROOT_CONFIG_FILENAMES = exports.ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts", "babel.config.ts", "babel.config.mts"]; +const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts"]; +const BABELIGNORE_FILENAME = ".babelignore"; +const runConfig = (0, _caching.makeWeakCache)(function* runConfig(options, cache) { + yield* []; + return { + options: (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache)), + cacheNeedsConfiguration: !cache.configured() + }; +}); +function* readConfigCode(filepath, data) { + if (!_fs().existsSync(filepath)) return null; + let options = yield* (0, _moduleTypes.default)(filepath, (yield* (0, _async.isAsync)()) ? "auto" : "require", "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously " + "or when using the Node.js `--experimental-require-module` flag.", "You appear to be using a configuration file that contains top-level " + "await, which is only supported when running Babel asynchronously."); + let cacheNeedsConfiguration = false; + if (typeof options === "function") { + ({ + options, + cacheNeedsConfiguration + } = yield* runConfig(options, data)); + } + if (!options || typeof options !== "object" || Array.isArray(options)) { + throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath); + } + if (typeof options.then === "function") { + options.catch == null || options.catch(() => {}); + throw new _configError.default(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath); + } + if (cacheNeedsConfiguration) throwConfigError(filepath); + return buildConfigFileObject(options, filepath); +} +const cfboaf = new WeakMap(); +function buildConfigFileObject(options, filepath) { + let configFilesByFilepath = cfboaf.get(options); + if (!configFilesByFilepath) { + cfboaf.set(options, configFilesByFilepath = new Map()); + } + let configFile = configFilesByFilepath.get(filepath); + if (!configFile) { + configFile = { + filepath, + dirname: _path().dirname(filepath), + options + }; + configFilesByFilepath.set(filepath, configFile); + } + return configFile; +} +const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => { + const babel = file.options.babel; + if (babel === undefined) return null; + if (typeof babel !== "object" || Array.isArray(babel) || babel === null) { + throw new _configError.default(`.babel property must be an object`, file.filepath); + } + return { + filepath: file.filepath, + dirname: file.dirname, + options: babel + }; +}); +const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => { + let options; + try { + options = _json().parse(content); + } catch (err) { + throw new _configError.default(`Error while parsing config - ${err.message}`, filepath); + } + if (!options) throw new _configError.default(`No config detected`, filepath); + if (typeof options !== "object") { + throw new _configError.default(`Config returned typeof ${typeof options}`, filepath); + } + if (Array.isArray(options)) { + throw new _configError.default(`Expected config object but found array`, filepath); + } + delete options.$schema; + return { + filepath, + dirname: _path().dirname(filepath), + options + }; +}); +const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => { + const ignoreDir = _path().dirname(filepath); + const ignorePatterns = content.split("\n").map(line => line.replace(/#.*$/, "").trim()).filter(Boolean); + for (const pattern of ignorePatterns) { + if (pattern.startsWith("!")) { + throw new _configError.default(`Negation of file paths is not supported.`, filepath); + } + } + return { + filepath, + dirname: _path().dirname(filepath), + ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir)) + }; +}); +function findConfigUpwards(rootDir) { + let dirname = rootDir; + for (;;) { + for (const filename of ROOT_CONFIG_FILENAMES) { + if (_fs().existsSync(_path().join(dirname, filename))) { + return dirname; + } + } + const nextDir = _path().dirname(dirname); + if (dirname === nextDir) break; + dirname = nextDir; + } + return null; +} +function* findRelativeConfig(packageData, envName, caller) { + let config = null; + let ignore = null; + const dirname = _path().dirname(packageData.filepath); + for (const loc of packageData.directories) { + if (!config) { + var _packageData$pkg; + config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null); + } + if (!ignore) { + const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME); + ignore = yield* readIgnoreConfig(ignoreLoc); + if (ignore) { + debug("Found ignore %o from %o.", ignore.filepath, dirname); + } + } + } + return { + config, + ignore + }; +} +function findRootConfig(dirname, envName, caller) { + return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller); +} +function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) { + const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller))); + const config = configs.reduce((previousConfig, config) => { + if (config && previousConfig) { + throw new _configError.default(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`); + } + return config || previousConfig; + }, previousConfig); + if (config) { + debug("Found configuration %o from %o.", config.filepath, dirname); + } + return config; +} +function* loadConfig(name, dirname, envName, caller) { + const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, { + paths: [b] + }, M = require("module")) => { + let f = M._findPath(r, M._nodeModulePaths(b).concat(b)); + if (f) return f; + f = new Error(`Cannot resolve module '${r}'`); + f.code = "MODULE_NOT_FOUND"; + throw f; + })(name, { + paths: [dirname] + }); + const conf = yield* readConfig(filepath, envName, caller); + if (!conf) { + throw new _configError.default(`Config file contains no configuration data`, filepath); + } + debug("Loaded config %o from %o.", name, dirname); + return conf; +} +function readConfig(filepath, envName, caller) { + const ext = _path().extname(filepath); + switch (ext) { + case ".js": + case ".cjs": + case ".mjs": + case ".ts": + case ".cts": + case ".mts": + return readConfigCode(filepath, { + envName, + caller + }); + default: + return readConfigJSON5(filepath); + } +} +function* resolveShowConfigPath(dirname) { + const targetPath = process.env.BABEL_SHOW_CONFIG_FOR; + if (targetPath != null) { + const absolutePath = _path().resolve(dirname, targetPath); + const stats = yield* fs.stat(absolutePath); + if (!stats.isFile()) { + throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`); + } + return absolutePath; + } + return null; +} +function throwConfigError(filepath) { + throw new _configError.default(`\ +Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured +for various types of caching, using the first param of their handler functions: + +module.exports = function(api) { + // The API exposes the following: + + // Cache the returned value forever and don't call this function again. + api.cache(true); + + // Don't cache at all. Not recommended because it will be very slow. + api.cache(false); + + // Cached based on the value of some function. If this function returns a value different from + // a previously-encountered value, the plugins will re-evaluate. + var env = api.cache(() => process.env.NODE_ENV); + + // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for + // any possible NODE_ENV value that might come up during plugin execution. + var isProd = api.cache(() => process.env.NODE_ENV === "production"); + + // .cache(fn) will perform a linear search though instances to find the matching plugin based + // based on previous instantiated plugins. If you want to recreate the plugin and discard the + // previous instance whenever something changes, you may use: + var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production"); + + // Note, we also expose the following more-verbose versions of the above examples: + api.cache.forever(); // api.cache(true) + api.cache.never(); // api.cache(false) + api.cache.using(fn); // api.cache(fn) + + // Return the value that will be cached. + return { }; +};`, filepath); +} +0 && 0; + +//# sourceMappingURL=configuration.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js.map b/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js.map new file mode 100644 index 0000000000000000000000000000000000000000..07c99ef74203c2857c1b9aeeab02b86c3a8b5691 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/configuration.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_debug","data","require","_fs","_path","_json","_gensync","_caching","_configApi","_utils","_moduleTypes","_patternToRegex","_configError","fs","_rewriteStackTrace","_async","debug","buildDebug","ROOT_CONFIG_FILENAMES","exports","RELATIVE_CONFIG_FILENAMES","BABELIGNORE_FILENAME","runConfig","makeWeakCache","options","cache","endHiddenCallStack","makeConfigAPI","cacheNeedsConfiguration","configured","readConfigCode","filepath","nodeFs","existsSync","loadCodeDefault","isAsync","Array","isArray","ConfigError","then","catch","throwConfigError","buildConfigFileObject","cfboaf","WeakMap","configFilesByFilepath","get","set","Map","configFile","dirname","path","packageToBabelConfig","makeWeakCacheSync","file","babel","undefined","readConfigJSON5","makeStaticFileCache","content","json5","parse","err","message","$schema","readIgnoreConfig","ignoreDir","ignorePatterns","split","map","line","replace","trim","filter","Boolean","pattern","startsWith","ignore","pathPatternToRegex","findConfigUpwards","rootDir","filename","join","nextDir","findRelativeConfig","packageData","envName","caller","config","loc","directories","_packageData$pkg","loadOneConfig","pkg","ignoreLoc","findRootConfig","names","previousConfig","configs","gensync","all","readConfig","reduce","basename","loadConfig","name","v","w","process","versions","node","resolve","r","paths","b","M","f","_findPath","_nodeModulePaths","concat","Error","code","conf","ext","extname","resolveShowConfigPath","targetPath","env","BABEL_SHOW_CONFIG_FOR","absolutePath","stats","stat","isFile"],"sources":["../../../src/config/files/configuration.ts"],"sourcesContent":["import buildDebug from \"debug\";\nimport nodeFs from \"node:fs\";\nimport path from \"node:path\";\nimport json5 from \"json5\";\nimport gensync from \"gensync\";\nimport type { Handler } from \"gensync\";\nimport { makeWeakCache, makeWeakCacheSync } from \"../caching.ts\";\nimport type { CacheConfigurator } from \"../caching.ts\";\nimport { makeConfigAPI } from \"../helpers/config-api.ts\";\nimport type { ConfigAPI } from \"../helpers/config-api.ts\";\nimport { makeStaticFileCache } from \"./utils.ts\";\nimport loadCodeDefault from \"./module-types.ts\";\nimport pathPatternToRegex from \"../pattern-to-regex.ts\";\nimport type { FilePackageData, RelativeConfig, ConfigFile } from \"./types.ts\";\nimport type { CallerMetadata, InputOptions } from \"../validation/options.ts\";\nimport ConfigError from \"../../errors/config-error.ts\";\n\nimport * as fs from \"../../gensync-utils/fs.ts\";\n\nimport { createRequire } from \"node:module\";\nimport { endHiddenCallStack } from \"../../errors/rewrite-stack-trace.ts\";\nimport { isAsync } from \"../../gensync-utils/async.ts\";\nconst require = createRequire(import.meta.url);\n\nconst debug = buildDebug(\"babel:config:loading:files:configuration\");\n\nexport const ROOT_CONFIG_FILENAMES = [\n \"babel.config.js\",\n \"babel.config.cjs\",\n \"babel.config.mjs\",\n \"babel.config.json\",\n \"babel.config.cts\",\n \"babel.config.ts\",\n \"babel.config.mts\",\n];\nconst RELATIVE_CONFIG_FILENAMES = [\n \".babelrc\",\n \".babelrc.js\",\n \".babelrc.cjs\",\n \".babelrc.mjs\",\n \".babelrc.json\",\n \".babelrc.cts\",\n];\n\nconst BABELIGNORE_FILENAME = \".babelignore\";\n\ntype ConfigCacheData = {\n envName: string;\n caller: CallerMetadata | undefined;\n};\n\nconst runConfig = makeWeakCache(function* runConfig(\n options: Function,\n cache: CacheConfigurator,\n): Handler<{\n options: InputOptions | null;\n cacheNeedsConfiguration: boolean;\n}> {\n // if we want to make it possible to use async configs\n yield* [];\n\n return {\n options: endHiddenCallStack(options as any as (api: ConfigAPI) => unknown)(\n makeConfigAPI(cache),\n ),\n cacheNeedsConfiguration: !cache.configured(),\n };\n});\n\nfunction* readConfigCode(\n filepath: string,\n data: ConfigCacheData,\n): Handler {\n if (!nodeFs.existsSync(filepath)) return null;\n\n let options = yield* loadCodeDefault(\n filepath,\n (yield* isAsync()) ? \"auto\" : \"require\",\n \"You appear to be using a native ECMAScript module configuration \" +\n \"file, which is only supported when running Babel asynchronously \" +\n \"or when using the Node.js `--experimental-require-module` flag.\",\n \"You appear to be using a configuration file that contains top-level \" +\n \"await, which is only supported when running Babel asynchronously.\",\n );\n\n let cacheNeedsConfiguration = false;\n if (typeof options === \"function\") {\n ({ options, cacheNeedsConfiguration } = yield* runConfig(options, data));\n }\n\n if (!options || typeof options !== \"object\" || Array.isArray(options)) {\n throw new ConfigError(\n `Configuration should be an exported JavaScript object.`,\n filepath,\n );\n }\n\n // @ts-expect-error todo(flow->ts)\n if (typeof options.then === \"function\") {\n // @ts-expect-error We use ?. in case options is a thenable but not a promise\n options.catch?.(() => {});\n throw new ConfigError(\n `You appear to be using an async configuration, ` +\n `which your current version of Babel does not support. ` +\n `We may add support for this in the future, ` +\n `but if you're on the most recent version of @babel/core and still ` +\n `seeing this error, then you'll need to synchronously return your config.`,\n filepath,\n );\n }\n\n if (cacheNeedsConfiguration) throwConfigError(filepath);\n\n return buildConfigFileObject(options, filepath);\n}\n\n// We cache the generated ConfigFile object rather than creating a new one\n// every time, so that it can be used as a cache key in other functions.\nconst cfboaf /* configFilesByOptionsAndFilepath */ = new WeakMap<\n InputOptions,\n Map\n>();\nfunction buildConfigFileObject(\n options: InputOptions,\n filepath: string,\n): ConfigFile {\n let configFilesByFilepath = cfboaf.get(options);\n if (!configFilesByFilepath) {\n cfboaf.set(options, (configFilesByFilepath = new Map()));\n }\n\n let configFile = configFilesByFilepath.get(filepath);\n if (!configFile) {\n configFile = {\n filepath,\n dirname: path.dirname(filepath),\n options,\n };\n configFilesByFilepath.set(filepath, configFile);\n }\n\n return configFile;\n}\n\nconst packageToBabelConfig = makeWeakCacheSync(\n (file: ConfigFile): ConfigFile | null => {\n const babel: unknown = file.options.babel;\n\n if (babel === undefined) return null;\n\n if (typeof babel !== \"object\" || Array.isArray(babel) || babel === null) {\n throw new ConfigError(`.babel property must be an object`, file.filepath);\n }\n\n return {\n filepath: file.filepath,\n dirname: file.dirname,\n options: babel,\n };\n },\n);\n\nconst readConfigJSON5 = makeStaticFileCache((filepath, content): ConfigFile => {\n let options;\n try {\n options = json5.parse(content);\n } catch (err) {\n throw new ConfigError(\n `Error while parsing config - ${err.message}`,\n filepath,\n );\n }\n\n if (!options) throw new ConfigError(`No config detected`, filepath);\n\n if (typeof options !== \"object\") {\n throw new ConfigError(`Config returned typeof ${typeof options}`, filepath);\n }\n if (Array.isArray(options)) {\n throw new ConfigError(`Expected config object but found array`, filepath);\n }\n\n delete options.$schema;\n\n return {\n filepath,\n dirname: path.dirname(filepath),\n options,\n };\n});\n\nconst readIgnoreConfig = makeStaticFileCache((filepath, content) => {\n const ignoreDir = path.dirname(filepath);\n const ignorePatterns = content\n .split(\"\\n\")\n .map(line =>\n line.replace(process.env.BABEL_8_BREAKING ? /^#.*$/ : /#.*$/, \"\").trim(),\n )\n .filter(Boolean);\n\n for (const pattern of ignorePatterns) {\n if (pattern.startsWith(\"!\")) {\n throw new ConfigError(\n `Negation of file paths is not supported.`,\n filepath,\n );\n }\n }\n\n return {\n filepath,\n dirname: path.dirname(filepath),\n ignore: ignorePatterns.map(pattern =>\n pathPatternToRegex(pattern, ignoreDir),\n ),\n };\n});\n\nexport function findConfigUpwards(rootDir: string): string | null {\n let dirname = rootDir;\n for (;;) {\n for (const filename of ROOT_CONFIG_FILENAMES) {\n if (nodeFs.existsSync(path.join(dirname, filename))) {\n return dirname;\n }\n }\n\n const nextDir = path.dirname(dirname);\n if (dirname === nextDir) break;\n dirname = nextDir;\n }\n\n return null;\n}\n\nexport function* findRelativeConfig(\n packageData: FilePackageData,\n envName: string,\n caller: CallerMetadata | undefined,\n): Handler {\n let config = null;\n let ignore = null;\n\n const dirname = path.dirname(packageData.filepath);\n\n for (const loc of packageData.directories) {\n if (!config) {\n config = yield* loadOneConfig(\n RELATIVE_CONFIG_FILENAMES,\n loc,\n envName,\n caller,\n packageData.pkg?.dirname === loc\n ? packageToBabelConfig(packageData.pkg)\n : null,\n );\n }\n\n if (!ignore) {\n const ignoreLoc = path.join(loc, BABELIGNORE_FILENAME);\n ignore = yield* readIgnoreConfig(ignoreLoc);\n\n if (ignore) {\n debug(\"Found ignore %o from %o.\", ignore.filepath, dirname);\n }\n }\n }\n\n return { config, ignore };\n}\n\nexport function findRootConfig(\n dirname: string,\n envName: string,\n caller: CallerMetadata | undefined,\n): Handler {\n return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);\n}\n\nfunction* loadOneConfig(\n names: string[],\n dirname: string,\n envName: string,\n caller: CallerMetadata | undefined,\n previousConfig: ConfigFile | null = null,\n): Handler {\n const configs = yield* gensync.all(\n names.map(filename =>\n readConfig(path.join(dirname, filename), envName, caller),\n ),\n );\n const config = configs.reduce((previousConfig: ConfigFile | null, config) => {\n if (config && previousConfig) {\n throw new ConfigError(\n `Multiple configuration files found. Please remove one:\\n` +\n ` - ${path.basename(previousConfig.filepath)}\\n` +\n ` - ${config.filepath}\\n` +\n `from ${dirname}`,\n );\n }\n\n return config || previousConfig;\n }, previousConfig);\n\n if (config) {\n debug(\"Found configuration %o from %o.\", config.filepath, dirname);\n }\n return config;\n}\n\nexport function* loadConfig(\n name: string,\n dirname: string,\n envName: string,\n caller: CallerMetadata | undefined,\n): Handler {\n const filepath = require.resolve(name, { paths: [dirname] });\n\n const conf = yield* readConfig(filepath, envName, caller);\n if (!conf) {\n throw new ConfigError(\n `Config file contains no configuration data`,\n filepath,\n );\n }\n\n debug(\"Loaded config %o from %o.\", name, dirname);\n return conf;\n}\n\n/**\n * Read the given config file, returning the result. Returns null if no config was found, but will\n * throw if there are parsing errors while loading a config.\n */\nfunction readConfig(\n filepath: string,\n envName: string,\n caller: CallerMetadata | undefined,\n): Handler {\n const ext = path.extname(filepath);\n switch (ext) {\n case \".js\":\n case \".cjs\":\n case \".mjs\":\n case \".ts\":\n case \".cts\":\n case \".mts\":\n return readConfigCode(filepath, { envName, caller });\n default:\n return readConfigJSON5(filepath);\n }\n}\n\nexport function* resolveShowConfigPath(\n dirname: string,\n): Handler {\n const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;\n if (targetPath != null) {\n const absolutePath = path.resolve(dirname, targetPath);\n const stats = yield* fs.stat(absolutePath);\n if (!stats.isFile()) {\n throw new Error(\n `${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`,\n );\n }\n return absolutePath;\n }\n return null;\n}\n\nfunction throwConfigError(filepath: string): never {\n throw new ConfigError(\n `\\\nCaching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured\nfor various types of caching, using the first param of their handler functions:\n\nmodule.exports = function(api) {\n // The API exposes the following:\n\n // Cache the returned value forever and don't call this function again.\n api.cache(true);\n\n // Don't cache at all. Not recommended because it will be very slow.\n api.cache(false);\n\n // Cached based on the value of some function. If this function returns a value different from\n // a previously-encountered value, the plugins will re-evaluate.\n var env = api.cache(() => process.env.NODE_ENV);\n\n // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for\n // any possible NODE_ENV value that might come up during plugin execution.\n var isProd = api.cache(() => process.env.NODE_ENV === \"production\");\n\n // .cache(fn) will perform a linear search though instances to find the matching plugin based\n // based on previous instantiated plugins. If you want to recreate the plugin and discard the\n // previous instance whenever something changes, you may use:\n var isProd = api.cache.invalidate(() => process.env.NODE_ENV === \"production\");\n\n // Note, we also expose the following more-verbose versions of the above examples:\n api.cache.forever(); // api.cache(true)\n api.cache.never(); // api.cache(false)\n api.cache.using(fn); // api.cache(fn)\n\n // Return the value that will be cached.\n return { };\n};`,\n filepath,\n );\n}\n"],"mappings":";;;;;;;;;;;AAAA,SAAAA,OAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,MAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,IAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,GAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,MAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,KAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,MAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,KAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,SAAA;EAAA,MAAAL,IAAA,GAAAC,OAAA;EAAAI,QAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,IAAAM,QAAA,GAAAL,OAAA;AAEA,IAAAM,UAAA,GAAAN,OAAA;AAEA,IAAAO,MAAA,GAAAP,OAAA;AACA,IAAAQ,YAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AAGA,IAAAU,YAAA,GAAAV,OAAA;AAEA,IAAAW,EAAA,GAAAX,OAAA;AAEAA,OAAA;AACA,IAAAY,kBAAA,GAAAZ,OAAA;AACA,IAAAa,MAAA,GAAAb,OAAA;AAGA,MAAMc,KAAK,GAAGC,OAASA,CAAC,CAAC,0CAA0C,CAAC;AAE7D,MAAMC,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,GAAG,CACnC,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,CACnB;AACD,MAAME,yBAAyB,GAAG,CAChC,UAAU,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,cAAc,CACf;AAED,MAAMC,oBAAoB,GAAG,cAAc;AAO3C,MAAMC,SAAS,GAAG,IAAAC,sBAAa,EAAC,UAAUD,SAASA,CACjDE,OAAiB,EACjBC,KAAyC,EAIxC;EAED,OAAO,EAAE;EAET,OAAO;IACLD,OAAO,EAAE,IAAAE,qCAAkB,EAACF,OAA6C,CAAC,CACxE,IAAAG,wBAAa,EAACF,KAAK,CACrB,CAAC;IACDG,uBAAuB,EAAE,CAACH,KAAK,CAACI,UAAU,CAAC;EAC7C,CAAC;AACH,CAAC,CAAC;AAEF,UAAUC,cAAcA,CACtBC,QAAgB,EAChB9B,IAAqB,EACO;EAC5B,IAAI,CAAC+B,IAAKA,CAAC,CAACC,UAAU,CAACF,QAAQ,CAAC,EAAE,OAAO,IAAI;EAE7C,IAAIP,OAAO,GAAG,OAAO,IAAAU,oBAAe,EAClCH,QAAQ,EACR,CAAC,OAAO,IAAAI,cAAO,EAAC,CAAC,IAAI,MAAM,GAAG,SAAS,EACvC,kEAAkE,GAChE,kEAAkE,GAClE,iEAAiE,EACnE,sEAAsE,GACpE,mEACJ,CAAC;EAED,IAAIP,uBAAuB,GAAG,KAAK;EACnC,IAAI,OAAOJ,OAAO,KAAK,UAAU,EAAE;IACjC,CAAC;MAAEA,OAAO;MAAEI;IAAwB,CAAC,GAAG,OAAON,SAAS,CAACE,OAAO,EAAEvB,IAAI,CAAC;EACzE;EAEA,IAAI,CAACuB,OAAO,IAAI,OAAOA,OAAO,KAAK,QAAQ,IAAIY,KAAK,CAACC,OAAO,CAACb,OAAO,CAAC,EAAE;IACrE,MAAM,IAAIc,oBAAW,CACnB,wDAAwD,EACxDP,QACF,CAAC;EACH;EAGA,IAAI,OAAOP,OAAO,CAACe,IAAI,KAAK,UAAU,EAAE;IAEtCf,OAAO,CAACgB,KAAK,YAAbhB,OAAO,CAACgB,KAAK,CAAG,MAAM,CAAC,CAAC,CAAC;IACzB,MAAM,IAAIF,oBAAW,CACnB,iDAAiD,GAC/C,wDAAwD,GACxD,6CAA6C,GAC7C,oEAAoE,GACpE,0EAA0E,EAC5EP,QACF,CAAC;EACH;EAEA,IAAIH,uBAAuB,EAAEa,gBAAgB,CAACV,QAAQ,CAAC;EAEvD,OAAOW,qBAAqB,CAAClB,OAAO,EAAEO,QAAQ,CAAC;AACjD;AAIA,MAAMY,MAAM,GAAyC,IAAIC,OAAO,CAG9D,CAAC;AACH,SAASF,qBAAqBA,CAC5BlB,OAAqB,EACrBO,QAAgB,EACJ;EACZ,IAAIc,qBAAqB,GAAGF,MAAM,CAACG,GAAG,CAACtB,OAAO,CAAC;EAC/C,IAAI,CAACqB,qBAAqB,EAAE;IAC1BF,MAAM,CAACI,GAAG,CAACvB,OAAO,EAAGqB,qBAAqB,GAAG,IAAIG,GAAG,CAAC,CAAE,CAAC;EAC1D;EAEA,IAAIC,UAAU,GAAGJ,qBAAqB,CAACC,GAAG,CAACf,QAAQ,CAAC;EACpD,IAAI,CAACkB,UAAU,EAAE;IACfA,UAAU,GAAG;MACXlB,QAAQ;MACRmB,OAAO,EAAEC,MAAGA,CAAC,CAACD,OAAO,CAACnB,QAAQ,CAAC;MAC/BP;IACF,CAAC;IACDqB,qBAAqB,CAACE,GAAG,CAAChB,QAAQ,EAAEkB,UAAU,CAAC;EACjD;EAEA,OAAOA,UAAU;AACnB;AAEA,MAAMG,oBAAoB,GAAG,IAAAC,0BAAiB,EAC3CC,IAAgB,IAAwB;EACvC,MAAMC,KAAc,GAAGD,IAAI,CAAC9B,OAAO,CAAC+B,KAAK;EAEzC,IAAIA,KAAK,KAAKC,SAAS,EAAE,OAAO,IAAI;EAEpC,IAAI,OAAOD,KAAK,KAAK,QAAQ,IAAInB,KAAK,CAACC,OAAO,CAACkB,KAAK,CAAC,IAAIA,KAAK,KAAK,IAAI,EAAE;IACvE,MAAM,IAAIjB,oBAAW,CAAC,mCAAmC,EAAEgB,IAAI,CAACvB,QAAQ,CAAC;EAC3E;EAEA,OAAO;IACLA,QAAQ,EAAEuB,IAAI,CAACvB,QAAQ;IACvBmB,OAAO,EAAEI,IAAI,CAACJ,OAAO;IACrB1B,OAAO,EAAE+B;EACX,CAAC;AACH,CACF,CAAC;AAED,MAAME,eAAe,GAAG,IAAAC,0BAAmB,EAAC,CAAC3B,QAAQ,EAAE4B,OAAO,KAAiB;EAC7E,IAAInC,OAAO;EACX,IAAI;IACFA,OAAO,GAAGoC,MAAIA,CAAC,CAACC,KAAK,CAACF,OAAO,CAAC;EAChC,CAAC,CAAC,OAAOG,GAAG,EAAE;IACZ,MAAM,IAAIxB,oBAAW,CACnB,gCAAgCwB,GAAG,CAACC,OAAO,EAAE,EAC7ChC,QACF,CAAC;EACH;EAEA,IAAI,CAACP,OAAO,EAAE,MAAM,IAAIc,oBAAW,CAAC,oBAAoB,EAAEP,QAAQ,CAAC;EAEnE,IAAI,OAAOP,OAAO,KAAK,QAAQ,EAAE;IAC/B,MAAM,IAAIc,oBAAW,CAAC,0BAA0B,OAAOd,OAAO,EAAE,EAAEO,QAAQ,CAAC;EAC7E;EACA,IAAIK,KAAK,CAACC,OAAO,CAACb,OAAO,CAAC,EAAE;IAC1B,MAAM,IAAIc,oBAAW,CAAC,wCAAwC,EAAEP,QAAQ,CAAC;EAC3E;EAEA,OAAOP,OAAO,CAACwC,OAAO;EAEtB,OAAO;IACLjC,QAAQ;IACRmB,OAAO,EAAEC,MAAGA,CAAC,CAACD,OAAO,CAACnB,QAAQ,CAAC;IAC/BP;EACF,CAAC;AACH,CAAC,CAAC;AAEF,MAAMyC,gBAAgB,GAAG,IAAAP,0BAAmB,EAAC,CAAC3B,QAAQ,EAAE4B,OAAO,KAAK;EAClE,MAAMO,SAAS,GAAGf,MAAGA,CAAC,CAACD,OAAO,CAACnB,QAAQ,CAAC;EACxC,MAAMoC,cAAc,GAAGR,OAAO,CAC3BS,KAAK,CAAC,IAAI,CAAC,CACXC,GAAG,CAACC,IAAI,IACPA,IAAI,CAACC,OAAO,CAA0C,MAAM,EAAE,EAAE,CAAC,CAACC,IAAI,CAAC,CACzE,CAAC,CACAC,MAAM,CAACC,OAAO,CAAC;EAElB,KAAK,MAAMC,OAAO,IAAIR,cAAc,EAAE;IACpC,IAAIQ,OAAO,CAACC,UAAU,CAAC,GAAG,CAAC,EAAE;MAC3B,MAAM,IAAItC,oBAAW,CACnB,0CAA0C,EAC1CP,QACF,CAAC;IACH;EACF;EAEA,OAAO;IACLA,QAAQ;IACRmB,OAAO,EAAEC,MAAGA,CAAC,CAACD,OAAO,CAACnB,QAAQ,CAAC;IAC/B8C,MAAM,EAAEV,cAAc,CAACE,GAAG,CAACM,OAAO,IAChC,IAAAG,uBAAkB,EAACH,OAAO,EAAET,SAAS,CACvC;EACF,CAAC;AACH,CAAC,CAAC;AAEK,SAASa,iBAAiBA,CAACC,OAAe,EAAiB;EAChE,IAAI9B,OAAO,GAAG8B,OAAO;EACrB,SAAS;IACP,KAAK,MAAMC,QAAQ,IAAI/D,qBAAqB,EAAE;MAC5C,IAAIc,IAAKA,CAAC,CAACC,UAAU,CAACkB,MAAGA,CAAC,CAAC+B,IAAI,CAAChC,OAAO,EAAE+B,QAAQ,CAAC,CAAC,EAAE;QACnD,OAAO/B,OAAO;MAChB;IACF;IAEA,MAAMiC,OAAO,GAAGhC,MAAGA,CAAC,CAACD,OAAO,CAACA,OAAO,CAAC;IACrC,IAAIA,OAAO,KAAKiC,OAAO,EAAE;IACzBjC,OAAO,GAAGiC,OAAO;EACnB;EAEA,OAAO,IAAI;AACb;AAEO,UAAUC,kBAAkBA,CACjCC,WAA4B,EAC5BC,OAAe,EACfC,MAAkC,EACT;EACzB,IAAIC,MAAM,GAAG,IAAI;EACjB,IAAIX,MAAM,GAAG,IAAI;EAEjB,MAAM3B,OAAO,GAAGC,MAAGA,CAAC,CAACD,OAAO,CAACmC,WAAW,CAACtD,QAAQ,CAAC;EAElD,KAAK,MAAM0D,GAAG,IAAIJ,WAAW,CAACK,WAAW,EAAE;IACzC,IAAI,CAACF,MAAM,EAAE;MAAA,IAAAG,gBAAA;MACXH,MAAM,GAAG,OAAOI,aAAa,CAC3BxE,yBAAyB,EACzBqE,GAAG,EACHH,OAAO,EACPC,MAAM,EACN,EAAAI,gBAAA,GAAAN,WAAW,CAACQ,GAAG,qBAAfF,gBAAA,CAAiBzC,OAAO,MAAKuC,GAAG,GAC5BrC,oBAAoB,CAACiC,WAAW,CAACQ,GAAG,CAAC,GACrC,IACN,CAAC;IACH;IAEA,IAAI,CAAChB,MAAM,EAAE;MACX,MAAMiB,SAAS,GAAG3C,MAAGA,CAAC,CAAC+B,IAAI,CAACO,GAAG,EAAEpE,oBAAoB,CAAC;MACtDwD,MAAM,GAAG,OAAOZ,gBAAgB,CAAC6B,SAAS,CAAC;MAE3C,IAAIjB,MAAM,EAAE;QACV7D,KAAK,CAAC,0BAA0B,EAAE6D,MAAM,CAAC9C,QAAQ,EAAEmB,OAAO,CAAC;MAC7D;IACF;EACF;EAEA,OAAO;IAAEsC,MAAM;IAAEX;EAAO,CAAC;AAC3B;AAEO,SAASkB,cAAcA,CAC5B7C,OAAe,EACfoC,OAAe,EACfC,MAAkC,EACN;EAC5B,OAAOK,aAAa,CAAC1E,qBAAqB,EAAEgC,OAAO,EAAEoC,OAAO,EAAEC,MAAM,CAAC;AACvE;AAEA,UAAUK,aAAaA,CACrBI,KAAe,EACf9C,OAAe,EACfoC,OAAe,EACfC,MAAkC,EAClCU,cAAiC,GAAG,IAAI,EACZ;EAC5B,MAAMC,OAAO,GAAG,OAAOC,SAAMA,CAAC,CAACC,GAAG,CAChCJ,KAAK,CAAC3B,GAAG,CAACY,QAAQ,IAChBoB,UAAU,CAAClD,MAAGA,CAAC,CAAC+B,IAAI,CAAChC,OAAO,EAAE+B,QAAQ,CAAC,EAAEK,OAAO,EAAEC,MAAM,CAC1D,CACF,CAAC;EACD,MAAMC,MAAM,GAAGU,OAAO,CAACI,MAAM,CAAC,CAACL,cAAiC,EAAET,MAAM,KAAK;IAC3E,IAAIA,MAAM,IAAIS,cAAc,EAAE;MAC5B,MAAM,IAAI3D,oBAAW,CACnB,0DAA0D,GACxD,MAAMa,MAAGA,CAAC,CAACoD,QAAQ,CAACN,cAAc,CAAClE,QAAQ,CAAC,IAAI,GAChD,MAAMyD,MAAM,CAACzD,QAAQ,IAAI,GACzB,QAAQmB,OAAO,EACnB,CAAC;IACH;IAEA,OAAOsC,MAAM,IAAIS,cAAc;EACjC,CAAC,EAAEA,cAAc,CAAC;EAElB,IAAIT,MAAM,EAAE;IACVxE,KAAK,CAAC,iCAAiC,EAAEwE,MAAM,CAACzD,QAAQ,EAAEmB,OAAO,CAAC;EACpE;EACA,OAAOsC,MAAM;AACf;AAEO,UAAUgB,UAAUA,CACzBC,IAAY,EACZvD,OAAe,EACfoC,OAAe,EACfC,MAAkC,EACb;EACrB,MAAMxD,QAAQ,GAAG,GAAA2E,CAAA,EAAAC,CAAA,MAAAD,CAAA,GAAAA,CAAA,CAAAtC,KAAA,OAAAuC,CAAA,GAAAA,CAAA,CAAAvC,KAAA,QAAAsC,CAAA,OAAAC,CAAA,OAAAD,CAAA,OAAAC,CAAA,QAAAD,CAAA,QAAAC,CAAA,MAAAC,OAAA,CAAAC,QAAA,CAAAC,IAAA,WAAA5G,OAAA,CAAA6G,OAAA,IAAAC,CAAA;IAAAC,KAAA,GAAAC,CAAA;EAAA,GAAAC,CAAA,GAAAjH,OAAA;IAAA,IAAAkH,CAAA,GAAAD,CAAA,CAAAE,SAAA,CAAAL,CAAA,EAAAG,CAAA,CAAAG,gBAAA,CAAAJ,CAAA,EAAAK,MAAA,CAAAL,CAAA;IAAA,IAAAE,CAAA,SAAAA,CAAA;IAAAA,CAAA,OAAAI,KAAA,2BAAAR,CAAA;IAAAI,CAAA,CAAAK,IAAA;IAAA,MAAAL,CAAA;EAAA,GAAgBX,IAAI,EAAE;IAAEQ,KAAK,EAAE,CAAC/D,OAAO;EAAE,CAAC,CAAC;EAE5D,MAAMwE,IAAI,GAAG,OAAOrB,UAAU,CAACtE,QAAQ,EAAEuD,OAAO,EAAEC,MAAM,CAAC;EACzD,IAAI,CAACmC,IAAI,EAAE;IACT,MAAM,IAAIpF,oBAAW,CACnB,4CAA4C,EAC5CP,QACF,CAAC;EACH;EAEAf,KAAK,CAAC,2BAA2B,EAAEyF,IAAI,EAAEvD,OAAO,CAAC;EACjD,OAAOwE,IAAI;AACb;AAMA,SAASrB,UAAUA,CACjBtE,QAAgB,EAChBuD,OAAe,EACfC,MAAkC,EACN;EAC5B,MAAMoC,GAAG,GAAGxE,MAAGA,CAAC,CAACyE,OAAO,CAAC7F,QAAQ,CAAC;EAClC,QAAQ4F,GAAG;IACT,KAAK,KAAK;IACV,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,KAAK;IACV,KAAK,MAAM;IACX,KAAK,MAAM;MACT,OAAO7F,cAAc,CAACC,QAAQ,EAAE;QAAEuD,OAAO;QAAEC;MAAO,CAAC,CAAC;IACtD;MACE,OAAO9B,eAAe,CAAC1B,QAAQ,CAAC;EACpC;AACF;AAEO,UAAU8F,qBAAqBA,CACpC3E,OAAe,EACS;EACxB,MAAM4E,UAAU,GAAGlB,OAAO,CAACmB,GAAG,CAACC,qBAAqB;EACpD,IAAIF,UAAU,IAAI,IAAI,EAAE;IACtB,MAAMG,YAAY,GAAG9E,MAAGA,CAAC,CAAC4D,OAAO,CAAC7D,OAAO,EAAE4E,UAAU,CAAC;IACtD,MAAMI,KAAK,GAAG,OAAOrH,EAAE,CAACsH,IAAI,CAACF,YAAY,CAAC;IAC1C,IAAI,CAACC,KAAK,CAACE,MAAM,CAAC,CAAC,EAAE;MACnB,MAAM,IAAIZ,KAAK,CACb,GAAGS,YAAY,sFACjB,CAAC;IACH;IACA,OAAOA,YAAY;EACrB;EACA,OAAO,IAAI;AACb;AAEA,SAASxF,gBAAgBA,CAACV,QAAgB,EAAS;EACjD,MAAM,IAAIO,oBAAW,CACnB;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,EACCP,QACF,CAAC;AACH;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs b/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs new file mode 100644 index 0000000000000000000000000000000000000000..46fa5d5cfc41c42efc8b8be53aa993e8a9e3c651 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs @@ -0,0 +1,6 @@ +module.exports = function import_(filepath) { + return import(filepath); +}; +0 && 0; + +//# sourceMappingURL=import.cjs.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs.map b/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs.map new file mode 100644 index 0000000000000000000000000000000000000000..2200da80f43f57e23145c3ce719b16743188fd66 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/import.cjs.map @@ -0,0 +1 @@ +{"version":3,"names":["module","exports","import_","filepath"],"sources":["../../../src/config/files/import.cjs"],"sourcesContent":["// We keep this in a separate file so that in older node versions, where\n// import() isn't supported, we can try/catch around the require() call\n// when loading this file.\n\nmodule.exports = function import_(filepath) {\n return import(filepath);\n};\n"],"mappings":"AAIAA,MAAM,CAACC,OAAO,GAAG,SAASC,OAAOA,CAACC,QAAQ,EAAE;EAC1C,OAAO,OAAOA,QAAQ,CAAC;AACzB,CAAC;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js b/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js new file mode 100644 index 0000000000000000000000000000000000000000..d8ba7dbc8d7e96837481886ae35931428acca238 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js @@ -0,0 +1,58 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ROOT_CONFIG_FILENAMES = void 0; +exports.findConfigUpwards = findConfigUpwards; +exports.findPackageData = findPackageData; +exports.findRelativeConfig = findRelativeConfig; +exports.findRootConfig = findRootConfig; +exports.loadConfig = loadConfig; +exports.loadPlugin = loadPlugin; +exports.loadPreset = loadPreset; +exports.resolvePlugin = resolvePlugin; +exports.resolvePreset = resolvePreset; +exports.resolveShowConfigPath = resolveShowConfigPath; +function findConfigUpwards(rootDir) { + return null; +} +function* findPackageData(filepath) { + return { + filepath, + directories: [], + pkg: null, + isPackage: false + }; +} +function* findRelativeConfig(pkgData, envName, caller) { + return { + config: null, + ignore: null + }; +} +function* findRootConfig(dirname, envName, caller) { + return null; +} +function* loadConfig(name, dirname, envName, caller) { + throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`); +} +function* resolveShowConfigPath(dirname) { + return null; +} +const ROOT_CONFIG_FILENAMES = exports.ROOT_CONFIG_FILENAMES = []; +function resolvePlugin(name, dirname) { + return null; +} +function resolvePreset(name, dirname) { + return null; +} +function loadPlugin(name, dirname) { + throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`); +} +function loadPreset(name, dirname) { + throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`); +} +0 && 0; + +//# sourceMappingURL=index-browser.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js.map b/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e10ddeeef8bece1675f04692609e1f8fcb4aadb1 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/index-browser.js.map @@ -0,0 +1 @@ +{"version":3,"names":["findConfigUpwards","rootDir","findPackageData","filepath","directories","pkg","isPackage","findRelativeConfig","pkgData","envName","caller","config","ignore","findRootConfig","dirname","loadConfig","name","Error","resolveShowConfigPath","ROOT_CONFIG_FILENAMES","exports","resolvePlugin","resolvePreset","loadPlugin","loadPreset"],"sources":["../../../src/config/files/index-browser.ts"],"sourcesContent":["/* c8 ignore start */\n\nimport type { Handler } from \"gensync\";\n\nimport type {\n ConfigFile,\n IgnoreFile,\n RelativeConfig,\n FilePackageData,\n} from \"./types.ts\";\n\nimport type { CallerMetadata } from \"../validation/options.ts\";\n\nexport type { ConfigFile, IgnoreFile, RelativeConfig, FilePackageData };\n\nexport function findConfigUpwards(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n rootDir: string,\n): string | null {\n return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* findPackageData(filepath: string): Handler {\n return {\n filepath,\n directories: [],\n pkg: null,\n isPackage: false,\n };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRelativeConfig(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n pkgData: FilePackageData,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata | undefined,\n): Handler {\n return { config: null, ignore: null };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRootConfig(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n dirname: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata | undefined,\n): Handler {\n return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* loadConfig(\n name: string,\n dirname: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata | undefined,\n): Handler {\n throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);\n}\n\n// eslint-disable-next-line require-yield\nexport function* resolveShowConfigPath(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n dirname: string,\n): Handler {\n return null;\n}\n\nexport const ROOT_CONFIG_FILENAMES: string[] = [];\n\ntype Resolved =\n | { loader: \"require\"; filepath: string }\n | { loader: \"import\"; filepath: string };\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePlugin(name: string, dirname: string): Resolved | null {\n return null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePreset(name: string, dirname: string): Resolved | null {\n return null;\n}\n\nexport function loadPlugin(\n name: string,\n dirname: string,\n): Handler<{\n filepath: string;\n value: unknown;\n}> {\n throw new Error(\n `Cannot load plugin ${name} relative to ${dirname} in a browser`,\n );\n}\n\nexport function loadPreset(\n name: string,\n dirname: string,\n): Handler<{\n filepath: string;\n value: unknown;\n}> {\n throw new Error(\n `Cannot load preset ${name} relative to ${dirname} in a browser`,\n );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeO,SAASA,iBAAiBA,CAE/BC,OAAe,EACA;EACf,OAAO,IAAI;AACb;AAGO,UAAUC,eAAeA,CAACC,QAAgB,EAA4B;EAC3E,OAAO;IACLA,QAAQ;IACRC,WAAW,EAAE,EAAE;IACfC,GAAG,EAAE,IAAI;IACTC,SAAS,EAAE;EACb,CAAC;AACH;AAGO,UAAUC,kBAAkBA,CAEjCC,OAAwB,EAExBC,OAAe,EAEfC,MAAkC,EACT;EACzB,OAAO;IAAEC,MAAM,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAK,CAAC;AACvC;AAGO,UAAUC,cAAcA,CAE7BC,OAAe,EAEfL,OAAe,EAEfC,MAAkC,EACN;EAC5B,OAAO,IAAI;AACb;AAGO,UAAUK,UAAUA,CACzBC,IAAY,EACZF,OAAe,EAEfL,OAAe,EAEfC,MAAkC,EACb;EACrB,MAAM,IAAIO,KAAK,CAAC,eAAeD,IAAI,gBAAgBF,OAAO,eAAe,CAAC;AAC5E;AAGO,UAAUI,qBAAqBA,CAEpCJ,OAAe,EACS;EACxB,OAAO,IAAI;AACb;AAEO,MAAMK,qBAA+B,GAAAC,OAAA,CAAAD,qBAAA,GAAG,EAAE;AAO1C,SAASE,aAAaA,CAACL,IAAY,EAAEF,OAAe,EAAmB;EAC5E,OAAO,IAAI;AACb;AAGO,SAASQ,aAAaA,CAACN,IAAY,EAAEF,OAAe,EAAmB;EAC5E,OAAO,IAAI;AACb;AAEO,SAASS,UAAUA,CACxBP,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACb,sBAAsBD,IAAI,gBAAgBF,OAAO,eACnD,CAAC;AACH;AAEO,SAASU,UAAUA,CACxBR,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACb,sBAAsBD,IAAI,gBAAgBF,OAAO,eACnD,CAAC;AACH;AAAC","ignoreList":[]} \ No newline at end of file diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/index.js b/tools/ui/node_modules/@babel/core/lib/config/files/index.js new file mode 100644 index 0000000000000000000000000000000000000000..8750f40a9c80b2ef6cb5d980f4125092b9b2c031 --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/index.js @@ -0,0 +1,78 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", { + enumerable: true, + get: function () { + return _configuration.ROOT_CONFIG_FILENAMES; + } +}); +Object.defineProperty(exports, "findConfigUpwards", { + enumerable: true, + get: function () { + return _configuration.findConfigUpwards; + } +}); +Object.defineProperty(exports, "findPackageData", { + enumerable: true, + get: function () { + return _package.findPackageData; + } +}); +Object.defineProperty(exports, "findRelativeConfig", { + enumerable: true, + get: function () { + return _configuration.findRelativeConfig; + } +}); +Object.defineProperty(exports, "findRootConfig", { + enumerable: true, + get: function () { + return _configuration.findRootConfig; + } +}); +Object.defineProperty(exports, "loadConfig", { + enumerable: true, + get: function () { + return _configuration.loadConfig; + } +}); +Object.defineProperty(exports, "loadPlugin", { + enumerable: true, + get: function () { + return _plugins.loadPlugin; + } +}); +Object.defineProperty(exports, "loadPreset", { + enumerable: true, + get: function () { + return _plugins.loadPreset; + } +}); +Object.defineProperty(exports, "resolvePlugin", { + enumerable: true, + get: function () { + return _plugins.resolvePlugin; + } +}); +Object.defineProperty(exports, "resolvePreset", { + enumerable: true, + get: function () { + return _plugins.resolvePreset; + } +}); +Object.defineProperty(exports, "resolveShowConfigPath", { + enumerable: true, + get: function () { + return _configuration.resolveShowConfigPath; + } +}); +var _package = require("./package.js"); +var _configuration = require("./configuration.js"); +var _plugins = require("./plugins.js"); +({}); +0 && 0; + +//# sourceMappingURL=index.js.map diff --git a/tools/ui/node_modules/@babel/core/lib/config/files/index.js.map b/tools/ui/node_modules/@babel/core/lib/config/files/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..832135f91841883254526ca15906ca14b7a8c62d --- /dev/null +++ b/tools/ui/node_modules/@babel/core/lib/config/files/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_package","require","_configuration","_plugins"],"sources":["../../../src/config/files/index.ts"],"sourcesContent":["type indexBrowserType = typeof import(\"./index-browser\");\ntype indexType = typeof import(\"./index\");\n\n// Kind of gross, but essentially asserting that the exports of this module are the same as the\n// exports of index-browser, since this file may be replaced at bundle time with index-browser.\n// eslint-disable-next-line @typescript-eslint/no-unused-expressions\n({}) as any as indexBrowserType as indexType;\n\nexport { findPackageData } from \"./package.ts\";\n\nexport {\n findConfigUpwards,\n findRelativeConfig,\n findRootConfig,\n loadConfig,\n resolveShowConfigPath,\n ROOT_CONFIG_FILENAMES,\n} from \"./configuration.ts\";\nexport type {\n ConfigFile,\n IgnoreFile,\n RelativeConfig,\n FilePackageData,\n} from \"./types.ts\";\nexport {\n loadPlugin,\n loadPreset,\n resolvePlugin,\n resolvePreset,\n} from \"./plugins.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,IAAAA,QAAA,GAAAC,OAAA;AAEA,IAAAC,cAAA,GAAAD,OAAA;AAcA,IAAAE,QAAA,GAAAF,OAAA;AAlBA,CAAC,CAAC,CAAC;AAA0C","ignoreList":[]} \ No newline at end of file