diff --git a/docs/api.md b/docs/api.md index d4216b7..e6be3e4 100644 --- a/docs/api.md +++ b/docs/api.md @@ -279,6 +279,8 @@ | `limit` | `50` | Page size | | `offset` | `0` | Items to skip | | `profile_id` | — | Filter by profile | +| `search` | — | Full-text search over names/previews | +| `special` | — | Session type filter. Omitted — no filtering (all sessions). `false` — service (`special=True`) sessions excluded, **the webclient default**. `true` — service sessions only | **Response `200`** (when pagination params provided) ```json @@ -531,6 +533,37 @@ --- +#### `GET /sessions/{session_id}/tasks` + +List the session's background tasks (TaskManager jobs). `task_update` WS +events are not replayed on reconnect, so clients fetch this snapshot to +rebuild their backgrounds view after a reload. + +**Response `200`** +```json +{ + "session_id": "...", + "tasks": [ + { + "task_id": "bt-ab12cd34", + "tool": "terminal", + "status": "running", + "args_summary": "sleep 60", + "parent_tool_call_id": "tc-1", + "started_at": "2026-04-10T18:00:00+00:00", + "finished_at": null, + "subagent_tokens": null, + "result_preview": "" + } + ] +} +``` + +**Errors** +- `404` — session not found + +--- + #### `GET /sessions/{session_id}/content` List published session content (artifacts registered via `content_publish` tool). @@ -1471,6 +1504,91 @@ - `400` — invalid payload - `503` — OAuth not configured +#### `POST /webhooks/synapse` (also `/webhooks/synapse/`) + +Receive one GNEXUS Synapse s2s delivery (see [`synapse.md`](synapse.md)). +Signature verified against every active per-user target secret; replays are +re-acked but never acted on twice. A non-duplicate delivery schedules a +fire-and-forget agent reaction (per-user `reactions_enabled` gate). + +**Response `200`** +```json +{ "received": true, "event_id": "evt-..." } +``` + +**Errors** +- `401` — invalid webhook signature (or unparseable body) +- `503` — no navi-side Synapse targets configured + +--- + +### Synapse + +Per-user reaction settings (auth required). See details in +[`synapse.md`](synapse.md). + +#### `GET /synapse-settings` + +Returns the caller's settings plus `source_ready` (not persisted): +`reactions_enabled`, `push_target` (`app` | `app_synapse` | `synapse`), +`completion_notify` (`always` | `important` | `never`), `instructions`, +`source_ready`. + +#### `PUT /synapse-settings` + +Full save (`reactions_enabled`, `push_target`, `completion_notify`, +`instructions`). When `instructions` change, records an edit version +(`edited_by="user"`). Returns the saved settings + `source_ready`. + +#### `GET /synapse-settings/versions?limit=20` + +Instruction edit history, newest first: `content`, `edited_by` +(`user` | `navi`), `reason`, `created_at`. `limit` 1..100. + +#### `POST /synapse-targets` · `GET /synapse-targets` · `DELETE /synapse-targets/{id}` + +Per-user Synapse s2s target secrets: create (`token_ref` + `secret`, +secret is write-only), list (`id`, `token_ref`, `created_at`), revoke. + +--- + +### MCP user keys (BYOK) + +Per-user credentials for MCP servers whose config declares a `user_key` slot +(see [`mcp.md`](mcp.md)). Auth required. Keys are never returned in any +response — only presence and update time. + +#### `GET /mcp-keys` + +Servers that accept a user key **and** are referenced by at least one +profile. Response `200`: + +```json +{"items": [ + { + "server_name": "gnexus-creds", + "transport": "streamable_http", + "key_type": "header", + "key_location": "Authorization", + "prefix": "Bearer ", + "instructions": "...", + "has_key": false, + "updated_at": null + } +]} +``` + +#### `PUT /mcp-keys/{server_name}` + +Body `{"key": "..."}` (1..4096 chars, trimmed). Saves the caller's key +(Fernet-encrypted at rest) and invalidates the cached resolution. `404` for +an unknown or key-less server, `422` for an empty/oversized key. + +#### `DELETE /mcp-keys/{server_name}` + +Drops the caller's key (falls back to the config default). `204` always when +the server exists (even if no key was stored), `404` for unknown/key-less. + --- ## Files diff --git a/docs/config.md b/docs/config.md index 1a12006..2b1119c 100644 --- a/docs/config.md +++ b/docs/config.md @@ -137,6 +137,25 @@ | `TOOLS_DIR` | str | `tools` | Directory for user-defined tools (auto-discovered at startup) | | `CONTEXT_PROVIDERS_DIR` | str | `context_providers` | Directory for user-defined context providers (auto-discovered at startup) | +### MCP `user_key` (BYOK) + +Per-server JSON config (`mcp_servers.d/.json`) — where a user's personal +credential is injected. Details in [`mcp.md`](mcp.md). + +```json +// HTTP server: key goes into an Authorization-style header +{ "transport": "streamable_http", "url": "https://…", + "user_key": { "header": "Authorization", "prefix": "Bearer " } } + +// stdio server: key goes into an env var +{ "transport": "stdio", "command": "uvx", "env": { "API_KEY": "default" }, + "user_key": { "env": "API_KEY" } } +``` + +Keys are stored Fernet-encrypted (`NAVI_AUTH_ENCRYPTION_KEY`, see +Authentication above). Users without a saved key fall back to the default +credential from the config file. + ## Session files | Variable | Type | Default | Description | @@ -196,14 +215,26 @@ | Variable | Type | Default | Description | |---|---|---|---| -| `NAVI_VAPID_PUBLIC_KEY` | str | `""` | VAPID public key for web push. Empty = push fully disabled (endpoints 503, no notifications sent). | -| `NAVI_VAPID_PRIVATE_KEY` | str | `""` | VAPID private key. Generate the pair once: `pip install py_vapid && python -m py_vapid gen`. | -| `NAVI_VAPID_SUBJECT` | str | `mailto:admin@navi.local` | Contact for the push service (a `mailto:` or `https:` URL). | +| `NAVI_PUSH_VAPID_PUBLIC_KEY` | str | `""` | VAPID public key for web push. Empty = push fully disabled (endpoints 503, no notifications sent). | +| `NAVI_PUSH_VAPID_PRIVATE_KEY` | str | `""` | VAPID private key. Generate the pair once: `pip install py_vapid && python -m py_vapid gen`. | +| `NAVI_PUSH_VAPID_SUBJECT` | str | `mailto:admin@navi.local` | Contact for the push service (a `mailto:` or `https:` URL). | | `NAVI_PUSH_COOLDOWN_SEC` | int | `30` | Minimum seconds between two pushes for the same session. | Push notifications fire when an agent turn (or a scheduled recall) completes and no browser tab is watching that session. See [`docs/push.md`](push.md). +## Synapse source + +| Variable | Type | Default | Description | +|---|---|---|---| +| `SYNAPSE_SOURCE_URL` | str | `""` | GNEXUS Synapse base URL for the outgoing source API. Empty = nothing is ever emitted. | +| `SYNAPSE_SOURCE_API_KEY` | str | `""` | `syn_*` source key registered in the Synapse admin panel (write it into `.env` yourself). | +| `SYNAPSE_SOURCE_NAME` | str | `navi` | Source name on Synapse's side. | + +Without both URL and key, Synapse-linked outgoing events are silently skipped and +the UI disables Synapse-linked options (`source_ready: false`). +See [`docs/synapse.md`](synapse.md). + ## Persona | Variable | Type | Default | Description | diff --git a/docs/index.md b/docs/index.md index cfb8ed0..00c1787 100644 --- a/docs/index.md +++ b/docs/index.md @@ -29,12 +29,14 @@ | [`architecture.md`](architecture.md) | Component diagram, data flow, dependency graph | | [`agent.md`](agent.md) | Agent loop, planning phase, tool execution, subagents, workers | | [`tools.md`](tools.md) | Built-in tools, user tool format, hot-reload | +| [`mcp.md`](mcp.md) | MCP servers — configs, tool exposure, per-user keys (BYOK) | | [`sessions.md`](sessions.md) | Session model, dual-buffer design, context compression | | [`store.md`](store.md) | KV store — per-session/per-user key-value persistence | | [`recall.md`](recall.md) | Scheduled callbacks — headless recall system | | [`tasks.md`](tasks.md) | Background tasks — detach tool calls, TaskManager, completion notes, message queue | | [`websocket.md`](websocket.md) | WebSocket protocol — all events, stop mechanism | | [`push.md`](push.md) | PWA — install, offline shell, web push (VAPID, trigger rule) | +| [`synapse.md`](synapse.md) | GNEXUS Synapse integration — inbound gateway, agent reactions, notify tool, outbound events | | [`profiles.md`](profiles.md) | Profiles, system prompts, persona, profile switching | | [`context_providers.md`](context_providers.md) | Context providers — inject dynamic system context per turn | | [`memory.md`](memory.md) | Long-term memory — facts, extraction, search | diff --git a/docs/mcp.md b/docs/mcp.md new file mode 100644 index 0000000..468a222 --- /dev/null +++ b/docs/mcp.md @@ -0,0 +1,108 @@ +# MCP (Model Context Protocol) + +How Navi connects to external MCP servers, how their tools are exposed, and +how per-user credentials (BYOK) work. + +## Configs + +Each server lives in its own file `mcp_servers.d/.json`: + +```json +{ + "transport": "streamable_http", + "url": "https://creds.example.com/mcp", + "headers": { "Authorization": "Bearer gcr_system_default" }, + "groups": { + "creds": ["search_secrets", "get_secret", "reveal_secret"] + }, + "instructions": "MANDATORY: ...", + "user_key": { "header": "Authorization", "prefix": "Bearer " } +} +``` + +| Field | Applies to | Meaning | +|---|---|---| +| `transport` | all | `stdio` \| `sse` \| `streamable_http` | +| `command`, `args`, `env`, `cwd` | `stdio` | Subprocess launch | +| `url`, `headers` | `sse`, `streamable_http` | Endpoint and HTTP headers | +| `groups` | all | Named tool groups profiles reference instead of listing tools | +| `instructions` | all | Overlay injected next to the server's own initialize instructions | +| `user_key` | all | Declares the per-user credential slot (BYOK); omit for key-less servers | + +The legacy monolithic `mcp_servers.json` is auto-migrated to `mcp_servers.d/` +on first load. Edits take effect on server restart or a `reload_tools`-triggered +`McpManager.reload_all()`. + +**Heads-up for admin config edits:** `PUT /admin/agents/mcp-servers` round-trips +the whole model — write back the config you read, or a `user_key` slot added by +hand is silently erased. + +## Runtime + +- `McpManager` (`navi/mcp/manager.py`) holds one `McpClient` per server, + reconnects dead ones in a 30 s health-check loop, and is the single + `call_tool` gateway. Connection headers/env are fixed at transport open + (`navi/mcp/client.py`) — a shared client cannot switch credentials per call. +- Tool names follow `mcp____`; profiles select servers via + `tools.agent.mcp` / `tools.subagent.mcp` group maps. Registered MCP tools + are process-wide, regardless of which profile uses them. +- `McpTool.execute` forwards `ctx.user_id` (falling back to the + `current_user_id` ContextVar) into `manager.call_tool(..., user_id=...)`. + +## Per-user keys (BYOK) + +A config with a `user_key` slot lets each user bring their own credential: + +```json +"user_key": { "header": "Authorization", "prefix": "Bearer " } +``` +or, for stdio servers: +```json +"user_key": { "env": "API_KEY" } +``` + +Exactly one destination (validator `navi/mcp/config.py::McpUserKey`); a +`header` is only valid on HTTP transports, an `env` only on stdio. + +Resolution flow (`McpManager._client_for`): + +1. `user_id is None`, or the config has no `user_key`, or the resolver has no + saved key → the **default shared client** is used with the plaintext + credential from the config file. This path never touches the database — + behaviour without BYOK is byte-for-byte unchanged. +2. Otherwise `KeyResolver.resolve(user_id, server)` reads the user's key + (30 s in-memory TTL; every failure — DB error, missing + `NAVI_AUTH_ENCRYPTION_KEY` — logs a warning and resolves to `None`, i.e. + falls back to the default rather than breaking the tool call). +3. The tool call runs on a **per-(server, user) `McpClient` clone** built from + `McpServerConfig.with_user_key(key)` (deep copy of the config with the key + injected into the header/env destination). Clones are cached per key + snapshot: a changed key transparently rebuilds the client. + +Cache bounds: hard LRU cap of 32 per-user clients; per-user clients idle +longer than 30 minutes are reaped by the health-check tick. Per-user clients +are outside the health-check's reconnect logic — they reconnect lazily with +backoff when next called. `disconnect_all` (reload/shutdown) tears user +clients down as well. + +Key changes (PUT/DELETE) fire the resolver's `on_change` callback, which drops +affected per-user clients immediately. + +### Storage + +`mcp_user_keys` table (postgres, `navi/mcp/_ddl.py`), Fernet-encrypted via +`NAVI_AUTH_ENCRYPTION_KEY` (`navi/mcp/keystore.py::McpKeyStore`). One row per +`(user_id, server_name)`; deleting a user cascades. Keys never leave the +backend through logs or REST responses. + +Anon mode (`NAVI_AUTH_ENABLED=false`) is one shared local user — its saved +key effectively becomes a system-level override, and requires +`NAVI_AUTH_ENCRYPTION_KEY` to be set (the Fernet encryptor refuses an empty +key). + +## REST + +Settings UI surface — see [`api.md`](api.md#mcp-user-keys-byok): +`GET /mcp-keys` (eligible servers, no key values), `PUT /mcp-keys/{server}` +(save/invalidate), `DELETE /mcp-keys/{server}` (reset to default). +The webclient renders the panel only when the eligible list is non-empty. \ No newline at end of file diff --git a/docs/push.md b/docs/push.md index 6b19dab..ed0dab5 100644 --- a/docs/push.md +++ b/docs/push.md @@ -87,7 +87,7 @@ ### Configuration -`NAVI_VAPID_PUBLIC_KEY` / `NAVI_VAPID_PRIVATE_KEY` / `NAVI_VAPID_SUBJECT` / +`NAVI_PUSH_VAPID_PUBLIC_KEY` / `NAVI_PUSH_VAPID_PRIVATE_KEY` / `NAVI_PUSH_VAPID_SUBJECT` / `NAVI_PUSH_COOLDOWN_SEC` — see [`config.md`](config.md). Generate the VAPID pair once with `pip install py_vapid && python -m py_vapid gen`. Empty keys = push disabled everywhere (client panel shows the toggle as unavailable). diff --git a/docs/synapse.md b/docs/synapse.md new file mode 100644 index 0000000..dc4d962 --- /dev/null +++ b/docs/synapse.md @@ -0,0 +1,104 @@ +# Synapse integration + +navi speaks to the [GNEXUS Synapse](https://handbook.gnexus) notification hub in +both directions: + +- **Inbound** — Synapse delivers platform events to navi's webhook; each event + can trigger an *agent reaction* (a background agent run). +- **Outbound** — navi emits low-level lifecycle events (reaction finished / + failed, notify-tool pushes) into Synapse's ingest, where they are simply + logged. + +The `gnexus-synapse` package (vendored dependency) owns the wire format: +`verify_webhook` / `ack` / `make_signature` on the receiving side, +`AsyncSynapseClient` on the emitting side. + +## Configuration + +| Env var | Purpose | +|---|---| +| `SYNAPSE_SOURCE_URL` | Synapse base URL for the *outgoing* source API | +| `SYNAPSE_SOURCE_API_KEY` | `syn_*` key registered in the Synapse admin panel | +| `SYNAPSE_SOURCE_NAME` | source name shown in Synapse (default `navi`) | + +Without a source key nothing outgoing is sent, and Synapse-linked UI options +are disabled (`source_ready: false` in settings responses). + +Inbound deliveries need a per-user **target**: a `token_ref` + shared secret +created in the Synapse admin panel and registered by the user in navi +(`POST /synapse-targets`). + +## Inbound: delivery gateway + +`POST /webhooks/synapse` (`navi/api/routes/synapse.py`) — verifies the +signature against every active target secret (a mismatch never tells which +target failed → 401), dedupes by `event_id` (Synapse retries until 2xx; replays +are re-acked but never acted on twice), logs `synapse.delivery_accepted`, and +hands the envelope to `schedule_reaction()` fire-and-forget, so the ack never +waits for agent work. + +## Inbound: reaction runner + +`navi/synapse/reactions.py` — the point of the feature. Pipeline: + +1. **Gate** — the matched target's user must have `reactions_enabled: true`; + otherwise the event is accepted and discarded (`synapse.reaction_disabled`). +2. **Dispatcher meta-pass** — a single LLM call to the hidden `dispatcher` + profile (`navi/profiles/dispatcher/`, temperature 0.2, one shot, no tools). + Input: the user's reaction instructions + the event envelope. Output: strict + JSON `{profile_id, task, understood}` or `{skip: true}`. Unparseable output + or a backend failure = skip (logged, never a crash). +3. **Profile resolution** — only *visible* profiles may host a reaction; a + hidden or unknown id falls back to `secretary`. +4. **Special session** — a fresh session with `special=True`, name + `Synapse: {event_type}` and `session_metadata["synapse"]` (event id/type/ + dispatcher's understanding). Session + opening message are persisted + *before* the run, so a crash mid-run still leaves a visible trail. +5. **Headless run** — orchestrator `create_run` + `run_agent` with the target + user's tool context. No live subscriber, but the run registry means the user + watching the session in the UI sees the stream live. +6. **Finalise** — app push per `completion_notify` (`always` / `important` = + only when the run had errors / `never`) and a low-level + `reaction.finished` / `reaction.failed` event to Synapse (best effort). + +## Outbound: source side + +`navi/synapse/outbound.py` — `emit_low_level(subject, action, payload, +priority, dedup_key)`: silently no-ops when the source is not configured, +otherwise emits through `AsyncSynapseClient` and closes it per call. + +Users of it: the reaction runner (`reaction`, `finished`/`failed`) and the +`notify` tool (`navi-notification`, action = push level). + +## notify tool + +`navi/tools/notify.py` — the agent's signal channel. Parameters: `message` +(required) + `level` (`info` | `warning` | `intervention`). Reads the user's +`push_target` and delivers through both legs, then answers *honestly*: +`Delivered: app. Skipped: synapse (source key not configured)` — the agent can +see what actually happened and never retries into a wall. Priorities map +`info→normal`, `warning→high`, `intervention→critical`. + +## Per-user settings + +`navi/synapse/settings_store.py` (postgres `synapse_settings`, +`synapse_instruction_versions`): + +- `reactions_enabled` (default `false`), +- `push_target`: `app` | `app_synapse` | `synapse` (default `app`), +- `completion_notify`: `always` | `important` | `never` (default `important`), +- `instructions`: reaction instructions, editable by **both** the user and + navi (`synthesize_instructions` tool edits with `edited_by="navi"`), every + change recorded in the version history (last 100 kept, with author + reason). + +REST: `GET/PUT /synapse-settings` (PUT records a version when instructions +change), `GET /synapse-settings/versions?limit=`. GET/PUT replies include the +non-persisted `source_ready` flag. + +## Service sessions in the UI + +`special=True` sessions are excluded from the regular session list at the REST +layer (`GET /sessions?special=false|true`; omitting the param shows +everything — admin/API callers see all). The webclient sidebar has a +service-sessions toggle that fetches `special=true`; special items render +muted with a robot icon. \ No newline at end of file diff --git a/docs/tasks.md b/docs/tasks.md index 0113c0f..a819421 100644 --- a/docs/tasks.md +++ b/docs/tasks.md @@ -102,7 +102,12 @@ 120 s) expires; `wait_timeout` is a normal failed result telling the agent to continue other work. - `cancel` — cooperative cancel: sets the job's stop event and cancels its - asyncio task. + asyncio task, then waits (bounded, 2 s) for the terminal state so the tool + answers honestly: `cancelled`, the job's real result if it completed right + under the cancellation, or "cancellation requested (still finishing)". + Deleting the session cancels all of its running background jobs + (`cancel_session_jobs`) without leaving pending result notes in the KV + store. Manual for the agent: `manuals/tasks.md`. @@ -129,8 +134,9 @@ - live events from all tools merge through one tagged queue; - results and tool messages are appended in call order after the batch settles, with a single session save; -- Stop mid-batch cancels every unfinished tool and synthesises - "stopped by the user" results for each; +- Stop mid-batch cancels every unfinished tool (its real result is lost) and + synthesises "stopped by the user" results for each; calls that already + finished keep their real results and are recorded in call order; - one tool's exception is recorded as its own failed result and does not kill its neighbours (backend-level LLM errors still abort the turn). diff --git a/docs/tools.md b/docs/tools.md index eccb3cc..8738658 100644 --- a/docs/tools.md +++ b/docs/tools.md @@ -30,6 +30,8 @@ MCP tools survive `reload_tools` because they are registered as external tools in `ToolRegistry`. +MCP configs, transports and per-user credentials (BYOK) are covered in [`mcp.md`](mcp.md). + | Tool | Name | Description | |---|---|---| | `FilesystemTool` | `filesystem` | Read/write/list/copy/grep/diff local files (path restrictions via config) | @@ -48,14 +50,16 @@ | `ListProfilesTool` | `list_profiles` | List all available profiles | | `ShareFileTool` | `share_file` | Copy an existing local file into session files and return a download link | | `ContentPublishTool` | `content_publish` | Register an existing session file for inline viewing in chat | -| `McpStatusTool` | `mcp_status` | Check connectivity and list tools for configured MCP servers | +| `McpStatusTool` | `mcp_status` | Check connectivity and list tools for configured MCP servers (marks servers accepting per-user keys) | | `CreateMcpServerTool` | `create_mcp_server` | Scaffold a new MCP server directory with boilerplate | -| `TestMcpToolTool` | `test_mcp_tool` | Execute a single MCP tool call in isolation for diagnostics | +| `TestMcpToolTool` | `test_mcp_tool` | Execute a single MCP tool call in isolation for diagnostics; for BYOK servers runs on the current user's saved key | | `ReflectTool` | `reflect` | Self-reflection and analysis | | `PeerTool` | `peer` | Swarm communication: `list` machines, `status` of one peer, `ask` a peer a question (answered by a real agent run on the other side) | | `PlanTool` | `plan` | Agent-invoked planning: fresh plan or re-plan with a `reason` (and optional `updated_goal`). The tool result instructs the agent to wait for user confirmation when the task is complex, and to proceed immediately otherwise | | `ScheduleRecallTool` | `schedule_recall` | Schedule a headless callback for the current session (once/recurring/immediate) | | `ManageRecallTool` | `manage_recall` | Cancel, skip, or list scheduled recalls for the current session | +| `SynapseInstructionsTool` | `synapse_instructions` | Read / update the user's Synapse reaction instructions (`edited_by="navi"`, `reason` recorded); updates are stored in the edit history | +| `NotifyTool` | `notify` | Push a notification to the user (`message` + `level`: info/warning/intervention); legs app push and Synapse event per the user's push_target, result reports delivered/skipped honestly | ### User tools (`tools/*.py`) diff --git a/navi/api/routes/agents.py b/navi/api/routes/agents.py index 28ddd52..0cdb27b 100644 --- a/navi/api/routes/agents.py +++ b/navi/api/routes/agents.py @@ -21,6 +21,8 @@ is_admin = user is not None and user.role == "admin" result = [] for p in profiles.all(): + if getattr(p, "is_hidden", False): + continue if getattr(p, "is_admin_only", False) and not is_admin: continue result.append( diff --git a/navi/api/routes/auth.py b/navi/api/routes/auth.py index 6e00584..eb1709b 100644 --- a/navi/api/routes/auth.py +++ b/navi/api/routes/auth.py @@ -187,14 +187,15 @@ async with pool.acquire() as conn: await conn.execute( """INSERT INTO navi_users ( - id, email, display_name, username, first_name, last_name, + id, email, display_name, avatar_url, username, first_name, last_name, phone, birth_date, country, city, locale, role, permissions, created_at, updated_at ) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $14) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $15) ON CONFLICT (id) DO UPDATE SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, + avatar_url = COALESCE(EXCLUDED.avatar_url, navi_users.avatar_url), username = EXCLUDED.username, first_name = EXCLUDED.first_name, last_name = EXCLUDED.last_name, @@ -209,6 +210,7 @@ auth_user.user_id, auth_user.email, profile.get("display_name") or auth_user.email, + auth_user.avatar_url, profile.get("username"), profile.get("first_name"), profile.get("last_name"), diff --git a/navi/api/routes/health.py b/navi/api/routes/health.py index d1a0da4..5ec4b73 100644 --- a/navi/api/routes/health.py +++ b/navi/api/routes/health.py @@ -1,20 +1,76 @@ +"""Health endpoint — handbook contract (10-platform/health.md). + +`status` is the aggregate of the sub-checks (worst of: down > degraded > ok). +Embed/hive failures degrade the service, they don't take it down. The body +keeps the pre-contract `embed`/`hive` payloads at the top level so existing +in-house tooling keeps working (monitors ignore unknown fields). +""" + +import time + from fastapi import APIRouter from navi.config import settings router = APIRouter(tags=["health"]) +# The embed check is a real network call — polls come in every ~30 s, so the +# result is cached short (handbook: cache at most 10 s). +_EMBED_CACHE_TTL = 10.0 +_embed_cache: dict = {"checked_at": 0.0, "result": None} + @router.get("/health") async def health() -> dict: - embed_status = await _check_embed() + embed_status = await _check_embed_cached() + hive = _hive_status() + + embed_check = _embed_check_entry(embed_status) + hive_check = _hive_check_entry(hive) + + statuses = [check["status"] for check in (embed_check, hive_check)] + aggregate = "degraded" if "degraded" in statuses else "ok" + return { - "status": "ok", + "status": aggregate, + "service": "navi", + "checks": {"embed": embed_check, "hive": hive_check}, + # Legacy payloads (pre-contract) — kept for existing tooling. "embed": embed_status, - "hive": _hive_status(), + "hive": hive, } +def _embed_check_entry(embed_status: dict) -> dict: + """Map the legacy embed probe to a handbook-shaped check entry.""" + if embed_status.get("ok"): + check = {"status": "ok"} + if embed_status.get("ms") is not None: + check["ms"] = embed_status["ms"] + return check + return { + "status": "degraded", + "detail": embed_status.get("error") or "no_embedding_backend", + } + + +def _hive_check_entry(hive: dict) -> dict: + """Map the swarm registry status to a handbook-shaped check entry.""" + if not hive.get("configured", False): + return {"status": "ok", "detail": "not configured"} + if hive.get("error"): + return {"status": "degraded", "detail": hive["error"]} + if not hive.get("reachable", False): + detail = hive.get("last_error") or "hive unreachable" + return {"status": "degraded", "detail": detail} + return {"status": "ok"} + + +@router.get("/health/embed") +async def health_embed() -> dict: + return await _check_embed_cached() + + def _hive_status() -> dict: """Swarm registry (hive) reachability as seen by the announce loop.""" if not settings.hive_url: @@ -27,12 +83,28 @@ return announcer.get_status() -@router.get("/health/embed") -async def health_embed() -> dict: - return await _check_embed() +async def _check_embed_cached() -> dict: + """Embed self-check, cached for up to 10 s (health polls every ~30 s).""" + now = time.monotonic() + if ( + _embed_cache["result"] is not None + and now - _embed_cache["checked_at"] < _EMBED_CACHE_TTL + ): + return _embed_cache["result"] + + started = time.perf_counter() + result = await _check_embed() + elapsed_ms = int((time.perf_counter() - started) * 1000) + result.setdefault("ms", None) + result["ms"] = elapsed_ms + + _embed_cache["checked_at"] = now + _embed_cache["result"] = result + return result async def _check_embed() -> dict: + """One embed call against the active backend; never raises.""" backend = None try: from navi.api.deps import get_memory_store @@ -45,4 +117,4 @@ return {"ok": True, "backend": getattr(backend, "_host", "unknown"), "error": None} except Exception as e: host = getattr(backend, "_host", "unknown") if backend else "none" - return {"ok": False, "backend": host, "error": str(e)} + return {"ok": False, "backend": host, "error": str(e)} \ No newline at end of file diff --git a/navi/api/routes/mcp_keys.py b/navi/api/routes/mcp_keys.py new file mode 100644 index 0000000..b611ff0 --- /dev/null +++ b/navi/api/routes/mcp_keys.py @@ -0,0 +1,138 @@ +"""Per-user MCP credentials (BYOK) — REST for the settings UI. + +A server config (``mcp_servers.d/*.json``) may declare a ``user_key`` slot; +only such servers appear here. Users save their own key, which overrides the +default plaintext credential for their tool calls; users without a key fall +back to the default. Keys are never returned — only presence and update time. +""" + +from typing import Annotated + +import structlog +from fastapi import APIRouter, Depends, HTTPException +from pydantic import BaseModel, Field + +from navi.api.deps import require_user +from navi.auth import User + +log = structlog.get_logger() + +router = APIRouter(prefix="/mcp-keys", tags=["mcp-keys"]) + + +def _pool(): + from navi.api.deps import get_session_store + + return get_session_store()._get_pool() + + +def _eligible_configs(): + """Configs that accept a user key and are referenced by at least one profile. + + A server nobody connects to is noise in the settings UI even if its + config declares a user_key slot. + """ + from navi.api.deps import get_profile_registry + from navi.mcp.config import load_mcp_servers + + referenced: set[str] = set() + for profile in get_profile_registry().all(): + referenced.update(profile.tools.agent.mcp) + referenced.update(profile.tools.subagent.mcp) + + return { + name: cfg + for name, cfg in load_mcp_servers().items() + if name in referenced and cfg.user_key is not None + } + + +class McpKeyItem(BaseModel): + server_name: str + transport: str + key_type: str # header | env + key_location: str # header name or env var name + prefix: str | None = None + instructions: str | None = None + has_key: bool + updated_at: str | None = None + + +@router.get("") +async def list_mcp_keys( + user: Annotated[User, Depends(require_user)], +) -> dict: + keyed = _eligible_configs() + if not keyed: + return {"items": []} + + from navi.mcp.keystore import McpKeyStore + + keys = await McpKeyStore(await _pool()).list_servers(user.id) + + def _item(name: str, cfg) -> dict: + return McpKeyItem( + server_name=name, + transport=cfg.transport, + key_type="header" if cfg.user_key.header else "env", + key_location=cfg.user_key.header or cfg.user_key.env, + prefix=cfg.user_key.prefix, + instructions=cfg.instructions, + has_key=name in keys, + updated_at=keys[name].isoformat() if name in keys else None, + ).model_dump() + + return {"items": [_item(name, cfg) for name, cfg in sorted(keyed.items())]} + + +class SaveMcpKeyRequest(BaseModel): + key: str = Field(min_length=1, max_length=4096) + + +def _get_config(server_name: str): + """The config for *server_name*; 404 when missing or key-less.""" + from navi.mcp.config import load_mcp_servers + + cfg = load_mcp_servers().get(server_name) + if cfg is None or cfg.user_key is None: + raise HTTPException(status_code=404, detail="Unknown server or it accepts no user key") + return cfg + + +@router.put("/{server_name}") +async def save_mcp_key( + server_name: str, + payload: SaveMcpKeyRequest, + user: Annotated[User, Depends(require_user)], +) -> dict: + _get_config(server_name) + + from navi.mcp.keystore import McpKeyStore, get_key_resolver + + updated_at = await McpKeyStore(await _pool()).set( + user.id, server_name, payload.key.strip(), + ) + get_key_resolver().invalidate(user.id, server_name) + log.info("mcp_key.saved", user_id=user.id, server=server_name) + return { + "server_name": server_name, + "has_key": True, + "updated_at": updated_at.isoformat(), + } + + +@router.delete("/{server_name}", status_code=204) +async def delete_mcp_key( + server_name: str, + user: Annotated[User, Depends(require_user)], +) -> None: + _get_config(server_name) + + from navi.mcp.keystore import McpKeyStore, get_key_resolver + + deleted = await McpKeyStore(await _pool()).delete(user.id, server_name) + get_key_resolver().invalidate(user.id, server_name) + if not deleted: + # Key never existed — still 204, the desired end state is reached. + return + log.info("mcp_key.deleted", user_id=user.id, server=server_name) \ No newline at end of file diff --git a/navi/api/routes/sessions.py b/navi/api/routes/sessions.py index 40348df..d54e80a 100644 --- a/navi/api/routes/sessions.py +++ b/navi/api/routes/sessions.py @@ -45,6 +45,34 @@ pinned: bool +class RenameSessionRequest(BaseModel): + # Empty string means "regenerate from session content" (the client sends + # it when the user cleared the title and left the edit field). + name: str = "" + + +def _session_owner(user) -> str | None: + """Owner id for session create/list. + + In local mode (auth disabled) the anonymous user is a separate user with + user_id=None — not an alias of every other user — so sessions must be + persisted ownerless and listings must scope to NULL-owner rows only. + """ + return user.id if settings.navi_auth_enabled else None + + +def _session_admin(user) -> bool: + """Listing-scope admin flag — only meaningful when auth is enabled. + + The local-mode anonymous user is nominally 'admin' so debug/admin + endpoints keep working, but the admin flag must never widen the chat + session listings beyond NULL-owner rows there. + """ + return settings.navi_auth_enabled and ( + user.role == "admin" or user.has_permission("navi.sessions.read_all") + ) + + @router.post("", status_code=201) async def create_session( payload: CreateSessionRequest, @@ -64,10 +92,10 @@ except ProfileNotFound: raise HTTPException(status_code=404, detail=f"Profile '{profile_id}' not found") - session = await store.create(profile_id, user_id=user.id) + session = await store.create(profile_id, user_id=_session_owner(user)) # Fire-and-forget: extract memory from any stale sessions (last active > 30 min ago) - asyncio.create_task(_process_stale_sessions(store, memory, user_id=user.id)) + asyncio.create_task(_process_stale_sessions(store, memory, user_id=_session_owner(user))) return { "session_id": session.id, @@ -114,11 +142,16 @@ offset: Annotated[int | None, Query(ge=0)] = None, profile_id: str | None = None, search: str | None = Query(None), + special: bool | None = Query(None), ) -> dict | list[dict]: - is_admin = user.role == "admin" or user.has_permission("navi.sessions.read_all") + # special=None and special=False both mean the regular list; special=True + # exposes the service sessions (e.g. Synapse reactions), which the sidebar + # hides behind its toggle. + special_filter = False if special is None else special + is_admin = _session_admin(user) if limit is None and offset is None: - sessions = await store.list_all(user_id=user.id, is_admin=is_admin) + sessions = await store.list_all(user_id=_session_owner(user), is_admin=is_admin, special=special_filter) if profile_id and not search: sessions = [s for s in sessions if s.profile_id == profile_id] pending_ids = await scheduler.get_pending_session_ids([s.id for s in sessions]) @@ -130,17 +163,19 @@ sessions = await store.search_list( limit=page_limit + 1, offset=page_offset, - user_id=user.id, + user_id=_session_owner(user), is_admin=is_admin, search=search, + special=special_filter, ) else: sessions = await store.list_page( limit=page_limit + 1, offset=page_offset, profile_id=profile_id, - user_id=user.id, + user_id=_session_owner(user), is_admin=is_admin, + special=special_filter, ) items = sessions[:page_limit] pending_ids = await scheduler.get_pending_session_ids([s.id for s in items]) @@ -161,6 +196,7 @@ "message_count": len(session.messages), "preview": _preview(session), "pinned": session.pinned, + "special": session.special, "has_pending_recall": has_pending_recall, "created_at": session.created_at.isoformat(), "last_active": session.last_active.isoformat(), @@ -200,6 +236,31 @@ return indices, preview +@router.get("/{session_id}/meta") +async def get_session_meta( + session_id: str, + store: Annotated[SessionStore, Depends(get_session_store)], + user: Annotated[User, Depends(require_user)], +) -> dict: + # Light session head without the message payload — the webclient loads the + # history separately via /{session_id}/messages/history in pages. + session = await store.get_meta(session_id) + if session is None: + raise HTTPException(status_code=404, detail="Session not found") + check_session_access(session, user, permission="navi.sessions.read_all") + return { + "session_id": session.id, + "profile_id": session.profile_id, + "name": session.name, + "message_count": session.db_message_count, + "context_token_count": session.context_token_count, + "max_context_tokens": settings.ollama_num_ctx, + "archive_threshold": session.archive_threshold, + "created_at": session.created_at.isoformat(), + "last_active": session.last_active.isoformat(), + } + + @router.get("/{session_id}") async def get_session( session_id: str, @@ -469,6 +530,46 @@ ) +@router.get("/{session_id}/tasks") +async def list_session_tasks( + session_id: str, + store: Annotated[SessionStore, Depends(get_session_store)], + user: Annotated[User, Depends(require_user)], +) -> dict: + """List this session's background tasks (the TaskManager jobs). + + task_update events are delivered live over the WS and are not replayed on + reconnect, so the client fetches this snapshot to rebuild its + backgrounds tab after a reload / reconnection. + """ + session = await store.get(session_id) + if session is None: + raise HTTPException(status_code=404, detail="Session not found") + check_session_access(session, user, permission="navi.sessions.read_all") + + from datetime import datetime, timezone as _tz + + from navi.core.tasks import args_summary, get_task_manager + + items = [] + for j in get_task_manager().list(session_id): + items.append({ + "task_id": j.task_id, + "tool": j.tool, + "status": j.status, + "args_summary": args_summary(j.args), + "parent_tool_call_id": j.parent_tool_call_id or None, + "started_at": datetime.fromtimestamp(j.created_at, tz=_tz.utc).isoformat(), + "finished_at": ( + datetime.fromtimestamp(j.finished_at, tz=_tz.utc).isoformat() + if j.finished_at is not None else None + ), + "subagent_tokens": j.subagent_tokens, + "result_preview": j.preview() or None, + }) + return {"session_id": session_id, "tasks": items} + + @router.post("/{session_id}/generate-name") async def generate_name( session_id: str, @@ -492,8 +593,19 @@ if not user_messages: return {"name": None} + # Short first user messages often carry no topic (greetings, one-liners) — + # that's why a share of sessions stayed unnamed. The agent's final replies + # are where the actual subject lands; fold them into the naming context. + assistant_messages = [ + m.content for m in session.messages + if m.role == "assistant" and m.content + ][-2:] + backend = backends.get("ollama") - name = await generate_session_name(user_messages, backend, settings.ollama_default_model) + name = await generate_session_name( + user_messages, backend, settings.ollama_default_model, + assistant_messages=assistant_messages, + ) if name: await store.set_name(session_id, name) @@ -501,12 +613,59 @@ return {"name": name} +@router.patch("/{session_id}/name") +async def rename_session( + session_id: str, + body: RenameSessionRequest, + store: Annotated[SessionStore, Depends(get_session_store)], + backends: Annotated[BackendRegistry, Depends(get_backend_registry)], + user: Annotated[User, Depends(require_user)], +) -> dict: + """Set the session title manually, or regenerate it on an empty edit. + + A whitespace-only name falls back to LLM naming (the same context as + generate-name: user messages plus the agent's final replies). + """ + session = await store.get(session_id) + if session is None: + raise HTTPException(status_code=404, detail="Session not found") + check_session_access(session, user) + + name = body.name.strip()[:200] + if not name: + user_messages = [ + m.content for m in session.messages + if m.role == "user" and m.content + ] + assistant_messages = [ + m.content for m in session.messages + if m.role == "assistant" and m.content + ][-2:] + if not user_messages: + return {"name": None} + backend = backends.get("ollama") + name = await generate_session_name( + user_messages, backend, settings.ollama_default_model, + assistant_messages=assistant_messages, + ) + if not name: + return {"name": None} + + ok = await store.set_name(session_id, name) + if not ok: + raise HTTPException(status_code=404, detail="Session not found") + return {"session_id": session_id, "name": name} + + @router.delete("/{session_id}", status_code=204) async def delete_session( session_id: str, store: Annotated[SessionStore, Depends(get_session_store)], user: Annotated[User, Depends(require_user)], ) -> None: + import time as _time + + _t0 = _time.perf_counter() session = await store.get(session_id) if session is None: raise HTTPException(status_code=404, detail="Session not found") @@ -517,11 +676,35 @@ if orchestrator and orchestrator._container and orchestrator._container.terminal_manager: await orchestrator._container.terminal_manager.close_all(session_id) + # Cancel background tasks for this session: they outlive the run but not + # their session, and letting them finish would burn tokens for a session + # that no longer exists while their completion notes dangle in the KV + # store (suppress_note = True, set inside cancel_session_jobs). + from navi.core.tasks import get_task_manager + from navi.core.task_notes import clear as clear_task_notes + _t_get = _time.perf_counter() + get_task_manager().cancel_session_jobs(session_id) + # Pending notes from earlier completed jobs would never drain — the + # session is going away. + await clear_task_notes(session_id) + _t_tasks = _time.perf_counter() + deleted = await store.delete(session_id) + _t_db = _time.perf_counter() if not deleted: raise HTTPException(status_code=404, detail="Session not found") # Remove session file directory if it exists await delete_session_dir(session_id) + _t_dir = _time.perf_counter() + log.info( + "sessions.delete_timing", + session_id=session_id, + lookup_terminals_ms=round((_t_get - _t0) * 1000, 1), + tasks_notes_ms=round((_t_tasks - _t_get) * 1000, 1), + db_delete_ms=round((_t_db - _t_tasks) * 1000, 1), + files_dir_ms=round((_t_dir - _t_db) * 1000, 1), + total_ms=round((_t_dir - _t0) * 1000, 1), + ) @router.get("/{session_id}/messages/archive") @@ -546,6 +729,32 @@ } +@router.get("/{session_id}/messages/history") +async def get_session_history( + session_id: str, + store: Annotated[SessionStore, Depends(get_session_store)], + user: Annotated[User, Depends(require_user)], + before_seq: int | None = None, + limit: int = Query(150, ge=1, le=200), +) -> dict: + """Paged full history (archive ∪ hot), newest page first. + + Without ``before_seq`` — the tail a client shows initially; with it — the + next older page for scroll-up loading. Returns oldest-first items so the + client can render/prepend them directly. + """ + session = await store.get_meta(session_id) + if session is None: + raise HTTPException(status_code=404, detail="Session not found") + check_session_access(session, user) + msgs, has_more = await store.get_history_page(session_id, before_seq=before_seq, limit=limit) + return { + "items": [m.model_dump(mode="json", exclude_none=True) for m in msgs], + "has_more": has_more, + "next_before_seq": msgs[0].sequence_number if msgs else None, + } + + @router.get("/{session_id}/recall") async def get_session_recall( session_id: str, diff --git a/navi/api/routes/synapse.py b/navi/api/routes/synapse.py new file mode 100644 index 0000000..cc07a9a --- /dev/null +++ b/navi/api/routes/synapse.py @@ -0,0 +1,229 @@ +"""Synapse webhook routes — s2s delivery gateway + per-user target secrets. + +Receiving half of the Synapse integration (handbook 10-platform/notifications.md, +§ «Интеграция получателя»): Synapse delivers events to POST /webhooks/synapse. +The route is registered with both spellings («.../synapse» and «.../synapse/») — +protection against an SPA catch-all swallowing one of them, mirroring the +gnexus-auth webhook contract. + +Delivery handling: verify-and-ack, then a fire-and-forget reaction run +(`navi.synapse.reactions`) for the matched user — gated by their per-user +reaction settings. Outbound events are emitted from `navi.synapse.outbound`. +""" + +from collections import OrderedDict +from typing import Annotated, Literal + +import structlog +from fastapi import APIRouter, Depends, HTTPException, Query, Request +from gnexus_synapse import ack, verify_webhook +from gnexus_synapse.exceptions import SynapseWebhookError +from pydantic import BaseModel + +from navi.api.deps import require_user +from navi.auth import User +from navi.synapse.outbound import synapse_source_ready +from navi.synapse.settings_store import ( + CompletionNotify, + PushTarget, + SynapseSettingsStore, +) +from navi.synapse.store import SynapseTargetStore + +log = structlog.get_logger() + +webhook_router = APIRouter(prefix="/webhooks", tags=["synapse"]) +targets_router = APIRouter(prefix="/synapse-targets", tags=["synapse"]) +settings_router = APIRouter(prefix="/synapse-settings", tags=["synapse"]) + +# Idempotency: Synapse retries until a 2xx, so the same delivery may arrive +# more than once. An insertion-ordered map of event ids, hard-capped, is +# enough — retries always concern minutes-old deliveries. +_seen_events: OrderedDict[str, bool] = OrderedDict() +_SEEN_EVENTS_MAX = 1024 + + +def _mark_event(event_id: str) -> bool: + """True if this event id was not seen before.""" + if event_id in _seen_events: + _seen_events.move_to_end(event_id) + return False + _seen_events[event_id] = True + while len(_seen_events) > _SEEN_EVENTS_MAX: + _seen_events.popitem(last=False) + return True + + +def _pool(): + from navi.api.deps import get_session_store + + return get_session_store()._get_pool() + + +@webhook_router.post("/synapse") +@webhook_router.post("/synapse/") +async def synapse_delivery(request: Request) -> dict: + """Verify and accept one Synapse s2s delivery.""" + raw = await request.body() + + store = SynapseTargetStore(await _pool()) + targets = await store.active_secrets() + if not targets: + raise HTTPException(status_code=503, detail="No navi-side Synapse targets configured") + + # Try every active per-user secret until one verifies; a mismatch tells + # nothing about which target failed — never expose that. + envelope: dict | None = None + matched: dict | None = None + for target in targets: + try: + envelope = verify_webhook(raw, dict(request.headers), target["secret"]) + matched = target + break + except SynapseWebhookError: + continue + + if envelope is None: + log.warning("synapse.deliver_rejected", detail="no target secret matched") + raise HTTPException(status_code=401, detail="Invalid webhook signature") + + event_id = envelope.get("event_id") or "" + payload = envelope.get("payload") if isinstance(envelope.get("payload"), dict) else {} + + if event_id and not _mark_event(event_id): + # Already accepted (Synapse retry) — ack again, don't act twice. + return ack(event_id) + + log.info( + "synapse.delivery_accepted", + event_id=event_id, + event_type=request.headers.get("x-gnexus-event-type") or envelope.get("type"), + source=request.headers.get("x-synapse-source") or envelope.get("source"), + subject=envelope.get("subject"), + action=envelope.get("action"), + payload_user_id=payload.get("user_id"), + target_user_id=matched["user_id"], + target_ref=matched["token_ref"], + ) + # Reaction layer: a fire-and-forget agent run under the matched user's + # reaction settings (gated there). The ack above must not wait for it. + from navi.synapse.reactions import schedule_reaction + + event_type = ( + request.headers.get("x-gnexus-event-type") or envelope.get("type") or "" + ) + schedule_reaction(envelope, user_id=matched["user_id"], event_type=event_type) + return ack(event_id) + + +class CreateSynapseTargetRequest(BaseModel): + token_ref: str + secret: str + + +class SynapseTargetItem(BaseModel): + id: int + token_ref: str + created_at: str + + +@targets_router.post("") +async def create_target( + payload: CreateSynapseTargetRequest, + user: Annotated[User, Depends(require_user)], +) -> dict: + ref = payload.token_ref.strip() + if not ref or len(ref) > 64: + raise HTTPException(status_code=422, detail="token_ref must be 1..64 characters") + if len(payload.secret) < 16: + raise HTTPException( + status_code=422, detail="Secret must be at least 16 characters" + ) + + store = SynapseTargetStore(await _pool()) + target = await store.create(user.id, ref, payload.secret) + log.info("synapse.target_created", user_id=user.id, token_ref=ref, target_id=target.id) + return { + "id": target.id, + "token_ref": target.token_ref, + "created_at": target.created_at.isoformat(), + } + + +@targets_router.get("") +async def list_targets(user: Annotated[User, Depends(require_user)]) -> dict: + store = SynapseTargetStore(await _pool()) + items = await store.list_for_user(user.id) + return { + "items": [ + SynapseTargetItem( + id=t.id, + token_ref=t.token_ref, + created_at=t.created_at.isoformat(), + ).model_dump() + for t in items + ] + } + + +@targets_router.delete("/{target_id}", status_code=204) +async def revoke_target( + target_id: int, + user: Annotated[User, Depends(require_user)], +) -> None: + store = SynapseTargetStore(await _pool()) + if not await store.revoke(target_id, user.id): + raise HTTPException(status_code=404, detail="Target not found") + log.info("synapse.target_revoked", user_id=user.id, target_id=target_id) + + +class UpdateSynapseSettingsRequest(BaseModel): + reactions_enabled: bool + push_target: PushTarget + completion_notify: CompletionNotify + instructions: str + + +@settings_router.get("") +async def get_synapse_settings( + user: Annotated[User, Depends(require_user)], +) -> dict: + store = SynapseSettingsStore(await _pool()) + settings_row = await store.get(user.id) + data = settings_row.model_dump(mode="json", exclude={"user_id"}) + # Not persisted — tells the UI whether Synapse-linked options are usable. + data["source_ready"] = synapse_source_ready() + return data + + +@settings_router.put("") +async def update_synapse_settings( + payload: UpdateSynapseSettingsRequest, + user: Annotated[User, Depends(require_user)], +) -> dict: + store = SynapseSettingsStore(await _pool()) + current = await store.get(user.id) + current.reactions_enabled = payload.reactions_enabled + current.push_target = payload.push_target + current.completion_notify = payload.completion_notify + if payload.instructions != current.instructions: + await store.save_instructions( + user.id, payload.instructions, edited_by="user" + ) + current.instructions = payload.instructions + await store.save(current) + data = current.model_dump(mode="json", exclude={"user_id"}) + data["source_ready"] = synapse_source_ready() + return data + + +@settings_router.get("/versions") +async def list_instruction_versions( + user: Annotated[User, Depends(require_user)], + limit: Annotated[int, Query(ge=1, le=100)] = 20, +) -> dict: + store = SynapseSettingsStore(await _pool()) + versions = await store.list_versions(user.id, limit=limit) + return { + "items": [v.model_dump(mode="json") for v in versions] + } \ No newline at end of file diff --git a/navi/api/routes/webhooks.py b/navi/api/routes/webhooks.py index 93af75a..1269dbb 100644 --- a/navi/api/routes/webhooks.py +++ b/navi/api/routes/webhooks.py @@ -1,5 +1,7 @@ """Webhook receiver for gnexus-auth events.""" +from datetime import datetime, timezone + import structlog from fastapi import APIRouter, HTTPException, Request from gnexus_gauth.exceptions import WebhookPayloadException, WebhookVerificationException @@ -20,7 +22,11 @@ - auth.global_logout → invalidate all sessions - session.revoked → invalidate matching session - client.roles_changed / client.permissions_changed → update user role/permissions - """ + - user.profile_updated → update the mirrored navi_users profile + (handbook: profile.update; role/permissions have their own events, and a + local locale override must survive this hook — navi has none yet, the + locale column is a straight mirror, so it is updated together) +""" if not settings.gnauth_client_id or not settings.gnauth_client_secret: raise HTTPException(status_code=503, detail="OAuth is not configured") @@ -83,9 +89,56 @@ await _update_user_permissions(user_id) log.info("webhook.permissions_updated", user_id=user_id, webhook_event=event_type) + elif event_type == "user.profile_updated": + profile = (event.metadata or {}).get("profile") + user_id = target.get("user_id") or (event.metadata or {}).get("user", {}).get("id") + if user_id and isinstance(profile, dict): + await _update_user_profile(user_id, profile) + log.info("webhook.profile_updated", user_id=user_id, changed_fields=(event.metadata or {}).get("changed_fields")) + else: + log.warning("webhook.profile_update_unusable", user_id=user_id) + return {"ok": True} +async def _update_user_profile(user_id: str, profile: dict) -> None: + """Mirror a gnexus-auth profile change into navi_users (role/permissions aside).""" + try: + from navi.api.deps import get_session_store + store = get_session_store() + pool = await store._get_pool() + async with pool.acquire() as conn: + await conn.execute( + """UPDATE navi_users SET + display_name = COALESCE($2, display_name), + avatar_url = COALESCE($3, avatar_url), + username = COALESCE($4, username), + first_name = COALESCE($5, first_name), + last_name = COALESCE($6, last_name), + phone = COALESCE($7, phone), + birth_date = COALESCE($8, birth_date), + country = COALESCE($9, country), + city = COALESCE($10, city), + locale = COALESCE($11, locale), + updated_at = $1 + WHERE id = $12""", + datetime.now(timezone.utc), + profile.get("display_name"), + profile.get("avatar_url"), + profile.get("username"), + profile.get("first_name"), + profile.get("last_name"), + profile.get("phone"), + profile.get("birth_date"), + profile.get("country"), + profile.get("city"), + profile.get("locale"), + user_id, + ) + except Exception: + log.warning("webhook.update_profile_failed", user_id=user_id, exc_info=True) + + async def _invalidate_user_sessions(user_id: str) -> None: try: from navi.api.deps import get_session_store @@ -117,7 +170,7 @@ async with pool.acquire() as conn: await conn.execute( "UPDATE navi_users SET permissions = '[]', updated_at = $1 WHERE id = $2", - __import__("datetime").datetime.now(__import__("datetime").timezone.utc), + datetime.now(timezone.utc), user_id, ) except Exception: diff --git a/navi/api/websocket.py b/navi/api/websocket.py index df56832..faa2087 100644 --- a/navi/api/websocket.py +++ b/navi/api/websocket.py @@ -204,6 +204,9 @@ # Register run and subscribe before starting the task so we never # miss events even if the task is very fast. run = orchestrator.create_run(session_id) + # Remember which socket owns this run: at teardown, session_sync goes + # to every OTHER watching socket (this one reloads via its own path). + run.owner_socket = websocket queue = run.subscribe() # Set user context for tool sandboxing (inherited by the agent task) @@ -388,6 +391,9 @@ "session_id": session.id, "profile_id": session.profile_id, }) + # Messages queued while every socket was gone never drained + # (or drained into a dead socket) — run them now, headlessly. + orchestrator.schedule_queued_drain(session_id, session_store) while True: raw = await websocket.receive_text() @@ -557,3 +563,8 @@ current_run.unsubscribe(queue) # Remove this socket from the session tracking set. await orchestrator.remove_websocket(session_id, websocket) + # The last watcher may have left mid-drain: the queue's drain loop + # bailed out when `connected` turned False, and the run's own + # schedule_queued_drain skipped while this socket was still + # registered. Pick any leftover queue up now. + orchestrator.schedule_queued_drain(session_id, session_store) diff --git a/navi/auth/_ddl.py b/navi/auth/_ddl.py index f537a7d..0b75c10 100644 --- a/navi/auth/_ddl.py +++ b/navi/auth/_ddl.py @@ -9,6 +9,7 @@ id TEXT PRIMARY KEY, email TEXT NOT NULL, display_name TEXT, + avatar_url TEXT, username TEXT, first_name TEXT, last_name TEXT, @@ -51,6 +52,7 @@ # Columns added after initial table creation — boot-time migration. _NAVI_USERS_MIGRATION_COLUMNS = [ + ("avatar_url", "TEXT"), ("username", "TEXT"), ("first_name", "TEXT"), ("last_name", "TEXT"), diff --git a/navi/auth/deps.py b/navi/auth/deps.py index 2d735ab..24b50e1 100644 --- a/navi/auth/deps.py +++ b/navi/auth/deps.py @@ -253,6 +253,7 @@ country=profile.get("country"), city=profile.get("city"), locale=profile.get("locale"), + avatar_url=auth_user.avatar_url, ) profile = auth_user.profile @@ -316,7 +317,7 @@ token_hash = hashlib.sha256(token.encode()).hexdigest() async with pool.acquire() as db_conn: user_row = await db_conn.fetchrow( - "SELECT u.id, u.email, u.display_name, u.username, u.first_name, u.last_name, " + "SELECT u.id, u.email, u.display_name, u.avatar_url, u.username, u.first_name, u.last_name, " "u.phone, u.birth_date, u.country, u.city, u.locale, u.role, u.permissions, " "t.id AS token_id, t.revoked_at " "FROM api_tokens t JOIN navi_users u ON u.id = t.user_id " @@ -336,6 +337,7 @@ id=user_row["id"], email=user_row["email"], display_name=user_row["display_name"] or user_row["email"], + avatar_url=user_row["avatar_url"], username=user_row["username"], first_name=user_row["first_name"], last_name=user_row["last_name"], @@ -423,21 +425,22 @@ store, user_id: str, email: str, display_name: str | None, role: str, permissions: list[str], username: str | None = None, first_name: str | None = None, last_name: str | None = None, phone: str | None = None, birth_date: str | None = None, country: str | None = None, - city: str | None = None, locale: str | None = None, + city: str | None = None, locale: str | None = None, avatar_url: str | None = None, ) -> None: pool = await store._get_pool() import json async with pool.acquire() as conn: await conn.execute( """INSERT INTO navi_users ( - id, email, display_name, username, first_name, last_name, + id, email, display_name, avatar_url, username, first_name, last_name, phone, birth_date, country, city, locale, role, permissions, created_at, updated_at ) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $14) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $15) ON CONFLICT (id) DO UPDATE SET email = EXCLUDED.email, display_name = EXCLUDED.display_name, + avatar_url = COALESCE(EXCLUDED.avatar_url, navi_users.avatar_url), username = EXCLUDED.username, first_name = EXCLUDED.first_name, last_name = EXCLUDED.last_name, @@ -449,7 +452,7 @@ role = EXCLUDED.role, permissions = EXCLUDED.permissions, updated_at = EXCLUDED.updated_at""", - user_id, email, display_name or email, username, first_name, last_name, + user_id, email, display_name or email, avatar_url, username, first_name, last_name, phone, birth_date, country, city, locale, role, json.dumps(permissions), datetime.now(timezone.utc), ) @@ -493,11 +496,15 @@ """Raise 403 if user does not own the session and lacks the required permission. Legacy sessions (user_id=None) are accessible only to admins. - When auth is disabled, all sessions are shared by the single anonymous user. + When auth is disabled, the anonymous local user is a separate user with + user_id=None: only NULL-owner sessions are visible — other users' chats + must never leak into local mode. """ from fastapi import HTTPException if not settings.navi_auth_enabled: + if session.user_id is not None: + raise HTTPException(status_code=403, detail="Access denied") return if session.user_id is None: diff --git a/navi/config.py b/navi/config.py index c33c90c..88e7143 100644 --- a/navi/config.py +++ b/navi/config.py @@ -181,6 +181,14 @@ # runs can overlap on one session; also dedups rapid-fire turns). navi_push_cooldown_sec: int = 30 + # Synapse ingest — navi as an event SOURCE (outbound reaction notifications). + # Empty api key = navi cannot emit events to Synapse: the settings UI + # disables the synapse push-target options and the notify tool silently + # skips that leg of delivery. + synapse_source_url: str = "" + synapse_source_api_key: str = "" + synapse_source_name: str = "navi" + # LLM call timeouts # complete() is non-streaming (compression) — blocked until full response llm_complete_timeout: int = 120 diff --git a/navi/core/agent.py b/navi/core/agent.py index 7274e82..4943595 100644 --- a/navi/core/agent.py +++ b/navi/core/agent.py @@ -1025,38 +1025,49 @@ yield value if stopped: + # Stop must actually stop work: cancel in-flight tools the same + # way the sequential path does (docs/tasks.md: stop mid-batch + # cancels every unfinished tool). Calls that already finished + # keep their real results — only unfinished ones get the + # synthetic stopped note below; erasing a completed + # backgrounded call (task_id) would orphan the task in the + # client UI. log.info( "agent.batch_stopped", tools=[tc.name for tc in turn_tool_calls], ) - for tc in turn_tool_calls: - yield ToolEvent( - tool_name=tc.name, - arguments=tc.arguments, - result="Tool execution was stopped by the user.", - success=False, - tool_call_id=tc.id, - ) - session.messages.append( - Message( - role="tool", - content="Tool execution was stopped by the user.", - tool_call_id=tc.id, - name=tc.name, - metadata={}, - is_context=False, - ) - ) - await self._sessions.save(session) - return + for t in tasks: + if not t.done(): + t.cancel() + await asyncio.gather(*tasks, return_exceptions=True) # Results and messages in call order, one save for the batch. + # A stopped batch mixes real results (finished calls) with the + # synthetic stopped note (cancelled calls). for tc, holder in zip(turn_tool_calls, holders): - r = ( - holder[0] - if holder - else RuntimeError("tool task produced no result") - ) + if not holder: + if stopped: + yield ToolEvent( + tool_name=tc.name, + arguments=tc.arguments, + result="Tool execution was stopped by the user.", + success=False, + tool_call_id=tc.id, + ) + session.messages.append( + Message( + role="tool", + content="Tool execution was stopped by the user.", + tool_call_id=tc.id, + name=tc.name, + metadata={}, + is_context=False, + ) + ) + continue + r = RuntimeError("tool task produced no result") + else: + r = holder[0] if isinstance(r, Exception): if isinstance(r, (LLMBackendError, LLMConnectionError)): raise r @@ -1088,10 +1099,14 @@ session.context.append(image_msg) await self._sessions.save(session) finally: - # gather(return_exceptions=True) contains each cancelled tool task - # (awaiting one directly would re-raise CancelledError past the - # results already produced) while an outer cancellation of the run - # itself still propagates. + # Cancel whatever is still running (generator closed mid-batch or + # an outer cancellation of the run), then gather to contain each + # cancelled task — awaiting the results directly would re-raise + # CancelledError past the results already produced, while an + # outer cancellation of the run itself still propagates. + for t in tasks: + if not t.done(): + t.cancel() await asyncio.gather(*tasks, return_exceptions=True) async def _execute_tools_sequential( diff --git a/navi/core/compressor.py b/navi/core/compressor.py index 1b4dee5..b6f55ea 100644 --- a/navi/core/compressor.py +++ b/navi/core/compressor.py @@ -107,6 +107,12 @@ return max(0, score) +def _order_like(reference: list[Message], subset: list[Message]) -> list[Message]: + """Reorder `subset` into the order its members appear in `reference`.""" + wanted = {id(m) for m in subset} + return [m for m in reference if id(m) in wanted] + + def partition_messages( messages: list[Message], keep_recent: int, @@ -121,26 +127,43 @@ Tool call groups (assistant + tool results) always stay together. When adaptive=True, important turns (user corrections, errors, critical tools) are kept longer and social/filler turns are compressed sooner. + + Summary messages (is_summary=True) are not part of any turn: they carry + already-compressed history, not a new user request. They always go into + to_summarize so the fresh summary replaces them (the single-summary + invariant) — an old summary can never act as a turn's user-request head + (which the midturn split would keep verbatim beside the fresh summary) or + be rescued by the adaptive swap. This is what used to make repeated + midturn compressions pile stale summary copies into the context. """ non_system = [m for m in messages if m.role != "system"] + summary_msgs = [m for m in non_system if m.is_summary] + convo = [m for m in non_system if not m.is_summary] - # Group into turns: each turn starts with a user message + # Group into turns: each turn starts with a user message. A non-user + # message with no open turn (can only follow a stripped summary) trails + # the user request that preceded it, so it attaches to the previous turn + # instead of forming an orphan turn without a head. turns: list[list[Message]] = [] - current: list[Message] = [] - for msg in non_system: - if msg.role == "user" and current: - turns.append(current) - current = [msg] + for msg in convo: + if msg.role == "user" or not turns: + turns.append([msg]) else: - current.append(msg) - if current: - turns.append(current) + turns[-1].append(msg) if len(turns) <= keep_recent: if keep_recent_messages is not None: intra_turn = partition_current_turn_messages(turns, keep_recent_messages) if intra_turn is not None: - return intra_turn + old, to_keep = intra_turn + # A compression pass replaces every old summary, never keeps + # one beside the fresh one (single-summary invariant). + return _order_like(non_system, old + summary_msgs), to_keep + if summary_msgs: + # Even when nothing else has aged out, summaries are never kept: + # two or more of them must consolidate (the meta-summary path in + # compress_context) instead of sitting in the context together. + return _order_like(non_system, summary_msgs), convo return [], non_system # nothing old enough to compress # Adaptive: pull important older turns into the kept region and push @@ -192,6 +215,10 @@ to_keep = [m for turn in recent_turns for m in turn] else: to_keep = [m for turn in recent_turns for m in turn] + + # Fold every old summary into this pass; to_summarize is emitted in + # chronological order so the summarizer sees history in sequence. + to_summarize = _order_like(non_system, to_summarize + summary_msgs) return to_summarize, to_keep @@ -838,8 +865,13 @@ # Mark messages in session.messages as not context if they are no longer in new_context # and are not system messages. + # Iterate session.context too: after a session reload, context-only rows + # (old summaries — is_display=False) are present in session.context but + # NOT in session.messages, so demoting only the latter left stale + # summaries with is_context=True in the DB — they piled up in the + # context at every reload (the half-the-context-is-summaries symptom). new_context_ids = {id(m) for m in new_context} - for msg in session.messages: + for msg in [*session.messages, *session.context]: if msg.role != "system" and id(msg) not in new_context_ids: msg.is_context = False diff --git a/navi/core/container.py b/navi/core/container.py index 4641dfd..55751a0 100644 --- a/navi/core/container.py +++ b/navi/core/container.py @@ -114,6 +114,11 @@ mcp_manager = McpManager() await mcp_manager.load_all() + # BYOK: per-user MCP credentials resolve through the process-wide resolver. + from navi.mcp.keystore import get_key_resolver + + mcp_manager.set_key_resolver(get_key_resolver()) + from navi.tools._internal.terminal_manager import TerminalManager terminal_manager = TerminalManager() terminal_manager.start() diff --git a/navi/core/context_builder.py b/navi/core/context_builder.py index cc8c50c..d9212a6 100644 --- a/navi/core/context_builder.py +++ b/navi/core/context_builder.py @@ -106,7 +106,7 @@ parts.append(persona) parts.append(profile.system_prompt) - other = [p for p in self._profiles.all() if p.id != profile.id] + other = [p for p in self._profiles.all() if p.id != profile.id and not getattr(p, "is_hidden", False)] if other: lines = [ "## Available profiles", diff --git a/navi/core/name_generator.py b/navi/core/name_generator.py index 584452c..7963a50 100644 --- a/navi/core/name_generator.py +++ b/navi/core/name_generator.py @@ -1,27 +1,44 @@ -"""Generate a short session name from user messages via LLM.""" +"""Generate a short session name from the conversation via LLM.""" from navi.llm.base import LLMBackend, Message _SYSTEM = ( "You are a session title generator. " - "Given the user's messages from a conversation, produce ONE short title (3–6 words, no punctuation at the end). " + "Given the user's messages (and, possibly, the assistant's replies) from a conversation, " + "produce ONE short title (3–6 words, no punctuation at the end). " "The title must reflect the actual topic. " "Respond in the same language as the user's messages. " - "If the messages contain no clear topic yet (e.g. only greetings, very short or ambiguous text), " + "If there's still no clear topic (e.g. only greetings, very short or ambiguous text), " "reply with exactly: NO_TITLE" ) +# Assistant replies can be huge; a tail slice is enough context for a title. +_ASSISTANT_MSG_CHARS = 600 +_ASSISTANT_MSG_COUNT = 2 + async def generate_session_name( user_messages: list[str], backend: LLMBackend, model: str, + assistant_messages: list[str] | None = None, ) -> str | None: """Return a short title or None if content isn't substantial enough.""" if not user_messages: return None combined = "\n".join(f"- {m}" for m in user_messages[:10]) + + # Naming runs right after the first exchange, when user messages are often + # greetings or one-liners with no topic. The agent's final response is + # where the actual subject shows up — include a trimmed tail of it. + if assistant_messages: + combined += "\n\nAssistant replies:\n" + "\n---\n".join( + m[-_ASSISTANT_MSG_CHARS:] + for m in assistant_messages[-_ASSISTANT_MSG_COUNT:] + if m + ) + messages = [ Message(role="system", content=_SYSTEM), Message(role="user", content=f"User messages:\n{combined}"), diff --git a/navi/core/orchestrator.py b/navi/core/orchestrator.py index 9f43981..7ae7b13 100644 --- a/navi/core/orchestrator.py +++ b/navi/core/orchestrator.py @@ -3,6 +3,7 @@ from __future__ import annotations import asyncio +import contextlib import dataclasses from collections import deque from dataclasses import dataclass, field @@ -86,6 +87,10 @@ # Sessions currently being drained headlessly (guards against the # drain's own run_agent finally re-scheduling a parallel drain). self._headless_draining: set[str] = set() + # Per-task delivery chains: the previous TaskUpdate delivery task, so + # a fast-finishing task cannot emit its terminal update before the + # earlier "running" one hits the wire (ghost-chip ordering). + self._task_notify_tasks: dict[str, asyncio.Task] = {} # Wire event bus subscriber so recall updates reach connected clients from navi.core.event_bus import get_event_bus @@ -146,11 +151,32 @@ Out-of-band like terminal events — a background task outlives any single run, so it bypasses the run's event sink and replay buffer. + Deliveries for one task are chained so ``running`` is always sent + before ``completed/failed/cancelled`` even when the task finishes + between the two ``create_task`` calls. """ from navi.core.events import TaskUpdate - if isinstance(update, TaskUpdate): - await self._notify_session(update.session_id, update.to_wire()) + if not isinstance(update, TaskUpdate): + return + prev = self._task_notify_tasks.pop(update.task_id, None) + + async def _deliver(): + if prev is not None: + with contextlib.suppress(asyncio.CancelledError, Exception): + await prev + try: + await self._notify_session(update.session_id, update.to_wire()) + except Exception: + log.exception("ws.task_update_failed", task_id=update.task_id) + + task = asyncio.create_task(_deliver()) + self._drain_tasks.add(task) + task.add_done_callback(self._drain_tasks.discard) + # Chain later updates of the same task behind this one; terminal + # updates are final — their entry drops out of the chain map. + if update.status == "running": + self._task_notify_tasks[update.task_id] = task # -- user message queue (messages arriving while a run is active) ------- @@ -201,6 +227,36 @@ self._drain_tasks.add(task) task.add_done_callback(self._drain_tasks.discard) + def broadcast_session_sync(self, session_id: str, session=None, exclude=None) -> None: + """Tell every watching socket to reload session history. + + Covers sockets that aren't subscribed to the finished run: another tab + of the same session (its queued message just executed here), a socket + reconnecting during a headless drain, and so on. Fire-and-forget — + must never disturb the run's teardown. + """ + state = self._sessions.get(session_id) + if state is None: + return + profile_id = getattr(session, "profile_id", None) if session is not None else None + + async def _send(ws): + try: + await ws.send_json({ + "type": "session_sync", + "session_id": session_id, + "profile_id": profile_id, + }) + except Exception: + pass # dead socket — its removal path cleans it up + + for ws in list(state.websockets): + if ws is exclude: + continue + task = asyncio.create_task(_send(ws)) + self._drain_tasks.add(task) + task.add_done_callback(self._drain_tasks.discard) + async def _drain_queued(self, session_id: str, session_store) -> None: """Run queued user messages without a websocket (push still fires).""" self._headless_draining.add(session_id) @@ -208,6 +264,9 @@ await self._drain_queued_inner(session_id, session_store) finally: self._headless_draining.discard(session_id) + # Watchers of this session (e.g. a reconnecting tab) learn the + # drained outcomes only through a history reload. + self.broadcast_session_sync(session_id) async def _drain_queued_inner(self, session_id: str, session_store) -> None: """Run queued user messages without a websocket (push still fires).""" @@ -437,6 +496,11 @@ # Client may have disconnected with messages still queued — run # them headlessly (a live socket would have drained them itself). self.schedule_queued_drain(session_id, session_store) + # Other tabs of the session aren't subscribed to this run — they + # reload the saved result through session_sync (the run-owning + # socket syncs in its own handler path). + self.broadcast_session_sync(session_id, session, + exclude=getattr(run, "owner_socket", None)) # ── Forced compact (TUI /compact) ─────────────────────────────────────── @@ -469,6 +533,11 @@ if state is not None: state.run = None await self._cleanup(session_id) + # Compact rewrites history — watchers and a possibly queued drain + # must still happen after it (same lifecycle as run_agent). + self.schedule_queued_drain(session_id, session_store) + self.broadcast_session_sync(session_id, + exclude=getattr(run, "owner_socket", None)) # ── Headless recall run ─────────────────────────────────────────────────── diff --git a/navi/core/pg_session_store.py b/navi/core/pg_session_store.py index 456eb34..11c1631 100644 --- a/navi/core/pg_session_store.py +++ b/navi/core/pg_session_store.py @@ -32,6 +32,7 @@ messages TEXT NOT NULL DEFAULT '[]', context TEXT NOT NULL DEFAULT '', pinned BOOLEAN NOT NULL DEFAULT FALSE, + special BOOLEAN NOT NULL DEFAULT FALSE, created_at TIMESTAMPTZ NOT NULL, last_active TIMESTAMPTZ NOT NULL, context_token_count INTEGER NOT NULL DEFAULT 0, @@ -46,7 +47,8 @@ ALTER TABLE sessions ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES navi_users(id) ON DELETE SET NULL; ALTER TABLE sessions ADD COLUMN IF NOT EXISTS next_sequence INTEGER NOT NULL DEFAULT 0; ALTER TABLE sessions ADD COLUMN IF NOT EXISTS archive_threshold INTEGER NOT NULL DEFAULT 0; -ALTER TABLE sessions ADD COLUMN IF NOT EXISTS session_metadata TEXT NOT NULL DEFAULT '{}' +ALTER TABLE sessions ADD COLUMN IF NOT EXISTS session_metadata TEXT NOT NULL DEFAULT '{}'; +ALTER TABLE sessions ADD COLUMN IF NOT EXISTS special BOOLEAN NOT NULL DEFAULT FALSE """ _SESSION_MESSAGES_DDL = """ @@ -333,6 +335,7 @@ messages=messages, context=context, pinned=bool(row["pinned"]), + special=bool(row.get("special", False)), name=row["name"], created_at=row["created_at"], last_active=row["last_active"], @@ -348,6 +351,23 @@ return sessions +def _special_frag(special: bool | None) -> str: + """SQL fragment for the special filter; '' when unfiltered.""" + if special is None: + return "" + return f"special = {str(bool(special)).upper()}" + + +def _special_and(special: bool | None) -> str: + frag = _special_frag(special) + return f" AND {frag}" if frag else "" + + +def _special_where(special: bool | None) -> str: + frag = _special_frag(special) + return f" WHERE {frag}" if frag else "" + + class PgSessionStore(SessionStore): def __init__(self, pool: asyncpg.Pool) -> None: self._pool = pool @@ -391,7 +411,7 @@ pool = await self._get_pool() async with pool.acquire() as conn: row = await conn.fetchrow( - "SELECT id, profile_id, user_id, pinned, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " "FROM sessions WHERE id = $1", session_id, ) @@ -429,6 +449,7 @@ messages=messages, context=context, pinned=bool(row["pinned"]), + special=bool(row.get("special", False)), name=row["name"], created_at=row["created_at"], last_active=row["last_active"], @@ -452,9 +473,9 @@ # set on insert and not overwritten on conflict (managed elsewhere). await conn.execute( "INSERT INTO sessions " - "(id, profile_id, user_id, pinned, created_at, last_active, " + "(id, profile_id, user_id, pinned, special, created_at, last_active, " " context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata) " - "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) " + "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) " "ON CONFLICT (id) DO UPDATE SET " " profile_id = EXCLUDED.profile_id, " " user_id = EXCLUDED.user_id, " @@ -463,7 +484,8 @@ " planning_logs = EXCLUDED.planning_logs, " " session_metadata = EXCLUDED.session_metadata", session.id, session.profile_id, session.user_id, session.pinned, - session.created_at, session.last_active, session.context_token_count, + session.special, session.created_at, session.last_active, + session.context_token_count, session.name, json.dumps(session.planning_logs, ensure_ascii=False), session.db_next_sequence, session.archive_threshold, @@ -636,6 +658,109 @@ # Return oldest-first so the caller can prepend them in order return [_row_to_message(r) for r in reversed(rows)] + async def get_meta(self, session_id: str) -> Session | None: + """Session row without any message payload — cheap head for the UI. + + Unlike get() this never reads session_messages; message counts come + from a single aggregate. For pending (not-yet-persisted) sessions it + returns the in-memory object like get() does. + """ + async with self._pending_lock: + pending = self._pending.get(session_id) + if pending is not None: + return pending + + pool = await self._get_pool() + async with pool.acquire() as conn: + row = await conn.fetchrow( + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + "FROM sessions WHERE id = $1", + session_id, + ) + if not row: + return None + msg_count = await conn.fetchval( + "SELECT COUNT(*) FROM session_messages WHERE session_id = $1", + session_id, + ) + planning_logs_raw = row["planning_logs"] + planning_logs = json.loads(planning_logs_raw) if planning_logs_raw else [] + metadata_raw = row.get("session_metadata") + s = Session( + id=row["id"], + profile_id=row["profile_id"], + user_id=row["user_id"], + messages=[], + context=[], + pinned=bool(row["pinned"]), + special=bool(row.get("special", False)), + name=row["name"], + created_at=row["created_at"], + last_active=row["last_active"], + context_token_count=row["context_token_count"] or 0, + planning_logs=planning_logs, + ) + s.db_message_count = int(msg_count or 0) + next_seq = row["next_sequence"] or (s.db_message_count + 1) + s.db_next_sequence = int(next_seq) + s.archive_threshold = row["archive_threshold"] or 0 + s.session_metadata = json.loads(metadata_raw or "{}") if metadata_raw else {} + return s + + async def get_history_page( + self, session_id: str, before_seq: int | None = None, limit: int = 150 + ) -> tuple[list[Message], bool]: + """One page of full history (archive ∪ hot), display messages only. + + Returns (messages oldest-first, has_more). With before_seq=None the + page starts at the newest message — the tail the UI loads initially; + with before_seq set it continues below that sequence number (scroll-up + pagination). UNION (not ALL) collapses rows doubled across hot/archive + by a crash between the archive copy and delete. + + Each message carries ``metadata.display_index`` — its 0-based rank in + the full display history — so paged clients build ids that match a full + reload (feedback keys and message jumps depend on that stability). + """ + pool = await self._get_pool() + async with pool.acquire() as conn: + rows = await conn.fetch( + """ + WITH hist AS ( + SELECT * FROM session_messages WHERE session_id = $1 AND is_display + UNION + SELECT * FROM session_messages_archive WHERE session_id = $1 AND is_display + ), ranked AS ( + SELECT *, ROW_NUMBER() OVER (ORDER BY sequence_number) - 1 AS display_index + FROM hist + ) + SELECT * FROM ranked + WHERE ($2::int IS NULL OR sequence_number < $2) + ORDER BY sequence_number DESC + LIMIT $3 + """, + session_id, before_seq, limit + 1, + ) + has_more = len(rows) > limit + # SQL rank of each row: 0-based position in the full display history. + rank_by_seq = {r["sequence_number"]: r["display_index"] for r in rows[:limit]} + msgs = [_row_to_message(r) for r in rows[:limit]] + msgs.reverse() # oldest-first + # A page boundary can split a tool batch — patch the fragment like get() does. + repair_dangling_tool_calls(msgs) + # Synthetic placeholders from the repair have no sequence number and no + # rank — give them the next rank after the last real message so client + # ids stay collision-free. + last_known: int | None = None + for m in msgs: + di = rank_by_seq.get(m.sequence_number) if m.sequence_number >= 0 else None + if di is None and last_known is not None: + di = last_known + 1 + if di is not None: + m.metadata = dict(m.metadata or {}) | {"display_index": di} + last_known = di + return msgs, has_more + async def set_pinned(self, session_id: str, pinned: bool) -> bool: pool = await self._get_pool() async with pool.acquire() as conn: @@ -646,6 +771,13 @@ return result == "UPDATE 1" async def set_name(self, session_id: str, name: str) -> bool: + # A never-persisted session lives only in _pending (lazy persistence): + # the bare UPDATE would touch 0 rows and silently drop the name. + async with self._pending_lock: + pending = self._pending.get(session_id) + if pending is not None: + pending.name = name + return True pool = await self._get_pool() async with pool.acquire() as conn: result = await conn.execute( @@ -654,19 +786,33 @@ ) return result == "UPDATE 1" - async def list_all(self, user_id: str | None = None, is_admin: bool = False) -> list[Session]: + async def list_all( + self, user_id: str | None = None, is_admin: bool = False, special: bool | None = None + ) -> list[Session]: + """Sessions visible to the caller. + + Scoping: admins see everything; a named owner sees their own rows; + ``user_id=None`` (local mode, the anonymous local user) sees only + NULL-owner sessions — never other users' chats. + ``special``: None — no filter, False — regular only, True — special only. + """ pool = await self._get_pool() async with pool.acquire() as conn: - if not is_admin and user_id is not None: + if is_admin: rows = await conn.fetch( - "SELECT id, profile_id, user_id, pinned, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " - "FROM sessions WHERE user_id = $1 ORDER BY pinned DESC, last_active DESC", + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + f"FROM sessions{_special_where(special)} ORDER BY pinned DESC, last_active DESC" + ) + elif user_id is not None: + rows = await conn.fetch( + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + f"FROM sessions WHERE user_id = $1{_special_and(special)} ORDER BY pinned DESC, last_active DESC", user_id, ) else: rows = await conn.fetch( - "SELECT id, profile_id, user_id, pinned, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " - "FROM sessions ORDER BY pinned DESC, last_active DESC" + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + f"FROM sessions WHERE user_id IS NULL{_special_and(special)} ORDER BY pinned DESC, last_active DESC" ) return await _build_sessions(conn, rows) @@ -678,6 +824,7 @@ profile_id: str | None = None, user_id: str | None = None, is_admin: bool = False, + special: bool | None = None, ) -> list[Session]: pool = await self._get_pool() async with pool.acquire() as conn: @@ -691,26 +838,38 @@ params.append(value) return f"${param_idx}" - if not is_admin and user_id is not None: + if not is_admin and user_id is None: + # Local mode: the anonymous local user owns NULL sessions only. + conditions.append("user_id IS NULL") + elif not is_admin: conditions.append(f"user_id = {add_param(user_id)}") if profile_id: conditions.append(f"profile_id = {add_param(profile_id)}") + frag = _special_frag(special) + if frag: + conditions.append(frag) where = "WHERE " + " AND ".join(conditions) if conditions else "" order_limit = f"ORDER BY pinned DESC, last_active DESC LIMIT {add_param(limit)} OFFSET {add_param(offset)}" rows = await conn.fetch( - "SELECT id, profile_id, user_id, pinned, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " f"FROM sessions {where} {order_limit}", *params, ) return await _build_sessions(conn, rows) async def delete(self, session_id: str) -> bool: + # A never-persisted session lives only in _pending (lazy persistence: + # create() defers the row until the first save()), so the bare DB + # DELETE alone reports 0 rows for a very real session. Pop the + # pending entry first, then count the DB result. + async with self._pending_lock: + pending = self._pending.pop(session_id, None) pool = await self._get_pool() async with pool.acquire() as conn: result = await conn.execute("DELETE FROM sessions WHERE id = $1", session_id) - return result == "DELETE 1" + return pending is not None or result == "DELETE 1" async def count_all( self, @@ -718,6 +877,7 @@ user_id: str | None = None, is_admin: bool = False, search: str | None = None, + special: bool | None = None, ) -> int: pool = await self._get_pool() async with pool.acquire() as conn: @@ -731,13 +891,19 @@ params.append(value) return f"${param_idx}" - if not is_admin and user_id is not None: + if not is_admin and user_id is None: + # Local mode: the anonymous local user owns NULL sessions only. + conditions.append("user_id IS NULL") + elif not is_admin: conditions.append(f"user_id = {add_param(user_id)}") if search: like = f"%{search}%" conditions.append( f"(id ILIKE {add_param(like)} OR name ILIKE {add_param(like)} OR user_id ILIKE {add_param(like)} OR profile_id ILIKE {add_param(like)} OR EXISTS (SELECT 1 FROM session_messages m WHERE m.session_id = sessions.id AND m.is_display = true AND m.content ILIKE {add_param(like)}) OR EXISTS (SELECT 1 FROM session_messages_archive a WHERE a.session_id = sessions.id AND a.is_display = true AND a.content ILIKE {add_param(like)}))" ) + frag = _special_frag(special) + if frag: + conditions.append(frag) where = "WHERE " + " AND ".join(conditions) if conditions else "" row = await conn.fetchrow(f"SELECT COUNT(*) FROM sessions {where}", *params) @@ -753,6 +919,7 @@ search: str | None = None, sort_by: str = "last_active", sort_order: str = "desc", + special: bool | None = None, ) -> list[Session]: pool = await self._get_pool() async with pool.acquire() as conn: @@ -766,13 +933,19 @@ params.append(value) return f"${param_idx}" - if not is_admin and user_id is not None: + if not is_admin and user_id is None: + # Local mode: the anonymous local user owns NULL sessions only. + conditions.append("user_id IS NULL") + elif not is_admin: conditions.append(f"user_id = {add_param(user_id)}") if search: like = f"%{search}%" conditions.append( f"(id ILIKE {add_param(like)} OR name ILIKE {add_param(like)} OR user_id ILIKE {add_param(like)} OR profile_id ILIKE {add_param(like)} OR EXISTS (SELECT 1 FROM session_messages m WHERE m.session_id = sessions.id AND m.is_display = true AND m.content ILIKE {add_param(like)}) OR EXISTS (SELECT 1 FROM session_messages_archive a WHERE a.session_id = sessions.id AND a.is_display = true AND a.content ILIKE {add_param(like)}))" ) + frag = _special_frag(special) + if frag: + conditions.append(frag) where = "WHERE " + " AND ".join(conditions) if conditions else "" @@ -783,7 +956,7 @@ order_clause = f"ORDER BY pinned DESC, {col} {order} LIMIT {add_param(limit)} OFFSET {add_param(offset)}" rows = await conn.fetch( - "SELECT id, profile_id, user_id, pinned, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " + "SELECT id, profile_id, user_id, pinned, special, created_at, last_active, context_token_count, name, planning_logs, next_sequence, archive_threshold, session_metadata " f"FROM sessions {where} {order_clause}", *params, ) diff --git a/navi/core/registry.py b/navi/core/registry.py index a8a774e..681b905 100644 --- a/navi/core/registry.py +++ b/navi/core/registry.py @@ -16,6 +16,7 @@ ListProfilesTool, ManageRecallTool, MemoryTool, + NotifyTool, PeerTool, ReflectTool, PlanTool, @@ -24,6 +25,7 @@ SshExecTool, ScratchpadTool, SwitchProfileTool, + SynapseInstructionsTool, TasksTool, TerminalTool, TestMcpToolTool, @@ -236,6 +238,10 @@ profile_registry=profiles, ) list_profiles_tool = ListProfilesTool(profile_registry=profiles) + synapse_instructions_tool = SynapseInstructionsTool( + pool_provider=getattr(session_store, "_get_pool", None), + ) + notify_tool = NotifyTool() builtins = [FilesystemTool(ai_helper=ai_helper), CodeExecTool(), TerminalTool(terminal_manager=terminal_manager), SshExecTool(), ImageViewTool(), @@ -248,6 +254,7 @@ mcp_status_tool, create_mcp_server_tool, test_mcp_tool_tool, schedule_recall_tool, manage_recall_tool, spawn_tool, switch_tool, list_profiles_tool, + synapse_instructions_tool, notify_tool, TasksTool()] if memory_tool: builtins.append(memory_tool) diff --git a/navi/core/session.py b/navi/core/session.py index 0b35edc..4ad2074 100644 --- a/navi/core/session.py +++ b/navi/core/session.py @@ -17,6 +17,7 @@ context: list[Message] = Field(default_factory=list) # LLM context (may be compressed) context_token_count: int = 0 # accumulated total; reset to 0 after compression pinned: bool = False + special: bool = False # service sessions (e.g. Synapse reactions) — hidden from the default list name: str | None = None created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc)) last_active: datetime = Field(default_factory=lambda: datetime.now(timezone.utc)) @@ -38,7 +39,13 @@ async def save(self, session: Session) -> None: ... @abstractmethod - async def list_all(self, user_id: str | None = None, is_admin: bool = False) -> list[Session]: ... + async def list_all( + self, + user_id: str | None = None, + is_admin: bool = False, + special: bool | None = None, + ) -> list[Session]: + """special: None — no filtering, False — regular only, True — special only.""" @abstractmethod async def list_page( @@ -49,6 +56,7 @@ profile_id: str | None = None, user_id: str | None = None, is_admin: bool = False, + special: bool | None = None, ) -> list[Session]: ... @abstractmethod @@ -58,6 +66,7 @@ user_id: str | None = None, is_admin: bool = False, search: str | None = None, + special: bool | None = None, ) -> int: ... @abstractmethod @@ -71,6 +80,7 @@ search: str | None = None, sort_by: str = "last_active", sort_order: str = "desc", + special: bool | None = None, ) -> list[Session]: ... @abstractmethod @@ -107,12 +117,25 @@ session.last_active = datetime.now(timezone.utc) self._sessions[session.id] = session - async def list_all(self, user_id: str | None = None, is_admin: bool = False) -> list[Session]: + @staticmethod + def _special_filter(sessions: list["Session"], special: bool | None) -> list["Session"]: + if special is None: + return sessions + return [s for s in sessions if s.special == special] + + async def list_all( + self, user_id: str | None = None, is_admin: bool = False, special: bool | None = None + ) -> list[Session]: sessions = self._sessions.values() - if not is_admin and user_id is not None: + if is_admin: + pass + elif user_id is not None: sessions = [s for s in sessions if s.user_id == user_id] + else: + # user_id=None non-admin means the anonymous local user: NULL-owner rows only. + sessions = [s for s in sessions if s.user_id is None] return sorted( - sessions, + self._special_filter(list(sessions), special), key=lambda s: (s.pinned, s.last_active), reverse=True, ) @@ -125,8 +148,9 @@ profile_id: str | None = None, user_id: str | None = None, is_admin: bool = False, + special: bool | None = None, ) -> list[Session]: - sessions = await self.list_all(user_id=user_id, is_admin=is_admin) + sessions = await self.list_all(user_id=user_id, is_admin=is_admin, special=special) if profile_id: sessions = [s for s in sessions if s.profile_id == profile_id] return sessions[offset:offset + limit] @@ -137,9 +161,10 @@ user_id: str | None = None, is_admin: bool = False, search: str | None = None, + special: bool | None = None, ) -> int: sessions = await self.search_list( - limit=10000, offset=0, user_id=user_id, is_admin=is_admin, search=search + limit=10000, offset=0, user_id=user_id, is_admin=is_admin, search=search, special=special ) return len(sessions) @@ -153,10 +178,17 @@ search: str | None = None, sort_by: str = "last_active", sort_order: str = "desc", + special: bool | None = None, ) -> list[Session]: sessions = list(self._sessions.values()) - if not is_admin and user_id is not None: + if is_admin: + pass + elif user_id is not None: sessions = [s for s in sessions if s.user_id == user_id] + else: + # user_id=None non-admin: anonymous local user — NULL-owner rows only. + sessions = [s for s in sessions if s.user_id is None] + sessions = self._special_filter(sessions, special) if search: q = search.lower() sessions = [ diff --git a/navi/core/subagent_runner.py b/navi/core/subagent_runner.py index b6ab0f6..51c9691 100644 --- a/navi/core/subagent_runner.py +++ b/navi/core/subagent_runner.py @@ -387,7 +387,15 @@ "tool.execute.subagent", tool=tc.name, args=tc.arguments ) try: - result = await tool.execute(tc.arguments, ctx=tool_ctx) + # Same background interception as the main loop: + # background=true detaches into TaskManager (and + # the flag never reaches the tool itself). None = + # run inline as before. + result = self._tool_executor._maybe_background( + tc, tc.name, tool, tool_ctx + ) + if result is None: + result = await tool.execute(tc.arguments, ctx=tool_ctx) content = result.to_message_content() success = result.success metadata = result.metadata or {} diff --git a/navi/core/task_notes.py b/navi/core/task_notes.py index b873cc1..b3078fe 100644 --- a/navi/core/task_notes.py +++ b/navi/core/task_notes.py @@ -104,6 +104,14 @@ await _kv_store.set("", session_id, "task_notes", "pending", payload) +async def clear(session_id: str) -> None: + """Drop all pending notes for a session (e.g. on session delete).""" + if _kv_store is None: + return + async with _lock(): + await _save(session_id, [], 0) + + async def pending_count(session_id: str) -> int: if _kv_store is None: return 0 diff --git a/navi/core/tasks.py b/navi/core/tasks.py index 759b11a..0c385d3 100644 --- a/navi/core/tasks.py +++ b/navi/core/tasks.py @@ -83,6 +83,9 @@ stop_event: asyncio.Event = field(default_factory=asyncio.Event) task: asyncio.Task | None = None subagent_tokens: int | None = None + # Set when the job is cancelled for reasons where a completion note would + # dangle in the KV store (e.g. the session itself is being deleted). + suppress_note: bool = False def preview(self, limit: int = 800) -> str: """Short result summary for notes / task_update events.""" @@ -227,13 +230,33 @@ if job.status != "running" or job.task is None or job.task.done(): return False job.stop_event.set() - job.task.cancel() + # Task.cancel() is the authoritative race check: it returns False when + # the job finished between our status check and this call — report + # "not cancelled" then, instead of a false "cancelled". + if not job.task.cancel(): + return False # A task cancelled before its first step never enters _run_job, so its # CancelledError handler never fires — finalise by hand via the # done-callback (a no-op when _run_job already finalised). job.task.add_done_callback(lambda _t: self._finalise_if_unfinished(job)) return True + def cancel_session_jobs(self, session_id: str) -> int: + """Cancel every running background task of a session. + + Used on session delete: the jobs outlive the run but not their + session, and letting them finish would burn tokens for a session + that no longer exists while their completion notes dangle in the + KV store. + """ + cancelled = 0 + for job in self.list(session_id): + if job.status == "running": + job.suppress_note = True + if self.cancel(job): + cancelled += 1 + return cancelled + def _finalise_if_unfinished(self, job: TaskJob) -> None: if job.status != "running": return # normal path — _run_job already finalised @@ -249,12 +272,13 @@ status="cancelled", session_id=job.session_id) async def _note(): - try: - from navi.core.task_notes import add_note + if not job.suppress_note: + try: + from navi.core.task_notes import add_note - await add_note(job) - except Exception: - log.exception("tasks.note_write_failed", task_id=job.task_id) + await add_note(job) + except Exception: + log.exception("tasks.note_write_failed", task_id=job.task_id) asyncio.create_task(_note()) @@ -320,12 +344,13 @@ self._harvest_subagent_tokens(job) self._publish(job) job.done.set() # never gated on the note write below - try: - from navi.core.task_notes import add_note + if not job.suppress_note: + try: + from navi.core.task_notes import add_note - await add_note(job) - except Exception: - log.exception("tasks.note_write_failed", task_id=job.task_id) + await add_note(job) + except Exception: + log.exception("tasks.note_write_failed", task_id=job.task_id) log.info( "tasks.finished", task_id=job.task_id, tool=job.tool, status=job.status, session_id=job.session_id, diff --git a/navi/main.py b/navi/main.py index 905071f..e38b0ee 100644 --- a/navi/main.py +++ b/navi/main.py @@ -13,7 +13,7 @@ from fastapi.staticfiles import StaticFiles from navi.api.deps import require_admin -from navi.api.routes import agents, api_tokens, auth, health, messages, peer, push, sessions, webhooks +from navi.api.routes import agents, api_tokens, auth, health, messages, mcp_keys, peer, push, sessions, webhooks, synapse from navi.api.routes.admin import router as admin_router from navi.api.websocket import router as ws_router from navi.config import settings @@ -118,6 +118,8 @@ from navi.core.scheduler import recall_scheduler_loop from navi.core.pg_session_store import pending_sweep_loop from navi.push._ddl import ensure_tables as ensure_push_tables + from navi.synapse._ddl import ensure_tables as ensure_synapse_tables + from navi.mcp._ddl import ensure_tables as ensure_mcp_tables # Ensure auth tables first (navi_users is referenced by other DDL). for attempt in range(1, 6): @@ -126,6 +128,8 @@ await ensure_tables() pool = await container.database.pool() await ensure_push_tables(pool) + await ensure_synapse_tables(pool) + await ensure_mcp_tables(pool) break except Exception as e: if attempt < 5: @@ -256,6 +260,10 @@ app.include_router(ws_router) app.include_router(push.router) app.include_router(webhooks.router) +app.include_router(synapse.webhook_router) +app.include_router(synapse.targets_router) +app.include_router(synapse.settings_router) +app.include_router(mcp_keys.router) app.include_router(admin_router) # Eval endpoints spend LLM tokens and read session data — admin only. # (With auth disabled require_admin resolves to the anonymous admin user.) diff --git a/navi/mcp/__init__.py b/navi/mcp/__init__.py index 6444326..aa9b0c1 100644 --- a/navi/mcp/__init__.py +++ b/navi/mcp/__init__.py @@ -1,5 +1,11 @@ from .client import McpClient -from .config import McpServerConfig, load_mcp_servers +from .config import McpServerConfig, McpUserKey, load_mcp_servers from .manager import McpManager -__all__ = ["McpClient", "McpServerConfig", "load_mcp_servers", "McpManager"] +__all__ = [ + "McpClient", + "McpServerConfig", + "McpUserKey", + "load_mcp_servers", + "McpManager", +] \ No newline at end of file diff --git a/navi/mcp/_ddl.py b/navi/mcp/_ddl.py new file mode 100644 index 0000000..9bc5bfe --- /dev/null +++ b/navi/mcp/_ddl.py @@ -0,0 +1,21 @@ +"""DDL for mcp_user_keys — per-user credentials for MCP servers (BYOK). + +A server config declares a ``user_key`` slot (header or env destination). +Users may save their own key, which overrides the default plaintext +credential in ``mcp_servers.d/*.json`` for their tool calls; users without a +key fall back to the default. Keys are stored Fernet-encrypted. +""" + +_DDL = """ +CREATE TABLE IF NOT EXISTS mcp_user_keys ( + user_id TEXT NOT NULL REFERENCES navi_users(id) ON DELETE CASCADE, + server_name TEXT NOT NULL, + key_enc TEXT NOT NULL, + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, server_name) +); +""" + + +async def ensure_tables(pool) -> None: + await pool.execute(_DDL) \ No newline at end of file diff --git a/navi/mcp/config.py b/navi/mcp/config.py index e3a8eef..931a3ab 100644 --- a/navi/mcp/config.py +++ b/navi/mcp/config.py @@ -5,11 +5,37 @@ from pathlib import Path from typing import Literal -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, model_validator logger = logging.getLogger(__name__) +class McpUserKey(BaseModel): + """Declares where a per-user credential is injected into a server config. + + Exactly one destination. When a user has saved their own key (see + ``navi/mcp/keystore.py``), the runtime clones the server config with + ``headers[header] = prefix + key`` (sse/streamable_http) or + ``env[env] = key`` (stdio); users without a key fall back to the default + plaintext credential in the config. + """ + + header: str | None = None + prefix: str | None = None + env: str | None = None + + @model_validator(mode="after") + def _exactly_one_destination(self) -> "McpUserKey": + if bool(self.header) == bool(self.env): + raise ValueError("user_key must declare exactly one of 'header' or 'env'") + if self.prefix and not self.header: + raise ValueError("'prefix' is only valid together with 'header'") + return self + + +_HTTP_TRANSPORTS = ("sse", "streamable_http") + + class McpServerConfig(BaseModel): """Configuration for a single MCP server.""" @@ -33,6 +59,41 @@ # instructions provided by the MCP server itself during the initialize handshake. instructions: str | None = None + # Per-user credential slot (Bring Your Own Key). None = the server needs no + # user key; all users share the default plaintext credential above. + user_key: McpUserKey | None = None + + @property + def accepts_user_key(self) -> bool: + return self.user_key is not None + + def with_user_key(self, key: str) -> "McpServerConfig": + """Return a deep copy of this config with *key* injected per user_key.""" + if self.user_key is None: + raise ValueError("Server accepts no user key") + cfg = self.model_copy(deep=True) + assert cfg.user_key is not None + if cfg.user_key.header: + headers = dict(cfg.headers or {}) + headers[cfg.user_key.header] = (cfg.user_key.prefix or "") + key + cfg.headers = headers + else: + env = dict(cfg.env or {}) + env[cfg.user_key.env or ""] = key + cfg.env = env + return cfg + + @model_validator(mode="after") + def _user_key_transport_compatible(self) -> "McpServerConfig": + if self.user_key is not None: + if self.user_key.header and self.transport not in _HTTP_TRANSPORTS: + raise ValueError( + "user_key.header requires transport 'sse' or 'streamable_http'" + ) + if self.user_key.env and self.transport != "stdio": + raise ValueError("user_key.env requires transport 'stdio'") + return self + @property def is_stdio(self) -> bool: return self.transport == "stdio" diff --git a/navi/mcp/keystore.py b/navi/mcp/keystore.py new file mode 100644 index 0000000..addf076 --- /dev/null +++ b/navi/mcp/keystore.py @@ -0,0 +1,144 @@ +"""Storage for per-user MCP credentials (BYOK), postgres + Fernet. + +The key replaces the default plaintext credential from ``mcp_servers.d/*.json`` +for a given user's tool calls. It is never returned by any API — only its +presence and update time. +""" + +from __future__ import annotations + +import logging +import time +from datetime import datetime, timezone +from typing import Callable + +from navi.auth.encrypt import get_encryptor + +log = logging.getLogger(__name__) + +_UPSERT = """ +INSERT INTO mcp_user_keys (user_id, server_name, key_enc, updated_at) +VALUES ($1, $2, $3, $4) +ON CONFLICT (user_id, server_name) +DO UPDATE SET key_enc = EXCLUDED.key_enc, updated_at = EXCLUDED.updated_at +""" + +_DELETE = """ +DELETE FROM mcp_user_keys WHERE user_id = $1 AND server_name = $2 +RETURNING server_name +""" + +_GET = """ +SELECT key_enc FROM mcp_user_keys WHERE user_id = $1 AND server_name = $2 +""" + +_LIST_SERVERS = """ +SELECT server_name, updated_at FROM mcp_user_keys WHERE user_id = $1 +""" + + +class McpKeyStore: + def __init__(self, pool): + self._pool = pool + + async def set(self, user_id: str, server_name: str, key: str) -> datetime: + updated_at = datetime.now(timezone.utc) + await self._pool.execute( + _UPSERT, user_id, server_name, get_encryptor().encrypt(key), updated_at, + ) + return updated_at + + async def delete(self, user_id: str, server_name: str) -> bool: + """Remove the user's key. False when there was none.""" + deleted = await self._pool.fetchval(_DELETE, user_id, server_name) + return deleted is not None + + async def get(self, user_id: str, server_name: str) -> str | None: + """The decrypted key, or None when the user has none.""" + enc = await self._pool.fetchval(_GET, user_id, server_name) + if not enc: + return None + return get_encryptor().decrypt(enc) + + async def list_servers(self, user_id: str) -> dict[str, datetime]: + """{server_name: updated_at} — servers where the user has a key.""" + rows = await self._pool.fetch(_LIST_SERVERS, user_id) + return {r["server_name"]: r["updated_at"] for r in rows} + + +class KeyResolver: + """Cached (user_id, server_name) -> decrypted key, TTL-bounded. + + Every failure — DB error, missing encryption key — resolves to ``None`` + with a warning: the BYOK layer must never break a tool call, the caller + falls back to the default config credential. + """ + + def __init__( + self, + store_factory: Callable[[], McpKeyStore], + *, + ttl: float = 30.0, + now: Callable[[], float] = time.monotonic, + ) -> None: + self._store_factory = store_factory + self._ttl = ttl + self._now = now + self._cache: dict[tuple[str, str], tuple[float, str | None]] = {} + self._on_change: Callable[[str, str | None], None] | None = None + + async def resolve(self, user_id: str, server_name: str) -> str | None: + """The user's key for *server_name*, or None (no key / any failure).""" + entry = self._cache.get((user_id, server_name)) + if entry is not None: + expires_at, key = entry + if self._now() < expires_at: + return key + del self._cache[(user_id, server_name)] + try: + key = await self._store_factory().get(user_id, server_name) + except Exception: + log.warning( + "mcp user key resolve failed: user=%s server=%s — falling back to default credential", + user_id, + server_name, + exc_info=True, + ) + return None + self._cache[(user_id, server_name)] = (self._now() + self._ttl, key) + return key + + def invalidate(self, user_id: str, server_name: str | None = None) -> None: + """Drop cached key(s); *server_name* None clears every server of the user.""" + if server_name is None: + for k in [k for k in self._cache if k[0] == user_id]: + del self._cache[k] + else: + self._cache.pop((user_id, server_name), None) + if self._on_change is not None: + self._on_change(user_id, server_name) + + def invalidate_all(self) -> None: + self._cache.clear() + if self._on_change is not None: + self._on_change(None, None) + + def set_on_change(self, cb: Callable[[str | None, str | None], None]) -> None: + """Callback fired on invalidation — used by McpManager to drop + per-user clients built on the old key.""" + self._on_change = cb + + +_resolver: KeyResolver | None = None + + +def get_key_resolver() -> KeyResolver: + """Process-wide resolver, lazily wired to the session-store pool.""" + global _resolver + if _resolver is None: + from navi.api.deps import get_session_store + + _resolver = KeyResolver( + lambda: McpKeyStore(get_session_store()._get_pool()), + ) + return _resolver \ No newline at end of file diff --git a/navi/mcp/manager.py b/navi/mcp/manager.py index 80641eb..87e8b51 100644 --- a/navi/mcp/manager.py +++ b/navi/mcp/manager.py @@ -2,6 +2,8 @@ import asyncio import logging +import time +from collections import OrderedDict from pathlib import Path from typing import Any, Awaitable, Callable @@ -10,6 +12,11 @@ logger = logging.getLogger(__name__) +# Per-user client cache (BYOK): hard size cap to bound stdio subprocesses. +_USER_CLIENT_LIMIT = 32 +# Per-user clients unused for this long are dropped (health-check tick). +_USER_CLIENT_IDLE_SEC = 30.0 * 60.0 + class McpManager: """Holds a pool of :class:`McpClient` instances and manages their lifecycle. @@ -39,6 +46,14 @@ # "connected" toast notifications on every health-check poll. self._connected_status: dict[str, bool] = {} + # BYOK: per-user client clones keyed (server_name, user_id) -> + # (client, key it was built with, monotonic last-used). Ordered + # oldest-first for LRU eviction. + self._user_clients: OrderedDict[ + tuple[str, str], tuple[McpClient, str, float] + ] = OrderedDict() + self._key_resolver: Any = None + @property def clients(self) -> dict[str, McpClient]: return self._clients @@ -105,7 +120,7 @@ async def disconnect_all(self) -> None: """Close every open connection and clear the client pool.""" - if not self._clients: + if not self._clients and not self._user_clients: return for name, client in list(self._clients.items()): try: @@ -116,6 +131,17 @@ logger.warning("MCP server %r disconnect error: %s", name, exc) self._clients.clear() self._connected_status.clear() + for (server, user), (client, _, _) in list(self._user_clients.items()): + try: + await client.disconnect() + except asyncio.CancelledError: + pass + except Exception as exc: + logger.warning( + "MCP user client (server=%s user=%s) disconnect error: %s", + server, user, exc, + ) + self._user_clients.clear() async def get_all_tools(self) -> list[tuple[str, Any]]: """Return ``(server_name, mcp_tool)`` for every tool on every server. @@ -170,16 +196,115 @@ out[name] = "\n".join(parts) return out - async def call_tool(self, server_name: str, tool_name: str, arguments: dict[str, Any] | None = None) -> tuple[str, bool]: + async def call_tool( + self, + server_name: str, + tool_name: str, + arguments: dict[str, Any] | None = None, + *, + user_id: str | None = None, + ) -> tuple[str, bool]: """Proxy a tool call to the named server. + *user_id* selects that user's BYOK credential when the server config + declares a ``user_key`` slot; None (or no saved key) falls back to the + default shared client. Keyword-only, so existing positional callers + are unaffected. + Returns (output_text, is_error) so the caller knows whether the MCP tool itself reported a failure. """ + client = await self._client_for(server_name, user_id) + return await client.call_tool(tool_name, arguments) + + # ── Per-user (BYOK) clients ────────────────────────────────────────────── + + def set_key_resolver(self, resolver: Any) -> None: + """Wire the KeyResolver (navi.mcp.keystore) into the call path.""" + self._key_resolver = resolver + resolver.set_on_change(self._on_key_change) + + def _on_key_change(self, user_id: str | None, server_name: str | None) -> None: + """A key changed — per-user clients built on it become stale.""" + stale = [ + k + for k in self._user_clients + if (user_id is None or k[1] == user_id) + and (server_name is None or k[0] == server_name) + ] + for key in stale: + client = self._user_clients.pop(key)[0] + logger.info("MCP user client dropped (key changed): %s %s", key[0], key[1]) + self._disconnect_quietly(client) + + def _disconnect_quietly(self, client: McpClient) -> None: + try: + asyncio.get_running_loop().create_task(self._quiet_disconnect(client)) + except RuntimeError: + # No running loop (interpreter shutdown) — the transport dies with it. + pass + + @staticmethod + async def _quiet_disconnect(client: McpClient) -> None: + try: + await client.disconnect() + except asyncio.CancelledError: + pass + except Exception: + logger.debug("MCP user-client disconnect error", exc_info=True) + + async def _client_for(self, server_name: str, user_id: str | None) -> McpClient: + """The client to call with: default, or a per-user BYOK clone. + + The default path is checked first and never touches the resolver — + servers without a ``user_key`` slot and user-less calls behave + byte-for-byte as before. + """ + if user_id is not None: + cfg = self._get_configs().get(server_name) + if cfg is not None and cfg.user_key is not None and self._key_resolver is not None: + try: + user_key = await self._key_resolver.resolve(user_id, server_name) + except Exception: + # KeyResolver guarantees None on failure; belt-and-suspenders: + # the tool call must never break because of the BYOK layer. + logger.warning( + "MCP key resolver error for server=%s user=%s — using default", + server_name, user_id, exc_info=True, + ) + user_key = None + if user_key: + return await self._user_client(server_name, user_id, cfg, user_key) client = self._clients.get(server_name) if client is None: raise RuntimeError(f"MCP server {server_name!r} is not connected") - return await client.call_tool(tool_name, arguments) + return client + + async def _user_client( + self, server_name: str, user_id: str, cfg: McpServerConfig, key: str + ) -> McpClient: + """A per-user McpClient clone; rebuilt transparently when the key changes.""" + entry = self._user_clients.get((server_name, user_id)) + if entry is not None and entry[1] == key: + client, _, _ = entry + else: + if entry is not None: + # Key rotated between resolutions — tear the old one down. + self._user_clients.pop((server_name, user_id)) + self._disconnect_quietly(entry[0]) + client = McpClient(server_name, cfg.with_user_key(key)) + logger.info("MCP user client created: server=%s user=%s", server_name, user_id) + self._user_clients[(server_name, user_id)] = (client, key, time.monotonic()) + self._user_clients.move_to_end((server_name, user_id)) + + # Hard LRU cap: bound stdio subprocesses and idle HTTP clients. + while len(self._user_clients) > _USER_CLIENT_LIMIT: + evicted_key, (evicted_client, _, _) = self._user_clients.popitem(last=False) + logger.info( + "MCP user client evicted (LRU): server=%s user=%s", *evicted_key + ) + self._disconnect_quietly(evicted_client) + return client # ── Health check ───────────────────────────────────────────────────────── @@ -243,3 +368,21 @@ ) except Exception: pass + + # Idle per-user clients: not part of the health-check itself (they + # reconnect lazily with backoff when next called), only reaped here. + self._evict_idle_user_clients() + + def _evict_idle_user_clients(self) -> None: + now = time.monotonic() + idle_keys = [ + k + for k, (_, _, last_used) in self._user_clients.items() + if now - last_used > _USER_CLIENT_IDLE_SEC + ] + for key in idle_keys: + client = self._user_clients.pop(key)[0] + logger.info( + "MCP user client evicted (idle): server=%s user=%s", *key + ) + self._disconnect_quietly(client) diff --git a/navi/mcp/tools.py b/navi/mcp/tools.py index e3d7218..ee32f97 100644 --- a/navi/mcp/tools.py +++ b/navi/mcp/tools.py @@ -6,7 +6,13 @@ from pathlib import Path from navi.config import settings -from navi.tools._internal.base import Tool, ToolContext, ToolResult, current_session_id +from navi.tools._internal.base import ( + Tool, + ToolContext, + ToolResult, + current_session_id, + current_user_id, +) from .manager import McpManager @@ -96,8 +102,11 @@ forwarded[key] = self._normalize_path_param(forwarded[key]) try: + uid = ctx.user_id if ctx else None + if uid is None: + uid = current_user_id.get() output, is_error = await self._manager.call_tool( - self.server_name, self.tool_name, forwarded + self.server_name, self.tool_name, forwarded, user_id=uid ) if is_error: return ToolResult( diff --git a/navi/profiles/base.py b/navi/profiles/base.py index 09c68af..84fd020 100644 --- a/navi/profiles/base.py +++ b/navi/profiles/base.py @@ -59,6 +59,11 @@ # Admin-only profiles are hidden from non-admin users in the profile list. is_admin_only: bool = False + # Hidden profiles never appear in user-facing profile lists (welcome cards, + # switch_profile, list_profiles) — they are internal roles (e.g. the Synapse + # reaction dispatcher) addressed by code, not by the user. + is_hidden: bool = False + # Subagent-only profiles can only be used via spawn_agent — switch_profile # is blocked. Useful for narrow specialist agents that should never become # the main session profile. diff --git a/navi/profiles/developer/config.json b/navi/profiles/developer/config.json index ff9f83a..3fa597b 100644 --- a/navi/profiles/developer/config.json +++ b/navi/profiles/developer/config.json @@ -54,7 +54,9 @@ "gmail", "schedule_recall", "manage_recall", - "peer" + "peer", + "synapse_instructions", + "notify" ], "mcp": { "navi-web": [ diff --git a/navi/profiles/discuss/config.json b/navi/profiles/discuss/config.json index d10f429..ec1978d 100644 --- a/navi/profiles/discuss/config.json +++ b/navi/profiles/discuss/config.json @@ -43,7 +43,9 @@ "share_file", "filesystem", "schedule_recall", - "manage_recall" + "manage_recall", + "synapse_instructions", + "notify" ], "mcp": { "gnexus-book": [ diff --git a/navi/profiles/dispatcher/config.json b/navi/profiles/dispatcher/config.json new file mode 100644 index 0000000..35d5064 --- /dev/null +++ b/navi/profiles/dispatcher/config.json @@ -0,0 +1,23 @@ +{ + "id": "dispatcher", + "name": "Synapse Reaction Dispatcher", + "description": "Internal role: routes an inbound Synapse event to the right session profile and formulates the reaction task. Hidden from all user-facing profile lists.", + "llm_backend": "ollama", + "model": [ + "gemma4:31b-cloud", + "qwen3.6:35b", + "gemma4:26b-a4b-it-q4_K_M" + ], + "temperature": 0.2, + "max_iterations": 1, + "think_enabled": false, + "iteration_budget_enabled": false, + "goal_anchoring_enabled": false, + "anti_stall_enabled": false, + "final_intercept_enabled": false, + "is_hidden": true, + "tools": { + "agent": { "native": [], "mcp": {} }, + "subagent": { "native": [], "mcp": {} } + } +} \ No newline at end of file diff --git a/navi/profiles/dispatcher/system_prompt.txt b/navi/profiles/dispatcher/system_prompt.txt new file mode 100644 index 0000000..c7e90b3 --- /dev/null +++ b/navi/profiles/dispatcher/system_prompt.txt @@ -0,0 +1,32 @@ +Mode: Synapse reaction dispatcher — one-shot routing decision, no tools, no dialogue. + +## Role + +A Synapse event has arrived and must be turned into a background reaction session. +You decide WHAT to do about this event and WHICH profile runs the reaction, based +strictly on the user's reaction instructions provided below the event. + +## Decision + +Answer with ONLY a JSON object, no markdown fences, no prose before or after: + +{ + "profile_id": "", + "task": "", + "understood": "" +} + +Rules: +- "task" is written as an instruction addressed to Navi (like a message from the + user). It contains everything the reaction needs: the event summary, the exact + payload facts worth keeping, and what the instructions say to do about it. +- Do NOT include anything the reaction agent cannot verify itself (no assumptions, + no made-up data). The payload is the ground truth. +- "profile_id" must be one of the listed profile ids. When the instructions don't + clearly call for a specialist profile, pick the default one named in them; if + they name nothing, use "secretary". +- If the instructions say to IGNORE events of this kind, return exactly: + {"skip": true} +- If the event payload is unreadable or insufficient for the instructions to act, + return {"skip": true} too — do not guess. +- Never invent profile ids outside the list. \ No newline at end of file diff --git a/navi/profiles/loader.py b/navi/profiles/loader.py index 449fd35..fa36cc0 100644 --- a/navi/profiles/loader.py +++ b/navi/profiles/loader.py @@ -89,6 +89,7 @@ short_description=config.get("short_description", ""), full_description=config.get("full_description", {}), is_subagent_only=config.get("is_subagent_only", False), + is_hidden=config.get("is_hidden", False), think_enabled=config.get("think_enabled", True), iteration_budget_enabled=config.get("iteration_budget_enabled", True), goal_anchoring_enabled=config.get("goal_anchoring_enabled", True), @@ -153,6 +154,7 @@ "subagent_planning_enabled": profile.subagent_planning_enabled, "subagent_think_enabled": profile.subagent_think_enabled, "is_subagent_only": profile.is_subagent_only, + "is_hidden": profile.is_hidden, "tools": profile.tools.model_dump(mode="json"), "context_providers": profile.context_providers, "compression_keep_recent": profile.compression_keep_recent, diff --git a/navi/profiles/modeler_3d/config.json b/navi/profiles/modeler_3d/config.json index d4065b7..89d8733 100644 --- a/navi/profiles/modeler_3d/config.json +++ b/navi/profiles/modeler_3d/config.json @@ -51,7 +51,9 @@ "share_file", "content_publish", "schedule_recall", - "manage_recall" + "manage_recall", + "synapse_instructions", + "notify" ], "mcp": { "navi-3d": [ diff --git a/navi/profiles/navi_code/config.json b/navi/profiles/navi_code/config.json index 739eb2c..d556dd2 100644 --- a/navi/profiles/navi_code/config.json +++ b/navi/profiles/navi_code/config.json @@ -58,7 +58,9 @@ "spawn_agent", "schedule_recall", "manage_recall", - "peer" + "peer", + "synapse_instructions", + "notify" ], "mcp": { "navi-web": [ diff --git a/navi/profiles/secretary/config.json b/navi/profiles/secretary/config.json index 9f7a31d..bee3d16 100644 --- a/navi/profiles/secretary/config.json +++ b/navi/profiles/secretary/config.json @@ -50,7 +50,9 @@ "weather", "gmail", "schedule_recall", - "manage_recall" + "manage_recall", + "synapse_instructions", + "notify" ], "mcp": { "navi-web": [ diff --git a/navi/profiles/server_admin/config.json b/navi/profiles/server_admin/config.json index 406fe83..cf56a8e 100644 --- a/navi/profiles/server_admin/config.json +++ b/navi/profiles/server_admin/config.json @@ -53,7 +53,9 @@ "gmail", "schedule_recall", "manage_recall", - "peer" + "peer", + "synapse_instructions", + "notify" ], "mcp": { "gnexus-book": [ diff --git a/navi/profiles/tool_developer/config.json b/navi/profiles/tool_developer/config.json index a0b46a3..9d2c883 100644 --- a/navi/profiles/tool_developer/config.json +++ b/navi/profiles/tool_developer/config.json @@ -55,7 +55,9 @@ "test_mcp_tool", "mcp_status", "schedule_recall", - "manage_recall" + "manage_recall", + "synapse_instructions", + "notify" ], "mcp": { "navi-web": [ diff --git a/navi/push/__init__.py b/navi/push/__init__.py index 9e616ec..bb59024 100644 --- a/navi/push/__init__.py +++ b/navi/push/__init__.py @@ -1,6 +1,6 @@ """Web push (PWA) — subscription storage and turn-completion notifications. -Optional integration: with NAVI_VAPID_PUBLIC_KEY/NAVI_VAPID_PRIVATE_KEY empty +Optional integration: with NAVI_PUSH_VAPID_PUBLIC_KEY/NAVI_PUSH_VAPID_PRIVATE_KEY empty the service is disabled and behaves as a no-op everywhere. """ diff --git a/navi/push/service.py b/navi/push/service.py index 2fbf5b3..4aea7e7 100644 --- a/navi/push/service.py +++ b/navi/push/service.py @@ -78,6 +78,21 @@ } asyncio.create_task(self._send_all(user_id, payload)) + async def notify_custom( + self, session_id: str, user_id: str | None, title: str, body: str + ) -> None: + """Arbitrary notification push (reaction completions, intervention + signals). No cooldown — an explicit signal must not be muffled.""" + if not self.enabled or not user_id: + return + payload = { + "title": title, + "body": body, + "url": f"/#{session_id}", + "session_id": session_id, + } + asyncio.create_task(self._send_all(user_id, payload)) + async def _send_all(self, user_id: str, payload: dict) -> None: try: subs = await self._store.list_for_user(user_id) diff --git a/navi/synapse/__init__.py b/navi/synapse/__init__.py new file mode 100644 index 0000000..33d0f5a --- /dev/null +++ b/navi/synapse/__init__.py @@ -0,0 +1,11 @@ +"""Synapse s2s gateway — receiving half only. + +navi does not generate outbound events yet (user decision); what exists is the +delivery gateway: a /webhooks/synapse endpoint that verifies Synapse-delivered +envelopes with per-user target secrets (handbook 10-platform/notifications.md). +""" + +from navi.synapse._ddl import ensure_tables +from navi.synapse.store import SynapseTargetStore + +__all__ = ["ensure_tables", "SynapseTargetStore"] \ No newline at end of file diff --git a/navi/synapse/_ddl.py b/navi/synapse/_ddl.py new file mode 100644 index 0000000..3f5f872 --- /dev/null +++ b/navi/synapse/_ddl.py @@ -0,0 +1,46 @@ +"""DDL for synapse_targets — per-user secrets of Synapse s2s delivery targets. + +Each user registers their own Synapse target (create it in the Synapse admin +panel / MCP `target_create` with the given token_ref, pointing at this navi's +POST /webhooks/synapse) and pastes the secret here. The gateway collects the +secrets of all active targets to verify incoming deliveries. +""" + +_DDL = """ +CREATE TABLE IF NOT EXISTS synapse_targets ( + id SERIAL PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES navi_users(id) ON DELETE CASCADE, + token_ref TEXT NOT NULL, + secret_enc TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ +); + +CREATE INDEX IF NOT EXISTS idx_synapse_targets_user_id ON synapse_targets (user_id); + +CREATE TABLE IF NOT EXISTS synapse_settings ( + user_id TEXT PRIMARY KEY REFERENCES navi_users(id) ON DELETE CASCADE, + reactions_enabled BOOLEAN NOT NULL DEFAULT FALSE, + push_target TEXT NOT NULL DEFAULT 'app', -- app | app_synapse | synapse + completion_notify TEXT NOT NULL DEFAULT 'important', -- always | important | never + instructions TEXT NOT NULL DEFAULT '', + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Version history of reaction instructions: the agent can edit its own +-- instructions (self-improvement), the history keeps that auditable. +CREATE TABLE IF NOT EXISTS synapse_instruction_versions ( + id SERIAL PRIMARY KEY, + user_id TEXT NOT NULL REFERENCES navi_users(id) ON DELETE CASCADE, + content TEXT NOT NULL, + edited_by TEXT NOT NULL, -- 'user' | 'navi' + reason TEXT, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE INDEX IF NOT EXISTS idx_synapse_instruction_versions_user ON synapse_instruction_versions (user_id, created_at); +""" + + +async def ensure_tables(pool) -> None: + await pool.execute(_DDL) \ No newline at end of file diff --git a/navi/synapse/outbound.py b/navi/synapse/outbound.py new file mode 100644 index 0000000..3811a00 --- /dev/null +++ b/navi/synapse/outbound.py @@ -0,0 +1,49 @@ +"""Outbound navi→Synapse events — the source side of the integration. + +Navi emits low-level lifecycle facts (reaction finished / failed) through the +Synapse ingest API, where they are simply logged. Requires the source key +(`syn_*`) registered in the Synapse admin panel; without it nothing is sent. +""" + +import structlog + +from navi.config import settings + +log = structlog.get_logger() + + +def synapse_source_ready() -> bool: + return bool(settings.synapse_source_url and settings.synapse_source_api_key) + + +async def emit_low_level( + subject: str, + action: str, + payload: dict, + priority: str = "low", + dedup_key: str | None = None, +) -> None: + """Fire one ingest event; silently skip when source is not configured.""" + if not synapse_source_ready(): + return + from gnexus_synapse import AsyncSynapseClient + + client = AsyncSynapseClient( + url=settings.synapse_source_url, + api_key=settings.synapse_source_api_key, + default_source=settings.synapse_source_name, + ) + try: + event = await client.emit( + subject=subject, + action=action, + priority=priority, + payload=payload, + dedup_key=dedup_key, + ) + if event is not None: + log.info( + "synapse.outbound_emitted", subject=subject, action=action, event_id=event.id, + ) + finally: + await client.aclose() \ No newline at end of file diff --git a/navi/synapse/reactions.py b/navi/synapse/reactions.py new file mode 100644 index 0000000..2eb62c3 --- /dev/null +++ b/navi/synapse/reactions.py @@ -0,0 +1,298 @@ +"""Reaction runner — inbound Synapse event → hidden special session. + +Scheduling contract: the webhook gateway (`navi.api.routes.synapse`) verifies +the delivery and acks it fast; everything heavier — the dispatcher meta-pass, +session creation, the agent run — happens here, fire-and-forget. + +Flow: +1) per-user settings gate (reactions_enabled); +2) dispatcher meta-pass: envelope + user instructions → + JSON {profile_id, task} or {skip: true}; +3) a fresh `special=True` session is created for the target profile; +4) the agent runs the task headlessly (no WS subscriber — but the orchestrator + run registry lets the user watch the stream live by just opening the + session); +5) completion: session name generation, an app push per the user's + completion_notify setting and a low-level "reaction.finished" event to + Synapse (pure log entry there, best effort). +""" + +from __future__ import annotations + +import asyncio +import json + +import structlog + +from navi.config import settings +from navi.llm.base import Message + +log = structlog.get_logger() + +_DISPATCHER_PROFILE_ID = "dispatcher" +_FALLBACK_PROFILE_ID = "secretary" + + +def synapse_source_ready() -> bool: + """True when navi can emit events to Synapse (source key configured).""" + return bool(settings.synapse_source_url and settings.synapse_source_api_key) + + +# Strong references so the event loop does not garbage-collect running tasks. +_TASKS: set[asyncio.Task] = set() + + +def schedule_reaction(envelope: dict, user_id: str, event_type: str) -> None: + """Fire-and-forget entry — never touches the ack path with heavy work.""" + task = asyncio.create_task(_run_reaction_guarded(envelope, user_id, event_type)) + _TASKS.add(task) + task.add_done_callback(_TASKS.discard) + + +async def _run_reaction_guarded(envelope: dict, user_id: str, event_type: str) -> None: + try: + await run_reaction(envelope, user_id=user_id, event_type=event_type) + except Exception: + log.exception("synapse.reaction_failed", event_id=envelope.get("event_id"), user_id=user_id) + + +async def run_reaction(envelope: dict, *, user_id: str, event_type: str) -> None: + from navi.api.deps import ( + get_backend_registry, + get_orchestrator, + get_profile_registry, + get_session_store, + ) + from navi.synapse.settings_store import SynapseSettingsStore + + session_store = get_session_store() + settings_row = await SynapseSettingsStore(_pool_of(session_store)).get(user_id) + if not settings_row.reactions_enabled: + log.info("synapse.reaction_disabled", event_id=envelope.get("event_id"), user_id=user_id) + return + + profile_id, task_text, understood = await _dispatch(envelope, settings_row.instructions) + if profile_id is None: + log.info("synapse.reaction_skipped", event_id=envelope.get("event_id"), user_id=user_id) + return + + profiles = get_profile_registry() + profile = _resolve_profile(profiles, profile_id) + task_text = (task_text or "").strip() + if not task_text: + log.warning("synapse.reaction_empty_task", event_id=envelope.get("event_id")) + return + + session = await session_store.create(profile.id, user_id=user_id) + session.special = True + session.name = f"Synapse: {event_type}" + session.session_metadata["synapse"] = { + "event_id": envelope.get("event_id"), + "event_type": event_type, + "understood": understood, + } + user_message = _reaction_message(envelope, event_type, task_text, settings_row.instructions) + # Persist the session + the opening message before the run: a crash + # mid-run still leaves a visible, deletable trail in the special list. + await session_store.save(session) + + orchestrator = get_orchestrator() + async with orchestrator.session_lock(session.id): + run = orchestrator.create_run(session.id) + queue = run.subscribe() + + run.task = _spawn_run_task(orchestrator, session.id, user_message, session_store, user_id) + + errors: list[str] = [] + final_text = "" + try: + while True: + kind, payload = await queue.get() + if kind == "event": + full = getattr(payload, "full_content", None) + if full: + final_text = full + elif kind == "error": + errors.append(str(payload)) + elif kind == "done": + break + elif kind == "stopped": + errors.append("Run stopped by the user.") + finally: + run.unsubscribe(queue) + + await _finalise( + session, session_store, settings_row, user_id, + errors=errors, final_text=final_text, event_type=event_type, + ) + + +def _spawn_run_task(orchestrator, session_id: str, user_message: str, session_store, user_id: str): + """Start the agent run with the target user's tool-sandbox context.""" + from navi.tools._internal.base import ( + current_user_id, + current_user_info, + current_user_role, + ) + + current_user_info.set(None) + role_token = current_user_role.set("user") + uid_token = current_user_id.set(user_id) + try: + return asyncio.create_task( + orchestrator.run_agent( + session_id, user_message, None, None, None, session_store, + ) + ) + finally: + current_user_id.reset(uid_token) + current_user_role.reset(role_token) + + +async def _dispatch(envelope: dict, instructions: str) -> tuple[str | None, str, str]: + """One-shot dispatcher call. Returns (profile_id, task, understood) or (None, '', '').""" + from navi.api.deps import get_backend_registry, get_profile_registry + + try: + profiles = get_profile_registry() + dispatcher = profiles.get(_DISPATCHER_PROFILE_ID) + backend = get_backend_registry().get(dispatcher.llm_backend) + except Exception: + log.exception("synapse.reaction_dispatcher_unavailable") + return None, "", "" + + visible = [p.id for p in profiles.all() if not getattr(p, "is_hidden", False)] + system = dispatcher.system_prompt + ( + "\n\n## Available profile ids\n" + "\n".join(f"- {pid}" for pid in visible) + ) + user = ( + "## The user's reaction instructions\n" + + (instructions.strip() or "(empty — pick the safest sensible route)") + + "\n\n## Event envelope\n" + + json.dumps(envelope, ensure_ascii=False, indent=2) + ) + try: + resp = await backend.complete( + [Message(role="system", content=system), Message(role="user", content=user)], + tools=[], + model=dispatcher.model[0], + temperature=dispatcher.temperature, + ) + except Exception: + log.exception("synapse.reaction_dispatch_call_failed") + return None, "", "" + + parsed = _parse_decision(resp.content or "") + if parsed is None or parsed.get("skip"): + return None, "", "" + return parsed.get("profile_id") or "", parsed.get("task") or "", parsed.get("understood") or "" + + +def _parse_decision(text: str) -> dict | None: + text = text.strip() + if not text: + return None + if text.startswith("```"): + text = text.strip("` \n\t") + if text.startswith("json"): + text = text[4:].lstrip() + try: + start, end = text.find("{"), text.rfind("}") + if start == -1 or end <= start: + return None + return json.loads(text[start:end + 1]) + except ValueError: + return None + + +def _resolve_profile(profiles, profile_id: str): + """Only user-visible profiles may host a reaction session.""" + from navi.exceptions import ProfileNotFound + + try: + profile = profiles.get(profile_id) + if getattr(profile, "is_hidden", False): + raise ProfileNotFound(profile_id) + return profile + except Exception: + return profiles.get(_FALLBACK_PROFILE_ID) + + +def _reaction_message(envelope: dict, event_type: str, task_text: str, instructions: str) -> str: + parts = [ + "This is a background reaction session: a Synapse platform event was delivered " + "and the reaction system formed the task below. React on it as instructed — " + "this session is a service one, the user reads it later. Work autonomously: " + "there is no live dialog partner here.", + "", + "## Task (from the reaction dispatcher)", + task_text, + "", + "## Event envelope", + "```json", + json.dumps(envelope, ensure_ascii=False, indent=2), + "```", + ] + if instructions.strip(): + parts += [ + "", + "## The user's reaction instructions", + instructions.strip(), + ] + return "\n".join(parts) + + +async def _finalise( + session, + session_store, + settings_row, + user_id: str, + *, + errors: list[str], + final_text: str, + event_type: str, +) -> None: + from navi.api.deps import get_push_service + from navi.push.service import _preview + from navi.synapse.outbound import emit_low_level + + # App push, per the user's completion_notify preference. + important_case = bool(errors) + want_push = ( + settings_row.completion_notify == "always" + or (settings_row.completion_notify == "important" and important_case) + ) + if want_push and settings_row.push_target in ("app", "app_synapse"): + push_service = get_push_service() + if push_service is not None: + try: + if errors: + title = f"Реакция {event_type} упала" + body = "(ошибка) " + _preview(errors[-1]) + else: + title = f"Реакция {event_type} завершена" + body = _preview(final_text) + await push_service.notify_custom(session.id, user_id, title, body) + except Exception: + log.exception("synapse.reaction_push_failed", session_id=session.id) + + # Low-level lifecycle event to Synapse — a pure log entry on their side, + # independent of the push settings; best effort, silent on failure. + if synapse_source_ready(): + try: + await emit_low_level( + subject="reaction", + action="finished" if not errors else "failed", + payload={ + "session_id": session.id, + "event_id": session.session_metadata.get("synapse", {}).get("event_id"), + "event_type": event_type, + "errors": errors, + }, + ) + except Exception: + log.debug("synapse.reaction_lifecycle_event_skipped", session_id=session.id) + + +def _pool_of(session_store): + return session_store._get_pool() \ No newline at end of file diff --git a/navi/synapse/settings_store.py b/navi/synapse/settings_store.py new file mode 100644 index 0000000..c64a93a --- /dev/null +++ b/navi/synapse/settings_store.py @@ -0,0 +1,121 @@ +"""Per-user Synapse reaction settings + instruction version history (postgres). + +Reaction instructions are the contract between the user and the agent: the +dispatcher meta-pass and every reaction run read them before acting. The agent +itself may edit the document (self-improvement) — every edit lands in +synapse_instruction_versions with an `edited_by` label, so the history doubles +as the audit log of the agent touching its own rules. +""" + +from datetime import datetime, timezone +from typing import Literal + +from pydantic import BaseModel + +PushTarget = Literal["app", "app_synapse", "synapse"] +CompletionNotify = Literal["always", "important", "never"] + +_VERSIONS_KEEP = 100 # versions kept per user; older ones are trimmed + + +class SynapseSettings(BaseModel): + user_id: str + reactions_enabled: bool = False + push_target: PushTarget = "app" + completion_notify: CompletionNotify = "important" + instructions: str = "" + updated_at: datetime | None = None + + +class InstructionVersion(BaseModel): + content: str + edited_by: str + reason: str | None = None + created_at: datetime + + +class SynapseSettingsStore: + def __init__(self, pool): + self._pool = pool + + async def get(self, user_id: str) -> SynapseSettings: + row = await self._pool.fetchrow( + "SELECT user_id, reactions_enabled, push_target, completion_notify, instructions, updated_at " + "FROM synapse_settings WHERE user_id = $1", + user_id, + ) + if row is None: + return SynapseSettings(user_id=user_id) + return SynapseSettings( + user_id=row["user_id"], + reactions_enabled=row["reactions_enabled"], + push_target=row["push_target"], + completion_notify=row["completion_notify"], + instructions=row["instructions"], + updated_at=row["updated_at"], + ) + + async def save(self, settings: SynapseSettings) -> None: + now = datetime.now(timezone.utc) + await self._pool.execute( + """ + INSERT INTO synapse_settings + (user_id, reactions_enabled, push_target, completion_notify, instructions, updated_at) + VALUES ($1, $2, $3, $4, $5, $6) + ON CONFLICT (user_id) DO UPDATE SET + reactions_enabled = EXCLUDED.reactions_enabled, + push_target = EXCLUDED.push_target, + completion_notify = EXCLUDED.completion_notify, + instructions = EXCLUDED.instructions, + updated_at = EXCLUDED.updated_at + """, + settings.user_id, settings.reactions_enabled, settings.push_target, + settings.completion_notify, settings.instructions, now, + ) + + async def save_instructions( + self, user_id: str, content: str, edited_by: Literal["user", "navi"], + reason: str | None = None, + ) -> None: + """Update the instructions document and record the edit in the history. + + One transaction: the version row and the settings row never disagree. + """ + now = datetime.now(timezone.utc) + async with self._pool.acquire() as conn, conn.transaction(): + await conn.execute( + """ + INSERT INTO synapse_settings (user_id, instructions, updated_at) + VALUES ($1, $2, $3) + ON CONFLICT (user_id) DO UPDATE SET + instructions = EXCLUDED.instructions, + updated_at = EXCLUDED.updated_at + """, + user_id, content, now, + ) + await conn.execute( + """ + INSERT INTO synapse_instruction_versions (user_id, content, edited_by, reason, created_at) + VALUES ($1, $2, $3, $4, $5) + """, + user_id, content, edited_by, reason, now, + ) + await conn.execute( + """ + DELETE FROM synapse_instruction_versions + WHERE user_id = $1 AND id NOT IN ( + SELECT id FROM synapse_instruction_versions + WHERE user_id = $1 ORDER BY created_at DESC, id DESC LIMIT $2 + ) + """, + user_id, _VERSIONS_KEEP, + ) + + async def list_versions(self, user_id: str, limit: int = 20) -> list[InstructionVersion]: + rows = await self._pool.fetch( + "SELECT content, edited_by, reason, created_at " + "FROM synapse_instruction_versions WHERE user_id = $1 " + "ORDER BY created_at DESC, id DESC LIMIT $2", + user_id, limit, + ) + return [InstructionVersion(**r) for r in rows] \ No newline at end of file diff --git a/navi/synapse/store.py b/navi/synapse/store.py new file mode 100644 index 0000000..9bb26ee --- /dev/null +++ b/navi/synapse/store.py @@ -0,0 +1,90 @@ +"""Storage for per-user Synapse s2s delivery secrets (postgres, asyncpg). + +The secret is verified on every delivery, so unlike api_tokens it cannot be +stored as a hash — it is kept Fernet-encrypted (see navi.auth.encrypt) and is +shown in the UI exactly once, on creation. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from datetime import datetime, timezone + +from navi.auth.encrypt import get_encryptor + + +@dataclass +class SynapseTarget: + id: int + user_id: str + token_ref: str + created_at: datetime + revoked_at: datetime | None = None + + +_CREATE = """ +INSERT INTO synapse_targets (user_id, token_ref, secret_enc, created_at) +VALUES ($1, $2, $3, $4) +RETURNING id, created_at +""" + +_LIST_FOR_USER = """ +SELECT id, user_id, token_ref, created_at, revoked_at +FROM synapse_targets WHERE user_id = $1 AND revoked_at IS NULL +ORDER BY created_at DESC +""" + +_REVOKE = """ +UPDATE synapse_targets SET revoked_at = $2 WHERE id = $1 AND user_id = $3 AND revoked_at IS NULL +""" + +# For the gateway: every active secret, decrypted, with its owner. +_ALL_ACTIVE_SECRETS = """ +SELECT t.id, t.user_id, t.token_ref, t.secret_enc +FROM synapse_targets t +WHERE t.revoked_at IS NULL +""" + + +class SynapseTargetStore: + def __init__(self, pool): + self._pool = pool + + async def create(self, user_id: str, token_ref: str, secret: str) -> SynapseTarget: + row = await self._pool.fetchrow( + _CREATE, user_id, token_ref, get_encryptor().encrypt(secret), + datetime.now(timezone.utc), + ) + return SynapseTarget( + id=row["id"], user_id=user_id, token_ref=token_ref, created_at=row["created_at"], + ) + + async def list_for_user(self, user_id: str) -> list[SynapseTarget]: + rows = await self._pool.fetch(_LIST_FOR_USER, user_id) + return [ + SynapseTarget( + id=r["id"], user_id=r["user_id"], token_ref=r["token_ref"], + created_at=r["created_at"], revoked_at=r["revoked_at"], + ) + for r in rows + ] + + async def revoke(self, target_id: int, user_id: str) -> bool: + result = await self._pool.fetchval( + _REVOKE, target_id, datetime.now(timezone.utc), user_id, + ) + return result is not None + + async def active_secrets(self) -> list[dict]: + """[(id, user_id, token_ref, secret_plain)] — ordered by creation.""" + rows = await self._pool.fetch(_ALL_ACTIVE_SECRETS) + decrypt = get_encryptor().decrypt + return [ + { + "id": r["id"], + "user_id": r["user_id"], + "token_ref": r["token_ref"], + "secret": decrypt(r["secret_enc"]), + } + for r in rows + ] \ No newline at end of file diff --git a/navi/tools/__init__.py b/navi/tools/__init__.py index 4136696..485f807 100644 --- a/navi/tools/__init__.py +++ b/navi/tools/__init__.py @@ -14,6 +14,8 @@ from .scratchpad import ScratchpadTool from .switch_profile import SwitchProfileTool from .list_profiles import ListProfilesTool +from .synapse_instructions import SynapseInstructionsTool +from .notify import NotifyTool from .reflect import ReflectTool from .plan import PlanRunner, PlanTool from .peer import PeerTool @@ -38,6 +40,8 @@ "ScratchpadTool", "SwitchProfileTool", "ListProfilesTool", + "SynapseInstructionsTool", + "NotifyTool", "ReflectTool", "PlanRunner", "PlanTool", diff --git a/navi/tools/list_profiles.py b/navi/tools/list_profiles.py index 27f16cb..3360b1d 100644 --- a/navi/tools/list_profiles.py +++ b/navi/tools/list_profiles.py @@ -36,9 +36,17 @@ success=False, output="", error=f"Profile '{profile_id}' not found. Available: {available}", ) + if getattr(p, "is_hidden", False): + available = ", ".join( + x.id for x in self._profiles.all() if not getattr(x, "is_hidden", False) + ) + return ToolResult( + success=False, output="", + error=f"Profile '{profile_id}' is an internal role. Available: {available}", + ) return ToolResult(success=True, output=self._format(p)) - sections = [self._format(p) for p in self._profiles.all()] + sections = [self._format(p) for p in self._profiles.all() if not getattr(p, "is_hidden", False)] return ToolResult(success=True, output="\n\n".join(sections)) @staticmethod diff --git a/navi/tools/mcp_status.py b/navi/tools/mcp_status.py index cb04542..6317c3d 100644 --- a/navi/tools/mcp_status.py +++ b/navi/tools/mcp_status.py @@ -36,10 +36,17 @@ lines: list[str] = [] for name, client in manager.clients.items(): + cfg = manager._get_configs().get(name) if not client.connected: lines.append(f"Server: {name} (disconnected)") continue lines.append(f"Server: {name} (connected)") + if cfg is not None and cfg.user_key is not None: + dest = cfg.user_key.header or cfg.user_key.env + lines.append( + f" (accepts a per-user key via {dest} — without one this " + "server runs on the shared default)" + ) try: tools = await client.list_tools() for t in tools: diff --git a/navi/tools/notify.py b/navi/tools/notify.py new file mode 100644 index 0000000..afb578f --- /dev/null +++ b/navi/tools/notify.py @@ -0,0 +1,132 @@ +"""notify — the agent's user-facing signal channel (application + Synapse). + +Respects the user's push_target setting: app-only, app+Synapse, or Synapse-only. +The Synapse leg needs the source key; without it that leg is skipped and the +result says so explicitly, so the agent never wastes retries. +""" + +from navi.synapse.settings_store import SynapseSettingsStore +from navi.tools._internal.base import ( + Tool, + ToolContext, + ToolResult, + current_session_id, + current_user_id, +) + +_LEVEL_TO_PRIORITY = {"info": "normal", "warning": "high", "intervention": "critical"} + + +class NotifyTool(Tool): + name = "notify" + description = ( + "Push a notification to the user (application web push and/or a Synapse " + "event, per the user's notification settings). Use it to signal that " + "something needs the user's attention or that a background task finished. " + "For 'intervention' level state clearly WHAT decision you need from the " + "user and by when — the push opens this session." + ) + parameters = { + "type": "object", + "properties": { + "message": {"type": "string", "description": "Notification text, one plain sentence or two."}, + "level": { + "type": "string", + "enum": ["info", "warning", "intervention"], + "description": "info: FYI. warning: something went wrong / degraded. intervention: the user's decision is needed now.", + }, + }, + "required": ["message"], + } + + async def execute(self, params: dict, ctx: ToolContext | None = None) -> ToolResult: + user_id = ctx.user_id if ctx is not None else current_user_id.get(None) + if user_id is None: + return ToolResult( + success=False, output="", + error="No user context — cannot address a notification.", + ) + message = (params.get("message") or "").strip() + if not message: + return ToolResult(success=False, output="", error="Empty notification text.") + level = params.get("level") or "info" + if level not in _LEVEL_TO_PRIORITY: + return ToolResult( + success=False, output="", + error=f"Unknown level '{level}': info, warning, intervention.", + ) + session_id = ctx.session_id if ctx is not None else current_session_id.get() + + delivered: list[str] = [] + skipped: list[str] = [] + + settings_row = await SynapseSettingsStore(self._store_pool()).get(user_id) + push_target = settings_row.push_target + + if push_target in ("app", "app_synapse"): + push_service = self._push_service() + if push_service is not None and push_service.enabled: + try: + await push_service.notify_custom( + session_id or "", user_id, + title=_title_for(level), + body=message, + ) + delivered.append("app") + except Exception as e: + skipped.append(f"app ({e})") + else: + skipped.append("app (web push not configured)") + + if push_target in ("app_synapse", "synapse"): + from navi.synapse.outbound import emit_low_level, synapse_source_ready + + if synapse_source_ready(): + try: + from navi.synapse.outbound import emit_low_level + + await emit_low_level( + subject="navi-notification", + action=level, + payload={ + "session_id": session_id, + "user_id": user_id, + "message": message, + }, + priority=_LEVEL_TO_PRIORITY[level], + dedup_key=f"notify:{session_id}:{abs(hash(message)) % 10**10}", + ) + delivered.append("synapse") + except Exception as e: + skipped.append(f"synapse ({e})") + else: + skipped.append("synapse (source key not configured)") + + parts = [] + if delivered: + parts.append("Delivered: " + ", ".join(delivered) + ".") + if skipped: + parts.append("Skipped: " + "; ".join(skipped) + ".") + return ToolResult(success=True, output=" ".join(parts)) + + def _store_pool(self): + from navi.api.deps import get_session_store + + return get_session_store()._get_pool() + + @staticmethod + def _push_service(): + try: + from navi.api.deps import get_push_service + + return get_push_service() + except Exception: + return None + + +def _title_for(level: str) -> str: + return { + "info": "Navi: уведомление", + "warning": "Navi: предупреждение", + "intervention": "Navi: нужно ваше решение", + }[level] \ No newline at end of file diff --git a/navi/tools/switch_profile.py b/navi/tools/switch_profile.py index 2baa39c..65666aa 100644 --- a/navi/tools/switch_profile.py +++ b/navi/tools/switch_profile.py @@ -29,7 +29,8 @@ async def execute(self, params: dict, ctx: ToolContext | None = None) -> ToolResult: profile_id = (params.get("profile_id") or "").strip() - available = ", ".join(p.id for p in self._profiles.all()) + visible = [p for p in self._profiles.all() if not getattr(p, "is_hidden", False)] + available = ", ".join(p.id for p in visible) try: profile = self._profiles.get(profile_id) @@ -40,6 +41,13 @@ error=f"Profile '{profile_id}' not found. Available: {available}", ) + if getattr(profile, "is_hidden", False): + return ToolResult( + success=False, + output=f"Profile '{profile_id}' is an internal role and not switchable. Available: {available}", + error="hidden_profile", + ) + if getattr(profile, "is_subagent_only", False): return ToolResult( success=False, diff --git a/navi/tools/synapse_instructions.py b/navi/tools/synapse_instructions.py new file mode 100644 index 0000000..7d5c9d0 --- /dev/null +++ b/navi/tools/synapse_instructions.py @@ -0,0 +1,90 @@ +"""Reaction instructions tool — read / update the per-user Synapse reaction rules. + +The instructions are the standing contract between the user and the reaction +system: which events to react to, which profile to route them to, what to do. +Navi may refine this document through this tool (self-improvement); every edit +is recorded with edited_by='navi' in the version history. +""" + +from navi.synapse.settings_store import SynapseSettingsStore +from navi.tools._internal.base import Tool, ToolContext, ToolResult, current_user_id + + +class SynapseInstructionsTool(Tool): + name = "synapse_instructions" + description = ( + "Read or update the user's Synapse reaction instructions — the standing rules " + "describing which platform events Navi reacts to and how. Read them before " + "acting on Synapse events; update them only when a change is clearly wanted " + "and explained (the user reviews the edit history)." + ) + parameters = { + "type": "object", + "properties": { + "op": { + "type": "string", + "enum": ["read", "update"], + "description": "read: return the current document. update: replace it with `content`.", + }, + "content": { + "type": "string", + "description": "update only: the FULL new text of the instructions document.", + }, + "reason": { + "type": "string", + "description": "update only: one sentence explaining why you are changing the rules.", + }, + }, + "required": ["op"], + } + + def __init__(self, pool_provider=None) -> None: + self._pool_provider = pool_provider + + async def execute(self, params: dict, ctx: ToolContext | None = None) -> ToolResult: + user_id = ctx.user_id if ctx is not None else current_user_id.get(None) + if user_id is None: + return ToolResult( + success=False, output="", + error="No user context — reaction instructions are per-user.", + ) + + if not callable(self._pool_provider): + return ToolResult( + success=False, output="", + error="Reaction settings storage is not available (no pool).", + ) + store = SynapseSettingsStore(self._pool_provider()) + settings_row = await store.get(user_id) + + op = params.get("op", "read") + if op == "read": + body = settings_row.instructions.strip() + if not body: + return ToolResult( + success=True, + output="The reaction instructions document is empty — no reactions are configured yet.", + ) + return ToolResult(success=True, output=body) + + if op != "update": + return ToolResult(success=False, output="", error=f"Unknown op '{op}'.") + + content = (params.get("content") or "").strip() + if not content: + return ToolResult( + success=False, output="", + error="update requires non-empty `content` — use the full new text of the document.", + ) + reason = (params.get("reason") or "").strip() + await store.save_instructions( + user_id, content, edited_by="navi", reason=reason or None, + ) + return ToolResult( + success=True, + output=( + "Instructions updated and recorded in the edit history" + + (f" ({reason})" if reason else "") + + ". The change applies to future Synapse reactions." + ), + ) \ No newline at end of file diff --git a/navi/tools/tasks.py b/navi/tools/tasks.py index 12798a7..76fb53d 100644 --- a/navi/tools/tasks.py +++ b/navi/tools/tasks.py @@ -98,7 +98,38 @@ if action == "cancel": if manager.cancel(job): - return ToolResult(success=True, output=f"Task {job.task_id} cancelled.") + # cancel() only *requests* cancellation: the task may have + # been one step from finishing and complete normally anyway. + # Wait (bounded) for the terminal state so the agent gets the + # real outcome rather than an optimistic "cancelled". + try: + await asyncio.wait_for(job.done.wait(), timeout=2.0) + except (asyncio.TimeoutError, TimeoutError): + return ToolResult( + success=True, + output=( + f"Task {job.task_id}: cancellation requested " + f"(still finishing). Use tasks check to see the outcome." + ), + ) + if job.status == "cancelled": + return ToolResult(success=True, + output=f"Task {job.task_id} cancelled.") + # Terminal but not cancelled: the job completed before the + # cancellation could land — show its real result. + return ToolResult( + success=False, + output=self._render_check(job), + error="not_running", + ) + if job.task is not None and job.task.done(): + # cancel() lost the race — the job finished right under us; + # show its real result instead of a stale "running" status. + return ToolResult( + success=False, + output=self._render_check(job), + error="not_running", + ) return ToolResult( success=False, output=f"Task {job.task_id} is not running (status: {job.status}).", diff --git a/navi/tools/test_mcp_tool.py b/navi/tools/test_mcp_tool.py index 80eb4d0..00ff419 100644 --- a/navi/tools/test_mcp_tool.py +++ b/navi/tools/test_mcp_tool.py @@ -2,7 +2,7 @@ import asyncio -from ._internal.base import Tool, ToolContext, ToolResult +from ._internal.base import Tool, ToolContext, ToolResult, current_user_id class TestMcpToolTool(Tool): @@ -13,7 +13,9 @@ "Returns the raw output and whether the tool reported an error. " "Always use this after writing or editing an MCP server to verify " "each tool works before reporting success to the user. " - "Do NOT use mcp_status for testing individual tools — mcp_status is for discovery only." + "Do NOT use mcp_status for testing individual tools — mcp_status is for discovery only. " + "For servers with a per-user key slot (BYOK), the call runs on the " + "current user's saved key — test results reflect what this user sees." ) parameters = { "type": "object", @@ -81,8 +83,11 @@ ) try: + uid = ctx.user_id if ctx else None + if uid is None: + uid = current_user_id.get() output, is_error = await asyncio.wait_for( - manager.call_tool(server_name, tool_name, arguments), + manager.call_tool(server_name, tool_name, arguments, user_id=uid), timeout=30.0, ) except asyncio.TimeoutError: diff --git a/pyproject.toml b/pyproject.toml index 45f29dd..cd1ae7a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,6 +41,10 @@ "gnexus-gauth @ git+https://git.gnexus.space/root/gnexus-auth-client-py.git", "cryptography>=42", + # Synapse notification hub — client lib (ingest + s2s webhook verification). + # Only the receiving half is used today: no outbound events per user decision. + "gnexus-synapse @ git+https://git.gnexus.space/root/gn-synapse-client-py.git@v0.1.2", + # MCP (Model Context Protocol). v2 renamed FastMCP → MCPServer with # breaking API changes — pin to v1 until navi/mcp is migrated. "mcp>=1.27,<2", diff --git a/tests/integration/test_api_routes.py b/tests/integration/test_api_routes.py index c3e310e..710eb23 100644 --- a/tests/integration/test_api_routes.py +++ b/tests/integration/test_api_routes.py @@ -10,8 +10,14 @@ response = client.get("/health") assert response.status_code == 200 data = response.json() - assert data["status"] == "ok" - assert "embed" in data + # Aggregate of the sub-checks (worst of: degraded > ok) — in a bare + # test environment the embed backend may not be reachable, so both + # outcomes are legal for the aggregate. + assert data["status"] in ("ok", "degraded") + assert data["service"] == "navi" + statuses = [c["status"] for c in data["checks"].values()] + assert data["status"] == ("degraded" if "degraded" in statuses else "ok") + assert "embed" in data # legacy top-level payload kept def test_health_embed(self, client): response = client.get("/health/embed") @@ -238,6 +244,17 @@ assert response.status_code == 404 @pytest.mark.anyio + async def test_rename_session(self, client, make_session): + session = await make_session("secretary") + response = client.patch(f"/sessions/{session.id}/name", json={"name": " My title "}) + assert response.status_code == 200 + assert response.json()["name"] == "My title" + + def test_rename_session_not_found(self, client): + response = client.patch("/sessions/nonexistent/name", json={"name": "x"}) + assert response.status_code == 404 + + @pytest.mark.anyio async def test_get_context(self, client, make_session, mock_deps): session = await make_session("secretary", [Message(role="user", content="hello")]) session.context.append(Message(role="user", content="hello")) diff --git a/tests/integration/test_auth_disabled.py b/tests/integration/test_auth_disabled.py index 8ab45ea..0a0f0bb 100644 --- a/tests/integration/test_auth_disabled.py +++ b/tests/integration/test_auth_disabled.py @@ -110,7 +110,8 @@ session = await store.get(data["session_id"]) assert session is not None - assert session.user_id == "anonymous" + # Local mode: sessions belong to the NULL owner, not to a user alias. + assert session.user_id is None @pytest.mark.anyio async def test_list_sessions_without_auth(self, no_auth_client): @@ -124,6 +125,35 @@ assert any(s["session_id"] == session_id for s in sessions) @pytest.mark.anyio + async def test_local_mode_never_lists_other_users_sessions(self, no_auth_client): + """Local mode is a separate user with user_id NULL — chats owned by + real users must not appear in the sidebar.""" + client, store = no_auth_client + # Another user's session, as on a shared database. + foreign = await store.create("secretary", user_id="1") + # Our own (NULL-owner) session. + resp = client.post("/sessions", json={"profile_id": "secretary"}) + own_id = resp.json()["session_id"] + + response = client.get("/sessions") + assert response.status_code == 200 + ids = [s["session_id"] for s in response.json()] + assert own_id in ids + assert foreign.id not in ids + + # Direct access by id is denied too (check_session_access). + foreign_resp = client.get(f"/sessions/{foreign.id}") + assert foreign_resp.status_code == 403 + + @pytest.mark.anyio + async def test_local_mode_can_open_legacy_null_owner_session(self, no_auth_client): + client, store = no_auth_client + legacy = await store.create("secretary", user_id=None) + + response = client.get(f"/sessions/{legacy.id}") + assert response.status_code == 200 + + @pytest.mark.anyio async def test_create_session_uses_default_profile(self, monkeypatch, no_auth_client): """When navi_default_profile_id is set, POST /sessions with no body uses it.""" import navi.config as _config diff --git a/tests/unit/api/test_health.py b/tests/unit/api/test_health.py new file mode 100644 index 0000000..a16308f --- /dev/null +++ b/tests/unit/api/test_health.py @@ -0,0 +1,73 @@ +"""Health endpoint contract tests (handbook 10-platform/health.md).""" + +from unittest.mock import AsyncMock + +import pytest +from fastapi.testclient import TestClient + +import navi.api.routes.health as health_mod +from navi.config import Settings + + +@pytest.fixture +def health_client(monkeypatch): + new_settings = Settings(_env_file=None, navi_persona_file="", hive_url="") + monkeypatch.setattr(health_mod, "settings", new_settings) + from navi.main import app + + return TestClient(app) + + +@pytest.fixture(autouse=True) +def _fresh_embed_cache(): + health_mod._embed_cache["checked_at"] = 0.0 + health_mod._embed_cache["result"] = None + yield + + +def test_health_ok_when_all_checks_pass(health_client, monkeypatch): + monkeypatch.setattr( + health_mod, "_check_embed", + AsyncMock(return_value={"ok": True, "backend": "ollama:11434", "error": None}), + ) + resp = health_client.get("/health") + assert resp.status_code == 200 + body = resp.json() + assert body["status"] == "ok" + assert body["service"] == "navi" + assert body["checks"]["embed"]["status"] == "ok" + assert body["checks"]["hive"]["status"] == "ok" + + +def test_health_degraded_when_embed_fails(health_client, monkeypatch): + monkeypatch.setattr( + health_mod, "_check_embed", + AsyncMock(return_value={"ok": False, "backend": "none", "error": "connection refused"}), + ) + body = health_client.get("/health").json() + assert body["status"] == "degraded" + assert body["checks"]["embed"]["status"] == "degraded" + assert body["checks"]["embed"]["detail"] == "connection refused" + + +def test_health_keeps_legacy_embed_payload(health_client, monkeypatch): + """The pre-contract top-level `embed` dict must survive for existing tooling.""" + monkeypatch.setattr( + health_mod, "_check_embed", + AsyncMock(return_value={"ok": True, "backend": "ollama:11434", "error": None}), + ) + body = health_client.get("/health").json() + assert body["embed"]["ok"] is True + assert body["embed"]["backend"] == "ollama:11434" + + +def test_embed_check_is_cached(health_client, monkeypatch): + check = AsyncMock(return_value={"ok": True, "backend": "x", "error": None}) + monkeypatch.setattr(health_mod, "_check_embed", check) + + first = health_client.get("/health").json() + second = health_client.get("/health").json() + + assert check.await_count == 1 # second poll was served from cache + assert first["checks"]["embed"] == second["checks"]["embed"] + assert isinstance(first["checks"]["embed"]["ms"], int) \ No newline at end of file diff --git a/tests/unit/api/test_mcp_keys.py b/tests/unit/api/test_mcp_keys.py new file mode 100644 index 0000000..4563847 --- /dev/null +++ b/tests/unit/api/test_mcp_keys.py @@ -0,0 +1,189 @@ +"""Per-user MCP keys REST — GET filter, PUT/DELETE round-trip.""" + +from datetime import datetime, timezone +from unittest.mock import AsyncMock, MagicMock + +import pytest +from fastapi.testclient import TestClient + +from navi.config import Settings +from navi.mcp.config import McpServerConfig, McpUserKey + + +@pytest.fixture +def mcp_keys_client(monkeypatch): + """Anonymous-admin test client with faked configs and key store pool.""" + import types + + import navi.api.routes.mcp_keys as keys_mod + import navi.auth.deps as auth_deps + import navi.mcp.config as cfg_mod + from navi.main import app + + # Anonymous admin (auth disabled) — routes resolve without a cookie. + monkeypatch.setattr( + auth_deps, "settings", + Settings(_env_file=None, navi_persona_file="", navi_auth_enabled=False), + ) + monkeypatch.setattr(keys_mod, "_pool", AsyncMock(return_value=MagicMock())) + + # Four servers: two eligible (http-header, stdio-env), one eligible but + # not referenced by any profile, one without a user_key slot. + cfgs = { + "http-server": McpServerConfig( + transport="streamable_http", + url="https://http", + headers={"Authorization": "Bearer default"}, + user_key=McpUserKey(header="Authorization", prefix="Bearer "), + ), + "stdio-server": McpServerConfig( + transport="stdio", + command="uvx", + env={"API_KEY": "default"}, + user_key=McpUserKey(env="API_KEY"), + ), + "unreferenced": McpServerConfig( + transport="sse", + url="https://unref", + user_key=McpUserKey(header="Authorization"), + ), + "no-slider": McpServerConfig(transport="sse", url="https://plain"), + } + monkeypatch.setattr(cfg_mod, "load_mcp_servers", lambda path=None: cfgs) + + profile = types.SimpleNamespace( + tools=types.SimpleNamespace( + agent=types.SimpleNamespace(mcp={"http-server": [], "stdio-server": []}), + subagent=types.SimpleNamespace(mcp={}), + ) + ) + + class _Registry: + def all(self): + return [profile] + + import navi.api.deps as deps_mod + + monkeypatch.setattr(deps_mod, "get_profile_registry", lambda: _Registry()) + + return TestClient(app) + + +def test_get_returns_only_keyed_referenced_servers(mcp_keys_client, monkeypatch): + import navi.mcp.keystore as keystore_mod + + store = MagicMock() + store.list_servers = AsyncMock(return_value={}) + monkeypatch.setattr(keystore_mod, "McpKeyStore", MagicMock(return_value=store)) + + data = mcp_keys_client.get("/mcp-keys").json() + names = [i["server_name"] for i in data["items"]] + assert names == ["http-server", "stdio-server"] + by_name = {i["server_name"]: i for i in data["items"]} + assert by_name["http-server"]["key_type"] == "header" + assert by_name["http-server"]["key_location"] == "Authorization" + assert by_name["http-server"]["prefix"] == "Bearer " + assert by_name["http-server"]["has_key"] is False + assert by_name["http-server"]["updated_at"] is None + assert by_name["stdio-server"]["key_type"] == "env" + # The key value itself is never present anywhere in the response. + assert "default" not in mcp_keys_client.get("/mcp-keys").text + + +def test_get_empty_when_no_keyed_servers(mcp_keys_client, monkeypatch): + import navi.mcp.config as cfg_mod + + monkeypatch.setattr( + cfg_mod, "load_mcp_servers", + lambda path=None: {"no-slider": McpServerConfig(transport="sse", url="https://x")}, + ) + assert mcp_keys_client.get("/mcp-keys").json() == {"items": []} + + +def test_get_lists_saved_key_presence(mcp_keys_client, monkeypatch): + import navi.mcp.keystore as keystore_mod + + ts = datetime(2026, 10, 7, tzinfo=timezone.utc) + store = MagicMock() + store.list_servers = AsyncMock(return_value={"http-server": ts}) + monkeypatch.setattr(keystore_mod, "McpKeyStore", MagicMock(return_value=store)) + + data = mcp_keys_client.get("/mcp-keys").json() + by_name = {i["server_name"]: i for i in data["items"]} + assert by_name["http-server"]["has_key"] is True + assert by_name["http-server"]["updated_at"] == ts.isoformat() + assert by_name["stdio-server"]["has_key"] is False + + +class TestPut: + def test_save_and_invalidate(self, mcp_keys_client, monkeypatch): + import navi.mcp.keystore as keystore_mod + + store = MagicMock() + store = MagicMock() + store.set = AsyncMock(return_value=datetime(2026, 10, 7, tzinfo=timezone.utc)) + invalidated: list = [] + + class FakeResolver: + def invalidate(self, user_id, server_name): + invalidated.append((user_id, server_name)) + + monkeypatch.setattr(keystore_mod, "McpKeyStore", MagicMock(return_value=store)) + monkeypatch.setattr(keystore_mod, "get_key_resolver", lambda: FakeResolver()) + + resp = mcp_keys_client.put("/mcp-keys/http-server", json={"key": "sk-user"}) + assert resp.status_code == 200 + body = resp.json() + assert body["server_name"] == "http-server" + assert body["has_key"] is True + store.set.assert_awaited_once() + # key passed stripped, value never logged in the response + assert store.set.await_args.args[2] == "sk-user" + assert "sk-user" not in resp.text + assert len(invalidated) == 1 + + def test_save_404_on_unknown_server(self, mcp_keys_client): + resp = mcp_keys_client.put("/mcp-keys/nope", json={"key": "sk"}) + assert resp.status_code == 404 + + def test_save_404_on_keyless_server(self, mcp_keys_client): + resp = mcp_keys_client.put("/mcp-keys/no-slider", json={"key": "sk"}) + assert resp.status_code == 404 + + def test_save_422_on_empty_key(self, mcp_keys_client): + resp = mcp_keys_client.put("/mcp-keys/http-server", json={"key": ""}) + assert resp.status_code == 422 + + +class TestDelete: + def test_delete_204(self, mcp_keys_client, monkeypatch): + import navi.mcp.keystore as keystore_mod + + store = MagicMock() + store.delete = AsyncMock(return_value=True) + invalidated: list = [] + + class FakeResolver: + def invalidate(self, user_id, server_name): + invalidated.append((user_id, server_name)) + + monkeypatch.setattr(keystore_mod, "McpKeyStore", MagicMock(return_value=store)) + monkeypatch.setattr(keystore_mod, "get_key_resolver", lambda: FakeResolver()) + + resp = mcp_keys_client.delete("/mcp-keys/http-server") + assert resp.status_code == 204 + assert len(invalidated) == 1 + + def test_missing_key_is_still_204(self, mcp_keys_client, monkeypatch): + import navi.mcp.keystore as keystore_mod + + store = MagicMock() + store.delete = AsyncMock(return_value=False) + monkeypatch.setattr(keystore_mod, "McpKeyStore", MagicMock(return_value=store)) + + resp = mcp_keys_client.delete("/mcp-keys/http-server") + assert resp.status_code == 204 + + def test_delete_404_on_unknown_server(self, mcp_keys_client): + resp = mcp_keys_client.delete("/mcp-keys/nope") + assert resp.status_code == 404 \ No newline at end of file diff --git a/tests/unit/api/test_session_tasks_route.py b/tests/unit/api/test_session_tasks_route.py new file mode 100644 index 0000000..081ae0a --- /dev/null +++ b/tests/unit/api/test_session_tasks_route.py @@ -0,0 +1,98 @@ +"""Unit tests for the GET /sessions/{id}/tasks background-task list endpoint.""" + +import asyncio + +import pytest +from fastapi import HTTPException + +import navi.api.routes.sessions as sessions_mod +from navi.auth import User +from navi.core import tasks as tasks_mod +from navi.core.session import InMemorySessionStore +from navi.core.tasks import TaskManager +from navi.tools._internal.base import ToolContext, ToolResult + + +_FAKE_USER = User(id="test-user", email="test@example.com", display_name="Test", + role="admin", permissions=[]) + + +@pytest.fixture(autouse=True) +def fresh_manager(monkeypatch): + manager = TaskManager() + monkeypatch.setattr(tasks_mod, "_manager", manager) + yield manager + for job in list(manager._jobs.values()): + if job.task is not None and not job.task.done(): + job.task.cancel() + + +@pytest.fixture +async def store(): + session_store = InMemorySessionStore() + await session_store.create("secretary") + return session_store + + +def make_ctx(session_id): + return ToolContext( + session_id=session_id, event_sink=None, stop_event=None, model=None, + user_id=None, user_role="admin", user_info=None, cwd=None, + ) + + +async def _session_id(store: InMemorySessionStore) -> str: + sessions = await store.list_all() + return sessions[0].id + + +class TestListSessionTasks: + async def test_lists_jobs_with_summary(self, fresh_manager, store): + session_id = await _session_id(store) + + async def factory(bg_ctx): + await asyncio.sleep(30) + + job = fresh_manager.submit( + session_id, "terminal", + {"action": "run", "command": "sleep 60", "background": True}, + factory, make_ctx(session_id), + ) + result = await sessions_mod.list_session_tasks(session_id, store, _FAKE_USER) + fresh_manager.cancel(job) + + assert result["session_id"] == session_id + assert len(result["tasks"]) == 1 + task = result["tasks"][0] + assert task["task_id"] == job.task_id + assert task["tool"] == "terminal" + assert task["status"] == "running" + assert "sleep 60" in task["args_summary"] + # background flag must be stripped in the summary args + assert task["parent_tool_call_id"] is None + assert task["result_preview"] == "" or task["result_preview"] is None + + async def test_session_scoped_and_shows_finished(self, fresh_manager, store): + session_id = await _session_id(store) + + async def factory(bg_ctx): + return ToolResult(success=True, output="done 42") + + job = fresh_manager.submit( + session_id, "code_exec", {"code": "x"}, factory, make_ctx(session_id)) + other = fresh_manager.submit( + "other-session", "code_exec", {"code": "y"}, factory, make_ctx("other-session")) + await job.done.wait() + await other.done.wait() + + result = await sessions_mod.list_session_tasks(session_id, store, _FAKE_USER) + assert [t["task_id"] for t in result["tasks"]] == [job.task_id] + task = result["tasks"][0] + assert task["status"] == "completed" + assert "done 42" in task["result_preview"] + assert task["finished_at"] is not None + + async def test_unknown_session_404(self, fresh_manager, store): + with pytest.raises(HTTPException) as exc: + await sessions_mod.list_session_tasks("nope", store, _FAKE_USER) + assert exc.value.status_code == 404 \ No newline at end of file diff --git a/tests/unit/api/test_synapse.py b/tests/unit/api/test_synapse.py new file mode 100644 index 0000000..20b7a6b --- /dev/null +++ b/tests/unit/api/test_synapse.py @@ -0,0 +1,312 @@ +"""Synapse s2s gateway tests — signature verification and target CRUD.""" + +import json +from unittest.mock import AsyncMock, MagicMock + +import pytest +from fastapi.testclient import TestClient + +from navi.config import Settings + +S2S_SECRET = "s2s-target-secret-0123456789" + + +@pytest.fixture +def synapse_client(monkeypatch): + import navi.api.routes.synapse as synapse_mod + import navi.auth.deps as auth_deps + import navi.synapse.reactions as reactions + + # Anonymous admin (auth disabled) — CRUD routes resolve without a cookie. + monkeypatch.setattr( + auth_deps, "settings", + Settings(_env_file=None, navi_persona_file="", navi_auth_enabled=False), + ) + monkeypatch.setattr(synapse_mod, "_pool", AsyncMock(return_value=MagicMock())) + + # Don't spawn real reaction runs from tests; collect the calls instead. + reactions_scheduled: list = [] + monkeypatch.setattr( + reactions, "schedule_reaction", + lambda envelope, user_id, event_type: reactions_scheduled.append( + (envelope, user_id, event_type) + ), + ) + + from navi.main import app + + client = TestClient(app) + client.reactions_scheduled = reactions_scheduled + return client + + +def _target(**overrides): + target = {"id": 1, "user_id": "u1", "token_ref": "tgt-1", "secret": S2S_SECRET} + target.update(overrides) + return target + + +def _sign(body: bytes, secret: str = S2S_SECRET): + from gnexus_synapse import make_signature + + return {"X-Gnexus-Signature": make_signature(body, secret), + "X-Gnexus-Event-Type": "gntodo.task.created"} + + +def _post(tc: TestClient, url: str, body: dict, secret: str = S2S_SECRET): + raw = json.dumps(body).encode() + return tc.post(url, content=raw, headers=_sign(raw, secret)) + + +def test_synapse_delivery_503_without_targets(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[]), + ) + envelope = {"event_id": "e1", "subject": "topic", "action": "done"} + resp = _post(synapse_client, "/webhooks/synapse", envelope) + assert resp.status_code == 503 + + +def test_synapse_delivery_401_on_foreign_secret(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + envelope = {"event_id": "e2", "subject": "topic", "action": "done"} + resp = _post(synapse_client, "/webhooks/synapse", envelope, secret="wrong-secret-0123") + assert resp.status_code == 401 + + +def test_synapse_delivery_401_on_broken_json(synapse_client, monkeypatch): + """A correctly signed non-JSON body must not leak a 500 — it is a 401.""" + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + resp = synapse_client.post( + "/webhooks/synapse", content=b"not-json{", headers=_sign(b"not-json{"), + ) + assert resp.status_code == 401 + + +def test_synapse_delivery_200_and_both_spellings(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + envelope = { + "event_id": "e3", "subject": "task", "action": "completed", + "payload": {"user_id": "u1"}, "source": "gntodo", + } + client = synapse_client + resp = _post(client, "/webhooks/synapse", envelope) + assert resp.status_code == 200 + assert resp.json() == {"received": True, "event_id": "e3"} + + resp_slash = _post(client, "/webhooks/synapse/", envelope) + assert resp_slash.status_code == 200 + + +def test_synapse_duplicate_delivery_acknowledged_once(synapse_client, monkeypatch): + """A replayed event id is acked again but only marked once.""" + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + synapse_mod._seen_events.clear() + + envelope = {"event_id": "e4", "subject": "t", "action": "a"} + client = synapse_client + first = _post(client, "/webhooks/synapse", envelope) + assert first.status_code == 200 + + second = _post(client, "/webhooks/synapse", envelope) + assert second.status_code == 200 + assert synapse_mod._seen_events["e4"] is True + + +def test_synapse_delivery_schedules_reaction(synapse_client, monkeypatch): + """A fresh, verified delivery hands the envelope to the reaction layer.""" + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + synapse_mod._seen_events.clear() + + envelope = { + "event_id": "e9", "subject": "task", "action": "created", + "payload": {"user_id": "u1"}, "source": "gntodo", + } + resp = _post(synapse_client, "/webhooks/synapse", envelope) + assert resp.status_code == 200 + + assert synapse_client.reactions_scheduled == [( + envelope, "u1", "gntodo.task.created", + )] + + +def test_synapse_replayed_delivery_skips_reaction(synapse_client, monkeypatch): + """A replayed event id is acked again but does not react twice.""" + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod.SynapseTargetStore, "active_secrets", + AsyncMock(return_value=[_target()]), + ) + synapse_mod._seen_events.clear() + + envelope = {"event_id": "e10", "subject": "t", "action": "a"} + first = _post(synapse_client, "/webhooks/synapse", envelope) + second = _post(synapse_client, "/webhooks/synapse", envelope) + assert first.status_code == second.status_code == 200 + assert len(synapse_client.reactions_scheduled) == 1 + + +def test_synapse_target_crud(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + import navi.synapse.store as store_mod + + created = MagicMock( + id=7, token_ref="tgt-9", + created_at=__import__("datetime").datetime(2026, 10, 7, 12, 0, 0), + ) + monkeypatch.setattr(store_mod.SynapseTargetStore, "create", AsyncMock(return_value=created)) + monkeypatch.setattr(store_mod.SynapseTargetStore, "list_for_user", AsyncMock(return_value=[created])) + monkeypatch.setattr(store_mod.SynapseTargetStore, "revoke", AsyncMock(return_value=True)) + + client = synapse_client + created_resp = client.post( + "/synapse-targets", + json={"token_ref": "tgt-9", "secret": S2S_SECRET}, + ) + assert created_resp.status_code == 200 + assert created_resp.json()["token_ref"] == "tgt-9" + + listed = client.get("/synapse-targets") + assert listed.status_code == 200 + assert listed.json()["items"][0]["token_ref"] == "tgt-9" + + revoked = client.delete("/synapse-targets/7") + assert revoked.status_code == 204 + + +def test_synapse_settings_get_defaults(synapse_client, monkeypatch): + """No row yet — the endpoint returns the defaults, not a 500.""" + import navi.api.routes.synapse as synapse_mod + from navi.synapse.settings_store import SynapseSettings + + async def fake_get(self, user_id): + return SynapseSettings(user_id=user_id) + + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "get", fake_get) + + resp = synapse_client.get("/synapse-settings") + assert resp.status_code == 200 + body = resp.json() + assert body["reactions_enabled"] is False + assert body["push_target"] == "app" + assert body["completion_notify"] == "important" + assert body["instructions"] == "" + # tells the UI whether Synapse-linked options are usable (no keys in tests) + assert body["source_ready"] is False + + +def test_synapse_settings_put_records_user_edit(synapse_client, monkeypatch): + """Changing instructions via PUT stores an edited_by='user' version.""" + import navi.api.routes.synapse as synapse_mod + from navi.synapse.settings_store import SynapseSettings + + current = SynapseSettings(user_id="u1", instructions="") + saved_instructions: list = [] + + async def fake_get(self, user_id): + return current + + async def fake_save_instructions(self, user_id, content, edited_by, reason=None): + saved_instructions.append((content, edited_by, reason)) + current.instructions = content + + async def fake_save(self, settings_obj): + pass + + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "get", fake_get) + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "save_instructions", fake_save_instructions) + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "save", fake_save) + + resp = synapse_client.put( + "/synapse-settings", + json={ + "reactions_enabled": True, + "push_target": "app_synapse", + "completion_notify": "always", + "instructions": "Тот, кто приходит от gntodo, отвечает.", + }, + ) + assert resp.status_code == 200 + assert resp.json()["reactions_enabled"] is True + assert saved_instructions == [( + "Тот, кто приходит от gntodo, отвечает.", "user", None + )] + + +def test_synapse_settings_put_same_instructions_skips_version(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + from navi.synapse.settings_store import SynapseSettings + + current = SynapseSettings(user_id="u1") + + async def fake_get(self, user_id): + return current + + async def fake_save_instructions(self, *args, **kwargs): + raise AssertionError("unchanged instructions must not record a version") + + async def fake_save(self, settings_obj): + pass + + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "get", fake_get) + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "save_instructions", fake_save_instructions) + monkeypatch.setattr(synapse_mod.SynapseSettingsStore, "save", fake_save) + + resp = synapse_client.put( + "/synapse-settings", + json={ + "reactions_enabled": False, + "push_target": "app", + "completion_notify": "never", + "instructions": "", + }, + ) + assert resp.status_code == 200 + + +def test_synapse_settings_validation(synapse_client, monkeypatch): + import navi.api.routes.synapse as synapse_mod + + monkeypatch.setattr( + synapse_mod, "_pool", AsyncMock(return_value=MagicMock()) + ) + + resp = synapse_client.put( + "/synapse-settings", + json={ + "reactions_enabled": True, + "push_target": "carrier_pigeon", + "completion_notify": "always", + "instructions": "", + }, + ) + assert resp.status_code == 422 diff --git a/tests/unit/api/test_webhooks.py b/tests/unit/api/test_webhooks.py index 5103033..0ef46fa 100644 --- a/tests/unit/api/test_webhooks.py +++ b/tests/unit/api/test_webhooks.py @@ -180,4 +180,53 @@ resp = _post(tc, json.dumps({"type": "user.blocked", "target": {"user_id": "u9"}})) assert resp.status_code == 200 assert resp.json() == {"ok": True} - invalidate.assert_awaited_once_with("u9") \ No newline at end of file + invalidate.assert_awaited_once_with("u9") + +def test_webhook_updates_profile_mirror(webhook_client, monkeypatch): + """user.profile_updated updates navi_users via _update_user_profile.""" + tc, _ = webhook_client + body = json.dumps({ + "type": "user.profile_updated", + "target": {"user_id": "u1"}, + "data": { + "user": {"id": "u1"}, + "changed_fields": ["display_name", "avatar"], + "profile": { + "display_name": "New Name", + "avatar_url": "https://auth.test/files/avatar.png", + "locale": "ru", + }, + }, + }) + headers = _sign(body) + headers["x-gnexus-event-type"] = "user.profile_updated" + + update_profile = AsyncMock() + monkeypatch.setattr("navi.api.routes.webhooks._update_user_profile", update_profile) + + resp = _post(tc, body, headers) + assert resp.status_code == 200 + assert resp.json() == {"ok": True} + update_profile.assert_awaited_once_with( + "u1", + {"display_name": "New Name", "avatar_url": "https://auth.test/files/avatar.png", "locale": "ru"}, + ) + + +def test_webhook_ignores_profile_update_without_profile(webhook_client, monkeypatch): + """profile_updated without a usable profile must not touch the mirror.""" + tc, _ = webhook_client + body = json.dumps({ + "type": "user.profile_updated", + "target": {"user_id": "u1"}, + "data": {"user": {"id": "u1"}}, + }) + headers = _sign(body) + headers["x-gnexus-event-type"] = "user.profile_updated" + + update_profile = AsyncMock() + monkeypatch.setattr("navi.api.routes.webhooks._update_user_profile", update_profile) + + resp = _post(tc, body, headers) + assert resp.status_code == 200 + update_profile.assert_not_awaited() diff --git a/tests/unit/api/test_websocket.py b/tests/unit/api/test_websocket.py index 4851791..ebb1ca4 100644 --- a/tests/unit/api/test_websocket.py +++ b/tests/unit/api/test_websocket.py @@ -29,7 +29,9 @@ @pytest.fixture def mock_session(): session = MagicMock() - session.user_id = "test-user-id" + # user_id=None = legacy/local-owned session (deps.settings may carry + # env-derived NAVI_AUTH_ENABLED=false in unit runs; NULL owner passes). + session.user_id = None return session @@ -631,3 +633,66 @@ if state and state.run: state.run = None orchestrator._sessions.pop("s1", None) + + +# ── Two-tab visibility (B5) and stranded queue (B4) ────────────────────────── + + +@pytest.mark.anyio +async def test_run_marks_owner_socket(mock_websocket, mock_user, monkeypatch): + """The run-owning socket is recorded so teardown excludes it from rebroadcasts.""" + orchestrator = AgentSessionOrchestrator(MagicMock()) + monkeypatch.setattr(orchestrator, "run_agent", AsyncMock()) + monkeypatch.setattr(ws_mod, "_stream_to_client", AsyncMock(return_value=True)) + + connected, ran = await ws_mod._run_single_message( + session_id="s1", user_content="hi", raw_images=None, + display_content=None, uploaded_files=[], hidden=False, + websocket=mock_websocket, orchestrator=orchestrator, + session_store=MagicMock(), user=mock_user, + ) + assert connected is True and ran is True + run = orchestrator.get_run("s1") + assert run is not None + assert run.owner_socket is mock_websocket + + +@pytest.mark.anyio +async def test_broadcast_session_sync_reaches_other_tabs_only(mock_websocket, mock_user, monkeypatch): + """Watchers reload via session_sync; the excluded (owner) socket does not.""" + orchestrator = AgentSessionOrchestrator(MagicMock()) + other = AsyncMock() + orchestrator.add_websocket("s1", mock_websocket) + orchestrator.add_websocket("s1", other) + + orchestrator.broadcast_session_sync("s1", session=None, exclude=mock_websocket) + await asyncio.sleep(0.02) + + other.send_json.assert_awaited_once() + payload = other.send_json.call_args.args[0] + assert payload["type"] == "session_sync" + assert payload["session_id"] == "s1" + mock_websocket.send_json.assert_not_awaited() + + +@pytest.mark.anyio +async def test_headless_drain_broadcasts_session_sync(mock_websocket, monkeypatch): + """After the headless drain, remaining watchers reload the outcome (B4 tail).""" + orchestrator = AgentSessionOrchestrator(MagicMock()) + + async def fake_run_agent(session_id, content, *args, **kwargs): + state = orchestrator._sessions.get(session_id) + if state is not None: + state.run = None + + monkeypatch.setattr(orchestrator, "run_agent", fake_run_agent) + orchestrator.queue_message("s1", {"user_content": "queued", "uploaded_files": []}) + orchestrator.add_websocket("s1", mock_websocket) + + await orchestrator._drain_queued("s1", None) + await asyncio.sleep(0.02) # let the fire-and-forget broadcast run + + assert not orchestrator.has_pending("s1") + mock_websocket.send_json.assert_awaited() + payload = mock_websocket.send_json.call_args_list[-1].args[0] + assert payload["type"] == "session_sync" diff --git a/tests/unit/auth/test_api_tokens.py b/tests/unit/auth/test_api_tokens.py index c4cac6f..980c9cd 100644 --- a/tests/unit/auth/test_api_tokens.py +++ b/tests/unit/auth/test_api_tokens.py @@ -55,6 +55,7 @@ "id": user_id, "email": "u@test.com", "display_name": "Test User", + "avatar_url": None, "username": "testuser", "first_name": "Test", "last_name": "User", diff --git a/tests/unit/auth/test_deps.py b/tests/unit/auth/test_deps.py index 892aa41..a8229f6 100644 --- a/tests/unit/auth/test_deps.py +++ b/tests/unit/auth/test_deps.py @@ -428,12 +428,18 @@ @pytest.mark.asyncio -async def test_check_session_access_allows_everything_when_disabled(_auth_env): +async def test_check_session_access_disabled_allows_null_owner_only(_auth_env): + """Local mode: the anonymous local user owns only NULL-owner sessions — + other users' chats must not be readable by id.""" _auth_env["settings"].navi_auth_enabled = False - user = User(id="u1", email="u@test.com", role="user") - session = FakeChatSession(user_id="u2") - # should not raise even for non-owner non-admin - check_session_access(session, user) + local = User(id="anonymous", email="anonymous@navi.local", role="admin") + # Legacy/local sessions (user_id=None) are visible. + check_session_access(FakeChatSession(user_id=None), local) + # A real user's session is not. + from fastapi import HTTPException + with pytest.raises(HTTPException) as exc_info: + check_session_access(FakeChatSession(user_id="u2"), local) + assert exc_info.value.status_code == 403 @pytest.mark.asyncio diff --git a/tests/unit/core/test_compressor.py b/tests/unit/core/test_compressor.py index 04e5a6d..f09b217 100644 --- a/tests/unit/core/test_compressor.py +++ b/tests/unit/core/test_compressor.py @@ -129,6 +129,114 @@ # Nothing is dropped: old + recent partition the whole non-system set. assert len(old) + len(recent) == len(msgs) + def test_summary_in_inflight_turn_is_folded_not_kept(self): + """Regression: a midturn compression inserts its summary right before + the kept head of the in-flight turn. The summary's role=user made it + the head of that turn, so the next midturn pass kept the old summary + verbatim beside the fresh one — a new stale copy at every compression + (six summary copies built up to half the context in one session).""" + msgs = [] + for i in range(14): + msgs.append(Message(role="user", content=f"u{i}")) + msgs.append(Message(role="assistant", content=f"a{i}")) + msgs.append(Message(role="user", content="old summary text", is_summary=True)) + msgs.append(Message(role="user", content="inflight request")) + for i in range(10): + msgs.append(Message(role="assistant", content=f"step {i}")) + msgs.append(Message(role="tool", content=f"res {i}", name="fs", tool_call_id=str(i))) + + old, recent = partition_messages(msgs, keep_recent=12, keep_recent_messages=4) + + old_contents = {m.content for m in old} + recent_contents = {m.content for m in recent} + assert "old summary text" in old_contents + assert "old summary text" not in recent_contents + # The real user request stays as the verbatim head, not the summary. + assert "inflight request" in recent_contents + assert len(old) + len(recent) == len(msgs) + + def test_summary_in_recent_window_is_folded(self): + """An existing summary inside the turn-based keep window still goes to + to_summarize — the new summary must replace it (single-summary invariant), + never sit beside it.""" + msgs = [ + Message(role="user", content="u0"), + Message(role="assistant", content="a0"), + Message(role="user", content="old summary text", is_summary=True), + ] + for i in range(1, 7): + msgs.append(Message(role="user", content=f"u{i}")) + msgs.append(Message(role="assistant", content=f"a{i}")) + + old, recent = partition_messages(msgs, keep_recent=6) + + old_contents = {m.content for m in old} + recent_contents = {m.content for m in recent} + assert "old summary text" in old_contents + assert "old summary text" not in recent_contents + assert "u1" in recent_contents + + def test_adaptive_swap_does_not_rescue_summary(self): + """Adaptive swap must not pull a summary-carrying turn back into the + keep window: the summary text pattern-matches importance heuristics + ("wrong", "fix"), which used to resurrect stale summaries every pass.""" + summary_text = "summary: the first approach was wrong, fix the parser" + msgs = [ + Message(role="user", content="setup the project"), + Message(role="assistant", content="ok"), + Message(role="user", content=summary_text, is_summary=True), + ] + for i in range(6): + msgs.append(Message(role="user", content=f"task {i}")) + msgs.append(Message(role="assistant", content=f"answer {i}")) + + old, recent = partition_messages(msgs, keep_recent=2) # adaptive=True + + old_contents = {m.content for m in old} + recent_contents = {m.content for m in recent} + assert summary_text in old_contents + assert summary_text not in recent_contents + assert len(old) + len(recent) == len(msgs) + + def test_summary_stays_chronological_in_to_summarize(self): + """Summaries folded into to_summarize keep their position between the + surrounding turns (the summarizer reads history in sequence).""" + msgs = [ + Message(role="user", content="u0"), + Message(role="assistant", content="a0"), + ] + msgs.append(Message(role="user", content="old summary text", is_summary=True)) + for i in range(2, 7): + msgs.append(Message(role="user", content=f"u{i}")) + msgs.append(Message(role="assistant", content=f"a{i}")) + + old, _ = partition_messages(msgs, keep_recent=2) + + idx = [m.content for m in old].index("old summary text") + assert [m.content for m in old] == [ + "u0", "a0", "old summary text", "u2", "a2", "u3", "a3", "u4", "a4", + ] + + def test_midturn_fallback_folds_summary_in_short_history(self): + """Early-exit path (turns <= keep_recent) with midturn mode: a summary + inside the in-flight turn is folded, and the kept head is the real + user request.""" + msgs = [ + Message(role="user", content="old summary text", is_summary=True), + Message(role="user", content="long request"), + ] + for i in range(6): + msgs.append(Message(role="assistant", content=f"step {i}")) + msgs.append(Message(role="tool", content=f"res {i}", name="fs", tool_call_id=str(i))) + + old, recent = partition_messages(msgs, keep_recent=8, keep_recent_messages=4) + + old_contents = {m.content for m in old} + assert "old summary text" in old_contents + assert recent[0].role == "user" + assert recent[0].content == "long request" + assert len(old) + len(recent) == len(msgs) + class TestFormatForSummary: def test_user_message(self): diff --git a/tests/unit/core/test_name_generator.py b/tests/unit/core/test_name_generator.py new file mode 100644 index 0000000..2c01f87 --- /dev/null +++ b/tests/unit/core/test_name_generator.py @@ -0,0 +1,55 @@ +"""Unit tests for the session name generator.""" + +import pytest + +from navi.core.name_generator import generate_session_name +from navi.llm.base import LLMBackend, Message + + +class _FakeBackend(LLMBackend): + def __init__(self, reply: str): + self.reply = reply + self.last_prompt = None + + async def complete(self, messages, tools=None, model=None, **kwargs): + self.last_prompt = messages[-1].content + return type("R", (), {"content": self.reply})() + + async def stream_complete(self, messages, tools=None, model=None, **kwargs): + yield {"type": "text", "text": self.reply} + + +@pytest.mark.asyncio +async def test_folds_assistant_replies_into_context(): + backend = _FakeBackend("Setup of TLS on the proxy") + name = await generate_session_name( + ["привет", "ну так продолжай"], + backend, + "test-model", + assistant_messages=["Сделаю шаги: 1) сгенерирую ключи..." + ("x" * 1000)], + ) + assert name == "Setup of TLS on the proxy" + # The assistant reply is trimmed to its 600-char tail, not passed whole + assert "xxxxx" not in backend.last_prompt.replace("x" * 600, "") + tail_len = len("Assistant replies:\n") + 600 + assert len(backend.last_prompt) - len(backend.last_prompt.split("Assistant replies:\n")[0]) == tail_len + + +@pytest.mark.asyncio +async def test_no_topic_still_yields_none(): + backend = _FakeBackend("NO_TITLE") + name = await generate_session_name( + ["привет", "как дела?"], + backend, + "test-model", + assistant_messages=["Тоже привет!"], + ) + assert name is None + + +@pytest.mark.asyncio +async def test_without_assistant_replies_unchanged(): + backend = _FakeBackend("Debugging the deploy") + name = await generate_session_name(["fix the deploy"], backend, "test-model") + assert name == "Debugging the deploy" + assert "Assistant replies:" not in backend.last_prompt \ No newline at end of file diff --git a/tests/unit/core/test_parallel_tools.py b/tests/unit/core/test_parallel_tools.py index c6bee9d..98e23e3 100644 --- a/tests/unit/core/test_parallel_tools.py +++ b/tests/unit/core/test_parallel_tools.py @@ -29,9 +29,14 @@ self._delay = delay self._emit = emit self._fail = fail + self.cancelled = False async def execute(self, arguments, ctx=None): - await asyncio.sleep(self._delay) + try: + await asyncio.sleep(self._delay) + except asyncio.CancelledError: + self.cancelled = True + raise if self._emit is not None: sink = current_event_sink.get() await sink.put(self._emit) @@ -159,6 +164,58 @@ pass assert turn_ctx.tool_call_count == 2 + async def test_stop_cancels_running_tools(self): + """Stop mid-batch cancels in-flight tools, not just abandons them (B1).""" + agent, _ = make_agent() + slow = SlowTool("long", 5.0) + stop_event = asyncio.Event() + + async def set_stop(): + await asyncio.sleep(0.05) + stop_event.set() + + asyncio.create_task(set_stop()) + + async def run(): + return [ + ev async for ev in agent._execute_tools_parallel( + make_tcs("long"), [slow], make_turn_ctx(), + SimpleNamespace(messages=[], context=[]), stop_event, None) + ] + + events = await asyncio.wait_for(run(), timeout=3.0) + # the 5s tool must have been cancelled, not left running in background + assert slow.cancelled is True + tool_events = [e for e in events if isinstance(e, ToolEvent)] + assert all(not e.success for e in tool_events) + + async def test_stop_keeps_completed_results(self): + """Stop erases nothing that already finished — real results survive (B2).""" + agent, _ = make_agent() + fast = SlowTool("fast", 0.01) + slow = SlowTool("long", 5.0) + session = SimpleNamespace(messages=[], context=[]) + stop_event = asyncio.Event() + + async def set_stop(): + await asyncio.sleep(0.15) + stop_event.set() + + asyncio.create_task(set_stop()) + events = [ev async for ev in agent._execute_tools_parallel( + make_tcs("fast", "long"), [fast, slow], make_turn_ctx(), + session, stop_event, None)] + tool_events = {e.tool_name: e for e in events if isinstance(e, ToolEvent)} + # fast finished before the stop — its real result must survive + assert tool_events["fast"].success is True + assert tool_events["fast"].result == "done fast" + # slow was in flight — synthetic stopped result + assert "stopped by the user" in tool_events["long"].result + msgs_by_name = {m.name: m for m in session.messages} + assert msgs_by_name["fast"].content == "done fast" + assert msgs_by_name["fast"].is_context is not False + assert msgs_by_name["long"].is_context is False + class TestDispatch: async def test_gate_off_uses_sequential_path(self): diff --git a/tests/unit/core/test_pg_session_store.py b/tests/unit/core/test_pg_session_store.py index 3668431..a71ae61 100644 --- a/tests/unit/core/test_pg_session_store.py +++ b/tests/unit/core/test_pg_session_store.py @@ -201,3 +201,246 @@ removed = await store.sweep_pending(max_age_seconds=3600) assert removed == 0 assert session.id in store._pending + + +def _make_store(): + conn = FakeConnection() + store = PgSessionStore(FakePool(conn)) + store._initialized = True + return store, conn + + +def _msg_row(seq, display_index=None, **overrides): + """FakeRecord shaped like a session_messages row, plus display_index.""" + fields = { + "role": "user", + "content": f"m{seq}", + "sequence_number": seq, + "is_display": True, + "metadata": "{}", + } + if display_index is not None: + fields["display_index"] = display_index + fields.update(overrides) + return FakeRecord(**fields) + + +import json as _json # noqa: E402 +from tests.conftest_factory import FakeRecord # noqa: E402 + + +def _meta_row(**overrides): + fields = { + "id": "sid-1", + "profile_id": "secretary", + "user_id": "u1", + "pinned": True, + "created_at": __import__("datetime").datetime(2026, 1, 1, tzinfo=__import__("datetime").timezone.utc), + "last_active": __import__("datetime").datetime(2026, 1, 2, tzinfo=__import__("datetime").timezone.utc), + "context_token_count": 1234, + "name": "Test session", + "planning_logs": None, + "next_sequence": 45, + "archive_threshold": 30, + "session_metadata": '{"terminal": {"tty": "/dev/pts/0"}}', + } + fields.update(overrides) + return FakeRecord(**fields) + + +@pytest.mark.asyncio +async def test_get_meta_returns_light_session_head(): + store, conn = _make_store() + conn.enqueue(_meta_row()) # sessions row + conn.enqueue(44) # session_messages COUNT + + s = await store.get_meta("sid-1") + + assert s is not None + assert s.id == "sid-1" + assert s.profile_id == "secretary" + assert s.name == "Test session" + assert s.messages == [] + assert s.context == [] + assert s.db_message_count == 44 + assert s.db_next_sequence == 45 # stored next_sequence wins over count+1 + assert s.archive_threshold == 30 + assert s.session_metadata == {"terminal": {"tty": "/dev/pts/0"}} + # Only two cheap queries — no session_messages payload fetch. + assert len([c for c in conn.calls if c[0] == "fetch"]) == 0 + + +@pytest.mark.asyncio +async def test_get_meta_falls_back_to_count_plus_one(): + store, conn = _make_store() + conn.enqueue(_meta_row(next_sequence=None)) + conn.enqueue(44) + + s = await store.get_meta("sid-1") + assert s.db_next_sequence == 45 # count + 1 + + +@pytest.mark.asyncio +async def test_get_meta_returns_pending_session_without_db(): + store, conn = _make_store() + session = await store.create(profile_id="test") + + got = await store.get_meta(session.id) + + assert got is session + assert conn.calls == [] + + +@pytest.mark.asyncio +async def test_get_meta_missing_returns_none(): + store, conn = _make_store() + conn.enqueue(None) # no sessions row + + assert await store.get_meta("nope") is None + + +def _ranked_rows(seqs): + """Rows as the pagination SQL would emit them: newest-first, with ranks. + The SQL returns limit+1 rows when there are more — slicing that peeks + is the store's job, not the fixture's.""" + base_rank = 100 # ranks may have gaps when non-display rows are skipped + return [_msg_row(s, display_index=base_rank - (len(seqs) - 1 - i)) for i, s in enumerate(seqs)] + + +@pytest.mark.asyncio +async def test_get_history_page_tail_oldest_first_with_ranks(): + store, conn = _make_store() + rows = _ranked_rows([4, 2, 0]) # 3 rows for limit 2 → 1 extra → has_more + conn.enqueue(rows) + + msgs, has_more = await store.get_history_page("sid-1", limit=2) + + assert has_more is True + # page = 2 newest (seq 4, 2), delivered oldest-first + assert [m.sequence_number for m in msgs] == [2, 4] + assert [m.metadata["display_index"] for m in msgs] == [99, 98] + + +@pytest.mark.asyncio +async def test_get_history_page_no_more(): + store, conn = _make_store() + conn.enqueue([_msg_row(0, display_index=7)]) + + msgs, has_more = await store.get_history_page("sid-1", limit=2) + + assert has_more is False + assert [m.metadata["display_index"] for m in msgs] == [7] + + +@pytest.mark.asyncio +async def test_get_history_page_passes_before_seq(): + store, conn = _make_store() + conn.enqueue([_msg_row(3, display_index=8)]) + + await store.get_history_page("sid-1", before_seq=3, limit=2) + + fetches = [c for c in conn.calls if c[0] == "fetch"] + assert fetches and fetches[0][2] == ("sid-1", 3, 3) # limit + 1 peek + + +@pytest.mark.asyncio +async def test_get_history_page_keeps_placeholder_rank_shift(): + """A dangling tool-call at a page boundary gets a synthetic placeholder; + ranks must come from sequence numbers so inserted placeholders don't + shift the real messages' ranks.""" + from navi.llm.base import ToolCallRequest + + tc = ToolCallRequest(id="tc-1", name="terminal", arguments={}) + store, conn = _make_store() + # Newest-first rows: assistant with an unanswered tool_call on top, + # then two real messages. + rows = [ + _msg_row(12, display_index=7, **{ + "role": "assistant", + "tool_calls": _json.dumps([tc.model_dump(mode="json")]), + "content": "", + }), + _msg_row(11, display_index=6, **{"role": "tool", "tool_call_id": "other"}), + _msg_row(10, display_index=5, **{"role": "assistant", "content": "done"}), + ] + conn.enqueue(rows) + + msgs, _ = await store.get_history_page("sid-1", limit=3) + + # oldest-first: assistant(10), tool(other), assistant(12) + placeholder tail + assert [m.sequence_number for m in msgs] == [10, 11, 12, -1] + assert msgs[0].metadata["display_index"] == 5 + assert msgs[2].metadata["display_index"] == 7 # not shifted by the insert + # synthetic placeholder continues the rank walk + assert msgs[3].metadata["display_index"] == 8 + assert msgs[3].content == "[Interrupted before result]" + + +# ── Listing scope: local mode (user_id=None) is a separate owner ────────────── + + +@pytest.mark.asyncio +async def test_list_all_null_owner_scopes_to_null_rows(): + store, conn = _make_store() + conn.enqueue([]) + + await store.list_all(user_id=None, is_admin=False) + + sql = conn.calls[0][1] + assert "user_id IS NULL" in sql + + +@pytest.mark.asyncio +async def test_list_all_named_owner_filters_by_user(): + store, conn = _make_store() + conn.enqueue([]) + + await store.list_all(user_id="u1", is_admin=False) + + sql = conn.calls[0][1] + assert "user_id = $1" in sql + assert "IS NULL" not in sql + + +@pytest.mark.asyncio +async def test_list_all_admin_sees_everything(): + store, conn = _make_store() + conn.enqueue([]) + + await store.list_all(user_id="u1", is_admin=True) + + sql = conn.calls[0][1] + assert "WHERE" not in sql # no user_id filter in the SELECT list or WHERE + + +@pytest.mark.asyncio +async def test_list_page_null_owner_scopes_to_null_rows(): + store, conn = _make_store() + conn.enqueue([]) + + await store.list_page(limit=10, offset=0, user_id=None, is_admin=False) + + sql = conn.calls[0][1] + assert "user_id IS NULL" in sql + + +@pytest.mark.asyncio +async def test_search_list_null_owner_scopes_to_null_rows(): + store, conn = _make_store() + conn.enqueue([]) + + await store.search_list(limit=10, offset=0, user_id=None, is_admin=False, search="ip") + + fetches = [c for c in conn.calls if c[0] == "fetch"] + assert fetches and "user_id IS NULL" in fetches[0][1] + + +@pytest.mark.asyncio +async def test_count_all_null_owner_scopes_to_null_rows(): + store, conn = _make_store() + conn.enqueue(0) + + await store.count_all(user_id=None, is_admin=False) + + rows = [c for c in conn.calls if c[0] == "fetchrow"] + assert rows and "SELECT COUNT(*) FROM sessions WHERE user_id IS NULL" in rows[0][1] diff --git a/tests/unit/core/test_session_special_filter.py b/tests/unit/core/test_session_special_filter.py new file mode 100644 index 0000000..9940f81 --- /dev/null +++ b/tests/unit/core/test_session_special_filter.py @@ -0,0 +1,57 @@ +"""Special (service) session filtering in session stores. + +Store-level default is *no* special filtering (None): hiding service sessions +from the user-facing list is the REST layer's decision, explicit in the +`sessions` route (`?special=` — False hides, True lists only special). +""" + +import pytest + +from navi.core.session import InMemorySessionStore + + +@pytest.fixture +def store() -> InMemorySessionStore: + store = InMemorySessionStore() + store._sessions["reg"] = _fake("reg", special=False) + store._sessions["spec"] = _fake("spec", special=True) + return store + + +def _fake(session_id: str, special: bool): + from navi.core.session import Session + + return Session(id=session_id, profile_id="secretary", special=special) + + +async def test_list_all_no_filter_by_default(store): + ids = sorted(s.id for s in await store.list_all()) + assert ids == ["reg", "spec"] + + +async def test_list_all_regular_only(store): + ids = [s.id for s in await store.list_all(special=False)] + assert ids == ["reg"] + + +async def test_list_all_special_only(store): + ids = [s.id for s in await store.list_all(special=True)] + assert ids == ["spec"] + + +async def test_list_page_count_search_filter_special(store): + page = await store.list_page(limit=10, offset=0, special=False) + assert [s.id for s in page] == ["reg"] + + page_special = await store.list_page(limit=10, offset=0, special=True) + assert [s.id for s in page_special] == ["spec"] + + assert await store.count_all(special=False) == 1 + assert await store.count_all(special=True) == 1 + assert await store.count_all(special=None) == 2 + assert await store.count_all() == 2 # no filter — admin/back-end paths + + found = await store.search_list(limit=10, offset=0, search="reg", special=False) + assert [s.id for s in found] == ["reg"] + found_special = await store.search_list(limit=10, offset=0, search="reg", special=True) + assert found_special == [] \ No newline at end of file diff --git a/tests/unit/core/test_synapse_reactions.py b/tests/unit/core/test_synapse_reactions.py new file mode 100644 index 0000000..11805e6 --- /dev/null +++ b/tests/unit/core/test_synapse_reactions.py @@ -0,0 +1,257 @@ +"""Tests for the Synapse reaction runner (dispatcher meta-pass → session run).""" + +import asyncio +import json +from types import SimpleNamespace +from unittest.mock import AsyncMock, MagicMock + +import pytest + +import navi.api.deps as deps +import navi.synapse.reactions as reactions +from navi.core.registry import ProfileRegistry +from navi.profiles import ALL_PROFILES + + +def _registry() -> ProfileRegistry: + reg = ProfileRegistry() + for p in ALL_PROFILES: + reg.register(p) + return reg + + +# ── _parse_decision ───────────────────────────────────────────────────────── + +def test_parse_decision_plain_and_fenced(): + plain = json.dumps({"profile_id": "developer", "task": "t", "understood": "u"}) + assert reactions._parse_decision(plain) == { + "profile_id": "developer", "task": "t", "understood": "u" + } + + fenced = "Sure:\n```json\n" + plain + "\n```" + assert reactions._parse_decision(fenced) == { + "profile_id": "developer", "task": "t", "understood": "u" + } + + +def test_parse_decision_garbage_and_skip(): + assert reactions._parse_decision("no json here") is None + assert reactions._parse_decision("") is None + decision = reactions._parse_decision('{"skip": true, "reason": "junk delivery"}') + assert decision is not None and decision["skip"] is True + + +# ── _resolve_profile ──────────────────────────────────────────────────────── + +def test_visible_profile_resolves(): + reg = _registry() + assert reactions._resolve_profile(reg, "developer").id == "developer" + + +def test_hidden_profile_falls_back_to_secretary(): + reg = _registry() + # dispatcher exists but is hidden → must never host a session + assert reg.get("dispatcher").is_hidden + assert reactions._resolve_profile(reg, "dispatcher").id == "secretary" + + +def test_unknown_profile_falls_back_to_secretary(): + reg = _registry() + assert reactions._resolve_profile(reg, "astronaut").id == "secretary" + + +# ── _dispatch ─────────────────────────────────────────────────────────────── + +async def test_dispatch_returns_decision(monkeypatch): + decision = json.dumps({"profile_id": "developer", "task": "fix it", "understood": "ok"}) + backend = MagicMock() + backend.complete = AsyncMock( + return_value=SimpleNamespace(content=f"```json\n{decision}\n```") + ) + monkeypatch.setattr( + deps, "get_profile_registry", lambda: _registry() + ) + monkeypatch.setattr( + deps, "get_backend_registry", lambda: SimpleNamespace(get=lambda key: backend) + ) + + profile_id, task, understood = await reactions._dispatch({"event_id": "e1"}, "instructions") + assert (profile_id, task, understood) == ("developer", "fix it", "ok") + # the dispatcher pass must only see the user's instructions + the envelope + user_msg = backend.complete.await_args.args[0][1].content + assert "instructions" in user_msg and "event_id" in user_msg + + +async def test_dispatch_backend_failure_yields_skip(monkeypatch): + backend = MagicMock() + backend.complete = AsyncMock(side_effect=RuntimeError("boom")) + monkeypatch.setattr(deps, "get_profile_registry", lambda: _registry()) + monkeypatch.setattr( + deps, "get_backend_registry", lambda: SimpleNamespace(get=lambda key: backend) + ) + assert await reactions._dispatch({}, "") == (None, "", "") + + +# ── run_reaction ──────────────────────────────────────────────────────────── + +class _FakeSession: + def __init__(self, session_id): + self.id = session_id + self.special = False + self.name = "" + self.session_metadata = {} + + +def _fake_store(saved): + store = MagicMock() + + async def fake_create(profile_id, user_id=None): + session = _FakeSession("sess-1") + saved.append((profile_id, user_id, session)) + return session + + store.create = fake_create + store.save = AsyncMock() + return store + + +def _fake_orchestrator(queue): + import contextlib + + orchestrator = MagicMock() + + session_locks: dict = {} + + def fake_lock(session_id): + # mirror the real orchestrator: session_lock returns an asyncio.Lock + return session_locks.setdefault(session_id, asyncio.Lock()) + + orchestrator.session_lock = fake_lock + + run = MagicMock() + run.subscribe = lambda: queue + run.unsubscribe = lambda q: None + orchestrator.create_run = lambda sid: run + orchestrator.run_agent = AsyncMock() + return orchestrator, run + + +async def test_run_reaction_disabled_gate(monkeypatch): + """reactions_enabled=False → no session is created, nothing is dispatched.""" + from navi.synapse.settings_store import SynapseSettings + + saved: list = [] + store = _fake_store(saved) + monkeypatch.setattr(deps, "get_session_store", lambda: store) + async def fake_get(self, user_id): + return SynapseSettings(user_id=user_id) + monkeypatch.setattr( + "navi.synapse.settings_store.SynapseSettingsStore.get", fake_get + ) + dispatched: list = [] + + async def fake_dispatch(*args, **kwargs): + dispatched.append(args) + return "developer", "t", "u" + + monkeypatch.setattr(reactions, "_dispatch", fake_dispatch) + + await reactions.run_reaction({"event_id": "e1"}, user_id="u1", event_type="todo.created") + + assert dispatched == [] + assert saved == [] + + +async def test_run_reaction_happy_path(monkeypatch): + """Gate passes → dispatcher picks a profile → special session is created and run.""" + from navi.synapse.settings_store import SynapseSettings, SynapseSettingsStore + + saved: list = [] + store = _fake_store(saved) + monkeypatch.setattr(deps, "get_session_store", lambda: store) + + current = SynapseSettings(user_id="u1", reactions_enabled=True, instructions="watch gntodo") + async def fake_get(self, user_id): + return current + monkeypatch.setattr(SynapseSettingsStore, "get", fake_get) + + monkeypatch.setattr(deps, "get_profile_registry", lambda: _registry()) + monkeypatch.setattr(reactions, "_dispatch", AsyncMock(return_value=("developer", "fix it", "ok"))) + + queue: asyncio.Queue = asyncio.Queue() + orchestrator, run = _fake_orchestrator(queue) + monkeypatch.setattr(deps, "get_orchestrator", lambda: orchestrator) + + # run_agent completes right away: drain must see "done" from queue. + ran: list = [] + + async def fake_run_agent(*args, **kwargs): + ran.append(args) + await queue.put(("done", None)) + orchestrator.run_agent = fake_run_agent + + # No push service in deps, and no synapse source: finalise must be silent. + monkeypatch.setattr(deps, "get_push_service", lambda: None) + monkeypatch.setattr(reactions, "synapse_source_ready", lambda: False) + + await reactions.run_reaction( + {"event_id": "e1", "subject": "gntodo", "action": "created"}, + user_id="u1", event_type="gntodo.task.created", + ) + + profile_id, user_id, session = saved[0] + assert (profile_id, user_id) == ("developer", "u1") + assert session.special is True + assert session.name == "Synapse: gntodo.task.created" + assert session.session_metadata["synapse"]["event_id"] == "e1" + store.save.assert_awaited() + assert len(ran) == 1 + assert ran[0][0] == session.id + + +async def test_run_reaction_finalise_pushes_on_importance(monkeypatch): + """completion_notify='important' + errors → app push is sent.""" + from navi.synapse.settings_store import SynapseSettings, SynapseSettingsStore + + saved: list = [] + store = _fake_store(saved) + monkeypatch.setattr(deps, "get_session_store", lambda: store) + + current = SynapseSettings(user_id="u1", reactions_enabled=True, push_target="app") + async def fake_get(self, user_id): + return current + monkeypatch.setattr(SynapseSettingsStore, "get", fake_get) + + monkeypatch.setattr(deps, "get_profile_registry", lambda: _registry()) + monkeypatch.setattr(reactions, "_dispatch", AsyncMock(return_value=("secretary", "t", "u"))) + + queue: asyncio.Queue = asyncio.Queue() + orchestrator, _run = _fake_orchestrator(queue) + monkeypatch.setattr(deps, "get_orchestrator", lambda: orchestrator) + + async def failing_run_agent(*args, **kwargs): + await queue.put(("error", "model exploded")) + await queue.put(("done", None)) + orchestrator.run_agent = failing_run_agent + + pushes: list = [] + class _Push: + async def notify_custom(self, session_id, user_id, title, body): + pushes.append((session_id, user_id, title, body)) + monkeypatch.setattr(deps, "get_push_service", lambda: _Push()) + monkeypatch.setattr(reactions, "synapse_source_ready", lambda: True) + emitted: list = [] + + async def fake_emit_low_level(subject, action, payload, priority="low", dedup_key=None): + emitted.append({"subject": subject, "action": action, "payload": payload}) + import navi.synapse.outbound as outbound_mod + monkeypatch.setattr(outbound_mod, "emit_low_level", fake_emit_low_level) + + await reactions.run_reaction({"event_id": "e7"}, user_id="u1", event_type="gntodo.x") + + assert len(pushes) == 1 + title = pushes[0][2] + assert "упала" in title + assert "model exploded" in pushes[0][3] + assert emitted[0]["action"] == "failed" + assert emitted[0]["payload"]["event_id"] == "e7" \ No newline at end of file diff --git a/tests/unit/core/test_task_manager.py b/tests/unit/core/test_task_manager.py index 3308dec..65d43a3 100644 --- a/tests/unit/core/test_task_manager.py +++ b/tests/unit/core/test_task_manager.py @@ -159,6 +159,72 @@ fresh_manager.cancel(third) +class TestSessionCleanup: + def make_blocking(self, manager, session_id, tool="code_exec"): + started = asyncio.Event() + + async def factory(bg_ctx): + started.set() + await asyncio.sleep(30) + + job = manager.submit(session_id, tool, {}, factory, make_ctx(session_id=session_id)) + return job, started + + async def test_cancel_session_jobs_cancels_running_only(self, fresh_manager): + job1, started1 = self.make_blocking(fresh_manager, "s1") + job2, started2 = self.make_blocking(fresh_manager, "s2") + await started1.wait() + await started2.wait() + + assert fresh_manager.cancel_session_jobs("s1") == 1 + await job1.done.wait() + assert job1.status == "cancelled" + # another session's task is untouched + assert job2.status == "running" + assert fresh_manager.cancel_session_jobs("s2") == 1 + await job2.done.wait() + + async def test_cancel_session_jobs_ignores_finished(self, fresh_manager): + async def factory(bg_ctx): + return ToolResult(success=True, output="ok") + + done_job = fresh_manager.submit("s1", "code_exec", {}, factory, make_ctx()) + await done_job.done.wait() + job, started = self.make_blocking(fresh_manager, "s1") + await started.wait() + + assert fresh_manager.cancel_session_jobs("s1") == 1 + await job.done.wait() + # the earlier finished job stays completed, not cancelled + assert done_job.status == "completed" + + async def test_cancel_session_jobs_suppresses_notes(self, fresh_manager, monkeypatch): + called = [] + + async def fake_add_note(job): + called.append(job.task_id) + + monkeypatch.setattr("navi.core.task_notes.add_note", fake_add_note) + + async def factory(bg_ctx): + await asyncio.sleep(0.01) + + # finished job (would normally leave a pending note) is irrelevant here; + # what matters: the cancelled-by-session-delete job writes no note. + fast_job = fresh_manager.submit("s1", "code_exec", {}, factory, make_ctx()) + await fast_job.done.wait() + job, started = self.make_blocking(fresh_manager, "s1") + await started.wait() + + assert fresh_manager.cancel_session_jobs("s1") == 1 + assert job.suppress_note is True + await job.done.wait() + await asyncio.sleep(0.05) # let the fire-and-forget _note task run + # the fast job wrote its note (normal path) but the session-delete + # cancellation must not + assert called == [fast_job.task_id] + + class TestUpdateCallback: async def test_published_on_submit_and_finish(self, fresh_manager): updates = [] diff --git a/tests/unit/core/test_task_notes.py b/tests/unit/core/test_task_notes.py index b06491b..6c25f3d 100644 --- a/tests/unit/core/test_task_notes.py +++ b/tests/unit/core/test_task_notes.py @@ -56,6 +56,19 @@ await task_notes.add_note(make_job()) assert await task_notes.pending_count("s1") == 1 + async def test_clear_drops_pending_notes(self, kv): + await task_notes.add_note(make_job()) + await task_notes.add_note(make_job(task_id="bt-cd34")) + await task_notes.clear("s1") + assert await task_notes.pending_count("s1") == 0 + assert await task_notes.drain("s1") is None + + async def test_clear_scoped_by_session(self, kv): + await task_notes.add_note(make_job()) + await task_notes.add_note(make_job(session_id="s2")) + await task_notes.clear("s1") + assert await task_notes.pending_count("s2") == 1 + async def test_cap_drops_oldest(self, kv, monkeypatch): patch_settings(monkeypatch, task_notes_max_pending=2) for i in range(4): diff --git a/tests/unit/mcp/test_keystore.py b/tests/unit/mcp/test_keystore.py new file mode 100644 index 0000000..3058f2c --- /dev/null +++ b/tests/unit/mcp/test_keystore.py @@ -0,0 +1,240 @@ +"""McpUserKey config validation + McpKeyStore / KeyResolver unit tests.""" + +from datetime import datetime, timezone +from unittest.mock import AsyncMock + +import pytest +from cryptography.fernet import Fernet + +from navi.auth.encrypt import TokenEncryptor +from navi.mcp.config import McpServerConfig, McpUserKey +from navi.mcp.keystore import KeyResolver, McpKeyStore + + +from tests.conftest_factory import FakeRecord + + +class FakePool: + """Pool-level asyncpg fake: captures queries, returns canned results.""" + + def __init__(self): + self.queries: list[tuple[str, tuple]] = [] + self.executes: list = [] + self.fetch_returns: list = [] + self.fetchval_returns: list = [] + + @staticmethod + def _take(queue: list): + if not queue: + return None + result = queue.pop(0) + if isinstance(result, Exception): + raise result + return result + + async def execute(self, query, *args): + self.queries.append((query, args)) + return self._take(self.executes) or "OK" + + async def fetchval(self, query, *args): + self.queries.append((query, args)) + return self._take(self.fetchval_returns) + + async def fetch(self, query, *args): + self.queries.append((query, args)) + return self._take(self.fetch_returns) or [] + + +class TestUserKeyValidation: + def test_header_slot(self): + cfg = McpServerConfig( + transport="streamable_http", + url="https://x", + headers={"Authorization": "Bearer default"}, + user_key=McpUserKey(header="Authorization", prefix="Bearer "), + ) + assert cfg.accepts_user_key + + def test_env_slot(self): + cfg = McpServerConfig( + transport="stdio", + command="uvx", + env={"API_KEY": "default"}, + user_key=McpUserKey(env="API_KEY"), + ) + assert cfg.accepts_user_key + + def test_both_destinations_rejected(self): + with pytest.raises(Exception): + McpServerConfig(user_key=McpUserKey(header="H", env="E")) + + def test_no_destination_rejected(self): + with pytest.raises(Exception): + McpServerConfig(user_key=McpUserKey()) + + def test_header_requires_http_transport(self): + with pytest.raises(Exception): + McpServerConfig(transport="stdio", user_key=McpUserKey(header="Authorization")) + + def test_env_requires_stdio_transport(self): + with pytest.raises(Exception): + McpServerConfig(transport="sse", user_key=McpUserKey(env="API_KEY")) + + def test_no_user_key_is_default(self): + assert McpServerConfig().accepts_user_key is False + + +class TestWithUserKey: + def _http_cfg(self): + return McpServerConfig( + transport="streamable_http", + url="https://x", + headers={"Authorization": "Bearer default", "X-Other": "1"}, + user_key=McpUserKey(header="Authorization", prefix="Bearer "), + ) + + def test_injects_header_and_prefix(self): + patched = self._http_cfg().with_user_key("sk-123") + assert patched.headers["Authorization"] == "Bearer sk-123" + assert patched.headers["X-Other"] == "1" + + def test_no_prefix_appends_raw(self): + cfg = self._http_cfg() + cfg.user_key.prefix = None + assert cfg.with_user_key("sk").headers["Authorization"] == "sk" + + def test_env_injection(self): + cfg = McpServerConfig( + transport="stdio", + command="uvx", + env={"API_KEY": "default"}, + user_key=McpUserKey(env="API_KEY"), + ) + assert cfg.with_user_key("abc").env["API_KEY"] == "abc" + + def test_original_config_untouched(self): + cfg = self._http_cfg() + cfg.with_user_key("sk-123") + assert cfg.headers["Authorization"] == "Bearer default" + + def test_raises_when_no_slot(self): + with pytest.raises(ValueError): + McpServerConfig().with_user_key("sk") + + +@pytest.fixture +def encryptor(monkeypatch): + enc = TokenEncryptor(Fernet.generate_key().decode()) + import navi.mcp.keystore as ks + + monkeypatch.setattr(ks, "get_encryptor", lambda: enc) + return enc + + +class TestMcpKeyStore: + async def test_set_persists_encrypted(self, encryptor): + pool = FakePool() + store = McpKeyStore(pool) + ts = await store.set("u1", "srv", "sk-plain") + assert isinstance(ts, datetime) + query, args = pool.queries[0] + assert "ON CONFLICT (user_id, server_name)" in query + assert args[0] == "u1" and args[1] == "srv" + assert encryptor.decrypt(args[2]) == "sk-plain" + + async def test_get_missing_returns_none(self, encryptor): + store = McpKeyStore(FakePool()) + assert await store.get("u1", "srv") is None + + async def test_get_decrypts(self, encryptor): + pool = FakePool() + store = McpKeyStore(pool) + pool.fetchval_returns.append(encryptor.encrypt("sk-plain")) + assert await store.get("u1", "srv") == "sk-plain" + + async def test_delete_true_when_row_returned(self, encryptor): + pool = FakePool() + store = McpKeyStore(pool) + pool.fetchval_returns.append("srv") + assert await store.delete("u1", "srv") is True + + async def test_delete_false_when_no_row(self, encryptor): + store = McpKeyStore(FakePool()) + assert await store.delete("u1", "srv") is False + + async def test_list_servers(self, encryptor): + pool = FakePool() + store = McpKeyStore(pool) + ts = datetime.now(timezone.utc) + pool.fetch_returns.append([FakeRecord(server_name="a", updated_at=ts)]) + assert await store.list_servers("u1") == {"a": ts} + + +class TestKeyResolver: + @staticmethod + def _store(key="sk-1"): + store = AsyncMock(spec=McpKeyStore) + store.get = AsyncMock(return_value=key) + return store + + async def test_resolve_delegates_to_store(self, encryptor): + store = self._store() + resolver = KeyResolver(lambda: store) + assert await resolver.resolve("u1", "srv") == "sk-1" + store.get.assert_awaited_once_with("u1", "srv") + + async def test_resolve_caches_within_ttl(self, encryptor): + store = self._store() + clock = [1_000.0] + resolver = KeyResolver(lambda: store, ttl=30.0, now=lambda: clock[0]) + await resolver.resolve("u1", "srv") + await resolver.resolve("u1", "srv") + store.get.assert_awaited_once() + + clock[0] += 31.0 # past TTL -> re-resolve + await resolver.resolve("u1", "srv") + assert store.get.await_count == 2 + + async def test_missing_key_resolves_none(self, encryptor): + store = self._store(key=None) + resolver = KeyResolver(lambda: store) + assert await resolver.resolve("u1", "srv") is None + + async def test_db_error_resolves_none(self, encryptor): + store = AsyncMock(spec=McpKeyStore) + store.get = AsyncMock(side_effect=RuntimeError("db down")) + resolver = KeyResolver(lambda: store) + assert await resolver.resolve("u1", "srv") is None + + async def test_invalidate_forces_re_resolve(self, encryptor): + store = self._store() + resolver = KeyResolver(lambda: store) + await resolver.resolve("u1", "srv") + resolver.invalidate("u1", "srv") + await resolver.resolve("u1", "srv") + assert store.get.await_count == 2 + + async def test_invalidate_all(self, encryptor): + store = self._store() + resolver = KeyResolver(lambda: store) + await resolver.resolve("u1", "srv") + await resolver.resolve("u2", "srv") + resolver.invalidate_all() + await resolver.resolve("u1", "srv") + assert store.get.await_count == 3 + + async def test_on_change_fired_with_scope(self, encryptor): + events: list = [] + resolver = KeyResolver(lambda: self._store()) + resolver.set_on_change(lambda user, srv: events.append((user, srv))) + resolver.invalidate("u1", "srv") + resolver.invalidate("u2", None) + resolver.invalidate_all() + assert events == [("u1", "srv"), ("u2", None), (None, None)] + + async def test_error_not_cached_then_recovery(self, encryptor): + store = AsyncMock(spec=McpKeyStore) + store.get = AsyncMock(side_effect=[RuntimeError("down"), "sk-recovered"]) + resolver = KeyResolver(lambda: store) + assert await resolver.resolve("u1", "srv") is None + assert await resolver.resolve("u1", "srv") == "sk-recovered" \ No newline at end of file diff --git a/tests/unit/mcp/test_manager_byok.py b/tests/unit/mcp/test_manager_byok.py new file mode 100644 index 0000000..0d37b2e --- /dev/null +++ b/tests/unit/mcp/test_manager_byok.py @@ -0,0 +1,228 @@ +"""McpManager BYOK runtime — per-user clients, caching, fallback, LRU.""" + +import asyncio +from unittest.mock import MagicMock + +import pytest + +import navi.mcp.manager as manager_mod +from navi.mcp.config import McpServerConfig, McpUserKey + + +class FakeClient: + """Stand-in for McpClient: records construction and disconnects.""" + + instances: list["FakeClient"] = [] + + def __init__(self, name, config): + self.name = name + self.config = config + self.disconnected = False + FakeClient.instances.append(self) + + async def call_tool(self, tool_name, arguments=None): + return ("ok", False) + + async def disconnect(self): + self.disconnected = True + + +class FakeResolver: + def __init__(self, keys: dict | None = None): + self.keys = keys or {} + self.on_change = None + self.resolves: list = [] + + async def resolve(self, user_id, server_name): + self.resolves.append((user_id, server_name)) + return self.keys.get((user_id, server_name)) + + def set_on_change(self, cb): + self.on_change = cb + + def invalidate(self, user_id, server_name=None): + if self.on_change: + self.on_change(user_id, server_name) + + +@pytest.fixture(autouse=True) +def fake_client(monkeypatch): + FakeClient.instances = [] + monkeypatch.setattr(manager_mod, "McpClient", FakeClient) + return FakeClient + + +@pytest.fixture +def manager(): + m = manager_mod.McpManager() + m._configs = _configs() + m._clients = {"http-server": FakeClient("http-server", _configs()["http-server"])} + return m + + +def _configs(): + return { + "http-server": McpServerConfig( + transport="streamable_http", + url="https://x", + headers={"Authorization": "Bearer default"}, + user_key=McpUserKey(header="Authorization", prefix="Bearer "), + ), + "std-server": McpServerConfig( + transport="stdio", + command="uvx", + env={"API_KEY": "default"}, + user_key=McpUserKey(env="API_KEY"), + ), + "plain-server": McpServerConfig(transport="sse", url="https://plain"), + } + + +async def test_call_without_user_uses_default_client(manager): + manager._clients["plain-server"] = FakeClient("plain-server", _configs()["plain-server"]) + out, is_err = await manager.call_tool("plain-server", "t") + assert (out, is_err) == ("ok", False) + + +async def test_no_user_key_slot_resolves_never(manager): + """A key-less server must not touch the resolver at all (zero regression).""" + manager._clients["plain-server"] = FakeClient("plain-server", _configs()["plain-server"]) + resolver = FakeResolver(keys={("u1", "plain-server"): "sk"}) + manager.set_key_resolver(resolver) + await manager.call_tool("plain-server", "t", user_id="u1") + assert resolver.resolves == [] + + +async def test_no_user_id_resolves_never(manager): + resolver = FakeResolver(keys={("u1", "http-server"): "sk"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t") + assert resolver.resolves == [] + + +async def test_user_key_builds_per_user_client(manager, fake_client): + resolver = FakeResolver(keys={("u1", "http-server"): "sk-user"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + + user_clients = [c for c in fake_client.instances if c is not manager._clients["http-server"]] + assert len(user_clients) == 1 + assert user_clients[0].config.headers["Authorization"] == "Bearer sk-user" + # The default config itself is untouched. + assert manager._clients["http-server"].config.headers["Authorization"] == "Bearer default" + + +async def test_user_key_env_substitution(manager, fake_client): + manager._clients["std-server"] = FakeClient("std-server", _configs()["std-server"]) + resolver = FakeResolver(keys={("u1", "std-server"): "sk-env"}) + manager.set_key_resolver(resolver) + await manager.call_tool("std-server", "t", user_id="u1") + + user_clients = [c for c in fake_client.instances if c.config is not None and c.config.env] + assert user_clients[-1].config.env["API_KEY"] == "sk-env" + assert user_clients[-1].config.env["API_KEY"] != "default" + + +async def test_no_saved_key_falls_back_to_default(manager, fake_client): + resolver = FakeResolver(keys={}) # user never saved a key + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + default = manager._clients["http-server"] + assert default.config.headers["Authorization"] == "Bearer default" + assert len(fake_client.instances) == 1 + + +async def test_user_client_cached_until_key_changes(manager, fake_client): + resolver = FakeResolver(keys={("u1", "http-server"): "sk-a"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + await manager.call_tool("http-server", "t", user_id="u1") + assert len(fake_client.instances) == 2 # default + one user client + + resolver.keys[("u1", "http-server")] = "sk-b" + await manager.call_tool("http-server", "t", user_id="u1") + assert len(fake_client.instances) == 3 # rebuilt on key change + + +async def test_resolver_error_falls_back_to_default(manager, fake_client): + class BrokenResolver: + async def resolve(self, user_id, server_name): + raise RuntimeError("db down") + + def set_on_change(self, cb): + pass + + manager.set_key_resolver(BrokenResolver()) + out, is_err = await manager.call_tool("http-server", "t", user_id="u1") + assert (out, is_err) == ("ok", False) + + +async def test_on_change_drops_user_clients(manager, fake_client): + resolver = FakeResolver(keys={("u1", "http-server"): "sk-a"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + uc = [c for c in fake_client.instances if c.__class__ is FakeClient and "http-server" in c.name] + user_client = uc[-1] + + resolver.invalidate("u1", "http-server") # fires on_change + assert (None, None) not in manager._user_clients + assert ("http-server", "u1") not in manager._user_clients + await asyncio.sleep(0) + assert user_client.disconnected + + +async def test_disconnect_all_tears_down_user_clients(manager, fake_client): + resolver = FakeResolver(keys={("u1", "http-server"): "sk-a"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + + await manager.disconnect_all() + assert not manager._user_clients + assert all(c.disconnected for c in fake_client.instances) + + +async def test_lru_cap_evicts_oldest(manager, fake_client): + resolver = FakeResolver(keys={(f"u{i}", "http-server"): f"sk-{i}" for i in range(40)}) + manager.set_key_resolver(resolver) + for i in range(40): + await manager.call_tool("http-server", "t", user_id=f"u{i}") + assert len(manager._user_clients) == manager_mod._USER_CLIENT_LIMIT + + +async def test_idle_eviction(manager, fake_client): + resolver = FakeResolver(keys={("u1", "http-server"): "sk"}) + manager.set_key_resolver(resolver) + await manager.call_tool("http-server", "t", user_id="u1") + + manager._evict_idle_user_clients() + assert ("http-server", "u1") in manager._user_clients + + # Backdate last-used past the idle threshold, then reap again. + client, key, _ = manager._user_clients[("http-server", "u1")] + manager._user_clients[("http-server", "u1")] = (client, key, 0.0) + manager._evict_idle_user_clients() + assert ("http-server", "u1") not in manager._user_clients + + +async def test_mcp_tool_forwards_user_id(): + """McpTool.execute прокидывает ctx.user_id в manager.call_tool.""" + from navi.mcp.tools import McpTool + from navi.tools._internal.base import ToolContext + + calls: list = [] + + class RecordingManager: + async def call_tool(self, server_name, tool_name, arguments=None, *, user_id=None): + calls.append((tool_name, arguments, user_id)) + return ("ok", False) + + tool = McpTool( + server_name="http-server", + tool_name="t1", + description="d", + parameters={}, + manager=RecordingManager(), + ) + ctx = ToolContext(session_id="s1", user_id="u9") + await tool.execute({"x": 1}, ctx) + assert calls == [("t1", {"x": 1, "session_id": "s1"}, "u9")] \ No newline at end of file diff --git a/tests/unit/test_mcp.py b/tests/unit/test_mcp.py index 9efd011..2f799b6 100644 --- a/tests/unit/test_mcp.py +++ b/tests/unit/test_mcp.py @@ -120,7 +120,9 @@ result = await tool.execute({"query": "foo"}) assert result.success assert result.output == "found 3 results" - mock_manager.call_tool.assert_awaited_once_with("book", "search", {"query": "foo"}) + mock_manager.call_tool.assert_awaited_once_with( + "book", "search", {"query": "foo"}, user_id=None + ) async def test_execute_mcp_error(self): mock_manager = AsyncMock(spec=McpManager) @@ -168,7 +170,8 @@ result = await tool.execute({"query": "foo"}) assert result.success mock_manager.call_tool.assert_awaited_once_with( - "book", "search", {"query": "foo", "session_id": "real-session-id"} + "book", "search", {"query": "foo", "session_id": "real-session-id"}, + user_id=None, ) finally: current_session_id.reset(token) diff --git a/tests/unit/tools/test_mcp_meta_tools.py b/tests/unit/tools/test_mcp_meta_tools.py new file mode 100644 index 0000000..48c5b1f --- /dev/null +++ b/tests/unit/tools/test_mcp_meta_tools.py @@ -0,0 +1,79 @@ +""""test_mcp_tool / mcp_status after the BYOK change — user key semantics.""" + +from unittest.mock import MagicMock + +from navi.mcp.config import McpServerConfig, McpUserKey +from navi.tools._internal.base import current_user_id, ToolContext +from navi.tools.mcp_status import McpStatusTool +from navi.tools.test_mcp_tool import TestMcpToolTool + + +def _configs(): + return { + "http-server": McpServerConfig( + transport="streamable_http", + url="https://x", + user_key=McpUserKey(header="Authorization", prefix="Bearer "), + ), + "plain": McpServerConfig(transport="sse", url="https://p"), + } + + +class RecordingManager: + def __init__(self): + self.calls: list = [] + self._configs_dict = _configs() + + @property + def clients(self): + client = MagicMock() + client.connected = True + return {"http-server": client, "plain": client} + + def _get_configs(self): + return self._configs_dict + + async def call_tool(self, server_name, tool_name, arguments=None, *, user_id=None): + self.calls.append((server_name, tool_name, arguments, user_id)) + return ("ok", False) + + +class TestTestMcpToolForwarding: + async def test_forwards_ctx_user_id(self): + manager = RecordingManager() + tool = TestMcpToolTool(mcp_manager=manager) + result = await tool.execute( + {"server_name": "http-server", "tool_name": "t"}, + ToolContext(session_id="s1", user_id="u9"), + ) + assert result.success + assert manager.calls == [("http-server", "t", {}, "u9")] + + async def test_forwards_contextvar_user_id_without_ctx(self): + manager = RecordingManager() + tool = TestMcpToolTool(mcp_manager=manager) + token = current_user_id.set("u7") + try: + await tool.execute({"server_name": "http-server", "tool_name": "t"}) + finally: + current_user_id.reset(token) + assert manager.calls == [("http-server", "t", {}, "u7")] + + async def test_no_user_resolves_none(self): + manager = RecordingManager() + tool = TestMcpToolTool(mcp_manager=manager) + await tool.execute({"server_name": "http-server", "tool_name": "t"}) + assert manager.calls == [("http-server", "t", {}, None)] + + +class TestMcpStatusByok: + async def test_marks_byok_servers(self): + manager = RecordingManager() + tool = McpStatusTool(mcp_manager=manager) + result = await tool.execute({}) + lines = result.output.splitlines() + idx_http = next(i for i, l in enumerate(lines) if "http-server" in l) + idx_plain = next(i for i, l in enumerate(lines) if "plain " in l) + assert "accepts a per-user key via Authorization" in lines[idx_http + 1] + assert "accepts a per-user key" not in lines[idx_plain] + assert "accepts a per-user key" not in lines[idx_plain + 1] \ No newline at end of file diff --git a/tests/unit/tools/test_notify.py b/tests/unit/tools/test_notify.py new file mode 100644 index 0000000..70cf7cb --- /dev/null +++ b/tests/unit/tools/test_notify.py @@ -0,0 +1,139 @@ +"""Tests for the notify tool — app push / Synapse legs per push_target.""" + +import pytest +from unittest.mock import AsyncMock, MagicMock + +from navi.synapse.settings_store import SynapseSettings +from navi.tools import NotifyTool +from navi.tools._internal.base import ToolContext + + +def _tool(monkeypatch, settings_row, *, push_service=None, source_ready=True): + async def fake_get(self, user_id): + return settings_row + + monkeypatch.setattr("navi.synapse.settings_store.SynapseSettingsStore.get", fake_get) + monkeypatch.setattr(NotifyTool, "_store_pool", lambda self: None) + + monkeypatch.setattr(NotifyTool, "_push_service", staticmethod(lambda: push_service)) + + import navi.synapse.outbound as outbound + + monkeypatch.setattr(outbound, "synapse_source_ready", lambda: source_ready) + emitted = [] + + async def fake_emit(**kwargs): + emitted.append(kwargs) + return MagicMock(id="ev-1") + + async def fake_emit_low_level(subject, action, payload, priority="low", dedup_key=None): + emitted.append( + {"subject": subject, "action": action, "payload": payload, + "priority": priority, "dedup_key": dedup_key} + ) + + monkeypatch.setattr(outbound, "emit_low_level", fake_emit_low_level) + return NotifyTool(), emitted + + +async def test_no_user_context_fails(monkeypatch): + tool, _ = _tool(monkeypatch, SynapseSettings(user_id="u1")) + result = await tool.execute({"message": "hi"}) + assert not result.success + assert "user" in result.error.lower() + + +async def test_empty_message_fails(monkeypatch): + tool, _ = _tool(monkeypatch, SynapseSettings(user_id="u1")) + result = await tool.execute({"message": " "}, ctx=ToolContext(user_id="u1")) + assert not result.success + + +async def test_unknown_level_fails(monkeypatch): + tool, _ = _tool(monkeypatch, SynapseSettings(user_id="u1")) + result = await tool.execute( + {"message": "hi", "level": "panic"}, ctx=ToolContext(user_id="u1") + ) + assert not result.success + assert "panic" in result.error + + +async def test_app_target_delivers_app_only(monkeypatch): + push = MagicMock(enabled=True, notify_custom=AsyncMock()) + tool, emitted = _tool(monkeypatch, SynapseSettings(user_id="u1", push_target="app"), + push_service=push) + result = await tool.execute({"message": "done"}, ctx=ToolContext(user_id="u1", session_id="s1")) + assert result.success + assert "Delivered: app" in result.output + assert "synapse" not in result.output + push.notify_custom.assert_awaited_once() + session_arg, user_arg = push.notify_custom.await_args.args + title, body = push.notify_custom.await_args.kwargs["title"], push.notify_custom.await_args.kwargs["body"] + assert (session_arg, user_arg) == ("s1", "u1") + assert body == "done" + assert emitted == [] + + +async def test_app_synapse_delivers_both(monkeypatch): + push = MagicMock(enabled=True, notify_custom=AsyncMock()) + tool, emitted = _tool(monkeypatch, SynapseSettings(user_id="u1", push_target="app_synapse"), + push_service=push) + result = await tool.execute( + {"message": "need your call", "level": "intervention"}, + ctx=ToolContext(user_id="u1"), + ) + assert result.success + assert "Delivered: app, synapse" in result.output + assert len(emitted) == 1 + assert emitted[0]["subject"] == "navi-notification" + assert emitted[0]["action"] == "intervention" + assert emitted[0]["priority"] == "critical" + + +async def test_synapse_only_skips_app(monkeypatch): + push = MagicMock(enabled=True, notify_custom=AsyncMock()) + tool, emitted = _tool(monkeypatch, SynapseSettings(user_id="u1", push_target="synapse"), + push_service=push) + result = await tool.execute({"message": "done"}, ctx=ToolContext(user_id="u1")) + assert result.success + assert "Delivered: synapse" in result.output + # the app leg is not requested at all, not "skipped" + assert "Skipped" not in result.output + push.notify_custom.assert_not_awaited() + assert len(emitted) == 1 + + +async def test_synapse_leg_skipped_when_not_configured(monkeypatch): + push = MagicMock(enabled=True, notify_custom=AsyncMock()) + tool, _ = _tool(monkeypatch, SynapseSettings(user_id="u1", push_target="synapse"), + push_service=push, source_ready=False) + result = await tool.execute({"message": "done"}, ctx=ToolContext(user_id="u1")) + assert result.success + assert "Skipped: synapse (source key not configured)" in result.output + assert "Delivered" not in result.output + + +async def test_app_leg_skipped_when_push_service_missing(monkeypatch): + tool, emitted = _tool( + monkeypatch, SynapseSettings(user_id="u1", push_target="app"), + push_service=None, source_ready=False, + ) + result = await tool.execute({"message": "done"}, ctx=ToolContext(user_id="u1")) + assert result.success + assert "Skipped: app (web push not configured)" in result.output + assert emitted == [] + + +async def test_warning_maps_to_high_priority(monkeypatch): + tool, emitted = _tool(monkeypatch, SynapseSettings(user_id="u1", push_target="synapse")) + await tool.execute({"message": "hm", "level": "warning"}, ctx=ToolContext(user_id="u1")) + assert emitted[0]["priority"] == "high" + + +def test_registered_as_builtin(): + """The tool is wired into the default registry by name.""" + from navi.core.registry import ToolRegistry + + tools = ToolRegistry() + tools.register(NotifyTool(), builtin=True) + assert tools.get("notify") is not None \ No newline at end of file diff --git a/tests/unit/tools/test_synapse_instructions.py b/tests/unit/tools/test_synapse_instructions.py new file mode 100644 index 0000000..d7c386f --- /dev/null +++ b/tests/unit/tools/test_synapse_instructions.py @@ -0,0 +1,87 @@ +"""Tests for the synapse_instructions tool and the hidden dispatcher profile.""" + +import pytest + +from navi.profiles import ALL_PROFILES +from navi.core.registry import ProfileRegistry +from navi.tools import SynapseInstructionsTool +from navi.tools._internal.base import ToolContext + + +def _tool_with_store(monkeypatch, store): + async def fake_get(self, user_id): + return store + + monkeypatch.setattr( + "navi.synapse.settings_store.SynapseSettingsStore.get", + fake_get, + ) + updates = [] + + async def fake_save_instructions(self, user_id, content, edited_by, reason=None): + updates.append((user_id, content, edited_by, reason)) + store.instructions = content + + monkeypatch.setattr( + "navi.synapse.settings_store.SynapseSettingsStore.save_instructions", + fake_save_instructions, + ) + return SynapseInstructionsTool(pool_provider=lambda: None), updates + + +async def test_read_empty(monkeypatch): + from navi.synapse.settings_store import SynapseSettings + + tool, _ = _tool_with_store(monkeypatch, SynapseSettings(user_id="u1")) + ctx = ToolContext(session_id="s1", user_id="u1") + result = await tool.execute({"op": "read"}, ctx=ctx) + assert result.success + assert "empty" in result.output.lower() + + +async def test_update_records_navi_edit(monkeypatch): + from navi.synapse.settings_store import SynapseSettings + + tool, updates = _tool_with_store(monkeypatch, SynapseSettings(user_id="u1")) + ctx = ToolContext(session_id="s1", user_id="u1") + result = await tool.execute( + {"op": "update", "content": "gntodo → developer", "reason": " clarified scope"}, + ctx=ctx, + ) + assert result.success + assert updates == [("u1", "gntodo → developer", "navi", "clarified scope")] + + +async def test_update_requires_content(monkeypatch): + from navi.synapse.settings_store import SynapseSettings + + tool, updates = _tool_with_store(monkeypatch, SynapseSettings(user_id="u1")) + ctx = ToolContext(session_id="s1", user_id="u1") + result = await tool.execute({"op": "update"}, ctx=ctx) + assert not result.success + assert updates == [] + + +async def test_no_user_context_fails(monkeypatch): + from navi.synapse.settings_store import SynapseSettings + + tool, _ = _tool_with_store(monkeypatch, SynapseSettings(user_id="u1")) + result = await tool.execute({"op": "read"}) + assert not result.success + assert "user" in result.error.lower() + + +def test_dispatcher_profile_is_hidden(): + """The dispatcher profile exists, is hidden, and the registry serves it.""" + ids = [p.id for p in ALL_PROFILES] + assert "dispatcher" in ids + assert "secretary" in ids + + reg = ProfileRegistry() + for p in ALL_PROFILES: + reg.register(p) + dispatcher = reg.get("dispatcher") + assert dispatcher.is_hidden is True + + listed = [p.id for p in reg.all() if not getattr(p, "is_hidden", False)] + assert "dispatcher" not in listed \ No newline at end of file diff --git a/tests/unit/tools/test_tasks_tool.py b/tests/unit/tools/test_tasks_tool.py index 408e38d..f3fbe2e 100644 --- a/tests/unit/tools/test_tasks_tool.py +++ b/tests/unit/tools/test_tasks_tool.py @@ -138,6 +138,59 @@ assert not result.success assert result.error == "not_running" + async def test_cancel_confirms_status(self, fresh_manager): + """A cancel on a live job waits for the terminal state (B9: honest answer).""" + job = await submit_ok(fresh_manager, delay=0.05) + result = await TasksTool().execute( + {"action": "cancel", "task_id": job.task_id}, ctx=make_ctx()) + assert result.success + assert "cancelled" in result.output + await job.done.wait() + assert job.status == "cancelled" + + async def test_cancel_raced_completion_shows_result(self, fresh_manager, monkeypatch): + """Completed-right-under-the-cancel reports the real outcome (B9).""" + import time + + job = await submit_ok(fresh_manager, delay=30, output="raced done") + # simulate the race: the job completed normally before the + # cancellation could land — terminal state published, so the tool + # must show the real result, not "cancelled". + def raced_cancel(target): + job.result = ToolResult(success=True, output="raced done") + job.status = "completed" + job.finished_at = time.time() + job.done.set() + return True + + monkeypatch.setattr(fresh_manager, "cancel", raced_cancel) + result = await TasksTool().execute( + {"action": "cancel", "task_id": job.task_id}, ctx=make_ctx()) + assert not result.success + assert result.error == "not_running" + assert "raced done" in result.output + fresh_manager.cancel(job) # cleanup the sleeper task + + async def test_cancel_of_done_task_shows_result(self, fresh_manager): + """Task already done but status not yet flipped: no false 'cancelled'.""" + from navi.core.tasks import TaskJob + + async def done_coro(): + return ToolResult(success=True, output="real result") + + job = TaskJob(task_id="bt-deadbeef", session_id="s1", tool="code_exec", args={}) + job.status = "completed" + job.result = ToolResult(success=True, output="real result") + job.task = asyncio.create_task(done_coro()) + await asyncio.sleep(0) # let it finish + job.done.set() + fresh_manager._jobs[job.task_id] = job + result = await TasksTool().execute( + {"action": "cancel", "task_id": job.task_id}, ctx=make_ctx()) + assert not result.success + assert result.error == "not_running" + assert "real result" in result.output + class TestFallbacks: async def test_session_falls_back_to_contextvar(self, fresh_manager, monkeypatch): diff --git a/tests/unit/workers/test_compression_worker.py b/tests/unit/workers/test_compression_worker.py index b100123..ed3ad10 100644 --- a/tests/unit/workers/test_compression_worker.py +++ b/tests/unit/workers/test_compression_worker.py @@ -134,6 +134,41 @@ assert all(m.is_context is False for m in dropped) +@pytest.mark.asyncio +async def test_worker_demotes_context_only_summaries_after_reload(): + """After a session reload, old summaries (is_display=False) exist in + session.context but NOT in session.messages. The demotion loop must cover + both lists — otherwise stale summaries keep is_context=True in the DB and + pile up in the context (they once built up to half of one session's + context: 6 copies, 120k of 239k chars).""" + worker = CompressionWorker() + backend = FakeLLMBackend(responses=["fresh summary"]) + store = InMemorySessionStore() + session = Session(profile_id="test") + store._sessions[session.id] = session + + old_summary = Message( + role="user", content="old summary text", is_summary=True, + is_display=False, is_context=True, + ) + context = [old_summary] + for i in range(10): + context.append(Message(role="user", content=f"task {i}")) + context.append(Message(role="assistant", content=f"answer {i}")) + session.context = list(context) + # Reload state: display history has no context-only rows. + session.messages = [m for m in context if not m.is_summary] + + result = await worker.run(session, _ctx(session.id, backend, store)) + assert any(isinstance(ev, ContextCompressed) for ev in result.events) + # The stale summary is demoted even though it is absent from session.messages. + assert old_summary.is_context is False + kept_summaries = [m for m in session.context if m.is_summary] + assert len(kept_summaries) == 1 + assert kept_summaries[0] is not old_summary + assert "fresh summary" in kept_summaries[0].content + + def test_worker_keep_recent_messages_mirrors_midturn(): """The worker passes keep_recent_messages=max(12, context_keep_recent*2), matching the midturn auto-compress path (source of truth for the intra-turn diff --git a/webclient/CLAUDE.md b/webclient/CLAUDE.md index bc196ee..20813e6 100644 --- a/webclient/CLAUDE.md +++ b/webclient/CLAUDE.md @@ -67,3 +67,27 @@ - Tool call visibility — the user wants to see what the agent is doing - Thinking blocks — collapsible, clearly separated from the response - Profile indicator and ability to create sessions with a specific profile + +## Design system (gnexus-ui-kit v1.0) + +Full component docs, rules and demo live in the vendored copy: +**`vendor/gnexus-ui-kit/CLAUDE.md`** — read it before styling anything. + +Facts specific to this app: + +- Kit is consumed as **prebuilt CSS**: `import 'gnexus-ui-kit/css'` in `src/main.js` + (kit v1.0's `_fonts.scss` references fonts by relative url(), which breaks + Sass source compilation — the Vite bundler resolves them instead). +- **Theme**: default dark `dist/css/kit.css`. No theme switcher. +- **Tokens**: CSS variables `--gn-*` (colors/surfaces/borders/motion/spacing) + everywhere in styles; SCSS structural tokens (`$space-*`, `$color-*`, `$border-*`, + `focus_ring`) via `@use 'kit-deps' as *` (aliased to `vendor/gnexus-ui-kit/src/scss` + in loadPaths). Typography tokens are NOT exported by kit-deps — use the + `--gn-font-*` CSS variables or literals. +- **Icons**: Phosphor web font. Icon props and classes must carry the `ph` base + class and `ph-` prefix (`ph ph-copy`, or `ph-copy` is auto-prefixed by kit). +- App-owned classes (`.card-grid-*`, `.card-modal-*` on CardGrid content, chat + domain cards, `.session-item`) are locked by tests — do not rename. +- Surfaces intentionally NOT kit components (documented escape hatches): + LoginScreen (SSO redirect, GnLoginCard doesn't fit), chat domain cards, + MessageList, ImageLightbox. diff --git a/webclient/dist/assets/IBMPlexMono-Bold-Ovd3DSUS.ttf b/webclient/dist/assets/IBMPlexMono-Bold-Ovd3DSUS.ttf new file mode 100644 index 0000000..247979c --- /dev/null +++ b/webclient/dist/assets/IBMPlexMono-Bold-Ovd3DSUS.ttf Binary files differ diff --git a/webclient/dist/assets/IBMPlexMono-Italic-DgAgaWWu.ttf b/webclient/dist/assets/IBMPlexMono-Italic-DgAgaWWu.ttf new file mode 100644 index 0000000..e259e84 --- /dev/null +++ b/webclient/dist/assets/IBMPlexMono-Italic-DgAgaWWu.ttf Binary files differ diff --git a/webclient/dist/assets/IBMPlexMono-Medium-COFd06Dj.ttf b/webclient/dist/assets/IBMPlexMono-Medium-COFd06Dj.ttf new file mode 100644 index 0000000..8253c5f --- /dev/null +++ b/webclient/dist/assets/IBMPlexMono-Medium-COFd06Dj.ttf Binary files differ diff --git a/webclient/dist/assets/IBMPlexMono-Regular-BF3vfe7_.ttf b/webclient/dist/assets/IBMPlexMono-Regular-BF3vfe7_.ttf new file mode 100644 index 0000000..601ae94 --- /dev/null +++ b/webclient/dist/assets/IBMPlexMono-Regular-BF3vfe7_.ttf Binary files differ diff --git a/webclient/dist/assets/IBMPlexMono-SemiBold-D0J2bq8P.ttf b/webclient/dist/assets/IBMPlexMono-SemiBold-D0J2bq8P.ttf new file mode 100644 index 0000000..5e0b41d --- /dev/null +++ b/webclient/dist/assets/IBMPlexMono-SemiBold-D0J2bq8P.ttf Binary files differ diff --git a/webclient/dist/assets/Phosphor-BXRFlF4V.svg b/webclient/dist/assets/Phosphor-BXRFlF4V.svg new file mode 100644 index 0000000..8e62676 --- /dev/null +++ b/webclient/dist/assets/Phosphor-BXRFlF4V.svg @@ -0,0 +1,3056 @@ + + + + + + +{ + "fontFamily": "Phosphor", + "majorVersion": 2, + "minorVersion": 1, + "fontURL": "https://phosphoricons.com", + "description": "A flexible icon family for everyone\nFont generated by IcoMoon.", + "copyright": "Phosphor Icons", + "designer": "Tobias Fried & Helena Zhang", + "designerURL": "https://phosphoricons.com", + "license": "MIT", + "licenseURL": "https://raw.githubusercontent.com/phosphor-icons/homepage/master/LICENSE", + "version": "Version 2.1", + "fontId": "Phosphor", + "psName": "Phosphor", + "subFamily": "Regular", + "fullName": "Phosphor" +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/webclient/dist/assets/Phosphor-BdqudwT5.woff b/webclient/dist/assets/Phosphor-BdqudwT5.woff new file mode 100644 index 0000000..c48057d --- /dev/null +++ b/webclient/dist/assets/Phosphor-BdqudwT5.woff Binary files differ diff --git a/webclient/dist/assets/Phosphor-CDxgqcPu.ttf b/webclient/dist/assets/Phosphor-CDxgqcPu.ttf new file mode 100644 index 0000000..7c1b8a7 --- /dev/null +++ b/webclient/dist/assets/Phosphor-CDxgqcPu.ttf Binary files differ diff --git a/webclient/dist/assets/Phosphor-DtdjzkpE.woff2 b/webclient/dist/assets/Phosphor-DtdjzkpE.woff2 new file mode 100644 index 0000000..76ff203 --- /dev/null +++ b/webclient/dist/assets/Phosphor-DtdjzkpE.woff2 Binary files differ diff --git a/webclient/dist/assets/fonts/phosphor-icons/LICENSE b/webclient/dist/assets/fonts/phosphor-icons/LICENSE deleted file mode 100644 index c04a19d..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2020-2021 Phosphor Icons - -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/webclient/dist/assets/fonts/phosphor-icons/README.md b/webclient/dist/assets/fonts/phosphor-icons/README.md deleted file mode 100644 index 5dfcfcc..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/README.md +++ /dev/null @@ -1,138 +0,0 @@ - - -# phosphor-icons - -Phosphor is a flexible icon family for interfaces, diagrams, presentations — whatever, really. Explore all our icons at [phosphoricons.com](https://phosphoricons.com). - -[![NPM](https://img.shields.io/npm/v/phosphor-icons.svg?style=flat-square)](https://www.npmjs.com/package/phosphor-icons) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com) [![Travis](https://img.shields.io/travis/com/rektdeckard/phosphor-icons.svg?style=flat-square)](https://travis-ci.com/github/rektdeckard/phosphor-icons) - -[![GitHub stars](https://img.shields.io/github/stars/phosphor-icons/phosphor-icons?style=flat-square&label=Star)](https://github.com/phosphor-icons/phosphor-icons) -[![GitHub forks](https://img.shields.io/github/forks/phosphor-icons/phosphor-icons?style=flat-square&label=Fork)](https://github.com/phosphor-icons/phosphor-icons/fork) -[![GitHub watchers](https://img.shields.io/github/watchers/phosphor-icons/phosphor-icons?style=flat-square&label=Watch)](https://github.com/phosphor-icons/phosphor-icons) -[![Follow on GitHub](https://img.shields.io/github/followers/rektdeckard?style=flat-square&label=Follow)](https://github.com/rektdeckard) - -## Usage - -### Getting Started - -We use a similar approach as many other icon sets out there, providing icons as a webfont that uses Unicode's Private Use Area character codes to map normally non-rendering characters to icons. But you don't need to know that. All you need to do is add the script to the document ``, and drop in icons with an `` tag and the appropriate class: - -```html - - - - - - - - - - - -``` - -> **Note:** For stability, you may choose to source a specific version of Phosphor by adding the version to the script URL, for example: `https://unpkg.com/phosphor-icons@1.3.2`. The CDN supports version ranges. - -### Styling - -Since the icons are just text under the hood, they can be colored and styled with CSS like any other font, including `font-size`, `color`, etc. We include several helper classes to provide easy sizing if you need it: - -```css -.ph-xxs { - font-size: 0.5em; -} -.ph-xs { - font-size: 0.75em; -} -.ph-sm { - font-size: 0.875em; -} -.ph-lg { - font-size: 1.3333em; - line-height: 0.75em; - vertical-align: -0.0667em; -} -.ph-xl { - font-size: 1.5em; - line-height: 0.6666em; - vertical-align: -0.075em; -} -.ph-1x { - font-size: 1em; -} -.ph-2x { - font-size: 2em; -} -.ph-3x { - font-size: 3em; -} -.ph-4x { - font-size: 4em; -} -.ph-5x { - font-size: 5em; -} -.ph-6x { - font-size: 6em; -} -.ph-7x { - font-size: 7em; -} -.ph-8x { - font-size: 8em; -} -.ph-9x { - font-size: 9em; -} -.ph-10x { - font-size: 10em; -} -.ph-fw { - text-align: center; - width: 1.25em; -} -``` - -> **Note:** Overriding the `font-family`, `font-style`, `font-weight`, `font-variant`, or `text-transform` may break the icons and render unprintable characters. Don't do it. - -> **Note:** The `duotone` weight is not yet available for this implementation, as fonts do not support baked-in alpha/opacity. In future we plan to move to an SVG-based approach with full support for all icon weights. - -### Ligatures - -The icon font now supports ligatures, meaning that in any text using `font-family: "Phosphor"`, writing the name of an icon (without the `ph-` prefix) will convert to the corresponding icon. The largest possible string will be matched, meaning you can use any available weight, and print multiple icons without separating with spaces or other characters if you choose. - -```html - - - - - - - -

sword-fill shield

- - -``` - -## Our Related Projects - -- [phosphor-home](https://github.com/phosphor-icons/phosphor-home) ▲ Phosphor homepage and general info -- [phosphor-react](https://github.com/phosphor-icons/phosphor-react) ▲ Phosphor icon component library for React -- [phosphor-vue](https://github.com/phosphor-icons/phosphor-vue) ▲ Phosphor icon component library for Vue -- [phosphor-flutter](https://github.com/phosphor-icons/phosphor-flutter) ▲ Phosphor IconData library for Flutter -- [phosphor-webcomponents](https://github.com/phosphor-icons/phosphor-webcomponents) ▲ Phosphor icons as Web Components -- [phosphor-figma](https://github.com/phosphor-icons/phosphor-figma) ▲ Phosphor icons Figma plugin -- [phosphor-sketch](https://github.com/phosphor-icons/phosphor-sketch) ▲ Phosphor icons Sketch plugin - -## Community Projects - -- [phosphor-react-native](https://github.com/duongdev/phosphor-react-native) ▲ Phosphor icon component library for React Native -- [phosphor-svelte](https://github.com/haruaki07/phosphor-svelte) ▲ Phosphor icons for Svelte apps -- [phosphor-r](https://github.com/dreamRs/phosphoricons) ▲ Phosphor icon wrapper for R documents and applications -- [blade-phosphor-icons](https://github.com/codeat3/blade-phosphor-icons) ▲ Phosphor icons in your Laravel Blade views - -If you've made a port of Phosphor and you want to see it here, just open a PR [here](https://github.com/phosphor-icons/phosphor-home)! - -## License - -MIT © [Phosphor Icons](https://github.com/phosphor-icons) diff --git a/webclient/dist/assets/fonts/phosphor-icons/package.json b/webclient/dist/assets/fonts/phosphor-icons/package.json deleted file mode 100644 index c341b84..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/package.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "name": "phosphor-icons", - "version": "1.4.2", - "description": "A clean and friendly icon family for web", - "main": "src/index.js", - "files": [ - "src" - ], - "scripts": { - "test": "http-server -o /test", - "collate": "node ./bin/collate.js", - "icomoon": "node ./bin/icomoon.js" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/phosphor-icons/phosphor-icons.git" - }, - "keywords": [ - "icons", - "icon-pack", - "web", - "html", - "css", - "svg", - "svg-icons", - "icon-font" - ], - "author": "rektdeckard", - "license": "MIT", - "bugs": { - "url": "https://github.com/phosphor-icons/phosphor-icons/issues" - }, - "homepage": "https://phosphoricons.com", - "devDependencies": { - "chalk": "^4.1.0", - "svgson": "^5.2.1" - } -} diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/css/icons.css b/webclient/dist/assets/fonts/phosphor-icons/src/css/icons.css deleted file mode 100644 index ba57b05..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/css/icons.css +++ /dev/null @@ -1,21038 +0,0 @@ -/*-------------------------------- - -Phosphor Web Font -Generated using nucleoapp.com - --------------------------------- */ -@font-face { - font-family: "Phosphor"; - src: url(data:font/opentype;charset=utf-8;base64,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); - src: url(data:font/x-font-woff;charset=utf-8;base64,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) - format("woff"), - url(data:font/truetype;charset=utf-8;base64,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) - format("truetype"); - font-weight: normal; - font-style: normal; -} -/*------------------------ - base class definition --------------------------*/ -[class^="ph-"], -[class*=" ph-"] { - display: inline-flex; -} - -[class^="ph-"]:before, -[class*=" ph-"]:before { - font: normal normal normal 1em/1 "Phosphor"; - color: inherit; - flex-shrink: 0; - speak: none; - text-transform: none; - text-decoration: inherit; - text-align: center; - /* Better Font Rendering */ - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; -} -/*------------------------ - change icon size --------------------------*/ -/* relative units */ -.ph-xxs { - font-size: 0.5em; -} -.ph-xs { - font-size: 0.75em; -} -.ph-sm { - font-size: 0.875em; -} -.ph-lg { - font-size: 1.3333em; - line-height: 0.75em; - vertical-align: -0.0667em; -} -.ph-xl { - font-size: 1.5em; - line-height: 0.6666em; - vertical-align: -0.075em; -} -.ph-1x { - font-size: 1em; -} -.ph-2x { - font-size: 2em; -} -.ph-3x { - font-size: 3em; -} -.ph-4x { - font-size: 4em; -} -.ph-5x { - font-size: 5em; -} -.ph-6x { - font-size: 6em; -} -.ph-7x { - font-size: 7em; -} -.ph-8x { - font-size: 8em; -} -.ph-9x { - font-size: 9em; -} -.ph-10x { - font-size: 10em; -} -.ph-fw { - text-align: center; - width: 1.25em; -} - -/*------------------------ - icons --------------------------*/ - -.ph-activity-thin::before { - content: "\ea02"; -} - -.ph-address-book-thin::before { - content: "\ea03"; -} - -.ph-airplane-in-flight-thin::before { - content: "\ea04"; -} - -.ph-airplane-landing-thin::before { - content: "\ea05"; -} - -.ph-airplane-takeoff-thin::before { - content: "\ea06"; -} - -.ph-airplane-thin::before { - content: "\ea07"; -} - -.ph-airplane-tilt-thin::before { - content: "\ea08"; -} - -.ph-airplay-thin::before { - content: "\ea09"; -} - -.ph-alarm-thin::before { - content: "\ea0a"; -} - -.ph-alien-thin::before { - content: "\ea0b"; -} - -.ph-align-bottom-simple-thin::before { - content: "\ea0c"; -} - -.ph-align-bottom-thin::before { - content: "\ea0d"; -} - -.ph-align-center-horizontal-simple-thin::before { - content: "\ea0e"; -} - -.ph-align-center-horizontal-thin::before { - content: "\ea0f"; -} - -.ph-align-center-vertical-simple-thin::before { - content: "\ea10"; -} - -.ph-align-center-vertical-thin::before { - content: "\ea11"; -} - -.ph-align-left-simple-thin::before { - content: "\ea12"; -} - -.ph-align-left-thin::before { - content: "\ea13"; -} - -.ph-align-right-simple-thin::before { - content: "\ea14"; -} - -.ph-align-right-thin::before { - content: "\ea15"; -} - -.ph-align-top-simple-thin::before { - content: "\ea16"; -} - -.ph-align-top-thin::before { - content: "\ea17"; -} - -.ph-anchor-simple-thin::before { - content: "\ea18"; -} - -.ph-anchor-thin::before { - content: "\ea19"; -} - -.ph-android-logo-thin::before { - content: "\ea1a"; -} - -.ph-angular-logo-thin::before { - content: "\ea1b"; -} - -.ph-aperture-thin::before { - content: "\ea1c"; -} - -.ph-app-store-logo-thin::before { - content: "\ea1d"; -} - -.ph-app-window-thin::before { - content: "\ea1e"; -} - -.ph-apple-logo-thin::before { - content: "\ea1f"; -} - -.ph-apple-podcasts-logo-thin::before { - content: "\ea20"; -} - -.ph-archive-box-thin::before { - content: "\ea21"; -} - -.ph-archive-thin::before { - content: "\ea22"; -} - -.ph-archive-tray-thin::before { - content: "\ea23"; -} - -.ph-armchair-thin::before { - content: "\ea24"; -} - -.ph-arrow-arc-left-thin::before { - content: "\ea25"; -} - -.ph-arrow-arc-right-thin::before { - content: "\ea26"; -} - -.ph-arrow-bend-double-up-left-thin::before { - content: "\ea27"; -} - -.ph-arrow-bend-double-up-right-thin::before { - content: "\ea28"; -} - -.ph-arrow-bend-down-left-thin::before { - content: "\ea29"; -} - -.ph-arrow-bend-down-right-thin::before { - content: "\ea2a"; -} - -.ph-arrow-bend-left-down-thin::before { - content: "\ea2b"; -} - -.ph-arrow-bend-left-up-thin::before { - content: "\ea2c"; -} - -.ph-arrow-bend-right-down-thin::before { - content: "\ea2d"; -} - -.ph-arrow-bend-right-up-thin::before { - content: "\ea2e"; -} - -.ph-arrow-bend-up-left-thin::before { - content: "\ea2f"; -} - -.ph-arrow-bend-up-right-thin::before { - content: "\ea30"; -} - -.ph-arrow-circle-down-left-thin::before { - content: "\ea31"; -} - -.ph-arrow-circle-down-right-thin::before { - content: "\ea32"; -} - -.ph-arrow-circle-down-thin::before { - content: "\ea33"; -} - -.ph-arrow-circle-left-thin::before { - content: "\ea34"; -} - -.ph-arrow-circle-right-thin::before { - content: "\ea35"; -} - -.ph-arrow-circle-up-left-thin::before { - content: "\ea36"; -} - -.ph-arrow-circle-up-right-thin::before { - content: "\ea37"; -} - -.ph-arrow-circle-up-thin::before { - content: "\ea38"; -} - -.ph-arrow-clockwise-thin::before { - content: "\ea39"; -} - -.ph-arrow-counter-clockwise-thin::before { - content: "\ea3a"; -} - -.ph-arrow-down-left-thin::before { - content: "\ea3b"; -} - -.ph-arrow-down-right-thin::before { - content: "\ea3c"; -} - -.ph-arrow-down-thin::before { - content: "\ea3d"; -} - -.ph-arrow-elbow-down-left-thin::before { - content: "\ea3e"; -} - -.ph-arrow-elbow-down-right-thin::before { - content: "\ea3f"; -} - -.ph-arrow-elbow-left-down-thin::before { - content: "\ea40"; -} - -.ph-arrow-elbow-left-thin::before { - content: "\ea41"; -} - -.ph-arrow-elbow-left-up-thin::before { - content: "\ea42"; -} - -.ph-arrow-elbow-right-down-thin::before { - content: "\ea43"; -} - -.ph-arrow-elbow-right-thin::before { - content: "\ea44"; -} - -.ph-arrow-elbow-right-up-thin::before { - content: "\ea45"; -} - -.ph-arrow-elbow-up-left-thin::before { - content: "\ea46"; -} - -.ph-arrow-elbow-up-right-thin::before { - content: "\ea47"; -} - -.ph-arrow-fat-down-thin::before { - content: "\ea48"; -} - -.ph-arrow-fat-left-thin::before { - content: "\ea49"; -} - -.ph-arrow-fat-line-down-thin::before { - content: "\ea4a"; -} - -.ph-arrow-fat-line-left-thin::before { - content: "\ea4b"; -} - -.ph-arrow-fat-line-right-thin::before { - content: "\ea4c"; -} - -.ph-arrow-fat-line-up-thin::before { - content: "\ea4d"; -} - -.ph-arrow-fat-lines-down-thin::before { - content: "\ea4e"; -} - -.ph-arrow-fat-lines-left-thin::before { - content: "\ea4f"; -} - -.ph-arrow-fat-lines-right-thin::before { - content: "\ea50"; -} - -.ph-arrow-fat-lines-up-thin::before { - content: "\ea51"; -} - -.ph-arrow-fat-right-thin::before { - content: "\ea52"; -} - -.ph-arrow-fat-up-thin::before { - content: "\ea53"; -} - -.ph-arrow-left-thin::before { - content: "\ea54"; -} - -.ph-arrow-line-down-left-thin::before { - content: "\ea55"; -} - -.ph-arrow-line-down-right-thin::before { - content: "\ea56"; -} - -.ph-arrow-line-down-thin::before { - content: "\ea57"; -} - -.ph-arrow-line-left-thin::before { - content: "\ea58"; -} - -.ph-arrow-line-right-thin::before { - content: "\ea59"; -} - -.ph-arrow-line-up-left-thin::before { - content: "\ea5a"; -} - -.ph-arrow-line-up-right-thin::before { - content: "\ea5b"; -} - -.ph-arrow-line-up-thin::before { - content: "\ea5c"; -} - -.ph-arrow-right-thin::before { - content: "\ea5d"; -} - -.ph-arrow-square-down-left-thin::before { - content: "\ea5e"; -} - -.ph-arrow-square-down-right-thin::before { - content: "\ea5f"; -} - -.ph-arrow-square-down-thin::before { - content: "\ea60"; -} - -.ph-arrow-square-in-thin::before { - content: "\ea61"; -} - -.ph-arrow-square-left-thin::before { - content: "\ea62"; -} - -.ph-arrow-square-out-thin::before { - content: "\ea63"; -} - -.ph-arrow-square-right-thin::before { - content: "\ea64"; -} - -.ph-arrow-square-up-left-thin::before { - content: "\ea65"; -} - -.ph-arrow-square-up-right-thin::before { - content: "\ea66"; -} - -.ph-arrow-square-up-thin::before { - content: "\ea67"; -} - -.ph-arrow-u-down-left-thin::before { - content: "\ea68"; -} - -.ph-arrow-u-down-right-thin::before { - content: "\ea69"; -} - -.ph-arrow-u-left-down-thin::before { - content: "\ea6a"; -} - -.ph-arrow-u-left-up-thin::before { - content: "\ea6b"; -} - -.ph-arrow-u-right-down-thin::before { - content: "\ea6c"; -} - -.ph-arrow-u-right-up-thin::before { - content: "\ea6d"; -} - -.ph-arrow-u-up-left-thin::before { - content: "\ea6e"; -} - -.ph-arrow-u-up-right-thin::before { - content: "\ea6f"; -} - -.ph-arrow-up-left-thin::before { - content: "\ea70"; -} - -.ph-arrow-up-right-thin::before { - content: "\ea71"; -} - -.ph-arrow-up-thin::before { - content: "\ea72"; -} - -.ph-arrows-clockwise-thin::before { - content: "\ea73"; -} - -.ph-arrows-counter-clockwise-thin::before { - content: "\ea74"; -} - -.ph-arrows-down-up-thin::before { - content: "\ea75"; -} - -.ph-arrows-horizontal-thin::before { - content: "\ea76"; -} - -.ph-arrows-in-cardinal-thin::before { - content: "\ea77"; -} - -.ph-arrows-in-line-horizontal-thin::before { - content: "\ea78"; -} - -.ph-arrows-in-line-vertical-thin::before { - content: "\ea79"; -} - -.ph-arrows-in-simple-thin::before { - content: "\ea7a"; -} - -.ph-arrows-in-thin::before { - content: "\ea7b"; -} - -.ph-arrows-left-right-thin::before { - content: "\ea7c"; -} - -.ph-arrows-out-cardinal-thin::before { - content: "\ea7d"; -} - -.ph-arrows-out-line-horizontal-thin::before { - content: "\ea7e"; -} - -.ph-arrows-out-line-vertical-thin::before { - content: "\ea7f"; -} - -.ph-arrows-out-simple-thin::before { - content: "\ea80"; -} - -.ph-arrows-out-thin::before { - content: "\ea81"; -} - -.ph-arrows-vertical-thin::before { - content: "\ea82"; -} - -.ph-article-medium-thin::before { - content: "\ea83"; -} - -.ph-article-ny-times-thin::before { - content: "\ea84"; -} - -.ph-article-thin::before { - content: "\ea85"; -} - -.ph-asterisk-simple-thin::before { - content: "\ea86"; -} - -.ph-asterisk-thin::before { - content: "\ea87"; -} - -.ph-at-thin::before { - content: "\ea88"; -} - -.ph-atom-thin::before { - content: "\ea89"; -} - -.ph-baby-thin::before { - content: "\ea8a"; -} - -.ph-backpack-thin::before { - content: "\ea8b"; -} - -.ph-backspace-thin::before { - content: "\ea8c"; -} - -.ph-bag-simple-thin::before { - content: "\ea8d"; -} - -.ph-bag-thin::before { - content: "\ea8e"; -} - -.ph-balloon-thin::before { - content: "\ea8f"; -} - -.ph-bandaids-thin::before { - content: "\ea90"; -} - -.ph-bank-thin::before { - content: "\ea91"; -} - -.ph-barbell-thin::before { - content: "\ea92"; -} - -.ph-barcode-thin::before { - content: "\ea93"; -} - -.ph-barricade-thin::before { - content: "\ea94"; -} - -.ph-baseball-thin::before { - content: "\ea95"; -} - -.ph-basketball-thin::before { - content: "\ea96"; -} - -.ph-bathtub-thin::before { - content: "\ea97"; -} - -.ph-battery-charging-thin::before { - content: "\ea98"; -} - -.ph-battery-charging-vertical-thin::before { - content: "\ea99"; -} - -.ph-battery-empty-thin::before { - content: "\ea9a"; -} - -.ph-battery-full-thin::before { - content: "\ea9b"; -} - -.ph-battery-high-thin::before { - content: "\ea9c"; -} - -.ph-battery-low-thin::before { - content: "\ea9d"; -} - -.ph-battery-medium-thin::before { - content: "\ea9e"; -} - -.ph-battery-plus-thin::before { - content: "\ea9f"; -} - -.ph-battery-warning-thin::before { - content: "\eaa0"; -} - -.ph-battery-warning-vertical-thin::before { - content: "\eaa1"; -} - -.ph-bed-thin::before { - content: "\eaa2"; -} - -.ph-beer-bottle-thin::before { - content: "\eaa3"; -} - -.ph-behance-logo-thin::before { - content: "\eaa4"; -} - -.ph-bell-ringing-thin::before { - content: "\eaa5"; -} - -.ph-bell-simple-ringing-thin::before { - content: "\eaa6"; -} - -.ph-bell-simple-slash-thin::before { - content: "\eaa7"; -} - -.ph-bell-simple-thin::before { - content: "\eaa8"; -} - -.ph-bell-simple-z-thin::before { - content: "\eaa9"; -} - -.ph-bell-slash-thin::before { - content: "\eaaa"; -} - -.ph-bell-thin::before { - content: "\eaab"; -} - -.ph-bell-z-thin::before { - content: "\eaac"; -} - -.ph-bezier-curve-thin::before { - content: "\eaad"; -} - -.ph-bicycle-thin::before { - content: "\eaae"; -} - -.ph-binoculars-thin::before { - content: "\eaaf"; -} - -.ph-bird-thin::before { - content: "\eab0"; -} - -.ph-bluetooth-connected-thin::before { - content: "\eab1"; -} - -.ph-bluetooth-slash-thin::before { - content: "\eab2"; -} - -.ph-bluetooth-thin::before { - content: "\eab3"; -} - -.ph-bluetooth-x-thin::before { - content: "\eab4"; -} - -.ph-boat-thin::before { - content: "\eab5"; -} - -.ph-book-bookmark-thin::before { - content: "\eab6"; -} - -.ph-book-open-thin::before { - content: "\eab7"; -} - -.ph-book-thin::before { - content: "\eab8"; -} - -.ph-bookmark-simple-thin::before { - content: "\eab9"; -} - -.ph-bookmark-thin::before { - content: "\eaba"; -} - -.ph-bookmarks-simple-thin::before { - content: "\eabb"; -} - -.ph-bookmarks-thin::before { - content: "\eabc"; -} - -.ph-books-thin::before { - content: "\eabd"; -} - -.ph-bounding-box-thin::before { - content: "\eabe"; -} - -.ph-brackets-angle-thin::before { - content: "\eabf"; -} - -.ph-brackets-curly-thin::before { - content: "\eac0"; -} - -.ph-brackets-round-thin::before { - content: "\eac1"; -} - -.ph-brackets-square-thin::before { - content: "\eac2"; -} - -.ph-brain-thin::before { - content: "\eac3"; -} - -.ph-brandy-thin::before { - content: "\eac4"; -} - -.ph-briefcase-metal-thin::before { - content: "\eac5"; -} - -.ph-briefcase-thin::before { - content: "\eac6"; -} - -.ph-broadcast-thin::before { - content: "\eac7"; -} - -.ph-browser-thin::before { - content: "\eac8"; -} - -.ph-browsers-thin::before { - content: "\eac9"; -} - -.ph-bug-beetle-thin::before { - content: "\eaca"; -} - -.ph-bug-droid-thin::before { - content: "\eacb"; -} - -.ph-bug-thin::before { - content: "\eacc"; -} - -.ph-buildings-thin::before { - content: "\eacd"; -} - -.ph-bus-thin::before { - content: "\eace"; -} - -.ph-butterfly-thin::before { - content: "\eacf"; -} - -.ph-cactus-thin::before { - content: "\ead0"; -} - -.ph-cake-thin::before { - content: "\ead1"; -} - -.ph-calculator-thin::before { - content: "\ead2"; -} - -.ph-calendar-blank-thin::before { - content: "\ead3"; -} - -.ph-calendar-check-thin::before { - content: "\ead4"; -} - -.ph-calendar-plus-thin::before { - content: "\ead5"; -} - -.ph-calendar-thin::before { - content: "\ead6"; -} - -.ph-calendar-x-thin::before { - content: "\ead7"; -} - -.ph-camera-rotate-thin::before { - content: "\ead8"; -} - -.ph-camera-slash-thin::before { - content: "\ead9"; -} - -.ph-camera-thin::before { - content: "\eada"; -} - -.ph-campfire-thin::before { - content: "\eadb"; -} - -.ph-car-simple-thin::before { - content: "\eadc"; -} - -.ph-car-thin::before { - content: "\eadd"; -} - -.ph-cardholder-thin::before { - content: "\eade"; -} - -.ph-cards-thin::before { - content: "\eadf"; -} - -.ph-caret-circle-double-down-thin::before { - content: "\eae0"; -} - -.ph-caret-circle-double-left-thin::before { - content: "\eae1"; -} - -.ph-caret-circle-double-right-thin::before { - content: "\eae2"; -} - -.ph-caret-circle-double-up-thin::before { - content: "\eae3"; -} - -.ph-caret-circle-down-thin::before { - content: "\eae4"; -} - -.ph-caret-circle-left-thin::before { - content: "\eae5"; -} - -.ph-caret-circle-right-thin::before { - content: "\eae6"; -} - -.ph-caret-circle-up-thin::before { - content: "\eae7"; -} - -.ph-caret-double-down-thin::before { - content: "\eae8"; -} - -.ph-caret-double-left-thin::before { - content: "\eae9"; -} - -.ph-caret-double-right-thin::before { - content: "\eaea"; -} - -.ph-caret-double-up-thin::before { - content: "\eaeb"; -} - -.ph-caret-down-thin::before { - content: "\eaec"; -} - -.ph-caret-left-thin::before { - content: "\eaed"; -} - -.ph-caret-right-thin::before { - content: "\eaee"; -} - -.ph-caret-up-thin::before { - content: "\eaef"; -} - -.ph-cat-thin::before { - content: "\eaf0"; -} - -.ph-cell-signal-full-thin::before { - content: "\eaf1"; -} - -.ph-cell-signal-high-thin::before { - content: "\eaf2"; -} - -.ph-cell-signal-low-thin::before { - content: "\eaf3"; -} - -.ph-cell-signal-medium-thin::before { - content: "\eaf4"; -} - -.ph-cell-signal-none-thin::before { - content: "\eaf5"; -} - -.ph-cell-signal-slash-thin::before { - content: "\eaf6"; -} - -.ph-cell-signal-x-thin::before { - content: "\eaf7"; -} - -.ph-chalkboard-simple-thin::before { - content: "\eaf8"; -} - -.ph-chalkboard-teacher-thin::before { - content: "\eaf9"; -} - -.ph-chalkboard-thin::before { - content: "\eafa"; -} - -.ph-chart-bar-horizontal-thin::before { - content: "\eafb"; -} - -.ph-chart-bar-thin::before { - content: "\eafc"; -} - -.ph-chart-line-thin::before { - content: "\eafd"; -} - -.ph-chart-line-up-thin::before { - content: "\eafe"; -} - -.ph-chart-pie-slice-thin::before { - content: "\eaff"; -} - -.ph-chart-pie-thin::before { - content: "\eb00"; -} - -.ph-chat-centered-dots-thin::before { - content: "\eb01"; -} - -.ph-chat-centered-text-thin::before { - content: "\eb02"; -} - -.ph-chat-centered-thin::before { - content: "\eb03"; -} - -.ph-chat-circle-dots-thin::before { - content: "\eb04"; -} - -.ph-chat-circle-text-thin::before { - content: "\eb05"; -} - -.ph-chat-circle-thin::before { - content: "\eb06"; -} - -.ph-chat-dots-thin::before { - content: "\eb07"; -} - -.ph-chat-teardrop-dots-thin::before { - content: "\eb08"; -} - -.ph-chat-teardrop-text-thin::before { - content: "\eb09"; -} - -.ph-chat-teardrop-thin::before { - content: "\eb0a"; -} - -.ph-chat-text-thin::before { - content: "\eb0b"; -} - -.ph-chat-thin::before { - content: "\eb0c"; -} - -.ph-chats-circle-thin::before { - content: "\eb0d"; -} - -.ph-chats-teardrop-thin::before { - content: "\eb0e"; -} - -.ph-chats-thin::before { - content: "\eb0f"; -} - -.ph-check-circle-thin::before { - content: "\eb10"; -} - -.ph-check-square-offset-thin::before { - content: "\eb11"; -} - -.ph-check-square-thin::before { - content: "\eb12"; -} - -.ph-check-thin::before { - content: "\eb13"; -} - -.ph-checks-thin::before { - content: "\eb14"; -} - -.ph-circle-dashed-thin::before { - content: "\eb15"; -} - -.ph-circle-half-thin::before { - content: "\eb16"; -} - -.ph-circle-half-tilt-thin::before { - content: "\eb17"; -} - -.ph-circle-notch-thin::before { - content: "\eb18"; -} - -.ph-circle-thin::before { - content: "\eb19"; -} - -.ph-circle-wavy-check-thin::before { - content: "\eb1a"; -} - -.ph-circle-wavy-question-thin::before { - content: "\eb1b"; -} - -.ph-circle-wavy-thin::before { - content: "\eb1c"; -} - -.ph-circle-wavy-warning-thin::before { - content: "\eb1d"; -} - -.ph-circles-four-thin::before { - content: "\eb1e"; -} - -.ph-circles-three-plus-thin::before { - content: "\eb1f"; -} - -.ph-circles-three-thin::before { - content: "\eb20"; -} - -.ph-clipboard-text-thin::before { - content: "\eb21"; -} - -.ph-clipboard-thin::before { - content: "\eb22"; -} - -.ph-clock-afternoon-thin::before { - content: "\eb23"; -} - -.ph-clock-clockwise-thin::before { - content: "\eb24"; -} - -.ph-clock-counter-clockwise-thin::before { - content: "\eb25"; -} - -.ph-clock-thin::before { - content: "\eb26"; -} - -.ph-closed-captioning-thin::before { - content: "\eb27"; -} - -.ph-cloud-arrow-down-thin::before { - content: "\eb28"; -} - -.ph-cloud-arrow-up-thin::before { - content: "\eb29"; -} - -.ph-cloud-check-thin::before { - content: "\eb2a"; -} - -.ph-cloud-fog-thin::before { - content: "\eb2b"; -} - -.ph-cloud-lightning-thin::before { - content: "\eb2c"; -} - -.ph-cloud-moon-thin::before { - content: "\eb2d"; -} - -.ph-cloud-rain-thin::before { - content: "\eb2e"; -} - -.ph-cloud-slash-thin::before { - content: "\eb2f"; -} - -.ph-cloud-snow-thin::before { - content: "\eb30"; -} - -.ph-cloud-sun-thin::before { - content: "\eb31"; -} - -.ph-cloud-thin::before { - content: "\eb32"; -} - -.ph-club-thin::before { - content: "\eb33"; -} - -.ph-coat-hanger-thin::before { - content: "\eb34"; -} - -.ph-code-simple-thin::before { - content: "\eb35"; -} - -.ph-code-thin::before { - content: "\eb36"; -} - -.ph-codepen-logo-thin::before { - content: "\eb37"; -} - -.ph-codesandbox-logo-thin::before { - content: "\eb38"; -} - -.ph-coffee-thin::before { - content: "\eb39"; -} - -.ph-coin-thin::before { - content: "\eb3a"; -} - -.ph-coin-vertical-thin::before { - content: "\eb3b"; -} - -.ph-coins-thin::before { - content: "\eb3c"; -} - -.ph-columns-thin::before { - content: "\eb3d"; -} - -.ph-command-thin::before { - content: "\eb3e"; -} - -.ph-compass-thin::before { - content: "\eb3f"; -} - -.ph-computer-tower-thin::before { - content: "\eb40"; -} - -.ph-confetti-thin::before { - content: "\eb41"; -} - -.ph-cookie-thin::before { - content: "\eb42"; -} - -.ph-cooking-pot-thin::before { - content: "\eb43"; -} - -.ph-copy-simple-thin::before { - content: "\eb44"; -} - -.ph-copy-thin::before { - content: "\eb45"; -} - -.ph-copyleft-thin::before { - content: "\eb46"; -} - -.ph-copyright-thin::before { - content: "\eb47"; -} - -.ph-corners-in-thin::before { - content: "\eb48"; -} - -.ph-corners-out-thin::before { - content: "\eb49"; -} - -.ph-cpu-thin::before { - content: "\eb4a"; -} - -.ph-credit-card-thin::before { - content: "\eb4b"; -} - -.ph-crop-thin::before { - content: "\eb4c"; -} - -.ph-crosshair-simple-thin::before { - content: "\eb4d"; -} - -.ph-crosshair-thin::before { - content: "\eb4e"; -} - -.ph-crown-simple-thin::before { - content: "\eb4f"; -} - -.ph-crown-thin::before { - content: "\eb50"; -} - -.ph-cube-thin::before { - content: "\eb51"; -} - -.ph-currency-btc-thin::before { - content: "\eb52"; -} - -.ph-currency-circle-dollar-thin::before { - content: "\eb53"; -} - -.ph-currency-cny-thin::before { - content: "\eb54"; -} - -.ph-currency-dollar-simple-thin::before { - content: "\eb55"; -} - -.ph-currency-dollar-thin::before { - content: "\eb56"; -} - -.ph-currency-eth-thin::before { - content: "\eb57"; -} - -.ph-currency-eur-thin::before { - content: "\eb58"; -} - -.ph-currency-gbp-thin::before { - content: "\eb59"; -} - -.ph-currency-inr-thin::before { - content: "\eb5a"; -} - -.ph-currency-jpy-thin::before { - content: "\eb5b"; -} - -.ph-currency-krw-thin::before { - content: "\eb5c"; -} - -.ph-currency-kzt-thin::before { - content: "\eb5d"; -} - -.ph-currency-ngn-thin::before { - content: "\eb5e"; -} - -.ph-currency-rub-thin::before { - content: "\eb5f"; -} - -.ph-cursor-text-thin::before { - content: "\eb60"; -} - -.ph-cursor-thin::before { - content: "\eb61"; -} - -.ph-cylinder-thin::before { - content: "\eb62"; -} - -.ph-database-thin::before { - content: "\eb63"; -} - -.ph-desktop-thin::before { - content: "\eb64"; -} - -.ph-desktop-tower-thin::before { - content: "\eb65"; -} - -.ph-detective-thin::before { - content: "\eb66"; -} - -.ph-device-mobile-camera-thin::before { - content: "\eb67"; -} - -.ph-device-mobile-speaker-thin::before { - content: "\eb68"; -} - -.ph-device-mobile-thin::before { - content: "\eb69"; -} - -.ph-device-tablet-camera-thin::before { - content: "\eb6a"; -} - -.ph-device-tablet-speaker-thin::before { - content: "\eb6b"; -} - -.ph-device-tablet-thin::before { - content: "\eb6c"; -} - -.ph-diamond-thin::before { - content: "\eb6d"; -} - -.ph-diamonds-four-thin::before { - content: "\eb6e"; -} - -.ph-dice-five-thin::before { - content: "\eb6f"; -} - -.ph-dice-four-thin::before { - content: "\eb70"; -} - -.ph-dice-one-thin::before { - content: "\eb71"; -} - -.ph-dice-six-thin::before { - content: "\eb72"; -} - -.ph-dice-three-thin::before { - content: "\eb73"; -} - -.ph-dice-two-thin::before { - content: "\eb74"; -} - -.ph-disc-thin::before { - content: "\eb75"; -} - -.ph-discord-logo-thin::before { - content: "\eb76"; -} - -.ph-divide-thin::before { - content: "\eb77"; -} - -.ph-dog-thin::before { - content: "\eb78"; -} - -.ph-door-thin::before { - content: "\eb79"; -} - -.ph-dots-nine-thin::before { - content: "\eb7a"; -} - -.ph-dots-six-thin::before { - content: "\eb7b"; -} - -.ph-dots-six-vertical-thin::before { - content: "\eb7c"; -} - -.ph-dots-three-circle-thin::before { - content: "\eb7d"; -} - -.ph-dots-three-circle-vertical-thin::before { - content: "\eb7e"; -} - -.ph-dots-three-outline-thin::before { - content: "\eb7f"; -} - -.ph-dots-three-outline-vertical-thin::before { - content: "\eb80"; -} - -.ph-dots-three-thin::before { - content: "\eb81"; -} - -.ph-dots-three-vertical-thin::before { - content: "\eb82"; -} - -.ph-download-simple-thin::before { - content: "\eb83"; -} - -.ph-download-thin::before { - content: "\eb84"; -} - -.ph-dribbble-logo-thin::before { - content: "\eb85"; -} - -.ph-drop-half-bottom-thin::before { - content: "\eb86"; -} - -.ph-drop-half-thin::before { - content: "\eb87"; -} - -.ph-drop-thin::before { - content: "\eb88"; -} - -.ph-ear-slash-thin::before { - content: "\eb89"; -} - -.ph-ear-thin::before { - content: "\eb8a"; -} - -.ph-egg-crack-thin::before { - content: "\eb8b"; -} - -.ph-egg-thin::before { - content: "\eb8c"; -} - -.ph-eject-simple-thin::before { - content: "\eb8d"; -} - -.ph-eject-thin::before { - content: "\eb8e"; -} - -.ph-envelope-open-thin::before { - content: "\eb8f"; -} - -.ph-envelope-simple-open-thin::before { - content: "\eb90"; -} - -.ph-envelope-simple-thin::before { - content: "\eb91"; -} - -.ph-envelope-thin::before { - content: "\eb92"; -} - -.ph-equalizer-thin::before { - content: "\eb93"; -} - -.ph-equals-thin::before { - content: "\eb94"; -} - -.ph-eraser-thin::before { - content: "\eb95"; -} - -.ph-exam-thin::before { - content: "\eb96"; -} - -.ph-export-thin::before { - content: "\eb97"; -} - -.ph-eye-closed-thin::before { - content: "\eb98"; -} - -.ph-eye-slash-thin::before { - content: "\eb99"; -} - -.ph-eye-thin::before { - content: "\eb9a"; -} - -.ph-eyedropper-sample-thin::before { - content: "\eb9b"; -} - -.ph-eyedropper-thin::before { - content: "\eb9c"; -} - -.ph-eyeglasses-thin::before { - content: "\eb9d"; -} - -.ph-face-mask-thin::before { - content: "\eb9e"; -} - -.ph-facebook-logo-thin::before { - content: "\eb9f"; -} - -.ph-factory-thin::before { - content: "\eba0"; -} - -.ph-faders-horizontal-thin::before { - content: "\eba1"; -} - -.ph-faders-thin::before { - content: "\eba2"; -} - -.ph-fast-forward-circle-thin::before { - content: "\eba3"; -} - -.ph-fast-forward-thin::before { - content: "\eba4"; -} - -.ph-figma-logo-thin::before { - content: "\eba5"; -} - -.ph-file-arrow-down-thin::before { - content: "\eba6"; -} - -.ph-file-arrow-up-thin::before { - content: "\eba7"; -} - -.ph-file-audio-thin::before { - content: "\eba8"; -} - -.ph-file-cloud-thin::before { - content: "\eba9"; -} - -.ph-file-code-thin::before { - content: "\ebaa"; -} - -.ph-file-css-thin::before { - content: "\ebab"; -} - -.ph-file-csv-thin::before { - content: "\ebac"; -} - -.ph-file-doc-thin::before { - content: "\ebad"; -} - -.ph-file-dotted-thin::before { - content: "\ebae"; -} - -.ph-file-html-thin::before { - content: "\ebaf"; -} - -.ph-file-image-thin::before { - content: "\ebb0"; -} - -.ph-file-jpg-thin::before { - content: "\ebb1"; -} - -.ph-file-js-thin::before { - content: "\ebb2"; -} - -.ph-file-jsx-thin::before { - content: "\ebb3"; -} - -.ph-file-lock-thin::before { - content: "\ebb4"; -} - -.ph-file-minus-thin::before { - content: "\ebb5"; -} - -.ph-file-pdf-thin::before { - content: "\ebb6"; -} - -.ph-file-plus-thin::before { - content: "\ebb7"; -} - -.ph-file-png-thin::before { - content: "\ebb8"; -} - -.ph-file-ppt-thin::before { - content: "\ebb9"; -} - -.ph-file-rs-thin::before { - content: "\ebba"; -} - -.ph-file-search-thin::before { - content: "\ebbb"; -} - -.ph-file-text-thin::before { - content: "\ebbc"; -} - -.ph-file-thin::before { - content: "\ebbd"; -} - -.ph-file-ts-thin::before { - content: "\ebbe"; -} - -.ph-file-tsx-thin::before { - content: "\ebbf"; -} - -.ph-file-video-thin::before { - content: "\ebc0"; -} - -.ph-file-vue-thin::before { - content: "\ebc1"; -} - -.ph-file-x-thin::before { - content: "\ebc2"; -} - -.ph-file-xls-thin::before { - content: "\ebc3"; -} - -.ph-file-zip-thin::before { - content: "\ebc4"; -} - -.ph-files-thin::before { - content: "\ebc5"; -} - -.ph-film-script-thin::before { - content: "\ebc6"; -} - -.ph-film-slate-thin::before { - content: "\ebc7"; -} - -.ph-film-strip-thin::before { - content: "\ebc8"; -} - -.ph-fingerprint-simple-thin::before { - content: "\ebc9"; -} - -.ph-fingerprint-thin::before { - content: "\ebca"; -} - -.ph-finn-the-human-thin::before { - content: "\ebcb"; -} - -.ph-fire-simple-thin::before { - content: "\ebcc"; -} - -.ph-fire-thin::before { - content: "\ebcd"; -} - -.ph-first-aid-kit-thin::before { - content: "\ebce"; -} - -.ph-first-aid-thin::before { - content: "\ebcf"; -} - -.ph-fish-simple-thin::before { - content: "\ebd0"; -} - -.ph-fish-thin::before { - content: "\ebd1"; -} - -.ph-flag-banner-thin::before { - content: "\ebd2"; -} - -.ph-flag-checkered-thin::before { - content: "\ebd3"; -} - -.ph-flag-thin::before { - content: "\ebd4"; -} - -.ph-flame-thin::before { - content: "\ebd5"; -} - -.ph-flashlight-thin::before { - content: "\ebd6"; -} - -.ph-flask-thin::before { - content: "\ebd7"; -} - -.ph-floppy-disk-back-thin::before { - content: "\ebd8"; -} - -.ph-floppy-disk-thin::before { - content: "\ebd9"; -} - -.ph-flow-arrow-thin::before { - content: "\ebda"; -} - -.ph-flower-lotus-thin::before { - content: "\ebdb"; -} - -.ph-flower-thin::before { - content: "\ebdc"; -} - -.ph-flying-saucer-thin::before { - content: "\ebdd"; -} - -.ph-folder-dotted-thin::before { - content: "\ebde"; -} - -.ph-folder-lock-thin::before { - content: "\ebdf"; -} - -.ph-folder-minus-thin::before { - content: "\ebe0"; -} - -.ph-folder-notch-minus-thin::before { - content: "\ebe1"; -} - -.ph-folder-notch-open-thin::before { - content: "\ebe2"; -} - -.ph-folder-notch-plus-thin::before { - content: "\ebe3"; -} - -.ph-folder-notch-thin::before { - content: "\ebe4"; -} - -.ph-folder-open-thin::before { - content: "\ebe5"; -} - -.ph-folder-plus-thin::before { - content: "\ebe6"; -} - -.ph-folder-simple-dotted-thin::before { - content: "\ebe7"; -} - -.ph-folder-simple-lock-thin::before { - content: "\ebe8"; -} - -.ph-folder-simple-minus-thin::before { - content: "\ebe9"; -} - -.ph-folder-simple-plus-thin::before { - content: "\ebea"; -} - -.ph-folder-simple-star-thin::before { - content: "\ebeb"; -} - -.ph-folder-simple-thin::before { - content: "\ebec"; -} - -.ph-folder-simple-user-thin::before { - content: "\ebed"; -} - -.ph-folder-star-thin::before { - content: "\ebee"; -} - -.ph-folder-thin::before { - content: "\ebef"; -} - -.ph-folder-user-thin::before { - content: "\ebf0"; -} - -.ph-folders-thin::before { - content: "\ebf1"; -} - -.ph-football-thin::before { - content: "\ebf2"; -} - -.ph-fork-knife-thin::before { - content: "\ebf3"; -} - -.ph-frame-corners-thin::before { - content: "\ebf4"; -} - -.ph-framer-logo-thin::before { - content: "\ebf5"; -} - -.ph-function-thin::before { - content: "\ebf6"; -} - -.ph-funnel-simple-thin::before { - content: "\ebf7"; -} - -.ph-funnel-thin::before { - content: "\ebf8"; -} - -.ph-game-controller-thin::before { - content: "\ebf9"; -} - -.ph-gas-pump-thin::before { - content: "\ebfa"; -} - -.ph-gauge-thin::before { - content: "\ebfb"; -} - -.ph-gear-six-thin::before { - content: "\ebfc"; -} - -.ph-gear-thin::before { - content: "\ebfd"; -} - -.ph-gender-female-thin::before { - content: "\ebfe"; -} - -.ph-gender-intersex-thin::before { - content: "\ebff"; -} - -.ph-gender-male-thin::before { - content: "\ec00"; -} - -.ph-gender-neuter-thin::before { - content: "\ec01"; -} - -.ph-gender-nonbinary-thin::before { - content: "\ec02"; -} - -.ph-gender-transgender-thin::before { - content: "\ec03"; -} - -.ph-ghost-thin::before { - content: "\ec04"; -} - -.ph-gif-thin::before { - content: "\ec05"; -} - -.ph-gift-thin::before { - content: "\ec06"; -} - -.ph-git-branch-thin::before { - content: "\ec07"; -} - -.ph-git-commit-thin::before { - content: "\ec08"; -} - -.ph-git-diff-thin::before { - content: "\ec09"; -} - -.ph-git-fork-thin::before { - content: "\ec0a"; -} - -.ph-git-merge-thin::before { - content: "\ec0b"; -} - -.ph-git-pull-request-thin::before { - content: "\ec0c"; -} - -.ph-github-logo-thin::before { - content: "\ec0d"; -} - -.ph-gitlab-logo-simple-thin::before { - content: "\ec0e"; -} - -.ph-gitlab-logo-thin::before { - content: "\ec0f"; -} - -.ph-globe-hemisphere-east-thin::before { - content: "\ec10"; -} - -.ph-globe-hemisphere-west-thin::before { - content: "\ec11"; -} - -.ph-globe-simple-thin::before { - content: "\ec12"; -} - -.ph-globe-stand-thin::before { - content: "\ec13"; -} - -.ph-globe-thin::before { - content: "\ec14"; -} - -.ph-google-chrome-logo-thin::before { - content: "\ec15"; -} - -.ph-google-logo-thin::before { - content: "\ec16"; -} - -.ph-google-photos-logo-thin::before { - content: "\ec17"; -} - -.ph-google-play-logo-thin::before { - content: "\ec18"; -} - -.ph-google-podcasts-logo-thin::before { - content: "\ec19"; -} - -.ph-gradient-thin::before { - content: "\ec1a"; -} - -.ph-graduation-cap-thin::before { - content: "\ec1b"; -} - -.ph-graph-thin::before { - content: "\ec1c"; -} - -.ph-grid-four-thin::before { - content: "\ec1d"; -} - -.ph-hamburger-thin::before { - content: "\ec1e"; -} - -.ph-hand-eye-thin::before { - content: "\ec1f"; -} - -.ph-hand-fist-thin::before { - content: "\ec20"; -} - -.ph-hand-grabbing-thin::before { - content: "\ec21"; -} - -.ph-hand-palm-thin::before { - content: "\ec22"; -} - -.ph-hand-pointing-thin::before { - content: "\ec23"; -} - -.ph-hand-soap-thin::before { - content: "\ec24"; -} - -.ph-hand-thin::before { - content: "\ec25"; -} - -.ph-hand-waving-thin::before { - content: "\ec26"; -} - -.ph-handbag-simple-thin::before { - content: "\ec27"; -} - -.ph-handbag-thin::before { - content: "\ec28"; -} - -.ph-hands-clapping-thin::before { - content: "\ec29"; -} - -.ph-handshake-thin::before { - content: "\ec2a"; -} - -.ph-hard-drive-thin::before { - content: "\ec2b"; -} - -.ph-hard-drives-thin::before { - content: "\ec2c"; -} - -.ph-hash-straight-thin::before { - content: "\ec2d"; -} - -.ph-hash-thin::before { - content: "\ec2e"; -} - -.ph-headlights-thin::before { - content: "\ec2f"; -} - -.ph-headphones-thin::before { - content: "\ec30"; -} - -.ph-headset-thin::before { - content: "\ec31"; -} - -.ph-heart-break-thin::before { - content: "\ec32"; -} - -.ph-heart-straight-break-thin::before { - content: "\ec33"; -} - -.ph-heart-straight-thin::before { - content: "\ec34"; -} - -.ph-heart-thin::before { - content: "\ec35"; -} - -.ph-heartbeat-thin::before { - content: "\ec36"; -} - -.ph-hexagon-thin::before { - content: "\ec37"; -} - -.ph-highlighter-circle-thin::before { - content: "\ec38"; -} - -.ph-horse-thin::before { - content: "\ec39"; -} - -.ph-hourglass-high-thin::before { - content: "\ec3a"; -} - -.ph-hourglass-low-thin::before { - content: "\ec3b"; -} - -.ph-hourglass-medium-thin::before { - content: "\ec3c"; -} - -.ph-hourglass-simple-high-thin::before { - content: "\ec3d"; -} - -.ph-hourglass-simple-low-thin::before { - content: "\ec3e"; -} - -.ph-hourglass-simple-medium-thin::before { - content: "\ec3f"; -} - -.ph-hourglass-simple-thin::before { - content: "\ec40"; -} - -.ph-hourglass-thin::before { - content: "\ec41"; -} - -.ph-house-line-thin::before { - content: "\ec42"; -} - -.ph-house-simple-thin::before { - content: "\ec43"; -} - -.ph-house-thin::before { - content: "\ec44"; -} - -.ph-identification-badge-thin::before { - content: "\ec45"; -} - -.ph-identification-card-thin::before { - content: "\ec46"; -} - -.ph-image-square-thin::before { - content: "\ec47"; -} - -.ph-image-thin::before { - content: "\ec48"; -} - -.ph-infinity-thin::before { - content: "\ec49"; -} - -.ph-info-thin::before { - content: "\ec4a"; -} - -.ph-instagram-logo-thin::before { - content: "\ec4b"; -} - -.ph-intersect-thin::before { - content: "\ec4c"; -} - -.ph-jeep-thin::before { - content: "\ec4d"; -} - -.ph-kanban-thin::before { - content: "\ec4e"; -} - -.ph-key-return-thin::before { - content: "\ec4f"; -} - -.ph-key-thin::before { - content: "\ec50"; -} - -.ph-keyboard-thin::before { - content: "\ec51"; -} - -.ph-keyhole-thin::before { - content: "\ec52"; -} - -.ph-knife-thin::before { - content: "\ec53"; -} - -.ph-ladder-simple-thin::before { - content: "\ec54"; -} - -.ph-ladder-thin::before { - content: "\ec55"; -} - -.ph-lamp-thin::before { - content: "\ec56"; -} - -.ph-laptop-thin::before { - content: "\ec57"; -} - -.ph-layout-thin::before { - content: "\ec58"; -} - -.ph-leaf-thin::before { - content: "\ec59"; -} - -.ph-lifebuoy-thin::before { - content: "\ec5a"; -} - -.ph-lightbulb-filament-thin::before { - content: "\ec5b"; -} - -.ph-lightbulb-thin::before { - content: "\ec5c"; -} - -.ph-lightning-slash-thin::before { - content: "\ec5d"; -} - -.ph-lightning-thin::before { - content: "\ec5e"; -} - -.ph-line-segment-thin::before { - content: "\ec5f"; -} - -.ph-line-segments-thin::before { - content: "\ec60"; -} - -.ph-link-break-thin::before { - content: "\ec61"; -} - -.ph-link-simple-break-thin::before { - content: "\ec62"; -} - -.ph-link-simple-horizontal-break-thin::before { - content: "\ec63"; -} - -.ph-link-simple-horizontal-thin::before { - content: "\ec64"; -} - -.ph-link-simple-thin::before { - content: "\ec65"; -} - -.ph-link-thin::before { - content: "\ec66"; -} - -.ph-linkedin-logo-thin::before { - content: "\ec67"; -} - -.ph-linux-logo-thin::before { - content: "\ec68"; -} - -.ph-list-bullets-thin::before { - content: "\ec69"; -} - -.ph-list-checks-thin::before { - content: "\ec6a"; -} - -.ph-list-dashes-thin::before { - content: "\ec6b"; -} - -.ph-list-numbers-thin::before { - content: "\ec6c"; -} - -.ph-list-plus-thin::before { - content: "\ec6d"; -} - -.ph-list-thin::before { - content: "\ec6e"; -} - -.ph-lock-key-open-thin::before { - content: "\ec6f"; -} - -.ph-lock-key-thin::before { - content: "\ec70"; -} - -.ph-lock-laminated-open-thin::before { - content: "\ec71"; -} - -.ph-lock-laminated-thin::before { - content: "\ec72"; -} - -.ph-lock-open-thin::before { - content: "\ec73"; -} - -.ph-lock-simple-open-thin::before { - content: "\ec74"; -} - -.ph-lock-simple-thin::before { - content: "\ec75"; -} - -.ph-lock-thin::before { - content: "\ec76"; -} - -.ph-magic-wand-thin::before { - content: "\ec77"; -} - -.ph-magnet-straight-thin::before { - content: "\ec78"; -} - -.ph-magnet-thin::before { - content: "\ec79"; -} - -.ph-magnifying-glass-minus-thin::before { - content: "\ec7a"; -} - -.ph-magnifying-glass-plus-thin::before { - content: "\ec7b"; -} - -.ph-magnifying-glass-thin::before { - content: "\ec7c"; -} - -.ph-map-pin-line-thin::before { - content: "\ec7d"; -} - -.ph-map-pin-thin::before { - content: "\ec7e"; -} - -.ph-map-trifold-thin::before { - content: "\ec7f"; -} - -.ph-marker-circle-thin::before { - content: "\ec80"; -} - -.ph-martini-thin::before { - content: "\ec81"; -} - -.ph-mask-happy-thin::before { - content: "\ec82"; -} - -.ph-mask-sad-thin::before { - content: "\ec83"; -} - -.ph-math-operations-thin::before { - content: "\ec84"; -} - -.ph-medal-thin::before { - content: "\ec85"; -} - -.ph-medium-logo-thin::before { - content: "\ec86"; -} - -.ph-megaphone-simple-thin::before { - content: "\ec87"; -} - -.ph-megaphone-thin::before { - content: "\ec88"; -} - -.ph-messenger-logo-thin::before { - content: "\ec89"; -} - -.ph-microphone-slash-thin::before { - content: "\ec8a"; -} - -.ph-microphone-stage-thin::before { - content: "\ec8b"; -} - -.ph-microphone-thin::before { - content: "\ec8c"; -} - -.ph-microsoft-excel-logo-thin::before { - content: "\ec8d"; -} - -.ph-microsoft-powerpoint-logo-thin::before { - content: "\ec8e"; -} - -.ph-microsoft-teams-logo-thin::before { - content: "\ec8f"; -} - -.ph-microsoft-word-logo-thin::before { - content: "\ec90"; -} - -.ph-minus-circle-thin::before { - content: "\ec91"; -} - -.ph-minus-thin::before { - content: "\ec92"; -} - -.ph-money-thin::before { - content: "\ec93"; -} - -.ph-monitor-play-thin::before { - content: "\ec94"; -} - -.ph-monitor-thin::before { - content: "\ec95"; -} - -.ph-moon-stars-thin::before { - content: "\ec96"; -} - -.ph-moon-thin::before { - content: "\ec97"; -} - -.ph-mountains-thin::before { - content: "\ec98"; -} - -.ph-mouse-simple-thin::before { - content: "\ec99"; -} - -.ph-mouse-thin::before { - content: "\ec9a"; -} - -.ph-music-note-simple-thin::before { - content: "\ec9b"; -} - -.ph-music-note-thin::before { - content: "\ec9c"; -} - -.ph-music-notes-plus-thin::before { - content: "\ec9d"; -} - -.ph-music-notes-simple-thin::before { - content: "\ec9e"; -} - -.ph-music-notes-thin::before { - content: "\ec9f"; -} - -.ph-navigation-arrow-thin::before { - content: "\eca0"; -} - -.ph-needle-thin::before { - content: "\eca1"; -} - -.ph-newspaper-clipping-thin::before { - content: "\eca2"; -} - -.ph-newspaper-thin::before { - content: "\eca3"; -} - -.ph-note-blank-thin::before { - content: "\eca4"; -} - -.ph-note-pencil-thin::before { - content: "\eca5"; -} - -.ph-note-thin::before { - content: "\eca6"; -} - -.ph-notebook-thin::before { - content: "\eca7"; -} - -.ph-notepad-thin::before { - content: "\eca8"; -} - -.ph-notification-thin::before { - content: "\eca9"; -} - -.ph-number-circle-eight-thin::before { - content: "\ecaa"; -} - -.ph-number-circle-five-thin::before { - content: "\ecab"; -} - -.ph-number-circle-four-thin::before { - content: "\ecac"; -} - -.ph-number-circle-nine-thin::before { - content: "\ecad"; -} - -.ph-number-circle-one-thin::before { - content: "\ecae"; -} - -.ph-number-circle-seven-thin::before { - content: "\ecaf"; -} - -.ph-number-circle-six-thin::before { - content: "\ecb0"; -} - -.ph-number-circle-three-thin::before { - content: "\ecb1"; -} - -.ph-number-circle-two-thin::before { - content: "\ecb2"; -} - -.ph-number-circle-zero-thin::before { - content: "\ecb3"; -} - -.ph-number-eight-thin::before { - content: "\ecb4"; -} - -.ph-number-five-thin::before { - content: "\ecb5"; -} - -.ph-number-four-thin::before { - content: "\ecb6"; -} - -.ph-number-nine-thin::before { - content: "\ecb7"; -} - -.ph-number-one-thin::before { - content: "\ecb8"; -} - -.ph-number-seven-thin::before { - content: "\ecb9"; -} - -.ph-number-six-thin::before { - content: "\ecba"; -} - -.ph-number-square-eight-thin::before { - content: "\ecbb"; -} - -.ph-number-square-five-thin::before { - content: "\ecbc"; -} - -.ph-number-square-four-thin::before { - content: "\ecbd"; -} - -.ph-number-square-nine-thin::before { - content: "\ecbe"; -} - -.ph-number-square-one-thin::before { - content: "\ecbf"; -} - -.ph-number-square-seven-thin::before { - content: "\ecc0"; -} - -.ph-number-square-six-thin::before { - content: "\ecc1"; -} - -.ph-number-square-three-thin::before { - content: "\ecc2"; -} - -.ph-number-square-two-thin::before { - content: "\ecc3"; -} - -.ph-number-square-zero-thin::before { - content: "\ecc4"; -} - -.ph-number-three-thin::before { - content: "\ecc5"; -} - -.ph-number-two-thin::before { - content: "\ecc6"; -} - -.ph-number-zero-thin::before { - content: "\ecc7"; -} - -.ph-nut-thin::before { - content: "\ecc8"; -} - -.ph-ny-times-logo-thin::before { - content: "\ecc9"; -} - -.ph-octagon-thin::before { - content: "\ecca"; -} - -.ph-option-thin::before { - content: "\eccb"; -} - -.ph-package-thin::before { - content: "\eccc"; -} - -.ph-paint-brush-broad-thin::before { - content: "\eccd"; -} - -.ph-paint-brush-household-thin::before { - content: "\ecce"; -} - -.ph-paint-brush-thin::before { - content: "\eccf"; -} - -.ph-paint-bucket-thin::before { - content: "\ecd0"; -} - -.ph-paint-roller-thin::before { - content: "\ecd1"; -} - -.ph-palette-thin::before { - content: "\ecd2"; -} - -.ph-paper-plane-right-thin::before { - content: "\ecd3"; -} - -.ph-paper-plane-thin::before { - content: "\ecd4"; -} - -.ph-paper-plane-tilt-thin::before { - content: "\ecd5"; -} - -.ph-paperclip-horizontal-thin::before { - content: "\ecd6"; -} - -.ph-paperclip-thin::before { - content: "\ecd7"; -} - -.ph-parachute-thin::before { - content: "\ecd8"; -} - -.ph-password-thin::before { - content: "\ecd9"; -} - -.ph-path-thin::before { - content: "\ecda"; -} - -.ph-pause-circle-thin::before { - content: "\ecdb"; -} - -.ph-pause-thin::before { - content: "\ecdc"; -} - -.ph-paw-print-thin::before { - content: "\ecdd"; -} - -.ph-peace-thin::before { - content: "\ecde"; -} - -.ph-pen-nib-straight-thin::before { - content: "\ecdf"; -} - -.ph-pen-nib-thin::before { - content: "\ece0"; -} - -.ph-pen-thin::before { - content: "\ece1"; -} - -.ph-pencil-circle-thin::before { - content: "\ece2"; -} - -.ph-pencil-line-thin::before { - content: "\ece3"; -} - -.ph-pencil-simple-line-thin::before { - content: "\ece4"; -} - -.ph-pencil-simple-thin::before { - content: "\ece5"; -} - -.ph-pencil-thin::before { - content: "\ece6"; -} - -.ph-percent-thin::before { - content: "\ece7"; -} - -.ph-person-simple-run-thin::before { - content: "\ece8"; -} - -.ph-person-simple-thin::before { - content: "\ece9"; -} - -.ph-person-simple-walk-thin::before { - content: "\ecea"; -} - -.ph-person-thin::before { - content: "\eceb"; -} - -.ph-perspective-thin::before { - content: "\ecec"; -} - -.ph-phone-call-thin::before { - content: "\eced"; -} - -.ph-phone-disconnect-thin::before { - content: "\ecee"; -} - -.ph-phone-incoming-thin::before { - content: "\ecef"; -} - -.ph-phone-outgoing-thin::before { - content: "\ecf0"; -} - -.ph-phone-slash-thin::before { - content: "\ecf1"; -} - -.ph-phone-thin::before { - content: "\ecf2"; -} - -.ph-phone-x-thin::before { - content: "\ecf3"; -} - -.ph-phosphor-logo-thin::before { - content: "\ecf4"; -} - -.ph-piano-keys-thin::before { - content: "\ecf5"; -} - -.ph-picture-in-picture-thin::before { - content: "\ecf6"; -} - -.ph-pill-thin::before { - content: "\ecf7"; -} - -.ph-pinterest-logo-thin::before { - content: "\ecf8"; -} - -.ph-pinwheel-thin::before { - content: "\ecf9"; -} - -.ph-pizza-thin::before { - content: "\ecfa"; -} - -.ph-placeholder-thin::before { - content: "\ecfb"; -} - -.ph-planet-thin::before { - content: "\ecfc"; -} - -.ph-play-circle-thin::before { - content: "\ecfd"; -} - -.ph-play-thin::before { - content: "\ecfe"; -} - -.ph-playlist-thin::before { - content: "\ecff"; -} - -.ph-plug-thin::before { - content: "\ed00"; -} - -.ph-plugs-connected-thin::before { - content: "\ed01"; -} - -.ph-plugs-thin::before { - content: "\ed02"; -} - -.ph-plus-circle-thin::before { - content: "\ed03"; -} - -.ph-plus-minus-thin::before { - content: "\ed04"; -} - -.ph-plus-thin::before { - content: "\ed05"; -} - -.ph-poker-chip-thin::before { - content: "\ed06"; -} - -.ph-police-car-thin::before { - content: "\ed07"; -} - -.ph-polygon-thin::before { - content: "\ed08"; -} - -.ph-popcorn-thin::before { - content: "\ed09"; -} - -.ph-power-thin::before { - content: "\ed0a"; -} - -.ph-prescription-thin::before { - content: "\ed0b"; -} - -.ph-presentation-chart-thin::before { - content: "\ed0c"; -} - -.ph-presentation-thin::before { - content: "\ed0d"; -} - -.ph-printer-thin::before { - content: "\ed0e"; -} - -.ph-prohibit-inset-thin::before { - content: "\ed0f"; -} - -.ph-prohibit-thin::before { - content: "\ed10"; -} - -.ph-projector-screen-chart-thin::before { - content: "\ed11"; -} - -.ph-projector-screen-thin::before { - content: "\ed12"; -} - -.ph-push-pin-simple-slash-thin::before { - content: "\ed13"; -} - -.ph-push-pin-simple-thin::before { - content: "\ed14"; -} - -.ph-push-pin-slash-thin::before { - content: "\ed15"; -} - -.ph-push-pin-thin::before { - content: "\ed16"; -} - -.ph-puzzle-piece-thin::before { - content: "\ed17"; -} - -.ph-qr-code-thin::before { - content: "\ed18"; -} - -.ph-question-thin::before { - content: "\ed19"; -} - -.ph-queue-thin::before { - content: "\ed1a"; -} - -.ph-quotes-thin::before { - content: "\ed1b"; -} - -.ph-radical-thin::before { - content: "\ed1c"; -} - -.ph-radio-button-thin::before { - content: "\ed1d"; -} - -.ph-radio-thin::before { - content: "\ed1e"; -} - -.ph-rainbow-cloud-thin::before { - content: "\ed1f"; -} - -.ph-rainbow-thin::before { - content: "\ed20"; -} - -.ph-receipt-thin::before { - content: "\ed21"; -} - -.ph-record-thin::before { - content: "\ed22"; -} - -.ph-rectangle-thin::before { - content: "\ed23"; -} - -.ph-recycle-thin::before { - content: "\ed24"; -} - -.ph-reddit-logo-thin::before { - content: "\ed25"; -} - -.ph-repeat-once-thin::before { - content: "\ed26"; -} - -.ph-repeat-thin::before { - content: "\ed27"; -} - -.ph-rewind-circle-thin::before { - content: "\ed28"; -} - -.ph-rewind-thin::before { - content: "\ed29"; -} - -.ph-robot-thin::before { - content: "\ed2a"; -} - -.ph-rocket-launch-thin::before { - content: "\ed2b"; -} - -.ph-rocket-thin::before { - content: "\ed2c"; -} - -.ph-rows-thin::before { - content: "\ed2d"; -} - -.ph-rss-simple-thin::before { - content: "\ed2e"; -} - -.ph-rss-thin::before { - content: "\ed2f"; -} - -.ph-rug-thin::before { - content: "\ed30"; -} - -.ph-ruler-thin::before { - content: "\ed31"; -} - -.ph-scales-thin::before { - content: "\ed32"; -} - -.ph-scan-thin::before { - content: "\ed33"; -} - -.ph-scissors-thin::before { - content: "\ed34"; -} - -.ph-screencast-thin::before { - content: "\ed35"; -} - -.ph-scribble-loop-thin::before { - content: "\ed36"; -} - -.ph-scroll-thin::before { - content: "\ed37"; -} - -.ph-selection-all-thin::before { - content: "\ed38"; -} - -.ph-selection-background-thin::before { - content: "\ed39"; -} - -.ph-selection-foreground-thin::before { - content: "\ed3a"; -} - -.ph-selection-inverse-thin::before { - content: "\ed3b"; -} - -.ph-selection-plus-thin::before { - content: "\ed3c"; -} - -.ph-selection-slash-thin::before { - content: "\ed3d"; -} - -.ph-selection-thin::before { - content: "\ed3e"; -} - -.ph-share-network-thin::before { - content: "\ed3f"; -} - -.ph-share-thin::before { - content: "\ed40"; -} - -.ph-shield-check-thin::before { - content: "\ed41"; -} - -.ph-shield-checkered-thin::before { - content: "\ed42"; -} - -.ph-shield-chevron-thin::before { - content: "\ed43"; -} - -.ph-shield-plus-thin::before { - content: "\ed44"; -} - -.ph-shield-slash-thin::before { - content: "\ed45"; -} - -.ph-shield-star-thin::before { - content: "\ed46"; -} - -.ph-shield-thin::before { - content: "\ed47"; -} - -.ph-shield-warning-thin::before { - content: "\ed48"; -} - -.ph-shopping-bag-open-thin::before { - content: "\ed49"; -} - -.ph-shopping-bag-thin::before { - content: "\ed4a"; -} - -.ph-shopping-cart-simple-thin::before { - content: "\ed4b"; -} - -.ph-shopping-cart-thin::before { - content: "\ed4c"; -} - -.ph-shower-thin::before { - content: "\ed4d"; -} - -.ph-shuffle-angular-thin::before { - content: "\ed4e"; -} - -.ph-shuffle-simple-thin::before { - content: "\ed4f"; -} - -.ph-shuffle-thin::before { - content: "\ed50"; -} - -.ph-sidebar-simple-thin::before { - content: "\ed51"; -} - -.ph-sidebar-thin::before { - content: "\ed52"; -} - -.ph-sign-in-thin::before { - content: "\ed53"; -} - -.ph-sign-out-thin::before { - content: "\ed54"; -} - -.ph-signpost-thin::before { - content: "\ed55"; -} - -.ph-sim-card-thin::before { - content: "\ed56"; -} - -.ph-sketch-logo-thin::before { - content: "\ed57"; -} - -.ph-skip-back-circle-thin::before { - content: "\ed58"; -} - -.ph-skip-back-thin::before { - content: "\ed59"; -} - -.ph-skip-forward-circle-thin::before { - content: "\ed5a"; -} - -.ph-skip-forward-thin::before { - content: "\ed5b"; -} - -.ph-skull-thin::before { - content: "\ed5c"; -} - -.ph-slack-logo-thin::before { - content: "\ed5d"; -} - -.ph-sliders-horizontal-thin::before { - content: "\ed5e"; -} - -.ph-sliders-thin::before { - content: "\ed5f"; -} - -.ph-smiley-blank-thin::before { - content: "\ed60"; -} - -.ph-smiley-meh-thin::before { - content: "\ed61"; -} - -.ph-smiley-nervous-thin::before { - content: "\ed62"; -} - -.ph-smiley-sad-thin::before { - content: "\ed63"; -} - -.ph-smiley-sticker-thin::before { - content: "\ed64"; -} - -.ph-smiley-thin::before { - content: "\ed65"; -} - -.ph-smiley-wink-thin::before { - content: "\ed66"; -} - -.ph-smiley-x-eyes-thin::before { - content: "\ed67"; -} - -.ph-snapchat-logo-thin::before { - content: "\ed68"; -} - -.ph-snowflake-thin::before { - content: "\ed69"; -} - -.ph-soccer-ball-thin::before { - content: "\ed6a"; -} - -.ph-sort-ascending-thin::before { - content: "\ed6b"; -} - -.ph-sort-descending-thin::before { - content: "\ed6c"; -} - -.ph-spade-thin::before { - content: "\ed6d"; -} - -.ph-sparkle-thin::before { - content: "\ed6e"; -} - -.ph-speaker-high-thin::before { - content: "\ed6f"; -} - -.ph-speaker-low-thin::before { - content: "\ed70"; -} - -.ph-speaker-none-thin::before { - content: "\ed71"; -} - -.ph-speaker-simple-high-thin::before { - content: "\ed72"; -} - -.ph-speaker-simple-low-thin::before { - content: "\ed73"; -} - -.ph-speaker-simple-none-thin::before { - content: "\ed74"; -} - -.ph-speaker-simple-slash-thin::before { - content: "\ed75"; -} - -.ph-speaker-simple-x-thin::before { - content: "\ed76"; -} - -.ph-speaker-slash-thin::before { - content: "\ed77"; -} - -.ph-speaker-x-thin::before { - content: "\ed78"; -} - -.ph-spinner-gap-thin::before { - content: "\ed79"; -} - -.ph-spinner-thin::before { - content: "\ed7a"; -} - -.ph-spiral-thin::before { - content: "\ed7b"; -} - -.ph-spotify-logo-thin::before { - content: "\ed7c"; -} - -.ph-square-half-bottom-thin::before { - content: "\ed7d"; -} - -.ph-square-half-thin::before { - content: "\ed7e"; -} - -.ph-square-logo-thin::before { - content: "\ed7f"; -} - -.ph-square-thin::before { - content: "\ed80"; -} - -.ph-squares-four-thin::before { - content: "\ed81"; -} - -.ph-stack-overflow-logo-thin::before { - content: "\ed82"; -} - -.ph-stack-simple-thin::before { - content: "\ed83"; -} - -.ph-stack-thin::before { - content: "\ed84"; -} - -.ph-stamp-thin::before { - content: "\ed85"; -} - -.ph-star-four-thin::before { - content: "\ed86"; -} - -.ph-star-half-thin::before { - content: "\ed87"; -} - -.ph-star-thin::before { - content: "\ed88"; -} - -.ph-sticker-thin::before { - content: "\ed89"; -} - -.ph-stop-circle-thin::before { - content: "\ed8a"; -} - -.ph-stop-thin::before { - content: "\ed8b"; -} - -.ph-storefront-thin::before { - content: "\ed8c"; -} - -.ph-strategy-thin::before { - content: "\ed8d"; -} - -.ph-stripe-logo-thin::before { - content: "\ed8e"; -} - -.ph-student-thin::before { - content: "\ed8f"; -} - -.ph-suitcase-simple-thin::before { - content: "\ed90"; -} - -.ph-suitcase-thin::before { - content: "\ed91"; -} - -.ph-sun-dim-thin::before { - content: "\ed92"; -} - -.ph-sun-horizon-thin::before { - content: "\ed93"; -} - -.ph-sun-thin::before { - content: "\ed94"; -} - -.ph-sunglasses-thin::before { - content: "\ed95"; -} - -.ph-swap-thin::before { - content: "\ed96"; -} - -.ph-swatches-thin::before { - content: "\ed97"; -} - -.ph-sword-thin::before { - content: "\ed98"; -} - -.ph-syringe-thin::before { - content: "\ed99"; -} - -.ph-t-shirt-thin::before { - content: "\ed9a"; -} - -.ph-table-thin::before { - content: "\ed9b"; -} - -.ph-tabs-thin::before { - content: "\ed9c"; -} - -.ph-tag-chevron-thin::before { - content: "\ed9d"; -} - -.ph-tag-simple-thin::before { - content: "\ed9e"; -} - -.ph-tag-thin::before { - content: "\ed9f"; -} - -.ph-target-thin::before { - content: "\eda0"; -} - -.ph-taxi-thin::before { - content: "\eda1"; -} - -.ph-telegram-logo-thin::before { - content: "\eda2"; -} - -.ph-television-simple-thin::before { - content: "\eda3"; -} - -.ph-television-thin::before { - content: "\eda4"; -} - -.ph-tennis-ball-thin::before { - content: "\eda5"; -} - -.ph-terminal-thin::before { - content: "\eda6"; -} - -.ph-terminal-window-thin::before { - content: "\eda7"; -} - -.ph-test-tube-thin::before { - content: "\eda8"; -} - -.ph-text-aa-thin::before { - content: "\eda9"; -} - -.ph-text-align-center-thin::before { - content: "\edaa"; -} - -.ph-text-align-justify-thin::before { - content: "\edab"; -} - -.ph-text-align-left-thin::before { - content: "\edac"; -} - -.ph-text-align-right-thin::before { - content: "\edad"; -} - -.ph-text-bolder-thin::before { - content: "\edae"; -} - -.ph-text-h-five-thin::before { - content: "\edaf"; -} - -.ph-text-h-four-thin::before { - content: "\edb0"; -} - -.ph-text-h-one-thin::before { - content: "\edb1"; -} - -.ph-text-h-six-thin::before { - content: "\edb2"; -} - -.ph-text-h-thin::before { - content: "\edb3"; -} - -.ph-text-h-three-thin::before { - content: "\edb4"; -} - -.ph-text-h-two-thin::before { - content: "\edb5"; -} - -.ph-text-indent-thin::before { - content: "\edb6"; -} - -.ph-text-italic-thin::before { - content: "\edb7"; -} - -.ph-text-outdent-thin::before { - content: "\edb8"; -} - -.ph-text-strikethrough-thin::before { - content: "\edb9"; -} - -.ph-text-t-thin::before { - content: "\edba"; -} - -.ph-text-underline-thin::before { - content: "\edbb"; -} - -.ph-textbox-thin::before { - content: "\edbc"; -} - -.ph-thermometer-cold-thin::before { - content: "\edbd"; -} - -.ph-thermometer-hot-thin::before { - content: "\edbe"; -} - -.ph-thermometer-simple-thin::before { - content: "\edbf"; -} - -.ph-thermometer-thin::before { - content: "\edc0"; -} - -.ph-thumbs-down-thin::before { - content: "\edc1"; -} - -.ph-thumbs-up-thin::before { - content: "\edc2"; -} - -.ph-ticket-thin::before { - content: "\edc3"; -} - -.ph-tiktok-logo-thin::before { - content: "\edc4"; -} - -.ph-timer-thin::before { - content: "\edc5"; -} - -.ph-toggle-left-thin::before { - content: "\edc6"; -} - -.ph-toggle-right-thin::before { - content: "\edc7"; -} - -.ph-toilet-paper-thin::before { - content: "\edc8"; -} - -.ph-toilet-thin::before { - content: "\edc9"; -} - -.ph-tote-simple-thin::before { - content: "\edca"; -} - -.ph-tote-thin::before { - content: "\edcb"; -} - -.ph-trademark-registered-thin::before { - content: "\edcc"; -} - -.ph-traffic-cone-thin::before { - content: "\edcd"; -} - -.ph-traffic-sign-thin::before { - content: "\edce"; -} - -.ph-traffic-signal-thin::before { - content: "\edcf"; -} - -.ph-train-regional-thin::before { - content: "\edd0"; -} - -.ph-train-simple-thin::before { - content: "\edd1"; -} - -.ph-train-thin::before { - content: "\edd2"; -} - -.ph-translate-thin::before { - content: "\edd3"; -} - -.ph-trash-simple-thin::before { - content: "\edd4"; -} - -.ph-trash-thin::before { - content: "\edd5"; -} - -.ph-tray-thin::before { - content: "\edd6"; -} - -.ph-tree-evergreen-thin::before { - content: "\edd7"; -} - -.ph-tree-structure-thin::before { - content: "\edd8"; -} - -.ph-tree-thin::before { - content: "\edd9"; -} - -.ph-trend-down-thin::before { - content: "\edda"; -} - -.ph-trend-up-thin::before { - content: "\eddb"; -} - -.ph-triangle-thin::before { - content: "\eddc"; -} - -.ph-trophy-thin::before { - content: "\eddd"; -} - -.ph-truck-thin::before { - content: "\edde"; -} - -.ph-twitch-logo-thin::before { - content: "\eddf"; -} - -.ph-twitter-logo-thin::before { - content: "\ede0"; -} - -.ph-umbrella-simple-thin::before { - content: "\ede1"; -} - -.ph-umbrella-thin::before { - content: "\ede2"; -} - -.ph-upload-simple-thin::before { - content: "\ede3"; -} - -.ph-upload-thin::before { - content: "\ede4"; -} - -.ph-user-circle-gear-thin::before { - content: "\ede5"; -} - -.ph-user-circle-minus-thin::before { - content: "\ede6"; -} - -.ph-user-circle-plus-thin::before { - content: "\ede7"; -} - -.ph-user-circle-thin::before { - content: "\ede8"; -} - -.ph-user-focus-thin::before { - content: "\ede9"; -} - -.ph-user-gear-thin::before { - content: "\edea"; -} - -.ph-user-list-thin::before { - content: "\edeb"; -} - -.ph-user-minus-thin::before { - content: "\edec"; -} - -.ph-user-plus-thin::before { - content: "\eded"; -} - -.ph-user-rectangle-thin::before { - content: "\edee"; -} - -.ph-user-square-thin::before { - content: "\edef"; -} - -.ph-user-switch-thin::before { - content: "\edf0"; -} - -.ph-user-thin::before { - content: "\edf1"; -} - -.ph-users-four-thin::before { - content: "\edf2"; -} - -.ph-users-thin::before { - content: "\edf3"; -} - -.ph-users-three-thin::before { - content: "\edf4"; -} - -.ph-vault-thin::before { - content: "\edf5"; -} - -.ph-vibrate-thin::before { - content: "\edf6"; -} - -.ph-video-camera-slash-thin::before { - content: "\edf7"; -} - -.ph-video-camera-thin::before { - content: "\edf8"; -} - -.ph-vignette-thin::before { - content: "\edf9"; -} - -.ph-voicemail-thin::before { - content: "\edfa"; -} - -.ph-volleyball-thin::before { - content: "\edfb"; -} - -.ph-wall-thin::before { - content: "\edfc"; -} - -.ph-wallet-thin::before { - content: "\edfd"; -} - -.ph-warning-circle-thin::before { - content: "\edfe"; -} - -.ph-warning-octagon-thin::before { - content: "\edff"; -} - -.ph-warning-thin::before { - content: "\ee00"; -} - -.ph-watch-thin::before { - content: "\ee01"; -} - -.ph-wave-sawtooth-thin::before { - content: "\ee02"; -} - -.ph-wave-sine-thin::before { - content: "\ee03"; -} - -.ph-wave-square-thin::before { - content: "\ee04"; -} - -.ph-wave-triangle-thin::before { - content: "\ee05"; -} - -.ph-waves-thin::before { - content: "\ee06"; -} - -.ph-webcam-thin::before { - content: "\ee07"; -} - -.ph-whatsapp-logo-thin::before { - content: "\ee08"; -} - -.ph-wheelchair-thin::before { - content: "\ee09"; -} - -.ph-wifi-high-thin::before { - content: "\ee0a"; -} - -.ph-wifi-low-thin::before { - content: "\ee0b"; -} - -.ph-wifi-medium-thin::before { - content: "\ee0c"; -} - -.ph-wifi-none-thin::before { - content: "\ee0d"; -} - -.ph-wifi-slash-thin::before { - content: "\ee0e"; -} - -.ph-wifi-x-thin::before { - content: "\ee0f"; -} - -.ph-wind-thin::before { - content: "\ee10"; -} - -.ph-windows-logo-thin::before { - content: "\ee11"; -} - -.ph-wine-thin::before { - content: "\ee12"; -} - -.ph-wrench-thin::before { - content: "\ee13"; -} - -.ph-x-circle-thin::before { - content: "\ee14"; -} - -.ph-x-square-thin::before { - content: "\ee15"; -} - -.ph-x-thin::before { - content: "\ee16"; -} - -.ph-yin-yang-thin::before { - content: "\ee17"; -} - -.ph-youtube-logo-thin::before { - content: "\ee18"; -} - -.ph-activity-light::before { - content: "\ee19"; -} - -.ph-address-book-light::before { - content: "\ee1a"; -} - -.ph-airplane-in-flight-light::before { - content: "\ee1b"; -} - -.ph-airplane-landing-light::before { - content: "\ee1c"; -} - -.ph-airplane-light::before { - content: "\ee1d"; -} - -.ph-airplane-takeoff-light::before { - content: "\ee1e"; -} - -.ph-airplane-tilt-light::before { - content: "\ee1f"; -} - -.ph-airplay-light::before { - content: "\ee20"; -} - -.ph-alarm-light::before { - content: "\ee21"; -} - -.ph-alien-light::before { - content: "\ee22"; -} - -.ph-align-bottom-light::before { - content: "\ee23"; -} - -.ph-align-bottom-simple-light::before { - content: "\ee24"; -} - -.ph-align-center-horizontal-light::before { - content: "\ee25"; -} - -.ph-align-center-horizontal-simple-light::before { - content: "\ee26"; -} - -.ph-align-center-vertical-light::before { - content: "\ee27"; -} - -.ph-align-center-vertical-simple-light::before { - content: "\ee28"; -} - -.ph-align-left-light::before { - content: "\ee29"; -} - -.ph-align-left-simple-light::before { - content: "\ee2a"; -} - -.ph-align-right-light::before { - content: "\ee2b"; -} - -.ph-align-right-simple-light::before { - content: "\ee2c"; -} - -.ph-align-top-light::before { - content: "\ee2d"; -} - -.ph-align-top-simple-light::before { - content: "\ee2e"; -} - -.ph-anchor-light::before { - content: "\ee2f"; -} - -.ph-anchor-simple-light::before { - content: "\ee30"; -} - -.ph-android-logo-light::before { - content: "\ee31"; -} - -.ph-angular-logo-light::before { - content: "\ee32"; -} - -.ph-aperture-light::before { - content: "\ee33"; -} - -.ph-app-store-logo-light::before { - content: "\ee34"; -} - -.ph-app-window-light::before { - content: "\ee35"; -} - -.ph-apple-logo-light::before { - content: "\ee36"; -} - -.ph-apple-podcasts-logo-light::before { - content: "\ee37"; -} - -.ph-archive-box-light::before { - content: "\ee38"; -} - -.ph-archive-light::before { - content: "\ee39"; -} - -.ph-archive-tray-light::before { - content: "\ee3a"; -} - -.ph-armchair-light::before { - content: "\ee3b"; -} - -.ph-arrow-arc-left-light::before { - content: "\ee3c"; -} - -.ph-arrow-arc-right-light::before { - content: "\ee3d"; -} - -.ph-arrow-bend-double-up-left-light::before { - content: "\ee3e"; -} - -.ph-arrow-bend-double-up-right-light::before { - content: "\ee3f"; -} - -.ph-arrow-bend-down-left-light::before { - content: "\ee40"; -} - -.ph-arrow-bend-down-right-light::before { - content: "\ee41"; -} - -.ph-arrow-bend-left-down-light::before { - content: "\ee42"; -} - -.ph-arrow-bend-left-up-light::before { - content: "\ee43"; -} - -.ph-arrow-bend-right-down-light::before { - content: "\ee44"; -} - -.ph-arrow-bend-right-up-light::before { - content: "\ee45"; -} - -.ph-arrow-bend-up-left-light::before { - content: "\ee46"; -} - -.ph-arrow-bend-up-right-light::before { - content: "\ee47"; -} - -.ph-arrow-circle-down-left-light::before { - content: "\ee48"; -} - -.ph-arrow-circle-down-light::before { - content: "\ee49"; -} - -.ph-arrow-circle-down-right-light::before { - content: "\ee4a"; -} - -.ph-arrow-circle-left-light::before { - content: "\ee4b"; -} - -.ph-arrow-circle-right-light::before { - content: "\ee4c"; -} - -.ph-arrow-circle-up-left-light::before { - content: "\ee4d"; -} - -.ph-arrow-circle-up-light::before { - content: "\ee4e"; -} - -.ph-arrow-circle-up-right-light::before { - content: "\ee4f"; -} - -.ph-arrow-clockwise-light::before { - content: "\ee50"; -} - -.ph-arrow-counter-clockwise-light::before { - content: "\ee51"; -} - -.ph-arrow-down-left-light::before { - content: "\ee52"; -} - -.ph-arrow-down-light::before { - content: "\ee53"; -} - -.ph-arrow-down-right-light::before { - content: "\ee54"; -} - -.ph-arrow-elbow-down-left-light::before { - content: "\ee55"; -} - -.ph-arrow-elbow-down-right-light::before { - content: "\ee56"; -} - -.ph-arrow-elbow-left-down-light::before { - content: "\ee57"; -} - -.ph-arrow-elbow-left-light::before { - content: "\ee58"; -} - -.ph-arrow-elbow-left-up-light::before { - content: "\ee59"; -} - -.ph-arrow-elbow-right-down-light::before { - content: "\ee5a"; -} - -.ph-arrow-elbow-right-light::before { - content: "\ee5b"; -} - -.ph-arrow-elbow-right-up-light::before { - content: "\ee5c"; -} - -.ph-arrow-elbow-up-left-light::before { - content: "\ee5d"; -} - -.ph-arrow-elbow-up-right-light::before { - content: "\ee5e"; -} - -.ph-arrow-fat-down-light::before { - content: "\ee5f"; -} - -.ph-arrow-fat-left-light::before { - content: "\ee60"; -} - -.ph-arrow-fat-line-down-light::before { - content: "\ee61"; -} - -.ph-arrow-fat-line-left-light::before { - content: "\ee62"; -} - -.ph-arrow-fat-line-right-light::before { - content: "\ee63"; -} - -.ph-arrow-fat-line-up-light::before { - content: "\ee64"; -} - -.ph-arrow-fat-lines-down-light::before { - content: "\ee65"; -} - -.ph-arrow-fat-lines-left-light::before { - content: "\ee66"; -} - -.ph-arrow-fat-lines-right-light::before { - content: "\ee67"; -} - -.ph-arrow-fat-lines-up-light::before { - content: "\ee68"; -} - -.ph-arrow-fat-right-light::before { - content: "\ee69"; -} - -.ph-arrow-fat-up-light::before { - content: "\ee6a"; -} - -.ph-arrow-left-light::before { - content: "\ee6b"; -} - -.ph-arrow-line-down-left-light::before { - content: "\ee6c"; -} - -.ph-arrow-line-down-light::before { - content: "\ee6d"; -} - -.ph-arrow-line-down-right-light::before { - content: "\ee6e"; -} - -.ph-arrow-line-left-light::before { - content: "\ee6f"; -} - -.ph-arrow-line-right-light::before { - content: "\ee70"; -} - -.ph-arrow-line-up-left-light::before { - content: "\ee71"; -} - -.ph-arrow-line-up-light::before { - content: "\ee72"; -} - -.ph-arrow-line-up-right-light::before { - content: "\ee73"; -} - -.ph-arrow-right-light::before { - content: "\ee74"; -} - -.ph-arrow-square-down-left-light::before { - content: "\ee75"; -} - -.ph-arrow-square-down-light::before { - content: "\ee76"; -} - -.ph-arrow-square-down-right-light::before { - content: "\ee77"; -} - -.ph-arrow-square-in-light::before { - content: "\ee78"; -} - -.ph-arrow-square-left-light::before { - content: "\ee79"; -} - -.ph-arrow-square-out-light::before { - content: "\ee7a"; -} - -.ph-arrow-square-right-light::before { - content: "\ee7b"; -} - -.ph-arrow-square-up-left-light::before { - content: "\ee7c"; -} - -.ph-arrow-square-up-light::before { - content: "\ee7d"; -} - -.ph-arrow-square-up-right-light::before { - content: "\ee7e"; -} - -.ph-arrow-u-down-left-light::before { - content: "\ee7f"; -} - -.ph-arrow-u-down-right-light::before { - content: "\ee80"; -} - -.ph-arrow-u-left-down-light::before { - content: "\ee81"; -} - -.ph-arrow-u-left-up-light::before { - content: "\ee82"; -} - -.ph-arrow-u-right-down-light::before { - content: "\ee83"; -} - -.ph-arrow-u-right-up-light::before { - content: "\ee84"; -} - -.ph-arrow-u-up-left-light::before { - content: "\ee85"; -} - -.ph-arrow-u-up-right-light::before { - content: "\ee86"; -} - -.ph-arrow-up-left-light::before { - content: "\ee87"; -} - -.ph-arrow-up-light::before { - content: "\ee88"; -} - -.ph-arrow-up-right-light::before { - content: "\ee89"; -} - -.ph-arrows-clockwise-light::before { - content: "\ee8a"; -} - -.ph-arrows-counter-clockwise-light::before { - content: "\ee8b"; -} - -.ph-arrows-down-up-light::before { - content: "\ee8c"; -} - -.ph-arrows-horizontal-light::before { - content: "\ee8d"; -} - -.ph-arrows-in-cardinal-light::before { - content: "\ee8e"; -} - -.ph-arrows-in-light::before { - content: "\ee8f"; -} - -.ph-arrows-in-line-horizontal-light::before { - content: "\ee90"; -} - -.ph-arrows-in-line-vertical-light::before { - content: "\ee91"; -} - -.ph-arrows-in-simple-light::before { - content: "\ee92"; -} - -.ph-arrows-left-right-light::before { - content: "\ee93"; -} - -.ph-arrows-out-cardinal-light::before { - content: "\ee94"; -} - -.ph-arrows-out-light::before { - content: "\ee95"; -} - -.ph-arrows-out-line-horizontal-light::before { - content: "\ee96"; -} - -.ph-arrows-out-line-vertical-light::before { - content: "\ee97"; -} - -.ph-arrows-out-simple-light::before { - content: "\ee98"; -} - -.ph-arrows-vertical-light::before { - content: "\ee99"; -} - -.ph-article-light::before { - content: "\ee9a"; -} - -.ph-article-medium-light::before { - content: "\ee9b"; -} - -.ph-article-ny-times-light::before { - content: "\ee9c"; -} - -.ph-asterisk-light::before { - content: "\ee9d"; -} - -.ph-asterisk-simple-light::before { - content: "\ee9e"; -} - -.ph-at-light::before { - content: "\ee9f"; -} - -.ph-atom-light::before { - content: "\eea0"; -} - -.ph-baby-light::before { - content: "\eea1"; -} - -.ph-backpack-light::before { - content: "\eea2"; -} - -.ph-backspace-light::before { - content: "\eea3"; -} - -.ph-bag-light::before { - content: "\eea4"; -} - -.ph-bag-simple-light::before { - content: "\eea5"; -} - -.ph-balloon-light::before { - content: "\eea6"; -} - -.ph-bandaids-light::before { - content: "\eea7"; -} - -.ph-bank-light::before { - content: "\eea8"; -} - -.ph-barbell-light::before { - content: "\eea9"; -} - -.ph-barcode-light::before { - content: "\eeaa"; -} - -.ph-barricade-light::before { - content: "\eeab"; -} - -.ph-baseball-light::before { - content: "\eeac"; -} - -.ph-basketball-light::before { - content: "\eead"; -} - -.ph-bathtub-light::before { - content: "\eeae"; -} - -.ph-battery-charging-light::before { - content: "\eeaf"; -} - -.ph-battery-charging-vertical-light::before { - content: "\eeb0"; -} - -.ph-battery-empty-light::before { - content: "\eeb1"; -} - -.ph-battery-full-light::before { - content: "\eeb2"; -} - -.ph-battery-high-light::before { - content: "\eeb3"; -} - -.ph-battery-low-light::before { - content: "\eeb4"; -} - -.ph-battery-medium-light::before { - content: "\eeb5"; -} - -.ph-battery-plus-light::before { - content: "\eeb6"; -} - -.ph-battery-warning-light::before { - content: "\eeb7"; -} - -.ph-battery-warning-vertical-light::before { - content: "\eeb8"; -} - -.ph-bed-light::before { - content: "\eeb9"; -} - -.ph-beer-bottle-light::before { - content: "\eeba"; -} - -.ph-behance-logo-light::before { - content: "\eebb"; -} - -.ph-bell-light::before { - content: "\eebc"; -} - -.ph-bell-ringing-light::before { - content: "\eebd"; -} - -.ph-bell-simple-light::before { - content: "\eebe"; -} - -.ph-bell-simple-ringing-light::before { - content: "\eebf"; -} - -.ph-bell-simple-slash-light::before { - content: "\eec0"; -} - -.ph-bell-simple-z-light::before { - content: "\eec1"; -} - -.ph-bell-slash-light::before { - content: "\eec2"; -} - -.ph-bell-z-light::before { - content: "\eec3"; -} - -.ph-bezier-curve-light::before { - content: "\eec4"; -} - -.ph-bicycle-light::before { - content: "\eec5"; -} - -.ph-binoculars-light::before { - content: "\eec6"; -} - -.ph-bird-light::before { - content: "\eec7"; -} - -.ph-bluetooth-connected-light::before { - content: "\eec8"; -} - -.ph-bluetooth-light::before { - content: "\eec9"; -} - -.ph-bluetooth-slash-light::before { - content: "\eeca"; -} - -.ph-bluetooth-x-light::before { - content: "\eecb"; -} - -.ph-boat-light::before { - content: "\eecc"; -} - -.ph-book-bookmark-light::before { - content: "\eecd"; -} - -.ph-book-light::before { - content: "\eece"; -} - -.ph-book-open-light::before { - content: "\eecf"; -} - -.ph-bookmark-light::before { - content: "\eed0"; -} - -.ph-bookmark-simple-light::before { - content: "\eed1"; -} - -.ph-bookmarks-light::before { - content: "\eed2"; -} - -.ph-bookmarks-simple-light::before { - content: "\eed3"; -} - -.ph-books-light::before { - content: "\eed4"; -} - -.ph-bounding-box-light::before { - content: "\eed5"; -} - -.ph-brackets-angle-light::before { - content: "\eed6"; -} - -.ph-brackets-curly-light::before { - content: "\eed7"; -} - -.ph-brackets-round-light::before { - content: "\eed8"; -} - -.ph-brackets-square-light::before { - content: "\eed9"; -} - -.ph-brain-light::before { - content: "\eeda"; -} - -.ph-brandy-light::before { - content: "\eedb"; -} - -.ph-briefcase-light::before { - content: "\eedc"; -} - -.ph-briefcase-metal-light::before { - content: "\eedd"; -} - -.ph-broadcast-light::before { - content: "\eede"; -} - -.ph-browser-light::before { - content: "\eedf"; -} - -.ph-browsers-light::before { - content: "\eee0"; -} - -.ph-bug-beetle-light::before { - content: "\eee1"; -} - -.ph-bug-droid-light::before { - content: "\eee2"; -} - -.ph-bug-light::before { - content: "\eee3"; -} - -.ph-buildings-light::before { - content: "\eee4"; -} - -.ph-bus-light::before { - content: "\eee5"; -} - -.ph-butterfly-light::before { - content: "\eee6"; -} - -.ph-cactus-light::before { - content: "\eee7"; -} - -.ph-cake-light::before { - content: "\eee8"; -} - -.ph-calculator-light::before { - content: "\eee9"; -} - -.ph-calendar-blank-light::before { - content: "\eeea"; -} - -.ph-calendar-check-light::before { - content: "\eeeb"; -} - -.ph-calendar-light::before { - content: "\eeec"; -} - -.ph-calendar-plus-light::before { - content: "\eeed"; -} - -.ph-calendar-x-light::before { - content: "\eeee"; -} - -.ph-camera-light::before { - content: "\eeef"; -} - -.ph-camera-rotate-light::before { - content: "\eef0"; -} - -.ph-camera-slash-light::before { - content: "\eef1"; -} - -.ph-campfire-light::before { - content: "\eef2"; -} - -.ph-car-light::before { - content: "\eef3"; -} - -.ph-car-simple-light::before { - content: "\eef4"; -} - -.ph-cardholder-light::before { - content: "\eef5"; -} - -.ph-cards-light::before { - content: "\eef6"; -} - -.ph-caret-circle-double-down-light::before { - content: "\eef7"; -} - -.ph-caret-circle-double-left-light::before { - content: "\eef8"; -} - -.ph-caret-circle-double-right-light::before { - content: "\eef9"; -} - -.ph-caret-circle-double-up-light::before { - content: "\eefa"; -} - -.ph-caret-circle-down-light::before { - content: "\eefb"; -} - -.ph-caret-circle-left-light::before { - content: "\eefc"; -} - -.ph-caret-circle-right-light::before { - content: "\eefd"; -} - -.ph-caret-circle-up-light::before { - content: "\eefe"; -} - -.ph-caret-double-down-light::before { - content: "\eeff"; -} - -.ph-caret-double-left-light::before { - content: "\ef00"; -} - -.ph-caret-double-right-light::before { - content: "\ef01"; -} - -.ph-caret-double-up-light::before { - content: "\ef02"; -} - -.ph-caret-down-light::before { - content: "\ef03"; -} - -.ph-caret-left-light::before { - content: "\ef04"; -} - -.ph-caret-right-light::before { - content: "\ef05"; -} - -.ph-caret-up-light::before { - content: "\ef06"; -} - -.ph-cat-light::before { - content: "\ef07"; -} - -.ph-cell-signal-full-light::before { - content: "\ef08"; -} - -.ph-cell-signal-high-light::before { - content: "\ef09"; -} - -.ph-cell-signal-low-light::before { - content: "\ef0a"; -} - -.ph-cell-signal-medium-light::before { - content: "\ef0b"; -} - -.ph-cell-signal-none-light::before { - content: "\ef0c"; -} - -.ph-cell-signal-slash-light::before { - content: "\ef0d"; -} - -.ph-cell-signal-x-light::before { - content: "\ef0e"; -} - -.ph-chalkboard-light::before { - content: "\ef0f"; -} - -.ph-chalkboard-simple-light::before { - content: "\ef10"; -} - -.ph-chalkboard-teacher-light::before { - content: "\ef11"; -} - -.ph-chart-bar-horizontal-light::before { - content: "\ef12"; -} - -.ph-chart-bar-light::before { - content: "\ef13"; -} - -.ph-chart-line-light::before { - content: "\ef14"; -} - -.ph-chart-line-up-light::before { - content: "\ef15"; -} - -.ph-chart-pie-light::before { - content: "\ef16"; -} - -.ph-chart-pie-slice-light::before { - content: "\ef17"; -} - -.ph-chat-centered-dots-light::before { - content: "\ef18"; -} - -.ph-chat-centered-light::before { - content: "\ef19"; -} - -.ph-chat-centered-text-light::before { - content: "\ef1a"; -} - -.ph-chat-circle-dots-light::before { - content: "\ef1b"; -} - -.ph-chat-circle-light::before { - content: "\ef1c"; -} - -.ph-chat-circle-text-light::before { - content: "\ef1d"; -} - -.ph-chat-dots-light::before { - content: "\ef1e"; -} - -.ph-chat-light::before { - content: "\ef1f"; -} - -.ph-chat-teardrop-dots-light::before { - content: "\ef20"; -} - -.ph-chat-teardrop-light::before { - content: "\ef21"; -} - -.ph-chat-teardrop-text-light::before { - content: "\ef22"; -} - -.ph-chat-text-light::before { - content: "\ef23"; -} - -.ph-chats-circle-light::before { - content: "\ef24"; -} - -.ph-chats-light::before { - content: "\ef25"; -} - -.ph-chats-teardrop-light::before { - content: "\ef26"; -} - -.ph-check-circle-light::before { - content: "\ef27"; -} - -.ph-check-light::before { - content: "\ef28"; -} - -.ph-check-square-light::before { - content: "\ef29"; -} - -.ph-check-square-offset-light::before { - content: "\ef2a"; -} - -.ph-checks-light::before { - content: "\ef2b"; -} - -.ph-circle-dashed-light::before { - content: "\ef2c"; -} - -.ph-circle-half-light::before { - content: "\ef2d"; -} - -.ph-circle-half-tilt-light::before { - content: "\ef2e"; -} - -.ph-circle-light::before { - content: "\ef2f"; -} - -.ph-circle-notch-light::before { - content: "\ef30"; -} - -.ph-circle-wavy-check-light::before { - content: "\ef31"; -} - -.ph-circle-wavy-light::before { - content: "\ef32"; -} - -.ph-circle-wavy-question-light::before { - content: "\ef33"; -} - -.ph-circle-wavy-warning-light::before { - content: "\ef34"; -} - -.ph-circles-four-light::before { - content: "\ef35"; -} - -.ph-circles-three-light::before { - content: "\ef36"; -} - -.ph-circles-three-plus-light::before { - content: "\ef37"; -} - -.ph-clipboard-light::before { - content: "\ef38"; -} - -.ph-clipboard-text-light::before { - content: "\ef39"; -} - -.ph-clock-afternoon-light::before { - content: "\ef3a"; -} - -.ph-clock-clockwise-light::before { - content: "\ef3b"; -} - -.ph-clock-counter-clockwise-light::before { - content: "\ef3c"; -} - -.ph-clock-light::before { - content: "\ef3d"; -} - -.ph-closed-captioning-light::before { - content: "\ef3e"; -} - -.ph-cloud-arrow-down-light::before { - content: "\ef3f"; -} - -.ph-cloud-arrow-up-light::before { - content: "\ef40"; -} - -.ph-cloud-check-light::before { - content: "\ef41"; -} - -.ph-cloud-fog-light::before { - content: "\ef42"; -} - -.ph-cloud-light::before { - content: "\ef43"; -} - -.ph-cloud-lightning-light::before { - content: "\ef44"; -} - -.ph-cloud-moon-light::before { - content: "\ef45"; -} - -.ph-cloud-rain-light::before { - content: "\ef46"; -} - -.ph-cloud-slash-light::before { - content: "\ef47"; -} - -.ph-cloud-snow-light::before { - content: "\ef48"; -} - -.ph-cloud-sun-light::before { - content: "\ef49"; -} - -.ph-club-light::before { - content: "\ef4a"; -} - -.ph-coat-hanger-light::before { - content: "\ef4b"; -} - -.ph-code-light::before { - content: "\ef4c"; -} - -.ph-code-simple-light::before { - content: "\ef4d"; -} - -.ph-codepen-logo-light::before { - content: "\ef4e"; -} - -.ph-codesandbox-logo-light::before { - content: "\ef4f"; -} - -.ph-coffee-light::before { - content: "\ef50"; -} - -.ph-coin-light::before { - content: "\ef51"; -} - -.ph-coin-vertical-light::before { - content: "\ef52"; -} - -.ph-coins-light::before { - content: "\ef53"; -} - -.ph-columns-light::before { - content: "\ef54"; -} - -.ph-command-light::before { - content: "\ef55"; -} - -.ph-compass-light::before { - content: "\ef56"; -} - -.ph-computer-tower-light::before { - content: "\ef57"; -} - -.ph-confetti-light::before { - content: "\ef58"; -} - -.ph-cookie-light::before { - content: "\ef59"; -} - -.ph-cooking-pot-light::before { - content: "\ef5a"; -} - -.ph-copy-light::before { - content: "\ef5b"; -} - -.ph-copy-simple-light::before { - content: "\ef5c"; -} - -.ph-copyleft-light::before { - content: "\ef5d"; -} - -.ph-copyright-light::before { - content: "\ef5e"; -} - -.ph-corners-in-light::before { - content: "\ef5f"; -} - -.ph-corners-out-light::before { - content: "\ef60"; -} - -.ph-cpu-light::before { - content: "\ef61"; -} - -.ph-credit-card-light::before { - content: "\ef62"; -} - -.ph-crop-light::before { - content: "\ef63"; -} - -.ph-crosshair-light::before { - content: "\ef64"; -} - -.ph-crosshair-simple-light::before { - content: "\ef65"; -} - -.ph-crown-light::before { - content: "\ef66"; -} - -.ph-crown-simple-light::before { - content: "\ef67"; -} - -.ph-cube-light::before { - content: "\ef68"; -} - -.ph-currency-btc-light::before { - content: "\ef69"; -} - -.ph-currency-circle-dollar-light::before { - content: "\ef6a"; -} - -.ph-currency-cny-light::before { - content: "\ef6b"; -} - -.ph-currency-dollar-light::before { - content: "\ef6c"; -} - -.ph-currency-dollar-simple-light::before { - content: "\ef6d"; -} - -.ph-currency-eth-light::before { - content: "\ef6e"; -} - -.ph-currency-eur-light::before { - content: "\ef6f"; -} - -.ph-currency-gbp-light::before { - content: "\ef70"; -} - -.ph-currency-inr-light::before { - content: "\ef71"; -} - -.ph-currency-jpy-light::before { - content: "\ef72"; -} - -.ph-currency-krw-light::before { - content: "\ef73"; -} - -.ph-currency-kzt-light::before { - content: "\ef74"; -} - -.ph-currency-ngn-light::before { - content: "\ef75"; -} - -.ph-currency-rub-light::before { - content: "\ef76"; -} - -.ph-cursor-light::before { - content: "\ef77"; -} - -.ph-cursor-text-light::before { - content: "\ef78"; -} - -.ph-cylinder-light::before { - content: "\ef79"; -} - -.ph-database-light::before { - content: "\ef7a"; -} - -.ph-desktop-light::before { - content: "\ef7b"; -} - -.ph-desktop-tower-light::before { - content: "\ef7c"; -} - -.ph-detective-light::before { - content: "\ef7d"; -} - -.ph-device-mobile-camera-light::before { - content: "\ef7e"; -} - -.ph-device-mobile-light::before { - content: "\ef7f"; -} - -.ph-device-mobile-speaker-light::before { - content: "\ef80"; -} - -.ph-device-tablet-camera-light::before { - content: "\ef81"; -} - -.ph-device-tablet-light::before { - content: "\ef82"; -} - -.ph-device-tablet-speaker-light::before { - content: "\ef83"; -} - -.ph-diamond-light::before { - content: "\ef84"; -} - -.ph-diamonds-four-light::before { - content: "\ef85"; -} - -.ph-dice-five-light::before { - content: "\ef86"; -} - -.ph-dice-four-light::before { - content: "\ef87"; -} - -.ph-dice-one-light::before { - content: "\ef88"; -} - -.ph-dice-six-light::before { - content: "\ef89"; -} - -.ph-dice-three-light::before { - content: "\ef8a"; -} - -.ph-dice-two-light::before { - content: "\ef8b"; -} - -.ph-disc-light::before { - content: "\ef8c"; -} - -.ph-discord-logo-light::before { - content: "\ef8d"; -} - -.ph-divide-light::before { - content: "\ef8e"; -} - -.ph-dog-light::before { - content: "\ef8f"; -} - -.ph-door-light::before { - content: "\ef90"; -} - -.ph-dots-nine-light::before { - content: "\ef91"; -} - -.ph-dots-six-light::before { - content: "\ef92"; -} - -.ph-dots-six-vertical-light::before { - content: "\ef93"; -} - -.ph-dots-three-circle-light::before { - content: "\ef94"; -} - -.ph-dots-three-circle-vertical-light::before { - content: "\ef95"; -} - -.ph-dots-three-light::before { - content: "\ef96"; -} - -.ph-dots-three-outline-light::before { - content: "\ef97"; -} - -.ph-dots-three-outline-vertical-light::before { - content: "\ef98"; -} - -.ph-dots-three-vertical-light::before { - content: "\ef99"; -} - -.ph-download-light::before { - content: "\ef9a"; -} - -.ph-download-simple-light::before { - content: "\ef9b"; -} - -.ph-dribbble-logo-light::before { - content: "\ef9c"; -} - -.ph-drop-half-bottom-light::before { - content: "\ef9d"; -} - -.ph-drop-half-light::before { - content: "\ef9e"; -} - -.ph-drop-light::before { - content: "\ef9f"; -} - -.ph-ear-light::before { - content: "\efa0"; -} - -.ph-ear-slash-light::before { - content: "\efa1"; -} - -.ph-egg-crack-light::before { - content: "\efa2"; -} - -.ph-egg-light::before { - content: "\efa3"; -} - -.ph-eject-light::before { - content: "\efa4"; -} - -.ph-eject-simple-light::before { - content: "\efa5"; -} - -.ph-envelope-light::before { - content: "\efa6"; -} - -.ph-envelope-open-light::before { - content: "\efa7"; -} - -.ph-envelope-simple-light::before { - content: "\efa8"; -} - -.ph-envelope-simple-open-light::before { - content: "\efa9"; -} - -.ph-equalizer-light::before { - content: "\efaa"; -} - -.ph-equals-light::before { - content: "\efab"; -} - -.ph-eraser-light::before { - content: "\efac"; -} - -.ph-exam-light::before { - content: "\efad"; -} - -.ph-export-light::before { - content: "\efae"; -} - -.ph-eye-closed-light::before { - content: "\efaf"; -} - -.ph-eye-light::before { - content: "\efb0"; -} - -.ph-eye-slash-light::before { - content: "\efb1"; -} - -.ph-eyedropper-light::before { - content: "\efb2"; -} - -.ph-eyedropper-sample-light::before { - content: "\efb3"; -} - -.ph-eyeglasses-light::before { - content: "\efb4"; -} - -.ph-face-mask-light::before { - content: "\efb5"; -} - -.ph-facebook-logo-light::before { - content: "\efb6"; -} - -.ph-factory-light::before { - content: "\efb7"; -} - -.ph-faders-horizontal-light::before { - content: "\efb8"; -} - -.ph-faders-light::before { - content: "\efb9"; -} - -.ph-fast-forward-circle-light::before { - content: "\efba"; -} - -.ph-fast-forward-light::before { - content: "\efbb"; -} - -.ph-figma-logo-light::before { - content: "\efbc"; -} - -.ph-file-arrow-down-light::before { - content: "\efbd"; -} - -.ph-file-arrow-up-light::before { - content: "\efbe"; -} - -.ph-file-audio-light::before { - content: "\efbf"; -} - -.ph-file-cloud-light::before { - content: "\efc0"; -} - -.ph-file-code-light::before { - content: "\efc1"; -} - -.ph-file-css-light::before { - content: "\efc2"; -} - -.ph-file-csv-light::before { - content: "\efc3"; -} - -.ph-file-doc-light::before { - content: "\efc4"; -} - -.ph-file-dotted-light::before { - content: "\efc5"; -} - -.ph-file-html-light::before { - content: "\efc6"; -} - -.ph-file-image-light::before { - content: "\efc7"; -} - -.ph-file-jpg-light::before { - content: "\efc8"; -} - -.ph-file-js-light::before { - content: "\efc9"; -} - -.ph-file-jsx-light::before { - content: "\efca"; -} - -.ph-file-light::before { - content: "\efcb"; -} - -.ph-file-lock-light::before { - content: "\efcc"; -} - -.ph-file-minus-light::before { - content: "\efcd"; -} - -.ph-file-pdf-light::before { - content: "\efce"; -} - -.ph-file-plus-light::before { - content: "\efcf"; -} - -.ph-file-png-light::before { - content: "\efd0"; -} - -.ph-file-ppt-light::before { - content: "\efd1"; -} - -.ph-file-rs-light::before { - content: "\efd2"; -} - -.ph-file-search-light::before { - content: "\efd3"; -} - -.ph-file-text-light::before { - content: "\efd4"; -} - -.ph-file-ts-light::before { - content: "\efd5"; -} - -.ph-file-tsx-light::before { - content: "\efd6"; -} - -.ph-file-video-light::before { - content: "\efd7"; -} - -.ph-file-vue-light::before { - content: "\efd8"; -} - -.ph-file-x-light::before { - content: "\efd9"; -} - -.ph-file-xls-light::before { - content: "\efda"; -} - -.ph-file-zip-light::before { - content: "\efdb"; -} - -.ph-files-light::before { - content: "\efdc"; -} - -.ph-film-script-light::before { - content: "\efdd"; -} - -.ph-film-slate-light::before { - content: "\efde"; -} - -.ph-film-strip-light::before { - content: "\efdf"; -} - -.ph-fingerprint-light::before { - content: "\efe0"; -} - -.ph-fingerprint-simple-light::before { - content: "\efe1"; -} - -.ph-finn-the-human-light::before { - content: "\efe2"; -} - -.ph-fire-light::before { - content: "\efe3"; -} - -.ph-fire-simple-light::before { - content: "\efe4"; -} - -.ph-first-aid-kit-light::before { - content: "\efe5"; -} - -.ph-first-aid-light::before { - content: "\efe6"; -} - -.ph-fish-light::before { - content: "\efe7"; -} - -.ph-fish-simple-light::before { - content: "\efe8"; -} - -.ph-flag-banner-light::before { - content: "\efe9"; -} - -.ph-flag-checkered-light::before { - content: "\efea"; -} - -.ph-flag-light::before { - content: "\efeb"; -} - -.ph-flame-light::before { - content: "\efec"; -} - -.ph-flashlight-light::before { - content: "\efed"; -} - -.ph-flask-light::before { - content: "\efee"; -} - -.ph-floppy-disk-back-light::before { - content: "\efef"; -} - -.ph-floppy-disk-light::before { - content: "\eff0"; -} - -.ph-flow-arrow-light::before { - content: "\eff1"; -} - -.ph-flower-light::before { - content: "\eff2"; -} - -.ph-flower-lotus-light::before { - content: "\eff3"; -} - -.ph-flying-saucer-light::before { - content: "\eff4"; -} - -.ph-folder-dotted-light::before { - content: "\eff5"; -} - -.ph-folder-light::before { - content: "\eff6"; -} - -.ph-folder-lock-light::before { - content: "\eff7"; -} - -.ph-folder-minus-light::before { - content: "\eff8"; -} - -.ph-folder-notch-light::before { - content: "\eff9"; -} - -.ph-folder-notch-minus-light::before { - content: "\effa"; -} - -.ph-folder-notch-open-light::before { - content: "\effb"; -} - -.ph-folder-notch-plus-light::before { - content: "\effc"; -} - -.ph-folder-open-light::before { - content: "\effd"; -} - -.ph-folder-plus-light::before { - content: "\effe"; -} - -.ph-folder-simple-dotted-light::before { - content: "\efff"; -} - -.ph-folder-simple-light::before { - content: "\f000"; -} - -.ph-folder-simple-lock-light::before { - content: "\f001"; -} - -.ph-folder-simple-minus-light::before { - content: "\f002"; -} - -.ph-folder-simple-plus-light::before { - content: "\f003"; -} - -.ph-folder-simple-star-light::before { - content: "\f004"; -} - -.ph-folder-simple-user-light::before { - content: "\f005"; -} - -.ph-folder-star-light::before { - content: "\f006"; -} - -.ph-folder-user-light::before { - content: "\f007"; -} - -.ph-folders-light::before { - content: "\f008"; -} - -.ph-football-light::before { - content: "\f009"; -} - -.ph-fork-knife-light::before { - content: "\f00a"; -} - -.ph-frame-corners-light::before { - content: "\f00b"; -} - -.ph-framer-logo-light::before { - content: "\f00c"; -} - -.ph-function-light::before { - content: "\f00d"; -} - -.ph-funnel-light::before { - content: "\f00e"; -} - -.ph-funnel-simple-light::before { - content: "\f00f"; -} - -.ph-game-controller-light::before { - content: "\f010"; -} - -.ph-gas-pump-light::before { - content: "\f011"; -} - -.ph-gauge-light::before { - content: "\f012"; -} - -.ph-gear-light::before { - content: "\f013"; -} - -.ph-gear-six-light::before { - content: "\f014"; -} - -.ph-gender-female-light::before { - content: "\f015"; -} - -.ph-gender-intersex-light::before { - content: "\f016"; -} - -.ph-gender-male-light::before { - content: "\f017"; -} - -.ph-gender-neuter-light::before { - content: "\f018"; -} - -.ph-gender-nonbinary-light::before { - content: "\f019"; -} - -.ph-gender-transgender-light::before { - content: "\f01a"; -} - -.ph-ghost-light::before { - content: "\f01b"; -} - -.ph-gif-light::before { - content: "\f01c"; -} - -.ph-gift-light::before { - content: "\f01d"; -} - -.ph-git-branch-light::before { - content: "\f01e"; -} - -.ph-git-commit-light::before { - content: "\f01f"; -} - -.ph-git-diff-light::before { - content: "\f020"; -} - -.ph-git-fork-light::before { - content: "\f021"; -} - -.ph-git-merge-light::before { - content: "\f022"; -} - -.ph-git-pull-request-light::before { - content: "\f023"; -} - -.ph-github-logo-light::before { - content: "\f024"; -} - -.ph-gitlab-logo-light::before { - content: "\f025"; -} - -.ph-gitlab-logo-simple-light::before { - content: "\f026"; -} - -.ph-globe-hemisphere-east-light::before { - content: "\f027"; -} - -.ph-globe-hemisphere-west-light::before { - content: "\f028"; -} - -.ph-globe-light::before { - content: "\f029"; -} - -.ph-globe-simple-light::before { - content: "\f02a"; -} - -.ph-globe-stand-light::before { - content: "\f02b"; -} - -.ph-google-chrome-logo-light::before { - content: "\f02c"; -} - -.ph-google-logo-light::before { - content: "\f02d"; -} - -.ph-google-photos-logo-light::before { - content: "\f02e"; -} - -.ph-google-play-logo-light::before { - content: "\f02f"; -} - -.ph-google-podcasts-logo-light::before { - content: "\f030"; -} - -.ph-gradient-light::before { - content: "\f031"; -} - -.ph-graduation-cap-light::before { - content: "\f032"; -} - -.ph-graph-light::before { - content: "\f033"; -} - -.ph-grid-four-light::before { - content: "\f034"; -} - -.ph-hamburger-light::before { - content: "\f035"; -} - -.ph-hand-eye-light::before { - content: "\f036"; -} - -.ph-hand-fist-light::before { - content: "\f037"; -} - -.ph-hand-grabbing-light::before { - content: "\f038"; -} - -.ph-hand-light::before { - content: "\f039"; -} - -.ph-hand-palm-light::before { - content: "\f03a"; -} - -.ph-hand-pointing-light::before { - content: "\f03b"; -} - -.ph-hand-soap-light::before { - content: "\f03c"; -} - -.ph-hand-waving-light::before { - content: "\f03d"; -} - -.ph-handbag-light::before { - content: "\f03e"; -} - -.ph-handbag-simple-light::before { - content: "\f03f"; -} - -.ph-hands-clapping-light::before { - content: "\f040"; -} - -.ph-handshake-light::before { - content: "\f041"; -} - -.ph-hard-drive-light::before { - content: "\f042"; -} - -.ph-hard-drives-light::before { - content: "\f043"; -} - -.ph-hash-light::before { - content: "\f044"; -} - -.ph-hash-straight-light::before { - content: "\f045"; -} - -.ph-headlights-light::before { - content: "\f046"; -} - -.ph-headphones-light::before { - content: "\f047"; -} - -.ph-headset-light::before { - content: "\f048"; -} - -.ph-heart-break-light::before { - content: "\f049"; -} - -.ph-heart-light::before { - content: "\f04a"; -} - -.ph-heart-straight-break-light::before { - content: "\f04b"; -} - -.ph-heart-straight-light::before { - content: "\f04c"; -} - -.ph-heartbeat-light::before { - content: "\f04d"; -} - -.ph-hexagon-light::before { - content: "\f04e"; -} - -.ph-highlighter-circle-light::before { - content: "\f04f"; -} - -.ph-horse-light::before { - content: "\f050"; -} - -.ph-hourglass-high-light::before { - content: "\f051"; -} - -.ph-hourglass-light::before { - content: "\f052"; -} - -.ph-hourglass-low-light::before { - content: "\f053"; -} - -.ph-hourglass-medium-light::before { - content: "\f054"; -} - -.ph-hourglass-simple-high-light::before { - content: "\f055"; -} - -.ph-hourglass-simple-light::before { - content: "\f056"; -} - -.ph-hourglass-simple-low-light::before { - content: "\f057"; -} - -.ph-hourglass-simple-medium-light::before { - content: "\f058"; -} - -.ph-house-light::before { - content: "\f059"; -} - -.ph-house-line-light::before { - content: "\f05a"; -} - -.ph-house-simple-light::before { - content: "\f05b"; -} - -.ph-identification-badge-light::before { - content: "\f05c"; -} - -.ph-identification-card-light::before { - content: "\f05d"; -} - -.ph-image-light::before { - content: "\f05e"; -} - -.ph-image-square-light::before { - content: "\f05f"; -} - -.ph-infinity-light::before { - content: "\f060"; -} - -.ph-info-light::before { - content: "\f061"; -} - -.ph-instagram-logo-light::before { - content: "\f062"; -} - -.ph-intersect-light::before { - content: "\f063"; -} - -.ph-jeep-light::before { - content: "\f064"; -} - -.ph-kanban-light::before { - content: "\f065"; -} - -.ph-key-light::before { - content: "\f066"; -} - -.ph-key-return-light::before { - content: "\f067"; -} - -.ph-keyboard-light::before { - content: "\f068"; -} - -.ph-keyhole-light::before { - content: "\f069"; -} - -.ph-knife-light::before { - content: "\f06a"; -} - -.ph-ladder-light::before { - content: "\f06b"; -} - -.ph-ladder-simple-light::before { - content: "\f06c"; -} - -.ph-lamp-light::before { - content: "\f06d"; -} - -.ph-laptop-light::before { - content: "\f06e"; -} - -.ph-layout-light::before { - content: "\f06f"; -} - -.ph-leaf-light::before { - content: "\f070"; -} - -.ph-lifebuoy-light::before { - content: "\f071"; -} - -.ph-lightbulb-filament-light::before { - content: "\f072"; -} - -.ph-lightbulb-light::before { - content: "\f073"; -} - -.ph-lightning-light::before { - content: "\f074"; -} - -.ph-lightning-slash-light::before { - content: "\f075"; -} - -.ph-line-segment-light::before { - content: "\f076"; -} - -.ph-line-segments-light::before { - content: "\f077"; -} - -.ph-link-break-light::before { - content: "\f078"; -} - -.ph-link-light::before { - content: "\f079"; -} - -.ph-link-simple-break-light::before { - content: "\f07a"; -} - -.ph-link-simple-horizontal-break-light::before { - content: "\f07b"; -} - -.ph-link-simple-horizontal-light::before { - content: "\f07c"; -} - -.ph-link-simple-light::before { - content: "\f07d"; -} - -.ph-linkedin-logo-light::before { - content: "\f07e"; -} - -.ph-linux-logo-light::before { - content: "\f07f"; -} - -.ph-list-bullets-light::before { - content: "\f080"; -} - -.ph-list-checks-light::before { - content: "\f081"; -} - -.ph-list-dashes-light::before { - content: "\f082"; -} - -.ph-list-light::before { - content: "\f083"; -} - -.ph-list-numbers-light::before { - content: "\f084"; -} - -.ph-list-plus-light::before { - content: "\f085"; -} - -.ph-lock-key-light::before { - content: "\f086"; -} - -.ph-lock-key-open-light::before { - content: "\f087"; -} - -.ph-lock-laminated-light::before { - content: "\f088"; -} - -.ph-lock-laminated-open-light::before { - content: "\f089"; -} - -.ph-lock-light::before { - content: "\f08a"; -} - -.ph-lock-open-light::before { - content: "\f08b"; -} - -.ph-lock-simple-light::before { - content: "\f08c"; -} - -.ph-lock-simple-open-light::before { - content: "\f08d"; -} - -.ph-magic-wand-light::before { - content: "\f08e"; -} - -.ph-magnet-light::before { - content: "\f08f"; -} - -.ph-magnet-straight-light::before { - content: "\f090"; -} - -.ph-magnifying-glass-light::before { - content: "\f091"; -} - -.ph-magnifying-glass-minus-light::before { - content: "\f092"; -} - -.ph-magnifying-glass-plus-light::before { - content: "\f093"; -} - -.ph-map-pin-light::before { - content: "\f094"; -} - -.ph-map-pin-line-light::before { - content: "\f095"; -} - -.ph-map-trifold-light::before { - content: "\f096"; -} - -.ph-marker-circle-light::before { - content: "\f097"; -} - -.ph-martini-light::before { - content: "\f098"; -} - -.ph-mask-happy-light::before { - content: "\f099"; -} - -.ph-mask-sad-light::before { - content: "\f09a"; -} - -.ph-math-operations-light::before { - content: "\f09b"; -} - -.ph-medal-light::before { - content: "\f09c"; -} - -.ph-medium-logo-light::before { - content: "\f09d"; -} - -.ph-megaphone-light::before { - content: "\f09e"; -} - -.ph-megaphone-simple-light::before { - content: "\f09f"; -} - -.ph-messenger-logo-light::before { - content: "\f0a0"; -} - -.ph-microphone-light::before { - content: "\f0a1"; -} - -.ph-microphone-slash-light::before { - content: "\f0a2"; -} - -.ph-microphone-stage-light::before { - content: "\f0a3"; -} - -.ph-microsoft-excel-logo-light::before { - content: "\f0a4"; -} - -.ph-microsoft-powerpoint-logo-light::before { - content: "\f0a5"; -} - -.ph-microsoft-teams-logo-light::before { - content: "\f0a6"; -} - -.ph-microsoft-word-logo-light::before { - content: "\f0a7"; -} - -.ph-minus-circle-light::before { - content: "\f0a8"; -} - -.ph-minus-light::before { - content: "\f0a9"; -} - -.ph-money-light::before { - content: "\f0aa"; -} - -.ph-monitor-light::before { - content: "\f0ab"; -} - -.ph-monitor-play-light::before { - content: "\f0ac"; -} - -.ph-moon-light::before { - content: "\f0ad"; -} - -.ph-moon-stars-light::before { - content: "\f0ae"; -} - -.ph-mountains-light::before { - content: "\f0af"; -} - -.ph-mouse-light::before { - content: "\f0b0"; -} - -.ph-mouse-simple-light::before { - content: "\f0b1"; -} - -.ph-music-note-light::before { - content: "\f0b2"; -} - -.ph-music-note-simple-light::before { - content: "\f0b3"; -} - -.ph-music-notes-light::before { - content: "\f0b4"; -} - -.ph-music-notes-plus-light::before { - content: "\f0b5"; -} - -.ph-music-notes-simple-light::before { - content: "\f0b6"; -} - -.ph-navigation-arrow-light::before { - content: "\f0b7"; -} - -.ph-needle-light::before { - content: "\f0b8"; -} - -.ph-newspaper-clipping-light::before { - content: "\f0b9"; -} - -.ph-newspaper-light::before { - content: "\f0ba"; -} - -.ph-note-blank-light::before { - content: "\f0bb"; -} - -.ph-note-light::before { - content: "\f0bc"; -} - -.ph-note-pencil-light::before { - content: "\f0bd"; -} - -.ph-notebook-light::before { - content: "\f0be"; -} - -.ph-notepad-light::before { - content: "\f0bf"; -} - -.ph-notification-light::before { - content: "\f0c0"; -} - -.ph-number-circle-eight-light::before { - content: "\f0c1"; -} - -.ph-number-circle-five-light::before { - content: "\f0c2"; -} - -.ph-number-circle-four-light::before { - content: "\f0c3"; -} - -.ph-number-circle-nine-light::before { - content: "\f0c4"; -} - -.ph-number-circle-one-light::before { - content: "\f0c5"; -} - -.ph-number-circle-seven-light::before { - content: "\f0c6"; -} - -.ph-number-circle-six-light::before { - content: "\f0c7"; -} - -.ph-number-circle-three-light::before { - content: "\f0c8"; -} - -.ph-number-circle-two-light::before { - content: "\f0c9"; -} - -.ph-number-circle-zero-light::before { - content: "\f0ca"; -} - -.ph-number-eight-light::before { - content: "\f0cb"; -} - -.ph-number-five-light::before { - content: "\f0cc"; -} - -.ph-number-four-light::before { - content: "\f0cd"; -} - -.ph-number-nine-light::before { - content: "\f0ce"; -} - -.ph-number-one-light::before { - content: "\f0cf"; -} - -.ph-number-seven-light::before { - content: "\f0d0"; -} - -.ph-number-six-light::before { - content: "\f0d1"; -} - -.ph-number-square-eight-light::before { - content: "\f0d2"; -} - -.ph-number-square-five-light::before { - content: "\f0d3"; -} - -.ph-number-square-four-light::before { - content: "\f0d4"; -} - -.ph-number-square-nine-light::before { - content: "\f0d5"; -} - -.ph-number-square-one-light::before { - content: "\f0d6"; -} - -.ph-number-square-seven-light::before { - content: "\f0d7"; -} - -.ph-number-square-six-light::before { - content: "\f0d8"; -} - -.ph-number-square-three-light::before { - content: "\f0d9"; -} - -.ph-number-square-two-light::before { - content: "\f0da"; -} - -.ph-number-square-zero-light::before { - content: "\f0db"; -} - -.ph-number-three-light::before { - content: "\f0dc"; -} - -.ph-number-two-light::before { - content: "\f0dd"; -} - -.ph-number-zero-light::before { - content: "\f0de"; -} - -.ph-nut-light::before { - content: "\f0df"; -} - -.ph-ny-times-logo-light::before { - content: "\f0e0"; -} - -.ph-octagon-light::before { - content: "\f0e1"; -} - -.ph-option-light::before { - content: "\f0e2"; -} - -.ph-package-light::before { - content: "\f0e3"; -} - -.ph-paint-brush-broad-light::before { - content: "\f0e4"; -} - -.ph-paint-brush-household-light::before { - content: "\f0e5"; -} - -.ph-paint-brush-light::before { - content: "\f0e6"; -} - -.ph-paint-bucket-light::before { - content: "\f0e7"; -} - -.ph-paint-roller-light::before { - content: "\f0e8"; -} - -.ph-palette-light::before { - content: "\f0e9"; -} - -.ph-paper-plane-light::before { - content: "\f0ea"; -} - -.ph-paper-plane-right-light::before { - content: "\f0eb"; -} - -.ph-paper-plane-tilt-light::before { - content: "\f0ec"; -} - -.ph-paperclip-horizontal-light::before { - content: "\f0ed"; -} - -.ph-paperclip-light::before { - content: "\f0ee"; -} - -.ph-parachute-light::before { - content: "\f0ef"; -} - -.ph-password-light::before { - content: "\f0f0"; -} - -.ph-path-light::before { - content: "\f0f1"; -} - -.ph-pause-circle-light::before { - content: "\f0f2"; -} - -.ph-pause-light::before { - content: "\f0f3"; -} - -.ph-paw-print-light::before { - content: "\f0f4"; -} - -.ph-peace-light::before { - content: "\f0f5"; -} - -.ph-pen-light::before { - content: "\f0f6"; -} - -.ph-pen-nib-light::before { - content: "\f0f7"; -} - -.ph-pen-nib-straight-light::before { - content: "\f0f8"; -} - -.ph-pencil-circle-light::before { - content: "\f0f9"; -} - -.ph-pencil-light::before { - content: "\f0fa"; -} - -.ph-pencil-line-light::before { - content: "\f0fb"; -} - -.ph-pencil-simple-light::before { - content: "\f0fc"; -} - -.ph-pencil-simple-line-light::before { - content: "\f0fd"; -} - -.ph-percent-light::before { - content: "\f0fe"; -} - -.ph-person-light::before { - content: "\f0ff"; -} - -.ph-person-simple-light::before { - content: "\f100"; -} - -.ph-person-simple-run-light::before { - content: "\f101"; -} - -.ph-person-simple-walk-light::before { - content: "\f102"; -} - -.ph-perspective-light::before { - content: "\f103"; -} - -.ph-phone-call-light::before { - content: "\f104"; -} - -.ph-phone-disconnect-light::before { - content: "\f105"; -} - -.ph-phone-incoming-light::before { - content: "\f106"; -} - -.ph-phone-light::before { - content: "\f107"; -} - -.ph-phone-outgoing-light::before { - content: "\f108"; -} - -.ph-phone-slash-light::before { - content: "\f109"; -} - -.ph-phone-x-light::before { - content: "\f10a"; -} - -.ph-phosphor-logo-light::before { - content: "\f10b"; -} - -.ph-piano-keys-light::before { - content: "\f10c"; -} - -.ph-picture-in-picture-light::before { - content: "\f10d"; -} - -.ph-pill-light::before { - content: "\f10e"; -} - -.ph-pinterest-logo-light::before { - content: "\f10f"; -} - -.ph-pinwheel-light::before { - content: "\f110"; -} - -.ph-pizza-light::before { - content: "\f111"; -} - -.ph-placeholder-light::before { - content: "\f112"; -} - -.ph-planet-light::before { - content: "\f113"; -} - -.ph-play-circle-light::before { - content: "\f114"; -} - -.ph-play-light::before { - content: "\f115"; -} - -.ph-playlist-light::before { - content: "\f116"; -} - -.ph-plug-light::before { - content: "\f117"; -} - -.ph-plugs-connected-light::before { - content: "\f118"; -} - -.ph-plugs-light::before { - content: "\f119"; -} - -.ph-plus-circle-light::before { - content: "\f11a"; -} - -.ph-plus-light::before { - content: "\f11b"; -} - -.ph-plus-minus-light::before { - content: "\f11c"; -} - -.ph-poker-chip-light::before { - content: "\f11d"; -} - -.ph-police-car-light::before { - content: "\f11e"; -} - -.ph-polygon-light::before { - content: "\f11f"; -} - -.ph-popcorn-light::before { - content: "\f120"; -} - -.ph-power-light::before { - content: "\f121"; -} - -.ph-prescription-light::before { - content: "\f122"; -} - -.ph-presentation-chart-light::before { - content: "\f123"; -} - -.ph-presentation-light::before { - content: "\f124"; -} - -.ph-printer-light::before { - content: "\f125"; -} - -.ph-prohibit-inset-light::before { - content: "\f126"; -} - -.ph-prohibit-light::before { - content: "\f127"; -} - -.ph-projector-screen-chart-light::before { - content: "\f128"; -} - -.ph-projector-screen-light::before { - content: "\f129"; -} - -.ph-push-pin-light::before { - content: "\f12a"; -} - -.ph-push-pin-simple-light::before { - content: "\f12b"; -} - -.ph-push-pin-simple-slash-light::before { - content: "\f12c"; -} - -.ph-push-pin-slash-light::before { - content: "\f12d"; -} - -.ph-puzzle-piece-light::before { - content: "\f12e"; -} - -.ph-qr-code-light::before { - content: "\f12f"; -} - -.ph-question-light::before { - content: "\f130"; -} - -.ph-queue-light::before { - content: "\f131"; -} - -.ph-quotes-light::before { - content: "\f132"; -} - -.ph-radical-light::before { - content: "\f133"; -} - -.ph-radio-button-light::before { - content: "\f134"; -} - -.ph-radio-light::before { - content: "\f135"; -} - -.ph-rainbow-cloud-light::before { - content: "\f136"; -} - -.ph-rainbow-light::before { - content: "\f137"; -} - -.ph-receipt-light::before { - content: "\f138"; -} - -.ph-record-light::before { - content: "\f139"; -} - -.ph-rectangle-light::before { - content: "\f13a"; -} - -.ph-recycle-light::before { - content: "\f13b"; -} - -.ph-reddit-logo-light::before { - content: "\f13c"; -} - -.ph-repeat-light::before { - content: "\f13d"; -} - -.ph-repeat-once-light::before { - content: "\f13e"; -} - -.ph-rewind-circle-light::before { - content: "\f13f"; -} - -.ph-rewind-light::before { - content: "\f140"; -} - -.ph-robot-light::before { - content: "\f141"; -} - -.ph-rocket-launch-light::before { - content: "\f142"; -} - -.ph-rocket-light::before { - content: "\f143"; -} - -.ph-rows-light::before { - content: "\f144"; -} - -.ph-rss-light::before { - content: "\f145"; -} - -.ph-rss-simple-light::before { - content: "\f146"; -} - -.ph-rug-light::before { - content: "\f147"; -} - -.ph-ruler-light::before { - content: "\f148"; -} - -.ph-scales-light::before { - content: "\f149"; -} - -.ph-scan-light::before { - content: "\f14a"; -} - -.ph-scissors-light::before { - content: "\f14b"; -} - -.ph-screencast-light::before { - content: "\f14c"; -} - -.ph-scribble-loop-light::before { - content: "\f14d"; -} - -.ph-scroll-light::before { - content: "\f14e"; -} - -.ph-selection-all-light::before { - content: "\f14f"; -} - -.ph-selection-background-light::before { - content: "\f150"; -} - -.ph-selection-foreground-light::before { - content: "\f151"; -} - -.ph-selection-inverse-light::before { - content: "\f152"; -} - -.ph-selection-light::before { - content: "\f153"; -} - -.ph-selection-plus-light::before { - content: "\f154"; -} - -.ph-selection-slash-light::before { - content: "\f155"; -} - -.ph-share-light::before { - content: "\f156"; -} - -.ph-share-network-light::before { - content: "\f157"; -} - -.ph-shield-check-light::before { - content: "\f158"; -} - -.ph-shield-checkered-light::before { - content: "\f159"; -} - -.ph-shield-chevron-light::before { - content: "\f15a"; -} - -.ph-shield-light::before { - content: "\f15b"; -} - -.ph-shield-plus-light::before { - content: "\f15c"; -} - -.ph-shield-slash-light::before { - content: "\f15d"; -} - -.ph-shield-star-light::before { - content: "\f15e"; -} - -.ph-shield-warning-light::before { - content: "\f15f"; -} - -.ph-shopping-bag-light::before { - content: "\f160"; -} - -.ph-shopping-bag-open-light::before { - content: "\f161"; -} - -.ph-shopping-cart-light::before { - content: "\f162"; -} - -.ph-shopping-cart-simple-light::before { - content: "\f163"; -} - -.ph-shower-light::before { - content: "\f164"; -} - -.ph-shuffle-angular-light::before { - content: "\f165"; -} - -.ph-shuffle-light::before { - content: "\f166"; -} - -.ph-shuffle-simple-light::before { - content: "\f167"; -} - -.ph-sidebar-light::before { - content: "\f168"; -} - -.ph-sidebar-simple-light::before { - content: "\f169"; -} - -.ph-sign-in-light::before { - content: "\f16a"; -} - -.ph-sign-out-light::before { - content: "\f16b"; -} - -.ph-signpost-light::before { - content: "\f16c"; -} - -.ph-sim-card-light::before { - content: "\f16d"; -} - -.ph-sketch-logo-light::before { - content: "\f16e"; -} - -.ph-skip-back-circle-light::before { - content: "\f16f"; -} - -.ph-skip-back-light::before { - content: "\f170"; -} - -.ph-skip-forward-circle-light::before { - content: "\f171"; -} - -.ph-skip-forward-light::before { - content: "\f172"; -} - -.ph-skull-light::before { - content: "\f173"; -} - -.ph-slack-logo-light::before { - content: "\f174"; -} - -.ph-sliders-horizontal-light::before { - content: "\f175"; -} - -.ph-sliders-light::before { - content: "\f176"; -} - -.ph-smiley-blank-light::before { - content: "\f177"; -} - -.ph-smiley-light::before { - content: "\f178"; -} - -.ph-smiley-meh-light::before { - content: "\f179"; -} - -.ph-smiley-nervous-light::before { - content: "\f17a"; -} - -.ph-smiley-sad-light::before { - content: "\f17b"; -} - -.ph-smiley-sticker-light::before { - content: "\f17c"; -} - -.ph-smiley-wink-light::before { - content: "\f17d"; -} - -.ph-smiley-x-eyes-light::before { - content: "\f17e"; -} - -.ph-snapchat-logo-light::before { - content: "\f17f"; -} - -.ph-snowflake-light::before { - content: "\f180"; -} - -.ph-soccer-ball-light::before { - content: "\f181"; -} - -.ph-sort-ascending-light::before { - content: "\f182"; -} - -.ph-sort-descending-light::before { - content: "\f183"; -} - -.ph-spade-light::before { - content: "\f184"; -} - -.ph-sparkle-light::before { - content: "\f185"; -} - -.ph-speaker-high-light::before { - content: "\f186"; -} - -.ph-speaker-low-light::before { - content: "\f187"; -} - -.ph-speaker-none-light::before { - content: "\f188"; -} - -.ph-speaker-simple-high-light::before { - content: "\f189"; -} - -.ph-speaker-simple-low-light::before { - content: "\f18a"; -} - -.ph-speaker-simple-none-light::before { - content: "\f18b"; -} - -.ph-speaker-simple-slash-light::before { - content: "\f18c"; -} - -.ph-speaker-simple-x-light::before { - content: "\f18d"; -} - -.ph-speaker-slash-light::before { - content: "\f18e"; -} - -.ph-speaker-x-light::before { - content: "\f18f"; -} - -.ph-spinner-gap-light::before { - content: "\f190"; -} - -.ph-spinner-light::before { - content: "\f191"; -} - -.ph-spiral-light::before { - content: "\f192"; -} - -.ph-spotify-logo-light::before { - content: "\f193"; -} - -.ph-square-half-bottom-light::before { - content: "\f194"; -} - -.ph-square-half-light::before { - content: "\f195"; -} - -.ph-square-light::before { - content: "\f196"; -} - -.ph-square-logo-light::before { - content: "\f197"; -} - -.ph-squares-four-light::before { - content: "\f198"; -} - -.ph-stack-light::before { - content: "\f199"; -} - -.ph-stack-overflow-logo-light::before { - content: "\f19a"; -} - -.ph-stack-simple-light::before { - content: "\f19b"; -} - -.ph-stamp-light::before { - content: "\f19c"; -} - -.ph-star-four-light::before { - content: "\f19d"; -} - -.ph-star-half-light::before { - content: "\f19e"; -} - -.ph-star-light::before { - content: "\f19f"; -} - -.ph-sticker-light::before { - content: "\f1a0"; -} - -.ph-stop-circle-light::before { - content: "\f1a1"; -} - -.ph-stop-light::before { - content: "\f1a2"; -} - -.ph-storefront-light::before { - content: "\f1a3"; -} - -.ph-strategy-light::before { - content: "\f1a4"; -} - -.ph-stripe-logo-light::before { - content: "\f1a5"; -} - -.ph-student-light::before { - content: "\f1a6"; -} - -.ph-suitcase-light::before { - content: "\f1a7"; -} - -.ph-suitcase-simple-light::before { - content: "\f1a8"; -} - -.ph-sun-dim-light::before { - content: "\f1a9"; -} - -.ph-sun-horizon-light::before { - content: "\f1aa"; -} - -.ph-sun-light::before { - content: "\f1ab"; -} - -.ph-sunglasses-light::before { - content: "\f1ac"; -} - -.ph-swap-light::before { - content: "\f1ad"; -} - -.ph-swatches-light::before { - content: "\f1ae"; -} - -.ph-sword-light::before { - content: "\f1af"; -} - -.ph-syringe-light::before { - content: "\f1b0"; -} - -.ph-t-shirt-light::before { - content: "\f1b1"; -} - -.ph-table-light::before { - content: "\f1b2"; -} - -.ph-tabs-light::before { - content: "\f1b3"; -} - -.ph-tag-chevron-light::before { - content: "\f1b4"; -} - -.ph-tag-light::before { - content: "\f1b5"; -} - -.ph-tag-simple-light::before { - content: "\f1b6"; -} - -.ph-target-light::before { - content: "\f1b7"; -} - -.ph-taxi-light::before { - content: "\f1b8"; -} - -.ph-telegram-logo-light::before { - content: "\f1b9"; -} - -.ph-television-light::before { - content: "\f1ba"; -} - -.ph-television-simple-light::before { - content: "\f1bb"; -} - -.ph-tennis-ball-light::before { - content: "\f1bc"; -} - -.ph-terminal-light::before { - content: "\f1bd"; -} - -.ph-terminal-window-light::before { - content: "\f1be"; -} - -.ph-test-tube-light::before { - content: "\f1bf"; -} - -.ph-text-aa-light::before { - content: "\f1c0"; -} - -.ph-text-align-center-light::before { - content: "\f1c1"; -} - -.ph-text-align-justify-light::before { - content: "\f1c2"; -} - -.ph-text-align-left-light::before { - content: "\f1c3"; -} - -.ph-text-align-right-light::before { - content: "\f1c4"; -} - -.ph-text-bolder-light::before { - content: "\f1c5"; -} - -.ph-text-h-five-light::before { - content: "\f1c6"; -} - -.ph-text-h-four-light::before { - content: "\f1c7"; -} - -.ph-text-h-light::before { - content: "\f1c8"; -} - -.ph-text-h-one-light::before { - content: "\f1c9"; -} - -.ph-text-h-six-light::before { - content: "\f1ca"; -} - -.ph-text-h-three-light::before { - content: "\f1cb"; -} - -.ph-text-h-two-light::before { - content: "\f1cc"; -} - -.ph-text-indent-light::before { - content: "\f1cd"; -} - -.ph-text-italic-light::before { - content: "\f1ce"; -} - -.ph-text-outdent-light::before { - content: "\f1cf"; -} - -.ph-text-strikethrough-light::before { - content: "\f1d0"; -} - -.ph-text-t-light::before { - content: "\f1d1"; -} - -.ph-text-underline-light::before { - content: "\f1d2"; -} - -.ph-textbox-light::before { - content: "\f1d3"; -} - -.ph-thermometer-cold-light::before { - content: "\f1d4"; -} - -.ph-thermometer-hot-light::before { - content: "\f1d5"; -} - -.ph-thermometer-light::before { - content: "\f1d6"; -} - -.ph-thermometer-simple-light::before { - content: "\f1d7"; -} - -.ph-thumbs-down-light::before { - content: "\f1d8"; -} - -.ph-thumbs-up-light::before { - content: "\f1d9"; -} - -.ph-ticket-light::before { - content: "\f1da"; -} - -.ph-tiktok-logo-light::before { - content: "\f1db"; -} - -.ph-timer-light::before { - content: "\f1dc"; -} - -.ph-toggle-left-light::before { - content: "\f1dd"; -} - -.ph-toggle-right-light::before { - content: "\f1de"; -} - -.ph-toilet-light::before { - content: "\f1df"; -} - -.ph-toilet-paper-light::before { - content: "\f1e0"; -} - -.ph-tote-light::before { - content: "\f1e1"; -} - -.ph-tote-simple-light::before { - content: "\f1e2"; -} - -.ph-trademark-registered-light::before { - content: "\f1e3"; -} - -.ph-traffic-cone-light::before { - content: "\f1e4"; -} - -.ph-traffic-sign-light::before { - content: "\f1e5"; -} - -.ph-traffic-signal-light::before { - content: "\f1e6"; -} - -.ph-train-light::before { - content: "\f1e7"; -} - -.ph-train-regional-light::before { - content: "\f1e8"; -} - -.ph-train-simple-light::before { - content: "\f1e9"; -} - -.ph-translate-light::before { - content: "\f1ea"; -} - -.ph-trash-light::before { - content: "\f1eb"; -} - -.ph-trash-simple-light::before { - content: "\f1ec"; -} - -.ph-tray-light::before { - content: "\f1ed"; -} - -.ph-tree-evergreen-light::before { - content: "\f1ee"; -} - -.ph-tree-light::before { - content: "\f1ef"; -} - -.ph-tree-structure-light::before { - content: "\f1f0"; -} - -.ph-trend-down-light::before { - content: "\f1f1"; -} - -.ph-trend-up-light::before { - content: "\f1f2"; -} - -.ph-triangle-light::before { - content: "\f1f3"; -} - -.ph-trophy-light::before { - content: "\f1f4"; -} - -.ph-truck-light::before { - content: "\f1f5"; -} - -.ph-twitch-logo-light::before { - content: "\f1f6"; -} - -.ph-twitter-logo-light::before { - content: "\f1f7"; -} - -.ph-umbrella-light::before { - content: "\f1f8"; -} - -.ph-umbrella-simple-light::before { - content: "\f1f9"; -} - -.ph-upload-light::before { - content: "\f1fa"; -} - -.ph-upload-simple-light::before { - content: "\f1fb"; -} - -.ph-user-circle-gear-light::before { - content: "\f1fc"; -} - -.ph-user-circle-light::before { - content: "\f1fd"; -} - -.ph-user-circle-minus-light::before { - content: "\f1fe"; -} - -.ph-user-circle-plus-light::before { - content: "\f1ff"; -} - -.ph-user-focus-light::before { - content: "\f200"; -} - -.ph-user-gear-light::before { - content: "\f201"; -} - -.ph-user-light::before { - content: "\f202"; -} - -.ph-user-list-light::before { - content: "\f203"; -} - -.ph-user-minus-light::before { - content: "\f204"; -} - -.ph-user-plus-light::before { - content: "\f205"; -} - -.ph-user-rectangle-light::before { - content: "\f206"; -} - -.ph-user-square-light::before { - content: "\f207"; -} - -.ph-user-switch-light::before { - content: "\f208"; -} - -.ph-users-four-light::before { - content: "\f209"; -} - -.ph-users-light::before { - content: "\f20a"; -} - -.ph-users-three-light::before { - content: "\f20b"; -} - -.ph-vault-light::before { - content: "\f20c"; -} - -.ph-vibrate-light::before { - content: "\f20d"; -} - -.ph-video-camera-light::before { - content: "\f20e"; -} - -.ph-video-camera-slash-light::before { - content: "\f20f"; -} - -.ph-vignette-light::before { - content: "\f210"; -} - -.ph-voicemail-light::before { - content: "\f211"; -} - -.ph-volleyball-light::before { - content: "\f212"; -} - -.ph-wall-light::before { - content: "\f213"; -} - -.ph-wallet-light::before { - content: "\f214"; -} - -.ph-warning-circle-light::before { - content: "\f215"; -} - -.ph-warning-light::before { - content: "\f216"; -} - -.ph-warning-octagon-light::before { - content: "\f217"; -} - -.ph-watch-light::before { - content: "\f218"; -} - -.ph-wave-sawtooth-light::before { - content: "\f219"; -} - -.ph-wave-sine-light::before { - content: "\f21a"; -} - -.ph-wave-square-light::before { - content: "\f21b"; -} - -.ph-wave-triangle-light::before { - content: "\f21c"; -} - -.ph-waves-light::before { - content: "\f21d"; -} - -.ph-webcam-light::before { - content: "\f21e"; -} - -.ph-whatsapp-logo-light::before { - content: "\f21f"; -} - -.ph-wheelchair-light::before { - content: "\f220"; -} - -.ph-wifi-high-light::before { - content: "\f221"; -} - -.ph-wifi-low-light::before { - content: "\f222"; -} - -.ph-wifi-medium-light::before { - content: "\f223"; -} - -.ph-wifi-none-light::before { - content: "\f224"; -} - -.ph-wifi-slash-light::before { - content: "\f225"; -} - -.ph-wifi-x-light::before { - content: "\f226"; -} - -.ph-wind-light::before { - content: "\f227"; -} - -.ph-windows-logo-light::before { - content: "\f228"; -} - -.ph-wine-light::before { - content: "\f229"; -} - -.ph-wrench-light::before { - content: "\f22a"; -} - -.ph-x-circle-light::before { - content: "\f22b"; -} - -.ph-x-light::before { - content: "\f22c"; -} - -.ph-x-square-light::before { - content: "\f22d"; -} - -.ph-yin-yang-light::before { - content: "\f22e"; -} - -.ph-youtube-logo-light::before { - content: "\f22f"; -} - -.ph-activity::before { - content: "\f230"; -} - -.ph-address-book::before { - content: "\f231"; -} - -.ph-airplane::before { - content: "\f232"; -} - -.ph-airplane-in-flight::before { - content: "\f233"; -} - -.ph-airplane-landing::before { - content: "\f234"; -} - -.ph-airplane-takeoff::before { - content: "\f235"; -} - -.ph-airplane-tilt::before { - content: "\f236"; -} - -.ph-airplay::before { - content: "\f237"; -} - -.ph-alarm::before { - content: "\f238"; -} - -.ph-alien::before { - content: "\f239"; -} - -.ph-align-bottom::before { - content: "\f23a"; -} - -.ph-align-bottom-simple::before { - content: "\f23b"; -} - -.ph-align-center-horizontal::before { - content: "\f23c"; -} - -.ph-align-center-horizontal-simple::before { - content: "\f23d"; -} - -.ph-align-center-vertical::before { - content: "\f23e"; -} - -.ph-align-center-vertical-simple::before { - content: "\f23f"; -} - -.ph-align-left::before { - content: "\f240"; -} - -.ph-align-left-simple::before { - content: "\f241"; -} - -.ph-align-right::before { - content: "\f242"; -} - -.ph-align-right-simple::before { - content: "\f243"; -} - -.ph-align-top::before { - content: "\f244"; -} - -.ph-align-top-simple::before { - content: "\f245"; -} - -.ph-anchor::before { - content: "\f246"; -} - -.ph-anchor-simple::before { - content: "\f247"; -} - -.ph-android-logo::before { - content: "\f248"; -} - -.ph-angular-logo::before { - content: "\f249"; -} - -.ph-aperture::before { - content: "\f24a"; -} - -.ph-app-store-logo::before { - content: "\f24b"; -} - -.ph-app-window::before { - content: "\f24c"; -} - -.ph-apple-logo::before { - content: "\f24d"; -} - -.ph-apple-podcasts-logo::before { - content: "\f24e"; -} - -.ph-archive::before { - content: "\f24f"; -} - -.ph-archive-box::before { - content: "\f250"; -} - -.ph-archive-tray::before { - content: "\f251"; -} - -.ph-armchair::before { - content: "\f252"; -} - -.ph-arrow-arc-left::before { - content: "\f253"; -} - -.ph-arrow-arc-right::before { - content: "\f254"; -} - -.ph-arrow-bend-double-up-left::before { - content: "\f255"; -} - -.ph-arrow-bend-double-up-right::before { - content: "\f256"; -} - -.ph-arrow-bend-down-left::before { - content: "\f257"; -} - -.ph-arrow-bend-down-right::before { - content: "\f258"; -} - -.ph-arrow-bend-left-down::before { - content: "\f259"; -} - -.ph-arrow-bend-left-up::before { - content: "\f25a"; -} - -.ph-arrow-bend-right-down::before { - content: "\f25b"; -} - -.ph-arrow-bend-right-up::before { - content: "\f25c"; -} - -.ph-arrow-bend-up-left::before { - content: "\f25d"; -} - -.ph-arrow-bend-up-right::before { - content: "\f25e"; -} - -.ph-arrow-circle-down::before { - content: "\f25f"; -} - -.ph-arrow-circle-down-left::before { - content: "\f260"; -} - -.ph-arrow-circle-down-right::before { - content: "\f261"; -} - -.ph-arrow-circle-left::before { - content: "\f262"; -} - -.ph-arrow-circle-right::before { - content: "\f263"; -} - -.ph-arrow-circle-up::before { - content: "\f264"; -} - -.ph-arrow-circle-up-left::before { - content: "\f265"; -} - -.ph-arrow-circle-up-right::before { - content: "\f266"; -} - -.ph-arrow-clockwise::before { - content: "\f267"; -} - -.ph-arrow-counter-clockwise::before { - content: "\f268"; -} - -.ph-arrow-down::before { - content: "\f269"; -} - -.ph-arrow-down-left::before { - content: "\f26a"; -} - -.ph-arrow-down-right::before { - content: "\f26b"; -} - -.ph-arrow-elbow-down-left::before { - content: "\f26c"; -} - -.ph-arrow-elbow-down-right::before { - content: "\f26d"; -} - -.ph-arrow-elbow-left::before { - content: "\f26e"; -} - -.ph-arrow-elbow-left-down::before { - content: "\f26f"; -} - -.ph-arrow-elbow-left-up::before { - content: "\f270"; -} - -.ph-arrow-elbow-right::before { - content: "\f271"; -} - -.ph-arrow-elbow-right-down::before { - content: "\f272"; -} - -.ph-arrow-elbow-right-up::before { - content: "\f273"; -} - -.ph-arrow-elbow-up-left::before { - content: "\f274"; -} - -.ph-arrow-elbow-up-right::before { - content: "\f275"; -} - -.ph-arrow-fat-down::before { - content: "\f276"; -} - -.ph-arrow-fat-left::before { - content: "\f277"; -} - -.ph-arrow-fat-line-down::before { - content: "\f278"; -} - -.ph-arrow-fat-line-left::before { - content: "\f279"; -} - -.ph-arrow-fat-line-right::before { - content: "\f27a"; -} - -.ph-arrow-fat-line-up::before { - content: "\f27b"; -} - -.ph-arrow-fat-lines-down::before { - content: "\f27c"; -} - -.ph-arrow-fat-lines-left::before { - content: "\f27d"; -} - -.ph-arrow-fat-lines-right::before { - content: "\f27e"; -} - -.ph-arrow-fat-lines-up::before { - content: "\f27f"; -} - -.ph-arrow-fat-right::before { - content: "\f280"; -} - -.ph-arrow-fat-up::before { - content: "\f281"; -} - -.ph-arrow-left::before { - content: "\f282"; -} - -.ph-arrow-line-down::before { - content: "\f283"; -} - -.ph-arrow-line-down-left::before { - content: "\f284"; -} - -.ph-arrow-line-down-right::before { - content: "\f285"; -} - -.ph-arrow-line-left::before { - content: "\f286"; -} - -.ph-arrow-line-right::before { - content: "\f287"; -} - -.ph-arrow-line-up::before { - content: "\f288"; -} - -.ph-arrow-line-up-left::before { - content: "\f289"; -} - -.ph-arrow-line-up-right::before { - content: "\f28a"; -} - -.ph-arrow-right::before { - content: "\f28b"; -} - -.ph-arrow-square-down::before { - content: "\f28c"; -} - -.ph-arrow-square-down-left::before { - content: "\f28d"; -} - -.ph-arrow-square-down-right::before { - content: "\f28e"; -} - -.ph-arrow-square-in::before { - content: "\f28f"; -} - -.ph-arrow-square-left::before { - content: "\f290"; -} - -.ph-arrow-square-out::before { - content: "\f291"; -} - -.ph-arrow-square-right::before { - content: "\f292"; -} - -.ph-arrow-square-up::before { - content: "\f293"; -} - -.ph-arrow-square-up-left::before { - content: "\f294"; -} - -.ph-arrow-square-up-right::before { - content: "\f295"; -} - -.ph-arrow-u-down-left::before { - content: "\f296"; -} - -.ph-arrow-u-down-right::before { - content: "\f297"; -} - -.ph-arrow-u-left-down::before { - content: "\f298"; -} - -.ph-arrow-u-left-up::before { - content: "\f299"; -} - -.ph-arrow-u-right-down::before { - content: "\f29a"; -} - -.ph-arrow-u-right-up::before { - content: "\f29b"; -} - -.ph-arrow-u-up-left::before { - content: "\f29c"; -} - -.ph-arrow-u-up-right::before { - content: "\f29d"; -} - -.ph-arrow-up::before { - content: "\f29e"; -} - -.ph-arrow-up-left::before { - content: "\f29f"; -} - -.ph-arrow-up-right::before { - content: "\f2a0"; -} - -.ph-arrows-clockwise::before { - content: "\f2a1"; -} - -.ph-arrows-counter-clockwise::before { - content: "\f2a2"; -} - -.ph-arrows-down-up::before { - content: "\f2a3"; -} - -.ph-arrows-horizontal::before { - content: "\f2a4"; -} - -.ph-arrows-in::before { - content: "\f2a5"; -} - -.ph-arrows-in-cardinal::before { - content: "\f2a6"; -} - -.ph-arrows-in-line-horizontal::before { - content: "\f2a7"; -} - -.ph-arrows-in-line-vertical::before { - content: "\f2a8"; -} - -.ph-arrows-in-simple::before { - content: "\f2a9"; -} - -.ph-arrows-left-right::before { - content: "\f2aa"; -} - -.ph-arrows-out::before { - content: "\f2ab"; -} - -.ph-arrows-out-cardinal::before { - content: "\f2ac"; -} - -.ph-arrows-out-line-horizontal::before { - content: "\f2ad"; -} - -.ph-arrows-out-line-vertical::before { - content: "\f2ae"; -} - -.ph-arrows-out-simple::before { - content: "\f2af"; -} - -.ph-arrows-vertical::before { - content: "\f2b0"; -} - -.ph-article::before { - content: "\f2b1"; -} - -.ph-article-medium::before { - content: "\f2b2"; -} - -.ph-article-ny-times::before { - content: "\f2b3"; -} - -.ph-asterisk::before { - content: "\f2b4"; -} - -.ph-asterisk-simple::before { - content: "\f2b5"; -} - -.ph-at::before { - content: "\f2b6"; -} - -.ph-atom::before { - content: "\f2b7"; -} - -.ph-baby::before { - content: "\f2b8"; -} - -.ph-backpack::before { - content: "\f2b9"; -} - -.ph-backspace::before { - content: "\f2ba"; -} - -.ph-bag::before { - content: "\f2bb"; -} - -.ph-bag-simple::before { - content: "\f2bc"; -} - -.ph-balloon::before { - content: "\f2bd"; -} - -.ph-bandaids::before { - content: "\f2be"; -} - -.ph-bank::before { - content: "\f2bf"; -} - -.ph-barbell::before { - content: "\f2c0"; -} - -.ph-barcode::before { - content: "\f2c1"; -} - -.ph-barricade::before { - content: "\f2c2"; -} - -.ph-baseball::before { - content: "\f2c3"; -} - -.ph-basketball::before { - content: "\f2c4"; -} - -.ph-bathtub::before { - content: "\f2c5"; -} - -.ph-battery-charging::before { - content: "\f2c6"; -} - -.ph-battery-charging-vertical::before { - content: "\f2c7"; -} - -.ph-battery-empty::before { - content: "\f2c8"; -} - -.ph-battery-full::before { - content: "\f2c9"; -} - -.ph-battery-high::before { - content: "\f2ca"; -} - -.ph-battery-low::before { - content: "\f2cb"; -} - -.ph-battery-medium::before { - content: "\f2cc"; -} - -.ph-battery-plus::before { - content: "\f2cd"; -} - -.ph-battery-warning::before { - content: "\f2ce"; -} - -.ph-battery-warning-vertical::before { - content: "\f2cf"; -} - -.ph-bed::before { - content: "\f2d0"; -} - -.ph-beer-bottle::before { - content: "\f2d1"; -} - -.ph-behance-logo::before { - content: "\f2d2"; -} - -.ph-bell::before { - content: "\f2d3"; -} - -.ph-bell-ringing::before { - content: "\f2d4"; -} - -.ph-bell-simple::before { - content: "\f2d5"; -} - -.ph-bell-simple-ringing::before { - content: "\f2d6"; -} - -.ph-bell-simple-slash::before { - content: "\f2d7"; -} - -.ph-bell-simple-z::before { - content: "\f2d8"; -} - -.ph-bell-slash::before { - content: "\f2d9"; -} - -.ph-bell-z::before { - content: "\f2da"; -} - -.ph-bezier-curve::before { - content: "\f2db"; -} - -.ph-bicycle::before { - content: "\f2dc"; -} - -.ph-binoculars::before { - content: "\f2dd"; -} - -.ph-bird::before { - content: "\f2de"; -} - -.ph-bluetooth::before { - content: "\f2df"; -} - -.ph-bluetooth-connected::before { - content: "\f2e0"; -} - -.ph-bluetooth-slash::before { - content: "\f2e1"; -} - -.ph-bluetooth-x::before { - content: "\f2e2"; -} - -.ph-boat::before { - content: "\f2e3"; -} - -.ph-book::before { - content: "\f2e4"; -} - -.ph-book-bookmark::before { - content: "\f2e5"; -} - -.ph-book-open::before { - content: "\f2e6"; -} - -.ph-bookmark::before { - content: "\f2e7"; -} - -.ph-bookmark-simple::before { - content: "\f2e8"; -} - -.ph-bookmarks::before { - content: "\f2e9"; -} - -.ph-bookmarks-simple::before { - content: "\f2ea"; -} - -.ph-books::before { - content: "\f2eb"; -} - -.ph-bounding-box::before { - content: "\f2ec"; -} - -.ph-brackets-angle::before { - content: "\f2ed"; -} - -.ph-brackets-curly::before { - content: "\f2ee"; -} - -.ph-brackets-round::before { - content: "\f2ef"; -} - -.ph-brackets-square::before { - content: "\f2f0"; -} - -.ph-brain::before { - content: "\f2f1"; -} - -.ph-brandy::before { - content: "\f2f2"; -} - -.ph-briefcase::before { - content: "\f2f3"; -} - -.ph-briefcase-metal::before { - content: "\f2f4"; -} - -.ph-broadcast::before { - content: "\f2f5"; -} - -.ph-browser::before { - content: "\f2f6"; -} - -.ph-browsers::before { - content: "\f2f7"; -} - -.ph-bug::before { - content: "\f2f8"; -} - -.ph-bug-beetle::before { - content: "\f2f9"; -} - -.ph-bug-droid::before { - content: "\f2fa"; -} - -.ph-buildings::before { - content: "\f2fb"; -} - -.ph-bus::before { - content: "\f2fc"; -} - -.ph-butterfly::before { - content: "\f2fd"; -} - -.ph-cactus::before { - content: "\f2fe"; -} - -.ph-cake::before { - content: "\f2ff"; -} - -.ph-calculator::before { - content: "\f300"; -} - -.ph-calendar::before { - content: "\f301"; -} - -.ph-calendar-blank::before { - content: "\f302"; -} - -.ph-calendar-check::before { - content: "\f303"; -} - -.ph-calendar-plus::before { - content: "\f304"; -} - -.ph-calendar-x::before { - content: "\f305"; -} - -.ph-camera::before { - content: "\f306"; -} - -.ph-camera-rotate::before { - content: "\f307"; -} - -.ph-camera-slash::before { - content: "\f308"; -} - -.ph-campfire::before { - content: "\f309"; -} - -.ph-car::before { - content: "\f30a"; -} - -.ph-car-simple::before { - content: "\f30b"; -} - -.ph-cardholder::before { - content: "\f30c"; -} - -.ph-cards::before { - content: "\f30d"; -} - -.ph-caret-circle-double-down::before { - content: "\f30e"; -} - -.ph-caret-circle-double-left::before { - content: "\f30f"; -} - -.ph-caret-circle-double-right::before { - content: "\f310"; -} - -.ph-caret-circle-double-up::before { - content: "\f311"; -} - -.ph-caret-circle-down::before { - content: "\f312"; -} - -.ph-caret-circle-left::before { - content: "\f313"; -} - -.ph-caret-circle-right::before { - content: "\f314"; -} - -.ph-caret-circle-up::before { - content: "\f315"; -} - -.ph-caret-double-down::before { - content: "\f316"; -} - -.ph-caret-double-left::before { - content: "\f317"; -} - -.ph-caret-double-right::before { - content: "\f318"; -} - -.ph-caret-double-up::before { - content: "\f319"; -} - -.ph-caret-down::before { - content: "\f31a"; -} - -.ph-caret-left::before { - content: "\f31b"; -} - -.ph-caret-right::before { - content: "\f31c"; -} - -.ph-caret-up::before { - content: "\f31d"; -} - -.ph-cat::before { - content: "\f31e"; -} - -.ph-cell-signal-full::before { - content: "\f31f"; -} - -.ph-cell-signal-high::before { - content: "\f320"; -} - -.ph-cell-signal-low::before { - content: "\f321"; -} - -.ph-cell-signal-medium::before { - content: "\f322"; -} - -.ph-cell-signal-none::before { - content: "\f323"; -} - -.ph-cell-signal-slash::before { - content: "\f324"; -} - -.ph-cell-signal-x::before { - content: "\f325"; -} - -.ph-chalkboard::before { - content: "\f326"; -} - -.ph-chalkboard-simple::before { - content: "\f327"; -} - -.ph-chalkboard-teacher::before { - content: "\f328"; -} - -.ph-chart-bar::before { - content: "\f329"; -} - -.ph-chart-bar-horizontal::before { - content: "\f32a"; -} - -.ph-chart-line::before { - content: "\f32b"; -} - -.ph-chart-line-up::before { - content: "\f32c"; -} - -.ph-chart-pie::before { - content: "\f32d"; -} - -.ph-chart-pie-slice::before { - content: "\f32e"; -} - -.ph-chat::before { - content: "\f32f"; -} - -.ph-chat-centered::before { - content: "\f330"; -} - -.ph-chat-centered-dots::before { - content: "\f331"; -} - -.ph-chat-centered-text::before { - content: "\f332"; -} - -.ph-chat-circle::before { - content: "\f333"; -} - -.ph-chat-circle-dots::before { - content: "\f334"; -} - -.ph-chat-circle-text::before { - content: "\f335"; -} - -.ph-chat-dots::before { - content: "\f336"; -} - -.ph-chat-teardrop::before { - content: "\f337"; -} - -.ph-chat-teardrop-dots::before { - content: "\f338"; -} - -.ph-chat-teardrop-text::before { - content: "\f339"; -} - -.ph-chat-text::before { - content: "\f33a"; -} - -.ph-chats::before { - content: "\f33b"; -} - -.ph-chats-circle::before { - content: "\f33c"; -} - -.ph-chats-teardrop::before { - content: "\f33d"; -} - -.ph-check::before { - content: "\f33e"; -} - -.ph-check-circle::before { - content: "\f33f"; -} - -.ph-check-square::before { - content: "\f340"; -} - -.ph-check-square-offset::before { - content: "\f341"; -} - -.ph-checks::before { - content: "\f342"; -} - -.ph-circle::before { - content: "\f343"; -} - -.ph-circle-dashed::before { - content: "\f344"; -} - -.ph-circle-half::before { - content: "\f345"; -} - -.ph-circle-half-tilt::before { - content: "\f346"; -} - -.ph-circle-notch::before { - content: "\f347"; -} - -.ph-circle-wavy::before { - content: "\f348"; -} - -.ph-circle-wavy-check::before { - content: "\f349"; -} - -.ph-circle-wavy-question::before { - content: "\f34a"; -} - -.ph-circle-wavy-warning::before { - content: "\f34b"; -} - -.ph-circles-four::before { - content: "\f34c"; -} - -.ph-circles-three::before { - content: "\f34d"; -} - -.ph-circles-three-plus::before { - content: "\f34e"; -} - -.ph-clipboard::before { - content: "\f34f"; -} - -.ph-clipboard-text::before { - content: "\f350"; -} - -.ph-clock::before { - content: "\f351"; -} - -.ph-clock-afternoon::before { - content: "\f352"; -} - -.ph-clock-clockwise::before { - content: "\f353"; -} - -.ph-clock-counter-clockwise::before { - content: "\f354"; -} - -.ph-closed-captioning::before { - content: "\f355"; -} - -.ph-cloud::before { - content: "\f356"; -} - -.ph-cloud-arrow-down::before { - content: "\f357"; -} - -.ph-cloud-arrow-up::before { - content: "\f358"; -} - -.ph-cloud-check::before { - content: "\f359"; -} - -.ph-cloud-fog::before { - content: "\f35a"; -} - -.ph-cloud-lightning::before { - content: "\f35b"; -} - -.ph-cloud-moon::before { - content: "\f35c"; -} - -.ph-cloud-rain::before { - content: "\f35d"; -} - -.ph-cloud-slash::before { - content: "\f35e"; -} - -.ph-cloud-snow::before { - content: "\f35f"; -} - -.ph-cloud-sun::before { - content: "\f360"; -} - -.ph-club::before { - content: "\f361"; -} - -.ph-coat-hanger::before { - content: "\f362"; -} - -.ph-code::before { - content: "\f363"; -} - -.ph-code-simple::before { - content: "\f364"; -} - -.ph-codepen-logo::before { - content: "\f365"; -} - -.ph-codesandbox-logo::before { - content: "\f366"; -} - -.ph-coffee::before { - content: "\f367"; -} - -.ph-coin::before { - content: "\f368"; -} - -.ph-coin-vertical::before { - content: "\f369"; -} - -.ph-coins::before { - content: "\f36a"; -} - -.ph-columns::before { - content: "\f36b"; -} - -.ph-command::before { - content: "\f36c"; -} - -.ph-compass::before { - content: "\f36d"; -} - -.ph-computer-tower::before { - content: "\f36e"; -} - -.ph-confetti::before { - content: "\f36f"; -} - -.ph-cookie::before { - content: "\f370"; -} - -.ph-cooking-pot::before { - content: "\f371"; -} - -.ph-copy::before { - content: "\f372"; -} - -.ph-copy-simple::before { - content: "\f373"; -} - -.ph-copyleft::before { - content: "\f374"; -} - -.ph-copyright::before { - content: "\f375"; -} - -.ph-corners-in::before { - content: "\f376"; -} - -.ph-corners-out::before { - content: "\f377"; -} - -.ph-cpu::before { - content: "\f378"; -} - -.ph-credit-card::before { - content: "\f379"; -} - -.ph-crop::before { - content: "\f37a"; -} - -.ph-crosshair::before { - content: "\f37b"; -} - -.ph-crosshair-simple::before { - content: "\f37c"; -} - -.ph-crown::before { - content: "\f37d"; -} - -.ph-crown-simple::before { - content: "\f37e"; -} - -.ph-cube::before { - content: "\f37f"; -} - -.ph-currency-btc::before { - content: "\f380"; -} - -.ph-currency-circle-dollar::before { - content: "\f381"; -} - -.ph-currency-cny::before { - content: "\f382"; -} - -.ph-currency-dollar::before { - content: "\f383"; -} - -.ph-currency-dollar-simple::before { - content: "\f384"; -} - -.ph-currency-eth::before { - content: "\f385"; -} - -.ph-currency-eur::before { - content: "\f386"; -} - -.ph-currency-gbp::before { - content: "\f387"; -} - -.ph-currency-inr::before { - content: "\f388"; -} - -.ph-currency-jpy::before { - content: "\f389"; -} - -.ph-currency-krw::before { - content: "\f38a"; -} - -.ph-currency-kzt::before { - content: "\f38b"; -} - -.ph-currency-ngn::before { - content: "\f38c"; -} - -.ph-currency-rub::before { - content: "\f38d"; -} - -.ph-cursor::before { - content: "\f38e"; -} - -.ph-cursor-text::before { - content: "\f38f"; -} - -.ph-cylinder::before { - content: "\f390"; -} - -.ph-database::before { - content: "\f391"; -} - -.ph-desktop::before { - content: "\f392"; -} - -.ph-desktop-tower::before { - content: "\f393"; -} - -.ph-detective::before { - content: "\f394"; -} - -.ph-device-mobile::before { - content: "\f395"; -} - -.ph-device-mobile-camera::before { - content: "\f396"; -} - -.ph-device-mobile-speaker::before { - content: "\f397"; -} - -.ph-device-tablet::before { - content: "\f398"; -} - -.ph-device-tablet-camera::before { - content: "\f399"; -} - -.ph-device-tablet-speaker::before { - content: "\f39a"; -} - -.ph-diamond::before { - content: "\f39b"; -} - -.ph-diamonds-four::before { - content: "\f39c"; -} - -.ph-dice-five::before { - content: "\f39d"; -} - -.ph-dice-four::before { - content: "\f39e"; -} - -.ph-dice-one::before { - content: "\f39f"; -} - -.ph-dice-six::before { - content: "\f3a0"; -} - -.ph-dice-three::before { - content: "\f3a1"; -} - -.ph-dice-two::before { - content: "\f3a2"; -} - -.ph-disc::before { - content: "\f3a3"; -} - -.ph-discord-logo::before { - content: "\f3a4"; -} - -.ph-divide::before { - content: "\f3a5"; -} - -.ph-dog::before { - content: "\f3a6"; -} - -.ph-door::before { - content: "\f3a7"; -} - -.ph-dots-nine::before { - content: "\f3a8"; -} - -.ph-dots-six::before { - content: "\f3a9"; -} - -.ph-dots-six-vertical::before { - content: "\f3aa"; -} - -.ph-dots-three::before { - content: "\f3ab"; -} - -.ph-dots-three-circle::before { - content: "\f3ac"; -} - -.ph-dots-three-circle-vertical::before { - content: "\f3ad"; -} - -.ph-dots-three-outline::before { - content: "\f3ae"; -} - -.ph-dots-three-outline-vertical::before { - content: "\f3af"; -} - -.ph-dots-three-vertical::before { - content: "\f3b0"; -} - -.ph-download::before { - content: "\f3b1"; -} - -.ph-download-simple::before { - content: "\f3b2"; -} - -.ph-dribbble-logo::before { - content: "\f3b3"; -} - -.ph-drop::before { - content: "\f3b4"; -} - -.ph-drop-half::before { - content: "\f3b5"; -} - -.ph-drop-half-bottom::before { - content: "\f3b6"; -} - -.ph-ear::before { - content: "\f3b7"; -} - -.ph-ear-slash::before { - content: "\f3b8"; -} - -.ph-egg::before { - content: "\f3b9"; -} - -.ph-egg-crack::before { - content: "\f3ba"; -} - -.ph-eject::before { - content: "\f3bb"; -} - -.ph-eject-simple::before { - content: "\f3bc"; -} - -.ph-envelope::before { - content: "\f3bd"; -} - -.ph-envelope-open::before { - content: "\f3be"; -} - -.ph-envelope-simple::before { - content: "\f3bf"; -} - -.ph-envelope-simple-open::before { - content: "\f3c0"; -} - -.ph-equalizer::before { - content: "\f3c1"; -} - -.ph-equals::before { - content: "\f3c2"; -} - -.ph-eraser::before { - content: "\f3c3"; -} - -.ph-exam::before { - content: "\f3c4"; -} - -.ph-export::before { - content: "\f3c5"; -} - -.ph-eye::before { - content: "\f3c6"; -} - -.ph-eye-closed::before { - content: "\f3c7"; -} - -.ph-eye-slash::before { - content: "\f3c8"; -} - -.ph-eyedropper::before { - content: "\f3c9"; -} - -.ph-eyedropper-sample::before { - content: "\f3ca"; -} - -.ph-eyeglasses::before { - content: "\f3cb"; -} - -.ph-face-mask::before { - content: "\f3cc"; -} - -.ph-facebook-logo::before { - content: "\f3cd"; -} - -.ph-factory::before { - content: "\f3ce"; -} - -.ph-faders::before { - content: "\f3cf"; -} - -.ph-faders-horizontal::before { - content: "\f3d0"; -} - -.ph-fast-forward::before { - content: "\f3d1"; -} - -.ph-fast-forward-circle::before { - content: "\f3d2"; -} - -.ph-figma-logo::before { - content: "\f3d3"; -} - -.ph-file::before { - content: "\f3d4"; -} - -.ph-file-arrow-down::before { - content: "\f3d5"; -} - -.ph-file-arrow-up::before { - content: "\f3d6"; -} - -.ph-file-audio::before { - content: "\f3d7"; -} - -.ph-file-cloud::before { - content: "\f3d8"; -} - -.ph-file-code::before { - content: "\f3d9"; -} - -.ph-file-css::before { - content: "\f3da"; -} - -.ph-file-csv::before { - content: "\f3db"; -} - -.ph-file-doc::before { - content: "\f3dc"; -} - -.ph-file-dotted::before { - content: "\f3dd"; -} - -.ph-file-html::before { - content: "\f3de"; -} - -.ph-file-image::before { - content: "\f3df"; -} - -.ph-file-jpg::before { - content: "\f3e0"; -} - -.ph-file-js::before { - content: "\f3e1"; -} - -.ph-file-jsx::before { - content: "\f3e2"; -} - -.ph-file-lock::before { - content: "\f3e3"; -} - -.ph-file-minus::before { - content: "\f3e4"; -} - -.ph-file-pdf::before { - content: "\f3e5"; -} - -.ph-file-plus::before { - content: "\f3e6"; -} - -.ph-file-png::before { - content: "\f3e7"; -} - -.ph-file-ppt::before { - content: "\f3e8"; -} - -.ph-file-rs::before { - content: "\f3e9"; -} - -.ph-file-search::before { - content: "\f3ea"; -} - -.ph-file-text::before { - content: "\f3eb"; -} - -.ph-file-ts::before { - content: "\f3ec"; -} - -.ph-file-tsx::before { - content: "\f3ed"; -} - -.ph-file-video::before { - content: "\f3ee"; -} - -.ph-file-vue::before { - content: "\f3ef"; -} - -.ph-file-x::before { - content: "\f3f0"; -} - -.ph-file-xls::before { - content: "\f3f1"; -} - -.ph-file-zip::before { - content: "\f3f2"; -} - -.ph-files::before { - content: "\f3f3"; -} - -.ph-film-script::before { - content: "\f3f4"; -} - -.ph-film-slate::before { - content: "\f3f5"; -} - -.ph-film-strip::before { - content: "\f3f6"; -} - -.ph-fingerprint::before { - content: "\f3f7"; -} - -.ph-fingerprint-simple::before { - content: "\f3f8"; -} - -.ph-finn-the-human::before { - content: "\f3f9"; -} - -.ph-fire::before { - content: "\f3fa"; -} - -.ph-fire-simple::before { - content: "\f3fb"; -} - -.ph-first-aid::before { - content: "\f3fc"; -} - -.ph-first-aid-kit::before { - content: "\f3fd"; -} - -.ph-fish::before { - content: "\f3fe"; -} - -.ph-fish-simple::before { - content: "\f3ff"; -} - -.ph-flag::before { - content: "\f400"; -} - -.ph-flag-banner::before { - content: "\f401"; -} - -.ph-flag-checkered::before { - content: "\f402"; -} - -.ph-flame::before { - content: "\f403"; -} - -.ph-flashlight::before { - content: "\f404"; -} - -.ph-flask::before { - content: "\f405"; -} - -.ph-floppy-disk::before { - content: "\f406"; -} - -.ph-floppy-disk-back::before { - content: "\f407"; -} - -.ph-flow-arrow::before { - content: "\f408"; -} - -.ph-flower::before { - content: "\f409"; -} - -.ph-flower-lotus::before { - content: "\f40a"; -} - -.ph-flying-saucer::before { - content: "\f40b"; -} - -.ph-folder::before { - content: "\f40c"; -} - -.ph-folder-dotted::before { - content: "\f40d"; -} - -.ph-folder-lock::before { - content: "\f40e"; -} - -.ph-folder-minus::before { - content: "\f40f"; -} - -.ph-folder-notch::before { - content: "\f410"; -} - -.ph-folder-notch-minus::before { - content: "\f411"; -} - -.ph-folder-notch-open::before { - content: "\f412"; -} - -.ph-folder-notch-plus::before { - content: "\f413"; -} - -.ph-folder-open::before { - content: "\f414"; -} - -.ph-folder-plus::before { - content: "\f415"; -} - -.ph-folder-simple::before { - content: "\f416"; -} - -.ph-folder-simple-dotted::before { - content: "\f417"; -} - -.ph-folder-simple-lock::before { - content: "\f418"; -} - -.ph-folder-simple-minus::before { - content: "\f419"; -} - -.ph-folder-simple-plus::before { - content: "\f41a"; -} - -.ph-folder-simple-star::before { - content: "\f41b"; -} - -.ph-folder-simple-user::before { - content: "\f41c"; -} - -.ph-folder-star::before { - content: "\f41d"; -} - -.ph-folder-user::before { - content: "\f41e"; -} - -.ph-folders::before { - content: "\f41f"; -} - -.ph-football::before { - content: "\f420"; -} - -.ph-fork-knife::before { - content: "\f421"; -} - -.ph-frame-corners::before { - content: "\f422"; -} - -.ph-framer-logo::before { - content: "\f423"; -} - -.ph-function::before { - content: "\f424"; -} - -.ph-funnel::before { - content: "\f425"; -} - -.ph-funnel-simple::before { - content: "\f426"; -} - -.ph-game-controller::before { - content: "\f427"; -} - -.ph-gas-pump::before { - content: "\f428"; -} - -.ph-gauge::before { - content: "\f429"; -} - -.ph-gear::before { - content: "\f42a"; -} - -.ph-gear-six::before { - content: "\f42b"; -} - -.ph-gender-female::before { - content: "\f42c"; -} - -.ph-gender-intersex::before { - content: "\f42d"; -} - -.ph-gender-male::before { - content: "\f42e"; -} - -.ph-gender-neuter::before { - content: "\f42f"; -} - -.ph-gender-nonbinary::before { - content: "\f430"; -} - -.ph-gender-transgender::before { - content: "\f431"; -} - -.ph-ghost::before { - content: "\f432"; -} - -.ph-gif::before { - content: "\f433"; -} - -.ph-gift::before { - content: "\f434"; -} - -.ph-git-branch::before { - content: "\f435"; -} - -.ph-git-commit::before { - content: "\f436"; -} - -.ph-git-diff::before { - content: "\f437"; -} - -.ph-git-fork::before { - content: "\f438"; -} - -.ph-git-merge::before { - content: "\f439"; -} - -.ph-git-pull-request::before { - content: "\f43a"; -} - -.ph-github-logo::before { - content: "\f43b"; -} - -.ph-gitlab-logo::before { - content: "\f43c"; -} - -.ph-gitlab-logo-simple::before { - content: "\f43d"; -} - -.ph-globe::before { - content: "\f43e"; -} - -.ph-globe-hemisphere-east::before { - content: "\f43f"; -} - -.ph-globe-hemisphere-west::before { - content: "\f440"; -} - -.ph-globe-simple::before { - content: "\f441"; -} - -.ph-globe-stand::before { - content: "\f442"; -} - -.ph-google-chrome-logo::before { - content: "\f443"; -} - -.ph-google-logo::before { - content: "\f444"; -} - -.ph-google-photos-logo::before { - content: "\f445"; -} - -.ph-google-play-logo::before { - content: "\f446"; -} - -.ph-google-podcasts-logo::before { - content: "\f447"; -} - -.ph-gradient::before { - content: "\f448"; -} - -.ph-graduation-cap::before { - content: "\f449"; -} - -.ph-graph::before { - content: "\f44a"; -} - -.ph-grid-four::before { - content: "\f44b"; -} - -.ph-hamburger::before { - content: "\f44c"; -} - -.ph-hand::before { - content: "\f44d"; -} - -.ph-hand-eye::before { - content: "\f44e"; -} - -.ph-hand-fist::before { - content: "\f44f"; -} - -.ph-hand-grabbing::before { - content: "\f450"; -} - -.ph-hand-palm::before { - content: "\f451"; -} - -.ph-hand-pointing::before { - content: "\f452"; -} - -.ph-hand-soap::before { - content: "\f453"; -} - -.ph-hand-waving::before { - content: "\f454"; -} - -.ph-handbag::before { - content: "\f455"; -} - -.ph-handbag-simple::before { - content: "\f456"; -} - -.ph-hands-clapping::before { - content: "\f457"; -} - -.ph-handshake::before { - content: "\f458"; -} - -.ph-hard-drive::before { - content: "\f459"; -} - -.ph-hard-drives::before { - content: "\f45a"; -} - -.ph-hash::before { - content: "\f45b"; -} - -.ph-hash-straight::before { - content: "\f45c"; -} - -.ph-headlights::before { - content: "\f45d"; -} - -.ph-headphones::before { - content: "\f45e"; -} - -.ph-headset::before { - content: "\f45f"; -} - -.ph-heart::before { - content: "\f460"; -} - -.ph-heart-break::before { - content: "\f461"; -} - -.ph-heart-straight::before { - content: "\f462"; -} - -.ph-heart-straight-break::before { - content: "\f463"; -} - -.ph-heartbeat::before { - content: "\f464"; -} - -.ph-hexagon::before { - content: "\f465"; -} - -.ph-highlighter-circle::before { - content: "\f466"; -} - -.ph-horse::before { - content: "\f467"; -} - -.ph-hourglass::before { - content: "\f468"; -} - -.ph-hourglass-high::before { - content: "\f469"; -} - -.ph-hourglass-low::before { - content: "\f46a"; -} - -.ph-hourglass-medium::before { - content: "\f46b"; -} - -.ph-hourglass-simple::before { - content: "\f46c"; -} - -.ph-hourglass-simple-high::before { - content: "\f46d"; -} - -.ph-hourglass-simple-low::before { - content: "\f46e"; -} - -.ph-hourglass-simple-medium::before { - content: "\f46f"; -} - -.ph-house::before { - content: "\f470"; -} - -.ph-house-line::before { - content: "\f471"; -} - -.ph-house-simple::before { - content: "\f472"; -} - -.ph-identification-badge::before { - content: "\f473"; -} - -.ph-identification-card::before { - content: "\f474"; -} - -.ph-image::before { - content: "\f475"; -} - -.ph-image-square::before { - content: "\f476"; -} - -.ph-infinity::before { - content: "\f477"; -} - -.ph-info::before { - content: "\f478"; -} - -.ph-instagram-logo::before { - content: "\f479"; -} - -.ph-intersect::before { - content: "\f47a"; -} - -.ph-jeep::before { - content: "\f47b"; -} - -.ph-kanban::before { - content: "\f47c"; -} - -.ph-key::before { - content: "\f47d"; -} - -.ph-key-return::before { - content: "\f47e"; -} - -.ph-keyboard::before { - content: "\f47f"; -} - -.ph-keyhole::before { - content: "\f480"; -} - -.ph-knife::before { - content: "\f481"; -} - -.ph-ladder::before { - content: "\f482"; -} - -.ph-ladder-simple::before { - content: "\f483"; -} - -.ph-lamp::before { - content: "\f484"; -} - -.ph-laptop::before { - content: "\f485"; -} - -.ph-layout::before { - content: "\f486"; -} - -.ph-leaf::before { - content: "\f487"; -} - -.ph-lifebuoy::before { - content: "\f488"; -} - -.ph-lightbulb::before { - content: "\f489"; -} - -.ph-lightbulb-filament::before { - content: "\f48a"; -} - -.ph-lightning::before { - content: "\f48b"; -} - -.ph-lightning-slash::before { - content: "\f48c"; -} - -.ph-line-segment::before { - content: "\f48d"; -} - -.ph-line-segments::before { - content: "\f48e"; -} - -.ph-link::before { - content: "\f48f"; -} - -.ph-link-break::before { - content: "\f490"; -} - -.ph-link-simple::before { - content: "\f491"; -} - -.ph-link-simple-break::before { - content: "\f492"; -} - -.ph-link-simple-horizontal::before { - content: "\f493"; -} - -.ph-link-simple-horizontal-break::before { - content: "\f494"; -} - -.ph-linkedin-logo::before { - content: "\f495"; -} - -.ph-linux-logo::before { - content: "\f496"; -} - -.ph-list::before { - content: "\f497"; -} - -.ph-list-bullets::before { - content: "\f498"; -} - -.ph-list-checks::before { - content: "\f499"; -} - -.ph-list-dashes::before { - content: "\f49a"; -} - -.ph-list-numbers::before { - content: "\f49b"; -} - -.ph-list-plus::before { - content: "\f49c"; -} - -.ph-lock::before { - content: "\f49d"; -} - -.ph-lock-key::before { - content: "\f49e"; -} - -.ph-lock-key-open::before { - content: "\f49f"; -} - -.ph-lock-laminated::before { - content: "\f4a0"; -} - -.ph-lock-laminated-open::before { - content: "\f4a1"; -} - -.ph-lock-open::before { - content: "\f4a2"; -} - -.ph-lock-simple::before { - content: "\f4a3"; -} - -.ph-lock-simple-open::before { - content: "\f4a4"; -} - -.ph-magic-wand::before { - content: "\f4a5"; -} - -.ph-magnet::before { - content: "\f4a6"; -} - -.ph-magnet-straight::before { - content: "\f4a7"; -} - -.ph-magnifying-glass::before { - content: "\f4a8"; -} - -.ph-magnifying-glass-minus::before { - content: "\f4a9"; -} - -.ph-magnifying-glass-plus::before { - content: "\f4aa"; -} - -.ph-map-pin::before { - content: "\f4ab"; -} - -.ph-map-pin-line::before { - content: "\f4ac"; -} - -.ph-map-trifold::before { - content: "\f4ad"; -} - -.ph-marker-circle::before { - content: "\f4ae"; -} - -.ph-martini::before { - content: "\f4af"; -} - -.ph-mask-happy::before { - content: "\f4b0"; -} - -.ph-mask-sad::before { - content: "\f4b1"; -} - -.ph-math-operations::before { - content: "\f4b2"; -} - -.ph-medal::before { - content: "\f4b3"; -} - -.ph-medium-logo::before { - content: "\f4b4"; -} - -.ph-megaphone::before { - content: "\f4b5"; -} - -.ph-megaphone-simple::before { - content: "\f4b6"; -} - -.ph-messenger-logo::before { - content: "\f4b7"; -} - -.ph-microphone::before { - content: "\f4b8"; -} - -.ph-microphone-slash::before { - content: "\f4b9"; -} - -.ph-microphone-stage::before { - content: "\f4ba"; -} - -.ph-microsoft-excel-logo::before { - content: "\f4bb"; -} - -.ph-microsoft-powerpoint-logo::before { - content: "\f4bc"; -} - -.ph-microsoft-teams-logo::before { - content: "\f4bd"; -} - -.ph-microsoft-word-logo::before { - content: "\f4be"; -} - -.ph-minus::before { - content: "\f4bf"; -} - -.ph-minus-circle::before { - content: "\f4c0"; -} - -.ph-money::before { - content: "\f4c1"; -} - -.ph-monitor::before { - content: "\f4c2"; -} - -.ph-monitor-play::before { - content: "\f4c3"; -} - -.ph-moon::before { - content: "\f4c4"; -} - -.ph-moon-stars::before { - content: "\f4c5"; -} - -.ph-mountains::before { - content: "\f4c6"; -} - -.ph-mouse::before { - content: "\f4c7"; -} - -.ph-mouse-simple::before { - content: "\f4c8"; -} - -.ph-music-note::before { - content: "\f4c9"; -} - -.ph-music-note-simple::before { - content: "\f4ca"; -} - -.ph-music-notes::before { - content: "\f4cb"; -} - -.ph-music-notes-plus::before { - content: "\f4cc"; -} - -.ph-music-notes-simple::before { - content: "\f4cd"; -} - -.ph-navigation-arrow::before { - content: "\f4ce"; -} - -.ph-needle::before { - content: "\f4cf"; -} - -.ph-newspaper::before { - content: "\f4d0"; -} - -.ph-newspaper-clipping::before { - content: "\f4d1"; -} - -.ph-note::before { - content: "\f4d2"; -} - -.ph-note-blank::before { - content: "\f4d3"; -} - -.ph-note-pencil::before { - content: "\f4d4"; -} - -.ph-notebook::before { - content: "\f4d5"; -} - -.ph-notepad::before { - content: "\f4d6"; -} - -.ph-notification::before { - content: "\f4d7"; -} - -.ph-number-circle-eight::before { - content: "\f4d8"; -} - -.ph-number-circle-five::before { - content: "\f4d9"; -} - -.ph-number-circle-four::before { - content: "\f4da"; -} - -.ph-number-circle-nine::before { - content: "\f4db"; -} - -.ph-number-circle-one::before { - content: "\f4dc"; -} - -.ph-number-circle-seven::before { - content: "\f4dd"; -} - -.ph-number-circle-six::before { - content: "\f4de"; -} - -.ph-number-circle-three::before { - content: "\f4df"; -} - -.ph-number-circle-two::before { - content: "\f4e0"; -} - -.ph-number-circle-zero::before { - content: "\f4e1"; -} - -.ph-number-eight::before { - content: "\f4e2"; -} - -.ph-number-five::before { - content: "\f4e3"; -} - -.ph-number-four::before { - content: "\f4e4"; -} - -.ph-number-nine::before { - content: "\f4e5"; -} - -.ph-number-one::before { - content: "\f4e6"; -} - -.ph-number-seven::before { - content: "\f4e7"; -} - -.ph-number-six::before { - content: "\f4e8"; -} - -.ph-number-square-eight::before { - content: "\f4e9"; -} - -.ph-number-square-five::before { - content: "\f4ea"; -} - -.ph-number-square-four::before { - content: "\f4eb"; -} - -.ph-number-square-nine::before { - content: "\f4ec"; -} - -.ph-number-square-one::before { - content: "\f4ed"; -} - -.ph-number-square-seven::before { - content: "\f4ee"; -} - -.ph-number-square-six::before { - content: "\f4ef"; -} - -.ph-number-square-three::before { - content: "\f4f0"; -} - -.ph-number-square-two::before { - content: "\f4f1"; -} - -.ph-number-square-zero::before { - content: "\f4f2"; -} - -.ph-number-three::before { - content: "\f4f3"; -} - -.ph-number-two::before { - content: "\f4f4"; -} - -.ph-number-zero::before { - content: "\f4f5"; -} - -.ph-nut::before { - content: "\f4f6"; -} - -.ph-ny-times-logo::before { - content: "\f4f7"; -} - -.ph-octagon::before { - content: "\f4f8"; -} - -.ph-option::before { - content: "\f4f9"; -} - -.ph-package::before { - content: "\f4fa"; -} - -.ph-paint-brush::before { - content: "\f4fb"; -} - -.ph-paint-brush-broad::before { - content: "\f4fc"; -} - -.ph-paint-brush-household::before { - content: "\f4fd"; -} - -.ph-paint-bucket::before { - content: "\f4fe"; -} - -.ph-paint-roller::before { - content: "\f4ff"; -} - -.ph-palette::before { - content: "\f500"; -} - -.ph-paper-plane::before { - content: "\f501"; -} - -.ph-paper-plane-right::before { - content: "\f502"; -} - -.ph-paper-plane-tilt::before { - content: "\f503"; -} - -.ph-paperclip::before { - content: "\f504"; -} - -.ph-paperclip-horizontal::before { - content: "\f505"; -} - -.ph-parachute::before { - content: "\f506"; -} - -.ph-password::before { - content: "\f507"; -} - -.ph-path::before { - content: "\f508"; -} - -.ph-pause::before { - content: "\f509"; -} - -.ph-pause-circle::before { - content: "\f50a"; -} - -.ph-paw-print::before { - content: "\f50b"; -} - -.ph-peace::before { - content: "\f50c"; -} - -.ph-pen::before { - content: "\f50d"; -} - -.ph-pen-nib::before { - content: "\f50e"; -} - -.ph-pen-nib-straight::before { - content: "\f50f"; -} - -.ph-pencil::before { - content: "\f510"; -} - -.ph-pencil-circle::before { - content: "\f511"; -} - -.ph-pencil-line::before { - content: "\f512"; -} - -.ph-pencil-simple::before { - content: "\f513"; -} - -.ph-pencil-simple-line::before { - content: "\f514"; -} - -.ph-percent::before { - content: "\f515"; -} - -.ph-person::before { - content: "\f516"; -} - -.ph-person-simple::before { - content: "\f517"; -} - -.ph-person-simple-run::before { - content: "\f518"; -} - -.ph-person-simple-walk::before { - content: "\f519"; -} - -.ph-perspective::before { - content: "\f51a"; -} - -.ph-phone::before { - content: "\f51b"; -} - -.ph-phone-call::before { - content: "\f51c"; -} - -.ph-phone-disconnect::before { - content: "\f51d"; -} - -.ph-phone-incoming::before { - content: "\f51e"; -} - -.ph-phone-outgoing::before { - content: "\f51f"; -} - -.ph-phone-slash::before { - content: "\f520"; -} - -.ph-phone-x::before { - content: "\f521"; -} - -.ph-phosphor-logo::before { - content: "\f522"; -} - -.ph-piano-keys::before { - content: "\f523"; -} - -.ph-picture-in-picture::before { - content: "\f524"; -} - -.ph-pill::before { - content: "\f525"; -} - -.ph-pinterest-logo::before { - content: "\f526"; -} - -.ph-pinwheel::before { - content: "\f527"; -} - -.ph-pizza::before { - content: "\f528"; -} - -.ph-placeholder::before { - content: "\f529"; -} - -.ph-planet::before { - content: "\f52a"; -} - -.ph-play::before { - content: "\f52b"; -} - -.ph-play-circle::before { - content: "\f52c"; -} - -.ph-playlist::before { - content: "\f52d"; -} - -.ph-plug::before { - content: "\f52e"; -} - -.ph-plugs::before { - content: "\f52f"; -} - -.ph-plugs-connected::before { - content: "\f530"; -} - -.ph-plus::before { - content: "\f531"; -} - -.ph-plus-circle::before { - content: "\f532"; -} - -.ph-plus-minus::before { - content: "\f533"; -} - -.ph-poker-chip::before { - content: "\f534"; -} - -.ph-police-car::before { - content: "\f535"; -} - -.ph-polygon::before { - content: "\f536"; -} - -.ph-popcorn::before { - content: "\f537"; -} - -.ph-power::before { - content: "\f538"; -} - -.ph-prescription::before { - content: "\f539"; -} - -.ph-presentation::before { - content: "\f53a"; -} - -.ph-presentation-chart::before { - content: "\f53b"; -} - -.ph-printer::before { - content: "\f53c"; -} - -.ph-prohibit::before { - content: "\f53d"; -} - -.ph-prohibit-inset::before { - content: "\f53e"; -} - -.ph-projector-screen::before { - content: "\f53f"; -} - -.ph-projector-screen-chart::before { - content: "\f540"; -} - -.ph-push-pin::before { - content: "\f541"; -} - -.ph-push-pin-simple::before { - content: "\f542"; -} - -.ph-push-pin-simple-slash::before { - content: "\f543"; -} - -.ph-push-pin-slash::before { - content: "\f544"; -} - -.ph-puzzle-piece::before { - content: "\f545"; -} - -.ph-qr-code::before { - content: "\f546"; -} - -.ph-question::before { - content: "\f547"; -} - -.ph-queue::before { - content: "\f548"; -} - -.ph-quotes::before { - content: "\f549"; -} - -.ph-radical::before { - content: "\f54a"; -} - -.ph-radio::before { - content: "\f54b"; -} - -.ph-radio-button::before { - content: "\f54c"; -} - -.ph-rainbow::before { - content: "\f54d"; -} - -.ph-rainbow-cloud::before { - content: "\f54e"; -} - -.ph-receipt::before { - content: "\f54f"; -} - -.ph-record::before { - content: "\f550"; -} - -.ph-rectangle::before { - content: "\f551"; -} - -.ph-recycle::before { - content: "\f552"; -} - -.ph-reddit-logo::before { - content: "\f553"; -} - -.ph-repeat::before { - content: "\f554"; -} - -.ph-repeat-once::before { - content: "\f555"; -} - -.ph-rewind::before { - content: "\f556"; -} - -.ph-rewind-circle::before { - content: "\f557"; -} - -.ph-robot::before { - content: "\f558"; -} - -.ph-rocket::before { - content: "\f559"; -} - -.ph-rocket-launch::before { - content: "\f55a"; -} - -.ph-rows::before { - content: "\f55b"; -} - -.ph-rss::before { - content: "\f55c"; -} - -.ph-rss-simple::before { - content: "\f55d"; -} - -.ph-rug::before { - content: "\f55e"; -} - -.ph-ruler::before { - content: "\f55f"; -} - -.ph-scales::before { - content: "\f560"; -} - -.ph-scan::before { - content: "\f561"; -} - -.ph-scissors::before { - content: "\f562"; -} - -.ph-screencast::before { - content: "\f563"; -} - -.ph-scribble-loop::before { - content: "\f564"; -} - -.ph-scroll::before { - content: "\f565"; -} - -.ph-selection::before { - content: "\f566"; -} - -.ph-selection-all::before { - content: "\f567"; -} - -.ph-selection-background::before { - content: "\f568"; -} - -.ph-selection-foreground::before { - content: "\f569"; -} - -.ph-selection-inverse::before { - content: "\f56a"; -} - -.ph-selection-plus::before { - content: "\f56b"; -} - -.ph-selection-slash::before { - content: "\f56c"; -} - -.ph-share::before { - content: "\f56d"; -} - -.ph-share-network::before { - content: "\f56e"; -} - -.ph-shield::before { - content: "\f56f"; -} - -.ph-shield-check::before { - content: "\f570"; -} - -.ph-shield-checkered::before { - content: "\f571"; -} - -.ph-shield-chevron::before { - content: "\f572"; -} - -.ph-shield-plus::before { - content: "\f573"; -} - -.ph-shield-slash::before { - content: "\f574"; -} - -.ph-shield-star::before { - content: "\f575"; -} - -.ph-shield-warning::before { - content: "\f576"; -} - -.ph-shopping-bag::before { - content: "\f577"; -} - -.ph-shopping-bag-open::before { - content: "\f578"; -} - -.ph-shopping-cart::before { - content: "\f579"; -} - -.ph-shopping-cart-simple::before { - content: "\f57a"; -} - -.ph-shower::before { - content: "\f57b"; -} - -.ph-shuffle::before { - content: "\f57c"; -} - -.ph-shuffle-angular::before { - content: "\f57d"; -} - -.ph-shuffle-simple::before { - content: "\f57e"; -} - -.ph-sidebar::before { - content: "\f57f"; -} - -.ph-sidebar-simple::before { - content: "\f580"; -} - -.ph-sign-in::before { - content: "\f581"; -} - -.ph-sign-out::before { - content: "\f582"; -} - -.ph-signpost::before { - content: "\f583"; -} - -.ph-sim-card::before { - content: "\f584"; -} - -.ph-sketch-logo::before { - content: "\f585"; -} - -.ph-skip-back::before { - content: "\f586"; -} - -.ph-skip-back-circle::before { - content: "\f587"; -} - -.ph-skip-forward::before { - content: "\f588"; -} - -.ph-skip-forward-circle::before { - content: "\f589"; -} - -.ph-skull::before { - content: "\f58a"; -} - -.ph-slack-logo::before { - content: "\f58b"; -} - -.ph-sliders::before { - content: "\f58c"; -} - -.ph-sliders-horizontal::before { - content: "\f58d"; -} - -.ph-smiley::before { - content: "\f58e"; -} - -.ph-smiley-blank::before { - content: "\f58f"; -} - -.ph-smiley-meh::before { - content: "\f590"; -} - -.ph-smiley-nervous::before { - content: "\f591"; -} - -.ph-smiley-sad::before { - content: "\f592"; -} - -.ph-smiley-sticker::before { - content: "\f593"; -} - -.ph-smiley-wink::before { - content: "\f594"; -} - -.ph-smiley-x-eyes::before { - content: "\f595"; -} - -.ph-snapchat-logo::before { - content: "\f596"; -} - -.ph-snowflake::before { - content: "\f597"; -} - -.ph-soccer-ball::before { - content: "\f598"; -} - -.ph-sort-ascending::before { - content: "\f599"; -} - -.ph-sort-descending::before { - content: "\f59a"; -} - -.ph-spade::before { - content: "\f59b"; -} - -.ph-sparkle::before { - content: "\f59c"; -} - -.ph-speaker-high::before { - content: "\f59d"; -} - -.ph-speaker-low::before { - content: "\f59e"; -} - -.ph-speaker-none::before { - content: "\f59f"; -} - -.ph-speaker-simple-high::before { - content: "\f5a0"; -} - -.ph-speaker-simple-low::before { - content: "\f5a1"; -} - -.ph-speaker-simple-none::before { - content: "\f5a2"; -} - -.ph-speaker-simple-slash::before { - content: "\f5a3"; -} - -.ph-speaker-simple-x::before { - content: "\f5a4"; -} - -.ph-speaker-slash::before { - content: "\f5a5"; -} - -.ph-speaker-x::before { - content: "\f5a6"; -} - -.ph-spinner::before { - content: "\f5a7"; -} - -.ph-spinner-gap::before { - content: "\f5a8"; -} - -.ph-spiral::before { - content: "\f5a9"; -} - -.ph-spotify-logo::before { - content: "\f5aa"; -} - -.ph-square::before { - content: "\f5ab"; -} - -.ph-square-half::before { - content: "\f5ac"; -} - -.ph-square-half-bottom::before { - content: "\f5ad"; -} - -.ph-square-logo::before { - content: "\f5ae"; -} - -.ph-squares-four::before { - content: "\f5af"; -} - -.ph-stack::before { - content: "\f5b0"; -} - -.ph-stack-overflow-logo::before { - content: "\f5b1"; -} - -.ph-stack-simple::before { - content: "\f5b2"; -} - -.ph-stamp::before { - content: "\f5b3"; -} - -.ph-star::before { - content: "\f5b4"; -} - -.ph-star-four::before { - content: "\f5b5"; -} - -.ph-star-half::before { - content: "\f5b6"; -} - -.ph-sticker::before { - content: "\f5b7"; -} - -.ph-stop::before { - content: "\f5b8"; -} - -.ph-stop-circle::before { - content: "\f5b9"; -} - -.ph-storefront::before { - content: "\f5ba"; -} - -.ph-strategy::before { - content: "\f5bb"; -} - -.ph-stripe-logo::before { - content: "\f5bc"; -} - -.ph-student::before { - content: "\f5bd"; -} - -.ph-suitcase::before { - content: "\f5be"; -} - -.ph-suitcase-simple::before { - content: "\f5bf"; -} - -.ph-sun::before { - content: "\f5c0"; -} - -.ph-sun-dim::before { - content: "\f5c1"; -} - -.ph-sun-horizon::before { - content: "\f5c2"; -} - -.ph-sunglasses::before { - content: "\f5c3"; -} - -.ph-swap::before { - content: "\f5c4"; -} - -.ph-swatches::before { - content: "\f5c5"; -} - -.ph-sword::before { - content: "\f5c6"; -} - -.ph-syringe::before { - content: "\f5c7"; -} - -.ph-t-shirt::before { - content: "\f5c8"; -} - -.ph-table::before { - content: "\f5c9"; -} - -.ph-tabs::before { - content: "\f5ca"; -} - -.ph-tag::before { - content: "\f5cb"; -} - -.ph-tag-chevron::before { - content: "\f5cc"; -} - -.ph-tag-simple::before { - content: "\f5cd"; -} - -.ph-target::before { - content: "\f5ce"; -} - -.ph-taxi::before { - content: "\f5cf"; -} - -.ph-telegram-logo::before { - content: "\f5d0"; -} - -.ph-television::before { - content: "\f5d1"; -} - -.ph-television-simple::before { - content: "\f5d2"; -} - -.ph-tennis-ball::before { - content: "\f5d3"; -} - -.ph-terminal::before { - content: "\f5d4"; -} - -.ph-terminal-window::before { - content: "\f5d5"; -} - -.ph-test-tube::before { - content: "\f5d6"; -} - -.ph-text-aa::before { - content: "\f5d7"; -} - -.ph-text-align-center::before { - content: "\f5d8"; -} - -.ph-text-align-justify::before { - content: "\f5d9"; -} - -.ph-text-align-left::before { - content: "\f5da"; -} - -.ph-text-align-right::before { - content: "\f5db"; -} - -.ph-text-bolder::before { - content: "\f5dc"; -} - -.ph-text-h::before { - content: "\f5dd"; -} - -.ph-text-h-five::before { - content: "\f5de"; -} - -.ph-text-h-four::before { - content: "\f5df"; -} - -.ph-text-h-one::before { - content: "\f5e0"; -} - -.ph-text-h-six::before { - content: "\f5e1"; -} - -.ph-text-h-three::before { - content: "\f5e2"; -} - -.ph-text-h-two::before { - content: "\f5e3"; -} - -.ph-text-indent::before { - content: "\f5e4"; -} - -.ph-text-italic::before { - content: "\f5e5"; -} - -.ph-text-outdent::before { - content: "\f5e6"; -} - -.ph-text-strikethrough::before { - content: "\f5e7"; -} - -.ph-text-t::before { - content: "\f5e8"; -} - -.ph-text-underline::before { - content: "\f5e9"; -} - -.ph-textbox::before { - content: "\f5ea"; -} - -.ph-thermometer::before { - content: "\f5eb"; -} - -.ph-thermometer-cold::before { - content: "\f5ec"; -} - -.ph-thermometer-hot::before { - content: "\f5ed"; -} - -.ph-thermometer-simple::before { - content: "\f5ee"; -} - -.ph-thumbs-down::before { - content: "\f5ef"; -} - -.ph-thumbs-up::before { - content: "\f5f0"; -} - -.ph-ticket::before { - content: "\f5f1"; -} - -.ph-tiktok-logo::before { - content: "\f5f2"; -} - -.ph-timer::before { - content: "\f5f3"; -} - -.ph-toggle-left::before { - content: "\f5f4"; -} - -.ph-toggle-right::before { - content: "\f5f5"; -} - -.ph-toilet::before { - content: "\f5f6"; -} - -.ph-toilet-paper::before { - content: "\f5f7"; -} - -.ph-tote::before { - content: "\f5f8"; -} - -.ph-tote-simple::before { - content: "\f5f9"; -} - -.ph-trademark-registered::before { - content: "\f5fa"; -} - -.ph-traffic-cone::before { - content: "\f5fb"; -} - -.ph-traffic-sign::before { - content: "\f5fc"; -} - -.ph-traffic-signal::before { - content: "\f5fd"; -} - -.ph-train::before { - content: "\f5fe"; -} - -.ph-train-regional::before { - content: "\f5ff"; -} - -.ph-train-simple::before { - content: "\f600"; -} - -.ph-translate::before { - content: "\f601"; -} - -.ph-trash::before { - content: "\f602"; -} - -.ph-trash-simple::before { - content: "\f603"; -} - -.ph-tray::before { - content: "\f604"; -} - -.ph-tree::before { - content: "\f605"; -} - -.ph-tree-evergreen::before { - content: "\f606"; -} - -.ph-tree-structure::before { - content: "\f607"; -} - -.ph-trend-down::before { - content: "\f608"; -} - -.ph-trend-up::before { - content: "\f609"; -} - -.ph-triangle::before { - content: "\f60a"; -} - -.ph-trophy::before { - content: "\f60b"; -} - -.ph-truck::before { - content: "\f60c"; -} - -.ph-twitch-logo::before { - content: "\f60d"; -} - -.ph-twitter-logo::before { - content: "\f60e"; -} - -.ph-umbrella::before { - content: "\f60f"; -} - -.ph-umbrella-simple::before { - content: "\f610"; -} - -.ph-upload::before { - content: "\f611"; -} - -.ph-upload-simple::before { - content: "\f612"; -} - -.ph-user::before { - content: "\f613"; -} - -.ph-user-circle::before { - content: "\f614"; -} - -.ph-user-circle-gear::before { - content: "\f615"; -} - -.ph-user-circle-minus::before { - content: "\f616"; -} - -.ph-user-circle-plus::before { - content: "\f617"; -} - -.ph-user-focus::before { - content: "\f618"; -} - -.ph-user-gear::before { - content: "\f619"; -} - -.ph-user-list::before { - content: "\f61a"; -} - -.ph-user-minus::before { - content: "\f61b"; -} - -.ph-user-plus::before { - content: "\f61c"; -} - -.ph-user-rectangle::before { - content: "\f61d"; -} - -.ph-user-square::before { - content: "\f61e"; -} - -.ph-user-switch::before { - content: "\f61f"; -} - -.ph-users::before { - content: "\f620"; -} - -.ph-users-four::before { - content: "\f621"; -} - -.ph-users-three::before { - content: "\f622"; -} - -.ph-vault::before { - content: "\f623"; -} - -.ph-vibrate::before { - content: "\f624"; -} - -.ph-video-camera::before { - content: "\f625"; -} - -.ph-video-camera-slash::before { - content: "\f626"; -} - -.ph-vignette::before { - content: "\f627"; -} - -.ph-voicemail::before { - content: "\f628"; -} - -.ph-volleyball::before { - content: "\f629"; -} - -.ph-wall::before { - content: "\f62a"; -} - -.ph-wallet::before { - content: "\f62b"; -} - -.ph-warning::before { - content: "\f62c"; -} - -.ph-warning-circle::before { - content: "\f62d"; -} - -.ph-warning-octagon::before { - content: "\f62e"; -} - -.ph-watch::before { - content: "\f62f"; -} - -.ph-wave-sawtooth::before { - content: "\f630"; -} - -.ph-wave-sine::before { - content: "\f631"; -} - -.ph-wave-square::before { - content: "\f632"; -} - -.ph-wave-triangle::before { - content: "\f633"; -} - -.ph-waves::before { - content: "\f634"; -} - -.ph-webcam::before { - content: "\f635"; -} - -.ph-whatsapp-logo::before { - content: "\f636"; -} - -.ph-wheelchair::before { - content: "\f637"; -} - -.ph-wifi-high::before { - content: "\f638"; -} - -.ph-wifi-low::before { - content: "\f639"; -} - -.ph-wifi-medium::before { - content: "\f63a"; -} - -.ph-wifi-none::before { - content: "\f63b"; -} - -.ph-wifi-slash::before { - content: "\f63c"; -} - -.ph-wifi-x::before { - content: "\f63d"; -} - -.ph-wind::before { - content: "\f63e"; -} - -.ph-windows-logo::before { - content: "\f63f"; -} - -.ph-wine::before { - content: "\f640"; -} - -.ph-wrench::before { - content: "\f641"; -} - -.ph-x::before { - content: "\f642"; -} - -.ph-x-circle::before { - content: "\f643"; -} - -.ph-x-square::before { - content: "\f644"; -} - -.ph-yin-yang::before { - content: "\f645"; -} - -.ph-youtube-logo::before { - content: "\f646"; -} - -.ph-activity-bold::before { - content: "\f647"; -} - -.ph-address-book-bold::before { - content: "\f648"; -} - -.ph-airplane-bold::before { - content: "\f649"; -} - -.ph-airplane-in-flight-bold::before { - content: "\f64a"; -} - -.ph-airplane-landing-bold::before { - content: "\f64b"; -} - -.ph-airplane-takeoff-bold::before { - content: "\f64c"; -} - -.ph-airplane-tilt-bold::before { - content: "\f64d"; -} - -.ph-airplay-bold::before { - content: "\f64e"; -} - -.ph-alarm-bold::before { - content: "\f64f"; -} - -.ph-alien-bold::before { - content: "\f650"; -} - -.ph-align-bottom-bold::before { - content: "\f651"; -} - -.ph-align-bottom-simple-bold::before { - content: "\f652"; -} - -.ph-align-center-horizontal-bold::before { - content: "\f653"; -} - -.ph-align-center-horizontal-simple-bold::before { - content: "\f654"; -} - -.ph-align-center-vertical-bold::before { - content: "\f655"; -} - -.ph-align-center-vertical-simple-bold::before { - content: "\f656"; -} - -.ph-align-left-bold::before { - content: "\f657"; -} - -.ph-align-left-simple-bold::before { - content: "\f658"; -} - -.ph-align-right-bold::before { - content: "\f659"; -} - -.ph-align-right-simple-bold::before { - content: "\f65a"; -} - -.ph-align-top-bold::before { - content: "\f65b"; -} - -.ph-align-top-simple-bold::before { - content: "\f65c"; -} - -.ph-anchor-bold::before { - content: "\f65d"; -} - -.ph-anchor-simple-bold::before { - content: "\f65e"; -} - -.ph-android-logo-bold::before { - content: "\f65f"; -} - -.ph-angular-logo-bold::before { - content: "\f660"; -} - -.ph-aperture-bold::before { - content: "\f661"; -} - -.ph-app-store-logo-bold::before { - content: "\f662"; -} - -.ph-app-window-bold::before { - content: "\f663"; -} - -.ph-apple-logo-bold::before { - content: "\f664"; -} - -.ph-apple-podcasts-logo-bold::before { - content: "\f665"; -} - -.ph-archive-bold::before { - content: "\f666"; -} - -.ph-archive-box-bold::before { - content: "\f667"; -} - -.ph-archive-tray-bold::before { - content: "\f668"; -} - -.ph-armchair-bold::before { - content: "\f669"; -} - -.ph-arrow-arc-left-bold::before { - content: "\f66a"; -} - -.ph-arrow-arc-right-bold::before { - content: "\f66b"; -} - -.ph-arrow-bend-double-up-left-bold::before { - content: "\f66c"; -} - -.ph-arrow-bend-double-up-right-bold::before { - content: "\f66d"; -} - -.ph-arrow-bend-down-left-bold::before { - content: "\f66e"; -} - -.ph-arrow-bend-down-right-bold::before { - content: "\f66f"; -} - -.ph-arrow-bend-left-down-bold::before { - content: "\f670"; -} - -.ph-arrow-bend-left-up-bold::before { - content: "\f671"; -} - -.ph-arrow-bend-right-down-bold::before { - content: "\f672"; -} - -.ph-arrow-bend-right-up-bold::before { - content: "\f673"; -} - -.ph-arrow-bend-up-left-bold::before { - content: "\f674"; -} - -.ph-arrow-bend-up-right-bold::before { - content: "\f675"; -} - -.ph-arrow-circle-down-bold::before { - content: "\f676"; -} - -.ph-arrow-circle-down-left-bold::before { - content: "\f677"; -} - -.ph-arrow-circle-down-right-bold::before { - content: "\f678"; -} - -.ph-arrow-circle-left-bold::before { - content: "\f679"; -} - -.ph-arrow-circle-right-bold::before { - content: "\f67a"; -} - -.ph-arrow-circle-up-bold::before { - content: "\f67b"; -} - -.ph-arrow-circle-up-left-bold::before { - content: "\f67c"; -} - -.ph-arrow-circle-up-right-bold::before { - content: "\f67d"; -} - -.ph-arrow-clockwise-bold::before { - content: "\f67e"; -} - -.ph-arrow-counter-clockwise-bold::before { - content: "\f67f"; -} - -.ph-arrow-down-bold::before { - content: "\f680"; -} - -.ph-arrow-down-left-bold::before { - content: "\f681"; -} - -.ph-arrow-down-right-bold::before { - content: "\f682"; -} - -.ph-arrow-elbow-down-left-bold::before { - content: "\f683"; -} - -.ph-arrow-elbow-down-right-bold::before { - content: "\f684"; -} - -.ph-arrow-elbow-left-bold::before { - content: "\f685"; -} - -.ph-arrow-elbow-left-down-bold::before { - content: "\f686"; -} - -.ph-arrow-elbow-left-up-bold::before { - content: "\f687"; -} - -.ph-arrow-elbow-right-bold::before { - content: "\f688"; -} - -.ph-arrow-elbow-right-down-bold::before { - content: "\f689"; -} - -.ph-arrow-elbow-right-up-bold::before { - content: "\f68a"; -} - -.ph-arrow-elbow-up-left-bold::before { - content: "\f68b"; -} - -.ph-arrow-elbow-up-right-bold::before { - content: "\f68c"; -} - -.ph-arrow-fat-down-bold::before { - content: "\f68d"; -} - -.ph-arrow-fat-left-bold::before { - content: "\f68e"; -} - -.ph-arrow-fat-line-down-bold::before { - content: "\f68f"; -} - -.ph-arrow-fat-line-left-bold::before { - content: "\f690"; -} - -.ph-arrow-fat-line-right-bold::before { - content: "\f691"; -} - -.ph-arrow-fat-line-up-bold::before { - content: "\f692"; -} - -.ph-arrow-fat-lines-down-bold::before { - content: "\f693"; -} - -.ph-arrow-fat-lines-left-bold::before { - content: "\f694"; -} - -.ph-arrow-fat-lines-right-bold::before { - content: "\f695"; -} - -.ph-arrow-fat-lines-up-bold::before { - content: "\f696"; -} - -.ph-arrow-fat-right-bold::before { - content: "\f697"; -} - -.ph-arrow-fat-up-bold::before { - content: "\f698"; -} - -.ph-arrow-left-bold::before { - content: "\f699"; -} - -.ph-arrow-line-down-bold::before { - content: "\f69a"; -} - -.ph-arrow-line-down-left-bold::before { - content: "\f69b"; -} - -.ph-arrow-line-down-right-bold::before { - content: "\f69c"; -} - -.ph-arrow-line-left-bold::before { - content: "\f69d"; -} - -.ph-arrow-line-right-bold::before { - content: "\f69e"; -} - -.ph-arrow-line-up-bold::before { - content: "\f69f"; -} - -.ph-arrow-line-up-left-bold::before { - content: "\f6a0"; -} - -.ph-arrow-line-up-right-bold::before { - content: "\f6a1"; -} - -.ph-arrow-right-bold::before { - content: "\f6a2"; -} - -.ph-arrow-square-down-bold::before { - content: "\f6a3"; -} - -.ph-arrow-square-down-left-bold::before { - content: "\f6a4"; -} - -.ph-arrow-square-down-right-bold::before { - content: "\f6a5"; -} - -.ph-arrow-square-in-bold::before { - content: "\f6a6"; -} - -.ph-arrow-square-left-bold::before { - content: "\f6a7"; -} - -.ph-arrow-square-out-bold::before { - content: "\f6a8"; -} - -.ph-arrow-square-right-bold::before { - content: "\f6a9"; -} - -.ph-arrow-square-up-bold::before { - content: "\f6aa"; -} - -.ph-arrow-square-up-left-bold::before { - content: "\f6ab"; -} - -.ph-arrow-square-up-right-bold::before { - content: "\f6ac"; -} - -.ph-arrow-u-down-left-bold::before { - content: "\f6ad"; -} - -.ph-arrow-u-down-right-bold::before { - content: "\f6ae"; -} - -.ph-arrow-u-left-down-bold::before { - content: "\f6af"; -} - -.ph-arrow-u-left-up-bold::before { - content: "\f6b0"; -} - -.ph-arrow-u-right-down-bold::before { - content: "\f6b1"; -} - -.ph-arrow-u-right-up-bold::before { - content: "\f6b2"; -} - -.ph-arrow-u-up-left-bold::before { - content: "\f6b3"; -} - -.ph-arrow-u-up-right-bold::before { - content: "\f6b4"; -} - -.ph-arrow-up-bold::before { - content: "\f6b5"; -} - -.ph-arrow-up-left-bold::before { - content: "\f6b6"; -} - -.ph-arrow-up-right-bold::before { - content: "\f6b7"; -} - -.ph-arrows-clockwise-bold::before { - content: "\f6b8"; -} - -.ph-arrows-counter-clockwise-bold::before { - content: "\f6b9"; -} - -.ph-arrows-down-up-bold::before { - content: "\f6ba"; -} - -.ph-arrows-horizontal-bold::before { - content: "\f6bb"; -} - -.ph-arrows-in-bold::before { - content: "\f6bc"; -} - -.ph-arrows-in-cardinal-bold::before { - content: "\f6bd"; -} - -.ph-arrows-in-line-horizontal-bold::before { - content: "\f6be"; -} - -.ph-arrows-in-line-vertical-bold::before { - content: "\f6bf"; -} - -.ph-arrows-in-simple-bold::before { - content: "\f6c0"; -} - -.ph-arrows-left-right-bold::before { - content: "\f6c1"; -} - -.ph-arrows-out-bold::before { - content: "\f6c2"; -} - -.ph-arrows-out-cardinal-bold::before { - content: "\f6c3"; -} - -.ph-arrows-out-line-horizontal-bold::before { - content: "\f6c4"; -} - -.ph-arrows-out-line-vertical-bold::before { - content: "\f6c5"; -} - -.ph-arrows-out-simple-bold::before { - content: "\f6c6"; -} - -.ph-arrows-vertical-bold::before { - content: "\f6c7"; -} - -.ph-article-bold::before { - content: "\f6c8"; -} - -.ph-article-medium-bold::before { - content: "\f6c9"; -} - -.ph-article-ny-times-bold::before { - content: "\f6ca"; -} - -.ph-asterisk-bold::before { - content: "\f6cb"; -} - -.ph-asterisk-simple-bold::before { - content: "\f6cc"; -} - -.ph-at-bold::before { - content: "\f6cd"; -} - -.ph-atom-bold::before { - content: "\f6ce"; -} - -.ph-baby-bold::before { - content: "\f6cf"; -} - -.ph-backpack-bold::before { - content: "\f6d0"; -} - -.ph-backspace-bold::before { - content: "\f6d1"; -} - -.ph-bag-bold::before { - content: "\f6d2"; -} - -.ph-bag-simple-bold::before { - content: "\f6d3"; -} - -.ph-balloon-bold::before { - content: "\f6d4"; -} - -.ph-bandaids-bold::before { - content: "\f6d5"; -} - -.ph-bank-bold::before { - content: "\f6d6"; -} - -.ph-barbell-bold::before { - content: "\f6d7"; -} - -.ph-barcode-bold::before { - content: "\f6d8"; -} - -.ph-barricade-bold::before { - content: "\f6d9"; -} - -.ph-baseball-bold::before { - content: "\f6da"; -} - -.ph-basketball-bold::before { - content: "\f6db"; -} - -.ph-bathtub-bold::before { - content: "\f6dc"; -} - -.ph-battery-charging-bold::before { - content: "\f6dd"; -} - -.ph-battery-charging-vertical-bold::before { - content: "\f6de"; -} - -.ph-battery-empty-bold::before { - content: "\f6df"; -} - -.ph-battery-full-bold::before { - content: "\f6e0"; -} - -.ph-battery-high-bold::before { - content: "\f6e1"; -} - -.ph-battery-low-bold::before { - content: "\f6e2"; -} - -.ph-battery-medium-bold::before { - content: "\f6e3"; -} - -.ph-battery-plus-bold::before { - content: "\f6e4"; -} - -.ph-battery-warning-bold::before { - content: "\f6e5"; -} - -.ph-battery-warning-vertical-bold::before { - content: "\f6e6"; -} - -.ph-bed-bold::before { - content: "\f6e7"; -} - -.ph-beer-bottle-bold::before { - content: "\f6e8"; -} - -.ph-behance-logo-bold::before { - content: "\f6e9"; -} - -.ph-bell-bold::before { - content: "\f6ea"; -} - -.ph-bell-ringing-bold::before { - content: "\f6eb"; -} - -.ph-bell-simple-bold::before { - content: "\f6ec"; -} - -.ph-bell-simple-ringing-bold::before { - content: "\f6ed"; -} - -.ph-bell-simple-slash-bold::before { - content: "\f6ee"; -} - -.ph-bell-simple-z-bold::before { - content: "\f6ef"; -} - -.ph-bell-slash-bold::before { - content: "\f6f0"; -} - -.ph-bell-z-bold::before { - content: "\f6f1"; -} - -.ph-bezier-curve-bold::before { - content: "\f6f2"; -} - -.ph-bicycle-bold::before { - content: "\f6f3"; -} - -.ph-binoculars-bold::before { - content: "\f6f4"; -} - -.ph-bird-bold::before { - content: "\f6f5"; -} - -.ph-bluetooth-bold::before { - content: "\f6f6"; -} - -.ph-bluetooth-connected-bold::before { - content: "\f6f7"; -} - -.ph-bluetooth-slash-bold::before { - content: "\f6f8"; -} - -.ph-bluetooth-x-bold::before { - content: "\f6f9"; -} - -.ph-boat-bold::before { - content: "\f6fa"; -} - -.ph-book-bold::before { - content: "\f6fb"; -} - -.ph-book-bookmark-bold::before { - content: "\f6fc"; -} - -.ph-book-open-bold::before { - content: "\f6fd"; -} - -.ph-bookmark-bold::before { - content: "\f6fe"; -} - -.ph-bookmark-simple-bold::before { - content: "\f6ff"; -} - -.ph-bookmarks-bold::before { - content: "\f700"; -} - -.ph-bookmarks-simple-bold::before { - content: "\f701"; -} - -.ph-books-bold::before { - content: "\f702"; -} - -.ph-bounding-box-bold::before { - content: "\f703"; -} - -.ph-brackets-angle-bold::before { - content: "\f704"; -} - -.ph-brackets-curly-bold::before { - content: "\f705"; -} - -.ph-brackets-round-bold::before { - content: "\f706"; -} - -.ph-brackets-square-bold::before { - content: "\f707"; -} - -.ph-brain-bold::before { - content: "\f708"; -} - -.ph-brandy-bold::before { - content: "\f709"; -} - -.ph-briefcase-bold::before { - content: "\f70a"; -} - -.ph-briefcase-metal-bold::before { - content: "\f70b"; -} - -.ph-broadcast-bold::before { - content: "\f70c"; -} - -.ph-browser-bold::before { - content: "\f70d"; -} - -.ph-browsers-bold::before { - content: "\f70e"; -} - -.ph-bug-beetle-bold::before { - content: "\f70f"; -} - -.ph-bug-bold::before { - content: "\f710"; -} - -.ph-bug-droid-bold::before { - content: "\f711"; -} - -.ph-buildings-bold::before { - content: "\f712"; -} - -.ph-bus-bold::before { - content: "\f713"; -} - -.ph-butterfly-bold::before { - content: "\f714"; -} - -.ph-cactus-bold::before { - content: "\f715"; -} - -.ph-cake-bold::before { - content: "\f716"; -} - -.ph-calculator-bold::before { - content: "\f717"; -} - -.ph-calendar-blank-bold::before { - content: "\f718"; -} - -.ph-calendar-bold::before { - content: "\f719"; -} - -.ph-calendar-check-bold::before { - content: "\f71a"; -} - -.ph-calendar-plus-bold::before { - content: "\f71b"; -} - -.ph-calendar-x-bold::before { - content: "\f71c"; -} - -.ph-camera-bold::before { - content: "\f71d"; -} - -.ph-camera-rotate-bold::before { - content: "\f71e"; -} - -.ph-camera-slash-bold::before { - content: "\f71f"; -} - -.ph-campfire-bold::before { - content: "\f720"; -} - -.ph-car-bold::before { - content: "\f721"; -} - -.ph-car-simple-bold::before { - content: "\f722"; -} - -.ph-cardholder-bold::before { - content: "\f723"; -} - -.ph-cards-bold::before { - content: "\f724"; -} - -.ph-caret-circle-double-down-bold::before { - content: "\f725"; -} - -.ph-caret-circle-double-left-bold::before { - content: "\f726"; -} - -.ph-caret-circle-double-right-bold::before { - content: "\f727"; -} - -.ph-caret-circle-double-up-bold::before { - content: "\f728"; -} - -.ph-caret-circle-down-bold::before { - content: "\f729"; -} - -.ph-caret-circle-left-bold::before { - content: "\f72a"; -} - -.ph-caret-circle-right-bold::before { - content: "\f72b"; -} - -.ph-caret-circle-up-bold::before { - content: "\f72c"; -} - -.ph-caret-double-down-bold::before { - content: "\f72d"; -} - -.ph-caret-double-left-bold::before { - content: "\f72e"; -} - -.ph-caret-double-right-bold::before { - content: "\f72f"; -} - -.ph-caret-double-up-bold::before { - content: "\f730"; -} - -.ph-caret-down-bold::before { - content: "\f731"; -} - -.ph-caret-left-bold::before { - content: "\f732"; -} - -.ph-caret-right-bold::before { - content: "\f733"; -} - -.ph-caret-up-bold::before { - content: "\f734"; -} - -.ph-cat-bold::before { - content: "\f735"; -} - -.ph-cell-signal-full-bold::before { - content: "\f736"; -} - -.ph-cell-signal-high-bold::before { - content: "\f737"; -} - -.ph-cell-signal-low-bold::before { - content: "\f738"; -} - -.ph-cell-signal-medium-bold::before { - content: "\f739"; -} - -.ph-cell-signal-none-bold::before { - content: "\f73a"; -} - -.ph-cell-signal-slash-bold::before { - content: "\f73b"; -} - -.ph-cell-signal-x-bold::before { - content: "\f73c"; -} - -.ph-chalkboard-bold::before { - content: "\f73d"; -} - -.ph-chalkboard-simple-bold::before { - content: "\f73e"; -} - -.ph-chalkboard-teacher-bold::before { - content: "\f73f"; -} - -.ph-chart-bar-bold::before { - content: "\f740"; -} - -.ph-chart-bar-horizontal-bold::before { - content: "\f741"; -} - -.ph-chart-line-bold::before { - content: "\f742"; -} - -.ph-chart-line-up-bold::before { - content: "\f743"; -} - -.ph-chart-pie-bold::before { - content: "\f744"; -} - -.ph-chart-pie-slice-bold::before { - content: "\f745"; -} - -.ph-chat-bold::before { - content: "\f746"; -} - -.ph-chat-centered-bold::before { - content: "\f747"; -} - -.ph-chat-centered-dots-bold::before { - content: "\f748"; -} - -.ph-chat-centered-text-bold::before { - content: "\f749"; -} - -.ph-chat-circle-bold::before { - content: "\f74a"; -} - -.ph-chat-circle-dots-bold::before { - content: "\f74b"; -} - -.ph-chat-circle-text-bold::before { - content: "\f74c"; -} - -.ph-chat-dots-bold::before { - content: "\f74d"; -} - -.ph-chat-teardrop-bold::before { - content: "\f74e"; -} - -.ph-chat-teardrop-dots-bold::before { - content: "\f74f"; -} - -.ph-chat-teardrop-text-bold::before { - content: "\f750"; -} - -.ph-chat-text-bold::before { - content: "\f751"; -} - -.ph-chats-bold::before { - content: "\f752"; -} - -.ph-chats-circle-bold::before { - content: "\f753"; -} - -.ph-chats-teardrop-bold::before { - content: "\f754"; -} - -.ph-check-bold::before { - content: "\f755"; -} - -.ph-check-circle-bold::before { - content: "\f756"; -} - -.ph-check-square-bold::before { - content: "\f757"; -} - -.ph-check-square-offset-bold::before { - content: "\f758"; -} - -.ph-checks-bold::before { - content: "\f759"; -} - -.ph-circle-bold::before { - content: "\f75a"; -} - -.ph-circle-dashed-bold::before { - content: "\f75b"; -} - -.ph-circle-half-bold::before { - content: "\f75c"; -} - -.ph-circle-half-tilt-bold::before { - content: "\f75d"; -} - -.ph-circle-notch-bold::before { - content: "\f75e"; -} - -.ph-circle-wavy-bold::before { - content: "\f75f"; -} - -.ph-circle-wavy-check-bold::before { - content: "\f760"; -} - -.ph-circle-wavy-question-bold::before { - content: "\f761"; -} - -.ph-circle-wavy-warning-bold::before { - content: "\f762"; -} - -.ph-circles-four-bold::before { - content: "\f763"; -} - -.ph-circles-three-bold::before { - content: "\f764"; -} - -.ph-circles-three-plus-bold::before { - content: "\f765"; -} - -.ph-clipboard-bold::before { - content: "\f766"; -} - -.ph-clipboard-text-bold::before { - content: "\f767"; -} - -.ph-clock-afternoon-bold::before { - content: "\f768"; -} - -.ph-clock-bold::before { - content: "\f769"; -} - -.ph-clock-clockwise-bold::before { - content: "\f76a"; -} - -.ph-clock-counter-clockwise-bold::before { - content: "\f76b"; -} - -.ph-closed-captioning-bold::before { - content: "\f76c"; -} - -.ph-cloud-arrow-down-bold::before { - content: "\f76d"; -} - -.ph-cloud-arrow-up-bold::before { - content: "\f76e"; -} - -.ph-cloud-bold::before { - content: "\f76f"; -} - -.ph-cloud-check-bold::before { - content: "\f770"; -} - -.ph-cloud-fog-bold::before { - content: "\f771"; -} - -.ph-cloud-lightning-bold::before { - content: "\f772"; -} - -.ph-cloud-moon-bold::before { - content: "\f773"; -} - -.ph-cloud-rain-bold::before { - content: "\f774"; -} - -.ph-cloud-slash-bold::before { - content: "\f775"; -} - -.ph-cloud-snow-bold::before { - content: "\f776"; -} - -.ph-cloud-sun-bold::before { - content: "\f777"; -} - -.ph-club-bold::before { - content: "\f778"; -} - -.ph-coat-hanger-bold::before { - content: "\f779"; -} - -.ph-code-bold::before { - content: "\f77a"; -} - -.ph-code-simple-bold::before { - content: "\f77b"; -} - -.ph-codepen-logo-bold::before { - content: "\f77c"; -} - -.ph-codesandbox-logo-bold::before { - content: "\f77d"; -} - -.ph-coffee-bold::before { - content: "\f77e"; -} - -.ph-coin-bold::before { - content: "\f77f"; -} - -.ph-coin-vertical-bold::before { - content: "\f780"; -} - -.ph-coins-bold::before { - content: "\f781"; -} - -.ph-columns-bold::before { - content: "\f782"; -} - -.ph-command-bold::before { - content: "\f783"; -} - -.ph-compass-bold::before { - content: "\f784"; -} - -.ph-computer-tower-bold::before { - content: "\f785"; -} - -.ph-confetti-bold::before { - content: "\f786"; -} - -.ph-cookie-bold::before { - content: "\f787"; -} - -.ph-cooking-pot-bold::before { - content: "\f788"; -} - -.ph-copy-bold::before { - content: "\f789"; -} - -.ph-copy-simple-bold::before { - content: "\f78a"; -} - -.ph-copyleft-bold::before { - content: "\f78b"; -} - -.ph-copyright-bold::before { - content: "\f78c"; -} - -.ph-corners-in-bold::before { - content: "\f78d"; -} - -.ph-corners-out-bold::before { - content: "\f78e"; -} - -.ph-cpu-bold::before { - content: "\f78f"; -} - -.ph-credit-card-bold::before { - content: "\f790"; -} - -.ph-crop-bold::before { - content: "\f791"; -} - -.ph-crosshair-bold::before { - content: "\f792"; -} - -.ph-crosshair-simple-bold::before { - content: "\f793"; -} - -.ph-crown-bold::before { - content: "\f794"; -} - -.ph-crown-simple-bold::before { - content: "\f795"; -} - -.ph-cube-bold::before { - content: "\f796"; -} - -.ph-currency-btc-bold::before { - content: "\f797"; -} - -.ph-currency-circle-dollar-bold::before { - content: "\f798"; -} - -.ph-currency-cny-bold::before { - content: "\f799"; -} - -.ph-currency-dollar-bold::before { - content: "\f79a"; -} - -.ph-currency-dollar-simple-bold::before { - content: "\f79b"; -} - -.ph-currency-eth-bold::before { - content: "\f79c"; -} - -.ph-currency-eur-bold::before { - content: "\f79d"; -} - -.ph-currency-gbp-bold::before { - content: "\f79e"; -} - -.ph-currency-inr-bold::before { - content: "\f79f"; -} - -.ph-currency-jpy-bold::before { - content: "\f7a0"; -} - -.ph-currency-krw-bold::before { - content: "\f7a1"; -} - -.ph-currency-kzt-bold::before { - content: "\f7a2"; -} - -.ph-currency-ngn-bold::before { - content: "\f7a3"; -} - -.ph-currency-rub-bold::before { - content: "\f7a4"; -} - -.ph-cursor-bold::before { - content: "\f7a5"; -} - -.ph-cursor-text-bold::before { - content: "\f7a6"; -} - -.ph-cylinder-bold::before { - content: "\f7a7"; -} - -.ph-database-bold::before { - content: "\f7a8"; -} - -.ph-desktop-bold::before { - content: "\f7a9"; -} - -.ph-desktop-tower-bold::before { - content: "\f7aa"; -} - -.ph-detective-bold::before { - content: "\f7ab"; -} - -.ph-device-mobile-bold::before { - content: "\f7ac"; -} - -.ph-device-mobile-camera-bold::before { - content: "\f7ad"; -} - -.ph-device-mobile-speaker-bold::before { - content: "\f7ae"; -} - -.ph-device-tablet-bold::before { - content: "\f7af"; -} - -.ph-device-tablet-camera-bold::before { - content: "\f7b0"; -} - -.ph-device-tablet-speaker-bold::before { - content: "\f7b1"; -} - -.ph-diamond-bold::before { - content: "\f7b2"; -} - -.ph-diamonds-four-bold::before { - content: "\f7b3"; -} - -.ph-dice-five-bold::before { - content: "\f7b4"; -} - -.ph-dice-four-bold::before { - content: "\f7b5"; -} - -.ph-dice-one-bold::before { - content: "\f7b6"; -} - -.ph-dice-six-bold::before { - content: "\f7b7"; -} - -.ph-dice-three-bold::before { - content: "\f7b8"; -} - -.ph-dice-two-bold::before { - content: "\f7b9"; -} - -.ph-disc-bold::before { - content: "\f7ba"; -} - -.ph-discord-logo-bold::before { - content: "\f7bb"; -} - -.ph-divide-bold::before { - content: "\f7bc"; -} - -.ph-dog-bold::before { - content: "\f7bd"; -} - -.ph-door-bold::before { - content: "\f7be"; -} - -.ph-dots-nine-bold::before { - content: "\f7bf"; -} - -.ph-dots-six-bold::before { - content: "\f7c0"; -} - -.ph-dots-six-vertical-bold::before { - content: "\f7c1"; -} - -.ph-dots-three-bold::before { - content: "\f7c2"; -} - -.ph-dots-three-circle-bold::before { - content: "\f7c3"; -} - -.ph-dots-three-circle-vertical-bold::before { - content: "\f7c4"; -} - -.ph-dots-three-outline-bold::before { - content: "\f7c5"; -} - -.ph-dots-three-outline-vertical-bold::before { - content: "\f7c6"; -} - -.ph-dots-three-vertical-bold::before { - content: "\f7c7"; -} - -.ph-download-bold::before { - content: "\f7c8"; -} - -.ph-download-simple-bold::before { - content: "\f7c9"; -} - -.ph-dribbble-logo-bold::before { - content: "\f7ca"; -} - -.ph-drop-bold::before { - content: "\f7cb"; -} - -.ph-drop-half-bold::before { - content: "\f7cc"; -} - -.ph-drop-half-bottom-bold::before { - content: "\f7cd"; -} - -.ph-ear-bold::before { - content: "\f7ce"; -} - -.ph-ear-slash-bold::before { - content: "\f7cf"; -} - -.ph-egg-bold::before { - content: "\f7d0"; -} - -.ph-egg-crack-bold::before { - content: "\f7d1"; -} - -.ph-eject-bold::before { - content: "\f7d2"; -} - -.ph-eject-simple-bold::before { - content: "\f7d3"; -} - -.ph-envelope-bold::before { - content: "\f7d4"; -} - -.ph-envelope-open-bold::before { - content: "\f7d5"; -} - -.ph-envelope-simple-bold::before { - content: "\f7d6"; -} - -.ph-envelope-simple-open-bold::before { - content: "\f7d7"; -} - -.ph-equalizer-bold::before { - content: "\f7d8"; -} - -.ph-equals-bold::before { - content: "\f7d9"; -} - -.ph-eraser-bold::before { - content: "\f7da"; -} - -.ph-exam-bold::before { - content: "\f7db"; -} - -.ph-export-bold::before { - content: "\f7dc"; -} - -.ph-eye-bold::before { - content: "\f7dd"; -} - -.ph-eye-closed-bold::before { - content: "\f7de"; -} - -.ph-eye-slash-bold::before { - content: "\f7df"; -} - -.ph-eyedropper-bold::before { - content: "\f7e0"; -} - -.ph-eyedropper-sample-bold::before { - content: "\f7e1"; -} - -.ph-eyeglasses-bold::before { - content: "\f7e2"; -} - -.ph-face-mask-bold::before { - content: "\f7e3"; -} - -.ph-facebook-logo-bold::before { - content: "\f7e4"; -} - -.ph-factory-bold::before { - content: "\f7e5"; -} - -.ph-faders-bold::before { - content: "\f7e6"; -} - -.ph-faders-horizontal-bold::before { - content: "\f7e7"; -} - -.ph-fast-forward-bold::before { - content: "\f7e8"; -} - -.ph-fast-forward-circle-bold::before { - content: "\f7e9"; -} - -.ph-figma-logo-bold::before { - content: "\f7ea"; -} - -.ph-file-arrow-down-bold::before { - content: "\f7eb"; -} - -.ph-file-arrow-up-bold::before { - content: "\f7ec"; -} - -.ph-file-audio-bold::before { - content: "\f7ed"; -} - -.ph-file-bold::before { - content: "\f7ee"; -} - -.ph-file-cloud-bold::before { - content: "\f7ef"; -} - -.ph-file-code-bold::before { - content: "\f7f0"; -} - -.ph-file-css-bold::before { - content: "\f7f1"; -} - -.ph-file-csv-bold::before { - content: "\f7f2"; -} - -.ph-file-doc-bold::before { - content: "\f7f3"; -} - -.ph-file-dotted-bold::before { - content: "\f7f4"; -} - -.ph-file-html-bold::before { - content: "\f7f5"; -} - -.ph-file-image-bold::before { - content: "\f7f6"; -} - -.ph-file-jpg-bold::before { - content: "\f7f7"; -} - -.ph-file-js-bold::before { - content: "\f7f8"; -} - -.ph-file-jsx-bold::before { - content: "\f7f9"; -} - -.ph-file-lock-bold::before { - content: "\f7fa"; -} - -.ph-file-minus-bold::before { - content: "\f7fb"; -} - -.ph-file-pdf-bold::before { - content: "\f7fc"; -} - -.ph-file-plus-bold::before { - content: "\f7fd"; -} - -.ph-file-png-bold::before { - content: "\f7fe"; -} - -.ph-file-ppt-bold::before { - content: "\f7ff"; -} - -.ph-file-rs-bold::before { - content: "\f800"; -} - -.ph-file-search-bold::before { - content: "\f801"; -} - -.ph-file-text-bold::before { - content: "\f802"; -} - -.ph-file-ts-bold::before { - content: "\f803"; -} - -.ph-file-tsx-bold::before { - content: "\f804"; -} - -.ph-file-video-bold::before { - content: "\f805"; -} - -.ph-file-vue-bold::before { - content: "\f806"; -} - -.ph-file-x-bold::before { - content: "\f807"; -} - -.ph-file-xls-bold::before { - content: "\f808"; -} - -.ph-file-zip-bold::before { - content: "\f809"; -} - -.ph-files-bold::before { - content: "\f80a"; -} - -.ph-film-script-bold::before { - content: "\f80b"; -} - -.ph-film-slate-bold::before { - content: "\f80c"; -} - -.ph-film-strip-bold::before { - content: "\f80d"; -} - -.ph-fingerprint-bold::before { - content: "\f80e"; -} - -.ph-fingerprint-simple-bold::before { - content: "\f80f"; -} - -.ph-finn-the-human-bold::before { - content: "\f810"; -} - -.ph-fire-bold::before { - content: "\f811"; -} - -.ph-fire-simple-bold::before { - content: "\f812"; -} - -.ph-first-aid-bold::before { - content: "\f813"; -} - -.ph-first-aid-kit-bold::before { - content: "\f814"; -} - -.ph-fish-bold::before { - content: "\f815"; -} - -.ph-fish-simple-bold::before { - content: "\f816"; -} - -.ph-flag-banner-bold::before { - content: "\f817"; -} - -.ph-flag-bold::before { - content: "\f818"; -} - -.ph-flag-checkered-bold::before { - content: "\f819"; -} - -.ph-flame-bold::before { - content: "\f81a"; -} - -.ph-flashlight-bold::before { - content: "\f81b"; -} - -.ph-flask-bold::before { - content: "\f81c"; -} - -.ph-floppy-disk-back-bold::before { - content: "\f81d"; -} - -.ph-floppy-disk-bold::before { - content: "\f81e"; -} - -.ph-flow-arrow-bold::before { - content: "\f81f"; -} - -.ph-flower-bold::before { - content: "\f820"; -} - -.ph-flower-lotus-bold::before { - content: "\f821"; -} - -.ph-flying-saucer-bold::before { - content: "\f822"; -} - -.ph-folder-bold::before { - content: "\f823"; -} - -.ph-folder-dotted-bold::before { - content: "\f824"; -} - -.ph-folder-lock-bold::before { - content: "\f825"; -} - -.ph-folder-minus-bold::before { - content: "\f826"; -} - -.ph-folder-notch-bold::before { - content: "\f827"; -} - -.ph-folder-notch-minus-bold::before { - content: "\f828"; -} - -.ph-folder-notch-open-bold::before { - content: "\f829"; -} - -.ph-folder-notch-plus-bold::before { - content: "\f82a"; -} - -.ph-folder-open-bold::before { - content: "\f82b"; -} - -.ph-folder-plus-bold::before { - content: "\f82c"; -} - -.ph-folder-simple-bold::before { - content: "\f82d"; -} - -.ph-folder-simple-dotted-bold::before { - content: "\f82e"; -} - -.ph-folder-simple-lock-bold::before { - content: "\f82f"; -} - -.ph-folder-simple-minus-bold::before { - content: "\f830"; -} - -.ph-folder-simple-plus-bold::before { - content: "\f831"; -} - -.ph-folder-simple-star-bold::before { - content: "\f832"; -} - -.ph-folder-simple-user-bold::before { - content: "\f833"; -} - -.ph-folder-star-bold::before { - content: "\f834"; -} - -.ph-folder-user-bold::before { - content: "\f835"; -} - -.ph-folders-bold::before { - content: "\f836"; -} - -.ph-football-bold::before { - content: "\f837"; -} - -.ph-fork-knife-bold::before { - content: "\f838"; -} - -.ph-frame-corners-bold::before { - content: "\f839"; -} - -.ph-framer-logo-bold::before { - content: "\f83a"; -} - -.ph-function-bold::before { - content: "\f83b"; -} - -.ph-funnel-bold::before { - content: "\f83c"; -} - -.ph-funnel-simple-bold::before { - content: "\f83d"; -} - -.ph-game-controller-bold::before { - content: "\f83e"; -} - -.ph-gas-pump-bold::before { - content: "\f83f"; -} - -.ph-gauge-bold::before { - content: "\f840"; -} - -.ph-gear-bold::before { - content: "\f841"; -} - -.ph-gear-six-bold::before { - content: "\f842"; -} - -.ph-gender-female-bold::before { - content: "\f843"; -} - -.ph-gender-intersex-bold::before { - content: "\f844"; -} - -.ph-gender-male-bold::before { - content: "\f845"; -} - -.ph-gender-neuter-bold::before { - content: "\f846"; -} - -.ph-gender-nonbinary-bold::before { - content: "\f847"; -} - -.ph-gender-transgender-bold::before { - content: "\f848"; -} - -.ph-ghost-bold::before { - content: "\f849"; -} - -.ph-gif-bold::before { - content: "\f84a"; -} - -.ph-gift-bold::before { - content: "\f84b"; -} - -.ph-git-branch-bold::before { - content: "\f84c"; -} - -.ph-git-commit-bold::before { - content: "\f84d"; -} - -.ph-git-diff-bold::before { - content: "\f84e"; -} - -.ph-git-fork-bold::before { - content: "\f84f"; -} - -.ph-git-merge-bold::before { - content: "\f850"; -} - -.ph-git-pull-request-bold::before { - content: "\f851"; -} - -.ph-github-logo-bold::before { - content: "\f852"; -} - -.ph-gitlab-logo-bold::before { - content: "\f853"; -} - -.ph-gitlab-logo-simple-bold::before { - content: "\f854"; -} - -.ph-globe-bold::before { - content: "\f855"; -} - -.ph-globe-hemisphere-east-bold::before { - content: "\f856"; -} - -.ph-globe-hemisphere-west-bold::before { - content: "\f857"; -} - -.ph-globe-simple-bold::before { - content: "\f858"; -} - -.ph-globe-stand-bold::before { - content: "\f859"; -} - -.ph-google-chrome-logo-bold::before { - content: "\f85a"; -} - -.ph-google-logo-bold::before { - content: "\f85b"; -} - -.ph-google-photos-logo-bold::before { - content: "\f85c"; -} - -.ph-google-play-logo-bold::before { - content: "\f85d"; -} - -.ph-google-podcasts-logo-bold::before { - content: "\f85e"; -} - -.ph-gradient-bold::before { - content: "\f85f"; -} - -.ph-graduation-cap-bold::before { - content: "\f860"; -} - -.ph-graph-bold::before { - content: "\f861"; -} - -.ph-grid-four-bold::before { - content: "\f862"; -} - -.ph-hamburger-bold::before { - content: "\f863"; -} - -.ph-hand-bold::before { - content: "\f864"; -} - -.ph-hand-eye-bold::before { - content: "\f865"; -} - -.ph-hand-fist-bold::before { - content: "\f866"; -} - -.ph-hand-grabbing-bold::before { - content: "\f867"; -} - -.ph-hand-palm-bold::before { - content: "\f868"; -} - -.ph-hand-pointing-bold::before { - content: "\f869"; -} - -.ph-hand-soap-bold::before { - content: "\f86a"; -} - -.ph-hand-waving-bold::before { - content: "\f86b"; -} - -.ph-handbag-bold::before { - content: "\f86c"; -} - -.ph-handbag-simple-bold::before { - content: "\f86d"; -} - -.ph-hands-clapping-bold::before { - content: "\f86e"; -} - -.ph-handshake-bold::before { - content: "\f86f"; -} - -.ph-hard-drive-bold::before { - content: "\f870"; -} - -.ph-hard-drives-bold::before { - content: "\f871"; -} - -.ph-hash-bold::before { - content: "\f872"; -} - -.ph-hash-straight-bold::before { - content: "\f873"; -} - -.ph-headlights-bold::before { - content: "\f874"; -} - -.ph-headphones-bold::before { - content: "\f875"; -} - -.ph-headset-bold::before { - content: "\f876"; -} - -.ph-heart-bold::before { - content: "\f877"; -} - -.ph-heart-break-bold::before { - content: "\f878"; -} - -.ph-heart-straight-bold::before { - content: "\f879"; -} - -.ph-heart-straight-break-bold::before { - content: "\f87a"; -} - -.ph-heartbeat-bold::before { - content: "\f87b"; -} - -.ph-hexagon-bold::before { - content: "\f87c"; -} - -.ph-highlighter-circle-bold::before { - content: "\f87d"; -} - -.ph-horse-bold::before { - content: "\f87e"; -} - -.ph-hourglass-bold::before { - content: "\f87f"; -} - -.ph-hourglass-high-bold::before { - content: "\f880"; -} - -.ph-hourglass-low-bold::before { - content: "\f881"; -} - -.ph-hourglass-medium-bold::before { - content: "\f882"; -} - -.ph-hourglass-simple-bold::before { - content: "\f883"; -} - -.ph-hourglass-simple-high-bold::before { - content: "\f884"; -} - -.ph-hourglass-simple-low-bold::before { - content: "\f885"; -} - -.ph-hourglass-simple-medium-bold::before { - content: "\f886"; -} - -.ph-house-bold::before { - content: "\f887"; -} - -.ph-house-line-bold::before { - content: "\f888"; -} - -.ph-house-simple-bold::before { - content: "\f889"; -} - -.ph-identification-badge-bold::before { - content: "\f88a"; -} - -.ph-identification-card-bold::before { - content: "\f88b"; -} - -.ph-image-bold::before { - content: "\f88c"; -} - -.ph-image-square-bold::before { - content: "\f88d"; -} - -.ph-infinity-bold::before { - content: "\f88e"; -} - -.ph-info-bold::before { - content: "\f88f"; -} - -.ph-instagram-logo-bold::before { - content: "\f890"; -} - -.ph-intersect-bold::before { - content: "\f891"; -} - -.ph-jeep-bold::before { - content: "\f892"; -} - -.ph-kanban-bold::before { - content: "\f893"; -} - -.ph-key-bold::before { - content: "\f894"; -} - -.ph-key-return-bold::before { - content: "\f895"; -} - -.ph-keyboard-bold::before { - content: "\f896"; -} - -.ph-keyhole-bold::before { - content: "\f897"; -} - -.ph-knife-bold::before { - content: "\f898"; -} - -.ph-ladder-bold::before { - content: "\f899"; -} - -.ph-ladder-simple-bold::before { - content: "\f89a"; -} - -.ph-lamp-bold::before { - content: "\f89b"; -} - -.ph-laptop-bold::before { - content: "\f89c"; -} - -.ph-layout-bold::before { - content: "\f89d"; -} - -.ph-leaf-bold::before { - content: "\f89e"; -} - -.ph-lifebuoy-bold::before { - content: "\f89f"; -} - -.ph-lightbulb-bold::before { - content: "\f8a0"; -} - -.ph-lightbulb-filament-bold::before { - content: "\f8a1"; -} - -.ph-lightning-bold::before { - content: "\f8a2"; -} - -.ph-lightning-slash-bold::before { - content: "\f8a3"; -} - -.ph-line-segment-bold::before { - content: "\f8a4"; -} - -.ph-line-segments-bold::before { - content: "\f8a5"; -} - -.ph-link-bold::before { - content: "\f8a6"; -} - -.ph-link-break-bold::before { - content: "\f8a7"; -} - -.ph-link-simple-bold::before { - content: "\f8a8"; -} - -.ph-link-simple-break-bold::before { - content: "\f8a9"; -} - -.ph-link-simple-horizontal-bold::before { - content: "\f8aa"; -} - -.ph-link-simple-horizontal-break-bold::before { - content: "\f8ab"; -} - -.ph-linkedin-logo-bold::before { - content: "\f8ac"; -} - -.ph-linux-logo-bold::before { - content: "\f8ad"; -} - -.ph-list-bold::before { - content: "\f8ae"; -} - -.ph-list-bullets-bold::before { - content: "\f8af"; -} - -.ph-list-checks-bold::before { - content: "\f8b0"; -} - -.ph-list-dashes-bold::before { - content: "\f8b1"; -} - -.ph-list-numbers-bold::before { - content: "\f8b2"; -} - -.ph-list-plus-bold::before { - content: "\f8b3"; -} - -.ph-lock-bold::before { - content: "\f8b4"; -} - -.ph-lock-key-bold::before { - content: "\f8b5"; -} - -.ph-lock-key-open-bold::before { - content: "\f8b6"; -} - -.ph-lock-laminated-bold::before { - content: "\f8b7"; -} - -.ph-lock-laminated-open-bold::before { - content: "\f8b8"; -} - -.ph-lock-open-bold::before { - content: "\f8b9"; -} - -.ph-lock-simple-bold::before { - content: "\f8ba"; -} - -.ph-lock-simple-open-bold::before { - content: "\f8bb"; -} - -.ph-magic-wand-bold::before { - content: "\f8bc"; -} - -.ph-magnet-bold::before { - content: "\f8bd"; -} - -.ph-magnet-straight-bold::before { - content: "\f8be"; -} - -.ph-magnifying-glass-bold::before { - content: "\f8bf"; -} - -.ph-magnifying-glass-minus-bold::before { - content: "\f8c0"; -} - -.ph-magnifying-glass-plus-bold::before { - content: "\f8c1"; -} - -.ph-map-pin-bold::before { - content: "\f8c2"; -} - -.ph-map-pin-line-bold::before { - content: "\f8c3"; -} - -.ph-map-trifold-bold::before { - content: "\f8c4"; -} - -.ph-marker-circle-bold::before { - content: "\f8c5"; -} - -.ph-martini-bold::before { - content: "\f8c6"; -} - -.ph-mask-happy-bold::before { - content: "\f8c7"; -} - -.ph-mask-sad-bold::before { - content: "\f8c8"; -} - -.ph-math-operations-bold::before { - content: "\f8c9"; -} - -.ph-medal-bold::before { - content: "\f8ca"; -} - -.ph-medium-logo-bold::before { - content: "\f8cb"; -} - -.ph-megaphone-bold::before { - content: "\f8cc"; -} - -.ph-megaphone-simple-bold::before { - content: "\f8cd"; -} - -.ph-messenger-logo-bold::before { - content: "\f8ce"; -} - -.ph-microphone-bold::before { - content: "\f8cf"; -} - -.ph-microphone-slash-bold::before { - content: "\f8d0"; -} - -.ph-microphone-stage-bold::before { - content: "\f8d1"; -} - -.ph-microsoft-excel-logo-bold::before { - content: "\f8d2"; -} - -.ph-microsoft-powerpoint-logo-bold::before { - content: "\f8d3"; -} - -.ph-microsoft-teams-logo-bold::before { - content: "\f8d4"; -} - -.ph-microsoft-word-logo-bold::before { - content: "\f8d5"; -} - -.ph-minus-bold::before { - content: "\f8d6"; -} - -.ph-minus-circle-bold::before { - content: "\f8d7"; -} - -.ph-money-bold::before { - content: "\f8d8"; -} - -.ph-monitor-bold::before { - content: "\f8d9"; -} - -.ph-monitor-play-bold::before { - content: "\f8da"; -} - -.ph-moon-bold::before { - content: "\f8db"; -} - -.ph-moon-stars-bold::before { - content: "\f8dc"; -} - -.ph-mountains-bold::before { - content: "\f8dd"; -} - -.ph-mouse-bold::before { - content: "\f8de"; -} - -.ph-mouse-simple-bold::before { - content: "\f8df"; -} - -.ph-music-note-bold::before { - content: "\f8e0"; -} - -.ph-music-note-simple-bold::before { - content: "\f8e1"; -} - -.ph-music-notes-bold::before { - content: "\f8e2"; -} - -.ph-music-notes-plus-bold::before { - content: "\f8e3"; -} - -.ph-music-notes-simple-bold::before { - content: "\f8e4"; -} - -.ph-navigation-arrow-bold::before { - content: "\f8e5"; -} - -.ph-needle-bold::before { - content: "\f8e6"; -} - -.ph-newspaper-bold::before { - content: "\f8e7"; -} - -.ph-newspaper-clipping-bold::before { - content: "\f8e8"; -} - -.ph-note-blank-bold::before { - content: "\f8e9"; -} - -.ph-note-bold::before { - content: "\f8ea"; -} - -.ph-note-pencil-bold::before { - content: "\f8eb"; -} - -.ph-notebook-bold::before { - content: "\f8ec"; -} - -.ph-notepad-bold::before { - content: "\f8ed"; -} - -.ph-notification-bold::before { - content: "\f8ee"; -} - -.ph-number-circle-eight-bold::before { - content: "\f8ef"; -} - -.ph-number-circle-five-bold::before { - content: "\f8f0"; -} - -.ph-number-circle-four-bold::before { - content: "\f8f1"; -} - -.ph-number-circle-nine-bold::before { - content: "\f8f2"; -} - -.ph-number-circle-one-bold::before { - content: "\f8f3"; -} - -.ph-number-circle-seven-bold::before { - content: "\f8f4"; -} - -.ph-number-circle-six-bold::before { - content: "\f8f5"; -} - -.ph-number-circle-three-bold::before { - content: "\f8f6"; -} - -.ph-number-circle-two-bold::before { - content: "\f8f7"; -} - -.ph-number-circle-zero-bold::before { - content: "\f8f8"; -} - -.ph-number-eight-bold::before { - content: "\f8f9"; -} - -.ph-number-five-bold::before { - content: "\f8fa"; -} - -.ph-number-four-bold::before { - content: "\f8fb"; -} - -.ph-number-nine-bold::before { - content: "\f8fc"; -} - -.ph-number-one-bold::before { - content: "\f8fd"; -} - -.ph-number-seven-bold::before { - content: "\f8fe"; -} - -.ph-number-six-bold::before { - content: "\f8ff"; -} - -.ph-number-square-eight-bold::before { - content: "\f900"; -} - -.ph-number-square-five-bold::before { - content: "\f901"; -} - -.ph-number-square-four-bold::before { - content: "\f902"; -} - -.ph-number-square-nine-bold::before { - content: "\f903"; -} - -.ph-number-square-one-bold::before { - content: "\f904"; -} - -.ph-number-square-seven-bold::before { - content: "\f905"; -} - -.ph-number-square-six-bold::before { - content: "\f906"; -} - -.ph-number-square-three-bold::before { - content: "\f907"; -} - -.ph-number-square-two-bold::before { - content: "\f908"; -} - -.ph-number-square-zero-bold::before { - content: "\f909"; -} - -.ph-number-three-bold::before { - content: "\f90a"; -} - -.ph-number-two-bold::before { - content: "\f90b"; -} - -.ph-number-zero-bold::before { - content: "\f90c"; -} - -.ph-nut-bold::before { - content: "\f90d"; -} - -.ph-ny-times-logo-bold::before { - content: "\f90e"; -} - -.ph-octagon-bold::before { - content: "\f90f"; -} - -.ph-option-bold::before { - content: "\f910"; -} - -.ph-package-bold::before { - content: "\f911"; -} - -.ph-paint-brush-bold::before { - content: "\f912"; -} - -.ph-paint-brush-broad-bold::before { - content: "\f913"; -} - -.ph-paint-brush-household-bold::before { - content: "\f914"; -} - -.ph-paint-bucket-bold::before { - content: "\f915"; -} - -.ph-paint-roller-bold::before { - content: "\f916"; -} - -.ph-palette-bold::before { - content: "\f917"; -} - -.ph-paper-plane-bold::before { - content: "\f918"; -} - -.ph-paper-plane-right-bold::before { - content: "\f919"; -} - -.ph-paper-plane-tilt-bold::before { - content: "\f91a"; -} - -.ph-paperclip-bold::before { - content: "\f91b"; -} - -.ph-paperclip-horizontal-bold::before { - content: "\f91c"; -} - -.ph-parachute-bold::before { - content: "\f91d"; -} - -.ph-password-bold::before { - content: "\f91e"; -} - -.ph-path-bold::before { - content: "\f91f"; -} - -.ph-pause-bold::before { - content: "\f920"; -} - -.ph-pause-circle-bold::before { - content: "\f921"; -} - -.ph-paw-print-bold::before { - content: "\f922"; -} - -.ph-peace-bold::before { - content: "\f923"; -} - -.ph-pen-bold::before { - content: "\f924"; -} - -.ph-pen-nib-bold::before { - content: "\f925"; -} - -.ph-pen-nib-straight-bold::before { - content: "\f926"; -} - -.ph-pencil-bold::before { - content: "\f927"; -} - -.ph-pencil-circle-bold::before { - content: "\f928"; -} - -.ph-pencil-line-bold::before { - content: "\f929"; -} - -.ph-pencil-simple-bold::before { - content: "\f92a"; -} - -.ph-pencil-simple-line-bold::before { - content: "\f92b"; -} - -.ph-percent-bold::before { - content: "\f92c"; -} - -.ph-person-bold::before { - content: "\f92d"; -} - -.ph-person-simple-bold::before { - content: "\f92e"; -} - -.ph-person-simple-run-bold::before { - content: "\f92f"; -} - -.ph-person-simple-walk-bold::before { - content: "\f930"; -} - -.ph-perspective-bold::before { - content: "\f931"; -} - -.ph-phone-bold::before { - content: "\f932"; -} - -.ph-phone-call-bold::before { - content: "\f933"; -} - -.ph-phone-disconnect-bold::before { - content: "\f934"; -} - -.ph-phone-incoming-bold::before { - content: "\f935"; -} - -.ph-phone-outgoing-bold::before { - content: "\f936"; -} - -.ph-phone-slash-bold::before { - content: "\f937"; -} - -.ph-phone-x-bold::before { - content: "\f938"; -} - -.ph-phosphor-logo-bold::before { - content: "\f939"; -} - -.ph-piano-keys-bold::before { - content: "\f93a"; -} - -.ph-picture-in-picture-bold::before { - content: "\f93b"; -} - -.ph-pill-bold::before { - content: "\f93c"; -} - -.ph-pinterest-logo-bold::before { - content: "\f93d"; -} - -.ph-pinwheel-bold::before { - content: "\f93e"; -} - -.ph-pizza-bold::before { - content: "\f93f"; -} - -.ph-placeholder-bold::before { - content: "\f940"; -} - -.ph-planet-bold::before { - content: "\f941"; -} - -.ph-play-bold::before { - content: "\f942"; -} - -.ph-play-circle-bold::before { - content: "\f943"; -} - -.ph-playlist-bold::before { - content: "\f944"; -} - -.ph-plug-bold::before { - content: "\f945"; -} - -.ph-plugs-bold::before { - content: "\f946"; -} - -.ph-plugs-connected-bold::before { - content: "\f947"; -} - -.ph-plus-bold::before { - content: "\f948"; -} - -.ph-plus-circle-bold::before { - content: "\f949"; -} - -.ph-plus-minus-bold::before { - content: "\f94a"; -} - -.ph-poker-chip-bold::before { - content: "\f94b"; -} - -.ph-police-car-bold::before { - content: "\f94c"; -} - -.ph-polygon-bold::before { - content: "\f94d"; -} - -.ph-popcorn-bold::before { - content: "\f94e"; -} - -.ph-power-bold::before { - content: "\f94f"; -} - -.ph-prescription-bold::before { - content: "\f950"; -} - -.ph-presentation-bold::before { - content: "\f951"; -} - -.ph-presentation-chart-bold::before { - content: "\f952"; -} - -.ph-printer-bold::before { - content: "\f953"; -} - -.ph-prohibit-bold::before { - content: "\f954"; -} - -.ph-prohibit-inset-bold::before { - content: "\f955"; -} - -.ph-projector-screen-bold::before { - content: "\f956"; -} - -.ph-projector-screen-chart-bold::before { - content: "\f957"; -} - -.ph-push-pin-bold::before { - content: "\f958"; -} - -.ph-push-pin-simple-bold::before { - content: "\f959"; -} - -.ph-push-pin-simple-slash-bold::before { - content: "\f95a"; -} - -.ph-push-pin-slash-bold::before { - content: "\f95b"; -} - -.ph-puzzle-piece-bold::before { - content: "\f95c"; -} - -.ph-qr-code-bold::before { - content: "\f95d"; -} - -.ph-question-bold::before { - content: "\f95e"; -} - -.ph-queue-bold::before { - content: "\f95f"; -} - -.ph-quotes-bold::before { - content: "\f960"; -} - -.ph-radical-bold::before { - content: "\f961"; -} - -.ph-radio-bold::before { - content: "\f962"; -} - -.ph-radio-button-bold::before { - content: "\f963"; -} - -.ph-rainbow-bold::before { - content: "\f964"; -} - -.ph-rainbow-cloud-bold::before { - content: "\f965"; -} - -.ph-receipt-bold::before { - content: "\f966"; -} - -.ph-record-bold::before { - content: "\f967"; -} - -.ph-rectangle-bold::before { - content: "\f968"; -} - -.ph-recycle-bold::before { - content: "\f969"; -} - -.ph-reddit-logo-bold::before { - content: "\f96a"; -} - -.ph-repeat-bold::before { - content: "\f96b"; -} - -.ph-repeat-once-bold::before { - content: "\f96c"; -} - -.ph-rewind-bold::before { - content: "\f96d"; -} - -.ph-rewind-circle-bold::before { - content: "\f96e"; -} - -.ph-robot-bold::before { - content: "\f96f"; -} - -.ph-rocket-bold::before { - content: "\f970"; -} - -.ph-rocket-launch-bold::before { - content: "\f971"; -} - -.ph-rows-bold::before { - content: "\f972"; -} - -.ph-rss-bold::before { - content: "\f973"; -} - -.ph-rss-simple-bold::before { - content: "\f974"; -} - -.ph-rug-bold::before { - content: "\f975"; -} - -.ph-ruler-bold::before { - content: "\f976"; -} - -.ph-scales-bold::before { - content: "\f977"; -} - -.ph-scan-bold::before { - content: "\f978"; -} - -.ph-scissors-bold::before { - content: "\f979"; -} - -.ph-screencast-bold::before { - content: "\f97a"; -} - -.ph-scribble-loop-bold::before { - content: "\f97b"; -} - -.ph-scroll-bold::before { - content: "\f97c"; -} - -.ph-selection-all-bold::before { - content: "\f97d"; -} - -.ph-selection-background-bold::before { - content: "\f97e"; -} - -.ph-selection-bold::before { - content: "\f97f"; -} - -.ph-selection-foreground-bold::before { - content: "\f980"; -} - -.ph-selection-inverse-bold::before { - content: "\f981"; -} - -.ph-selection-plus-bold::before { - content: "\f982"; -} - -.ph-selection-slash-bold::before { - content: "\f983"; -} - -.ph-share-bold::before { - content: "\f984"; -} - -.ph-share-network-bold::before { - content: "\f985"; -} - -.ph-shield-bold::before { - content: "\f986"; -} - -.ph-shield-check-bold::before { - content: "\f987"; -} - -.ph-shield-checkered-bold::before { - content: "\f988"; -} - -.ph-shield-chevron-bold::before { - content: "\f989"; -} - -.ph-shield-plus-bold::before { - content: "\f98a"; -} - -.ph-shield-slash-bold::before { - content: "\f98b"; -} - -.ph-shield-star-bold::before { - content: "\f98c"; -} - -.ph-shield-warning-bold::before { - content: "\f98d"; -} - -.ph-shopping-bag-bold::before { - content: "\f98e"; -} - -.ph-shopping-bag-open-bold::before { - content: "\f98f"; -} - -.ph-shopping-cart-bold::before { - content: "\f990"; -} - -.ph-shopping-cart-simple-bold::before { - content: "\f991"; -} - -.ph-shower-bold::before { - content: "\f992"; -} - -.ph-shuffle-angular-bold::before { - content: "\f993"; -} - -.ph-shuffle-bold::before { - content: "\f994"; -} - -.ph-shuffle-simple-bold::before { - content: "\f995"; -} - -.ph-sidebar-bold::before { - content: "\f996"; -} - -.ph-sidebar-simple-bold::before { - content: "\f997"; -} - -.ph-sign-in-bold::before { - content: "\f998"; -} - -.ph-sign-out-bold::before { - content: "\f999"; -} - -.ph-signpost-bold::before { - content: "\f99a"; -} - -.ph-sim-card-bold::before { - content: "\f99b"; -} - -.ph-sketch-logo-bold::before { - content: "\f99c"; -} - -.ph-skip-back-bold::before { - content: "\f99d"; -} - -.ph-skip-back-circle-bold::before { - content: "\f99e"; -} - -.ph-skip-forward-bold::before { - content: "\f99f"; -} - -.ph-skip-forward-circle-bold::before { - content: "\f9a0"; -} - -.ph-skull-bold::before { - content: "\f9a1"; -} - -.ph-slack-logo-bold::before { - content: "\f9a2"; -} - -.ph-sliders-bold::before { - content: "\f9a3"; -} - -.ph-sliders-horizontal-bold::before { - content: "\f9a4"; -} - -.ph-smiley-blank-bold::before { - content: "\f9a5"; -} - -.ph-smiley-bold::before { - content: "\f9a6"; -} - -.ph-smiley-meh-bold::before { - content: "\f9a7"; -} - -.ph-smiley-nervous-bold::before { - content: "\f9a8"; -} - -.ph-smiley-sad-bold::before { - content: "\f9a9"; -} - -.ph-smiley-sticker-bold::before { - content: "\f9aa"; -} - -.ph-smiley-wink-bold::before { - content: "\f9ab"; -} - -.ph-smiley-x-eyes-bold::before { - content: "\f9ac"; -} - -.ph-snapchat-logo-bold::before { - content: "\f9ad"; -} - -.ph-snowflake-bold::before { - content: "\f9ae"; -} - -.ph-soccer-ball-bold::before { - content: "\f9af"; -} - -.ph-sort-ascending-bold::before { - content: "\f9b0"; -} - -.ph-sort-descending-bold::before { - content: "\f9b1"; -} - -.ph-spade-bold::before { - content: "\f9b2"; -} - -.ph-sparkle-bold::before { - content: "\f9b3"; -} - -.ph-speaker-high-bold::before { - content: "\f9b4"; -} - -.ph-speaker-low-bold::before { - content: "\f9b5"; -} - -.ph-speaker-none-bold::before { - content: "\f9b6"; -} - -.ph-speaker-simple-high-bold::before { - content: "\f9b7"; -} - -.ph-speaker-simple-low-bold::before { - content: "\f9b8"; -} - -.ph-speaker-simple-none-bold::before { - content: "\f9b9"; -} - -.ph-speaker-simple-slash-bold::before { - content: "\f9ba"; -} - -.ph-speaker-simple-x-bold::before { - content: "\f9bb"; -} - -.ph-speaker-slash-bold::before { - content: "\f9bc"; -} - -.ph-speaker-x-bold::before { - content: "\f9bd"; -} - -.ph-spinner-bold::before { - content: "\f9be"; -} - -.ph-spinner-gap-bold::before { - content: "\f9bf"; -} - -.ph-spiral-bold::before { - content: "\f9c0"; -} - -.ph-spotify-logo-bold::before { - content: "\f9c1"; -} - -.ph-square-bold::before { - content: "\f9c2"; -} - -.ph-square-half-bold::before { - content: "\f9c3"; -} - -.ph-square-half-bottom-bold::before { - content: "\f9c4"; -} - -.ph-square-logo-bold::before { - content: "\f9c5"; -} - -.ph-squares-four-bold::before { - content: "\f9c6"; -} - -.ph-stack-bold::before { - content: "\f9c7"; -} - -.ph-stack-overflow-logo-bold::before { - content: "\f9c8"; -} - -.ph-stack-simple-bold::before { - content: "\f9c9"; -} - -.ph-stamp-bold::before { - content: "\f9ca"; -} - -.ph-star-bold::before { - content: "\f9cb"; -} - -.ph-star-four-bold::before { - content: "\f9cc"; -} - -.ph-star-half-bold::before { - content: "\f9cd"; -} - -.ph-sticker-bold::before { - content: "\f9ce"; -} - -.ph-stop-bold::before { - content: "\f9cf"; -} - -.ph-stop-circle-bold::before { - content: "\f9d0"; -} - -.ph-storefront-bold::before { - content: "\f9d1"; -} - -.ph-strategy-bold::before { - content: "\f9d2"; -} - -.ph-stripe-logo-bold::before { - content: "\f9d3"; -} - -.ph-student-bold::before { - content: "\f9d4"; -} - -.ph-suitcase-bold::before { - content: "\f9d5"; -} - -.ph-suitcase-simple-bold::before { - content: "\f9d6"; -} - -.ph-sun-bold::before { - content: "\f9d7"; -} - -.ph-sun-dim-bold::before { - content: "\f9d8"; -} - -.ph-sun-horizon-bold::before { - content: "\f9d9"; -} - -.ph-sunglasses-bold::before { - content: "\f9da"; -} - -.ph-swap-bold::before { - content: "\f9db"; -} - -.ph-swatches-bold::before { - content: "\f9dc"; -} - -.ph-sword-bold::before { - content: "\f9dd"; -} - -.ph-syringe-bold::before { - content: "\f9de"; -} - -.ph-t-shirt-bold::before { - content: "\f9df"; -} - -.ph-table-bold::before { - content: "\f9e0"; -} - -.ph-tabs-bold::before { - content: "\f9e1"; -} - -.ph-tag-bold::before { - content: "\f9e2"; -} - -.ph-tag-chevron-bold::before { - content: "\f9e3"; -} - -.ph-tag-simple-bold::before { - content: "\f9e4"; -} - -.ph-target-bold::before { - content: "\f9e5"; -} - -.ph-taxi-bold::before { - content: "\f9e6"; -} - -.ph-telegram-logo-bold::before { - content: "\f9e7"; -} - -.ph-television-bold::before { - content: "\f9e8"; -} - -.ph-television-simple-bold::before { - content: "\f9e9"; -} - -.ph-tennis-ball-bold::before { - content: "\f9ea"; -} - -.ph-terminal-bold::before { - content: "\f9eb"; -} - -.ph-terminal-window-bold::before { - content: "\f9ec"; -} - -.ph-test-tube-bold::before { - content: "\f9ed"; -} - -.ph-text-aa-bold::before { - content: "\f9ee"; -} - -.ph-text-align-center-bold::before { - content: "\f9ef"; -} - -.ph-text-align-justify-bold::before { - content: "\f9f0"; -} - -.ph-text-align-left-bold::before { - content: "\f9f1"; -} - -.ph-text-align-right-bold::before { - content: "\f9f2"; -} - -.ph-text-bolder-bold::before { - content: "\f9f3"; -} - -.ph-text-h-bold::before { - content: "\f9f4"; -} - -.ph-text-h-five-bold::before { - content: "\f9f5"; -} - -.ph-text-h-four-bold::before { - content: "\f9f6"; -} - -.ph-text-h-one-bold::before { - content: "\f9f7"; -} - -.ph-text-h-six-bold::before { - content: "\f9f8"; -} - -.ph-text-h-three-bold::before { - content: "\f9f9"; -} - -.ph-text-h-two-bold::before { - content: "\f9fa"; -} - -.ph-text-indent-bold::before { - content: "\f9fb"; -} - -.ph-text-italic-bold::before { - content: "\f9fc"; -} - -.ph-text-outdent-bold::before { - content: "\f9fd"; -} - -.ph-text-strikethrough-bold::before { - content: "\f9fe"; -} - -.ph-text-t-bold::before { - content: "\f9ff"; -} - -.ph-text-underline-bold::before { - content: "\fa00"; -} - -.ph-textbox-bold::before { - content: "\fa01"; -} - -.ph-thermometer-bold::before { - content: "\fa02"; -} - -.ph-thermometer-cold-bold::before { - content: "\fa03"; -} - -.ph-thermometer-hot-bold::before { - content: "\fa04"; -} - -.ph-thermometer-simple-bold::before { - content: "\fa05"; -} - -.ph-thumbs-down-bold::before { - content: "\fa06"; -} - -.ph-thumbs-up-bold::before { - content: "\fa07"; -} - -.ph-ticket-bold::before { - content: "\fa08"; -} - -.ph-tiktok-logo-bold::before { - content: "\fa09"; -} - -.ph-timer-bold::before { - content: "\fa0a"; -} - -.ph-toggle-left-bold::before { - content: "\fa0b"; -} - -.ph-toggle-right-bold::before { - content: "\fa0c"; -} - -.ph-toilet-bold::before { - content: "\fa0d"; -} - -.ph-toilet-paper-bold::before { - content: "\fa0e"; -} - -.ph-tote-bold::before { - content: "\fa0f"; -} - -.ph-tote-simple-bold::before { - content: "\fa10"; -} - -.ph-trademark-registered-bold::before { - content: "\fa11"; -} - -.ph-traffic-cone-bold::before { - content: "\fa12"; -} - -.ph-traffic-sign-bold::before { - content: "\fa13"; -} - -.ph-traffic-signal-bold::before { - content: "\fa14"; -} - -.ph-train-bold::before { - content: "\fa15"; -} - -.ph-train-regional-bold::before { - content: "\fa16"; -} - -.ph-train-simple-bold::before { - content: "\fa17"; -} - -.ph-translate-bold::before { - content: "\fa18"; -} - -.ph-trash-bold::before { - content: "\fa19"; -} - -.ph-trash-simple-bold::before { - content: "\fa1a"; -} - -.ph-tray-bold::before { - content: "\fa1b"; -} - -.ph-tree-bold::before { - content: "\fa1c"; -} - -.ph-tree-evergreen-bold::before { - content: "\fa1d"; -} - -.ph-tree-structure-bold::before { - content: "\fa1e"; -} - -.ph-trend-down-bold::before { - content: "\fa1f"; -} - -.ph-trend-up-bold::before { - content: "\fa20"; -} - -.ph-triangle-bold::before { - content: "\fa21"; -} - -.ph-trophy-bold::before { - content: "\fa22"; -} - -.ph-truck-bold::before { - content: "\fa23"; -} - -.ph-twitch-logo-bold::before { - content: "\fa24"; -} - -.ph-twitter-logo-bold::before { - content: "\fa25"; -} - -.ph-umbrella-bold::before { - content: "\fa26"; -} - -.ph-umbrella-simple-bold::before { - content: "\fa27"; -} - -.ph-upload-bold::before { - content: "\fa28"; -} - -.ph-upload-simple-bold::before { - content: "\fa29"; -} - -.ph-user-bold::before { - content: "\fa2a"; -} - -.ph-user-circle-bold::before { - content: "\fa2b"; -} - -.ph-user-circle-gear-bold::before { - content: "\fa2c"; -} - -.ph-user-circle-minus-bold::before { - content: "\fa2d"; -} - -.ph-user-circle-plus-bold::before { - content: "\fa2e"; -} - -.ph-user-focus-bold::before { - content: "\fa2f"; -} - -.ph-user-gear-bold::before { - content: "\fa30"; -} - -.ph-user-list-bold::before { - content: "\fa31"; -} - -.ph-user-minus-bold::before { - content: "\fa32"; -} - -.ph-user-plus-bold::before { - content: "\fa33"; -} - -.ph-user-rectangle-bold::before { - content: "\fa34"; -} - -.ph-user-square-bold::before { - content: "\fa35"; -} - -.ph-user-switch-bold::before { - content: "\fa36"; -} - -.ph-users-bold::before { - content: "\fa37"; -} - -.ph-users-four-bold::before { - content: "\fa38"; -} - -.ph-users-three-bold::before { - content: "\fa39"; -} - -.ph-vault-bold::before { - content: "\fa3a"; -} - -.ph-vibrate-bold::before { - content: "\fa3b"; -} - -.ph-video-camera-bold::before { - content: "\fa3c"; -} - -.ph-video-camera-slash-bold::before { - content: "\fa3d"; -} - -.ph-vignette-bold::before { - content: "\fa3e"; -} - -.ph-voicemail-bold::before { - content: "\fa3f"; -} - -.ph-volleyball-bold::before { - content: "\fa40"; -} - -.ph-wall-bold::before { - content: "\fa41"; -} - -.ph-wallet-bold::before { - content: "\fa42"; -} - -.ph-warning-bold::before { - content: "\fa43"; -} - -.ph-warning-circle-bold::before { - content: "\fa44"; -} - -.ph-warning-octagon-bold::before { - content: "\fa45"; -} - -.ph-watch-bold::before { - content: "\fa46"; -} - -.ph-wave-sawtooth-bold::before { - content: "\fa47"; -} - -.ph-wave-sine-bold::before { - content: "\fa48"; -} - -.ph-wave-square-bold::before { - content: "\fa49"; -} - -.ph-wave-triangle-bold::before { - content: "\fa4a"; -} - -.ph-waves-bold::before { - content: "\fa4b"; -} - -.ph-webcam-bold::before { - content: "\fa4c"; -} - -.ph-whatsapp-logo-bold::before { - content: "\fa4d"; -} - -.ph-wheelchair-bold::before { - content: "\fa4e"; -} - -.ph-wifi-high-bold::before { - content: "\fa4f"; -} - -.ph-wifi-low-bold::before { - content: "\fa50"; -} - -.ph-wifi-medium-bold::before { - content: "\fa51"; -} - -.ph-wifi-none-bold::before { - content: "\fa52"; -} - -.ph-wifi-slash-bold::before { - content: "\fa53"; -} - -.ph-wifi-x-bold::before { - content: "\fa54"; -} - -.ph-wind-bold::before { - content: "\fa55"; -} - -.ph-windows-logo-bold::before { - content: "\fa56"; -} - -.ph-wine-bold::before { - content: "\fa57"; -} - -.ph-wrench-bold::before { - content: "\fa58"; -} - -.ph-x-bold::before { - content: "\fa59"; -} - -.ph-x-circle-bold::before { - content: "\fa5a"; -} - -.ph-x-square-bold::before { - content: "\fa5b"; -} - -.ph-yin-yang-bold::before { - content: "\fa5c"; -} - -.ph-youtube-logo-bold::before { - content: "\fa5d"; -} - -.ph-activity-fill::before { - content: "\fa5e"; -} - -.ph-address-book-fill::before { - content: "\fa5f"; -} - -.ph-airplane-fill::before { - content: "\fa60"; -} - -.ph-airplane-in-flight-fill::before { - content: "\fa61"; -} - -.ph-airplane-landing-fill::before { - content: "\fa62"; -} - -.ph-airplane-takeoff-fill::before { - content: "\fa63"; -} - -.ph-airplane-tilt-fill::before { - content: "\fa64"; -} - -.ph-airplay-fill::before { - content: "\fa65"; -} - -.ph-alarm-fill::before { - content: "\fa66"; -} - -.ph-alien-fill::before { - content: "\fa67"; -} - -.ph-align-bottom-fill::before { - content: "\fa68"; -} - -.ph-align-bottom-simple-fill::before { - content: "\fa69"; -} - -.ph-align-center-horizontal-fill::before { - content: "\fa6a"; -} - -.ph-align-center-horizontal-simple-fill::before { - content: "\fa6b"; -} - -.ph-align-center-vertical-fill::before { - content: "\fa6c"; -} - -.ph-align-center-vertical-simple-fill::before { - content: "\fa6d"; -} - -.ph-align-left-fill::before { - content: "\fa6e"; -} - -.ph-align-left-simple-fill::before { - content: "\fa6f"; -} - -.ph-align-right-fill::before { - content: "\fa70"; -} - -.ph-align-right-simple-fill::before { - content: "\fa71"; -} - -.ph-align-top-fill::before { - content: "\fa72"; -} - -.ph-align-top-simple-fill::before { - content: "\fa73"; -} - -.ph-anchor-fill::before { - content: "\fa74"; -} - -.ph-anchor-simple-fill::before { - content: "\fa75"; -} - -.ph-android-logo-fill::before { - content: "\fa76"; -} - -.ph-angular-logo-fill::before { - content: "\fa77"; -} - -.ph-aperture-fill::before { - content: "\fa78"; -} - -.ph-app-store-logo-fill::before { - content: "\fa79"; -} - -.ph-app-window-fill::before { - content: "\fa7a"; -} - -.ph-apple-logo-fill::before { - content: "\fa7b"; -} - -.ph-apple-podcasts-logo-fill::before { - content: "\fa7c"; -} - -.ph-archive-box-fill::before { - content: "\fa7d"; -} - -.ph-archive-fill::before { - content: "\fa7e"; -} - -.ph-archive-tray-fill::before { - content: "\fa7f"; -} - -.ph-armchair-fill::before { - content: "\fa80"; -} - -.ph-arrow-arc-left-fill::before { - content: "\fa81"; -} - -.ph-arrow-arc-right-fill::before { - content: "\fa82"; -} - -.ph-arrow-bend-double-up-left-fill::before { - content: "\fa83"; -} - -.ph-arrow-bend-double-up-right-fill::before { - content: "\fa84"; -} - -.ph-arrow-bend-down-left-fill::before { - content: "\fa85"; -} - -.ph-arrow-bend-down-right-fill::before { - content: "\fa86"; -} - -.ph-arrow-bend-left-down-fill::before { - content: "\fa87"; -} - -.ph-arrow-bend-left-up-fill::before { - content: "\fa88"; -} - -.ph-arrow-bend-right-down-fill::before { - content: "\fa89"; -} - -.ph-arrow-bend-right-up-fill::before { - content: "\fa8a"; -} - -.ph-arrow-bend-up-left-fill::before { - content: "\fa8b"; -} - -.ph-arrow-bend-up-right-fill::before { - content: "\fa8c"; -} - -.ph-arrow-circle-down-fill::before { - content: "\fa8d"; -} - -.ph-arrow-circle-down-left-fill::before { - content: "\fa8e"; -} - -.ph-arrow-circle-down-right-fill::before { - content: "\fa8f"; -} - -.ph-arrow-circle-left-fill::before { - content: "\fa90"; -} - -.ph-arrow-circle-right-fill::before { - content: "\fa91"; -} - -.ph-arrow-circle-up-fill::before { - content: "\fa92"; -} - -.ph-arrow-circle-up-left-fill::before { - content: "\fa93"; -} - -.ph-arrow-circle-up-right-fill::before { - content: "\fa94"; -} - -.ph-arrow-clockwise-fill::before { - content: "\fa95"; -} - -.ph-arrow-counter-clockwise-fill::before { - content: "\fa96"; -} - -.ph-arrow-down-fill::before { - content: "\fa97"; -} - -.ph-arrow-down-left-fill::before { - content: "\fa98"; -} - -.ph-arrow-down-right-fill::before { - content: "\fa99"; -} - -.ph-arrow-elbow-down-left-fill::before { - content: "\fa9a"; -} - -.ph-arrow-elbow-down-right-fill::before { - content: "\fa9b"; -} - -.ph-arrow-elbow-left-down-fill::before { - content: "\fa9c"; -} - -.ph-arrow-elbow-left-fill::before { - content: "\fa9d"; -} - -.ph-arrow-elbow-left-up-fill::before { - content: "\fa9e"; -} - -.ph-arrow-elbow-right-down-fill::before { - content: "\fa9f"; -} - -.ph-arrow-elbow-right-fill::before { - content: "\faa0"; -} - -.ph-arrow-elbow-right-up-fill::before { - content: "\faa1"; -} - -.ph-arrow-elbow-up-left-fill::before { - content: "\faa2"; -} - -.ph-arrow-elbow-up-right-fill::before { - content: "\faa3"; -} - -.ph-arrow-fat-down-fill::before { - content: "\faa4"; -} - -.ph-arrow-fat-left-fill::before { - content: "\faa5"; -} - -.ph-arrow-fat-line-down-fill::before { - content: "\faa6"; -} - -.ph-arrow-fat-line-left-fill::before { - content: "\faa7"; -} - -.ph-arrow-fat-line-right-fill::before { - content: "\faa8"; -} - -.ph-arrow-fat-line-up-fill::before { - content: "\faa9"; -} - -.ph-arrow-fat-lines-down-fill::before { - content: "\faaa"; -} - -.ph-arrow-fat-lines-left-fill::before { - content: "\faab"; -} - -.ph-arrow-fat-lines-right-fill::before { - content: "\faac"; -} - -.ph-arrow-fat-lines-up-fill::before { - content: "\faad"; -} - -.ph-arrow-fat-right-fill::before { - content: "\faae"; -} - -.ph-arrow-fat-up-fill::before { - content: "\faaf"; -} - -.ph-arrow-left-fill::before { - content: "\fab0"; -} - -.ph-arrow-line-down-fill::before { - content: "\fab1"; -} - -.ph-arrow-line-down-left-fill::before { - content: "\fab2"; -} - -.ph-arrow-line-down-right-fill::before { - content: "\fab3"; -} - -.ph-arrow-line-left-fill::before { - content: "\fab4"; -} - -.ph-arrow-line-right-fill::before { - content: "\fab5"; -} - -.ph-arrow-line-up-fill::before { - content: "\fab6"; -} - -.ph-arrow-line-up-left-fill::before { - content: "\fab7"; -} - -.ph-arrow-line-up-right-fill::before { - content: "\fab8"; -} - -.ph-arrow-right-fill::before { - content: "\fab9"; -} - -.ph-arrow-square-down-fill::before { - content: "\faba"; -} - -.ph-arrow-square-down-left-fill::before { - content: "\fabb"; -} - -.ph-arrow-square-down-right-fill::before { - content: "\fabc"; -} - -.ph-arrow-square-in-fill::before { - content: "\fabd"; -} - -.ph-arrow-square-left-fill::before { - content: "\fabe"; -} - -.ph-arrow-square-out-fill::before { - content: "\fabf"; -} - -.ph-arrow-square-right-fill::before { - content: "\fac0"; -} - -.ph-arrow-square-up-fill::before { - content: "\fac1"; -} - -.ph-arrow-square-up-left-fill::before { - content: "\fac2"; -} - -.ph-arrow-square-up-right-fill::before { - content: "\fac3"; -} - -.ph-arrow-u-down-left-fill::before { - content: "\fac4"; -} - -.ph-arrow-u-down-right-fill::before { - content: "\fac5"; -} - -.ph-arrow-u-left-down-fill::before { - content: "\fac6"; -} - -.ph-arrow-u-left-up-fill::before { - content: "\fac7"; -} - -.ph-arrow-u-right-down-fill::before { - content: "\fac8"; -} - -.ph-arrow-u-right-up-fill::before { - content: "\fac9"; -} - -.ph-arrow-u-up-left-fill::before { - content: "\faca"; -} - -.ph-arrow-u-up-right-fill::before { - content: "\facb"; -} - -.ph-arrow-up-fill::before { - content: "\facc"; -} - -.ph-arrow-up-left-fill::before { - content: "\facd"; -} - -.ph-arrow-up-right-fill::before { - content: "\face"; -} - -.ph-arrows-clockwise-fill::before { - content: "\facf"; -} - -.ph-arrows-counter-clockwise-fill::before { - content: "\fad0"; -} - -.ph-arrows-down-up-fill::before { - content: "\fad1"; -} - -.ph-arrows-horizontal-fill::before { - content: "\fad2"; -} - -.ph-arrows-in-cardinal-fill::before { - content: "\fad3"; -} - -.ph-arrows-in-fill::before { - content: "\fad4"; -} - -.ph-arrows-in-line-horizontal-fill::before { - content: "\fad5"; -} - -.ph-arrows-in-line-vertical-fill::before { - content: "\fad6"; -} - -.ph-arrows-in-simple-fill::before { - content: "\fad7"; -} - -.ph-arrows-left-right-fill::before { - content: "\fad8"; -} - -.ph-arrows-out-cardinal-fill::before { - content: "\fad9"; -} - -.ph-arrows-out-fill::before { - content: "\fada"; -} - -.ph-arrows-out-line-horizontal-fill::before { - content: "\fadb"; -} - -.ph-arrows-out-line-vertical-fill::before { - content: "\fadc"; -} - -.ph-arrows-out-simple-fill::before { - content: "\fadd"; -} - -.ph-arrows-vertical-fill::before { - content: "\fade"; -} - -.ph-article-fill::before { - content: "\fadf"; -} - -.ph-article-medium-fill::before { - content: "\fae0"; -} - -.ph-article-ny-times-fill::before { - content: "\fae1"; -} - -.ph-asterisk-fill::before { - content: "\fae2"; -} - -.ph-asterisk-simple-fill::before { - content: "\fae3"; -} - -.ph-at-fill::before { - content: "\fae4"; -} - -.ph-atom-fill::before { - content: "\fae5"; -} - -.ph-baby-fill::before { - content: "\fae6"; -} - -.ph-backpack-fill::before { - content: "\fae7"; -} - -.ph-backspace-fill::before { - content: "\fae8"; -} - -.ph-bag-fill::before { - content: "\fae9"; -} - -.ph-bag-simple-fill::before { - content: "\faea"; -} - -.ph-balloon-fill::before { - content: "\faeb"; -} - -.ph-bandaids-fill::before { - content: "\faec"; -} - -.ph-bank-fill::before { - content: "\faed"; -} - -.ph-barbell-fill::before { - content: "\faee"; -} - -.ph-barcode-fill::before { - content: "\faef"; -} - -.ph-barricade-fill::before { - content: "\faf0"; -} - -.ph-baseball-fill::before { - content: "\faf1"; -} - -.ph-basketball-fill::before { - content: "\faf2"; -} - -.ph-bathtub-fill::before { - content: "\faf3"; -} - -.ph-battery-charging-fill::before { - content: "\faf4"; -} - -.ph-battery-charging-vertical-fill::before { - content: "\faf5"; -} - -.ph-battery-empty-fill::before { - content: "\faf6"; -} - -.ph-battery-full-fill::before { - content: "\faf7"; -} - -.ph-battery-high-fill::before { - content: "\faf8"; -} - -.ph-battery-low-fill::before { - content: "\faf9"; -} - -.ph-battery-medium-fill::before { - content: "\fafa"; -} - -.ph-battery-plus-fill::before { - content: "\fafb"; -} - -.ph-battery-warning-fill::before { - content: "\fafc"; -} - -.ph-battery-warning-vertical-fill::before { - content: "\fafd"; -} - -.ph-bed-fill::before { - content: "\fafe"; -} - -.ph-beer-bottle-fill::before { - content: "\faff"; -} - -.ph-behance-logo-fill::before { - content: "\fb00"; -} - -.ph-bell-fill::before { - content: "\fb01"; -} - -.ph-bell-ringing-fill::before { - content: "\fb02"; -} - -.ph-bell-simple-fill::before { - content: "\fb03"; -} - -.ph-bell-simple-ringing-fill::before { - content: "\fb04"; -} - -.ph-bell-simple-slash-fill::before { - content: "\fb05"; -} - -.ph-bell-simple-z-fill::before { - content: "\fb06"; -} - -.ph-bell-slash-fill::before { - content: "\fb07"; -} - -.ph-bell-z-fill::before { - content: "\fb08"; -} - -.ph-bezier-curve-fill::before { - content: "\fb09"; -} - -.ph-bicycle-fill::before { - content: "\fb0a"; -} - -.ph-binoculars-fill::before { - content: "\fb0b"; -} - -.ph-bird-fill::before { - content: "\fb0c"; -} - -.ph-bluetooth-connected-fill::before { - content: "\fb0d"; -} - -.ph-bluetooth-fill::before { - content: "\fb0e"; -} - -.ph-bluetooth-slash-fill::before { - content: "\fb0f"; -} - -.ph-bluetooth-x-fill::before { - content: "\fb10"; -} - -.ph-boat-fill::before { - content: "\fb11"; -} - -.ph-book-bookmark-fill::before { - content: "\fb12"; -} - -.ph-book-fill::before { - content: "\fb13"; -} - -.ph-book-open-fill::before { - content: "\fb14"; -} - -.ph-bookmark-fill::before { - content: "\fb15"; -} - -.ph-bookmark-simple-fill::before { - content: "\fb16"; -} - -.ph-bookmarks-fill::before { - content: "\fb17"; -} - -.ph-bookmarks-simple-fill::before { - content: "\fb18"; -} - -.ph-books-fill::before { - content: "\fb19"; -} - -.ph-bounding-box-fill::before { - content: "\fb1a"; -} - -.ph-brackets-angle-fill::before { - content: "\fb1b"; -} - -.ph-brackets-curly-fill::before { - content: "\fb1c"; -} - -.ph-brackets-round-fill::before { - content: "\fb1d"; -} - -.ph-brackets-square-fill::before { - content: "\fb1e"; -} - -.ph-brain-fill::before { - content: "\fb1f"; -} - -.ph-brandy-fill::before { - content: "\fb20"; -} - -.ph-briefcase-fill::before { - content: "\fb21"; -} - -.ph-briefcase-metal-fill::before { - content: "\fb22"; -} - -.ph-broadcast-fill::before { - content: "\fb23"; -} - -.ph-browser-fill::before { - content: "\fb24"; -} - -.ph-browsers-fill::before { - content: "\fb25"; -} - -.ph-bug-beetle-fill::before { - content: "\fb26"; -} - -.ph-bug-droid-fill::before { - content: "\fb27"; -} - -.ph-bug-fill::before { - content: "\fb28"; -} - -.ph-buildings-fill::before { - content: "\fb29"; -} - -.ph-bus-fill::before { - content: "\fb2a"; -} - -.ph-butterfly-fill::before { - content: "\fb2b"; -} - -.ph-cactus-fill::before { - content: "\fb2c"; -} - -.ph-cake-fill::before { - content: "\fb2d"; -} - -.ph-calculator-fill::before { - content: "\fb2e"; -} - -.ph-calendar-blank-fill::before { - content: "\fb2f"; -} - -.ph-calendar-check-fill::before { - content: "\fb30"; -} - -.ph-calendar-fill::before { - content: "\fb31"; -} - -.ph-calendar-plus-fill::before { - content: "\fb32"; -} - -.ph-calendar-x-fill::before { - content: "\fb33"; -} - -.ph-camera-fill::before { - content: "\fb34"; -} - -.ph-camera-rotate-fill::before { - content: "\fb35"; -} - -.ph-camera-slash-fill::before { - content: "\fb36"; -} - -.ph-campfire-fill::before { - content: "\fb37"; -} - -.ph-car-fill::before { - content: "\fb38"; -} - -.ph-car-simple-fill::before { - content: "\fb39"; -} - -.ph-cardholder-fill::before { - content: "\fb3a"; -} - -.ph-cards-fill::before { - content: "\fb3b"; -} - -.ph-caret-circle-double-down-fill::before { - content: "\fb3c"; -} - -.ph-caret-circle-double-left-fill::before { - content: "\fb3d"; -} - -.ph-caret-circle-double-right-fill::before { - content: "\fb3e"; -} - -.ph-caret-circle-double-up-fill::before { - content: "\fb3f"; -} - -.ph-caret-circle-down-fill::before { - content: "\fb40"; -} - -.ph-caret-circle-left-fill::before { - content: "\fb41"; -} - -.ph-caret-circle-right-fill::before { - content: "\fb42"; -} - -.ph-caret-circle-up-fill::before { - content: "\fb43"; -} - -.ph-caret-double-down-fill::before { - content: "\fb44"; -} - -.ph-caret-double-left-fill::before { - content: "\fb45"; -} - -.ph-caret-double-right-fill::before { - content: "\fb46"; -} - -.ph-caret-double-up-fill::before { - content: "\fb47"; -} - -.ph-caret-down-fill::before { - content: "\fb48"; -} - -.ph-caret-left-fill::before { - content: "\fb49"; -} - -.ph-caret-right-fill::before { - content: "\fb4a"; -} - -.ph-caret-up-fill::before { - content: "\fb4b"; -} - -.ph-cat-fill::before { - content: "\fb4c"; -} - -.ph-cell-signal-full-fill::before { - content: "\fb4d"; -} - -.ph-cell-signal-high-fill::before { - content: "\fb4e"; -} - -.ph-cell-signal-low-fill::before { - content: "\fb4f"; -} - -.ph-cell-signal-medium-fill::before { - content: "\fb50"; -} - -.ph-cell-signal-none-fill::before { - content: "\fb51"; -} - -.ph-cell-signal-slash-fill::before { - content: "\fb52"; -} - -.ph-cell-signal-x-fill::before { - content: "\fb53"; -} - -.ph-chalkboard-fill::before { - content: "\fb54"; -} - -.ph-chalkboard-simple-fill::before { - content: "\fb55"; -} - -.ph-chalkboard-teacher-fill::before { - content: "\fb56"; -} - -.ph-chart-bar-fill::before { - content: "\fb57"; -} - -.ph-chart-bar-horizontal-fill::before { - content: "\fb58"; -} - -.ph-chart-line-fill::before { - content: "\fb59"; -} - -.ph-chart-line-up-fill::before { - content: "\fb5a"; -} - -.ph-chart-pie-fill::before { - content: "\fb5b"; -} - -.ph-chart-pie-slice-fill::before { - content: "\fb5c"; -} - -.ph-chat-centered-dots-fill::before { - content: "\fb5d"; -} - -.ph-chat-centered-fill::before { - content: "\fb5e"; -} - -.ph-chat-centered-text-fill::before { - content: "\fb5f"; -} - -.ph-chat-circle-dots-fill::before { - content: "\fb60"; -} - -.ph-chat-circle-fill::before { - content: "\fb61"; -} - -.ph-chat-circle-text-fill::before { - content: "\fb62"; -} - -.ph-chat-dots-fill::before { - content: "\fb63"; -} - -.ph-chat-fill::before { - content: "\fb64"; -} - -.ph-chat-teardrop-dots-fill::before { - content: "\fb65"; -} - -.ph-chat-teardrop-fill::before { - content: "\fb66"; -} - -.ph-chat-teardrop-text-fill::before { - content: "\fb67"; -} - -.ph-chat-text-fill::before { - content: "\fb68"; -} - -.ph-chats-circle-fill::before { - content: "\fb69"; -} - -.ph-chats-fill::before { - content: "\fb6a"; -} - -.ph-chats-teardrop-fill::before { - content: "\fb6b"; -} - -.ph-check-circle-fill::before { - content: "\fb6c"; -} - -.ph-check-fill::before { - content: "\fb6d"; -} - -.ph-check-square-fill::before { - content: "\fb6e"; -} - -.ph-check-square-offset-fill::before { - content: "\fb6f"; -} - -.ph-checks-fill::before { - content: "\fb70"; -} - -.ph-circle-dashed-fill::before { - content: "\fb71"; -} - -.ph-circle-fill::before { - content: "\fb72"; -} - -.ph-circle-half-fill::before { - content: "\fb73"; -} - -.ph-circle-half-tilt-fill::before { - content: "\fb74"; -} - -.ph-circle-notch-fill::before { - content: "\fb75"; -} - -.ph-circle-wavy-check-fill::before { - content: "\fb76"; -} - -.ph-circle-wavy-fill::before { - content: "\fb77"; -} - -.ph-circle-wavy-question-fill::before { - content: "\fb78"; -} - -.ph-circle-wavy-warning-fill::before { - content: "\fb79"; -} - -.ph-circles-four-fill::before { - content: "\fb7a"; -} - -.ph-circles-three-fill::before { - content: "\fb7b"; -} - -.ph-circles-three-plus-fill::before { - content: "\fb7c"; -} - -.ph-clipboard-fill::before { - content: "\fb7d"; -} - -.ph-clipboard-text-fill::before { - content: "\fb7e"; -} - -.ph-clock-afternoon-fill::before { - content: "\fb7f"; -} - -.ph-clock-clockwise-fill::before { - content: "\fb80"; -} - -.ph-clock-counter-clockwise-fill::before { - content: "\fb81"; -} - -.ph-clock-fill::before { - content: "\fb82"; -} - -.ph-closed-captioning-fill::before { - content: "\fb83"; -} - -.ph-cloud-arrow-down-fill::before { - content: "\fb84"; -} - -.ph-cloud-arrow-up-fill::before { - content: "\fb85"; -} - -.ph-cloud-check-fill::before { - content: "\fb86"; -} - -.ph-cloud-fill::before { - content: "\fb87"; -} - -.ph-cloud-fog-fill::before { - content: "\fb88"; -} - -.ph-cloud-lightning-fill::before { - content: "\fb89"; -} - -.ph-cloud-moon-fill::before { - content: "\fb8a"; -} - -.ph-cloud-rain-fill::before { - content: "\fb8b"; -} - -.ph-cloud-slash-fill::before { - content: "\fb8c"; -} - -.ph-cloud-snow-fill::before { - content: "\fb8d"; -} - -.ph-cloud-sun-fill::before { - content: "\fb8e"; -} - -.ph-club-fill::before { - content: "\fb8f"; -} - -.ph-coat-hanger-fill::before { - content: "\fb90"; -} - -.ph-code-fill::before { - content: "\fb91"; -} - -.ph-code-simple-fill::before { - content: "\fb92"; -} - -.ph-codepen-logo-fill::before { - content: "\fb93"; -} - -.ph-codesandbox-logo-fill::before { - content: "\fb94"; -} - -.ph-coffee-fill::before { - content: "\fb95"; -} - -.ph-coin-fill::before { - content: "\fb96"; -} - -.ph-coin-vertical-fill::before { - content: "\fb97"; -} - -.ph-coins-fill::before { - content: "\fb98"; -} - -.ph-columns-fill::before { - content: "\fb99"; -} - -.ph-command-fill::before { - content: "\fb9a"; -} - -.ph-compass-fill::before { - content: "\fb9b"; -} - -.ph-computer-tower-fill::before { - content: "\fb9c"; -} - -.ph-confetti-fill::before { - content: "\fb9d"; -} - -.ph-cookie-fill::before { - content: "\fb9e"; -} - -.ph-cooking-pot-fill::before { - content: "\fb9f"; -} - -.ph-copy-fill::before { - content: "\fba0"; -} - -.ph-copy-simple-fill::before { - content: "\fba1"; -} - -.ph-copyleft-fill::before { - content: "\fba2"; -} - -.ph-copyright-fill::before { - content: "\fba3"; -} - -.ph-corners-in-fill::before { - content: "\fba4"; -} - -.ph-corners-out-fill::before { - content: "\fba5"; -} - -.ph-cpu-fill::before { - content: "\fba6"; -} - -.ph-credit-card-fill::before { - content: "\fba7"; -} - -.ph-crop-fill::before { - content: "\fba8"; -} - -.ph-crosshair-fill::before { - content: "\fba9"; -} - -.ph-crosshair-simple-fill::before { - content: "\fbaa"; -} - -.ph-crown-fill::before { - content: "\fbab"; -} - -.ph-crown-simple-fill::before { - content: "\fbac"; -} - -.ph-cube-fill::before { - content: "\fbad"; -} - -.ph-currency-btc-fill::before { - content: "\fbae"; -} - -.ph-currency-circle-dollar-fill::before { - content: "\fbaf"; -} - -.ph-currency-cny-fill::before { - content: "\fbb0"; -} - -.ph-currency-dollar-fill::before { - content: "\fbb1"; -} - -.ph-currency-dollar-simple-fill::before { - content: "\fbb2"; -} - -.ph-currency-eth-fill::before { - content: "\fbb3"; -} - -.ph-currency-eur-fill::before { - content: "\fbb4"; -} - -.ph-currency-gbp-fill::before { - content: "\fbb5"; -} - -.ph-currency-inr-fill::before { - content: "\fbb6"; -} - -.ph-currency-jpy-fill::before { - content: "\fbb7"; -} - -.ph-currency-krw-fill::before { - content: "\fbb8"; -} - -.ph-currency-kzt-fill::before { - content: "\fbb9"; -} - -.ph-currency-ngn-fill::before { - content: "\fbba"; -} - -.ph-currency-rub-fill::before { - content: "\fbbb"; -} - -.ph-cursor-fill::before { - content: "\fbbc"; -} - -.ph-cursor-text-fill::before { - content: "\fbbd"; -} - -.ph-cylinder-fill::before { - content: "\fbbe"; -} - -.ph-database-fill::before { - content: "\fbbf"; -} - -.ph-desktop-fill::before { - content: "\fbc0"; -} - -.ph-desktop-tower-fill::before { - content: "\fbc1"; -} - -.ph-detective-fill::before { - content: "\fbc2"; -} - -.ph-device-mobile-camera-fill::before { - content: "\fbc3"; -} - -.ph-device-mobile-fill::before { - content: "\fbc4"; -} - -.ph-device-mobile-speaker-fill::before { - content: "\fbc5"; -} - -.ph-device-tablet-camera-fill::before { - content: "\fbc6"; -} - -.ph-device-tablet-fill::before { - content: "\fbc7"; -} - -.ph-device-tablet-speaker-fill::before { - content: "\fbc8"; -} - -.ph-diamond-fill::before { - content: "\fbc9"; -} - -.ph-diamonds-four-fill::before { - content: "\fbca"; -} - -.ph-dice-five-fill::before { - content: "\fbcb"; -} - -.ph-dice-four-fill::before { - content: "\fbcc"; -} - -.ph-dice-one-fill::before { - content: "\fbcd"; -} - -.ph-dice-six-fill::before { - content: "\fbce"; -} - -.ph-dice-three-fill::before { - content: "\fbcf"; -} - -.ph-dice-two-fill::before { - content: "\fbd0"; -} - -.ph-disc-fill::before { - content: "\fbd1"; -} - -.ph-discord-logo-fill::before { - content: "\fbd2"; -} - -.ph-divide-fill::before { - content: "\fbd3"; -} - -.ph-dog-fill::before { - content: "\fbd4"; -} - -.ph-door-fill::before { - content: "\fbd5"; -} - -.ph-dots-nine-fill::before { - content: "\fbd6"; -} - -.ph-dots-six-fill::before { - content: "\fbd7"; -} - -.ph-dots-six-vertical-fill::before { - content: "\fbd8"; -} - -.ph-dots-three-circle-fill::before { - content: "\fbd9"; -} - -.ph-dots-three-circle-vertical-fill::before { - content: "\fbda"; -} - -.ph-dots-three-fill::before { - content: "\fbdb"; -} - -.ph-dots-three-outline-fill::before { - content: "\fbdc"; -} - -.ph-dots-three-outline-vertical-fill::before { - content: "\fbdd"; -} - -.ph-dots-three-vertical-fill::before { - content: "\fbde"; -} - -.ph-download-fill::before { - content: "\fbdf"; -} - -.ph-download-simple-fill::before { - content: "\fbe0"; -} - -.ph-dribbble-logo-fill::before { - content: "\fbe1"; -} - -.ph-drop-fill::before { - content: "\fbe2"; -} - -.ph-drop-half-bottom-fill::before { - content: "\fbe3"; -} - -.ph-drop-half-fill::before { - content: "\fbe4"; -} - -.ph-ear-fill::before { - content: "\fbe5"; -} - -.ph-ear-slash-fill::before { - content: "\fbe6"; -} - -.ph-egg-crack-fill::before { - content: "\fbe7"; -} - -.ph-egg-fill::before { - content: "\fbe8"; -} - -.ph-eject-fill::before { - content: "\fbe9"; -} - -.ph-eject-simple-fill::before { - content: "\fbea"; -} - -.ph-envelope-fill::before { - content: "\fbeb"; -} - -.ph-envelope-open-fill::before { - content: "\fbec"; -} - -.ph-envelope-simple-fill::before { - content: "\fbed"; -} - -.ph-envelope-simple-open-fill::before { - content: "\fbee"; -} - -.ph-equalizer-fill::before { - content: "\fbef"; -} - -.ph-equals-fill::before { - content: "\fbf0"; -} - -.ph-eraser-fill::before { - content: "\fbf1"; -} - -.ph-exam-fill::before { - content: "\fbf2"; -} - -.ph-export-fill::before { - content: "\fbf3"; -} - -.ph-eye-closed-fill::before { - content: "\fbf4"; -} - -.ph-eye-fill::before { - content: "\fbf5"; -} - -.ph-eye-slash-fill::before { - content: "\fbf6"; -} - -.ph-eyedropper-fill::before { - content: "\fbf7"; -} - -.ph-eyedropper-sample-fill::before { - content: "\fbf8"; -} - -.ph-eyeglasses-fill::before { - content: "\fbf9"; -} - -.ph-face-mask-fill::before { - content: "\fbfa"; -} - -.ph-facebook-logo-fill::before { - content: "\fbfb"; -} - -.ph-factory-fill::before { - content: "\fbfc"; -} - -.ph-faders-fill::before { - content: "\fbfd"; -} - -.ph-faders-horizontal-fill::before { - content: "\fbfe"; -} - -.ph-fast-forward-circle-fill::before { - content: "\fbff"; -} - -.ph-fast-forward-fill::before { - content: "\fc00"; -} - -.ph-figma-logo-fill::before { - content: "\fc01"; -} - -.ph-file-arrow-down-fill::before { - content: "\fc02"; -} - -.ph-file-arrow-up-fill::before { - content: "\fc03"; -} - -.ph-file-audio-fill::before { - content: "\fc04"; -} - -.ph-file-cloud-fill::before { - content: "\fc05"; -} - -.ph-file-code-fill::before { - content: "\fc06"; -} - -.ph-file-css-fill::before { - content: "\fc07"; -} - -.ph-file-csv-fill::before { - content: "\fc08"; -} - -.ph-file-doc-fill::before { - content: "\fc09"; -} - -.ph-file-dotted-fill::before { - content: "\fc0a"; -} - -.ph-file-fill::before { - content: "\fc0b"; -} - -.ph-file-html-fill::before { - content: "\fc0c"; -} - -.ph-file-image-fill::before { - content: "\fc0d"; -} - -.ph-file-jpg-fill::before { - content: "\fc0e"; -} - -.ph-file-js-fill::before { - content: "\fc0f"; -} - -.ph-file-jsx-fill::before { - content: "\fc10"; -} - -.ph-file-lock-fill::before { - content: "\fc11"; -} - -.ph-file-minus-fill::before { - content: "\fc12"; -} - -.ph-file-pdf-fill::before { - content: "\fc13"; -} - -.ph-file-plus-fill::before { - content: "\fc14"; -} - -.ph-file-png-fill::before { - content: "\fc15"; -} - -.ph-file-ppt-fill::before { - content: "\fc16"; -} - -.ph-file-rs-fill::before { - content: "\fc17"; -} - -.ph-file-search-fill::before { - content: "\fc18"; -} - -.ph-file-text-fill::before { - content: "\fc19"; -} - -.ph-file-ts-fill::before { - content: "\fc1a"; -} - -.ph-file-tsx-fill::before { - content: "\fc1b"; -} - -.ph-file-video-fill::before { - content: "\fc1c"; -} - -.ph-file-vue-fill::before { - content: "\fc1d"; -} - -.ph-file-x-fill::before { - content: "\fc1e"; -} - -.ph-file-xls-fill::before { - content: "\fc1f"; -} - -.ph-file-zip-fill::before { - content: "\fc20"; -} - -.ph-files-fill::before { - content: "\fc21"; -} - -.ph-film-script-fill::before { - content: "\fc22"; -} - -.ph-film-slate-fill::before { - content: "\fc23"; -} - -.ph-film-strip-fill::before { - content: "\fc24"; -} - -.ph-fingerprint-fill::before { - content: "\fc25"; -} - -.ph-fingerprint-simple-fill::before { - content: "\fc26"; -} - -.ph-finn-the-human-fill::before { - content: "\fc27"; -} - -.ph-fire-fill::before { - content: "\fc28"; -} - -.ph-fire-simple-fill::before { - content: "\fc29"; -} - -.ph-first-aid-fill::before { - content: "\fc2a"; -} - -.ph-first-aid-kit-fill::before { - content: "\fc2b"; -} - -.ph-fish-fill::before { - content: "\fc2c"; -} - -.ph-fish-simple-fill::before { - content: "\fc2d"; -} - -.ph-flag-banner-fill::before { - content: "\fc2e"; -} - -.ph-flag-checkered-fill::before { - content: "\fc2f"; -} - -.ph-flag-fill::before { - content: "\fc30"; -} - -.ph-flame-fill::before { - content: "\fc31"; -} - -.ph-flashlight-fill::before { - content: "\fc32"; -} - -.ph-flask-fill::before { - content: "\fc33"; -} - -.ph-floppy-disk-back-fill::before { - content: "\fc34"; -} - -.ph-floppy-disk-fill::before { - content: "\fc35"; -} - -.ph-flow-arrow-fill::before { - content: "\fc36"; -} - -.ph-flower-fill::before { - content: "\fc37"; -} - -.ph-flower-lotus-fill::before { - content: "\fc38"; -} - -.ph-flying-saucer-fill::before { - content: "\fc39"; -} - -.ph-folder-dotted-fill::before { - content: "\fc3a"; -} - -.ph-folder-fill::before { - content: "\fc3b"; -} - -.ph-folder-lock-fill::before { - content: "\fc3c"; -} - -.ph-folder-minus-fill::before { - content: "\fc3d"; -} - -.ph-folder-notch-fill::before { - content: "\fc3e"; -} - -.ph-folder-notch-minus-fill::before { - content: "\fc3f"; -} - -.ph-folder-notch-open-fill::before { - content: "\fc40"; -} - -.ph-folder-notch-plus-fill::before { - content: "\fc41"; -} - -.ph-folder-open-fill::before { - content: "\fc42"; -} - -.ph-folder-plus-fill::before { - content: "\fc43"; -} - -.ph-folder-simple-dotted-fill::before { - content: "\fc44"; -} - -.ph-folder-simple-fill::before { - content: "\fc45"; -} - -.ph-folder-simple-lock-fill::before { - content: "\fc46"; -} - -.ph-folder-simple-minus-fill::before { - content: "\fc47"; -} - -.ph-folder-simple-plus-fill::before { - content: "\fc48"; -} - -.ph-folder-simple-star-fill::before { - content: "\fc49"; -} - -.ph-folder-simple-user-fill::before { - content: "\fc4a"; -} - -.ph-folder-star-fill::before { - content: "\fc4b"; -} - -.ph-folder-user-fill::before { - content: "\fc4c"; -} - -.ph-folders-fill::before { - content: "\fc4d"; -} - -.ph-football-fill::before { - content: "\fc4e"; -} - -.ph-fork-knife-fill::before { - content: "\fc4f"; -} - -.ph-frame-corners-fill::before { - content: "\fc50"; -} - -.ph-framer-logo-fill::before { - content: "\fc51"; -} - -.ph-function-fill::before { - content: "\fc52"; -} - -.ph-funnel-fill::before { - content: "\fc53"; -} - -.ph-funnel-simple-fill::before { - content: "\fc54"; -} - -.ph-game-controller-fill::before { - content: "\fc55"; -} - -.ph-gas-pump-fill::before { - content: "\fc56"; -} - -.ph-gauge-fill::before { - content: "\fc57"; -} - -.ph-gear-fill::before { - content: "\fc58"; -} - -.ph-gear-six-fill::before { - content: "\fc59"; -} - -.ph-gender-female-fill::before { - content: "\fc5a"; -} - -.ph-gender-intersex-fill::before { - content: "\fc5b"; -} - -.ph-gender-male-fill::before { - content: "\fc5c"; -} - -.ph-gender-neuter-fill::before { - content: "\fc5d"; -} - -.ph-gender-nonbinary-fill::before { - content: "\fc5e"; -} - -.ph-gender-transgender-fill::before { - content: "\fc5f"; -} - -.ph-ghost-fill::before { - content: "\fc60"; -} - -.ph-gif-fill::before { - content: "\fc61"; -} - -.ph-gift-fill::before { - content: "\fc62"; -} - -.ph-git-branch-fill::before { - content: "\fc63"; -} - -.ph-git-commit-fill::before { - content: "\fc64"; -} - -.ph-git-diff-fill::before { - content: "\fc65"; -} - -.ph-git-fork-fill::before { - content: "\fc66"; -} - -.ph-git-merge-fill::before { - content: "\fc67"; -} - -.ph-git-pull-request-fill::before { - content: "\fc68"; -} - -.ph-github-logo-fill::before { - content: "\fc69"; -} - -.ph-gitlab-logo-fill::before { - content: "\fc6a"; -} - -.ph-gitlab-logo-simple-fill::before { - content: "\fc6b"; -} - -.ph-globe-fill::before { - content: "\fc6c"; -} - -.ph-globe-hemisphere-east-fill::before { - content: "\fc6d"; -} - -.ph-globe-hemisphere-west-fill::before { - content: "\fc6e"; -} - -.ph-globe-simple-fill::before { - content: "\fc6f"; -} - -.ph-globe-stand-fill::before { - content: "\fc70"; -} - -.ph-google-chrome-logo-fill::before { - content: "\fc71"; -} - -.ph-google-logo-fill::before { - content: "\fc72"; -} - -.ph-google-photos-logo-fill::before { - content: "\fc73"; -} - -.ph-google-play-logo-fill::before { - content: "\fc74"; -} - -.ph-google-podcasts-logo-fill::before { - content: "\fc75"; -} - -.ph-gradient-fill::before { - content: "\fc76"; -} - -.ph-graduation-cap-fill::before { - content: "\fc77"; -} - -.ph-graph-fill::before { - content: "\fc78"; -} - -.ph-grid-four-fill::before { - content: "\fc79"; -} - -.ph-hamburger-fill::before { - content: "\fc7a"; -} - -.ph-hand-eye-fill::before { - content: "\fc7b"; -} - -.ph-hand-fill::before { - content: "\fc7c"; -} - -.ph-hand-fist-fill::before { - content: "\fc7d"; -} - -.ph-hand-grabbing-fill::before { - content: "\fc7e"; -} - -.ph-hand-palm-fill::before { - content: "\fc7f"; -} - -.ph-hand-pointing-fill::before { - content: "\fc80"; -} - -.ph-hand-soap-fill::before { - content: "\fc81"; -} - -.ph-hand-waving-fill::before { - content: "\fc82"; -} - -.ph-handbag-fill::before { - content: "\fc83"; -} - -.ph-handbag-simple-fill::before { - content: "\fc84"; -} - -.ph-hands-clapping-fill::before { - content: "\fc85"; -} - -.ph-handshake-fill::before { - content: "\fc86"; -} - -.ph-hard-drive-fill::before { - content: "\fc87"; -} - -.ph-hard-drives-fill::before { - content: "\fc88"; -} - -.ph-hash-fill::before { - content: "\fc89"; -} - -.ph-hash-straight-fill::before { - content: "\fc8a"; -} - -.ph-headlights-fill::before { - content: "\fc8b"; -} - -.ph-headphones-fill::before { - content: "\fc8c"; -} - -.ph-headset-fill::before { - content: "\fc8d"; -} - -.ph-heart-break-fill::before { - content: "\fc8e"; -} - -.ph-heart-fill::before { - content: "\fc8f"; -} - -.ph-heart-straight-break-fill::before { - content: "\fc90"; -} - -.ph-heart-straight-fill::before { - content: "\fc91"; -} - -.ph-heartbeat-fill::before { - content: "\fc92"; -} - -.ph-hexagon-fill::before { - content: "\fc93"; -} - -.ph-highlighter-circle-fill::before { - content: "\fc94"; -} - -.ph-horse-fill::before { - content: "\fc95"; -} - -.ph-hourglass-fill::before { - content: "\fc96"; -} - -.ph-hourglass-high-fill::before { - content: "\fc97"; -} - -.ph-hourglass-low-fill::before { - content: "\fc98"; -} - -.ph-hourglass-medium-fill::before { - content: "\fc99"; -} - -.ph-hourglass-simple-fill::before { - content: "\fc9a"; -} - -.ph-hourglass-simple-high-fill::before { - content: "\fc9b"; -} - -.ph-hourglass-simple-low-fill::before { - content: "\fc9c"; -} - -.ph-hourglass-simple-medium-fill::before { - content: "\fc9d"; -} - -.ph-house-fill::before { - content: "\fc9e"; -} - -.ph-house-line-fill::before { - content: "\fc9f"; -} - -.ph-house-simple-fill::before { - content: "\fca0"; -} - -.ph-identification-badge-fill::before { - content: "\fca1"; -} - -.ph-identification-card-fill::before { - content: "\fca2"; -} - -.ph-image-fill::before { - content: "\fca3"; -} - -.ph-image-square-fill::before { - content: "\fca4"; -} - -.ph-infinity-fill::before { - content: "\fca5"; -} - -.ph-info-fill::before { - content: "\fca6"; -} - -.ph-instagram-logo-fill::before { - content: "\fca7"; -} - -.ph-intersect-fill::before { - content: "\fca8"; -} - -.ph-jeep-fill::before { - content: "\fca9"; -} - -.ph-kanban-fill::before { - content: "\fcaa"; -} - -.ph-key-fill::before { - content: "\fcab"; -} - -.ph-key-return-fill::before { - content: "\fcac"; -} - -.ph-keyboard-fill::before { - content: "\fcad"; -} - -.ph-keyhole-fill::before { - content: "\fcae"; -} - -.ph-knife-fill::before { - content: "\fcaf"; -} - -.ph-ladder-fill::before { - content: "\fcb0"; -} - -.ph-ladder-simple-fill::before { - content: "\fcb1"; -} - -.ph-lamp-fill::before { - content: "\fcb2"; -} - -.ph-laptop-fill::before { - content: "\fcb3"; -} - -.ph-layout-fill::before { - content: "\fcb4"; -} - -.ph-leaf-fill::before { - content: "\fcb5"; -} - -.ph-lifebuoy-fill::before { - content: "\fcb6"; -} - -.ph-lightbulb-filament-fill::before { - content: "\fcb7"; -} - -.ph-lightbulb-fill::before { - content: "\fcb8"; -} - -.ph-lightning-fill::before { - content: "\fcb9"; -} - -.ph-lightning-slash-fill::before { - content: "\fcba"; -} - -.ph-line-segment-fill::before { - content: "\fcbb"; -} - -.ph-line-segments-fill::before { - content: "\fcbc"; -} - -.ph-link-break-fill::before { - content: "\fcbd"; -} - -.ph-link-fill::before { - content: "\fcbe"; -} - -.ph-link-simple-break-fill::before { - content: "\fcbf"; -} - -.ph-link-simple-fill::before { - content: "\fcc0"; -} - -.ph-link-simple-horizontal-break-fill::before { - content: "\fcc1"; -} - -.ph-link-simple-horizontal-fill::before { - content: "\fcc2"; -} - -.ph-linkedin-logo-fill::before { - content: "\fcc3"; -} - -.ph-linux-logo-fill::before { - content: "\fcc4"; -} - -.ph-list-bullets-fill::before { - content: "\fcc5"; -} - -.ph-list-checks-fill::before { - content: "\fcc6"; -} - -.ph-list-dashes-fill::before { - content: "\fcc7"; -} - -.ph-list-fill::before { - content: "\fcc8"; -} - -.ph-list-numbers-fill::before { - content: "\fcc9"; -} - -.ph-list-plus-fill::before { - content: "\fcca"; -} - -.ph-lock-fill::before { - content: "\fccb"; -} - -.ph-lock-key-fill::before { - content: "\fccc"; -} - -.ph-lock-key-open-fill::before { - content: "\fccd"; -} - -.ph-lock-laminated-fill::before { - content: "\fcce"; -} - -.ph-lock-laminated-open-fill::before { - content: "\fccf"; -} - -.ph-lock-open-fill::before { - content: "\fcd0"; -} - -.ph-lock-simple-fill::before { - content: "\fcd1"; -} - -.ph-lock-simple-open-fill::before { - content: "\fcd2"; -} - -.ph-magic-wand-fill::before { - content: "\fcd3"; -} - -.ph-magnet-fill::before { - content: "\fcd4"; -} - -.ph-magnet-straight-fill::before { - content: "\fcd5"; -} - -.ph-magnifying-glass-fill::before { - content: "\fcd6"; -} - -.ph-magnifying-glass-minus-fill::before { - content: "\fcd7"; -} - -.ph-magnifying-glass-plus-fill::before { - content: "\fcd8"; -} - -.ph-map-pin-fill::before { - content: "\fcd9"; -} - -.ph-map-pin-line-fill::before { - content: "\fcda"; -} - -.ph-map-trifold-fill::before { - content: "\fcdb"; -} - -.ph-marker-circle-fill::before { - content: "\fcdc"; -} - -.ph-martini-fill::before { - content: "\fcdd"; -} - -.ph-mask-happy-fill::before { - content: "\fcde"; -} - -.ph-mask-sad-fill::before { - content: "\fcdf"; -} - -.ph-math-operations-fill::before { - content: "\fce0"; -} - -.ph-medal-fill::before { - content: "\fce1"; -} - -.ph-medium-logo-fill::before { - content: "\fce2"; -} - -.ph-megaphone-fill::before { - content: "\fce3"; -} - -.ph-megaphone-simple-fill::before { - content: "\fce4"; -} - -.ph-messenger-logo-fill::before { - content: "\fce5"; -} - -.ph-microphone-fill::before { - content: "\fce6"; -} - -.ph-microphone-slash-fill::before { - content: "\fce7"; -} - -.ph-microphone-stage-fill::before { - content: "\fce8"; -} - -.ph-microsoft-excel-logo-fill::before { - content: "\fce9"; -} - -.ph-microsoft-powerpoint-logo-fill::before { - content: "\fcea"; -} - -.ph-microsoft-teams-logo-fill::before { - content: "\fceb"; -} - -.ph-microsoft-word-logo-fill::before { - content: "\fcec"; -} - -.ph-minus-circle-fill::before { - content: "\fced"; -} - -.ph-minus-fill::before { - content: "\fcee"; -} - -.ph-money-fill::before { - content: "\fcef"; -} - -.ph-monitor-fill::before { - content: "\fcf0"; -} - -.ph-monitor-play-fill::before { - content: "\fcf1"; -} - -.ph-moon-fill::before { - content: "\fcf2"; -} - -.ph-moon-stars-fill::before { - content: "\fcf3"; -} - -.ph-mountains-fill::before { - content: "\fcf4"; -} - -.ph-mouse-fill::before { - content: "\fcf5"; -} - -.ph-mouse-simple-fill::before { - content: "\fcf6"; -} - -.ph-music-note-fill::before { - content: "\fcf7"; -} - -.ph-music-note-simple-fill::before { - content: "\fcf8"; -} - -.ph-music-notes-fill::before { - content: "\fcf9"; -} - -.ph-music-notes-plus-fill::before { - content: "\fcfa"; -} - -.ph-music-notes-simple-fill::before { - content: "\fcfb"; -} - -.ph-navigation-arrow-fill::before { - content: "\fcfc"; -} - -.ph-needle-fill::before { - content: "\fcfd"; -} - -.ph-newspaper-clipping-fill::before { - content: "\fcfe"; -} - -.ph-newspaper-fill::before { - content: "\fcff"; -} - -.ph-note-blank-fill::before { - content: "\fd00"; -} - -.ph-note-fill::before { - content: "\fd01"; -} - -.ph-note-pencil-fill::before { - content: "\fd02"; -} - -.ph-notebook-fill::before { - content: "\fd03"; -} - -.ph-notepad-fill::before { - content: "\fd04"; -} - -.ph-notification-fill::before { - content: "\fd05"; -} - -.ph-number-circle-eight-fill::before { - content: "\fd06"; -} - -.ph-number-circle-five-fill::before { - content: "\fd07"; -} - -.ph-number-circle-four-fill::before { - content: "\fd08"; -} - -.ph-number-circle-nine-fill::before { - content: "\fd09"; -} - -.ph-number-circle-one-fill::before { - content: "\fd0a"; -} - -.ph-number-circle-seven-fill::before { - content: "\fd0b"; -} - -.ph-number-circle-six-fill::before { - content: "\fd0c"; -} - -.ph-number-circle-three-fill::before { - content: "\fd0d"; -} - -.ph-number-circle-two-fill::before { - content: "\fd0e"; -} - -.ph-number-circle-zero-fill::before { - content: "\fd0f"; -} - -.ph-number-eight-fill::before { - content: "\fd10"; -} - -.ph-number-five-fill::before { - content: "\fd11"; -} - -.ph-number-four-fill::before { - content: "\fd12"; -} - -.ph-number-nine-fill::before { - content: "\fd13"; -} - -.ph-number-one-fill::before { - content: "\fd14"; -} - -.ph-number-seven-fill::before { - content: "\fd15"; -} - -.ph-number-six-fill::before { - content: "\fd16"; -} - -.ph-number-square-eight-fill::before { - content: "\fd17"; -} - -.ph-number-square-five-fill::before { - content: "\fd18"; -} - -.ph-number-square-four-fill::before { - content: "\fd19"; -} - -.ph-number-square-nine-fill::before { - content: "\fd1a"; -} - -.ph-number-square-one-fill::before { - content: "\fd1b"; -} - -.ph-number-square-seven-fill::before { - content: "\fd1c"; -} - -.ph-number-square-six-fill::before { - content: "\fd1d"; -} - -.ph-number-square-three-fill::before { - content: "\fd1e"; -} - -.ph-number-square-two-fill::before { - content: "\fd1f"; -} - -.ph-number-square-zero-fill::before { - content: "\fd20"; -} - -.ph-number-three-fill::before { - content: "\fd21"; -} - -.ph-number-two-fill::before { - content: "\fd22"; -} - -.ph-number-zero-fill::before { - content: "\fd23"; -} - -.ph-nut-fill::before { - content: "\fd24"; -} - -.ph-ny-times-logo-fill::before { - content: "\fd25"; -} - -.ph-octagon-fill::before { - content: "\fd26"; -} - -.ph-option-fill::before { - content: "\fd27"; -} - -.ph-package-fill::before { - content: "\fd28"; -} - -.ph-paint-brush-broad-fill::before { - content: "\fd29"; -} - -.ph-paint-brush-fill::before { - content: "\fd2a"; -} - -.ph-paint-brush-household-fill::before { - content: "\fd2b"; -} - -.ph-paint-bucket-fill::before { - content: "\fd2c"; -} - -.ph-paint-roller-fill::before { - content: "\fd2d"; -} - -.ph-palette-fill::before { - content: "\fd2e"; -} - -.ph-paper-plane-fill::before { - content: "\fd2f"; -} - -.ph-paper-plane-right-fill::before { - content: "\fd30"; -} - -.ph-paper-plane-tilt-fill::before { - content: "\fd31"; -} - -.ph-paperclip-fill::before { - content: "\fd32"; -} - -.ph-paperclip-horizontal-fill::before { - content: "\fd33"; -} - -.ph-parachute-fill::before { - content: "\fd34"; -} - -.ph-password-fill::before { - content: "\fd35"; -} - -.ph-path-fill::before { - content: "\fd36"; -} - -.ph-pause-circle-fill::before { - content: "\fd37"; -} - -.ph-pause-fill::before { - content: "\fd38"; -} - -.ph-paw-print-fill::before { - content: "\fd39"; -} - -.ph-peace-fill::before { - content: "\fd3a"; -} - -.ph-pen-fill::before { - content: "\fd3b"; -} - -.ph-pen-nib-fill::before { - content: "\fd3c"; -} - -.ph-pen-nib-straight-fill::before { - content: "\fd3d"; -} - -.ph-pencil-circle-fill::before { - content: "\fd3e"; -} - -.ph-pencil-fill::before { - content: "\fd3f"; -} - -.ph-pencil-line-fill::before { - content: "\fd40"; -} - -.ph-pencil-simple-fill::before { - content: "\fd41"; -} - -.ph-pencil-simple-line-fill::before { - content: "\fd42"; -} - -.ph-percent-fill::before { - content: "\fd43"; -} - -.ph-person-fill::before { - content: "\fd44"; -} - -.ph-person-simple-fill::before { - content: "\fd45"; -} - -.ph-person-simple-run-fill::before { - content: "\fd46"; -} - -.ph-person-simple-walk-fill::before { - content: "\fd47"; -} - -.ph-perspective-fill::before { - content: "\fd48"; -} - -.ph-phone-call-fill::before { - content: "\fd49"; -} - -.ph-phone-disconnect-fill::before { - content: "\fd4a"; -} - -.ph-phone-fill::before { - content: "\fd4b"; -} - -.ph-phone-incoming-fill::before { - content: "\fd4c"; -} - -.ph-phone-outgoing-fill::before { - content: "\fd4d"; -} - -.ph-phone-slash-fill::before { - content: "\fd4e"; -} - -.ph-phone-x-fill::before { - content: "\fd4f"; -} - -.ph-phosphor-logo-fill::before { - content: "\fd50"; -} - -.ph-piano-keys-fill::before { - content: "\fd51"; -} - -.ph-picture-in-picture-fill::before { - content: "\fd52"; -} - -.ph-pill-fill::before { - content: "\fd53"; -} - -.ph-pinterest-logo-fill::before { - content: "\fd54"; -} - -.ph-pinwheel-fill::before { - content: "\fd55"; -} - -.ph-pizza-fill::before { - content: "\fd56"; -} - -.ph-placeholder-fill::before { - content: "\fd57"; -} - -.ph-planet-fill::before { - content: "\fd58"; -} - -.ph-play-circle-fill::before { - content: "\fd59"; -} - -.ph-play-fill::before { - content: "\fd5a"; -} - -.ph-playlist-fill::before { - content: "\fd5b"; -} - -.ph-plug-fill::before { - content: "\fd5c"; -} - -.ph-plugs-connected-fill::before { - content: "\fd5d"; -} - -.ph-plugs-fill::before { - content: "\fd5e"; -} - -.ph-plus-circle-fill::before { - content: "\fd5f"; -} - -.ph-plus-fill::before { - content: "\fd60"; -} - -.ph-plus-minus-fill::before { - content: "\fd61"; -} - -.ph-poker-chip-fill::before { - content: "\fd62"; -} - -.ph-police-car-fill::before { - content: "\fd63"; -} - -.ph-polygon-fill::before { - content: "\fd64"; -} - -.ph-popcorn-fill::before { - content: "\fd65"; -} - -.ph-power-fill::before { - content: "\fd66"; -} - -.ph-prescription-fill::before { - content: "\fd67"; -} - -.ph-presentation-chart-fill::before { - content: "\fd68"; -} - -.ph-presentation-fill::before { - content: "\fd69"; -} - -.ph-printer-fill::before { - content: "\fd6a"; -} - -.ph-prohibit-fill::before { - content: "\fd6b"; -} - -.ph-prohibit-inset-fill::before { - content: "\fd6c"; -} - -.ph-projector-screen-chart-fill::before { - content: "\fd6d"; -} - -.ph-projector-screen-fill::before { - content: "\fd6e"; -} - -.ph-push-pin-fill::before { - content: "\fd6f"; -} - -.ph-push-pin-simple-fill::before { - content: "\fd70"; -} - -.ph-push-pin-simple-slash-fill::before { - content: "\fd71"; -} - -.ph-push-pin-slash-fill::before { - content: "\fd72"; -} - -.ph-puzzle-piece-fill::before { - content: "\fd73"; -} - -.ph-qr-code-fill::before { - content: "\fd74"; -} - -.ph-question-fill::before { - content: "\fd75"; -} - -.ph-queue-fill::before { - content: "\fd76"; -} - -.ph-quotes-fill::before { - content: "\fd77"; -} - -.ph-radical-fill::before { - content: "\fd78"; -} - -.ph-radio-button-fill::before { - content: "\fd79"; -} - -.ph-radio-fill::before { - content: "\fd7a"; -} - -.ph-rainbow-cloud-fill::before { - content: "\fd7b"; -} - -.ph-rainbow-fill::before { - content: "\fd7c"; -} - -.ph-receipt-fill::before { - content: "\fd7d"; -} - -.ph-record-fill::before { - content: "\fd7e"; -} - -.ph-rectangle-fill::before { - content: "\fd7f"; -} - -.ph-recycle-fill::before { - content: "\fd80"; -} - -.ph-reddit-logo-fill::before { - content: "\fd81"; -} - -.ph-repeat-fill::before { - content: "\fd82"; -} - -.ph-repeat-once-fill::before { - content: "\fd83"; -} - -.ph-rewind-circle-fill::before { - content: "\fd84"; -} - -.ph-rewind-fill::before { - content: "\fd85"; -} - -.ph-robot-fill::before { - content: "\fd86"; -} - -.ph-rocket-fill::before { - content: "\fd87"; -} - -.ph-rocket-launch-fill::before { - content: "\fd88"; -} - -.ph-rows-fill::before { - content: "\fd89"; -} - -.ph-rss-fill::before { - content: "\fd8a"; -} - -.ph-rss-simple-fill::before { - content: "\fd8b"; -} - -.ph-rug-fill::before { - content: "\fd8c"; -} - -.ph-ruler-fill::before { - content: "\fd8d"; -} - -.ph-scales-fill::before { - content: "\fd8e"; -} - -.ph-scan-fill::before { - content: "\fd8f"; -} - -.ph-scissors-fill::before { - content: "\fd90"; -} - -.ph-screencast-fill::before { - content: "\fd91"; -} - -.ph-scribble-loop-fill::before { - content: "\fd92"; -} - -.ph-scroll-fill::before { - content: "\fd93"; -} - -.ph-selection-all-fill::before { - content: "\fd94"; -} - -.ph-selection-background-fill::before { - content: "\fd95"; -} - -.ph-selection-fill::before { - content: "\fd96"; -} - -.ph-selection-foreground-fill::before { - content: "\fd97"; -} - -.ph-selection-inverse-fill::before { - content: "\fd98"; -} - -.ph-selection-plus-fill::before { - content: "\fd99"; -} - -.ph-selection-slash-fill::before { - content: "\fd9a"; -} - -.ph-share-fill::before { - content: "\fd9b"; -} - -.ph-share-network-fill::before { - content: "\fd9c"; -} - -.ph-shield-check-fill::before { - content: "\fd9d"; -} - -.ph-shield-checkered-fill::before { - content: "\fd9e"; -} - -.ph-shield-chevron-fill::before { - content: "\fd9f"; -} - -.ph-shield-fill::before { - content: "\fda0"; -} - -.ph-shield-plus-fill::before { - content: "\fda1"; -} - -.ph-shield-slash-fill::before { - content: "\fda2"; -} - -.ph-shield-star-fill::before { - content: "\fda3"; -} - -.ph-shield-warning-fill::before { - content: "\fda4"; -} - -.ph-shopping-bag-fill::before { - content: "\fda5"; -} - -.ph-shopping-bag-open-fill::before { - content: "\fda6"; -} - -.ph-shopping-cart-fill::before { - content: "\fda7"; -} - -.ph-shopping-cart-simple-fill::before { - content: "\fda8"; -} - -.ph-shower-fill::before { - content: "\fda9"; -} - -.ph-shuffle-angular-fill::before { - content: "\fdaa"; -} - -.ph-shuffle-fill::before { - content: "\fdab"; -} - -.ph-shuffle-simple-fill::before { - content: "\fdac"; -} - -.ph-sidebar-fill::before { - content: "\fdad"; -} - -.ph-sidebar-simple-fill::before { - content: "\fdae"; -} - -.ph-sign-in-fill::before { - content: "\fdaf"; -} - -.ph-sign-out-fill::before { - content: "\fdb0"; -} - -.ph-signpost-fill::before { - content: "\fdb1"; -} - -.ph-sim-card-fill::before { - content: "\fdb2"; -} - -.ph-sketch-logo-fill::before { - content: "\fdb3"; -} - -.ph-skip-back-circle-fill::before { - content: "\fdb4"; -} - -.ph-skip-back-fill::before { - content: "\fdb5"; -} - -.ph-skip-forward-circle-fill::before { - content: "\fdb6"; -} - -.ph-skip-forward-fill::before { - content: "\fdb7"; -} - -.ph-skull-fill::before { - content: "\fdb8"; -} - -.ph-slack-logo-fill::before { - content: "\fdb9"; -} - -.ph-sliders-fill::before { - content: "\fdba"; -} - -.ph-sliders-horizontal-fill::before { - content: "\fdbb"; -} - -.ph-smiley-blank-fill::before { - content: "\fdbc"; -} - -.ph-smiley-fill::before { - content: "\fdbd"; -} - -.ph-smiley-meh-fill::before { - content: "\fdbe"; -} - -.ph-smiley-nervous-fill::before { - content: "\fdbf"; -} - -.ph-smiley-sad-fill::before { - content: "\fdc0"; -} - -.ph-smiley-sticker-fill::before { - content: "\fdc1"; -} - -.ph-smiley-wink-fill::before { - content: "\fdc2"; -} - -.ph-smiley-x-eyes-fill::before { - content: "\fdc3"; -} - -.ph-snapchat-logo-fill::before { - content: "\fdc4"; -} - -.ph-snowflake-fill::before { - content: "\fdc5"; -} - -.ph-soccer-ball-fill::before { - content: "\fdc6"; -} - -.ph-sort-ascending-fill::before { - content: "\fdc7"; -} - -.ph-sort-descending-fill::before { - content: "\fdc8"; -} - -.ph-spade-fill::before { - content: "\fdc9"; -} - -.ph-sparkle-fill::before { - content: "\fdca"; -} - -.ph-speaker-high-fill::before { - content: "\fdcb"; -} - -.ph-speaker-low-fill::before { - content: "\fdcc"; -} - -.ph-speaker-none-fill::before { - content: "\fdcd"; -} - -.ph-speaker-simple-high-fill::before { - content: "\fdce"; -} - -.ph-speaker-simple-low-fill::before { - content: "\fdcf"; -} - -.ph-speaker-simple-none-fill::before { - content: "\fdd0"; -} - -.ph-speaker-simple-slash-fill::before { - content: "\fdd1"; -} - -.ph-speaker-simple-x-fill::before { - content: "\fdd2"; -} - -.ph-speaker-slash-fill::before { - content: "\fdd3"; -} - -.ph-speaker-x-fill::before { - content: "\fdd4"; -} - -.ph-spinner-fill::before { - content: "\fdd5"; -} - -.ph-spinner-gap-fill::before { - content: "\fdd6"; -} - -.ph-spiral-fill::before { - content: "\fdd7"; -} - -.ph-spotify-logo-fill::before { - content: "\fdd8"; -} - -.ph-square-fill::before { - content: "\fdd9"; -} - -.ph-square-half-bottom-fill::before { - content: "\fdda"; -} - -.ph-square-half-fill::before { - content: "\fddb"; -} - -.ph-square-logo-fill::before { - content: "\fddc"; -} - -.ph-squares-four-fill::before { - content: "\fddd"; -} - -.ph-stack-fill::before { - content: "\fdde"; -} - -.ph-stack-overflow-logo-fill::before { - content: "\fddf"; -} - -.ph-stack-simple-fill::before { - content: "\fde0"; -} - -.ph-stamp-fill::before { - content: "\fde1"; -} - -.ph-star-fill::before { - content: "\fde2"; -} - -.ph-star-four-fill::before { - content: "\fde3"; -} - -.ph-star-half-fill::before { - content: "\fde4"; -} - -.ph-sticker-fill::before { - content: "\fde5"; -} - -.ph-stop-circle-fill::before { - content: "\fde6"; -} - -.ph-stop-fill::before { - content: "\fde7"; -} - -.ph-storefront-fill::before { - content: "\fde8"; -} - -.ph-strategy-fill::before { - content: "\fde9"; -} - -.ph-stripe-logo-fill::before { - content: "\fdea"; -} - -.ph-student-fill::before { - content: "\fdeb"; -} - -.ph-suitcase-fill::before { - content: "\fdec"; -} - -.ph-suitcase-simple-fill::before { - content: "\fded"; -} - -.ph-sun-dim-fill::before { - content: "\fdee"; -} - -.ph-sun-fill::before { - content: "\fdef"; -} - -.ph-sun-horizon-fill::before { - content: "\fdf0"; -} - -.ph-sunglasses-fill::before { - content: "\fdf1"; -} - -.ph-swap-fill::before { - content: "\fdf2"; -} - -.ph-swatches-fill::before { - content: "\fdf3"; -} - -.ph-sword-fill::before { - content: "\fdf4"; -} - -.ph-syringe-fill::before { - content: "\fdf5"; -} - -.ph-t-shirt-fill::before { - content: "\fdf6"; -} - -.ph-table-fill::before { - content: "\fdf7"; -} - -.ph-tabs-fill::before { - content: "\fdf8"; -} - -.ph-tag-chevron-fill::before { - content: "\fdf9"; -} - -.ph-tag-fill::before { - content: "\fdfa"; -} - -.ph-tag-simple-fill::before { - content: "\fdfb"; -} - -.ph-target-fill::before { - content: "\fdfc"; -} - -.ph-taxi-fill::before { - content: "\fdfd"; -} - -.ph-telegram-logo-fill::before { - content: "\fdfe"; -} - -.ph-television-fill::before { - content: "\fdff"; -} - -.ph-television-simple-fill::before { - content: "\fe00"; -} - -.ph-tennis-ball-fill::before { - content: "\fe01"; -} - -.ph-terminal-fill::before { - content: "\fe02"; -} - -.ph-terminal-window-fill::before { - content: "\fe03"; -} - -.ph-test-tube-fill::before { - content: "\fe04"; -} - -.ph-text-aa-fill::before { - content: "\fe05"; -} - -.ph-text-align-center-fill::before { - content: "\fe06"; -} - -.ph-text-align-justify-fill::before { - content: "\fe07"; -} - -.ph-text-align-left-fill::before { - content: "\fe08"; -} - -.ph-text-align-right-fill::before { - content: "\fe09"; -} - -.ph-text-bolder-fill::before { - content: "\fe0a"; -} - -.ph-text-h-fill::before { - content: "\fe0b"; -} - -.ph-text-h-five-fill::before { - content: "\fe0c"; -} - -.ph-text-h-four-fill::before { - content: "\fe0d"; -} - -.ph-text-h-one-fill::before { - content: "\fe0e"; -} - -.ph-text-h-six-fill::before { - content: "\fe0f"; -} - -.ph-text-h-three-fill::before { - content: "\fe10"; -} - -.ph-text-h-two-fill::before { - content: "\fe11"; -} - -.ph-text-indent-fill::before { - content: "\fe12"; -} - -.ph-text-italic-fill::before { - content: "\fe13"; -} - -.ph-text-outdent-fill::before { - content: "\fe14"; -} - -.ph-text-strikethrough-fill::before { - content: "\fe15"; -} - -.ph-text-t-fill::before { - content: "\fe16"; -} - -.ph-text-underline-fill::before { - content: "\fe17"; -} - -.ph-textbox-fill::before { - content: "\fe18"; -} - -.ph-thermometer-cold-fill::before { - content: "\fe19"; -} - -.ph-thermometer-fill::before { - content: "\fe1a"; -} - -.ph-thermometer-hot-fill::before { - content: "\fe1b"; -} - -.ph-thermometer-simple-fill::before { - content: "\fe1c"; -} - -.ph-thumbs-down-fill::before { - content: "\fe1d"; -} - -.ph-thumbs-up-fill::before { - content: "\fe1e"; -} - -.ph-ticket-fill::before { - content: "\fe1f"; -} - -.ph-tiktok-logo-fill::before { - content: "\fe20"; -} - -.ph-timer-fill::before { - content: "\fe21"; -} - -.ph-toggle-left-fill::before { - content: "\fe22"; -} - -.ph-toggle-right-fill::before { - content: "\fe23"; -} - -.ph-toilet-fill::before { - content: "\fe24"; -} - -.ph-toilet-paper-fill::before { - content: "\fe25"; -} - -.ph-tote-fill::before { - content: "\fe26"; -} - -.ph-tote-simple-fill::before { - content: "\fe27"; -} - -.ph-trademark-registered-fill::before { - content: "\fe28"; -} - -.ph-traffic-cone-fill::before { - content: "\fe29"; -} - -.ph-traffic-sign-fill::before { - content: "\fe2a"; -} - -.ph-traffic-signal-fill::before { - content: "\fe2b"; -} - -.ph-train-fill::before { - content: "\fe2c"; -} - -.ph-train-regional-fill::before { - content: "\fe2d"; -} - -.ph-train-simple-fill::before { - content: "\fe2e"; -} - -.ph-translate-fill::before { - content: "\fe2f"; -} - -.ph-trash-fill::before { - content: "\fe30"; -} - -.ph-trash-simple-fill::before { - content: "\fe31"; -} - -.ph-tray-fill::before { - content: "\fe32"; -} - -.ph-tree-evergreen-fill::before { - content: "\fe33"; -} - -.ph-tree-fill::before { - content: "\fe34"; -} - -.ph-tree-structure-fill::before { - content: "\fe35"; -} - -.ph-trend-down-fill::before { - content: "\fe36"; -} - -.ph-trend-up-fill::before { - content: "\fe37"; -} - -.ph-triangle-fill::before { - content: "\fe38"; -} - -.ph-trophy-fill::before { - content: "\fe39"; -} - -.ph-truck-fill::before { - content: "\fe3a"; -} - -.ph-twitch-logo-fill::before { - content: "\fe3b"; -} - -.ph-twitter-logo-fill::before { - content: "\fe3c"; -} - -.ph-umbrella-fill::before { - content: "\fe3d"; -} - -.ph-umbrella-simple-fill::before { - content: "\fe3e"; -} - -.ph-upload-fill::before { - content: "\fe3f"; -} - -.ph-upload-simple-fill::before { - content: "\fe40"; -} - -.ph-user-circle-fill::before { - content: "\fe41"; -} - -.ph-user-circle-gear-fill::before { - content: "\fe42"; -} - -.ph-user-circle-minus-fill::before { - content: "\fe43"; -} - -.ph-user-circle-plus-fill::before { - content: "\fe44"; -} - -.ph-user-fill::before { - content: "\fe45"; -} - -.ph-user-focus-fill::before { - content: "\fe46"; -} - -.ph-user-gear-fill::before { - content: "\fe47"; -} - -.ph-user-list-fill::before { - content: "\fe48"; -} - -.ph-user-minus-fill::before { - content: "\fe49"; -} - -.ph-user-plus-fill::before { - content: "\fe4a"; -} - -.ph-user-rectangle-fill::before { - content: "\fe4b"; -} - -.ph-user-square-fill::before { - content: "\fe4c"; -} - -.ph-user-switch-fill::before { - content: "\fe4d"; -} - -.ph-users-fill::before { - content: "\fe4e"; -} - -.ph-users-four-fill::before { - content: "\fe4f"; -} - -.ph-users-three-fill::before { - content: "\fe50"; -} - -.ph-vault-fill::before { - content: "\fe51"; -} - -.ph-vibrate-fill::before { - content: "\fe52"; -} - -.ph-video-camera-fill::before { - content: "\fe53"; -} - -.ph-video-camera-slash-fill::before { - content: "\fe54"; -} - -.ph-vignette-fill::before { - content: "\fe55"; -} - -.ph-voicemail-fill::before { - content: "\fe56"; -} - -.ph-volleyball-fill::before { - content: "\fe57"; -} - -.ph-wall-fill::before { - content: "\fe58"; -} - -.ph-wallet-fill::before { - content: "\fe59"; -} - -.ph-warning-circle-fill::before { - content: "\fe5a"; -} - -.ph-warning-fill::before { - content: "\fe5b"; -} - -.ph-warning-octagon-fill::before { - content: "\fe5c"; -} - -.ph-watch-fill::before { - content: "\fe5d"; -} - -.ph-wave-sawtooth-fill::before { - content: "\fe5e"; -} - -.ph-wave-sine-fill::before { - content: "\fe5f"; -} - -.ph-wave-square-fill::before { - content: "\fe60"; -} - -.ph-wave-triangle-fill::before { - content: "\fe61"; -} - -.ph-waves-fill::before { - content: "\fe62"; -} - -.ph-webcam-fill::before { - content: "\fe63"; -} - -.ph-whatsapp-logo-fill::before { - content: "\fe64"; -} - -.ph-wheelchair-fill::before { - content: "\fe65"; -} - -.ph-wifi-high-fill::before { - content: "\fe66"; -} - -.ph-wifi-low-fill::before { - content: "\fe67"; -} - -.ph-wifi-medium-fill::before { - content: "\fe68"; -} - -.ph-wifi-none-fill::before { - content: "\fe69"; -} - -.ph-wifi-slash-fill::before { - content: "\fe6a"; -} - -.ph-wifi-x-fill::before { - content: "\fe6b"; -} - -.ph-wind-fill::before { - content: "\fe6c"; -} - -.ph-windows-logo-fill::before { - content: "\fe6d"; -} - -.ph-wine-fill::before { - content: "\fe6e"; -} - -.ph-wrench-fill::before { - content: "\fe6f"; -} - -.ph-x-circle-fill::before { - content: "\fe70"; -} - -.ph-x-fill::before { - content: "\fe71"; -} - -.ph-x-square-fill::before { - content: "\fe72"; -} - -.ph-yin-yang-fill::before { - content: "\fe73"; -} - -.ph-youtube-logo-fill::before { - content: "\fe74"; -} diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot b/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot deleted file mode 100644 index 2af0b72..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot +++ /dev/null Binary files differ diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg b/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg deleted file mode 100644 index 8a51454..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg +++ /dev/null @@ -1,15725 +0,0 @@ - - - -{ - "author": "Phosphor Icons", - "description": "A friendly icon family for everyone", - "version": "1.4", - "copyright": "Phosphor Icons", - "license": "MIT", - "url": "https://phosphoricons.com" -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf b/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf deleted file mode 100644 index 2145d9b..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf +++ /dev/null Binary files differ diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff b/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff deleted file mode 100644 index 2f11770..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff +++ /dev/null Binary files differ diff --git a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 b/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 deleted file mode 100644 index 596a6fd..0000000 --- a/webclient/dist/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 +++ /dev/null Binary files differ diff --git a/webclient/dist/assets/index-Bg3aWTEG.css b/webclient/dist/assets/index-Bg3aWTEG.css new file mode 100644 index 0000000..3525342 --- /dev/null +++ b/webclient/dist/assets/index-Bg3aWTEG.css @@ -0,0 +1 @@ +@charset "UTF-8";.container[data-v-308a2eeb]{padding:18px}.section[data-v-308a2eeb]{margin-bottom:48px}.section-title[data-v-308a2eeb],.block[data-v-308a2eeb]{margin-bottom:34px}.block-title[data-v-308a2eeb]{margin-bottom:22px}p[data-v-308a2eeb],.text[data-v-308a2eeb]{margin-bottom:15px}.hint[data-v-308a2eeb]{margin-top:8px}.list[data-v-308a2eeb]{padding-left:22px;margin-bottom:15px}.list-item[data-v-308a2eeb]{margin-bottom:8px}.list-nested[data-v-308a2eeb]{margin-top:8px}.table[data-v-308a2eeb]{margin-bottom:22px}.table-caption[data-v-308a2eeb]{margin-bottom:8px}.form-group[data-v-308a2eeb]{margin-bottom:15px}.label[data-v-308a2eeb]{margin-bottom:5px;display:block}.input[data-v-308a2eeb],.textarea[data-v-308a2eeb],.select[data-v-308a2eeb]{margin-top:5px}.toast[data-v-308a2eeb]{padding:15px}.toast-stack[data-v-308a2eeb]{gap:8px}.search-highlight[data-v-308a2eeb]{background:#7aa2f740;color:#7aa2f7;font-weight:600;padding:0 2px;border-radius:2px}.session-name-row[data-v-308a2eeb]{display:flex;align-items:center;gap:6px;font-weight:500;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.recall-badge[data-v-308a2eeb]{color:var(--gn-color-accent);font-size:.85em;flex-shrink:0}.session-list-wrap[data-v-306ab182]{flex:1;overflow:hidden;display:flex;flex-direction:column}.session-scroller[data-v-306ab182]{flex:1;overflow-y:auto}.empty-sessions[data-v-306ab182]{display:flex;flex-direction:column;align-items:center;gap:8px;padding:32px 16px;color:var(--gn-color-text-dark);font-size:13px}.empty-sessions i[data-v-306ab182]{font-size:32px;opacity:.4}.empty-sessions p[data-v-306ab182]{margin:0}.sessions-loading[data-v-306ab182]{display:flex;align-items:center;justify-content:center;gap:10px;padding:28px 16px;color:var(--gn-color-text-dark);font-size:12px}.sessions-loading-more[data-v-306ab182]{padding:10px 16px 14px}.sessions-spinner[data-v-306ab182]{width:16px;height:16px;border:2px solid var(--gn-border-color-muted);border-top-color:var(--gn-color-secondary);border-radius:50%;animation:sessions-spin-306ab182 .8s linear infinite}@keyframes sessions-spin-306ab182{to{transform:rotate(360deg)}}.ptr-indicator[data-v-306ab182]{position:absolute;top:0;left:0;right:0;z-index:10;display:flex;align-items:center;justify-content:center;gap:8px;padding:8px;font-size:12px;color:var(--gn-color-text-dark);pointer-events:none;transition:opacity .15s,transform .15s;will-change:transform,opacity}.ptr-spinner[data-v-306ab182]{width:16px;height:16px;border:2px solid var(--gn-border-color-muted);border-top-color:var(--gn-color-secondary);border-radius:50%;transition:transform .15s}.ptr-spinning[data-v-306ab182]{animation:sessions-spin-306ab182 .8s linear infinite}.ptr-pulled[data-v-306ab182]{transition:transform .15s}@media(min-width:769px){.ptr-indicator[data-v-306ab182]{display:none}}.container[data-v-7de86c3c]{padding:18px}.section[data-v-7de86c3c]{margin-bottom:48px}.section-title[data-v-7de86c3c],.block[data-v-7de86c3c]{margin-bottom:34px}.block-title[data-v-7de86c3c]{margin-bottom:22px}p[data-v-7de86c3c],.text[data-v-7de86c3c]{margin-bottom:15px}.hint[data-v-7de86c3c]{margin-top:8px}.list[data-v-7de86c3c]{padding-left:22px;margin-bottom:15px}.list-item[data-v-7de86c3c]{margin-bottom:8px}.list-nested[data-v-7de86c3c]{margin-top:8px}.table[data-v-7de86c3c]{margin-bottom:22px}.table-caption[data-v-7de86c3c]{margin-bottom:8px}.form-group[data-v-7de86c3c]{margin-bottom:15px}.label[data-v-7de86c3c]{margin-bottom:5px;display:block}.input[data-v-7de86c3c],.textarea[data-v-7de86c3c],.select[data-v-7de86c3c]{margin-top:5px}.toast[data-v-7de86c3c]{padding:15px}.toast-stack[data-v-7de86c3c]{gap:8px}.sidebar-close-btn[data-v-7de86c3c]{display:none}@media(max-width:1279.98px){.sidebar-close-btn[data-v-7de86c3c]{display:flex}}.sidebar-search[data-v-7de86c3c]{display:none;padding:0 15px}.sidebar-search.is-open[data-v-7de86c3c]{display:block;padding-top:8px;padding-bottom:8px;border-bottom:1px solid var(--gn-border-color-muted)}.sidebar-search-inner[data-v-7de86c3c]{position:relative;display:flex;align-items:center;gap:5px}.sidebar-search-inner[data-v-7de86c3c] .search-field{flex:1;min-width:0}.sidebar-search-inner.is-loading[data-v-7de86c3c] .input-group-addon{position:relative!important}.sidebar-search-inner.is-loading[data-v-7de86c3c] .input-group-addon>i{display:none!important}.sidebar-search-inner.is-loading[data-v-7de86c3c] .input-group-addon:after{content:"";display:block;width:12px;height:12px;border:2px solid rgba(192,202,245,.24);border-top-color:#7aa2f7;border-radius:50%;animation:spin .6s linear infinite;margin:auto}.sessions-profiles[data-v-7de86c3c]{display:flex;gap:6px;padding:8px 15px 5px;overflow-x:auto;overscroll-behavior-x:contain;scrollbar-width:none}.sessions-profiles[data-v-7de86c3c]::-webkit-scrollbar{display:none}.sessions-profiles .chip[data-v-7de86c3c]{flex:0 0 auto}.sessions-profiles[data-v-7de86c3c] .chip:before{display:none}.sessions-header-actions[data-v-7de86c3c]{display:flex;align-items:center;gap:2px}.search-toggle-btn[data-v-7de86c3c]{font-size:14px;color:#787c99;transition:color .15s}.search-toggle-btn.active[data-v-7de86c3c],.search-toggle-btn[data-v-7de86c3c]:hover{color:#c0caf5}.recall-filter-btn[data-v-7de86c3c]{font-size:14px;color:#787c99;transition:color .15s}.recall-filter-btn.active[data-v-7de86c3c],.recall-filter-btn[data-v-7de86c3c]:hover{color:var(--gn-color-secondary)}.special-filter-btn[data-v-7de86c3c]{font-size:14px;color:#787c99;transition:color .15s}.special-filter-btn.active[data-v-7de86c3c],.special-filter-btn[data-v-7de86c3c]:hover{color:var(--gn-color-secondary)}.sidebar-footer[data-v-7de86c3c]{padding:12px 16px;border-top:1px solid var(--gn-border-color-muted);display:flex;align-items:center;justify-content:space-between;gap:8px}.user-info[data-v-7de86c3c]{display:flex;align-items:center;gap:8px;text-decoration:none;color:inherit;flex:1;min-width:0;cursor:pointer}.user-info:hover .user-name[data-v-7de86c3c]{color:var(--gn-color-text-light)}.user-name[data-v-7de86c3c]{font-size:13px;color:var(--gn-color-text-medium);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sidebar-footer-actions[data-v-7de86c3c]{display:flex;align-items:center;gap:8px}.admin-link[data-v-7de86c3c]{text-decoration:none}.lightbox-dialog{max-width:90vw;min-width:280px}body .modal .lightbox-dialog .lightbox-panel{justify-content:center;cursor:default}body .modal .lightbox-panel .modal-body{max-height:90vh;padding:0;display:flex;align-items:center;justify-content:center}.lightbox-img{display:block;width:auto;height:auto;max-width:100%;max-height:90vh}.lightbox-error{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;padding:32px;color:var(--gn-color-text-dark);font-size:13px}.lightbox-error i{font-size:32px}.selection-toolbar[data-v-b94aaefd]{position:fixed;transform:translate(-50%);z-index:900;pointer-events:all;background:var(--gn-color-warning);color:var(--gn-color-black)}.container[data-v-07ae46cf]{padding:18px}.section[data-v-07ae46cf]{margin-bottom:48px}.section-title[data-v-07ae46cf],.block[data-v-07ae46cf]{margin-bottom:34px}.block-title[data-v-07ae46cf]{margin-bottom:22px}p[data-v-07ae46cf],.text[data-v-07ae46cf]{margin-bottom:15px}.hint[data-v-07ae46cf]{margin-top:8px}.list[data-v-07ae46cf]{padding-left:22px;margin-bottom:15px}.list-item[data-v-07ae46cf]{margin-bottom:8px}.list-nested[data-v-07ae46cf]{margin-top:8px}.table[data-v-07ae46cf]{margin-bottom:22px}.table-caption[data-v-07ae46cf]{margin-bottom:8px}.form-group[data-v-07ae46cf]{margin-bottom:15px}.label[data-v-07ae46cf]{margin-bottom:5px;display:block}.input[data-v-07ae46cf],.textarea[data-v-07ae46cf],.select[data-v-07ae46cf]{margin-top:5px}.toast[data-v-07ae46cf]{padding:15px}.toast-stack[data-v-07ae46cf]{gap:8px}.artifacts-panel[data-v-07ae46cf]{container-type:inline-size;width:var(--artifacts-width, min(600px, 42vw));min-width:var(--artifacts-width, min(600px, 42vw));max-width:var(--artifacts-width, min(600px, 42vw));display:flex;flex-direction:column;background:var(--gn-color-black);border-left:2px solid var(--gn-border-color-muted);min-height:0;margin-right:calc(-1 * var(--artifacts-width, min(600px, 42vw)));opacity:0;pointer-events:none;transform:translate(100%);position:relative;transition:margin-right .22s ease,opacity .22s ease,transform .22s ease}.artifacts-panel.is-open[data-v-07ae46cf]{margin-right:0;opacity:1;pointer-events:auto;transform:translate(0)}.artifacts-panel.is-resizing[data-v-07ae46cf]{transition:none}.artifacts-resize-handle[data-v-07ae46cf]{position:absolute;top:0;left:-4px;bottom:0;width:8px;z-index:2;cursor:col-resize;touch-action:none}.artifacts-resize-handle[data-v-07ae46cf]:after{content:"";position:absolute;top:0;left:3px;width:1px;height:100%;background:transparent;transition:background .15s ease}.artifacts-resize-handle[data-v-07ae46cf]:hover:after,.artifacts-panel.is-resizing .artifacts-resize-handle[data-v-07ae46cf]:after{background:var(--gn-color-accent)}.artifacts-header[data-v-07ae46cf]{min-height:58px;display:flex;align-items:center;justify-content:space-between;gap:12px;padding:0 15px;border-bottom:2px solid var(--gn-border-color-muted)}.artifacts-empty[data-v-07ae46cf]{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--gn-color-text-dark);font-size:13px}.artifacts-tabs[data-v-07ae46cf]{display:flex;align-items:center;flex-wrap:nowrap;gap:8px;flex:1;min-width:0}.artifacts-tab[data-v-07ae46cf]{min-width:0;white-space:nowrap}@container (max-width: 560px){.artifacts-tab[data-v-07ae46cf]{padding:4px 10px;font-size:11px;gap:6px}.artifacts-tabs[data-v-07ae46cf]{gap:6px}}@container (max-width: 490px){.artifacts-tab[data-v-07ae46cf]{padding:3px 8px;font-size:10px;gap:5px}}@container (max-width: 400px){.artifacts-tab[data-v-07ae46cf]{padding:2px 6px}.artifacts-tab-count[data-v-07ae46cf]{padding-left:3px}}@container (max-width: 360px){.artifacts-tab i[data-v-07ae46cf]{display:none}}.artifacts-tab-count[data-v-07ae46cf]{padding-left:4px;opacity:.72}.artifacts-tab-count.has-running[data-v-07ae46cf]{color:var(--gn-color-success);opacity:1}.artifacts-list[data-v-07ae46cf]{max-height:232px;overflow-y:auto;border-bottom:2px solid var(--gn-border-color-muted)}.viewed-images-group[data-v-07ae46cf]{flex-shrink:0;border-bottom:2px solid var(--gn-border-color-muted);background:var(--gn-surface-panel-muted)}.viewed-images-header[data-v-07ae46cf]{display:flex;align-items:center;gap:8px;padding:8px 12px;font-size:12px;font-weight:500;color:var(--gn-color-text-medium)}.viewed-images-header i[data-v-07ae46cf]{font-size:14px;color:var(--gn-color-secondary)}.viewed-images-grid[data-v-07ae46cf]{display:grid;grid-template-columns:repeat(auto-fill,minmax(140px,1fr));gap:6px;padding:0 12px 12px;max-height:320px;overflow-y:auto}.viewed-image-thumb[data-v-07ae46cf]{width:100%;height:96px;object-fit:cover;border:1px solid var(--gn-border-color-muted);border-radius:6px;cursor:zoom-in;transition:border-color var(--gn-motion-fast) var(--gn-motion-ease),opacity var(--gn-motion-fast) var(--gn-motion-ease)}.viewed-image-thumb[data-v-07ae46cf]:hover{border-color:var(--gn-color-secondary);opacity:.85}.artifact-item[data-v-07ae46cf]{width:100%;min-height:50px;display:flex;align-items:center;gap:10px;padding:8px 12px;border:0;border-left:var(--gn-border-width-accent) solid transparent;background:transparent;color:var(--gn-color-text-light);text-align:left;cursor:pointer;transition:background var(--gn-motion-fast) var(--gn-motion-ease),border-color var(--gn-motion-fast) var(--gn-motion-ease)}.artifact-item[data-v-07ae46cf]:hover{background:color-mix(in srgb,var(--gn-color-text-light) 7%,transparent)}.artifact-item.is-active[data-v-07ae46cf]{border-left-color:var(--gn-color-secondary);background:var(--gn-surface-panel-muted)}.artifact-icon[data-v-07ae46cf]{display:inline-flex;flex-shrink:0;color:var(--gn-color-accent);font-size:20px}.artifact-info[data-v-07ae46cf]{min-width:0;flex:1;display:flex;flex-direction:column;gap:2px}.artifact-title[data-v-07ae46cf],.artifact-detail-title[data-v-07ae46cf],.artifact-detail-filename[data-v-07ae46cf]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.artifact-title[data-v-07ae46cf]{font-size:13px;font-weight:500}.artifact-meta[data-v-07ae46cf]{font-size:11px;color:var(--gn-color-text-dark)}.artifact-detail[data-v-07ae46cf]{flex:1;min-height:0;display:flex;flex-direction:column}.artifact-detail-header[data-v-07ae46cf]{padding:12px 15px 8px}.artifact-detail-title[data-v-07ae46cf]{font-size:14px;font-weight:600;color:var(--gn-color-text-light)}.artifact-detail-filename[data-v-07ae46cf]{margin-top:3px;font-size:12px;color:var(--gn-color-text-dark)}.artifact-actions[data-v-07ae46cf]{display:flex;flex-wrap:wrap;gap:4px;padding:0 15px 12px}.artifact-preview[data-v-07ae46cf]{flex:1;min-height:0;border-top:2px solid var(--gn-border-color-muted);background:var(--gn-color-black)}.artifact-frame[data-v-07ae46cf],.artifact-image[data-v-07ae46cf],.artifact-video[data-v-07ae46cf]{width:100%;height:100%;border:0;display:block}.artifact-image[data-v-07ae46cf],.artifact-video[data-v-07ae46cf]{object-fit:contain}.artifact-source[data-v-07ae46cf]{height:100%;overflow:auto;background:var(--gn-color-black)}.artifact-source-code[data-v-07ae46cf],.artifact-source-error[data-v-07ae46cf]{margin:0;padding:14px;white-space:pre;font-family:var(--gn-font-family-base);font-size:12px;line-height:1.6;color:var(--gn-color-text-light)}.artifact-source-error[data-v-07ae46cf]{color:var(--gn-color-error)}.artifact-source-state[data-v-07ae46cf]{display:flex;align-items:center;gap:8px;padding:14px;color:var(--gn-color-text-dark);font-size:12px}.artifact-no-preview[data-v-07ae46cf]{height:100%;min-height:220px;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:var(--gn-color-text-dark);font-size:13px}.artifact-no-preview i[data-v-07ae46cf]{font-size:28px}.links-list[data-v-07ae46cf]{max-height:none;flex:1;overflow-y:auto}.link-item[data-v-07ae46cf]{text-decoration:none}.link-item .artifact-title[data-v-07ae46cf]{color:var(--gn-color-accent)}.link-item:hover .artifact-title[data-v-07ae46cf],.link-item.is-active .artifact-title[data-v-07ae46cf]{color:var(--gn-color-text-light)}.link-detail[data-v-07ae46cf]{padding:12px 15px;border-top:2px solid var(--gn-border-color-muted)}.link-detail-header[data-v-07ae46cf]{margin-bottom:8px}.link-detail-count[data-v-07ae46cf]{font-size:12px;color:var(--gn-color-text-dark)}.link-actions[data-v-07ae46cf]{display:flex;gap:6px}.files-list[data-v-07ae46cf]{max-height:none;flex:1;overflow-y:auto}.file-item[data-v-07ae46cf],.file-item.is-dir[data-v-07ae46cf]{cursor:default}.file-item.is-dir .artifact-title[data-v-07ae46cf]{color:var(--gn-color-text-medium)}.file-row-actions[data-v-07ae46cf]{display:flex;gap:4px;flex-shrink:0;opacity:0;transition:opacity .15s ease}.file-item:hover .file-row-actions[data-v-07ae46cf]{opacity:1}.file-row-action[data-v-07ae46cf]{width:28px;height:28px;min-height:0;padding:0}@media(max-width:980px){.artifacts-panel[data-v-07ae46cf]{position:fixed;top:0;right:0;bottom:0;z-index:120;margin-right:0;transform:translate(100%);width:100vw;min-width:100vw;max-width:100vw}.artifacts-resize-handle[data-v-07ae46cf]{display:none}.artifacts-panel.is-open[data-v-07ae46cf]{transform:translate(0)}.artifacts-header[data-v-07ae46cf]{gap:6px;padding:0 10px}.artifacts-tab[data-v-07ae46cf]{padding:8px 10px;gap:4px}.artifacts-tab>span[data-v-07ae46cf]:not(.artifacts-tab-count){display:none}}@media(prefers-reduced-motion:reduce){.artifacts-panel[data-v-07ae46cf]{transition:none}}.files-toolbar[data-v-07ae46cf]{display:flex;align-items:center;justify-content:flex-end;padding:8px 12px 2px}.files-tab-wrap[data-v-07ae46cf]{position:relative;flex:1;display:flex;flex-direction:column;overflow:hidden}.files-refresh-btn[data-v-07ae46cf]:disabled{opacity:.5;cursor:not-allowed}@media(max-width:980px){.files-refresh-btn[data-v-07ae46cf]{display:none}}.files-ptr[data-v-07ae46cf]{position:absolute;top:0;left:0;right:0;z-index:10;display:flex;align-items:center;justify-content:center;gap:8px;padding:8px;font-size:12px;color:var(--gn-color-text-dark);pointer-events:none;transition:opacity .15s,transform .15s;will-change:transform,opacity}.ptr-pulled[data-v-07ae46cf]{transition:transform .15s}@media(min-width:981px){.files-ptr[data-v-07ae46cf]{display:none}}.terminals-list[data-v-07ae46cf]{max-height:none;flex:1;overflow-y:auto}.terminal-item.is-closed[data-v-07ae46cf]{opacity:.6}.terminal-item .artifact-meta[data-v-07ae46cf]{white-space:normal;word-break:break-word;line-height:1.4;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}.terminal-detail[data-v-07ae46cf]{flex:1;min-height:0;display:flex;flex-direction:column;border-top:2px solid var(--gn-border-color-muted);overflow-y:auto}.terminal-detail-header[data-v-07ae46cf]{padding:12px 15px 8px;display:flex;align-items:flex-start;justify-content:space-between;gap:8px}.terminal-detail-title-wrap[data-v-07ae46cf]{min-width:0}.artifacts-tab-count.has-running[data-v-07ae46cf]{background:var(--gn-color-success);color:var(--gn-color-black)}.terminal-detail-title[data-v-07ae46cf]{font-size:14px;font-weight:600;color:var(--gn-color-text-light);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.terminal-detail-close[data-v-07ae46cf]{flex-shrink:0}.terminal-detail-meta[data-v-07ae46cf]{margin-top:3px;font-size:12px;color:var(--gn-color-text-dark);word-break:break-word;line-height:1.5}.terminal-detail-grid[data-v-07ae46cf]{display:flex;flex-direction:column;gap:6px;padding:0 15px 12px;border-bottom:2px solid color-mix(in srgb,var(--gn-color-text-light) 12%,transparent)}.terminal-detail-row[data-v-07ae46cf]{display:flex;align-items:center;justify-content:space-between;gap:8px;font-size:12px}.terminal-detail-label[data-v-07ae46cf]{color:var(--gn-color-text-dark);flex-shrink:0}.terminal-detail-value[data-v-07ae46cf]{color:var(--gn-color-text-light);text-align:right;word-break:break-all}.terminal-detail-value.status-busy[data-v-07ae46cf]{color:var(--gn-color-success)}.terminal-detail-value.status-idle[data-v-07ae46cf]{color:var(--gn-color-secondary)}.terminal-detail-value.status-closed[data-v-07ae46cf]{color:var(--gn-color-error)}.terminal-detail-command[data-v-07ae46cf]{font-family:var(--gn-font-family-base);font-size:11px;color:var(--gn-color-accent)}.terminal-output-wrap[data-v-07ae46cf]{flex:1;min-height:0;display:flex;flex-direction:column;background:var(--gn-color-black)}.terminal-output-header[data-v-07ae46cf]{padding:8px 15px;font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:.05em;color:var(--gn-color-text-dark);border-bottom:2px solid color-mix(in srgb,var(--gn-color-text-light) 12%,transparent)}.terminal-output[data-v-07ae46cf]{flex:1;margin:0;padding:14px;overflow:auto;white-space:pre-wrap;word-break:break-word;font-family:var(--gn-font-family-base);font-size:12px;line-height:1.6;color:var(--gn-color-text-light)}.login-overlay[data-v-07af6970]{position:fixed;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;background:var(--gn-color-black);z-index:9999}.login-card[data-v-07af6970]{display:flex;flex-direction:column;align-items:center;gap:16px;padding:48px 40px;border:1px solid var(--gn-border-color-muted);border-radius:16px;max-width:360px;width:90%}.login-logo[data-v-07af6970]{width:64px;height:64px}.login-title[data-v-07af6970]{font-size:24px;font-weight:700;color:var(--gn-color-text-light);margin:0}.login-subtitle[data-v-07af6970]{font-size:14px;color:var(--gn-color-text-medium);margin:0}.login-btn[data-v-07af6970]{margin-top:8px;width:100%;justify-content:center}.container[data-v-2f8cc0a8]{padding:18px}.section[data-v-2f8cc0a8]{margin-bottom:48px}.section-title[data-v-2f8cc0a8],.block[data-v-2f8cc0a8]{margin-bottom:34px}.block-title[data-v-2f8cc0a8]{margin-bottom:22px}p[data-v-2f8cc0a8],.text[data-v-2f8cc0a8]{margin-bottom:15px}.hint[data-v-2f8cc0a8]{margin-top:8px}.list[data-v-2f8cc0a8]{padding-left:22px;margin-bottom:15px}.list-item[data-v-2f8cc0a8]{margin-bottom:8px}.list-nested[data-v-2f8cc0a8]{margin-top:8px}.table[data-v-2f8cc0a8]{margin-bottom:22px}.table-caption[data-v-2f8cc0a8]{margin-bottom:8px}.form-group[data-v-2f8cc0a8]{margin-bottom:15px}.label[data-v-2f8cc0a8]{margin-bottom:5px;display:block}.input[data-v-2f8cc0a8],.textarea[data-v-2f8cc0a8],.select[data-v-2f8cc0a8]{margin-top:5px}.toast[data-v-2f8cc0a8]{padding:15px}.toast-stack[data-v-2f8cc0a8]{gap:8px}.offline-banner[data-v-2f8cc0a8]{display:flex;align-items:center;justify-content:center;gap:8px;padding:5px 15px;background:#ff9e6426;color:#ff9e64;font-size:12px;border-bottom:1px solid rgba(255,158,100,.3)}.offline-banner i[data-v-2f8cc0a8]{font-size:16px;flex-shrink:0}.offline-slide-enter-active[data-v-2f8cc0a8],.offline-slide-leave-active[data-v-2f8cc0a8]{transition:max-height .25s ease,opacity .25s ease;overflow:hidden}.offline-slide-enter-from[data-v-2f8cc0a8],.offline-slide-leave-to[data-v-2f8cc0a8]{max-height:0;opacity:0}.offline-slide-enter-to[data-v-2f8cc0a8],.offline-slide-leave-from[data-v-2f8cc0a8]{max-height:48px;opacity:1}.welcome-sidebar-btn[data-v-0ba11e7d]{display:none;position:absolute;top:12px;left:12px}@media(max-width:1279.98px){.welcome-sidebar-btn[data-v-0ba11e7d]{display:flex}}.context-bar-pct[data-v-6810168f]{font-size:11px;font-weight:600;font-variant-numeric:tabular-nums;color:var(--gn-color-success);white-space:nowrap}.context-bar-pct.is-warn[data-v-6810168f]{color:var(--gn-color-warning)}.context-bar-pct.is-crit[data-v-6810168f]{color:var(--gn-color-error)}.btn-artifacts-toggle[data-v-47d78bd2]{position:relative}.artifact-count[data-v-47d78bd2]{position:absolute;top:-3px;right:-3px;min-width:16px;height:16px;display:inline-flex;align-items:center;justify-content:center;padding:0 4px;font-size:10px;line-height:1;background:var(--gn-color-secondary);color:var(--gn-color-black)}.recall-banner[data-v-47d78bd2]{display:flex;align-items:center;gap:8px;padding:6px 12px;background:color-mix(in srgb,var(--gn-color-secondary) 12%,transparent);border-bottom:1px solid var(--gn-border-color-muted);font-size:12px;color:var(--gn-color-text-medium)}.recall-banner i[data-v-47d78bd2]{color:var(--gn-color-secondary);font-size:14px}.recall-text[data-v-47d78bd2]{flex:1;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.recall-btn[data-v-47d78bd2]{background:none;border:none;color:var(--gn-color-text-dark);cursor:pointer;padding:2px 4px;font-size:14px;line-height:1;border-radius:4px;transition:color .15s,background .15s}.recall-btn[data-v-47d78bd2]:hover{color:var(--gn-color-text-medium);background:color-mix(in srgb,var(--gn-color-text-light) 6%,transparent)}.container[data-v-65a497ff]{padding:18px}.section[data-v-65a497ff]{margin-bottom:48px}.section-title[data-v-65a497ff],.block[data-v-65a497ff]{margin-bottom:34px}.block-title[data-v-65a497ff]{margin-bottom:22px}p[data-v-65a497ff],.text[data-v-65a497ff]{margin-bottom:15px}.hint[data-v-65a497ff]{margin-top:8px}.list[data-v-65a497ff]{padding-left:22px;margin-bottom:15px}.list-item[data-v-65a497ff]{margin-bottom:8px}.list-nested[data-v-65a497ff]{margin-top:8px}.table[data-v-65a497ff]{margin-bottom:22px}.table-caption[data-v-65a497ff]{margin-bottom:8px}.form-group[data-v-65a497ff]{margin-bottom:15px}.label[data-v-65a497ff]{margin-bottom:5px;display:block}.input[data-v-65a497ff],.textarea[data-v-65a497ff],.select[data-v-65a497ff]{margin-top:5px}.toast[data-v-65a497ff]{padding:15px}.toast-stack[data-v-65a497ff]{gap:8px}.content-card[data-v-65a497ff]{margin:8px 0;background:var(--gn-surface-panel);border:1px solid var(--gn-border-color-muted);border-radius:6px;overflow:hidden}.content-card summary[data-v-65a497ff]{display:flex;align-items:center;gap:10px;padding:10px 14px;cursor:pointer;-webkit-user-select:none;user-select:none;list-style:none}.content-card summary[data-v-65a497ff]::-webkit-details-marker{display:none}.content-icon[data-v-65a497ff]{font-size:20px;line-height:1;flex-shrink:0;color:var(--gn-color-text-medium)}.content-title[data-v-65a497ff]{flex:1;font-size:.9em;font-weight:500;color:var(--gn-color-text-light);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}[data-v-65a497ff] .badge{flex-shrink:0}.content-actions[data-v-65a497ff]{display:inline-flex;align-items:center;gap:2px}.content-actions .btn-icon[data-v-65a497ff]{width:26px;height:26px;font-size:18px;border-color:transparent}.content-chevron[data-v-65a497ff]{transition:transform .2s;color:var(--gn-color-text-dark)}.content-card[open] .content-chevron[data-v-65a497ff]{transform:rotate(180deg)}.content-body[data-v-65a497ff]{border-top:1px solid var(--gn-border-color-muted);overflow:auto}.content-iframe[data-v-65a497ff]{width:100%;height:300px;border:none;display:block}@media(min-width:768px){.content-iframe[data-v-65a497ff]{height:500px}}.content-image-wrap[data-v-65a497ff]{position:relative;min-height:160px}.content-image[data-v-65a497ff]{width:100%;max-height:60vh;object-fit:contain;cursor:zoom-in;display:block;background:var(--gn-surface-panel)}.content-image-skeleton[data-v-65a497ff]{position:absolute;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;background:color-mix(in srgb,var(--gn-color-grey) 12%,var(--gn-surface-panel));border-bottom:1px solid var(--gn-border-color-muted);color:var(--gn-color-text-dark)}.content-image-spinner[data-v-65a497ff]{animation:content-image-spin-65a497ff .9s linear infinite;font-size:22px}@keyframes content-image-spin-65a497ff{to{transform:rotate(360deg)}}.content-video[data-v-65a497ff]{width:100%;max-height:60vh;display:block;background:var(--gn-surface-panel)}.content-source[data-v-65a497ff]{max-height:500px;overflow:auto;background:var(--gn-color-black)}.content-source-code[data-v-65a497ff],.content-source-error[data-v-65a497ff]{margin:0;padding:14px;white-space:pre;font-family:IBM Plex Mono,monospace;font-size:12px;line-height:1.6;color:var(--gn-color-text-light)}.content-source-error[data-v-65a497ff]{color:var(--gn-color-error)}.content-source-state[data-v-65a497ff]{display:flex;align-items:center;gap:8px;padding:14px;color:var(--gn-color-text-dark);font-size:12px}.content-unknown[data-v-65a497ff]{padding:24px;text-align:center;color:var(--gn-color-text-dark);display:flex;flex-direction:column;align-items:center;gap:10px}.unknown-icon[data-v-65a497ff]{font-size:2em;line-height:1}.unknown-name[data-v-65a497ff]{font-size:.95em;font-weight:500;color:var(--gn-color-text-light);word-break:break-word;max-width:100%}.unknown-open[data-v-65a497ff]{width:auto;text-decoration:none;font-size:.9em}.card-grid[data-v-9596a41c]{display:flex;flex-direction:column;gap:12px}.card-grid-title[data-v-9596a41c]{font-size:1rem;font-weight:600;color:var(--gn-color-text-light)}.card-grid-items[data-v-9596a41c]{display:grid;grid-template-columns:repeat(2,1fr);gap:12px}@media(max-width:640px){.card-grid-items[data-v-9596a41c]{grid-template-columns:1fr}}.card-grid-item[data-v-9596a41c]{display:flex;flex-direction:column;background:color-mix(in srgb,var(--gn-color-grey) 12%,var(--gn-surface-panel));border:1px solid var(--gn-border-color-muted);overflow:hidden;cursor:pointer;transition:border-color .15s,transform .1s}.card-grid-item[data-v-9596a41c]:hover,.card-grid-item[data-v-9596a41c]:focus{border-color:var(--gn-color-secondary);outline:none}.card-grid-item[data-v-9596a41c]:active{transform:scale(.99)}.card-image[data-v-9596a41c]{width:100%;height:140px;object-fit:cover;background:var(--gn-surface-panel)}.card-no-image[data-v-9596a41c]{width:100%;height:140px;display:flex;align-items:center;justify-content:center;color:var(--gn-color-text-dark);font-size:2rem;background:var(--gn-surface-panel)}.card-content[data-v-9596a41c]{padding:12px;display:flex;flex-direction:column;gap:8px;flex:1}.card-title[data-v-9596a41c]{font-weight:600;font-size:.95rem;color:var(--gn-color-text-light);line-height:1.3}.card-subtitle[data-v-9596a41c]{font-size:.8rem;color:var(--gn-color-text-dark)}.card-meta[data-v-9596a41c]{display:flex;flex-wrap:wrap;gap:8px}.card-meta-item[data-v-9596a41c]{display:flex;gap:4px;font-size:.75rem}.card-meta-label[data-v-9596a41c]{color:var(--gn-color-text-dark)}.card-meta-value[data-v-9596a41c]{color:var(--gn-color-text-light);font-weight:500}.card-description[data-v-9596a41c]{font-size:.8rem;color:var(--gn-color-text-light);line-height:1.4;opacity:.85;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}.card-grid-more[data-v-9596a41c]{text-align:center;font-size:.8rem;color:var(--gn-color-text-dark)}.card-modal-image[data-v-9596a41c]{width:100%;max-height:320px;object-fit:cover;background:var(--gn-surface-panel)}.card-modal-content[data-v-9596a41c]{padding:20px;display:flex;flex-direction:column;gap:18px}.card-modal-title[data-v-9596a41c]{margin:0;font-size:1.15rem;font-weight:600;color:var(--gn-color-text-light);text-transform:none}.card-modal-subtitle[data-v-9596a41c]{color:var(--gn-color-text-dark);font-size:.9rem}.card-modal-section[data-v-9596a41c]{display:flex;flex-direction:column;gap:10px}.card-modal-section-title[data-v-9596a41c]{font-size:.75rem;text-transform:uppercase;letter-spacing:.05em;color:var(--gn-color-text-dark)}.card-modal-meta-grid[data-v-9596a41c]{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}.card-modal-meta-cell[data-v-9596a41c]{background:color-mix(in srgb,var(--gn-color-grey) 12%,var(--gn-surface-panel));border:1px solid var(--gn-border-color-muted);padding:10px}.card-modal-meta-label[data-v-9596a41c]{font-size:.7rem;color:var(--gn-color-text-dark);margin-bottom:4px}.card-modal-meta-value[data-v-9596a41c]{font-size:.9rem;color:var(--gn-color-text-light);font-weight:500}.card-modal-text[data-v-9596a41c]{margin:0;line-height:1.5;color:var(--gn-color-text-light)}.card-modal-details[data-v-9596a41c]{margin:0;display:grid;gap:8px}.card-modal-detail-row[data-v-9596a41c]{display:flex;justify-content:space-between;gap:12px;padding:8px 0;border-bottom:1px solid var(--gn-border-color-muted)}.card-modal-detail-row[data-v-9596a41c]:last-child{border-bottom:none}.card-modal-detail-row dt[data-v-9596a41c]{color:var(--gn-color-text-dark);font-size:.85rem}.card-modal-detail-row dd[data-v-9596a41c]{margin:0;color:var(--gn-color-text-light);font-size:.85rem;text-align:right;word-break:break-word}.card-modal-actions[data-v-9596a41c]{display:flex;gap:10px;flex-wrap:wrap}.card-modal-action[data-v-9596a41c]{display:inline-flex;align-items:center;padding:8px 14px;background:color-mix(in srgb,var(--gn-color-secondary) 14%,var(--gn-surface-panel));color:var(--gn-color-secondary);text-decoration:none;font-size:.85rem;font-weight:500}.card-modal-action[data-v-9596a41c]:hover{background:var(--gn-border-color-muted)}.ui-form[data-v-4d9c6b33]{display:flex;flex-direction:column;gap:14px}.ui-form-title[data-v-4d9c6b33]{font-size:1rem;font-weight:600;color:var(--gn-color-text-light)}.ui-form-description[data-v-4d9c6b33]{font-size:.85rem;color:var(--gn-color-text-dark);line-height:1.4}.ui-form-fields[data-v-4d9c6b33]{display:flex;flex-direction:column;gap:14px}.ui-form-field[data-v-4d9c6b33]{display:flex;flex-direction:column;gap:4px}.ui-form-field.has-error .ui-form-input[data-v-4d9c6b33]{border-color:var(--gn-color-error)}.ui-form-label[data-v-4d9c6b33]{font-size:.85rem;font-weight:500;color:var(--gn-color-text-light)}.ui-form-required[data-v-4d9c6b33]{color:var(--gn-color-error);margin-left:2px}.ui-form-field-hint[data-v-4d9c6b33]{font-size:.75rem;color:var(--gn-color-text-dark)}.ui-form-input[data-v-4d9c6b33]{padding:10px 12px;background:var(--gn-surface-panel);border:1px solid var(--gn-border-color-muted);color:var(--gn-color-text-light);font-size:.9rem;outline:none;transition:border-color .15s}.ui-form-input[data-v-4d9c6b33]:focus{border-color:var(--gn-color-secondary)}.ui-form-input[data-v-4d9c6b33]::placeholder{color:var(--gn-color-text-dark)}select.ui-form-input[data-v-4d9c6b33]{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='%236c7086' viewBox='0 0 256 256'%3E%3Cpath d='M213.66 101.66l-80 80a8 8 0 0 1-11.32 0l-80-80A8 8 0 0 1 48 88h160a8 8 0 0 1 5.66 13.66z'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 12px center;padding-right:32px}select.ui-form-input[multiple][data-v-4d9c6b33]{background-image:none;padding-right:12px;min-height:100px}.ui-form-checkbox[data-v-4d9c6b33]{display:flex;align-items:center;gap:8px;font-size:.9rem;color:var(--gn-color-text-light);cursor:pointer}.ui-form-checkbox input[data-v-4d9c6b33]{width:18px;height:18px;accent-color:var(--gn-color-secondary);cursor:pointer}.ui-form-error[data-v-4d9c6b33]{font-size:.8rem;color:var(--gn-color-error)}.ui-form-submit[data-v-4d9c6b33]{display:inline-flex;align-items:center;justify-content:center;gap:8px;align-self:flex-start;padding:10px 18px;background:var(--gn-color-secondary);color:var(--gn-surface-panel);border:none;font-size:.9rem;font-weight:600;cursor:pointer;transition:opacity .15s}.ui-form-submit[data-v-4d9c6b33]:disabled{opacity:.5;cursor:not-allowed}.ui-form-submit[data-v-4d9c6b33]:not(:disabled):hover{opacity:.9}.ui-form-spinner[data-v-4d9c6b33]{width:14px;height:14px;border:2px solid currentColor;border-top-color:transparent;border-radius:50%;animation:ui-form-spin-4d9c6b33 .8s linear infinite}@keyframes ui-form-spin-4d9c6b33{to{transform:rotate(360deg)}}.ui-form-submitted[data-v-4d9c6b33]{display:flex;flex-direction:column;gap:10px}.ui-form-submitted-note[data-v-4d9c6b33]{display:flex;align-items:center;gap:6px;font-size:.85rem;color:var(--gn-color-secondary)}.ui-form-summary[data-v-4d9c6b33]{margin:0;display:grid;gap:8px}.ui-form-summary-row[data-v-4d9c6b33]{display:flex;justify-content:space-between;gap:12px;padding:8px 0;border-bottom:1px solid var(--gn-border-color-muted)}.ui-form-summary-row[data-v-4d9c6b33]:last-child{border-bottom:none}.ui-form-summary-row dt[data-v-4d9c6b33]{color:var(--gn-color-text-dark);font-size:.85rem}.ui-form-summary-row dd[data-v-4d9c6b33]{margin:0;color:var(--gn-color-text-light);font-size:.85rem;text-align:right;word-break:break-word}.ui-component-card[data-v-5c9908d7]{margin:8px 0;background:var(--gn-surface-panel);border:1px solid var(--gn-border-color-muted);overflow:hidden}.ui-component-header[data-v-5c9908d7]{display:flex;align-items:center;gap:8px;padding:10px 14px;border-bottom:1px solid var(--gn-border-color-muted);-webkit-user-select:none;user-select:none}.ui-component-icon[data-v-5c9908d7]{font-size:1.2em;line-height:1}.ui-component-name[data-v-5c9908d7]{flex:1;font-size:.9em;font-weight:500;color:var(--gn-color-text-light);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.ui-component-badge[data-v-5c9908d7]{font-size:.7em;text-transform:uppercase;padding:2px 8px;background:color-mix(in srgb,var(--gn-color-secondary) 14%,var(--gn-surface-panel));color:var(--gn-color-secondary)}.ui-component-body[data-v-5c9908d7]{padding:12px 14px}.ui-component-fallback[data-v-5c9908d7]{color:var(--gn-color-text-dark)}.ui-component-fallback-title[data-v-5c9908d7]{font-size:.8rem;margin-bottom:8px;font-weight:500}.ui-component-fallback-json[data-v-5c9908d7]{margin:0;font-family:monospace;font-size:.8rem;white-space:pre-wrap}.stream-cursor[data-v-413d0a09]{display:inline-block;width:2px;height:1em;background:currentColor;margin-left:2px;vertical-align:text-bottom;animation:blink-413d0a09 1s step-end infinite}@keyframes blink-413d0a09{0%,to{opacity:1}50%{opacity:0}}.msg-rate-btn[data-v-413d0a09]{opacity:.55;transition:opacity .15s,color .15s}.msg-rate-btn[data-v-413d0a09]:hover{opacity:1}.msg-rate-btn.active[data-v-413d0a09]{opacity:1;color:var(--gn-color-secondary)}.compression-pending[data-v-cecede62]{display:flex;align-items:center;gap:8px;padding:8px 12px;border-radius:8px;background:var(--gn-surface-panel-strong);color:var(--gn-color-text-dark);font-size:13px}.compression-pending i[data-v-cecede62]{font-size:16px}.message-list-wrap[data-v-5c05d9cd]{flex:1;min-height:0;position:relative;display:flex;flex-direction:column}.message-scroller[data-v-5c05d9cd]{flex:1;min-height:0;overflow-y:auto;overflow-x:hidden;transition:opacity .25s ease;padding-top:16px}.message-scroller.is-hidden[data-v-5c05d9cd]{opacity:0;pointer-events:none}.message-row[data-v-5c05d9cd]{padding-bottom:32px;width:100%;max-width:920px;margin:0 auto;padding-left:24px;padding-right:24px;content-visibility:auto;contain-intrinsic-size:auto 140px}@media(max-width:767px){.message-row[data-v-5c05d9cd]{padding-left:10px;padding-right:10px}}.session-loading[data-v-5c05d9cd]{position:absolute;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;font-size:26px;color:var(--gn-color-text-medium);pointer-events:none}.session-loading .animate-spin[data-v-5c05d9cd]{animation:session-spin-5c05d9cd 1s linear infinite}@keyframes session-spin-5c05d9cd{to{transform:rotate(360deg)}}.archive-loading[data-v-5c05d9cd]{position:absolute;top:8px;left:0;right:0;z-index:5;display:flex;align-items:center;justify-content:center;gap:8px;padding:8px;font-size:13px;color:var(--gn-color-text-medium);background:transparent;pointer-events:none}.animate-spin[data-v-5c05d9cd]{animation:spin-5c05d9cd 1s linear infinite}@keyframes spin-5c05d9cd{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.scroll-to-bottom-btn[data-v-5c05d9cd]{position:absolute;bottom:16px;right:16px;width:40px;height:40px;border-radius:50%;background:var(--gn-color-secondary);color:var(--gn-color-black);border:none;cursor:pointer;display:flex;align-items:center;justify-content:center;font-size:18px;box-shadow:0 2px 12px #0006;opacity:.9;transition:opacity .15s ease,transform .15s ease;z-index:10}.scroll-to-bottom-btn[data-v-5c05d9cd]:hover{opacity:1;transform:translateY(-2px)}.scroll-btn-enter-active[data-v-5c05d9cd],.scroll-btn-leave-active[data-v-5c05d9cd]{transition:opacity .2s ease,transform .2s ease}.scroll-btn-enter-from[data-v-5c05d9cd],.scroll-btn-leave-to[data-v-5c05d9cd]{opacity:0;transform:translateY(8px)}.file-preview-image[data-v-f0b09655]{position:relative}.file-preview-image .file-preview-remove[data-v-f0b09655]{position:absolute;top:-4px;right:-4px;background:var(--gn-surface-panel);border:1px solid var(--gn-border-color-muted);width:18px;height:18px;display:flex;align-items:center;justify-content:center;font-size:10px;cursor:pointer;color:var(--gn-color-text-dark)}.file-preview-image .file-preview-remove[data-v-f0b09655]:hover{color:var(--gn-color-error)}.file-preview-image.is-processing[data-v-f0b09655]{display:flex;align-items:center;justify-content:center;color:var(--gn-color-text-medium)}.file-preview-image.is-processing .ph-spin[data-v-f0b09655]{animation:spin-f0b09655 .9s linear infinite}@keyframes spin-f0b09655{to{transform:rotate(360deg)}}.sending-notice[data-v-c90111b2]{display:flex;align-items:center;gap:6px;padding:4px 8px;font-size:12px;color:var(--gn-color-text-medium);margin-bottom:4px}.sending-notice .ph-spin[data-v-c90111b2]{animation:sending-spin-c90111b2 .9s linear infinite}@keyframes sending-spin-c90111b2{to{transform:rotate(360deg)}}.task-chips[data-v-af03bea1]{display:flex;gap:8px;padding:4px 16px 0;flex-wrap:wrap}.fade-enter-active[data-v-af03bea1],.fade-leave-active[data-v-af03bea1]{transition:opacity .2s}.fade-enter-from[data-v-af03bea1],.fade-leave-to[data-v-af03bea1]{opacity:0}.reconnect-banner[data-v-afc23956]{display:flex;align-items:center;gap:8px;margin:8px 16px 0;font-size:13px}.create-key-body[data-v-db609bf3]{min-width:min(320px,100vw - 48px)}.show-token-body[data-v-1b3695e8]{min-width:min(420px,100vw - 48px)}.show-token-warning[data-v-1b3695e8]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-warning);display:flex;align-items:center;gap:6px}.show-token-warning i[data-v-1b3695e8]{font-size:1.1rem}.show-token-value[data-v-1b3695e8]{flex:1 1 0;font-family:monospace;font-size:.85rem;word-break:break-all;color:var(--gn-color-text-medium)}.api-keys-panel[data-v-2cf539c2]{margin-bottom:24px}.api-keys-header[data-v-2cf539c2]{display:flex;align-items:center;justify-content:space-between;margin-bottom:12px}.api-keys-title[data-v-2cf539c2]{font-size:1.1rem;font-weight:600;margin:0;color:var(--gn-color-text-medium)}.api-keys-description[data-v-2cf539c2]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-text-medium)}.api-keys-warning[data-v-2cf539c2]{margin-bottom:16px}.api-keys-warning i[data-v-2cf539c2]{font-size:16px;flex-shrink:0}.api-keys-loading[data-v-2cf539c2]{padding:24px;text-align:center}.api-keys-panel code[data-v-2cf539c2]{font-family:var(--gn-font-family-base);color:var(--gn-color-text-medium)}.notifications-panel[data-v-aef788e9]{margin-bottom:24px}.notifications-title[data-v-aef788e9]{font-size:1.1rem;font-weight:600;margin:0 0 12px;color:var(--gn-color-text-medium)}.notifications-description[data-v-aef788e9]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-text-medium)}.notifications-unsupported[data-v-aef788e9]{display:flex;align-items:flex-start;gap:8px;margin-bottom:16px}.notifications-unsupported i[data-v-aef788e9]{font-size:16px;flex-shrink:0}.notifications-row[data-v-aef788e9]{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:14px 16px;border:1px solid var(--gn-border-color-muted);border-radius:8px}.notifications-row-title[data-v-aef788e9]{font-size:.9rem;color:var(--gn-color-text-medium)}.notifications-row-status[data-v-aef788e9]{font-size:.8rem;color:var(--gn-color-text-dark);margin-top:2px}.reactions-panel[data-v-0a24e5f3]{margin-bottom:24px}.reactions-title[data-v-0a24e5f3]{font-size:1.1rem;font-weight:600;margin:0 0 12px;color:var(--gn-color-text-medium)}.reactions-description[data-v-0a24e5f3]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-text-medium)}.reactions-alert[data-v-0a24e5f3]{display:flex;align-items:flex-start;gap:8px;margin-bottom:16px}.reactions-alert i[data-v-0a24e5f3]{font-size:16px;flex-shrink:0}.reactions-loading[data-v-0a24e5f3]{padding:24px;text-align:center}.reactions-row[data-v-0a24e5f3]{display:flex;align-items:flex-start;justify-content:space-between;gap:16px;padding:14px 16px;margin-bottom:12px;border:1px solid var(--gn-border-color-muted);border-radius:8px}.reactions-row-title[data-v-0a24e5f3]{font-size:.9rem;color:var(--gn-color-text-medium);font-weight:500}.reactions-row-status[data-v-0a24e5f3]{font-size:.8rem;color:var(--gn-color-text-dark);margin-top:2px;max-width:420px}.reactions-instructions[data-v-0a24e5f3]{padding:14px 16px;margin-bottom:12px;border:1px solid var(--gn-border-color-muted);border-radius:8px}.reactions-instructions-textarea[data-v-0a24e5f3]{margin-top:10px}.reactions-instructions-actions[data-v-0a24e5f3]{margin-top:10px;display:flex;justify-content:flex-end}.reactions-history[data-v-0a24e5f3]{margin-top:14px}.reactions-history-title[data-v-0a24e5f3]{font-size:.85rem;font-weight:600;color:var(--gn-color-text-medium);margin-bottom:8px}.reactions-history-item[data-v-0a24e5f3]{padding:8px 10px;border-left:2px solid var(--gn-border-color-muted)}.reactions-history-item+.reactions-history-item[data-v-0a24e5f3]{margin-top:8px}.reactions-history-meta[data-v-0a24e5f3]{display:flex;align-items:center;gap:4px;font-size:.75rem;color:var(--gn-color-text-dark)}.reactions-history-meta i[data-v-0a24e5f3]{font-size:12px}.reactions-history-text[data-v-0a24e5f3]{margin-top:4px;font-size:.8rem;color:var(--gn-color-text-medium);white-space:pre-wrap;word-break:break-word}.create-target-body[data-v-f6ec4fb5]{min-width:min(360px,100vw - 48px);display:flex;flex-direction:column;gap:15px}.create-target-hint[data-v-f6ec4fb5]{margin:0;font-size:.8125rem;color:var(--gn-color-text-medium)}.create-target-hint code[data-v-f6ec4fb5]{font-family:var(--gn-font-family-base)}.container[data-v-6049b504]{padding:18px}.section[data-v-6049b504]{margin-bottom:48px}.section-title[data-v-6049b504],.block[data-v-6049b504]{margin-bottom:34px}.block-title[data-v-6049b504]{margin-bottom:22px}p[data-v-6049b504],.text[data-v-6049b504]{margin-bottom:15px}.hint[data-v-6049b504]{margin-top:8px}.list[data-v-6049b504]{padding-left:22px;margin-bottom:15px}.list-item[data-v-6049b504]{margin-bottom:8px}.list-nested[data-v-6049b504]{margin-top:8px}.table[data-v-6049b504]{margin-bottom:22px}.table-caption[data-v-6049b504]{margin-bottom:8px}.form-group[data-v-6049b504]{margin-bottom:15px}.label[data-v-6049b504]{margin-bottom:5px;display:block}.input[data-v-6049b504],.textarea[data-v-6049b504],.select[data-v-6049b504]{margin-top:5px}.toast[data-v-6049b504]{padding:15px}.toast-stack[data-v-6049b504]{gap:8px}.synapse-panel[data-v-6049b504]{margin-bottom:24px}.synapse-header[data-v-6049b504]{display:flex;align-items:center;justify-content:space-between;margin-bottom:12px}.synapse-title[data-v-6049b504]{font-size:1.1rem;font-weight:600;margin:0;color:var(--gn-color-text-medium)}.synapse-description[data-v-6049b504]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-text-medium)}.synapse-loading[data-v-6049b504]{padding:24px;text-align:center}.container[data-v-09b3eec4]{padding:18px}.section[data-v-09b3eec4]{margin-bottom:48px}.section-title[data-v-09b3eec4],.block[data-v-09b3eec4]{margin-bottom:34px}.block-title[data-v-09b3eec4]{margin-bottom:22px}p[data-v-09b3eec4],.text[data-v-09b3eec4]{margin-bottom:15px}.hint[data-v-09b3eec4]{margin-top:8px}.list[data-v-09b3eec4]{padding-left:22px;margin-bottom:15px}.list-item[data-v-09b3eec4]{margin-bottom:8px}.list-nested[data-v-09b3eec4]{margin-top:8px}.table[data-v-09b3eec4]{margin-bottom:22px}.table-caption[data-v-09b3eec4]{margin-bottom:8px}.form-group[data-v-09b3eec4]{margin-bottom:15px}.label[data-v-09b3eec4]{margin-bottom:5px;display:block}.input[data-v-09b3eec4],.textarea[data-v-09b3eec4],.select[data-v-09b3eec4]{margin-top:5px}.toast[data-v-09b3eec4]{padding:15px}.toast-stack[data-v-09b3eec4]{gap:8px}.mcp-keys-panel[data-v-09b3eec4]{margin-bottom:24px}.mcp-keys-header[data-v-09b3eec4]{display:flex;align-items:center;justify-content:space-between;margin-bottom:12px}.mcp-keys-title[data-v-09b3eec4]{font-size:1.1rem;font-weight:600;margin:0;color:var(--gn-color-text-medium)}.mcp-keys-description[data-v-09b3eec4]{margin:0 0 16px;font-size:.875rem;color:var(--gn-color-text-medium)}.mcp-keys-loading[data-v-09b3eec4]{padding:24px;text-align:center}.mcp-keys-empty[data-v-09b3eec4]{display:flex;flex-direction:column;align-items:center;gap:10px;padding:32px 24px;border:1px dashed var(--gn-color-border);border-radius:var(--gn-radius-md);text-align:center}.mcp-keys-empty .empty-icon[data-v-09b3eec4]{font-size:2rem;color:var(--gn-color-text-dimmed)}.mcp-keys-empty p[data-v-09b3eec4]{margin:0;max-width:52ch;font-size:.875rem;color:var(--gn-color-text-medium)}.mcp-keys-empty code[data-v-09b3eec4]{font-family:var(--gn-font-mono, monospace);font-size:.8125rem}.mcp-keys-rows[data-v-09b3eec4]{display:flex;flex-direction:column;gap:12px}.mcp-keys-row[data-v-09b3eec4]{display:flex;align-items:center;gap:12px;padding:12px;border:1px solid var(--gn-color-border);border-radius:var(--gn-radius-md)}.mcp-keys-info[data-v-09b3eec4]{flex:0 0 220px;min-width:0}.mcp-keys-server[data-v-09b3eec4]{font-weight:600;color:var(--gn-color-text-strong)}.mcp-keys-where[data-v-09b3eec4]{font-size:.8125rem;color:var(--gn-color-text-medium)}.mcp-keys-updated[data-v-09b3eec4]{font-size:.75rem;color:var(--gn-color-text-dimmed)}.mcp-keys-input[data-v-09b3eec4]{flex:1 1 auto;min-width:160px}.mcp-keys-actions[data-v-09b3eec4]{display:flex;gap:8px;flex-shrink:0}@media(max-width:767px){.mcp-keys-row[data-v-09b3eec4]{flex-direction:column;align-items:stretch}.mcp-keys-info[data-v-09b3eec4]{flex:none}.mcp-keys-actions[data-v-09b3eec4]{justify-content:flex-end}}.container[data-v-7cd70059]{padding:18px}.section[data-v-7cd70059]{margin-bottom:48px}.section-title[data-v-7cd70059],.block[data-v-7cd70059]{margin-bottom:34px}.block-title[data-v-7cd70059]{margin-bottom:22px}p[data-v-7cd70059],.text[data-v-7cd70059]{margin-bottom:15px}.hint[data-v-7cd70059]{margin-top:8px}.list[data-v-7cd70059]{padding-left:22px;margin-bottom:15px}.list-item[data-v-7cd70059]{margin-bottom:8px}.list-nested[data-v-7cd70059]{margin-top:8px}.table[data-v-7cd70059]{margin-bottom:22px}.table-caption[data-v-7cd70059]{margin-bottom:8px}.form-group[data-v-7cd70059]{margin-bottom:15px}.label[data-v-7cd70059]{margin-bottom:5px;display:block}.input[data-v-7cd70059],.textarea[data-v-7cd70059],.select[data-v-7cd70059]{margin-top:5px}.toast[data-v-7cd70059]{padding:15px}.toast-stack[data-v-7cd70059]{gap:8px}.settings-view[data-v-7cd70059]{flex:1 1 0;min-height:0;min-width:0;display:flex;flex-direction:column;overflow:hidden}.settings-tabs[data-v-7cd70059]{flex-direction:column;flex-wrap:nowrap;align-items:stretch;width:100%;max-width:1200px;flex:1 1 0;min-height:0;padding:8px 15px 0;margin-bottom:0}.settings-tabs[data-v-7cd70059] .tabs-list{width:100%;max-width:none}.settings-tabs[data-v-7cd70059] .tabs-panels{flex:1 1 0;min-height:0;overflow-y:auto;padding:15px 15px 34px}@media(max-width:767px){.settings-tabs[data-v-7cd70059] .tabs-panels{padding:8px 8px 22px}}@media(max-width:767px){.settings-tabs[data-v-7cd70059]{padding-left:8px;padding-right:8px}}.app-shell[data-v-40fd87a2]{display:flex;flex:1 1 0;min-height:0;min-width:0;overflow:hidden}.sidebar-backdrop[data-v-40fd87a2]{display:none;position:fixed;top:0;right:0;bottom:0;left:0;background:#0009;z-index:99}@media(max-width:1279.98px){.sidebar-backdrop[data-v-40fd87a2]{display:block}}.artifacts-backdrop[data-v-40fd87a2]{display:none;position:fixed;top:0;right:0;bottom:0;left:0;background:#00000073;z-index:119}@media(max-width:980px){.artifacts-backdrop[data-v-40fd87a2]{display:block}}.backdrop-fade-enter-active[data-v-40fd87a2],.backdrop-fade-leave-active[data-v-40fd87a2]{transition:opacity .18s ease}.backdrop-fade-enter-from[data-v-40fd87a2],.backdrop-fade-leave-to[data-v-40fd87a2]{opacity:0}@font-face{font-family:IBM Plex Mono;src:url(/assets/IBMPlexMono-Regular-BF3vfe7_.ttf) format("truetype");font-weight:400;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/IBMPlexMono-Medium-COFd06Dj.ttf) format("truetype");font-weight:500;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/IBMPlexMono-SemiBold-D0J2bq8P.ttf) format("truetype");font-weight:600;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/IBMPlexMono-Bold-Ovd3DSUS.ttf) format("truetype");font-weight:700;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/IBMPlexMono-Italic-DgAgaWWu.ttf) format("truetype");font-weight:400;font-style:italic;font-display:swap}.text,p{margin-bottom:15px}.input,.select,.textarea{margin-top:5px}html{font-size:100%}body{font-family:IBM Plex Mono,monospace;font-size:14px;font-weight:400;line-height:1.6;letter-spacing:0;color:#c0caf5}h1,h2,h3,h4,h5,h6{font-family:IBM Plex Mono,monospace;font-weight:600;line-height:1.25;margin:0}h1.contrast,h2.contrast,h3.contrast,h4.contrast,h5.contrast,h6.contrast{background:#c0caf5;color:#16161e;display:inline;padding:0 8px;border-radius:3px}h1{font-size:30px;letter-spacing:0}h2{font-size:23px}h3{font-size:20px}h4{font-size:18px}h5{font-size:16px}h6{font-size:15px;font-weight:500}.text,p{font-size:14px;line-height:1.6}.text-sm{font-size:13px;line-height:1.4}.text-lg{font-size:15px;line-height:1.6}.text-lead{max-width:760px;color:#c0caf5;font-size:15px;font-weight:500;line-height:1.6}.text-muted{font-size:13px;color:#787c99}.text-strong,strong{font-weight:600}.text-bold{font-weight:700}.text-italic,em{font-style:italic}.text-success{color:#9ece6a}.text-warning{color:#e0af68}.text-danger,.text-error{color:#f7768e}.text-info{color:#bb9af7}.eyebrow{display:inline-flex;width:-moz-max-content;width:max-content;max-width:100%;padding:5px 8px;color:#16161e;background:#7aa2f7;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase}.caption{color:#787c99;font-size:12px;line-height:1.4}.code,code,pre{font-family:IBM Plex Mono,monospace;font-size:14px;line-height:1.4;border-radius:3px;background-color:#1f2335}.text-primary{color:#c0caf5}.text-secondary{color:#a9b1d6}pre{font-size:14px;line-height:1.6;white-space:pre-wrap}.code,pre code{-o-tab-size:2;tab-size:2;-moz-tab-size:2}.code{display:inline-flex;padding:0 5px;color:#7aa2f7;border:2px solid rgba(122,162,247,.24)}.kbd{display:inline-flex;align-items:center;min-height:24px;padding:0 8px;border:2px solid rgba(192,202,245,.24);border-bottom-color:#7aa2f7;border-radius:3px;color:#c0caf5;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase}.quote{max-width:760px;margin:0;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;color:#a9b1d6;background:#1f2335;font-size:14px;line-height:1.6}.quote cite{display:block;margin-top:12px;color:#7aa2f7;font-size:13px;font-style:normal;text-transform:uppercase}a{font-weight:500;text-decoration:none;color:#7aa2f7}@media(hover:hover)and (pointer:fine){a:hover{color:#e0af68}}@media(hover:none)and (pointer:coarse){a:active{color:#e0af68}}.link{font-size:inherit;font-weight:500}.label{font-size:13px;font-weight:500;line-height:1.4}.hint,.meta{font-size:12px;line-height:1.4}.table{font-size:13px;line-height:1.4}.table th{font-weight:600}.table td{font-weight:400}.list{font-size:14px;line-height:1.6}.list-item{font-size:inherit}.modal-title{font-size:18px;font-weight:600}.modal-body{font-size:14px}.toast-title{font-size:14px;font-weight:600}.toast-text{font-size:13px;line-height:1.4}:root{--gn-color-black:#16161E;--gn-color-dark:#1F2335;--gn-color-grey:#414868;--gn-color-text-light:#C0CAF5;--gn-color-text-medium:#A9B1D6;--gn-color-text-dark:#787C99;--gn-color-primary:#C0CAF5;--gn-color-secondary:#7AA2F7;--gn-color-accent:#FF9E64;--gn-color-success:#9ECE6A;--gn-color-warning:#E0AF68;--gn-color-error:#F7768E;--gn-color-info:#BB9AF7;--gn-surface-page:#16161E;--gn-surface-panel:#1F2335;--gn-surface-panel-muted:#1F2335;--gn-surface-panel-strong:rgba(192, 202, 245, .085);--gn-border-width-base:2px;--gn-border-width-accent:6px;--gn-border-width-choice:3px;--gn-border-style-base:solid;--gn-border-color-base:#C0CAF5;--gn-border-color-muted:rgba(192, 202, 245, .24);--gn-focus-outline-width:2px;--gn-focus-outline-offset:3px;--gn-focus-outline-color:#E0AF68;--gn-motion-fast:.15s;--gn-motion-base:.2s;--gn-motion-slow:.28s;--gn-motion-ease:ease;--gn-font-family-base:IBM Plex Mono,monospace;--gn-font-weight-regular:400;--gn-font-weight-medium:500;--gn-font-weight-semibold:600;--gn-font-weight-bold:700;--gn-font-size-xs:12px;--gn-font-size-sm:13px;--gn-font-size-md:14px;--gn-font-size-base:14px;--gn-font-size-lg:15px;--gn-font-size-xl:18px;--gn-line-height-tight:1.15;--gn-line-height-normal:1.4;--gn-line-height-relaxed:1.6;--gn-space-0:0;--gn-space-1:5px;--gn-space-2:8px;--gn-space-3:12px;--gn-space-4:15px;--gn-space-5:18px;--gn-space-6:22px;--gn-space-7:26px;--gn-space-8:34px;--gn-space-9:42px;--gn-space-10:48px;--gn-space-11:64px;--gn-space-12:80px}@keyframes terminal_scan_x{0%{transform:translate(-120%)}to{transform:translate(220%)}}@keyframes terminal_scan_y{0%{transform:translateY(-120%)}to{transform:translateY(220%)}}@keyframes terminal_pulse{0%,to{box-shadow:0 0 #c0caf500}50%{box-shadow:0 0 0 4px #c0caf52e}}@keyframes panel_boot{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}@keyframes overlay_reveal{0%{opacity:0;transform:translateY(-8px)}to{opacity:1;transform:translateY(0)}}@keyframes tooltip_reveal{0%{opacity:0;transform:translate(-50%) translateY(5px)}to{opacity:1;transform:translate(-50%) translateY(0)}}@media(prefers-reduced-motion:reduce){*,:after,:before{animation-duration:0s!important;animation-iteration-count:1!important;scroll-behavior:auto!important;transition-duration:0s!important}}.palette{display:flex;flex-direction:row;flex-wrap:wrap;gap:8px}.palette .color .color-box{width:92px;height:68px;border-radius:3px}body .bg-primary{background:#c0caf5}body .bg-secondary{background:#7aa2f7}body .bg-success{background:#9ece6a}body .bg-accent{background:#ff9e64}body .bg-info{background:#bb9af7}body .bg-warning{background:#e0af68}body .bg-error{background:#f7768e}body .text-color-primary{color:#c0caf5}body .text-color-secondary{color:#7aa2f7}body .text-color-success{color:#9ece6a}body .text-color-accent{color:#ff9e64}body .text-color-info{color:#bb9af7}body .text-color-warning{color:#e0af68}body .text-color-error{color:#f7768e}.loader{width:32px;aspect-ratio:1;--c:no-repeat linear-gradient(#FF3C00 0 0);background:var(--c) 0 0,var(--c) 0 100%,var(--c) 50% 0,var(--c) 50% 100%,var(--c) 100% 0,var(--c) 100% 100%;animation:l12 1s infinite}@keyframes l12{0%,to{background-size:20% 50%}16.67%{background-size:20% 30%,20% 30%,20% 50%,20% 50%,20% 50%,20% 50%}33.33%{background-size:20% 30%,20% 30%,20% 30%,20% 30%,20% 50%,20% 50%}50%{background-size:20% 30%,20% 30%,20% 30%,20% 30%,20% 30%,20% 30%}66.67%{background-size:20% 50%,20% 50%,20% 30%,20% 30%,20% 30%,20% 30%}83.33%{background-size:20% 50%,20% 50%,20% 50%,20% 50%,20% 30%,20% 30%}}.circle-loader{display:flex;flex-direction:row;align-items:center;gap:8px}.circle-loader .ph,.circle-loader .ph-bold{font-size:26px;transform-origin:50% 50%;animation:icon_spin 1.2s linear infinite}.progress{display:flex;flex-direction:column;gap:8px;width:100%;max-width:640px}.progress .progress-header{display:flex;align-items:center;justify-content:space-between;gap:12px;color:#a9b1d6;font-size:13px;font-weight:600;text-transform:uppercase}.progress .progress-value{color:#c0caf5;font-family:IBM Plex Mono,monospace}.progress .progress-track{position:relative;width:100%;height:18px;overflow:hidden;border:2px solid rgba(192,202,245,.24);border-radius:3px;background:#1f2335}.progress .progress-bar{display:block;position:relative;overflow:hidden;width:var(--progress-value,0%);height:100%;background:#7aa2f7;transition:width .28s ease}.progress.progress-success .progress-bar{background:#9ece6a}.progress.progress-warning .progress-bar{background:#e0af68}.progress.progress-danger .progress-bar,.progress.progress-error .progress-bar{background:#f7768e}.progress.progress-striped .progress-bar{background-image:repeating-linear-gradient(90deg,transparent 0,transparent 14px,rgba(22,22,30,.2) 14px,rgba(22,22,30,.2) 16px)}.progress.progress-animated .progress-bar:after{content:"";position:absolute;top:0;right:0;bottom:0;left:0;width:48%;background:linear-gradient(90deg,transparent,rgba(192,202,245,.28),transparent);transform:translate(-120%);animation:progress_scan 1.4s ease infinite}.usage-meter{display:grid;gap:12px;width:100%;max-width:420px;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.usage-meter .usage-meter-title{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:0;font-size:15px;font-weight:700;line-height:1;text-transform:uppercase}.usage-meter .usage-meter-value{color:#7aa2f7;font-family:IBM Plex Mono,monospace;font-size:13px}.usage-meter .usage-meter-meta{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.progress-stages{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;width:100%;max-width:720px}.progress-stages .progress-stage{min-height:42px;padding:8px 12px;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#787c99;background:#1f2335;font-size:13px;font-weight:600;line-height:1.4;text-transform:uppercase}.progress-stages .progress-stage-complete{color:#16161e;background:#9ece6a;border-color:#9ece6a}.progress-stages .progress-stage-current{color:#16161e;background:#e0af68;border-color:#e0af68}@media(max-width:767px){.progress-stages{grid-template-columns:1fr 1fr}}@media(max-width:479px){.progress-stages{grid-template-columns:1fr}}@keyframes progress_scan{0%{transform:translate(-120%)}to{transform:translate(220%)}}@keyframes icon_spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.btn{display:inline-flex;align-items:center;justify-content:center;min-height:40px;font-family:IBM Plex Mono,monospace;font-size:14px;font-weight:600;line-height:1;letter-spacing:.04em;padding:12px 22px;border-radius:3px;border-width:2px;border-left-width:6px;border-style:solid;border-color:#c0caf5;text-transform:uppercase;background-color:transparent;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background-color,border-color,color,opacity}.btn:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.btn.with-icon{border-left-width:40px;position:relative}.btn.with-icon .ph,.btn.with-icon .ph-bold{position:absolute;color:#16161e;left:-40px;top:1px;font-size:26px;height:100%;display:inline-flex;align-items:center;width:40px;justify-content:center;transition-duration:.2s;transition-property:color,left}@media(hover:hover)and (pointer:fine){.btn:hover.with-icon:not(.loading-state):not(.btn-small) .ph,.btn:hover.with-icon:not(.loading-state):not(.btn-small) .ph-bold{left:-22px}}@media(hover:none)and (pointer:coarse){.btn:active.with-icon:not(.loading-state):not(.btn-small) .ph,.btn:active.with-icon:not(.loading-state):not(.btn-small) .ph-bold{left:-22px}}.btn.btn-primary{color:#c0caf5;border-color:#c0caf5}@media(hover:hover)and (pointer:fine){.btn.btn-primary:hover{background-color:#c0caf5;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-primary:active{background-color:#c0caf5;color:#16161e}}.btn.btn-secondary{color:#7aa2f7;border-color:#7aa2f7}@media(hover:hover)and (pointer:fine){.btn.btn-secondary:hover{background-color:#7aa2f7;color:#16161e}.btn.btn-secondary:hover.with-icon .ph,.btn.btn-secondary:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-secondary:active{background-color:#7aa2f7;color:#16161e}.btn.btn-secondary:active.with-icon .ph,.btn.btn-secondary:active.with-icon .ph-bold{color:#16161e}}.btn.btn-accent{color:#ff9e64;border-color:#ff9e64}@media(hover:hover)and (pointer:fine){.btn.btn-accent:hover{background-color:#ff9e64;color:#16161e}.btn.btn-accent:hover.with-icon .ph,.btn.btn-accent:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-accent:active{background-color:#ff9e64;color:#16161e}.btn.btn-accent:active.with-icon .ph,.btn.btn-accent:active.with-icon .ph-bold{color:#16161e}}.btn.btn-danger{color:#f7768e;border-color:#f7768e}@media(hover:hover)and (pointer:fine){.btn.btn-danger:hover{background-color:#f7768e;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-danger:active{background-color:#f7768e;color:#16161e}}.btn.btn-warning{color:#e0af68;border-color:#e0af68}@media(hover:hover)and (pointer:fine){.btn.btn-warning:hover{background-color:#e0af68;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-warning:active{background-color:#e0af68;color:#16161e}}.btn.btn-success{color:#9ece6a;border-color:#9ece6a}@media(hover:hover)and (pointer:fine){.btn.btn-success:hover{background-color:#9ece6a;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-success:active{background-color:#9ece6a;color:#16161e}}.btn.btn-info{color:#bb9af7;border-color:#bb9af7}@media(hover:hover)and (pointer:fine){.btn.btn-info:hover{background-color:#bb9af7;color:#16161e}.btn.btn-info:hover.with-icon .ph,.btn.btn-info:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-info:active{background-color:#bb9af7;color:#16161e}.btn.btn-info:active.with-icon .ph,.btn.btn-info:active.with-icon .ph-bold{color:#16161e}}.btn[disabled]:not(.loading-state){color:#787c99;border-color:#c0caf53d;background-color:#1f2335;cursor:not-allowed;opacity:.72}.btn[disabled]:not(.loading-state).with-icon .ph,.btn[disabled]:not(.loading-state).with-icon .ph-bold{color:#787c99}@media(hover:hover)and (pointer:fine){.btn[disabled]:not(.loading-state):hover{background-color:#1f2335;color:#787c99}.btn[disabled]:not(.loading-state):hover.with-icon .ph,.btn[disabled]:not(.loading-state):hover.with-icon .ph-bold{color:#787c99}}@media(hover:none)and (pointer:coarse){.btn[disabled]:not(.loading-state):active{background-color:#1f2335;color:#787c99}.btn[disabled]:not(.loading-state):active.with-icon .ph,.btn[disabled]:not(.loading-state):active.with-icon .ph-bold{color:#787c99}}.btn[disabled]:not(.loading-state).with-icon:not(.btn-small) .ph,.btn[disabled]:not(.loading-state).with-icon:not(.btn-small) .ph-bold{left:-22px}.btn.btn-small{font-size:13px;font-weight:500;min-height:34px;padding:8px}.btn.btn-small.with-icon{border-left-width:28px}.btn.btn-small.with-icon .ph,.btn.btn-small.with-icon .ph-bold{top:0;left:-36px;font-size:22px}.btn.btn-small.with-icon.loading-state .ph,.btn.btn-small.with-icon.loading-state .ph-bold{font-size:26px}.btn.btn-large{font-size:15px;font-weight:700;min-height:46px;padding:15px 48px}.btn.loading-state{color:#16161e!important;border-color:#c0caf5!important;background-color:#c0caf5!important}.btn.loading-state .ph,.btn.loading-state .ph-bold{font-size:26px;transform-origin:50% 50%;animation:icon_spin 1.2s linear infinite}.btn-icon{display:flex;justify-content:center;align-items:center;width:34px;height:34px;background:0 0;color:#c0caf5;font-size:22px;border:2px solid transparent;border-radius:3px;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.btn-icon:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.btn-icon:not(.without-hover):hover{color:#e0af68;border-color:#e0af68}}@media(hover:none)and (pointer:coarse){.btn-icon:not(.without-hover):active{color:#e0af68;border-color:#e0af68}}.btn-icon:disabled,.btn-icon[disabled]{color:#787c99;border-color:transparent;background-color:transparent;cursor:not-allowed;opacity:.72}@media(hover:hover)and (pointer:fine){.btn-icon:disabled:not(.without-hover):hover,.btn-icon[disabled]:not(.without-hover):hover{color:#787c99;border-color:transparent}}@media(hover:none)and (pointer:coarse){.btn-icon:disabled:not(.without-hover):active,.btn-icon[disabled]:not(.without-hover):active{color:#787c99;border-color:transparent}}.btn-icon-sm{width:28px;height:28px;font-size:18px}.form-group{width:100%;max-width:600px}.form-group .label{display:flex;flex-direction:column;font-size:14px;width:100%;position:relative;color:#c0caf5}.form-group .label>.ph{position:absolute;color:#c0caf5;left:0;bottom:1px;font-size:26px;height:46px;display:inline-flex;align-items:center;width:40px;justify-content:center;transition-duration:.2s;transition-property:color,left}.form-group .label .input{min-height:46px;font-family:IBM Plex Mono,monospace;font-size:14px;font-weight:500;line-height:1;letter-spacing:.04em;padding:12px 22px;margin-top:8px;border-radius:3px;border-width:2px;border-bottom-width:6px;border-style:solid;border-color:#c0caf5;color:#c0caf5;background-color:#1f2335;transition-duration:.2s;transition-timing-function:ease;transition-property:background-color,border-color,color}@media(hover:hover)and (pointer:fine){.form-group .label .input:hover{border-bottom-color:#787c99}}@media(hover:none)and (pointer:coarse){.form-group .label .input:active{border-bottom-color:#787c99}}.form-group .label .input:focus{outline:2px solid #E0AF68;outline-offset:3px;border-color:#7aa2f7;background-color:transparent}.form-group .label .input:disabled{color:#787c99;border-color:#c0caf53d;background:#1f2335;cursor:not-allowed;opacity:.72}.form-group .label .input[readonly]{color:#a9b1d6;border-color:#c0caf53d;background:#c0caf508}.form-group .label .input::-moz-placeholder{color:#787c99}.form-group .label .input::placeholder{color:#787c99}.form-group .label .input::-webkit-search-cancel-button,.form-group .label .input::-webkit-search-decoration,.form-group .label .input::-webkit-search-results-button,.form-group .label .input::-webkit-search-results-decoration{display:none;-webkit-appearance:none}.form-group .label .input[type=date],.form-group .label .input[type=datetime-local],.form-group .label .input[type=month],.form-group .label .input[type=time]{color-scheme:dark;cursor:pointer;min-width:0;padding-right:40px;text-transform:uppercase}.form-group .label .input[type=date]::-webkit-calendar-picker-indicator,.form-group .label .input[type=datetime-local]::-webkit-calendar-picker-indicator,.form-group .label .input[type=month]::-webkit-calendar-picker-indicator,.form-group .label .input[type=time]::-webkit-calendar-picker-indicator{width:40px;height:100%;margin:0;padding:0;background:0 0;cursor:pointer;opacity:0}.form-group .label .input[type=date]::-webkit-datetime-edit,.form-group .label .input[type=datetime-local]::-webkit-datetime-edit,.form-group .label .input[type=month]::-webkit-datetime-edit,.form-group .label .input[type=time]::-webkit-datetime-edit{padding:0}.form-group .label .input[type=date]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=datetime-local]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=month]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=time]::-webkit-datetime-edit-fields-wrapper{color:#c0caf5}.form-group .label textarea.input{height:92px;line-height:1.25;resize:none}.form-group .label .ph+.input,.form-group .label .ph+.select-wrap .select{padding-left:40px}.form-group .label .select-wrap{margin-top:8px}.form-group .label .select{width:100%;height:46px;margin-top:0;appearance:none;-webkit-appearance:none;-moz-appearance:none}.form-group .label .select:focus{outline:0}.form-group .label .select option{color:#c0caf5;background:#1f2335}.form-group .label .select-wrap:after{content:"";position:absolute;right:22px;bottom:18px;transform:translateY(-50%);width:0;height:0;border-left:8px solid transparent;border-right:8px solid transparent;border-top:10px solid #c0caf5;pointer-events:none}.form-group .label.error .input:not(:focus){border-color:#f7768e}.form-group .label.error+.input-info{color:#e0af68}.form-group .label.success .input:not(:focus){border-color:#9ece6a}.form-group .label.success+.input-info{color:#9ece6a}.form-group .label.warning .input:not(:focus){border-color:#e0af68}.form-group .label.warning+.input-info{color:#e0af68}.form-group .input-info{font-size:14px;margin-top:8px}.form-group .input-info .ph{position:relative;top:1px}.form-group .input-info.error{color:#e0af68}.form-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:15px;width:100%;max-width:760px}.fieldset{width:100%;max-width:760px;margin:0;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#1f2335}.legend{padding:5px 8px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}@media(max-width:767px){.form-grid{grid-template-columns:1fr}}.file-upload{display:inline-flex;align-items:center;gap:8px;min-height:40px;padding:8px 12px;border:2px solid #7aa2f7;border-left-width:6px;border-radius:3px;color:#7aa2f7;background:#1f2335;font-size:13px;font-weight:700;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.file-upload input[type=file]{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}@media(hover:hover)and (pointer:fine){.file-upload:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.file-upload:active{color:#16161e;background:#7aa2f7}}.file-upload:focus-within{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-panel{width:100%;max-width:760px;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px;border-left-width:6px}.file-upload-form{display:flex;flex-direction:column;gap:15px;margin:0}.file-upload-header{display:flex;align-items:flex-start;justify-content:space-between;gap:15px;padding:15px 15px 0}.file-upload-heading{display:flex;flex-direction:column;gap:5px;min-width:0}.file-upload-title{margin:0;color:#c0caf5;font-size:15px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-description{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.file-upload-dropzone{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:center;gap:15px;margin:0 15px;padding:18px;border:2px dashed #7aa2f7;border-radius:6px;background:#7aa2f714;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color}.file-upload-dropzone input[type=file]{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}@media(hover:hover)and (pointer:fine){.file-upload-dropzone:hover{border-color:#c0caf5;background:#c0caf51a}}@media(hover:none)and (pointer:coarse){.file-upload-dropzone:active{border-color:#c0caf5;background:#c0caf51a}}.file-upload-dropzone:focus-within{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-icon{display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;color:#16161e;background:#7aa2f7;font-size:26px}.file-upload-body{display:flex;flex-direction:column;gap:5px;min-width:0}.file-upload-primary{color:#c0caf5;font-size:14px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-secondary{color:#a9b1d6;font-size:13px;line-height:1.4}.file-upload-preview{display:grid;grid-template-columns:repeat(auto-fill,minmax(148px,1fr));gap:12px;margin:0 15px}.file-upload-preview[hidden]{display:none}.file-upload-preview-item{position:relative;min-width:0;margin:0;border:2px solid rgba(192,202,245,.24);border-radius:3px;background:#1f2335}.file-upload-preview-remove{position:absolute;top:8px;right:8px;z-index:1;display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;padding:0;border:2px solid #f7768e;color:#f7768e;background:#1f2335;font-size:18px;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}@media(hover:hover)and (pointer:fine){.file-upload-preview-remove:hover{color:#16161e;background:#f7768e}}@media(hover:none)and (pointer:coarse){.file-upload-preview-remove:active{color:#16161e;background:#f7768e}}.file-upload-preview-remove:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-preview-visual{display:flex;align-items:center;justify-content:center;aspect-ratio:1;background:#1f2335}.file-upload-preview-visual img{display:block;width:100%;height:100%;-o-object-fit:cover;object-fit:cover}.file-upload-preview-type{display:inline-flex;align-items:center;justify-content:center;min-width:46px;min-height:46px;padding:8px;color:#16161e;background:#7aa2f7;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}.file-upload-preview-item figcaption{display:flex;flex-direction:column;gap:5px;overflow:hidden;padding:8px}.file-upload-preview-name{overflow:hidden;color:#c0caf5;font-size:12px;font-weight:700;line-height:1.25;text-overflow:ellipsis;white-space:nowrap}.file-upload-preview-meta{color:#a9b1d6;font-size:12px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-actions{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px;padding:0 15px 15px}@media(max-width:767px){.file-upload-header{flex-direction:column;align-items:stretch}.file-upload-dropzone{grid-template-columns:1fr}.file-upload-actions{justify-content:stretch}.file-upload-actions .btn{width:100%}}.range{width:100%;max-width:600px;accent-color:#7AA2F7}.range input[type=range]{-webkit-appearance:none;-moz-appearance:none;appearance:none;width:100%;height:40px;margin:0;background:0 0;cursor:pointer}.range input[type=range]::-webkit-slider-runnable-track{height:6px;background:#c0caf516;border:2px solid rgba(192,202,245,.24)}.range input[type=range]::-webkit-slider-thumb{width:16px;height:34px;margin-top:-17px;border:2px solid #7aa2f7;background:#7aa2f7;-webkit-appearance:none}.range input[type=range]::-moz-range-track{height:6px;background:#c0caf516;border:2px solid rgba(192,202,245,.24)}.range input[type=range]::-moz-range-thumb{width:16px;height:34px;border:2px solid #7aa2f7;border-radius:3px;background:#7aa2f7}.radio{display:inline-flex;flex-direction:row;gap:8px;align-items:center;cursor:pointer}.radio input[type=radio]{display:none}.radio .radio-control{width:20px;height:20px;border-radius:100%;border:3px solid #c0caf5;background:#1f2335;position:relative;display:flex;align-items:center;justify-content:center;flex-shrink:0;transition-duration:.2s;transition-property:border-color,background}.radio .radio-control:before{content:"";display:block;width:10px;height:10px;border-radius:100%;background:#c0caf5;transform:scale(0);transition-duration:.2s;transition-property:transform,background}@media(hover:hover)and (pointer:fine){.radio:hover .radio-control{background:#414868}}@media(hover:none)and (pointer:coarse){.radio:active .radio-control{background:#414868}}.radio input[type=radio]:checked:not(:disabled)+.radio-control{background:#c0caf52e}.radio input[type=radio]:checked+.radio-control:before{transform:scale(1)}.radio input[type=radio]:disabled+.radio-control{border-color:#414868;background:#4148681f;opacity:.5}.radio input[type=radio]:disabled:checked+.radio-control:before{background:#414868}.radio input[type=radio]:focus-visible+.radio-control{outline:2px solid #E0AF68;outline-offset:3px}.radio .radio-label{font-size:14px}.radio-group{display:flex;flex-wrap:wrap;gap:12px;align-items:center}.switch{display:inline-flex;flex-direction:row;gap:8px;align-items:center;cursor:pointer}.switch input[type=checkbox]{display:none}.switch .switch-control{height:14px;width:28px;border-radius:999px;border:2px solid #c0caf5;position:relative;background:0 0;transition-duration:.2s;transition-property:border-color,background;display:block}.switch .switch-control:before{content:"";display:block;height:18px;width:18px;border-radius:3px;background:#c0caf5;position:absolute;left:-5px;top:-5px;transition-duration:.2s;transition-property:left,background}@media(hover:hover)and (pointer:fine){.switch:hover .switch-control{background:#414868}}@media(hover:none)and (pointer:coarse){.switch:active .switch-control{background:#414868}}.switch input[type=checkbox]:checked:not(:disabled)+.switch-control{background:#7aa2f7;border-color:#7aa2f7}.switch input[type=checkbox]:checked+.switch-control:before{left:15px}.switch input[type=checkbox]:disabled+.switch-control{border-color:#414868}.switch input[type=checkbox]:focus-visible+.switch-control{outline:2px solid #E0AF68;outline-offset:3px}.switch input[type=checkbox]:disabled+.switch-control:before{background:#414868}.checkbox{display:inline-flex;flex-direction:row;gap:8px;align-items:center;cursor:pointer}.checkbox input[type=checkbox]{display:none}.checkbox .checkbox-control{width:20px;height:20px;border-radius:3px;border:2px solid #c0caf5;border-bottom-width:6px;background:#1f2335;position:relative;display:flex;align-items:center;justify-content:center;flex-shrink:0;transition-duration:.2s;transition-property:border-color,background}.checkbox .checkbox-control:before{content:"";display:block;width:10px;height:5px;border-left:2px solid #c0caf5;border-bottom:2px solid #c0caf5;transform:rotate(-45deg) scale(0);opacity:0;margin-top:-2px;transition-duration:.2s;transition-property:transform,opacity,border-color}@media(hover:hover)and (pointer:fine){.checkbox:hover .checkbox-control{background:#414868}}@media(hover:none)and (pointer:coarse){.checkbox:active .checkbox-control{background:#414868}}.checkbox input[type=checkbox]:checked:not(:disabled)+.checkbox-control{background:#c0caf52e}.checkbox input[type=checkbox]:checked+.checkbox-control:before{transform:rotate(-45deg) scale(1);opacity:1;border-color:#c0caf5}.checkbox input[type=checkbox]:disabled+.checkbox-control{border-color:#414868;background:#4148681f;opacity:.5}.checkbox input[type=checkbox]:disabled:checked+.checkbox-control:before{border-color:#414868}.checkbox input[type=checkbox]:focus-visible+.checkbox-control{outline:2px solid #E0AF68;outline-offset:3px}.checkbox .checkbox-label{font-size:14px}.input-group{display:flex;align-items:stretch;width:100%;max-width:600px;min-height:46px;border:2px solid rgba(192,202,245,.24);border-bottom-width:6px;border-radius:3px;overflow:hidden;background:#1f2335;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background}.input-group:focus-within{outline:2px solid #E0AF68;outline-offset:3px;border-color:#7aa2f7;background:0 0}.input-group .input-group-action,.input-group .input-group-addon{display:inline-flex;align-items:center;justify-content:center;min-width:46px;padding:0 12px;color:#a9b1d6;background:#c0caf50b;border:0;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;text-transform:uppercase}.input-group .input-group-action{color:#c0caf5;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.input-group .input-group-input{flex:1 1 auto;min-width:0;border:0;padding:12px 15px;color:#c0caf5;background:0 0;font-family:IBM Plex Mono,monospace;font-size:14px;font-weight:500;letter-spacing:.04em}.input-group .input-group-input:focus{outline:0}.input-group .input-group-input::-moz-placeholder{color:#787c99}.input-group .input-group-input::placeholder{color:#787c99}.input-group .input-group-input::-webkit-search-cancel-button,.input-group .input-group-input::-webkit-search-decoration,.input-group .input-group-input::-webkit-search-results-button,.input-group .input-group-input::-webkit-search-results-decoration{display:none;-webkit-appearance:none}.input-group .ph,.input-group .ph-bold{font-size:22px}.input-group.input-group-compact{min-height:40px}.input-group.input-group-compact .input-group-action,.input-group.input-group-compact .input-group-addon{min-width:40px}.input-group.input-group-compact .input-group-input{padding:8px 12px;font-size:13px}.search-field{max-width:420px}.repeater .repeater-header{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-bottom:12px}.repeater .repeater-title{font-size:14px;font-weight:600;color:#c0caf5}.repeater .repeater-list{display:grid;gap:8px}.repeater .repeater-item{background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px;padding:12px;display:grid;grid-template-columns:1fr auto;gap:12px;align-items:start}.repeater .repeater-item-body{width:100%}.repeater .repeater-item-actions{display:flex;align-items:center;gap:8px;padding-top:22px}.repeater.repeater-disabled{opacity:.6;pointer-events:none}.list{display:flex;flex-direction:column;gap:5px;list-style-type:none;padding-left:0}.list .list-item{display:flex;flex-direction:row;align-items:center;gap:8px;margin-left:0}.list.list-ordered{list-style-type:decimal;display:list-item;margin-left:30px}.list.list-ordered .list-item{display:list-item}.list.list-definition{width:100%;max-width:620px;gap:0;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.list.list-definition .list-row{display:grid;grid-template-columns:minmax(120px,.32fr) minmax(0,1fr);gap:15px;align-items:start;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color}.list.list-definition .list-row .list-term{display:inline-flex;width:-moz-max-content;width:max-content;max-width:100%;margin:0;padding:5px 8px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:background,transform}.list.list-definition .list-row .list-desc{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6;transition-duration:.2s;transition-timing-function:ease;transition-property:color,transform}.list.list-definition .list-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.list.list-definition .list-row:hover{background:#c0caf516}.list.list-definition .list-row:hover .list-term{background:#7aa2f7;transform:translate(5px)}.list.list-definition .list-row:hover .list-desc{color:#c0caf5;transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.list.list-definition .list-row:active{background:#c0caf516}.list.list-definition .list-row:active .list-term{background:#7aa2f7;transform:translate(5px)}.list.list-definition .list-row:active .list-desc{color:#c0caf5;transform:translate(5px)}}.list.list-nav{max-width:420px;width:100%;gap:0}.list.list-nav .list-item{display:flex;flex-direction:column;align-items:flex-start;height:50px;margin:0}.list.list-nav .list-item .list-action{display:flex;justify-content:space-between;align-items:center;width:100%;height:100%;padding:8px 12px;border:2px solid transparent;border-radius:3px;font-size:14px;background:#1f2335;color:inherit;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color,color}.list.list-nav .list-item .list-action:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.list.list-nav .list-item .list-action:hover{background:#7aa2f7;color:#16161e}}@media(hover:none)and (pointer:coarse){.list.list-nav .list-item .list-action:active{background:#7aa2f7;color:#16161e}}.list.list-nav .list-item .list-action .list-label{display:flex;flex-direction:row;gap:8px;align-items:center;letter-spacing:0;font-weight:400}.list.list-nav .list-item .list-action .list-meta{padding:8px;background:#9ece6a;color:#16161e;display:flex}.list.list-nav .list-item.list-item-active .list-action{background:#7aa2f7;color:#16161e;border-color:#7aa2f7}.list.list-actions{width:100%;max-width:420px;gap:22px}.list.list-actions .list-item{justify-content:space-between;align-items:flex-start;padding:12px 0;border-bottom:2px solid rgba(192,202,245,.08)}.list.list-actions .list-item .list-content{display:flex;flex-direction:column;gap:8px}.list.list-actions .list-item .list-content .list-title{font-size:15px;line-height:1}.list.list-actions .list-item .list-content .list-subtitle{color:#787c99}@media(hover:hover)and (pointer:fine){.list.list-actions .list-item:hover .list-title{color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.list.list-actions .list-item:active .list-title{color:#7aa2f7}}@media(max-width:479px){.list.list-definition .list-row{grid-template-columns:1fr;gap:8px}}.badge{position:relative;overflow:hidden;border-radius:3px;background:#c0caf5;color:#16161e;padding:5px 8px;font-size:13px;font-weight:600;line-height:1;letter-spacing:.04em;text-transform:uppercase;display:inline-flex;align-items:center;min-height:24px;transition-duration:.2s;transition-timing-function:ease;transition-property:filter,transform,border-color,color,background}.badge:after{content:"";position:absolute;inset:0 auto 0 0;width:40%;background:linear-gradient(90deg,transparent,rgba(22,22,30,.16),transparent);opacity:0;pointer-events:none;transform:translate(-120%)}@media(hover:hover)and (pointer:fine){.badge:hover{filter:saturate(1.12);transform:translateY(-1px)}.badge:hover:after{opacity:1;animation:terminal_scan_x .7s ease}}@media(hover:none)and (pointer:coarse){.badge:active{filter:saturate(1.12);transform:translateY(-1px)}.badge:active:after{opacity:1;animation:terminal_scan_x .7s ease}}.badge.badge-success{background:#9ece6a}.badge.badge-warning{background:#e0af68}.badge.badge-danger,.badge.badge-error{background:#f7768e}.badge.badge-info{background:#bb9af7;color:#16161e}.badge.badge-secondary{background:#7aa2f7;color:#16161e}.badge.badge-primary-outline{color:#c0caf5;border:2px solid #c0caf5;background:0 0;padding:3px 8px}.chip-group{display:flex;flex-wrap:wrap;gap:8px;align-items:center}.chip{display:inline-flex;align-items:center;gap:8px;min-height:30px;padding:5px 12px;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#a9b1d6;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:12px;font-weight:600;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color,opacity}.chip .ph,.chip .ph-bold{font-size:18px}.chip:before{content:"";display:inline-block;width:7px;height:7px;flex:0 0 auto;background:#787c99;transition-duration:.2s;transition-timing-function:ease;transition-property:background,box-shadow,transform}.chip:has(.ph):before,.chip:has(.ph-bold):before{display:none}.chip .chip-remove{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;margin-right:-5px;border:0;color:inherit;background:0 0;font:inherit;cursor:pointer}.chip .chip-remove:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.chip.chip-primary{color:#c0caf5;background:#c0caf514;border-color:#c0caf5}.chip.chip-primary:before{background:#c0caf5}.chip.chip-secondary{color:#7aa2f7;background:#7aa2f714;border-color:#7aa2f7}.chip.chip-secondary:before{background:#7aa2f7}.chip.chip-success{color:#9ece6a;background:#9ece6a14;border-color:#9ece6a}.chip.chip-success:before{background:#9ece6a}.chip.chip-warning{color:#e0af68;background:#e0af6814;border-color:#e0af68}.chip.chip-warning:before{background:#e0af68}.chip.chip-danger,.chip.chip-error{color:#f7768e;background:#f7768e14;border-color:#f7768e}.chip.chip-danger:before,.chip.chip-error:before{background:#f7768e}.chip.chip-selected,.chip[aria-pressed=true],.chip[aria-selected=true]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.chip.chip-selected:before,.chip[aria-pressed=true]:before,.chip[aria-selected=true]:before{background:#16161e}.chip.chip-secondary[aria-pressed=true],.chip.chip-secondary[aria-selected=true],.chip.chip-selected.chip-secondary{background:#7aa2f7;border-color:#7aa2f7}.chip.chip-disabled,.chip:disabled{color:#787c99;background:#1f2335;border-color:#c0caf53d;cursor:not-allowed;opacity:.7}.chip.chip-disabled:before,.chip:disabled:before{background:#414868}a.chip,button.chip{cursor:pointer}a.chip:focus-visible,button.chip:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){a.chip:hover,button.chip:hover{color:#c0caf5;background:#c0caf516;border-color:#7aa2f7}a.chip:hover:before,button.chip:hover:before{background:#7aa2f7;animation:terminal_pulse .7s ease;transform:scale(1.12)}}@media(hover:none)and (pointer:coarse){a.chip:active,button.chip:active{color:#c0caf5;background:#c0caf516;border-color:#7aa2f7}a.chip:active:before,button.chip:active:before{background:#7aa2f7;animation:terminal_pulse .7s ease;transform:scale(1.12)}}.tag-input{background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px;position:relative}.tag-input .tag-input-wrap{display:flex;flex-wrap:wrap;align-items:center;gap:8px;padding:8px 12px;min-height:40px;cursor:text}.tag-input .tag-input-field{flex:1 1 auto;min-width:80px;padding:5px 0;border:0;color:#c0caf5;background:0 0;font-family:IBM Plex Mono,monospace;font-size:13px;line-height:1;outline:0}.tag-input .tag-input-field::-moz-placeholder{color:#787c99;opacity:1}.tag-input .tag-input-field::placeholder{color:#787c99;opacity:1}.tag-input.tag-input-focused{border-color:#c0caf5}.tag-input .tag-input-meta{padding:0 12px 8px;color:#787c99;font-size:12px;line-height:1}.avatar{position:relative;display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;flex:0 0 auto;overflow:hidden;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#16161e;background:#c0caf5;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}.avatar img{width:100%;height:100%;-o-object-fit:cover;object-fit:cover}.avatar .ph,.avatar .ph-bold{font-size:22px}.avatar .avatar-status{position:absolute;right:-2px;bottom:-2px;width:13px;height:13px;border:2px solid #16161e;background:#787c99;transition-duration:.2s;transition-timing-function:ease;transition-property:background,box-shadow}.avatar.avatar-sm{width:34px;height:34px;font-size:12px}.avatar.avatar-sm .ph,.avatar.avatar-sm .ph-bold{font-size:18px}.avatar.avatar-lg{width:46px;height:46px;font-size:14px}.avatar.avatar-lg .ph,.avatar.avatar-lg .ph-bold{font-size:26px}.avatar.avatar-secondary{background:#7aa2f7}.avatar.avatar-success{background:#9ece6a}.avatar.avatar-warning{background:#e0af68}.avatar.avatar-danger,.avatar.avatar-error{background:#f7768e}.avatar.avatar-outline{color:#c0caf5;background:#1f2335;border-color:#c0caf5}.avatar.is-online .avatar-status{background:#9ece6a;animation:terminal_pulse 1.8s ease infinite}.avatar.is-busy .avatar-status{background:#e0af68}.avatar.is-offline .avatar-status{background:#787c99}.identity{display:inline-flex;align-items:center;gap:12px;min-width:0}.identity-content{display:flex;flex-direction:column;gap:5px;min-width:0}.identity-title{color:#c0caf5;font-size:14px;font-weight:600;line-height:1}.identity-meta{color:#787c99;font-size:13px;line-height:1.4}.avatar-stack{display:inline-flex;align-items:center}.avatar-stack .avatar{margin-right:-8px;border-color:#16161e}.avatar-stack .avatar-stack-count{display:inline-flex;align-items:center;justify-content:center;min-width:40px;height:40px;padding:0 8px;border:2px solid #16161e;color:#16161e;background:#e0af68;font-size:13px;font-weight:700}.table{width:100%;text-align:left;border:2px solid rgba(192,202,245,.24);border-collapse:separate;border-spacing:0;border-radius:6px;background:#1f2335}.table .table-row:first-child>:first-child{border-top-left-radius:6px}.table .table-row:first-child>:last-child{border-top-right-radius:6px}.table .table-row:last-child>:first-child{border-bottom-left-radius:6px}.table .table-row:last-child>:last-child{border-bottom-right-radius:6px}.table .table-caption{text-align:left;font-size:15px;background:#c0caf5;width:-moz-max-content;width:max-content;color:#16161e;padding:5px 12px;margin-bottom:0;font-weight:700;text-transform:uppercase}.table.table-empty{width:100%}.table.table-empty .is-empty{width:100%;padding:15px;font-size:13px;color:#787c99;text-align:left}.table .table-row td,.table .table-row th{padding:12px 18px;font-size:13px;vertical-align:middle;border-bottom:2px solid rgba(192,202,245,.08)}.table .table-row th{color:#c0caf5;background:#c0caf50a;text-transform:uppercase;letter-spacing:.04em}.table .table-head{border-bottom:2px solid #c0caf5}.table .table-body .table-row{transition-duration:.2s;transition-timing-function:ease;transition-property:background,color}.table .table-body .table-row td{transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}@media(hover:hover)and (pointer:fine){.table .table-body .table-row:hover{background:#7aa2f714}.table .table-body .table-row:hover td:first-child{color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.table .table-body .table-row:active{background:#7aa2f714}.table .table-body .table-row:active td:first-child{color:#7aa2f7}}.table .table-foot td,.table .table-foot th{padding-top:15px}.table.table-compact .table-caption{font-size:14px}.table.table-compact .table-row td,.table.table-compact .table-row th{padding:8px 12px;font-size:12px}.table.table-compact .table-cell-mono{color:#a9b1d6;font-family:IBM Plex Mono,monospace;letter-spacing:0}.table.table-compact .table-cell-actions{width:1%;white-space:nowrap}.table-wrapper{width:100%;overflow-x:auto}.toolbar{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:12px;width:100%;padding:12px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.toolbar .toolbar-group{display:flex;flex-wrap:wrap;align-items:center;gap:8px;min-width:0}.toolbar .toolbar-title{margin:0;font-size:15px;font-weight:700;line-height:1;text-transform:uppercase}.toolbar .toolbar-meta{color:#787c99;font-size:13px}.pagination{display:flex;flex-wrap:wrap;align-items:center;gap:8px}.pagination .pagination-item{display:inline-flex;align-items:center;justify-content:center;min-width:34px;border-radius:3px;height:34px;padding:0 12px;border:2px solid rgba(192,202,245,.24);color:#a9b1d6;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;line-height:1;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color,opacity}.pagination .pagination-item:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.pagination .pagination-item:hover{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.pagination .pagination-item:active{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}.pagination .pagination-item.pagination-item-active,.pagination .pagination-item[aria-current=page]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.pagination .pagination-item.pagination-item-disabled,.pagination .pagination-item:disabled{color:#787c99;background:#1f2335;border-color:#c0caf53d;cursor:not-allowed;opacity:.72}.pagination .pagination-ellipsis{color:#787c99;padding:0 5px}.empty-state{max-width:560px;padding:22px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.empty-state .empty-state-icon{display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;margin-bottom:15px;color:#16161e;background:#c0caf5;font-size:26px}.empty-state .empty-state-title{margin:0 0 8px;font-size:18px;font-weight:700;text-transform:uppercase}.empty-state .empty-state-text{max-width:440px;margin:0 0 18px;color:#a9b1d6;line-height:1.6}.empty-state .empty-state-actions{display:flex;flex-wrap:wrap;gap:8px}.empty-state.empty-state-error{border-color:#f7768e}.empty-state.empty-state-error .empty-state-icon{background:#f7768e}.skeleton{display:block;position:relative;overflow:hidden;border-radius:3px;background:#c0caf516}.skeleton:after{content:"";position:absolute;top:0;right:0;bottom:0;left:0;transform:translate(-100%);background:linear-gradient(90deg,transparent,rgba(192,202,245,.12),transparent);animation:skeleton_shimmer 1.6s infinite}.skeleton.skeleton-line{width:100%;height:14px}.skeleton.skeleton-title{width:60%;height:22px}.skeleton.skeleton-block{width:100%;height:120px}.skeleton.skeleton-square{width:46px;height:46px}.skeleton-stack{display:flex;flex-direction:column;gap:12px;max-width:520px;padding:15px;border:2px solid rgba(192,202,245,.24);border-radius:6px;background:#1f2335}@keyframes skeleton_shimmer{to{transform:translate(100%)}}.page-header{display:flex;flex-wrap:wrap;align-items:flex-end;justify-content:space-between;gap:18px;width:100%;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335;animation:panel_boot .28s ease both}.page-header .page-header-content{display:flex;flex-direction:column;gap:8px;min-width:min(100%,320px)}.page-header .page-header-kicker{color:#7aa2f7;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color}.page-header .page-header-title{margin:0;color:#c0caf5;font-size:23px;font-weight:700;line-height:1.15}.page-header .page-header-subtitle{max-width:720px;margin:0;color:#a9b1d6;font-size:14px;line-height:1.6}.page-header .page-header-meta{display:flex;flex-wrap:wrap;align-items:center;gap:8px;color:#787c99;font-size:13px}.page-header .page-header-actions{display:flex;flex-wrap:wrap;align-items:center;justify-content:flex-end;gap:8px}.page-header.page-header-compact{align-items:center;padding:15px}.page-header.page-header-compact .page-header-title{font-size:18px}.page-header.page-header-accent{border-color:#7aa2f7;background:#7aa2f70e}.description-list{display:grid;width:100%;max-width:760px;margin:0;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.description-list .description-list-row{display:grid;grid-template-columns:minmax(140px,.36fr) minmax(0,1fr);gap:15px;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background}.description-list .description-list-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.description-list .description-list-row:hover{background:#c0caf516}.description-list .description-list-row:hover .description-list-term{color:#7aa2f7}.description-list .description-list-row:hover .description-list-value{transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.description-list .description-list-row:active{background:#c0caf516}.description-list .description-list-row:active .description-list-term{color:#7aa2f7}.description-list .description-list-row:active .description-list-value{transform:translate(5px)}}.description-list .description-list-term{margin:0;color:#787c99;font-size:13px;font-weight:600;line-height:1.4;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color}.description-list .description-list-value{display:flex;flex-wrap:wrap;align-items:center;gap:8px;min-width:0;margin:0;color:#c0caf5;font-size:14px;line-height:1.4;transition-duration:.2s;transition-timing-function:ease;transition-property:transform}.description-list .description-list-value-muted{color:#a9b1d6}.description-list.description-list-compact{max-width:520px}.description-list.description-list-compact .description-list-row{grid-template-columns:minmax(112px,.42fr) minmax(0,1fr);gap:12px;padding:8px 12px}.description-list.description-list-compact .description-list-term,.description-list.description-list-compact .description-list-value{font-size:13px}@media(max-width:479px){.description-list .description-list-row{grid-template-columns:1fr;gap:5px}}.steps{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;width:100%;max-width:900px;margin:0;padding:0;list-style:none}.steps .step{position:relative;display:flex;flex-direction:column;gap:8px;min-height:120px;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.steps .step-marker{display:inline-flex;align-items:center;justify-content:center;width:34px;height:34px;border-radius:3px;color:#c0caf5;border:2px solid rgba(192,202,245,.24);font-size:13px;font-weight:700;line-height:1}.steps .step-title{margin:0;font-size:14px;font-weight:700;line-height:1.25;text-transform:uppercase}.steps .step-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.steps .step-complete{border-color:#9ece6a}.steps .step-complete .step-marker{color:#16161e;background:#9ece6a;border-color:#9ece6a}.steps .step-current{border-color:#7aa2f7}.steps .step-current .step-marker{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}.steps .step-disabled{opacity:.62}.steps.steps-vertical{grid-template-columns:1fr;max-width:520px;gap:0}.steps.steps-vertical .step{min-height:auto;border-bottom-width:0;border-radius:0}.steps.steps-vertical .step:last-child{border-bottom-width:2px}@media(max-width:1023px){.steps{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:479px){.steps{grid-template-columns:1fr}}.timeline{display:grid;gap:0;width:100%;max-width:760px;margin:0;padding:0;list-style:none}.timeline .timeline-item{position:relative;display:grid;grid-template-columns:40px minmax(0,1fr);gap:12px;min-height:88px}.timeline .timeline-item:before{content:"";position:absolute;top:40px;bottom:0;left:19px;width:2px;background:#c0caf53d}.timeline .timeline-item:last-child:before{display:none}.timeline .timeline-marker{position:relative;z-index:1;display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#a9b1d6;background:#16161e;font-size:18px;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background,color,box-shadow,transform}.timeline .timeline-content{min-width:0;padding:0 0 18px}.timeline .timeline-card{padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background,transform}.timeline .timeline-header{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px;margin-bottom:8px}.timeline .timeline-title{margin:0;font-size:14px;font-weight:700;line-height:1.25;text-transform:uppercase}.timeline .timeline-time{color:#787c99;font-size:12px;font-family:IBM Plex Mono,monospace;line-height:1.4}.timeline .timeline-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.timeline .timeline-meta{display:flex;flex-wrap:wrap;gap:8px;margin-top:12px}.timeline .timeline-item-success .timeline-card,.timeline .timeline-item-success .timeline-marker{border-color:#9ece6a}.timeline .timeline-item-success .timeline-marker{color:#16161e;background:#9ece6a}.timeline .timeline-item-warning .timeline-card,.timeline .timeline-item-warning .timeline-marker{border-color:#e0af68}.timeline .timeline-item-warning .timeline-marker{color:#16161e;background:#e0af68}.timeline .timeline-item-danger .timeline-card,.timeline .timeline-item-danger .timeline-marker,.timeline .timeline-item-error .timeline-card,.timeline .timeline-item-error .timeline-marker{border-color:#f7768e}.timeline .timeline-item-danger .timeline-marker,.timeline .timeline-item-error .timeline-marker{color:#16161e;background:#f7768e}@media(hover:hover)and (pointer:fine){.timeline .timeline-item:hover .timeline-marker{box-shadow:0 0 0 4px #7aa2f724;transform:scale(1.04)}.timeline .timeline-item:hover .timeline-card{background:#c0caf516;transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.timeline .timeline-item:active .timeline-marker{box-shadow:0 0 0 4px #7aa2f724;transform:scale(1.04)}.timeline .timeline-item:active .timeline-card{background:#c0caf516;transform:translate(5px)}}.activity-log{display:grid;width:100%;max-width:720px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;overflow:hidden;background:#1f2335}.activity-log .activity-log-row{display:grid;grid-template-columns:minmax(120px,.24fr) minmax(0,1fr) auto;gap:12px;align-items:center;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background}.activity-log .activity-log-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.activity-log .activity-log-row:hover{background:#c0caf516}}@media(hover:none)and (pointer:coarse){.activity-log .activity-log-row:active{background:#c0caf516}}.activity-log .activity-log-time{color:#787c99;font-family:IBM Plex Mono,monospace;font-size:12px}.activity-log .activity-log-title{color:#c0caf5;font-size:13px;font-weight:600;line-height:1.4}@media(max-width:479px){.activity-log .activity-log-row{grid-template-columns:1fr;gap:8px}}.accordion{display:grid;width:100%;max-width:760px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;overflow:hidden;background:#1f2335}.accordion-item{border-bottom:2px solid rgba(192,202,245,.08);overflow:hidden}.accordion-item:last-child{border-bottom:0}.accordion-item[open] .accordion-summary{color:#16161e;background:#c0caf5}.accordion-item[open] .accordion-icon{transform:rotate(180deg)}.accordion-summary{display:flex;width:100%;align-items:center;justify-content:space-between;gap:12px;min-height:40px;padding:12px 15px;border:0;color:#c0caf5;background:0 0;cursor:pointer;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.accordion-summary::-webkit-details-marker{display:none}.accordion-summary::marker{content:""}.accordion-summary:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.accordion-summary:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.accordion-summary:active{color:#16161e;background:#7aa2f7}}.accordion-summary-content{display:flex;align-items:center;gap:8px;min-width:0}.accordion-icon{flex:0 0 auto;font-size:18px;transition-duration:.2s;transition-property:transform}.accordion-panel{overflow:hidden;padding:15px;color:#a9b1d6;font-size:13px;line-height:1.6;transition-duration:.28s;transition-timing-function:ease;transition-property:height,opacity,transform}.accordion-panel p{margin-top:0}.accordion-panel p:last-child{margin-bottom:0}.disclosure{max-width:520px;border:2px solid rgba(192,202,245,.24);border-radius:6px;overflow:hidden;background:#1f2335}.disclosure .accordion-summary{min-height:34px;padding:8px 12px}.disclosure .accordion-panel{padding:12px}.tabs{width:100%;max-width:900px}.tabs-list{display:flex;align-items:stretch;gap:5px;width:-moz-fit-content;width:fit-content;max-width:100%;padding:5px;border:2px solid rgba(192,202,245,.24);border-radius:6px;background:#1f2335;overflow-x:auto;scrollbar-width:thin}.tab{position:relative;display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:40px;padding:12px 15px;border:0;border-radius:3px;color:#a9b1d6;background:0 0;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;white-space:nowrap;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,opacity}.tab .ph,.tab .ph-bold{font-size:18px}.tab:focus-visible{outline:2px solid #E0AF68;outline-offset:3px;z-index:1}@media(hover:hover)and (pointer:fine){.tab:hover{color:#c0caf5;background:#c0caf516}}@media(hover:none)and (pointer:coarse){.tab:active{color:#c0caf5;background:#c0caf516}}.tab:disabled,.tab[aria-disabled=true]{color:#787c99;cursor:not-allowed;opacity:.62}@media(hover:hover)and (pointer:fine){.tab:disabled:hover,.tab[aria-disabled=true]:hover{color:#787c99;background:0 0}}@media(hover:none)and (pointer:coarse){.tab:disabled:active,.tab[aria-disabled=true]:active{color:#787c99;background:0 0}}.tab-active,.tab[aria-selected=true]{color:#16161e;background:#c0caf5}.tab-panel{display:none}.tab-panel p{margin-top:0}.tab-panel p:last-child{margin-bottom:0}.tab-panel-active{display:block}.tabs-compact{max-width:620px}.tabs-compact .tab{min-height:34px;padding:8px 12px}.tabs-vertical{grid-template-columns:minmax(180px,240px) minmax(0,1fr);align-items:start}.tabs-vertical .tabs-list{flex-direction:column;overflow-x:visible}.tabs-vertical .tab{justify-content:flex-start;text-align:left}@media(max-width:767px){.tabs-vertical{grid-template-columns:1fr}.tabs-vertical .tabs-list{flex-direction:row;overflow-x:auto}.tabs-vertical .tab{justify-content:center;text-align:center}}.drawer{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1000;display:flex;justify-content:flex-end;pointer-events:none}.drawer .drawer-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1010;background:#16161e;opacity:0;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity;pointer-events:auto}.drawer .drawer-panel{position:relative;z-index:1020;width:min(460px,100vw - 18px);min-height:100vh;display:flex;flex-direction:column;gap:15px;background:#16161e;border-left:2px solid rgba(192,202,245,.24);box-shadow:-18px 0 42px #16161e61;opacity:0;transform:translate(100%);transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,transform;pointer-events:auto}.drawer .drawer-header{display:flex;align-items:center;justify-content:space-between;padding-right:15px;border-bottom:2px solid rgba(192,202,245,.24)}.drawer .drawer-title{margin:0;padding:12px 15px;color:#c0caf5;text-transform:uppercase;letter-spacing:.04em}.drawer .drawer-body{flex:1;overflow-y:auto;padding:18px}.drawer .drawer-footer{padding:18px;border-top:2px solid rgba(192,202,245,.24)}.drawer .drawer-footer .actions{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:12px;width:100%}.drawer.drawer-left{justify-content:flex-start}.drawer.drawer-left .drawer-panel{border-left:0;border-right:2px solid #c0caf5;box-shadow:18px 0 42px #16161e61;transform:translate(-100%)}.drawer.a-show .drawer-backdrop{opacity:.82}.drawer.a-show .drawer-panel{opacity:1;transform:translate(0)}.drawer.a-hide .drawer-backdrop{opacity:0}.drawer.a-hide .drawer-panel{opacity:0;transform:translate(100%)}.drawer.a-hide.drawer-left .drawer-panel{transform:translate(-100%)}.drawer-preview{display:grid;grid-template-columns:minmax(0,1fr) minmax(180px,280px);gap:18px;align-items:stretch;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#1f2335}.drawer-preview .drawer-preview-content{display:flex;flex-direction:column;gap:12px}.drawer-preview .drawer-preview-panel{display:flex;flex-direction:column;gap:12px;padding:15px;border:2px solid #7aa2f7;border-radius:6px;background:#1f2335}.drawer-preview .drawer-preview-title{margin:0;color:#7aa2f7;font-size:14px;text-transform:uppercase}.drawer-preview .drawer-preview-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}@media(max-width:720px){.drawer-preview{grid-template-columns:1fr}}.nav-topbar{position:sticky;top:0;z-index:900;display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;min-height:58px;border-bottom:2px solid rgba(192,202,245,.24);background:#16161ef5;box-shadow:0 10px 28px #16161e42}.nav-topbar-toggle{display:inline-flex;align-items:center;align-self:stretch;gap:8px;min-width:150px;padding:0 15px;border:0;border-right:2px solid rgba(192,202,245,.24);color:#c0caf5;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.nav-topbar-toggle .ph{color:#7aa2f7;font-size:22px}.nav-topbar-toggle:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.nav-topbar-toggle:hover{color:#16161e;background:#7aa2f7}.nav-topbar-toggle:hover .ph{color:#16161e}}@media(hover:none)and (pointer:coarse){.nav-topbar-toggle:active{color:#16161e;background:#7aa2f7}.nav-topbar-toggle:active .ph{color:#16161e}}.nav-topbar-brand{display:inline-flex;align-items:center;gap:8px;min-width:0;padding:0 15px;color:#c0caf5;font-size:13px;font-weight:700;text-transform:uppercase}.nav-topbar-brand img{width:48px;height:48px}.nav-topbar-current{min-width:160px;margin-right:15px;padding:5px 8px;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#a9b1d6;background:#1f2335;font-size:12px;font-weight:700;text-align:center;text-transform:uppercase}.nav-drawer-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:910;background:#16161e;opacity:0;pointer-events:none;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity}.nav-drawer{position:fixed;inset:0 auto 0 0;z-index:920;display:flex;flex-direction:column;width:min(380px,100vw);max-height:100vh;border-right:2px solid #c0caf5;background:#1f2335;box-shadow:18px 0 42px #16161e61;opacity:0;overflow:hidden;pointer-events:none;transform:translate(-100%);transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,transform}.nav-drawer.is-open{opacity:1;pointer-events:auto;transform:translate(0)}.nav-drawer-header{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px;border-bottom:2px solid rgba(192,202,245,.24)}.nav-drawer-title{display:inline-flex;padding:8px 12px;border-radius:3px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;text-transform:uppercase}.nav-drawer-subtitle{margin-top:8px;color:#787c99;font-size:12px;font-weight:700;text-transform:uppercase}.nav-drawer-close{display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;padding:0;border:2px solid rgba(192,202,245,.24);border-radius:3px;color:#c0caf5;background:0 0;font-size:22px;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.nav-drawer-close:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.nav-drawer-close:hover{color:#16161e;background:#f7768e;border-color:#f7768e}}@media(hover:none)and (pointer:coarse){.nav-drawer-close:active{color:#16161e;background:#f7768e;border-color:#f7768e}}.nav-drawer-body{flex:1;overflow-y:auto;overscroll-behavior:contain;padding:12px;scrollbar-width:thin;scrollbar-color:#7AA2F7 #1F2335}.nav-drawer-body::-webkit-scrollbar{width:8px}.nav-drawer-body::-webkit-scrollbar-track{background:#1f2335}.nav-drawer-body::-webkit-scrollbar-thumb{background:#7aa2f7}.nav-drawer-body .list.list-nav{max-width:none}.nav-drawer-footer{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px;border-top:2px solid rgba(192,202,245,.24);color:#787c99;background:#1f2335;font-size:12px;font-weight:700;text-transform:uppercase}.nav-drawer-footer .profile-identity{display:block;text-decoration:none;color:inherit;min-width:0;flex:1 1 auto;overflow:hidden}@media(hover:hover)and (pointer:fine){.nav-drawer-footer .profile-identity:hover{color:inherit}}@media(hover:none)and (pointer:coarse){.nav-drawer-footer .profile-identity:active{color:inherit}}.nav-drawer-open{overflow:hidden}.nav-drawer-open .nav-drawer-backdrop{opacity:.82;pointer-events:auto}@media(max-width:767px){.nav-topbar-toggle{min-width:54px;padding:0 12px}.nav-topbar-brand{padding-right:12px;padding-left:12px}.nav-topbar-current{max-width:38vw;min-width:0;margin-right:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.nav-drawer{width:100vw;border-right:0}}.nav-shell-preview{width:100%;max-width:900px;overflow:hidden;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;background:#16161e}.nav-shell-preview-topbar{position:relative;z-index:0;min-height:52px;box-shadow:none}.nav-shell-preview-body{display:grid;grid-template-columns:280px minmax(0,1fr);min-height:320px}.nav-shell-preview-drawer{position:relative;z-index:0;inset:auto;width:auto;max-height:none;opacity:1;pointer-events:auto;transform:none;box-shadow:none}.nav-shell-preview-content{display:flex;flex-direction:column;justify-content:center;gap:12px;min-width:0;padding:18px;border-left:2px solid rgba(192,202,245,.24);background:#1f2335}.nav-shell-preview-content h3{margin:0;color:#c0caf5;font-size:18px;text-transform:uppercase}.nav-shell-preview-content p{max-width:360px;margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}@media(max-width:767px){.nav-shell-preview-body{grid-template-columns:1fr}.nav-shell-preview-content{min-height:180px;border-top:2px solid rgba(192,202,245,.24);border-left:0}}.toast{position:fixed;z-index:1100;bottom:-100px;right:15px;max-width:420px;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;box-shadow:0 14px 36px #16161e5c;padding:0;opacity:0;overflow:hidden;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,bottom}.toast.a-show{bottom:15px;opacity:1}.toast.a-hide{bottom:-45px;opacity:0}.toast .toast-content{display:flex;flex-direction:column;gap:0;padding:15px 48px 15px 18px}.toast .toast-content .toast-header{display:flex;align-items:center;gap:8px;font-size:13px;font-weight:700;text-transform:uppercase;color:#c0caf5;line-height:1}.toast .toast-content .toast-header .ph{font-size:22px;flex-shrink:0}.toast .toast-content .toast-text{padding:8px 0 0;margin:0;color:#c0caf5;font-size:14px;line-height:1.6}.toast .toast-close{position:absolute;top:5px;right:8px;color:#a9b1d6;width:34px;height:34px;border-color:transparent;background:0 0}@media(hover:hover)and (pointer:fine){.toast .toast-close:not(.without-hover):hover{color:#c0caf5;border-color:transparent}}@media(hover:none)and (pointer:coarse){.toast .toast-close:not(.without-hover):active{color:#c0caf5;border-color:transparent}}.toast .toast-progress{height:3px;width:100%;background:#16161e73;overflow:hidden;margin-top:1px}.toast .toast-progress .toast-progress-bar{height:100%;width:100%;transform-origin:left;animation:toast-progress linear forwards;background:#7aa2f7}.toast.toast-info{border-color:#bb9af7}.toast.toast-info .toast-header,.toast.toast-info .toast-header .ph{color:#bb9af7}.toast.toast-info .toast-progress-bar{background:#bb9af7}.toast.toast-success{border-color:#9ece6a}.toast.toast-success .toast-header,.toast.toast-success .toast-header .ph{color:#9ece6a}.toast.toast-success .toast-progress-bar{background:#9ece6a}.toast.toast-warning{border-color:#e0af68}.toast.toast-warning .toast-header,.toast.toast-warning .toast-header .ph{color:#e0af68}.toast.toast-warning .toast-progress-bar{background:#e0af68}.toast.toast-danger{border-color:#f7768e}.toast.toast-danger .toast-header,.toast.toast-danger .toast-header .ph{color:#f7768e}.toast.toast-danger .toast-progress-bar{background:#f7768e}@keyframes toast-progress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}.card{position:relative;max-width:340px;width:-moz-max-content;width:max-content;overflow:hidden;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px}.card .card-title{color:#c0caf5;padding:15px 15px 0;font-weight:700;text-transform:uppercase}.card .card-content{padding:15px;height:100%}.card .card-content .card-thumb{display:block;width:min(68%,190px);margin:18px auto 22px}.card .card-content p{margin-top:8px;margin-bottom:0}.card .card-footer{padding:8px 15px 15px}.card.status-card{max-width:220px;overflow:hidden}.card.status-card .status-icon-container{position:relative}.card.status-card .status-icon-container .status-indicator{position:absolute;top:-15px;left:-5px;font-size:22px;color:#f7768e}.card.status-card .status-icon-container .status-indicator.status-online{color:#9ece6a}.card.status-card .status-icon-container .status-icon{display:flex;flex-direction:row;align-items:center;justify-content:flex-start;font-size:56px;height:108px;width:100%}.card.status-card .card-title{display:flex;width:100%;font-size:14px;font-weight:700;align-items:center;flex-direction:row;flex-wrap:nowrap;justify-content:space-between}.card.status-card .status-name{font-size:13px;line-height:1.4}.card.status-card.card-success{border-color:#9ece6a}.card.status-card.card-success .card-title,.card.status-card.card-success .modal-title,.card.status-card.card-success .toast-title{color:#9ece6a;background:0 0}.card.status-card.card-success .status-icon{color:#9ece6a}.card.status-card.card-warning{border-color:#e0af68}.card.status-card.card-warning .card-title,.card.status-card.card-warning .modal-title,.card.status-card.card-warning .toast-title{color:#e0af68;background:0 0}.card.status-card.card-warning .status-icon{color:#e0af68}.card.status-card.card-info{border-color:#bb9af7}.card.status-card.card-info .card-title,.card.status-card.card-info .modal-title,.card.status-card.card-info .toast-title{color:#bb9af7;background:0 0}.card.status-card.card-info .status-icon{color:#bb9af7}.card.status-card.card-secondary{border-color:#7aa2f7}.card.status-card.card-secondary .card-title,.card.status-card.card-secondary .modal-title,.card.status-card.card-secondary .toast-title{color:#7aa2f7;background:0 0}.card.status-card.card-secondary .status-icon{color:#7aa2f7}.card.status-card.card-danger,.card.status-card.card-error{border-color:#f7768e}.card.status-card.card-danger .card-title,.card.status-card.card-danger .modal-title,.card.status-card.card-danger .toast-title,.card.status-card.card-error .card-title,.card.status-card.card-error .modal-title,.card.status-card.card-error .toast-title{color:#f7768e;background:0 0}.card.status-card.card-danger .status-icon,.card.status-card.card-error .status-icon{color:#f7768e}.card.metric-card{max-width:320px;border-color:#c0caf53d}.card.metric-card .card-content{display:flex;flex-direction:column;gap:15px}.card.metric-card .metric-card-header{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.card.metric-card .metric-card-label{margin:0;color:#a9b1d6;font-size:13px;font-weight:600;text-transform:uppercase}.card.metric-card .metric-card-icon{display:inline-flex;align-items:center;justify-content:center;width:40px;height:40px;color:#16161e;background:#7aa2f7;font-size:22px}.card.metric-card .metric-card-value{margin:0;color:#c0caf5;font-size:30px;font-weight:700;line-height:1.15}.card.metric-card .metric-card-meta{display:flex;flex-wrap:wrap;align-items:center;gap:8px;color:#787c99;font-size:13px}.card.metric-card .metric-card-delta{color:#9ece6a;font-weight:700}.card.metric-card .metric-card-delta.metric-card-delta-negative{color:#f7768e}.card.card-horizontal{max-width:none;display:flex;flex-direction:row;align-items:stretch;overflow:hidden}.card.card-horizontal .card-media{flex:0 0 20%;min-width:80px;max-width:160px;max-height:160px;overflow:hidden;position:relative;aspect-ratio:1;align-self:start}.card.card-horizontal .card-media img{width:100%;height:100%;-o-object-fit:cover;object-fit:cover;display:block}.card.card-horizontal .card-body{flex:1 1 auto;display:flex;flex-direction:column;padding:15px;gap:12px}.card.card-horizontal .card-title{padding:0;background:0 0;color:#c0caf5;font-size:15px;font-weight:700;text-transform:none;line-height:1.25}.card.card-horizontal .card-title a{color:inherit;text-decoration:none}.card.card-horizontal .card-content{padding:0;height:auto}.card.card-horizontal .card-content p{margin:0}.card.card-horizontal .card-footer{padding:0;display:flex;flex-wrap:wrap;align-items:center;gap:12px;color:#a9b1d6;font-size:13px}.card.action-card{max-width:360px;border-color:#7aa2f7}.card.action-card .card-content{display:flex;flex-direction:column;gap:15px}.card.action-card .action-card-kicker{display:inline-flex;width:-moz-max-content;width:max-content;padding:5px 8px;color:#16161e;background:#7aa2f7;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase}.card.action-card .action-card-title{margin:0;font-size:18px;font-weight:700;line-height:1.25;text-transform:uppercase}.card.action-card .action-card-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.card.action-card .action-card-actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}.card.login-card{max-width:100%;width:460px;border-color:#c0caf5}.card.login-card .login-card-header{display:flex;align-items:center;justify-content:flex-start;gap:12px;padding:12px}.card.login-card .login-card-logo{display:block;width:auto;max-height:40px}.card.login-card .login-card-logo-icon{font-size:56px;color:#c0caf5}.card.login-card .login-card-title{font-size:18px;font-weight:700;text-transform:uppercase}.card.login-card .login-card-form{display:flex;flex-direction:column;gap:15px}.card.login-card .login-card-submit{width:-moz-max-content;width:max-content;margin-top:8px}.card.login-card .form-group{margin-bottom:0}.card.login-card .login-card-links{display:flex;justify-content:space-between;gap:12px;margin-top:8px;font-size:13px}.card.login-card .login-card-link{color:#a9b1d6;text-decoration:none}@media(hover:hover)and (pointer:fine){.card.login-card .login-card-link:hover{color:#c0caf5;text-decoration:underline}}@media(hover:none)and (pointer:coarse){.card.login-card .login-card-link:active{color:#c0caf5;text-decoration:underline}}.card.login-card .login-card-error{margin-bottom:8px}.card.user-card{max-width:320px}.card.user-card .user-card-body{display:flex;flex-direction:column;align-items:center;gap:15px;padding:18px;text-align:center}.card.user-card .identity{flex-direction:column;align-items:center;gap:15px}.card.user-card .identity .avatar{width:64px;height:64px;font-size:18px}.card.user-card .identity .identity-content{align-items:center;text-align:center}.card.user-card .user-card-role{color:#a9b1d6;font-size:13px;margin-top:5px}.card.user-card .user-card-actions{display:flex;gap:8px}.card.user-card-compact{max-width:none}.card.user-card-compact .user-card-body{flex-direction:row;justify-content:space-between;align-items:center;padding:12px 15px;text-align:left}.card.user-card-compact .identity{flex-direction:row;gap:12px}.card.user-card-compact .identity .avatar{width:38px;height:38px;font-size:13px}.card.user-card-compact .identity .identity-content{align-items:flex-start}.card.user-card-compact .user-card-actions{display:flex;gap:5px}.modal{position:fixed;top:0;bottom:0;left:0;right:0;z-index:1000;display:flex;flex-direction:column;align-items:center;justify-content:center}.modal .modal-backdrop{position:fixed;z-index:1010;top:0;bottom:0;left:0;right:0;background:#16161e;opacity:0;transition-duration:.25s;transition-property:opacity}.modal .modal-dialog{position:relative;z-index:1020;width:100%;max-width:960px;margin:200px 18px 18px;height:auto;max-height:calc(100vh - 48px);padding:0;display:flex;flex-direction:column;gap:0;opacity:0;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,margin-top}.modal .modal-dialog .modal-header{display:flex;flex-direction:row;justify-content:space-between;align-items:center;gap:15px}.modal .modal-dialog .modal-header .modal-title{padding:15px 18px 0;color:#c0caf5;text-transform:uppercase;letter-spacing:.04em}.modal .modal-dialog .modal-header .modal-close{flex:0 0 auto;color:#c0caf5;border-color:#c0caf53d;background:#16161e}.modal .modal-dialog .modal-panel{min-height:200px;display:flex;flex-direction:column;gap:15px;overflow:hidden;background:#16161e;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px}.modal .modal-dialog .modal-body{max-height:700px;overflow-y:auto;padding:18px}.modal .modal-dialog .modal-footer{padding:18px}.modal .modal-dialog .modal-footer .actions{display:flex;flex-direction:row;justify-content:flex-end;gap:15px;width:100%}.modal.a-show .modal-backdrop{opacity:1}.modal.a-show .modal-dialog{opacity:1;margin-top:0}.modal.a-hide .modal-backdrop{opacity:0}.modal.a-hide .modal-dialog{opacity:0;margin-top:-200px}.alert{position:relative;overflow:hidden;border-radius:6px;margin-bottom:12px;padding:12px 15px;border:2px solid transparent;border-left-style:solid;border-left-width:6px;background:#1f2335;color:#c0caf5;font-weight:500;line-height:1.4;transition-duration:.2s;transition-timing-function:ease;transition-property:background,color,border-color}.alert:after{content:"";position:absolute;inset:0 auto 0 0;width:36%;background:linear-gradient(90deg,transparent,rgba(192,202,245,.12),transparent);opacity:0;pointer-events:none;transform:translate(-120%)}@media(hover:hover)and (pointer:fine){.alert:hover:after{opacity:1;animation:terminal_scan_x .8s ease}}@media(hover:none)and (pointer:coarse){.alert:active:after{opacity:1;animation:terminal_scan_x .8s ease}}.alert.alert-primary{border-color:#c0caf5;background:#c0caf51a;color:#c0caf5}.alert.alert-success{border-color:#9ece6a;background:#9ece6a1a;color:#9ece6a}.alert.alert-secondary{border-color:#7aa2f7;background:#7aa2f71a;color:#7aa2f7}.alert.alert-info{border-color:#bb9af7;background:#bb9af71a;color:#c0caf5}.alert.alert-warning{border-color:#e0af68;background:#e0af681a;color:#e0af68}.alert.alert-danger,.alert.alert-error{border-color:#f7768e;background:#f7768e1a;color:#f7768e}.advanced-select-container{position:relative;height:0}.advanced-select{position:absolute;z-index:100;top:6px;width:100%;height:auto;max-height:200px;overflow-y:auto;background:#16161e;border:2px solid #c0caf5;border-left-width:6px;border-radius:6px;margin-top:20px;opacity:0;visibility:hidden;transition-property:opacity,margin-top,visibility;transition-duration:.2s;transition-timing-function:ease}.advanced-select.a-show{opacity:1;margin-top:0;visibility:visible}.advanced-select .popup-options-container .not-found{width:100%;padding:15px;text-align:center;display:none}.advanced-select .popup-options-container .not-found.show{display:block}.advanced-select .popup-options-container .options{width:100%;display:none}.advanced-select .popup-options-container .options.show{display:block}.advanced-select .popup-options-container .options .option{padding:8px 15px;transition-property:color,background;transition-duration:.15s}.advanced-select .popup-options-container .options .option.hide{display:none}.advanced-select .popup-options-container .options .option.focus,.advanced-select .popup-options-container .options .option:hover{color:#16161e;background:#e0af68}.component.editable-string-component .editable-string-content{display:flex;flex-direction:row;align-items:center;gap:8px;font-size:inherit}.component.editable-string-component .editable-string-content .editable-string{font-size:inherit;border-bottom:2px solid rgba(192,202,245,.24)}@media(hover:hover)and (pointer:fine){.component.editable-string-component .apply-changes-btn:hover,.component.editable-string-component .cancel-changes-btn:hover,.component.editable-string-component .edit-text-btn:hover{color:#16161e;background:#e0af68}}@media(hover:none)and (pointer:coarse){.component.editable-string-component .apply-changes-btn:active,.component.editable-string-component .cancel-changes-btn:active,.component.editable-string-component .edit-text-btn:active{color:#16161e;background:#e0af68}}.component.editable-string-component .apply-changes-btn{color:#e0af68}.component.editable-string-component .editable-string-form{display:flex;flex-direction:row;align-items:center;gap:8px}.component.editable-string-component .editable-string-form .form-group{max-width:260px;margin:0}.component.editable-string-component .editable-string-form .form-group .input{padding:8px 15px}.tabs{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin-bottom:15px}.tabs .tab{display:inline-flex;align-items:center;min-height:34px;padding:8px 12px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;color:#a9b1d6;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;line-height:1;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.tabs .tab:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.tabs .tab:hover{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.tabs .tab:active{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}.tabs .tab.tab-active,.tabs .tab[aria-selected=true]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.dropdown,.popover{position:relative;display:inline-flex}.dropdown-menu,.popover-panel,.tooltip-panel{z-index:40;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;box-shadow:0 14px 36px #16161e5c}.dropdown-menu,.popover-panel{position:absolute;top:calc(100% + 8px);left:0;min-width:220px;display:none;transform-origin:top left}.dropdown.is-open .dropdown-menu,.popover.is-open .popover-panel{display:block;animation:overlay_reveal .2s ease both}.dropdown-menu{padding:5px}.dropdown-menu .dropdown-item{display:flex;align-items:center;gap:8px;width:100%;min-height:34px;padding:8px 12px;border:0;color:#c0caf5;background:0 0;font-family:IBM Plex Mono,monospace;font-size:13px;text-align:left;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.dropdown-menu .dropdown-item .ph,.dropdown-menu .dropdown-item .ph-bold{font-size:18px}.dropdown-menu .dropdown-item:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.dropdown-menu .dropdown-item:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.dropdown-menu .dropdown-item:active{color:#16161e;background:#7aa2f7}}.dropdown-menu .dropdown-item.dropdown-item-danger{color:#f7768e}@media(hover:hover)and (pointer:fine){.dropdown-menu .dropdown-item.dropdown-item-danger:hover{color:#16161e;background:#f7768e}}@media(hover:none)and (pointer:coarse){.dropdown-menu .dropdown-item.dropdown-item-danger:active{color:#16161e;background:#f7768e}}.popover-panel{width:min(320px,100vw - 22px);padding:15px}.popover-panel .popover-title{margin:0 0 8px;font-size:14px;font-weight:700;text-transform:uppercase}.popover-panel .popover-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.tooltip{position:relative;display:inline-flex}.tooltip-panel{position:absolute;left:50%;bottom:calc(100% + 8px);width:-moz-max-content;width:max-content;max-width:260px;padding:8px 12px;color:#c0caf5;font-size:12px;line-height:1.4;transform:translate(-50%);opacity:0;visibility:hidden;pointer-events:none;transition-duration:.15s;transition-timing-function:ease;transition-property:opacity,visibility}.tooltip.is-open .tooltip-panel,.tooltip:focus-within .tooltip-panel,.tooltip:hover .tooltip-panel{opacity:1;visibility:visible;animation:tooltip_reveal .15s ease both}.m-0{margin:0!important}.mt-0{margin-top:0!important}.mr-0{margin-right:0!important}.mb-0{margin-bottom:0!important}.ml-0{margin-left:0!important}.mx-0{margin-left:0!important;margin-right:0!important}.my-0{margin-top:0!important;margin-bottom:0!important}.p-0{padding:0!important}.pt-0{padding-top:0!important}.pr-0{padding-right:0!important}.pb-0{padding-bottom:0!important}.pl-0{padding-left:0!important}.px-0{padding-left:0!important;padding-right:0!important}.py-0{padding-top:0!important;padding-bottom:0!important}.g-0{gap:0!important}.gx-0{-moz-column-gap:0!important;column-gap:0!important}.gy-0{row-gap:0!important}.m-1{margin:5px!important}.mt-1{margin-top:5px!important}.mr-1{margin-right:5px!important}.mb-1{margin-bottom:5px!important}.ml-1{margin-left:5px!important}.mx-1{margin-left:5px!important;margin-right:5px!important}.my-1{margin-top:5px!important;margin-bottom:5px!important}.p-1{padding:5px!important}.pt-1{padding-top:5px!important}.pr-1{padding-right:5px!important}.pb-1{padding-bottom:5px!important}.pl-1{padding-left:5px!important}.px-1{padding-left:5px!important;padding-right:5px!important}.py-1{padding-top:5px!important;padding-bottom:5px!important}.g-1{gap:5px!important}.gx-1{-moz-column-gap:5px!important;column-gap:5px!important}.gy-1{row-gap:5px!important}.m-2{margin:8px!important}.mt-2{margin-top:8px!important}.mr-2{margin-right:8px!important}.mb-2{margin-bottom:8px!important}.ml-2{margin-left:8px!important}.mx-2{margin-left:8px!important;margin-right:8px!important}.my-2{margin-top:8px!important;margin-bottom:8px!important}.p-2{padding:8px!important}.pt-2{padding-top:8px!important}.pr-2{padding-right:8px!important}.pb-2{padding-bottom:8px!important}.pl-2{padding-left:8px!important}.px-2{padding-left:8px!important;padding-right:8px!important}.py-2{padding-top:8px!important;padding-bottom:8px!important}.g-2{gap:8px!important}.gx-2{-moz-column-gap:8px!important;column-gap:8px!important}.gy-2{row-gap:8px!important}.m-3{margin:12px!important}.mt-3{margin-top:12px!important}.mr-3{margin-right:12px!important}.mb-3{margin-bottom:12px!important}.ml-3{margin-left:12px!important}.mx-3{margin-left:12px!important;margin-right:12px!important}.my-3{margin-top:12px!important;margin-bottom:12px!important}.p-3{padding:12px!important}.pt-3{padding-top:12px!important}.pr-3{padding-right:12px!important}.pb-3{padding-bottom:12px!important}.pl-3{padding-left:12px!important}.px-3{padding-left:12px!important;padding-right:12px!important}.py-3{padding-top:12px!important;padding-bottom:12px!important}.g-3{gap:12px!important}.gx-3{-moz-column-gap:12px!important;column-gap:12px!important}.gy-3{row-gap:12px!important}.m-4{margin:15px!important}.mt-4{margin-top:15px!important}.mr-4{margin-right:15px!important}.mb-4{margin-bottom:15px!important}.ml-4{margin-left:15px!important}.mx-4{margin-left:15px!important;margin-right:15px!important}.my-4{margin-top:15px!important;margin-bottom:15px!important}.p-4{padding:15px!important}.pt-4{padding-top:15px!important}.pr-4{padding-right:15px!important}.pb-4{padding-bottom:15px!important}.pl-4{padding-left:15px!important}.px-4{padding-left:15px!important;padding-right:15px!important}.py-4{padding-top:15px!important;padding-bottom:15px!important}.g-4{gap:15px!important}.gx-4{-moz-column-gap:15px!important;column-gap:15px!important}.gy-4{row-gap:15px!important}.m-5{margin:18px!important}.mt-5{margin-top:18px!important}.mr-5{margin-right:18px!important}.mb-5{margin-bottom:18px!important}.ml-5{margin-left:18px!important}.mx-5{margin-left:18px!important;margin-right:18px!important}.my-5{margin-top:18px!important;margin-bottom:18px!important}.p-5{padding:18px!important}.pt-5{padding-top:18px!important}.pr-5{padding-right:18px!important}.pb-5{padding-bottom:18px!important}.pl-5{padding-left:18px!important}.px-5{padding-left:18px!important;padding-right:18px!important}.py-5{padding-top:18px!important;padding-bottom:18px!important}.g-5{gap:18px!important}.gx-5{-moz-column-gap:18px!important;column-gap:18px!important}.gy-5{row-gap:18px!important}.m-6{margin:22px!important}.mt-6{margin-top:22px!important}.mr-6{margin-right:22px!important}.mb-6{margin-bottom:22px!important}.ml-6{margin-left:22px!important}.mx-6{margin-left:22px!important;margin-right:22px!important}.my-6{margin-top:22px!important;margin-bottom:22px!important}.p-6{padding:22px!important}.pt-6{padding-top:22px!important}.pr-6{padding-right:22px!important}.pb-6{padding-bottom:22px!important}.pl-6{padding-left:22px!important}.px-6{padding-left:22px!important;padding-right:22px!important}.py-6{padding-top:22px!important;padding-bottom:22px!important}.g-6{gap:22px!important}.gx-6{-moz-column-gap:22px!important;column-gap:22px!important}.gy-6{row-gap:22px!important}.m-7{margin:26px!important}.mt-7{margin-top:26px!important}.mr-7{margin-right:26px!important}.mb-7{margin-bottom:26px!important}.ml-7{margin-left:26px!important}.mx-7{margin-left:26px!important;margin-right:26px!important}.my-7{margin-top:26px!important;margin-bottom:26px!important}.p-7{padding:26px!important}.pt-7{padding-top:26px!important}.pr-7{padding-right:26px!important}.pb-7{padding-bottom:26px!important}.pl-7{padding-left:26px!important}.px-7{padding-left:26px!important;padding-right:26px!important}.py-7{padding-top:26px!important;padding-bottom:26px!important}.g-7{gap:26px!important}.gx-7{-moz-column-gap:26px!important;column-gap:26px!important}.gy-7{row-gap:26px!important}.m-8{margin:34px!important}.mt-8{margin-top:34px!important}.mr-8{margin-right:34px!important}.mb-8{margin-bottom:34px!important}.ml-8{margin-left:34px!important}.mx-8{margin-left:34px!important;margin-right:34px!important}.my-8{margin-top:34px!important;margin-bottom:34px!important}.p-8{padding:34px!important}.pt-8{padding-top:34px!important}.pr-8{padding-right:34px!important}.pb-8{padding-bottom:34px!important}.pl-8{padding-left:34px!important}.px-8{padding-left:34px!important;padding-right:34px!important}.py-8{padding-top:34px!important;padding-bottom:34px!important}.g-8{gap:34px!important}.gx-8{-moz-column-gap:34px!important;column-gap:34px!important}.gy-8{row-gap:34px!important}.m-9{margin:42px!important}.mt-9{margin-top:42px!important}.mr-9{margin-right:42px!important}.mb-9{margin-bottom:42px!important}.ml-9{margin-left:42px!important}.mx-9{margin-left:42px!important;margin-right:42px!important}.my-9{margin-top:42px!important;margin-bottom:42px!important}.p-9{padding:42px!important}.pt-9{padding-top:42px!important}.pr-9{padding-right:42px!important}.pb-9{padding-bottom:42px!important}.pl-9{padding-left:42px!important}.px-9{padding-left:42px!important;padding-right:42px!important}.py-9{padding-top:42px!important;padding-bottom:42px!important}.g-9{gap:42px!important}.gx-9{-moz-column-gap:42px!important;column-gap:42px!important}.gy-9{row-gap:42px!important}.m-10{margin:48px!important}.mt-10{margin-top:48px!important}.mr-10{margin-right:48px!important}.mb-10{margin-bottom:48px!important}.ml-10{margin-left:48px!important}.mx-10{margin-left:48px!important;margin-right:48px!important}.my-10{margin-top:48px!important;margin-bottom:48px!important}.p-10{padding:48px!important}.pt-10{padding-top:48px!important}.pr-10{padding-right:48px!important}.pb-10{padding-bottom:48px!important}.pl-10{padding-left:48px!important}.px-10{padding-left:48px!important;padding-right:48px!important}.py-10{padding-top:48px!important;padding-bottom:48px!important}.g-10{gap:48px!important}.gx-10{-moz-column-gap:48px!important;column-gap:48px!important}.gy-10{row-gap:48px!important}.m-11{margin:64px!important}.mt-11{margin-top:64px!important}.mr-11{margin-right:64px!important}.mb-11{margin-bottom:64px!important}.ml-11{margin-left:64px!important}.mx-11{margin-left:64px!important;margin-right:64px!important}.my-11{margin-top:64px!important;margin-bottom:64px!important}.p-11{padding:64px!important}.pt-11{padding-top:64px!important}.pr-11{padding-right:64px!important}.pb-11{padding-bottom:64px!important}.pl-11{padding-left:64px!important}.px-11{padding-left:64px!important;padding-right:64px!important}.py-11{padding-top:64px!important;padding-bottom:64px!important}.g-11{gap:64px!important}.gx-11{-moz-column-gap:64px!important;column-gap:64px!important}.gy-11{row-gap:64px!important}.m-12{margin:80px!important}.mt-12{margin-top:80px!important}.mr-12{margin-right:80px!important}.mb-12{margin-bottom:80px!important}.ml-12{margin-left:80px!important}.mx-12{margin-left:80px!important;margin-right:80px!important}.my-12{margin-top:80px!important;margin-bottom:80px!important}.p-12{padding:80px!important}.pt-12{padding-top:80px!important}.pr-12{padding-right:80px!important}.pb-12{padding-bottom:80px!important}.pl-12{padding-left:80px!important}.px-12{padding-left:80px!important;padding-right:80px!important}.py-12{padding-top:80px!important;padding-bottom:80px!important}.g-12{gap:80px!important}.gx-12{-moz-column-gap:80px!important;column-gap:80px!important}.gy-12{row-gap:80px!important}.row{display:flex;flex-direction:row}@media(max-width:1279px){.row.adaptive{flex-direction:column}}.column{display:flex;flex-direction:column}.f-grid{display:flex;flex-direction:row;flex-wrap:wrap}.grid{display:grid}.grid-2{display:grid;grid-template-columns:repeat(2,minmax(0,1fr))}.grid-3{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))}.items-start{align-items:flex-start!important}.items-center{align-items:center!important}.items-end{align-items:flex-end!important}.justify-start{justify-content:flex-start!important}.justify-center{justify-content:center!important}.justify-between{justify-content:space-between!important}.justify-end{justify-content:flex-end!important}.w-100{width:100%}.w-auto{width:auto!important}.w-fit{width:-moz-fit-content!important;width:fit-content!important}.w-200{width:200%}.h-100{height:100%}.min-w-0{min-width:0!important}.overflow-hidden{overflow:hidden!important}.overflow-auto{overflow:auto!important}.fs-xs{font-size:12px}.fs-sm{font-size:13px}.fs-md,.fs-base{font-size:14px}.fs-lg{font-size:15px}.fs-xl{font-size:18px}.text-left{text-align:left!important}.text-center{text-align:center!important}.text-right{text-align:right!important}.text-uppercase{text-transform:uppercase!important}.text-nowrap{white-space:nowrap!important}.d-none{display:none!important}.d-block{display:block!important}.d-inline-flex{display:inline-flex!important}.d-flex{display:flex!important}.d-grid{display:grid!important}@media(max-width:767px){.grid-2,.grid-3{grid-template-columns:1fr}}*{box-sizing:border-box}body,html{padding:0;margin:0}body{background-color:#16161e;color:#c0caf5}::-webkit-scrollbar{width:10px}::-webkit-scrollbar-track{width:10px;background:#16161e;cursor:pointer}::-webkit-scrollbar-thumb{width:10px;background:#414868;cursor:default}::-webkit-scrollbar-corner{background:0 0;height:1px}::-webkit-scrollbar-button{display:none}.ph.normalize{position:relative;top:.15em}@font-face{font-family:Phosphor;src:url(/assets/Phosphor-DtdjzkpE.woff2) format("woff2"),url(/assets/Phosphor-BdqudwT5.woff) format("woff"),url(/assets/Phosphor-CDxgqcPu.ttf) format("truetype"),url(/assets/Phosphor-BXRFlF4V.svg#Phosphor) format("svg");font-weight:400;font-style:normal;font-display:block}.ph{font-family:Phosphor!important;speak:never;font-style:normal;font-weight:400;font-variant:normal;text-transform:none;line-height:1;letter-spacing:0;-webkit-font-feature-settings:"liga";-moz-font-feature-settings:"liga=1";-moz-font-feature-settings:"liga";-ms-font-feature-settings:"liga" 1;font-feature-settings:"liga";-webkit-font-variant-ligatures:discretionary-ligatures;font-variant-ligatures:discretionary-ligatures;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.ph.ph-acorn:before{content:""}.ph.ph-address-book:before{content:""}.ph.ph-address-book-tabs:before{content:""}.ph.ph-air-traffic-control:before{content:""}.ph.ph-airplane:before{content:""}.ph.ph-airplane-in-flight:before{content:""}.ph.ph-airplane-landing:before{content:""}.ph.ph-airplane-takeoff:before{content:""}.ph.ph-airplane-taxiing:before{content:""}.ph.ph-airplane-tilt:before{content:""}.ph.ph-airplay:before{content:""}.ph.ph-alarm:before{content:""}.ph.ph-alien:before{content:""}.ph.ph-align-bottom:before{content:""}.ph.ph-align-bottom-simple:before{content:""}.ph.ph-align-center-horizontal:before{content:""}.ph.ph-align-center-horizontal-simple:before{content:""}.ph.ph-align-center-vertical:before{content:""}.ph.ph-align-center-vertical-simple:before{content:""}.ph.ph-align-left:before{content:""}.ph.ph-align-left-simple:before{content:""}.ph.ph-align-right:before{content:""}.ph.ph-align-right-simple:before{content:""}.ph.ph-align-top:before{content:""}.ph.ph-align-top-simple:before{content:""}.ph.ph-amazon-logo:before{content:""}.ph.ph-ambulance:before{content:""}.ph.ph-anchor:before{content:""}.ph.ph-anchor-simple:before{content:""}.ph.ph-android-logo:before{content:""}.ph.ph-angle:before{content:""}.ph.ph-angular-logo:before{content:""}.ph.ph-aperture:before{content:""}.ph.ph-app-store-logo:before{content:""}.ph.ph-app-window:before{content:""}.ph.ph-apple-logo:before{content:""}.ph.ph-apple-podcasts-logo:before{content:""}.ph.ph-approximate-equals:before{content:""}.ph.ph-archive:before{content:""}.ph.ph-armchair:before{content:""}.ph.ph-arrow-arc-left:before{content:""}.ph.ph-arrow-arc-right:before{content:""}.ph.ph-arrow-bend-double-up-left:before{content:""}.ph.ph-arrow-bend-double-up-right:before{content:""}.ph.ph-arrow-bend-down-left:before{content:""}.ph.ph-arrow-bend-down-right:before{content:""}.ph.ph-arrow-bend-left-down:before{content:""}.ph.ph-arrow-bend-left-up:before{content:""}.ph.ph-arrow-bend-right-down:before{content:""}.ph.ph-arrow-bend-right-up:before{content:""}.ph.ph-arrow-bend-up-left:before{content:""}.ph.ph-arrow-bend-up-right:before{content:""}.ph.ph-arrow-circle-down:before{content:""}.ph.ph-arrow-circle-down-left:before{content:""}.ph.ph-arrow-circle-down-right:before{content:""}.ph.ph-arrow-circle-left:before{content:""}.ph.ph-arrow-circle-right:before{content:""}.ph.ph-arrow-circle-up:before{content:""}.ph.ph-arrow-circle-up-left:before{content:""}.ph.ph-arrow-circle-up-right:before{content:""}.ph.ph-arrow-clockwise:before{content:""}.ph.ph-arrow-counter-clockwise:before{content:""}.ph.ph-arrow-down:before{content:""}.ph.ph-arrow-down-left:before{content:""}.ph.ph-arrow-down-right:before{content:""}.ph.ph-arrow-elbow-down-left:before{content:""}.ph.ph-arrow-elbow-down-right:before{content:""}.ph.ph-arrow-elbow-left:before{content:""}.ph.ph-arrow-elbow-left-down:before{content:""}.ph.ph-arrow-elbow-left-up:before{content:""}.ph.ph-arrow-elbow-right:before{content:""}.ph.ph-arrow-elbow-right-down:before{content:""}.ph.ph-arrow-elbow-right-up:before{content:""}.ph.ph-arrow-elbow-up-left:before{content:""}.ph.ph-arrow-elbow-up-right:before{content:""}.ph.ph-arrow-fat-down:before{content:""}.ph.ph-arrow-fat-left:before{content:""}.ph.ph-arrow-fat-line-down:before{content:""}.ph.ph-arrow-fat-line-left:before{content:""}.ph.ph-arrow-fat-line-right:before{content:""}.ph.ph-arrow-fat-line-up:before{content:""}.ph.ph-arrow-fat-lines-down:before{content:""}.ph.ph-arrow-fat-lines-left:before{content:""}.ph.ph-arrow-fat-lines-right:before{content:""}.ph.ph-arrow-fat-lines-up:before{content:""}.ph.ph-arrow-fat-right:before{content:""}.ph.ph-arrow-fat-up:before{content:""}.ph.ph-arrow-left:before{content:""}.ph.ph-arrow-line-down:before{content:""}.ph.ph-arrow-line-down-left:before{content:""}.ph.ph-arrow-line-down-right:before{content:""}.ph.ph-arrow-line-left:before{content:""}.ph.ph-arrow-line-right:before{content:""}.ph.ph-arrow-line-up:before{content:""}.ph.ph-arrow-line-up-left:before{content:""}.ph.ph-arrow-line-up-right:before{content:""}.ph.ph-arrow-right:before{content:""}.ph.ph-arrow-square-down:before{content:""}.ph.ph-arrow-square-down-left:before{content:""}.ph.ph-arrow-square-down-right:before{content:""}.ph.ph-arrow-square-in:before{content:""}.ph.ph-arrow-square-left:before{content:""}.ph.ph-arrow-square-out:before{content:""}.ph.ph-arrow-square-right:before{content:""}.ph.ph-arrow-square-up:before{content:""}.ph.ph-arrow-square-up-left:before{content:""}.ph.ph-arrow-square-up-right:before{content:""}.ph.ph-arrow-u-down-left:before{content:""}.ph.ph-arrow-u-down-right:before{content:""}.ph.ph-arrow-u-left-down:before{content:""}.ph.ph-arrow-u-left-up:before{content:""}.ph.ph-arrow-u-right-down:before{content:""}.ph.ph-arrow-u-right-up:before{content:""}.ph.ph-arrow-u-up-left:before{content:""}.ph.ph-arrow-u-up-right:before{content:""}.ph.ph-arrow-up:before{content:""}.ph.ph-arrow-up-left:before{content:""}.ph.ph-arrow-up-right:before{content:""}.ph.ph-arrows-clockwise:before{content:""}.ph.ph-arrows-counter-clockwise:before{content:""}.ph.ph-arrows-down-up:before{content:""}.ph.ph-arrows-horizontal:before{content:""}.ph.ph-arrows-in:before{content:""}.ph.ph-arrows-in-cardinal:before{content:""}.ph.ph-arrows-in-line-horizontal:before{content:""}.ph.ph-arrows-in-line-vertical:before{content:""}.ph.ph-arrows-in-simple:before{content:""}.ph.ph-arrows-left-right:before{content:""}.ph.ph-arrows-merge:before{content:""}.ph.ph-arrows-out:before{content:""}.ph.ph-arrows-out-cardinal:before{content:""}.ph.ph-arrows-out-line-horizontal:before{content:""}.ph.ph-arrows-out-line-vertical:before{content:""}.ph.ph-arrows-out-simple:before{content:""}.ph.ph-arrows-split:before{content:""}.ph.ph-arrows-vertical:before{content:""}.ph.ph-article:before{content:""}.ph.ph-article-medium:before{content:""}.ph.ph-article-ny-times:before{content:""}.ph.ph-asclepius:before{content:""}.ph.ph-caduceus:before{content:""}.ph.ph-asterisk:before{content:""}.ph.ph-asterisk-simple:before{content:""}.ph.ph-at:before{content:""}.ph.ph-atom:before{content:""}.ph.ph-avocado:before{content:""}.ph.ph-axe:before{content:""}.ph.ph-baby:before{content:""}.ph.ph-baby-carriage:before{content:""}.ph.ph-backpack:before{content:""}.ph.ph-backspace:before{content:""}.ph.ph-bag:before{content:""}.ph.ph-bag-simple:before{content:""}.ph.ph-balloon:before{content:""}.ph.ph-bandaids:before{content:""}.ph.ph-bank:before{content:""}.ph.ph-barbell:before{content:""}.ph.ph-barcode:before{content:""}.ph.ph-barn:before{content:""}.ph.ph-barricade:before{content:""}.ph.ph-baseball:before{content:""}.ph.ph-baseball-cap:before{content:""}.ph.ph-baseball-helmet:before{content:""}.ph.ph-basket:before{content:""}.ph.ph-basketball:before{content:""}.ph.ph-bathtub:before{content:""}.ph.ph-battery-charging:before{content:""}.ph.ph-battery-charging-vertical:before{content:""}.ph.ph-battery-empty:before{content:""}.ph.ph-battery-full:before{content:""}.ph.ph-battery-high:before{content:""}.ph.ph-battery-low:before{content:""}.ph.ph-battery-medium:before{content:""}.ph.ph-battery-plus:before{content:""}.ph.ph-battery-plus-vertical:before{content:""}.ph.ph-battery-vertical-empty:before{content:""}.ph.ph-battery-vertical-full:before{content:""}.ph.ph-battery-vertical-high:before{content:""}.ph.ph-battery-vertical-low:before{content:""}.ph.ph-battery-vertical-medium:before{content:""}.ph.ph-battery-warning:before{content:""}.ph.ph-battery-warning-vertical:before{content:""}.ph.ph-beach-ball:before{content:""}.ph.ph-beanie:before{content:""}.ph.ph-bed:before{content:""}.ph.ph-beer-bottle:before{content:""}.ph.ph-beer-stein:before{content:""}.ph.ph-behance-logo:before{content:""}.ph.ph-bell:before{content:""}.ph.ph-bell-ringing:before{content:""}.ph.ph-bell-simple:before{content:""}.ph.ph-bell-simple-ringing:before{content:""}.ph.ph-bell-simple-slash:before{content:""}.ph.ph-bell-simple-z:before{content:""}.ph.ph-bell-slash:before{content:""}.ph.ph-bell-z:before{content:""}.ph.ph-belt:before{content:""}.ph.ph-bezier-curve:before{content:""}.ph.ph-bicycle:before{content:""}.ph.ph-binary:before{content:""}.ph.ph-binoculars:before{content:""}.ph.ph-biohazard:before{content:""}.ph.ph-bird:before{content:""}.ph.ph-blueprint:before{content:""}.ph.ph-bluetooth:before{content:""}.ph.ph-bluetooth-connected:before{content:""}.ph.ph-bluetooth-slash:before{content:""}.ph.ph-bluetooth-x:before{content:""}.ph.ph-boat:before{content:""}.ph.ph-bomb:before{content:""}.ph.ph-bone:before{content:""}.ph.ph-book:before{content:""}.ph.ph-book-bookmark:before{content:""}.ph.ph-book-open:before{content:""}.ph.ph-book-open-text:before{content:""}.ph.ph-book-open-user:before{content:""}.ph.ph-bookmark:before{content:""}.ph.ph-bookmark-simple:before{content:""}.ph.ph-bookmarks:before{content:""}.ph.ph-bookmarks-simple:before{content:""}.ph.ph-books:before{content:""}.ph.ph-boot:before{content:""}.ph.ph-boules:before{content:""}.ph.ph-bounding-box:before{content:""}.ph.ph-bowl-food:before{content:""}.ph.ph-bowl-steam:before{content:""}.ph.ph-bowling-ball:before{content:""}.ph.ph-box-arrow-down:before{content:""}.ph.ph-archive-box:before{content:""}.ph.ph-box-arrow-up:before{content:""}.ph.ph-boxing-glove:before{content:""}.ph.ph-brackets-angle:before{content:""}.ph.ph-brackets-curly:before{content:""}.ph.ph-brackets-round:before{content:""}.ph.ph-brackets-square:before{content:""}.ph.ph-brain:before{content:""}.ph.ph-brandy:before{content:""}.ph.ph-bread:before{content:""}.ph.ph-bridge:before{content:""}.ph.ph-briefcase:before{content:""}.ph.ph-briefcase-metal:before{content:""}.ph.ph-broadcast:before{content:""}.ph.ph-broom:before{content:""}.ph.ph-browser:before{content:""}.ph.ph-browsers:before{content:""}.ph.ph-bug:before{content:""}.ph.ph-bug-beetle:before{content:""}.ph.ph-bug-droid:before{content:""}.ph.ph-building:before{content:""}.ph.ph-building-apartment:before{content:""}.ph.ph-building-office:before{content:""}.ph.ph-buildings:before{content:""}.ph.ph-bulldozer:before{content:""}.ph.ph-bus:before{content:""}.ph.ph-butterfly:before{content:""}.ph.ph-cable-car:before{content:""}.ph.ph-cactus:before{content:""}.ph.ph-cake:before{content:""}.ph.ph-calculator:before{content:""}.ph.ph-calendar:before{content:""}.ph.ph-calendar-blank:before{content:""}.ph.ph-calendar-check:before{content:""}.ph.ph-calendar-dot:before{content:""}.ph.ph-calendar-dots:before{content:""}.ph.ph-calendar-heart:before{content:""}.ph.ph-calendar-minus:before{content:""}.ph.ph-calendar-plus:before{content:""}.ph.ph-calendar-slash:before{content:""}.ph.ph-calendar-star:before{content:""}.ph.ph-calendar-x:before{content:""}.ph.ph-call-bell:before{content:""}.ph.ph-camera:before{content:""}.ph.ph-camera-plus:before{content:""}.ph.ph-camera-rotate:before{content:""}.ph.ph-camera-slash:before{content:""}.ph.ph-campfire:before{content:""}.ph.ph-car:before{content:""}.ph.ph-car-battery:before{content:""}.ph.ph-car-profile:before{content:""}.ph.ph-car-simple:before{content:""}.ph.ph-cardholder:before{content:""}.ph.ph-cards:before{content:""}.ph.ph-cards-three:before{content:""}.ph.ph-caret-circle-double-down:before{content:""}.ph.ph-caret-circle-double-left:before{content:""}.ph.ph-caret-circle-double-right:before{content:""}.ph.ph-caret-circle-double-up:before{content:""}.ph.ph-caret-circle-down:before{content:""}.ph.ph-caret-circle-left:before{content:""}.ph.ph-caret-circle-right:before{content:""}.ph.ph-caret-circle-up:before{content:""}.ph.ph-caret-circle-up-down:before{content:""}.ph.ph-caret-double-down:before{content:""}.ph.ph-caret-double-left:before{content:""}.ph.ph-caret-double-right:before{content:""}.ph.ph-caret-double-up:before{content:""}.ph.ph-caret-down:before{content:""}.ph.ph-caret-left:before{content:""}.ph.ph-caret-line-down:before{content:""}.ph.ph-caret-line-left:before{content:""}.ph.ph-caret-line-right:before{content:""}.ph.ph-caret-line-up:before{content:""}.ph.ph-caret-right:before{content:""}.ph.ph-caret-up:before{content:""}.ph.ph-caret-up-down:before{content:""}.ph.ph-carrot:before{content:""}.ph.ph-cash-register:before{content:""}.ph.ph-cassette-tape:before{content:""}.ph.ph-castle-turret:before{content:""}.ph.ph-cat:before{content:""}.ph.ph-cell-signal-full:before{content:""}.ph.ph-cell-signal-high:before{content:""}.ph.ph-cell-signal-low:before{content:""}.ph.ph-cell-signal-medium:before{content:""}.ph.ph-cell-signal-none:before{content:""}.ph.ph-cell-signal-slash:before{content:""}.ph.ph-cell-signal-x:before{content:""}.ph.ph-cell-tower:before{content:""}.ph.ph-certificate:before{content:""}.ph.ph-chair:before{content:""}.ph.ph-chalkboard:before{content:""}.ph.ph-chalkboard-simple:before{content:""}.ph.ph-chalkboard-teacher:before{content:""}.ph.ph-champagne:before{content:""}.ph.ph-charging-station:before{content:""}.ph.ph-chart-bar:before{content:""}.ph.ph-chart-bar-horizontal:before{content:""}.ph.ph-chart-donut:before{content:""}.ph.ph-chart-line:before{content:""}.ph.ph-chart-line-down:before{content:""}.ph.ph-chart-line-up:before{content:""}.ph.ph-chart-pie:before{content:""}.ph.ph-chart-pie-slice:before{content:""}.ph.ph-chart-polar:before{content:""}.ph.ph-chart-scatter:before{content:""}.ph.ph-chat:before{content:""}.ph.ph-chat-centered:before{content:""}.ph.ph-chat-centered-dots:before{content:""}.ph.ph-chat-centered-slash:before{content:""}.ph.ph-chat-centered-text:before{content:""}.ph.ph-chat-circle:before{content:""}.ph.ph-chat-circle-dots:before{content:""}.ph.ph-chat-circle-slash:before{content:""}.ph.ph-chat-circle-text:before{content:""}.ph.ph-chat-dots:before{content:""}.ph.ph-chat-slash:before{content:""}.ph.ph-chat-teardrop:before{content:""}.ph.ph-chat-teardrop-dots:before{content:""}.ph.ph-chat-teardrop-slash:before{content:""}.ph.ph-chat-teardrop-text:before{content:""}.ph.ph-chat-text:before{content:""}.ph.ph-chats:before{content:""}.ph.ph-chats-circle:before{content:""}.ph.ph-chats-teardrop:before{content:""}.ph.ph-check:before{content:""}.ph.ph-check-circle:before{content:""}.ph.ph-check-fat:before{content:""}.ph.ph-check-square:before{content:""}.ph.ph-check-square-offset:before{content:""}.ph.ph-checkerboard:before{content:""}.ph.ph-checks:before{content:""}.ph.ph-cheers:before{content:""}.ph.ph-cheese:before{content:""}.ph.ph-chef-hat:before{content:""}.ph.ph-cherries:before{content:""}.ph.ph-church:before{content:""}.ph.ph-cigarette:before{content:""}.ph.ph-cigarette-slash:before{content:""}.ph.ph-circle:before{content:""}.ph.ph-circle-dashed:before{content:""}.ph.ph-circle-half:before{content:""}.ph.ph-circle-half-tilt:before{content:""}.ph.ph-circle-notch:before{content:""}.ph.ph-circles-four:before{content:""}.ph.ph-circles-three:before{content:""}.ph.ph-circles-three-plus:before{content:""}.ph.ph-circuitry:before{content:""}.ph.ph-city:before{content:""}.ph.ph-clipboard:before{content:""}.ph.ph-clipboard-text:before{content:""}.ph.ph-clock:before{content:""}.ph.ph-clock-afternoon:before{content:""}.ph.ph-clock-clockwise:before{content:""}.ph.ph-clock-countdown:before{content:""}.ph.ph-clock-counter-clockwise:before{content:""}.ph.ph-clock-user:before{content:""}.ph.ph-closed-captioning:before{content:""}.ph.ph-cloud:before{content:""}.ph.ph-cloud-arrow-down:before{content:""}.ph.ph-cloud-arrow-up:before{content:""}.ph.ph-cloud-check:before{content:""}.ph.ph-cloud-fog:before{content:""}.ph.ph-cloud-lightning:before{content:""}.ph.ph-cloud-moon:before{content:""}.ph.ph-cloud-rain:before{content:""}.ph.ph-cloud-slash:before{content:""}.ph.ph-cloud-snow:before{content:""}.ph.ph-cloud-sun:before{content:""}.ph.ph-cloud-warning:before{content:""}.ph.ph-cloud-x:before{content:""}.ph.ph-clover:before{content:""}.ph.ph-club:before{content:""}.ph.ph-coat-hanger:before{content:""}.ph.ph-coda-logo:before{content:""}.ph.ph-code:before{content:""}.ph.ph-code-block:before{content:""}.ph.ph-code-simple:before{content:""}.ph.ph-codepen-logo:before{content:""}.ph.ph-codesandbox-logo:before{content:""}.ph.ph-coffee:before{content:""}.ph.ph-coffee-bean:before{content:""}.ph.ph-coin:before{content:""}.ph.ph-coin-vertical:before{content:""}.ph.ph-coins:before{content:""}.ph.ph-columns:before{content:""}.ph.ph-columns-plus-left:before{content:""}.ph.ph-columns-plus-right:before{content:""}.ph.ph-command:before{content:""}.ph.ph-compass:before{content:""}.ph.ph-compass-rose:before{content:""}.ph.ph-compass-tool:before{content:""}.ph.ph-computer-tower:before{content:""}.ph.ph-confetti:before{content:""}.ph.ph-contactless-payment:before{content:""}.ph.ph-control:before{content:""}.ph.ph-cookie:before{content:""}.ph.ph-cooking-pot:before{content:""}.ph.ph-copy:before{content:""}.ph.ph-copy-simple:before{content:""}.ph.ph-copyleft:before{content:""}.ph.ph-copyright:before{content:""}.ph.ph-corners-in:before{content:""}.ph.ph-corners-out:before{content:""}.ph.ph-couch:before{content:""}.ph.ph-court-basketball:before{content:""}.ph.ph-cow:before{content:""}.ph.ph-cowboy-hat:before{content:""}.ph.ph-cpu:before{content:""}.ph.ph-crane:before{content:""}.ph.ph-crane-tower:before{content:""}.ph.ph-credit-card:before{content:""}.ph.ph-cricket:before{content:""}.ph.ph-crop:before{content:""}.ph.ph-cross:before{content:""}.ph.ph-crosshair:before{content:""}.ph.ph-crosshair-simple:before{content:""}.ph.ph-crown:before{content:""}.ph.ph-crown-cross:before{content:""}.ph.ph-crown-simple:before{content:""}.ph.ph-cube:before{content:""}.ph.ph-cube-focus:before{content:""}.ph.ph-cube-transparent:before{content:""}.ph.ph-currency-btc:before{content:""}.ph.ph-currency-circle-dollar:before{content:""}.ph.ph-currency-cny:before{content:""}.ph.ph-currency-dollar:before{content:""}.ph.ph-currency-dollar-simple:before{content:""}.ph.ph-currency-eth:before{content:""}.ph.ph-currency-eur:before{content:""}.ph.ph-currency-gbp:before{content:""}.ph.ph-currency-inr:before{content:""}.ph.ph-currency-jpy:before{content:""}.ph.ph-currency-krw:before{content:""}.ph.ph-currency-kzt:before{content:""}.ph.ph-currency-ngn:before{content:""}.ph.ph-currency-rub:before{content:""}.ph.ph-cursor:before{content:""}.ph.ph-cursor-click:before{content:""}.ph.ph-cursor-text:before{content:""}.ph.ph-cylinder:before{content:""}.ph.ph-database:before{content:""}.ph.ph-desk:before{content:""}.ph.ph-desktop:before{content:""}.ph.ph-desktop-tower:before{content:""}.ph.ph-detective:before{content:""}.ph.ph-dev-to-logo:before{content:""}.ph.ph-device-mobile:before{content:""}.ph.ph-device-mobile-camera:before{content:""}.ph.ph-device-mobile-slash:before{content:""}.ph.ph-device-mobile-speaker:before{content:""}.ph.ph-device-rotate:before{content:""}.ph.ph-device-tablet:before{content:""}.ph.ph-device-tablet-camera:before{content:""}.ph.ph-device-tablet-speaker:before{content:""}.ph.ph-devices:before{content:""}.ph.ph-diamond:before{content:""}.ph.ph-diamonds-four:before{content:""}.ph.ph-dice-five:before{content:""}.ph.ph-dice-four:before{content:""}.ph.ph-dice-one:before{content:""}.ph.ph-dice-six:before{content:""}.ph.ph-dice-three:before{content:""}.ph.ph-dice-two:before{content:""}.ph.ph-disc:before{content:""}.ph.ph-disco-ball:before{content:""}.ph.ph-discord-logo:before{content:""}.ph.ph-divide:before{content:""}.ph.ph-dna:before{content:""}.ph.ph-dog:before{content:""}.ph.ph-door:before{content:""}.ph.ph-door-open:before{content:""}.ph.ph-dot:before{content:""}.ph.ph-dot-outline:before{content:""}.ph.ph-dots-nine:before{content:""}.ph.ph-dots-six:before{content:""}.ph.ph-dots-six-vertical:before{content:""}.ph.ph-dots-three:before{content:""}.ph.ph-dots-three-circle:before{content:""}.ph.ph-dots-three-circle-vertical:before{content:""}.ph.ph-dots-three-outline:before{content:""}.ph.ph-dots-three-outline-vertical:before{content:""}.ph.ph-dots-three-vertical:before{content:""}.ph.ph-download:before{content:""}.ph.ph-download-simple:before{content:""}.ph.ph-dress:before{content:""}.ph.ph-dresser:before{content:""}.ph.ph-dribbble-logo:before{content:""}.ph.ph-drone:before{content:""}.ph.ph-drop:before{content:""}.ph.ph-drop-half:before{content:""}.ph.ph-drop-half-bottom:before{content:""}.ph.ph-drop-simple:before{content:""}.ph.ph-drop-slash:before{content:""}.ph.ph-dropbox-logo:before{content:""}.ph.ph-ear:before{content:""}.ph.ph-ear-slash:before{content:""}.ph.ph-egg:before{content:""}.ph.ph-egg-crack:before{content:""}.ph.ph-eject:before{content:""}.ph.ph-eject-simple:before{content:""}.ph.ph-elevator:before{content:""}.ph.ph-empty:before{content:""}.ph.ph-engine:before{content:""}.ph.ph-envelope:before{content:""}.ph.ph-envelope-open:before{content:""}.ph.ph-envelope-simple:before{content:""}.ph.ph-envelope-simple-open:before{content:""}.ph.ph-equalizer:before{content:""}.ph.ph-equals:before{content:""}.ph.ph-eraser:before{content:""}.ph.ph-escalator-down:before{content:""}.ph.ph-escalator-up:before{content:""}.ph.ph-exam:before{content:""}.ph.ph-exclamation-mark:before{content:""}.ph.ph-exclude:before{content:""}.ph.ph-exclude-square:before{content:""}.ph.ph-export:before{content:""}.ph.ph-eye:before{content:""}.ph.ph-eye-closed:before{content:""}.ph.ph-eye-slash:before{content:""}.ph.ph-eyedropper:before{content:""}.ph.ph-eyedropper-sample:before{content:""}.ph.ph-eyeglasses:before{content:""}.ph.ph-eyes:before{content:""}.ph.ph-face-mask:before{content:""}.ph.ph-facebook-logo:before{content:""}.ph.ph-factory:before{content:""}.ph.ph-faders:before{content:""}.ph.ph-faders-horizontal:before{content:""}.ph.ph-fallout-shelter:before{content:""}.ph.ph-fan:before{content:""}.ph.ph-farm:before{content:""}.ph.ph-fast-forward:before{content:""}.ph.ph-fast-forward-circle:before{content:""}.ph.ph-feather:before{content:""}.ph.ph-fediverse-logo:before{content:""}.ph.ph-figma-logo:before{content:""}.ph.ph-file:before{content:""}.ph.ph-file-archive:before{content:""}.ph.ph-file-arrow-down:before{content:""}.ph.ph-file-arrow-up:before{content:""}.ph.ph-file-audio:before{content:""}.ph.ph-file-c:before{content:""}.ph.ph-file-c-sharp:before{content:""}.ph.ph-file-cloud:before{content:""}.ph.ph-file-code:before{content:""}.ph.ph-file-cpp:before{content:""}.ph.ph-file-css:before{content:""}.ph.ph-file-csv:before{content:""}.ph.ph-file-dashed:before{content:""}.ph.ph-file-dotted:before{content:""}.ph.ph-file-doc:before{content:""}.ph.ph-file-html:before{content:""}.ph.ph-file-image:before{content:""}.ph.ph-file-ini:before{content:""}.ph.ph-file-jpg:before{content:""}.ph.ph-file-js:before{content:""}.ph.ph-file-jsx:before{content:""}.ph.ph-file-lock:before{content:""}.ph.ph-file-magnifying-glass:before{content:""}.ph.ph-file-search:before{content:""}.ph.ph-file-md:before{content:""}.ph.ph-file-minus:before{content:""}.ph.ph-file-pdf:before{content:""}.ph.ph-file-plus:before{content:""}.ph.ph-file-png:before{content:""}.ph.ph-file-ppt:before{content:""}.ph.ph-file-py:before{content:""}.ph.ph-file-rs:before{content:""}.ph.ph-file-sql:before{content:""}.ph.ph-file-svg:before{content:""}.ph.ph-file-text:before{content:""}.ph.ph-file-ts:before{content:""}.ph.ph-file-tsx:before{content:""}.ph.ph-file-txt:before{content:""}.ph.ph-file-video:before{content:""}.ph.ph-file-vue:before{content:""}.ph.ph-file-x:before{content:""}.ph.ph-file-xls:before{content:""}.ph.ph-file-zip:before{content:""}.ph.ph-files:before{content:""}.ph.ph-film-reel:before{content:""}.ph.ph-film-script:before{content:""}.ph.ph-film-slate:before{content:""}.ph.ph-film-strip:before{content:""}.ph.ph-fingerprint:before{content:""}.ph.ph-fingerprint-simple:before{content:""}.ph.ph-finn-the-human:before{content:""}.ph.ph-fire:before{content:""}.ph.ph-fire-extinguisher:before{content:""}.ph.ph-fire-simple:before{content:""}.ph.ph-fire-truck:before{content:""}.ph.ph-first-aid:before{content:""}.ph.ph-first-aid-kit:before{content:""}.ph.ph-fish:before{content:""}.ph.ph-fish-simple:before{content:""}.ph.ph-flag:before{content:""}.ph.ph-flag-banner:before{content:""}.ph.ph-flag-banner-fold:before{content:""}.ph.ph-flag-checkered:before{content:""}.ph.ph-flag-pennant:before{content:""}.ph.ph-flame:before{content:""}.ph.ph-flashlight:before{content:""}.ph.ph-flask:before{content:""}.ph.ph-flip-horizontal:before{content:""}.ph.ph-flip-vertical:before{content:""}.ph.ph-floppy-disk:before{content:""}.ph.ph-floppy-disk-back:before{content:""}.ph.ph-flow-arrow:before{content:""}.ph.ph-flower:before{content:""}.ph.ph-flower-lotus:before{content:""}.ph.ph-flower-tulip:before{content:""}.ph.ph-flying-saucer:before{content:""}.ph.ph-folder:before{content:""}.ph.ph-folder-notch:before{content:""}.ph.ph-folder-dashed:before{content:""}.ph.ph-folder-dotted:before{content:""}.ph.ph-folder-lock:before{content:""}.ph.ph-folder-minus:before{content:""}.ph.ph-folder-notch-minus:before{content:""}.ph.ph-folder-open:before{content:""}.ph.ph-folder-notch-open:before{content:""}.ph.ph-folder-plus:before{content:""}.ph.ph-folder-notch-plus:before{content:""}.ph.ph-folder-simple:before{content:""}.ph.ph-folder-simple-dashed:before{content:""}.ph.ph-folder-simple-dotted:before{content:""}.ph.ph-folder-simple-lock:before{content:""}.ph.ph-folder-simple-minus:before{content:""}.ph.ph-folder-simple-plus:before{content:""}.ph.ph-folder-simple-star:before{content:""}.ph.ph-folder-simple-user:before{content:""}.ph.ph-folder-star:before{content:""}.ph.ph-folder-user:before{content:""}.ph.ph-folders:before{content:""}.ph.ph-football:before{content:""}.ph.ph-football-helmet:before{content:""}.ph.ph-footprints:before{content:""}.ph.ph-fork-knife:before{content:""}.ph.ph-four-k:before{content:""}.ph.ph-frame-corners:before{content:""}.ph.ph-framer-logo:before{content:""}.ph.ph-function:before{content:""}.ph.ph-funnel:before{content:""}.ph.ph-funnel-simple:before{content:""}.ph.ph-funnel-simple-x:before{content:""}.ph.ph-funnel-x:before{content:""}.ph.ph-game-controller:before{content:""}.ph.ph-garage:before{content:""}.ph.ph-gas-can:before{content:""}.ph.ph-gas-pump:before{content:""}.ph.ph-gauge:before{content:""}.ph.ph-gavel:before{content:""}.ph.ph-gear:before{content:""}.ph.ph-gear-fine:before{content:""}.ph.ph-gear-six:before{content:""}.ph.ph-gender-female:before{content:""}.ph.ph-gender-intersex:before{content:""}.ph.ph-gender-male:before{content:""}.ph.ph-gender-neuter:before{content:""}.ph.ph-gender-nonbinary:before{content:""}.ph.ph-gender-transgender:before{content:""}.ph.ph-ghost:before{content:""}.ph.ph-gif:before{content:""}.ph.ph-gift:before{content:""}.ph.ph-git-branch:before{content:""}.ph.ph-git-commit:before{content:""}.ph.ph-git-diff:before{content:""}.ph.ph-git-fork:before{content:""}.ph.ph-git-merge:before{content:""}.ph.ph-git-pull-request:before{content:""}.ph.ph-github-logo:before{content:""}.ph.ph-gitlab-logo:before{content:""}.ph.ph-gitlab-logo-simple:before{content:""}.ph.ph-globe:before{content:""}.ph.ph-globe-hemisphere-east:before{content:""}.ph.ph-globe-hemisphere-west:before{content:""}.ph.ph-globe-simple:before{content:""}.ph.ph-globe-simple-x:before{content:""}.ph.ph-globe-stand:before{content:""}.ph.ph-globe-x:before{content:""}.ph.ph-goggles:before{content:""}.ph.ph-golf:before{content:""}.ph.ph-goodreads-logo:before{content:""}.ph.ph-google-cardboard-logo:before{content:""}.ph.ph-google-chrome-logo:before{content:""}.ph.ph-google-drive-logo:before{content:""}.ph.ph-google-logo:before{content:""}.ph.ph-google-photos-logo:before{content:""}.ph.ph-google-play-logo:before{content:""}.ph.ph-google-podcasts-logo:before{content:""}.ph.ph-gps:before{content:""}.ph.ph-gps-fix:before{content:""}.ph.ph-gps-slash:before{content:""}.ph.ph-gradient:before{content:""}.ph.ph-graduation-cap:before{content:""}.ph.ph-grains:before{content:""}.ph.ph-grains-slash:before{content:""}.ph.ph-graph:before{content:""}.ph.ph-graphics-card:before{content:""}.ph.ph-greater-than:before{content:""}.ph.ph-greater-than-or-equal:before{content:""}.ph.ph-grid-four:before{content:""}.ph.ph-grid-nine:before{content:""}.ph.ph-guitar:before{content:""}.ph.ph-hair-dryer:before{content:""}.ph.ph-hamburger:before{content:""}.ph.ph-hammer:before{content:""}.ph.ph-hand:before{content:""}.ph.ph-hand-arrow-down:before{content:""}.ph.ph-hand-arrow-up:before{content:""}.ph.ph-hand-coins:before{content:""}.ph.ph-hand-deposit:before{content:""}.ph.ph-hand-eye:before{content:""}.ph.ph-hand-fist:before{content:""}.ph.ph-hand-grabbing:before{content:""}.ph.ph-hand-heart:before{content:""}.ph.ph-hand-palm:before{content:""}.ph.ph-hand-peace:before{content:""}.ph.ph-hand-pointing:before{content:""}.ph.ph-hand-soap:before{content:""}.ph.ph-hand-swipe-left:before{content:""}.ph.ph-hand-swipe-right:before{content:""}.ph.ph-hand-tap:before{content:""}.ph.ph-hand-waving:before{content:""}.ph.ph-hand-withdraw:before{content:""}.ph.ph-handbag:before{content:""}.ph.ph-handbag-simple:before{content:""}.ph.ph-hands-clapping:before{content:""}.ph.ph-hands-praying:before{content:""}.ph.ph-handshake:before{content:""}.ph.ph-hard-drive:before{content:""}.ph.ph-hard-drives:before{content:""}.ph.ph-hard-hat:before{content:""}.ph.ph-hash:before{content:""}.ph.ph-hash-straight:before{content:""}.ph.ph-head-circuit:before{content:""}.ph.ph-headlights:before{content:""}.ph.ph-headphones:before{content:""}.ph.ph-headset:before{content:""}.ph.ph-heart:before{content:""}.ph.ph-heart-break:before{content:""}.ph.ph-heart-half:before{content:""}.ph.ph-heart-straight:before{content:""}.ph.ph-heart-straight-break:before{content:""}.ph.ph-heartbeat:before{content:""}.ph.ph-hexagon:before{content:""}.ph.ph-high-definition:before{content:""}.ph.ph-high-heel:before{content:""}.ph.ph-highlighter:before{content:""}.ph.ph-highlighter-circle:before{content:""}.ph.ph-hockey:before{content:""}.ph.ph-hoodie:before{content:""}.ph.ph-horse:before{content:""}.ph.ph-hospital:before{content:""}.ph.ph-hourglass:before{content:""}.ph.ph-hourglass-high:before{content:""}.ph.ph-hourglass-low:before{content:""}.ph.ph-hourglass-medium:before{content:""}.ph.ph-hourglass-simple:before{content:""}.ph.ph-hourglass-simple-high:before{content:""}.ph.ph-hourglass-simple-low:before{content:""}.ph.ph-hourglass-simple-medium:before{content:""}.ph.ph-house:before{content:""}.ph.ph-house-line:before{content:""}.ph.ph-house-simple:before{content:""}.ph.ph-hurricane:before{content:""}.ph.ph-ice-cream:before{content:""}.ph.ph-identification-badge:before{content:""}.ph.ph-identification-card:before{content:""}.ph.ph-image:before{content:""}.ph.ph-image-broken:before{content:""}.ph.ph-image-square:before{content:""}.ph.ph-images:before{content:""}.ph.ph-images-square:before{content:""}.ph.ph-infinity:before{content:""}.ph.ph-lemniscate:before{content:""}.ph.ph-info:before{content:""}.ph.ph-instagram-logo:before{content:""}.ph.ph-intersect:before{content:""}.ph.ph-intersect-square:before{content:""}.ph.ph-intersect-three:before{content:""}.ph.ph-intersection:before{content:""}.ph.ph-invoice:before{content:""}.ph.ph-island:before{content:""}.ph.ph-jar:before{content:""}.ph.ph-jar-label:before{content:""}.ph.ph-jeep:before{content:""}.ph.ph-joystick:before{content:""}.ph.ph-kanban:before{content:""}.ph.ph-key:before{content:""}.ph.ph-key-return:before{content:""}.ph.ph-keyboard:before{content:""}.ph.ph-keyhole:before{content:""}.ph.ph-knife:before{content:""}.ph.ph-ladder:before{content:""}.ph.ph-ladder-simple:before{content:""}.ph.ph-lamp:before{content:""}.ph.ph-lamp-pendant:before{content:""}.ph.ph-laptop:before{content:""}.ph.ph-lasso:before{content:""}.ph.ph-lastfm-logo:before{content:""}.ph.ph-layout:before{content:""}.ph.ph-leaf:before{content:""}.ph.ph-lectern:before{content:""}.ph.ph-lego:before{content:""}.ph.ph-lego-smiley:before{content:""}.ph.ph-less-than:before{content:""}.ph.ph-less-than-or-equal:before{content:""}.ph.ph-letter-circle-h:before{content:""}.ph.ph-letter-circle-p:before{content:""}.ph.ph-letter-circle-v:before{content:""}.ph.ph-lifebuoy:before{content:""}.ph.ph-lightbulb:before{content:""}.ph.ph-lightbulb-filament:before{content:""}.ph.ph-lighthouse:before{content:""}.ph.ph-lightning:before{content:""}.ph.ph-lightning-a:before{content:""}.ph.ph-lightning-slash:before{content:""}.ph.ph-line-segment:before{content:""}.ph.ph-line-segments:before{content:""}.ph.ph-line-vertical:before{content:""}.ph.ph-link:before{content:""}.ph.ph-link-break:before{content:""}.ph.ph-link-simple:before{content:""}.ph.ph-link-simple-break:before{content:""}.ph.ph-link-simple-horizontal:before{content:""}.ph.ph-link-simple-horizontal-break:before{content:""}.ph.ph-linkedin-logo:before{content:""}.ph.ph-linktree-logo:before{content:""}.ph.ph-linux-logo:before{content:""}.ph.ph-list:before{content:""}.ph.ph-list-bullets:before{content:""}.ph.ph-list-checks:before{content:""}.ph.ph-list-dashes:before{content:""}.ph.ph-list-heart:before{content:""}.ph.ph-list-magnifying-glass:before{content:""}.ph.ph-list-numbers:before{content:""}.ph.ph-list-plus:before{content:""}.ph.ph-list-star:before{content:""}.ph.ph-lock:before{content:""}.ph.ph-lock-key:before{content:""}.ph.ph-lock-key-open:before{content:""}.ph.ph-lock-laminated:before{content:""}.ph.ph-lock-laminated-open:before{content:""}.ph.ph-lock-open:before{content:""}.ph.ph-lock-simple:before{content:""}.ph.ph-lock-simple-open:before{content:""}.ph.ph-lockers:before{content:""}.ph.ph-log:before{content:""}.ph.ph-magic-wand:before{content:""}.ph.ph-magnet:before{content:""}.ph.ph-magnet-straight:before{content:""}.ph.ph-magnifying-glass:before{content:""}.ph.ph-magnifying-glass-minus:before{content:""}.ph.ph-magnifying-glass-plus:before{content:""}.ph.ph-mailbox:before{content:""}.ph.ph-map-pin:before{content:""}.ph.ph-map-pin-area:before{content:""}.ph.ph-map-pin-line:before{content:""}.ph.ph-map-pin-plus:before{content:""}.ph.ph-map-pin-simple:before{content:""}.ph.ph-map-pin-simple-area:before{content:""}.ph.ph-map-pin-simple-line:before{content:""}.ph.ph-map-trifold:before{content:""}.ph.ph-markdown-logo:before{content:""}.ph.ph-marker-circle:before{content:""}.ph.ph-martini:before{content:""}.ph.ph-mask-happy:before{content:""}.ph.ph-mask-sad:before{content:""}.ph.ph-mastodon-logo:before{content:""}.ph.ph-math-operations:before{content:""}.ph.ph-matrix-logo:before{content:""}.ph.ph-medal:before{content:""}.ph.ph-medal-military:before{content:""}.ph.ph-medium-logo:before{content:""}.ph.ph-megaphone:before{content:""}.ph.ph-megaphone-simple:before{content:""}.ph.ph-member-of:before{content:""}.ph.ph-memory:before{content:""}.ph.ph-messenger-logo:before{content:""}.ph.ph-meta-logo:before{content:""}.ph.ph-meteor:before{content:""}.ph.ph-metronome:before{content:""}.ph.ph-microphone:before{content:""}.ph.ph-microphone-slash:before{content:""}.ph.ph-microphone-stage:before{content:""}.ph.ph-microscope:before{content:""}.ph.ph-microsoft-excel-logo:before{content:""}.ph.ph-microsoft-outlook-logo:before{content:""}.ph.ph-microsoft-powerpoint-logo:before{content:""}.ph.ph-microsoft-teams-logo:before{content:""}.ph.ph-microsoft-word-logo:before{content:""}.ph.ph-minus:before{content:""}.ph.ph-minus-circle:before{content:""}.ph.ph-minus-square:before{content:""}.ph.ph-money:before{content:""}.ph.ph-money-wavy:before{content:""}.ph.ph-monitor:before{content:""}.ph.ph-monitor-arrow-up:before{content:""}.ph.ph-monitor-play:before{content:""}.ph.ph-moon:before{content:""}.ph.ph-moon-stars:before{content:""}.ph.ph-moped:before{content:""}.ph.ph-moped-front:before{content:""}.ph.ph-mosque:before{content:""}.ph.ph-motorcycle:before{content:""}.ph.ph-mountains:before{content:""}.ph.ph-mouse:before{content:""}.ph.ph-mouse-left-click:before{content:""}.ph.ph-mouse-middle-click:before{content:""}.ph.ph-mouse-right-click:before{content:""}.ph.ph-mouse-scroll:before{content:""}.ph.ph-mouse-simple:before{content:""}.ph.ph-music-note:before{content:""}.ph.ph-music-note-simple:before{content:""}.ph.ph-music-notes:before{content:""}.ph.ph-music-notes-minus:before{content:""}.ph.ph-music-notes-plus:before{content:""}.ph.ph-music-notes-simple:before{content:""}.ph.ph-navigation-arrow:before{content:""}.ph.ph-needle:before{content:""}.ph.ph-network:before{content:""}.ph.ph-network-slash:before{content:""}.ph.ph-network-x:before{content:""}.ph.ph-newspaper:before{content:""}.ph.ph-newspaper-clipping:before{content:""}.ph.ph-not-equals:before{content:""}.ph.ph-not-member-of:before{content:""}.ph.ph-not-subset-of:before{content:""}.ph.ph-not-superset-of:before{content:""}.ph.ph-notches:before{content:""}.ph.ph-note:before{content:""}.ph.ph-note-blank:before{content:""}.ph.ph-note-pencil:before{content:""}.ph.ph-notebook:before{content:""}.ph.ph-notepad:before{content:""}.ph.ph-notification:before{content:""}.ph.ph-notion-logo:before{content:""}.ph.ph-nuclear-plant:before{content:""}.ph.ph-number-circle-eight:before{content:""}.ph.ph-number-circle-five:before{content:""}.ph.ph-number-circle-four:before{content:""}.ph.ph-number-circle-nine:before{content:""}.ph.ph-number-circle-one:before{content:""}.ph.ph-number-circle-seven:before{content:""}.ph.ph-number-circle-six:before{content:""}.ph.ph-number-circle-three:before{content:""}.ph.ph-number-circle-two:before{content:""}.ph.ph-number-circle-zero:before{content:""}.ph.ph-number-eight:before{content:""}.ph.ph-number-five:before{content:""}.ph.ph-number-four:before{content:""}.ph.ph-number-nine:before{content:""}.ph.ph-number-one:before{content:""}.ph.ph-number-seven:before{content:""}.ph.ph-number-six:before{content:""}.ph.ph-number-square-eight:before{content:""}.ph.ph-number-square-five:before{content:""}.ph.ph-number-square-four:before{content:""}.ph.ph-number-square-nine:before{content:""}.ph.ph-number-square-one:before{content:""}.ph.ph-number-square-seven:before{content:""}.ph.ph-number-square-six:before{content:""}.ph.ph-number-square-three:before{content:""}.ph.ph-number-square-two:before{content:""}.ph.ph-number-square-zero:before{content:""}.ph.ph-number-three:before{content:""}.ph.ph-number-two:before{content:""}.ph.ph-number-zero:before{content:""}.ph.ph-numpad:before{content:""}.ph.ph-nut:before{content:""}.ph.ph-ny-times-logo:before{content:""}.ph.ph-octagon:before{content:""}.ph.ph-office-chair:before{content:""}.ph.ph-onigiri:before{content:""}.ph.ph-open-ai-logo:before{content:""}.ph.ph-option:before{content:""}.ph.ph-orange:before{content:""}.ph.ph-orange-slice:before{content:""}.ph.ph-oven:before{content:""}.ph.ph-package:before{content:""}.ph.ph-paint-brush:before{content:""}.ph.ph-paint-brush-broad:before{content:""}.ph.ph-paint-brush-household:before{content:""}.ph.ph-paint-bucket:before{content:""}.ph.ph-paint-roller:before{content:""}.ph.ph-palette:before{content:""}.ph.ph-panorama:before{content:""}.ph.ph-pants:before{content:""}.ph.ph-paper-plane:before{content:""}.ph.ph-paper-plane-right:before{content:""}.ph.ph-paper-plane-tilt:before{content:""}.ph.ph-paperclip:before{content:""}.ph.ph-paperclip-horizontal:before{content:""}.ph.ph-parachute:before{content:""}.ph.ph-paragraph:before{content:""}.ph.ph-parallelogram:before{content:""}.ph.ph-park:before{content:""}.ph.ph-password:before{content:""}.ph.ph-path:before{content:""}.ph.ph-patreon-logo:before{content:""}.ph.ph-pause:before{content:""}.ph.ph-pause-circle:before{content:""}.ph.ph-paw-print:before{content:""}.ph.ph-paypal-logo:before{content:""}.ph.ph-peace:before{content:""}.ph.ph-pen:before{content:""}.ph.ph-pen-nib:before{content:""}.ph.ph-pen-nib-straight:before{content:""}.ph.ph-pencil:before{content:""}.ph.ph-pencil-circle:before{content:""}.ph.ph-pencil-line:before{content:""}.ph.ph-pencil-ruler:before{content:""}.ph.ph-pencil-simple:before{content:""}.ph.ph-pencil-simple-line:before{content:""}.ph.ph-pencil-simple-slash:before{content:""}.ph.ph-pencil-slash:before{content:""}.ph.ph-pentagon:before{content:""}.ph.ph-pentagram:before{content:""}.ph.ph-pepper:before{content:""}.ph.ph-percent:before{content:""}.ph.ph-person:before{content:""}.ph.ph-person-arms-spread:before{content:""}.ph.ph-person-simple:before{content:""}.ph.ph-person-simple-bike:before{content:""}.ph.ph-person-simple-circle:before{content:""}.ph.ph-person-simple-hike:before{content:""}.ph.ph-person-simple-run:before{content:""}.ph.ph-person-simple-ski:before{content:""}.ph.ph-person-simple-snowboard:before{content:""}.ph.ph-person-simple-swim:before{content:""}.ph.ph-person-simple-tai-chi:before{content:""}.ph.ph-person-simple-throw:before{content:""}.ph.ph-person-simple-walk:before{content:""}.ph.ph-perspective:before{content:""}.ph.ph-phone:before{content:""}.ph.ph-phone-call:before{content:""}.ph.ph-phone-disconnect:before{content:""}.ph.ph-phone-incoming:before{content:""}.ph.ph-phone-list:before{content:""}.ph.ph-phone-outgoing:before{content:""}.ph.ph-phone-pause:before{content:""}.ph.ph-phone-plus:before{content:""}.ph.ph-phone-slash:before{content:""}.ph.ph-phone-transfer:before{content:""}.ph.ph-phone-x:before{content:""}.ph.ph-phosphor-logo:before{content:""}.ph.ph-pi:before{content:""}.ph.ph-piano-keys:before{content:""}.ph.ph-picnic-table:before{content:""}.ph.ph-picture-in-picture:before{content:""}.ph.ph-piggy-bank:before{content:""}.ph.ph-pill:before{content:""}.ph.ph-ping-pong:before{content:""}.ph.ph-pint-glass:before{content:""}.ph.ph-pinterest-logo:before{content:""}.ph.ph-pinwheel:before{content:""}.ph.ph-pipe:before{content:""}.ph.ph-pipe-wrench:before{content:""}.ph.ph-pix-logo:before{content:""}.ph.ph-pizza:before{content:""}.ph.ph-placeholder:before{content:""}.ph.ph-planet:before{content:""}.ph.ph-plant:before{content:""}.ph.ph-play:before{content:""}.ph.ph-play-circle:before{content:""}.ph.ph-play-pause:before{content:""}.ph.ph-playlist:before{content:""}.ph.ph-plug:before{content:""}.ph.ph-plug-charging:before{content:""}.ph.ph-plugs:before{content:""}.ph.ph-plugs-connected:before{content:""}.ph.ph-plus:before{content:""}.ph.ph-plus-circle:before{content:""}.ph.ph-plus-minus:before{content:""}.ph.ph-plus-square:before{content:""}.ph.ph-poker-chip:before{content:""}.ph.ph-police-car:before{content:""}.ph.ph-polygon:before{content:""}.ph.ph-popcorn:before{content:""}.ph.ph-popsicle:before{content:""}.ph.ph-potted-plant:before{content:""}.ph.ph-power:before{content:""}.ph.ph-prescription:before{content:""}.ph.ph-presentation:before{content:""}.ph.ph-presentation-chart:before{content:""}.ph.ph-printer:before{content:""}.ph.ph-prohibit:before{content:""}.ph.ph-prohibit-inset:before{content:""}.ph.ph-projector-screen:before{content:""}.ph.ph-projector-screen-chart:before{content:""}.ph.ph-pulse:before{content:""}.ph.ph-activity:before{content:""}.ph.ph-push-pin:before{content:""}.ph.ph-push-pin-simple:before{content:""}.ph.ph-push-pin-simple-slash:before{content:""}.ph.ph-push-pin-slash:before{content:""}.ph.ph-puzzle-piece:before{content:""}.ph.ph-qr-code:before{content:""}.ph.ph-question:before{content:""}.ph.ph-question-mark:before{content:""}.ph.ph-queue:before{content:""}.ph.ph-quotes:before{content:""}.ph.ph-rabbit:before{content:""}.ph.ph-racquet:before{content:""}.ph.ph-radical:before{content:""}.ph.ph-radio:before{content:""}.ph.ph-radio-button:before{content:""}.ph.ph-radioactive:before{content:""}.ph.ph-rainbow:before{content:""}.ph.ph-rainbow-cloud:before{content:""}.ph.ph-ranking:before{content:""}.ph.ph-read-cv-logo:before{content:""}.ph.ph-receipt:before{content:""}.ph.ph-receipt-x:before{content:""}.ph.ph-record:before{content:""}.ph.ph-rectangle:before{content:""}.ph.ph-rectangle-dashed:before{content:""}.ph.ph-recycle:before{content:""}.ph.ph-reddit-logo:before{content:""}.ph.ph-repeat:before{content:""}.ph.ph-repeat-once:before{content:""}.ph.ph-replit-logo:before{content:""}.ph.ph-resize:before{content:""}.ph.ph-rewind:before{content:""}.ph.ph-rewind-circle:before{content:""}.ph.ph-road-horizon:before{content:""}.ph.ph-robot:before{content:""}.ph.ph-rocket:before{content:""}.ph.ph-rocket-launch:before{content:""}.ph.ph-rows:before{content:""}.ph.ph-rows-plus-bottom:before{content:""}.ph.ph-rows-plus-top:before{content:""}.ph.ph-rss:before{content:""}.ph.ph-rss-simple:before{content:""}.ph.ph-rug:before{content:""}.ph.ph-ruler:before{content:""}.ph.ph-sailboat:before{content:""}.ph.ph-scales:before{content:""}.ph.ph-scan:before{content:""}.ph.ph-scan-smiley:before{content:""}.ph.ph-scissors:before{content:""}.ph.ph-scooter:before{content:""}.ph.ph-screencast:before{content:""}.ph.ph-screwdriver:before{content:""}.ph.ph-scribble:before{content:""}.ph.ph-scribble-loop:before{content:""}.ph.ph-scroll:before{content:""}.ph.ph-seal:before{content:""}.ph.ph-circle-wavy:before{content:""}.ph.ph-seal-check:before{content:""}.ph.ph-circle-wavy-check:before{content:""}.ph.ph-seal-percent:before{content:""}.ph.ph-seal-question:before{content:""}.ph.ph-circle-wavy-question:before{content:""}.ph.ph-seal-warning:before{content:""}.ph.ph-circle-wavy-warning:before{content:""}.ph.ph-seat:before{content:""}.ph.ph-seatbelt:before{content:""}.ph.ph-security-camera:before{content:""}.ph.ph-selection:before{content:""}.ph.ph-selection-all:before{content:""}.ph.ph-selection-background:before{content:""}.ph.ph-selection-foreground:before{content:""}.ph.ph-selection-inverse:before{content:""}.ph.ph-selection-plus:before{content:""}.ph.ph-selection-slash:before{content:""}.ph.ph-shapes:before{content:""}.ph.ph-share:before{content:""}.ph.ph-share-fat:before{content:""}.ph.ph-share-network:before{content:""}.ph.ph-shield:before{content:""}.ph.ph-shield-check:before{content:""}.ph.ph-shield-checkered:before{content:""}.ph.ph-shield-chevron:before{content:""}.ph.ph-shield-plus:before{content:""}.ph.ph-shield-slash:before{content:""}.ph.ph-shield-star:before{content:""}.ph.ph-shield-warning:before{content:""}.ph.ph-shipping-container:before{content:""}.ph.ph-shirt-folded:before{content:""}.ph.ph-shooting-star:before{content:""}.ph.ph-shopping-bag:before{content:""}.ph.ph-shopping-bag-open:before{content:""}.ph.ph-shopping-cart:before{content:""}.ph.ph-shopping-cart-simple:before{content:""}.ph.ph-shovel:before{content:""}.ph.ph-shower:before{content:""}.ph.ph-shrimp:before{content:""}.ph.ph-shuffle:before{content:""}.ph.ph-shuffle-angular:before{content:""}.ph.ph-shuffle-simple:before{content:""}.ph.ph-sidebar:before{content:""}.ph.ph-sidebar-simple:before{content:""}.ph.ph-sigma:before{content:""}.ph.ph-sign-in:before{content:""}.ph.ph-sign-out:before{content:""}.ph.ph-signature:before{content:""}.ph.ph-signpost:before{content:""}.ph.ph-sim-card:before{content:""}.ph.ph-siren:before{content:""}.ph.ph-sketch-logo:before{content:""}.ph.ph-skip-back:before{content:""}.ph.ph-skip-back-circle:before{content:""}.ph.ph-skip-forward:before{content:""}.ph.ph-skip-forward-circle:before{content:""}.ph.ph-skull:before{content:""}.ph.ph-skype-logo:before{content:""}.ph.ph-slack-logo:before{content:""}.ph.ph-sliders:before{content:""}.ph.ph-sliders-horizontal:before{content:""}.ph.ph-slideshow:before{content:""}.ph.ph-smiley:before{content:""}.ph.ph-smiley-angry:before{content:""}.ph.ph-smiley-blank:before{content:""}.ph.ph-smiley-meh:before{content:""}.ph.ph-smiley-melting:before{content:""}.ph.ph-smiley-nervous:before{content:""}.ph.ph-smiley-sad:before{content:""}.ph.ph-smiley-sticker:before{content:""}.ph.ph-smiley-wink:before{content:""}.ph.ph-smiley-x-eyes:before{content:""}.ph.ph-snapchat-logo:before{content:""}.ph.ph-sneaker:before{content:""}.ph.ph-sneaker-move:before{content:""}.ph.ph-snowflake:before{content:""}.ph.ph-soccer-ball:before{content:""}.ph.ph-sock:before{content:""}.ph.ph-solar-panel:before{content:""}.ph.ph-solar-roof:before{content:""}.ph.ph-sort-ascending:before{content:""}.ph.ph-sort-descending:before{content:""}.ph.ph-soundcloud-logo:before{content:""}.ph.ph-spade:before{content:""}.ph.ph-sparkle:before{content:""}.ph.ph-speaker-hifi:before{content:""}.ph.ph-speaker-high:before{content:""}.ph.ph-speaker-low:before{content:""}.ph.ph-speaker-none:before{content:""}.ph.ph-speaker-simple-high:before{content:""}.ph.ph-speaker-simple-low:before{content:""}.ph.ph-speaker-simple-none:before{content:""}.ph.ph-speaker-simple-slash:before{content:""}.ph.ph-speaker-simple-x:before{content:""}.ph.ph-speaker-slash:before{content:""}.ph.ph-speaker-x:before{content:""}.ph.ph-speedometer:before{content:""}.ph.ph-sphere:before{content:""}.ph.ph-spinner:before{content:""}.ph.ph-spinner-ball:before{content:""}.ph.ph-spinner-gap:before{content:""}.ph.ph-spiral:before{content:""}.ph.ph-split-horizontal:before{content:""}.ph.ph-split-vertical:before{content:""}.ph.ph-spotify-logo:before{content:""}.ph.ph-spray-bottle:before{content:""}.ph.ph-square:before{content:""}.ph.ph-square-half:before{content:""}.ph.ph-square-half-bottom:before{content:""}.ph.ph-square-logo:before{content:""}.ph.ph-square-split-horizontal:before{content:""}.ph.ph-square-split-vertical:before{content:""}.ph.ph-squares-four:before{content:""}.ph.ph-stack:before{content:""}.ph.ph-stack-minus:before{content:""}.ph.ph-stack-overflow-logo:before{content:""}.ph.ph-stack-plus:before{content:""}.ph.ph-stack-simple:before{content:""}.ph.ph-stairs:before{content:""}.ph.ph-stamp:before{content:""}.ph.ph-standard-definition:before{content:""}.ph.ph-star:before{content:""}.ph.ph-star-and-crescent:before{content:""}.ph.ph-star-four:before{content:""}.ph.ph-star-half:before{content:""}.ph.ph-star-of-david:before{content:""}.ph.ph-steam-logo:before{content:""}.ph.ph-steering-wheel:before{content:""}.ph.ph-steps:before{content:""}.ph.ph-stethoscope:before{content:""}.ph.ph-sticker:before{content:""}.ph.ph-stool:before{content:""}.ph.ph-stop:before{content:""}.ph.ph-stop-circle:before{content:""}.ph.ph-storefront:before{content:""}.ph.ph-strategy:before{content:""}.ph.ph-stripe-logo:before{content:""}.ph.ph-student:before{content:""}.ph.ph-subset-of:before{content:""}.ph.ph-subset-proper-of:before{content:""}.ph.ph-subtitles:before{content:""}.ph.ph-subtitles-slash:before{content:""}.ph.ph-subtract:before{content:""}.ph.ph-subtract-square:before{content:""}.ph.ph-subway:before{content:""}.ph.ph-suitcase:before{content:""}.ph.ph-suitcase-rolling:before{content:""}.ph.ph-suitcase-simple:before{content:""}.ph.ph-sun:before{content:""}.ph.ph-sun-dim:before{content:""}.ph.ph-sun-horizon:before{content:""}.ph.ph-sunglasses:before{content:""}.ph.ph-superset-of:before{content:""}.ph.ph-superset-proper-of:before{content:""}.ph.ph-swap:before{content:""}.ph.ph-swatches:before{content:""}.ph.ph-swimming-pool:before{content:""}.ph.ph-sword:before{content:""}.ph.ph-synagogue:before{content:""}.ph.ph-syringe:before{content:""}.ph.ph-t-shirt:before{content:""}.ph.ph-table:before{content:""}.ph.ph-tabs:before{content:""}.ph.ph-tag:before{content:""}.ph.ph-tag-chevron:before{content:""}.ph.ph-tag-simple:before{content:""}.ph.ph-target:before{content:""}.ph.ph-taxi:before{content:""}.ph.ph-tea-bag:before{content:""}.ph.ph-telegram-logo:before{content:""}.ph.ph-television:before{content:""}.ph.ph-television-simple:before{content:""}.ph.ph-tennis-ball:before{content:""}.ph.ph-tent:before{content:""}.ph.ph-terminal:before{content:""}.ph.ph-terminal-window:before{content:""}.ph.ph-test-tube:before{content:""}.ph.ph-text-a-underline:before{content:""}.ph.ph-text-aa:before{content:""}.ph.ph-text-align-center:before{content:""}.ph.ph-text-align-justify:before{content:""}.ph.ph-text-align-left:before{content:""}.ph.ph-text-align-right:before{content:""}.ph.ph-text-b:before{content:""}.ph.ph-text-bolder:before{content:""}.ph.ph-text-columns:before{content:""}.ph.ph-text-h:before{content:""}.ph.ph-text-h-five:before{content:""}.ph.ph-text-h-four:before{content:""}.ph.ph-text-h-one:before{content:""}.ph.ph-text-h-six:before{content:""}.ph.ph-text-h-three:before{content:""}.ph.ph-text-h-two:before{content:""}.ph.ph-text-indent:before{content:""}.ph.ph-text-italic:before{content:""}.ph.ph-text-outdent:before{content:""}.ph.ph-text-strikethrough:before{content:""}.ph.ph-text-subscript:before{content:""}.ph.ph-text-superscript:before{content:""}.ph.ph-text-t:before{content:""}.ph.ph-text-t-slash:before{content:""}.ph.ph-text-underline:before{content:""}.ph.ph-textbox:before{content:""}.ph.ph-thermometer:before{content:""}.ph.ph-thermometer-cold:before{content:""}.ph.ph-thermometer-hot:before{content:""}.ph.ph-thermometer-simple:before{content:""}.ph.ph-threads-logo:before{content:""}.ph.ph-three-d:before{content:""}.ph.ph-thumbs-down:before{content:""}.ph.ph-thumbs-up:before{content:""}.ph.ph-ticket:before{content:""}.ph.ph-tidal-logo:before{content:""}.ph.ph-tiktok-logo:before{content:""}.ph.ph-tilde:before{content:""}.ph.ph-timer:before{content:""}.ph.ph-tip-jar:before{content:""}.ph.ph-tipi:before{content:""}.ph.ph-tire:before{content:""}.ph.ph-toggle-left:before{content:""}.ph.ph-toggle-right:before{content:""}.ph.ph-toilet:before{content:""}.ph.ph-toilet-paper:before{content:""}.ph.ph-toolbox:before{content:""}.ph.ph-tooth:before{content:""}.ph.ph-tornado:before{content:""}.ph.ph-tote:before{content:""}.ph.ph-tote-simple:before{content:""}.ph.ph-towel:before{content:""}.ph.ph-tractor:before{content:""}.ph.ph-trademark:before{content:""}.ph.ph-trademark-registered:before{content:""}.ph.ph-traffic-cone:before{content:""}.ph.ph-traffic-sign:before{content:""}.ph.ph-traffic-signal:before{content:""}.ph.ph-train:before{content:""}.ph.ph-train-regional:before{content:""}.ph.ph-train-simple:before{content:""}.ph.ph-tram:before{content:""}.ph.ph-translate:before{content:""}.ph.ph-trash:before{content:""}.ph.ph-trash-simple:before{content:""}.ph.ph-tray:before{content:""}.ph.ph-tray-arrow-down:before{content:""}.ph.ph-archive-tray:before{content:""}.ph.ph-tray-arrow-up:before{content:""}.ph.ph-treasure-chest:before{content:""}.ph.ph-tree:before{content:""}.ph.ph-tree-evergreen:before{content:""}.ph.ph-tree-palm:before{content:""}.ph.ph-tree-structure:before{content:""}.ph.ph-tree-view:before{content:""}.ph.ph-trend-down:before{content:""}.ph.ph-trend-up:before{content:""}.ph.ph-triangle:before{content:""}.ph.ph-triangle-dashed:before{content:""}.ph.ph-trolley:before{content:""}.ph.ph-trolley-suitcase:before{content:""}.ph.ph-trophy:before{content:""}.ph.ph-truck:before{content:""}.ph.ph-truck-trailer:before{content:""}.ph.ph-tumblr-logo:before{content:""}.ph.ph-twitch-logo:before{content:""}.ph.ph-twitter-logo:before{content:""}.ph.ph-umbrella:before{content:""}.ph.ph-umbrella-simple:before{content:""}.ph.ph-union:before{content:""}.ph.ph-unite:before{content:""}.ph.ph-unite-square:before{content:""}.ph.ph-upload:before{content:""}.ph.ph-upload-simple:before{content:""}.ph.ph-usb:before{content:""}.ph.ph-user:before{content:""}.ph.ph-user-check:before{content:""}.ph.ph-user-circle:before{content:""}.ph.ph-user-circle-check:before{content:""}.ph.ph-user-circle-dashed:before{content:""}.ph.ph-user-circle-gear:before{content:""}.ph.ph-user-circle-minus:before{content:""}.ph.ph-user-circle-plus:before{content:""}.ph.ph-user-focus:before{content:""}.ph.ph-user-gear:before{content:""}.ph.ph-user-list:before{content:""}.ph.ph-user-minus:before{content:""}.ph.ph-user-plus:before{content:""}.ph.ph-user-rectangle:before{content:""}.ph.ph-user-sound:before{content:""}.ph.ph-user-square:before{content:""}.ph.ph-user-switch:before{content:""}.ph.ph-users:before{content:""}.ph.ph-users-four:before{content:""}.ph.ph-users-three:before{content:""}.ph.ph-van:before{content:""}.ph.ph-vault:before{content:""}.ph.ph-vector-three:before{content:""}.ph.ph-vector-two:before{content:""}.ph.ph-vibrate:before{content:""}.ph.ph-video:before{content:""}.ph.ph-video-camera:before{content:""}.ph.ph-video-camera-slash:before{content:""}.ph.ph-video-conference:before{content:""}.ph.ph-vignette:before{content:""}.ph.ph-vinyl-record:before{content:""}.ph.ph-virtual-reality:before{content:""}.ph.ph-virus:before{content:""}.ph.ph-visor:before{content:""}.ph.ph-voicemail:before{content:""}.ph.ph-volleyball:before{content:""}.ph.ph-wall:before{content:""}.ph.ph-wallet:before{content:""}.ph.ph-warehouse:before{content:""}.ph.ph-warning:before{content:""}.ph.ph-warning-circle:before{content:""}.ph.ph-warning-diamond:before{content:""}.ph.ph-warning-octagon:before{content:""}.ph.ph-washing-machine:before{content:""}.ph.ph-watch:before{content:""}.ph.ph-wave-sawtooth:before{content:""}.ph.ph-wave-sine:before{content:""}.ph.ph-wave-square:before{content:""}.ph.ph-wave-triangle:before{content:""}.ph.ph-waveform:before{content:""}.ph.ph-waveform-slash:before{content:""}.ph.ph-waves:before{content:""}.ph.ph-webcam:before{content:""}.ph.ph-webcam-slash:before{content:""}.ph.ph-webhooks-logo:before{content:""}.ph.ph-wechat-logo:before{content:""}.ph.ph-whatsapp-logo:before{content:""}.ph.ph-wheelchair:before{content:""}.ph.ph-wheelchair-motion:before{content:""}.ph.ph-wifi-high:before{content:""}.ph.ph-wifi-low:before{content:""}.ph.ph-wifi-medium:before{content:""}.ph.ph-wifi-none:before{content:""}.ph.ph-wifi-slash:before{content:""}.ph.ph-wifi-x:before{content:""}.ph.ph-wind:before{content:""}.ph.ph-windmill:before{content:""}.ph.ph-windows-logo:before{content:""}.ph.ph-wine:before{content:""}.ph.ph-wrench:before{content:""}.ph.ph-x:before{content:""}.ph.ph-x-circle:before{content:""}.ph.ph-x-logo:before{content:""}.ph.ph-x-square:before{content:""}.ph.ph-yarn:before{content:""}.ph.ph-yin-yang:before{content:""}.ph.ph-youtube-logo:before{content:""}.container{padding:18px}.section{margin-bottom:48px}.section-title,.block{margin-bottom:34px}.block-title{margin-bottom:22px}p,.text{margin-bottom:15px}.hint{margin-top:8px}.list{padding-left:22px;margin-bottom:15px}.list-item{margin-bottom:8px}.list-nested{margin-top:8px}.table{margin-bottom:22px}.table-caption{margin-bottom:8px}.form-group{margin-bottom:15px}.label{margin-bottom:5px;display:block}.input,.textarea,.select{margin-top:5px}.toast{padding:15px}.toast-stack{gap:8px}*{scrollbar-width:thin;scrollbar-color:#414868 transparent}*::-webkit-scrollbar{width:8px;height:8px}*::-webkit-scrollbar-track{background:transparent}*::-webkit-scrollbar-thumb{width:8px;background:#414868;border-radius:9999px;cursor:default}*::-webkit-scrollbar-thumb:hover{background:#787c99}*::-webkit-scrollbar-corner{background:transparent}*::-webkit-scrollbar-button{display:none}.chat-header,.context-bar,.profile-badge,.msg-meta-row,.recall-banner,.app-sidebar,.input-bar,.tabs-list{-webkit-user-select:none;user-select:none;-webkit-touch-callout:none}.chat-header input,.chat-header textarea,.context-bar input,.context-bar textarea,.profile-badge input,.profile-badge textarea,.msg-meta-row input,.msg-meta-row textarea,.recall-banner input,.recall-banner textarea,.app-sidebar input,.app-sidebar textarea,.input-bar input,.input-bar textarea,.tabs-list input,.tabs-list textarea{-webkit-user-select:auto;user-select:auto;-webkit-touch-callout:default}@media(max-width:767px){textarea,input:not([type=checkbox]):not([type=radio]):not([type=range]){font-size:16px!important}}html,body{height:100%;overflow:hidden;overscroll-behavior:none}#app{display:flex;height:100%;overflow:hidden}.app-main{flex:1 1 0;min-width:0;min-height:0;display:flex;flex-direction:column;overflow:hidden;background:#16161e}.app-sidebar{width:380px;min-width:380px;max-width:380px;display:flex;flex-direction:column;background:#1f2335;border-right:2px solid rgba(192,202,245,.24);overflow:hidden;flex-shrink:0;transition:width .22s ease,min-width .22s ease,max-width .22s ease,border-color .22s ease,transform .28s ease}.app-sidebar.is-hidden-by-artifacts{width:0;min-width:0;max-width:0;border-right-color:transparent}@media(max-width:1279.98px){.app-sidebar{position:fixed;top:0;right:0;bottom:0;left:0;z-index:100;width:min(380px,92vw)!important;min-width:min(380px,92vw)!important;transform:translate(-100%);transition:transform .28s ease}.app-sidebar.is-mobile-open{transform:translate(0)}.app-sidebar.is-hidden-by-artifacts{width:min(380px,92vw)!important;min-width:min(380px,92vw)!important;max-width:min(380px,92vw)!important;border-right-color:#c0caf53d}}@media(max-width:980px){.app-sidebar,.app-sidebar.is-hidden-by-artifacts{width:100vw!important;min-width:100vw!important;max-width:100vw!important}}.sidebar-header{padding:15px;border-bottom:2px solid rgba(192,202,245,.24);display:flex;flex-direction:column;gap:8px}.sidebar-logo-row{display:flex;align-items:center;gap:8px}.sidebar-logo{display:flex;align-items:center;gap:8px;text-decoration:none;flex:1;min-width:0}.sidebar-logo img{width:42px;height:42px}.sidebar-logo span{font-size:16px;font-weight:700;color:#c0caf5}.sidebar-sessions{flex:1;overflow:hidden;display:flex;flex-direction:column}.sessions-header{display:flex;align-items:center;justify-content:space-between;padding:8px 15px;gap:8px}.sessions-label{font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:#787c99}.sessions-refresh-btn{font-size:14px;color:#787c99;transition:color .15s,transform .15s}.sessions-refresh-btn:hover{color:#c0caf5}.sessions-refresh-btn.is-spinning i{animation:spin .8s linear infinite}.session-item{display:flex;align-items:flex-start;gap:8px;padding:8px 15px;cursor:pointer;border-radius:0;transition:background .15s ease;position:relative}.session-item:hover{background:#1f2335}.session-item:hover .session-actions{opacity:1}@media(hover:none){.session-item .session-actions{opacity:1}}.session-item.is-active{background:#c0caf516;border-left:6px solid #7AA2F7;padding-left:9px}.session-item.is-pinned{background:#e0af6812}.session-item.is-pinned .session-name{color:#e0af68}.session-item.has-recall .session-actions{opacity:1}.session-item.is-special{opacity:.72}.session-item.is-special:hover{opacity:1}.session-item.is-special .session-name{font-weight:400}.session-icons{display:flex;flex-direction:column;align-items:center;gap:2px;flex-shrink:0;margin-top:2px;width:14px}.session-icons .session-pin-icon,.session-icons .session-recall-icon,.session-icons .session-special-icon{color:#787c99;font-size:14px;opacity:0;transition:opacity .15s ease}.session-icons .session-pin-icon{color:#e0af68}.session-icons .session-recall-icon,.session-icons .session-special-icon{color:var(--gn-color-secondary)}.is-pinned .session-icons .session-pin-icon,.has-recall .session-icons .session-recall-icon,.is-special .session-icons .session-special-icon{opacity:1}.session-info{flex:1;overflow:hidden}.session-name{font-size:13px;color:#c0caf5;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;line-height:1.4}.session-time{font-size:11px;color:#787c99;line-height:1.4;margin-top:2px}.session-preview{font-size:12px;color:#c0caf5;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;line-height:1.4;margin-top:3px}.session-actions{display:flex;gap:2px;opacity:0;transition:opacity .15s ease;flex-shrink:0;align-self:flex-start;margin-top:1px}.session-actions .btn-icon{width:26px;height:26px;font-size:14px}.chat-area{flex:1 1 0;min-height:0;min-width:0;display:flex;flex-direction:column;overflow:hidden;background:#16161e}.chat-header{display:flex;align-items:center;gap:8px;padding:8px 15px;border-bottom:2px solid rgba(192,202,245,.24);background:#1f2335;flex-shrink:0;min-height:54px}.chat-header-info{flex:1;display:flex;align-items:center;gap:8px;overflow:hidden;min-width:0}@media(max-width:768px){.chat-header-info{flex-direction:column;align-items:flex-start;gap:2px}}.chat-header-title{font-size:14px;font-weight:600;color:#c0caf5;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex-shrink:1;min-width:0;cursor:text}.chat-header-rename{flex:1;min-width:0;height:32px;padding:0 10px;font-size:14px;font-weight:600;font-family:inherit;color:#c0caf5;background:#c0caf516;border:1px solid #7AA2F7;border-radius:3px;outline:none}.profile-badge{display:inline-flex;align-items:center;gap:6px;flex-shrink:0;white-space:nowrap}.btn-sidebar-toggle{display:none}@media(max-width:1279.98px){.btn-sidebar-toggle{display:flex}}.context-bar{display:flex;align-items:center;flex-shrink:0;cursor:default}.msg-user{display:flex;justify-content:flex-end;gap:8px}.msg-user-bubble{background:#7aa2f7;color:#16161e;padding:8px 15px;border-radius:6px;font-size:14px;line-height:1.6;word-wrap:break-word;width:100%}.msg-user-bubble .msg-user-quote{margin:0 0 5px;padding:2px 0 2px 8px;border-left:3px solid rgba(22,22,30,.35);opacity:.7;font-size:13px}.msg-user--recall .msg-user-bubble{background:color-mix(in srgb,var(--gn-color-secondary) 12%,transparent);border:1px solid color-mix(in srgb,var(--gn-color-secondary) 25%,transparent)}.msg-user--recall .msg-user-bubble .msg-user-text{color:#c0caf5}.msg-recall-badge{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:var(--gn-color-secondary);margin-bottom:4px;opacity:.85}.msg-user-attachments{display:flex;flex-wrap:wrap;gap:5px;margin-top:5px}.msg-user-image{width:80px;height:80px;object-fit:cover;border-radius:6px;cursor:pointer;transition:opacity .15s}.msg-user-image:hover{opacity:.75}.msg-user-file-pill{display:inline-flex;align-items:center;gap:5px;padding:2px 8px;background:#16161e4d;border-radius:999px;font-size:12px}.msg-time{font-size:11px;color:#787c99;line-height:1;margin-top:4px}.msg-meta-row{display:flex;align-items:center;gap:8px;margin-top:2px;min-width:0}.msg-meta-item{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:#787c99;white-space:nowrap}.msg-meta-item i{font-size:12px;opacity:.7}.msg-user-wrap{display:flex;flex-direction:column;align-items:flex-end;max-width:70%}@media(max-width:768px){.msg-user-wrap{max-width:90%}}.msg-user-footer{display:flex;align-items:center;gap:5px;align-self:flex-end}.msg-copy-btn{width:22px;height:22px;min-width:22px;padding:0;font-size:12px;opacity:.5;transition:opacity .15s}.msg-copy-btn:hover{opacity:1}.msg-meta-row>.msg-copy-btn{margin-left:auto}.msg-meta-row .msg-rate-btn{width:22px;height:22px;min-width:22px;padding:0;font-size:13px}.msg-assistant{display:flex;flex-direction:column;gap:8px;max-width:100%}.planning-indicator{display:flex;align-items:center;gap:8px;font-size:13px;font-style:italic;color:#787c99;padding:5px 0}.planning-indicator.is-executing{color:#a9b1d6;font-style:normal}.planning-label{opacity:.75;transition:opacity .2s}.msg-assistant-avatar{width:28px;height:28px;border-radius:50%;flex-shrink:0}.msg-assistant-content{font-size:14px;line-height:1.7;color:#c0caf5;display:flex;flex-wrap:wrap;gap:8px}.msg-assistant-content>p,.msg-assistant-content>ul,.msg-assistant-content>ol,.msg-assistant-content>blockquote,.msg-assistant-content>pre,.msg-assistant-content>.table-wrap,.msg-assistant-content>.code-block,.msg-assistant-content>h1,.msg-assistant-content>h2,.msg-assistant-content>h3,.msg-assistant-content>h4,.msg-assistant-content>hr{flex:1 1 100%;margin:0}.msg-assistant-content>p:has(>.msg-md-image-link:only-child){flex:0 0 calc((100% - 16px) / 3)}.msg-assistant-content h1,.msg-assistant-content h2,.msg-assistant-content h3,.msg-assistant-content h4{color:#c0caf5}.msg-assistant-content ul,.msg-assistant-content ol{padding-left:22px}.msg-assistant-content li{margin-bottom:8px}.msg-assistant-content blockquote{padding-left:15px;border-left:6px solid #7AA2F7;color:#a9b1d6}.msg-assistant-content a{color:#7aa2f7}.msg-assistant-content strong{color:#c0caf5}.msg-assistant-content hr{border:none;border-top:1px solid rgba(192,202,245,.24)}.msg-assistant-content .msg-md-image-link{display:block;width:100%;text-decoration:none;border:2px solid rgba(192,202,245,.12);border-radius:3px;overflow:hidden;transition:border-color .2s ease;cursor:zoom-in}.msg-assistant-content .msg-md-image-link:hover{border-color:#7aa2f7}.msg-assistant-content .msg-md-image{display:block;width:100%;aspect-ratio:1/1;object-fit:cover;border-radius:2px}.msg-assistant-content .msg-md-image-link.is-broken{cursor:default;border-color:#f7768e66;background:#f7768e0f;display:flex;align-items:center;justify-content:center;aspect-ratio:1/1}.msg-assistant-content .msg-md-image-link.is-broken:before{content:"🖼️";font-size:32px;opacity:.4}.msg-assistant-content .msg-md-image-link.is-broken:hover{border-color:#f7768e66}.msg-assistant-content .msg-md-image-link.is-broken .msg-md-image{display:none}.msg-assistant-content .table-wrap{overflow-x:auto;-webkit-overflow-scrolling:touch;margin:15px 0}.msg-assistant-content .table-wrap table{margin:0;border:2px solid rgba(192,202,245,.24);border-radius:3px}.msg-assistant-content .table-wrap table th,.msg-assistant-content .table-wrap table td{padding:8px 15px;font-size:13px;vertical-align:middle;text-align:left;border-bottom:2px solid rgba(192,202,245,.24)}.msg-assistant-content .table-wrap table th{font-weight:600;color:#a9b1d6;background:#1f2335}.msg-assistant-content .table-wrap table tr:last-child th,.msg-assistant-content .table-wrap table tr:last-child td{border-bottom:none}.msg-assistant-content :not(pre)>code{font-family:IBM Plex Mono,monospace;font-size:13px;background:#c0caf516;padding:1px 5px;color:#7dcfff}.msg-assistant-content .code-block{margin:15px 0;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:3px;overflow:hidden}.msg-assistant-content .code-block .code-header{display:flex;align-items:center;justify-content:space-between;padding:5px 15px;background:#c0caf516;border-bottom:2px solid rgba(192,202,245,.24);font-size:12px;color:#787c99;font-family:IBM Plex Mono,monospace}.msg-assistant-content .code-block pre{margin:0;background:#1f2335!important}.msg-assistant-content .code-block pre code{font-family:IBM Plex Mono,monospace;font-size:13px;display:block;padding:15px;overflow-x:auto}.thinking-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;color:#787c99;font-size:12px;font-style:italic;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px;transition:background .15s ease;-webkit-user-select:none;user-select:none}.thinking-card summary::-webkit-details-marker{display:none}.thinking-card summary:hover{background:#c0caf516}.thinking-card[open] summary{border-bottom-color:transparent;border-radius:6px 6px 0 0}.thinking-card .thinking-chevron{margin-left:auto;font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.thinking-card[open] .thinking-chevron{transform:rotate(180deg)}.thinking-card .thinking-body{padding:8px 15px;font-size:12px;font-style:italic;color:#a9b1d6;line-height:1.5;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-top:none;border-radius:0 0 6px 6px;white-space:pre-wrap;word-break:break-word;max-height:800px;overflow-y:auto}.plan-card{border:2px solid #7AA2F7;border-left-width:6px;border-left-color:#7aa2f7;border-radius:6px;overflow:hidden;font-size:12px;margin-bottom:8px}.plan-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#7aa2f714;color:#7aa2f7;font-size:12px;-webkit-user-select:none;user-select:none}.plan-card summary::-webkit-details-marker{display:none}.plan-card summary:hover{background:#7aa2f724}.plan-card summary .plan-chevron{margin-left:auto;font-size:18px;color:#7aa2f799;transition:transform .15s ease;flex-shrink:0}.plan-card[open] .plan-chevron{transform:rotate(180deg)}.plan-card .plan-body{padding:8px 15px;font-size:12px;color:#a9b1d6;line-height:1.5;background:#7aa2f70a;border-top:2px solid rgba(122,162,247,.3)}.plan-card .plan-body p{margin:0 0 8px}.plan-card .plan-body p:last-child{margin-bottom:0}.plan-card .plan-body ul,.plan-card .plan-body ol{padding-left:22px;margin-bottom:8px}.plan-card .plan-body li{margin-bottom:5px}.plan-card .plan-body strong{color:#c0caf5}.tool-card{border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-radius:6px;margin-bottom:8px;border-left-color:#7aa2f7;overflow:hidden;font-size:13px}.tool-card.is-success{border-left-color:#9ece6a}.tool-card.is-error{border-left-color:#f7768e}.tool-card>summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#1f2335;color:#a9b1d6;-webkit-user-select:none;user-select:none}.tool-card>summary::-webkit-details-marker{display:none}.tool-card>summary:hover{background:#c0caf516}.tool-card>summary .tool-chevron{font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.tool-card[open]>summary .tool-chevron{transform:rotate(180deg)}.tool-card .tool-name{flex:1;font-family:IBM Plex Mono,monospace;font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tool-card .tool-running-time{font-family:IBM Plex Mono,monospace;font-size:11px;color:#787c99;white-space:nowrap}.tool-card .tool-status-icon{display:flex;align-items:center;justify-content:center;width:18px;height:18px;font-size:18px;flex-shrink:0}.tool-card-body{background:#1f2335;border-top:2px solid rgba(192,202,245,.24)}.tool-running-banner{display:flex;align-items:center;gap:8px;padding:8px 15px;color:#a9b1d6;background:#7aa2f714;border-bottom:1px solid rgba(192,202,245,.24);font-size:12px}.tool-section{padding:8px 15px}.tool-section+.tool-section{border-top:1px solid rgba(192,202,245,.24)}.tool-section-label{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:#787c99;margin-bottom:5px}.tool-code{font-family:IBM Plex Mono,monospace;font-size:12px;color:#a9b1d6;white-space:pre-wrap;word-break:break-word}.tool-args summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;-webkit-user-select:none;user-select:none;font-size:12px;color:#a9b1d6;background:#1f2335}.tool-args summary::-webkit-details-marker{display:none}.tool-args summary:hover{background:#c0caf516}.tool-args summary .tool-chevron{margin-left:auto;font-size:18px;color:#787c99;transition:transform .15s ease}.tool-args[open]>summary .tool-chevron{transform:rotate(180deg)}.tool-cards-summary{display:inline-flex;align-items:center;gap:8px;padding:5px 0}.tool-fade-item{transition:none}.tool-fade-enter-active,.tool-fade-leave-active{transition:opacity .2s ease,transform .2s ease}.tool-fade-enter-from{opacity:0;transform:translateY(-4px)}.tool-fade-leave-to{opacity:0}@supports (interpolate-size: allow-keywords){details{interpolate-size:allow-keywords}details::details-content{block-size:0;overflow:clip;transition:block-size .25s ease,content-visibility .25s ease;transition-behavior:allow-discrete}details[open]::details-content{block-size:auto}}.tool-result{font-size:12px;line-height:1.5;color:#a9b1d6}.tool-result h1,.tool-result h2,.tool-result h3,.tool-result h4{color:#c0caf5;margin:8px 0}.tool-result p{margin:5px 0}.tool-result ul,.tool-result ol{padding-left:22px;margin:5px 0}.tool-result li{margin-bottom:2px}.tool-result blockquote{padding-left:8px;border-left:6px solid #7AA2F7;color:#a9b1d6;margin:5px 0}.tool-result code{font-family:IBM Plex Mono,monospace;background:#c0caf516;padding:1px 4px;color:#7dcfff;font-size:11px}.tool-result pre{margin:5px 0;background:#1f2335;border:2px solid rgba(192,202,245,.24);overflow:hidden}.tool-result pre code{display:block;padding:8px;overflow-x:auto}.result-line{font-family:IBM Plex Mono,monospace;padding:1px 0;white-space:pre-wrap;word-break:break-word}.result-line.diff-summary,.result-line.diff-hunk,.result-line.diff-add,.result-line.diff-del,.result-line.diff-ctx{padding:0;line-height:1.3}.result-line.diff-summary,.result-line.diff-hunk{color:#a9b1d6}.result-line.diff-add{color:#9ece6a}.result-line.diff-del{color:#f7768e}.result-line.diff-ctx{color:inherit}.diff-num-marker.diff-add{color:#9ece6a}.diff-num-marker.diff-del{color:#f7768e}.diff-num-marker.diff-ctx,.diff-content{color:inherit}.read-header-path{color:#ff9e64}.read-header-rest{color:#a9b1d6}.read-warning{color:#e0af68}.read-num{color:#ff9e64}.read-content{color:inherit}.json-object,.json-array{font-family:IBM Plex Mono,monospace;display:flex;flex-direction:column;gap:1px;padding:5px 0}.json-item{display:flex;align-items:baseline;gap:5px;padding:1px 0}.json-key{color:#c0caf5;font-weight:500;flex-shrink:0}.json-sep{color:#787c99}.json-value{color:#a9b1d6;word-break:break-word;white-space:pre-wrap}.json-string{color:#9ece6a}.json-number{color:#e0af68}.json-bool{color:#c0caf5}.json-null,.json-empty{color:#787c99;font-style:italic}.subagent-steps{display:flex;flex-direction:column;gap:5px;padding:5px 15px 15px;background:#1f2335}.subagent-planning-indicator{display:flex;align-items:center;gap:8px;padding:5px 15px;font-size:12px;font-style:italic;color:#787c99;background:#1f2335}.task-update-step{display:flex;align-items:baseline;gap:8px;padding:5px 15px;font-size:12px;color:#a9b1d6;background:#1f2335}.task-update-step i{font-size:14px;color:#e0af68;flex:none}.task-update-step .task-step-tool{color:#c0caf5;font-weight:500}.task-update-step .task-step-status{color:#787c99;font-style:italic}.task-update-step .task-step-preview{color:#a9b1d6;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.task-update-step.completed i{color:#9ece6a}.task-update-step.completed .task-step-status{color:#9ece6a;font-style:normal}.task-update-step.failed i,.task-update-step.cancelled i{color:#f7768e}.task-update-step.failed .task-step-status,.task-update-step.cancelled .task-step-status{color:#f7768e;font-style:normal}.task-update-step .task-spin{animation:task-spin 1s linear infinite}@keyframes task-spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.subagent-step{border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-left-color:#7aa2f7;border-radius:6px;overflow:hidden;margin-bottom:8px;font-size:12px}.subagent-step.is-success{border-left-color:#9ece6a}.subagent-step.is-error{border-left-color:#f7768e}.subagent-step summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#1f2335;color:#a9b1d6;-webkit-user-select:none;user-select:none}.subagent-step summary::-webkit-details-marker{display:none}.subagent-step summary:hover{background:#c0caf516}.subagent-step .tool-name{flex:1;font-family:IBM Plex Mono,monospace;font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.subagent-step .tool-running-time{font-family:IBM Plex Mono,monospace;font-size:11px;color:#787c99;white-space:nowrap}.subagent-step .tool-status-icon{display:flex;align-items:center;justify-content:center;width:18px;height:18px;font-size:18px;flex-shrink:0}.subagent-step .tool-chevron{font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.subagent-step[open]>summary .tool-chevron{transform:rotate(180deg)}.summary-card{border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-left-color:#bb9af7;border-radius:6px;overflow:hidden;font-size:13px}.summary-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:8px 15px;cursor:pointer;background:#bb9af714;color:#bb9af7;-webkit-user-select:none;user-select:none}.summary-card summary::-webkit-details-marker{display:none}.compression-notice{font-size:12px}.compression-notice summary{list-style:none;text-align:center;padding:8px;color:#787c99;display:flex;align-items:center;justify-content:center;gap:8px;cursor:pointer;-webkit-user-select:none;user-select:none}.compression-notice summary::-webkit-details-marker{display:none}.compression-notice summary:before,.compression-notice summary:after{content:"";flex:1;height:1px;background:#c0caf53d}.compression-notice .compression-counts{opacity:.7}.compression-notice .compression-chevron{font-size:18px;transition:transform .15s ease}.compression-notice[open] .compression-chevron{transform:rotate(180deg)}.compression-notice .compression-body{padding:15px;font-size:13px;color:#a9b1d6;line-height:1.6;background:#1f2335;border:2px solid rgba(192,202,245,.24)}.input-bar{flex-shrink:0;padding:8px 15px;background:#16161e;border-top:2px solid rgba(192,202,245,.24)}@media(max-width:767px){.input-bar{padding:0}}.input-dropzone{position:relative}.input-dropzone.is-dragging:after{content:"Drop files here";position:absolute;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;background:#7aa2f71f;border:2px dashed #7AA2F7;font-size:14px;color:#7aa2f7;pointer-events:none;z-index:10}.file-preview-strip{display:flex;flex-wrap:wrap;gap:5px;margin-bottom:5px;max-width:920px;margin-left:auto;margin-right:auto}@media(max-width:767px){.file-preview-strip{padding-top:8px}}.file-preview-image{position:relative;width:60px;height:60px}.file-preview-image img{width:100%;height:100%;object-fit:cover;border:2px solid rgba(192,202,245,.24)}.file-preview-pill.file-preview-pill{text-transform:none;max-width:180px}.file-preview-pill.file-preview-pill .file-preview-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.file-preview-image{border:2px solid rgba(192,202,245,.24);border-radius:3px;overflow:hidden;background:#1f2335}.file-preview-remove{background:none;border:none;cursor:pointer;color:#787c99;padding:0;display:flex;align-items:center;font-size:14px;transition:color .15s ease;flex-shrink:0}.file-preview-remove:hover{color:#f7768e}.upload-progress{height:2px;background:#c0caf516;margin-bottom:5px;overflow:hidden}.upload-progress-fill{height:100%;background:#7aa2f7;transition:width .2s ease}.upload-progress.is-indeterminate .upload-progress-fill{width:30%;transition:none;animation:upload-slide 1.1s ease-in-out infinite}@keyframes upload-slide{0%{transform:translate(-110%)}to{transform:translate(440%)}}.input-row{display:flex;align-items:center;gap:8px;background:#1f2335;border:2px solid #C0CAF5;border-radius:3px;padding:8px;max-width:920px;margin:0 auto}.input-row:hover{border-bottom-color:#787c99}.input-row:focus-within{border-color:#7aa2f7;background:transparent}@media(max-width:767px){.input-row{border:none;border-radius:0;max-width:none;padding:8px 15px}}.input-textarea{flex:1;background:none;border:none;outline:none;resize:none;color:#c0caf5;font-size:14px;line-height:1.5;font-family:inherit;min-height:24px;max-height:144px;overflow-y:auto;padding:2px 0}.input-textarea::placeholder{color:#787c99}.welcome-screen{flex:1;position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:34px;gap:34px;text-align:center}@media(max-width:768px){.welcome-screen{padding:52px 15px 15px;gap:15px;justify-content:flex-start}}.welcome-logo{display:flex;flex-direction:column;align-items:center;gap:8px}.welcome-logo img{width:64px;height:64px}.welcome-logo h1{font-size:30px;font-weight:600;color:#c0caf5;margin:0}.welcome-logo p{font-size:var(--gn-font-size-base);color:#a9b1d6;margin:0}@media(max-width:768px){.welcome-logo{flex-direction:row;flex-wrap:wrap;justify-content:center;gap:8px}.welcome-logo img{width:36px;height:36px}.welcome-logo h1{font-size:22px}.welcome-logo p{font-size:13px;flex-basis:100%}}.welcome-profiles{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:15px;width:min(100%,880px)}@media(max-width:768px){.welcome-profiles{grid-template-columns:repeat(2,1fr);gap:10px;width:100%;max-width:100%}}.welcome-profile-card{display:flex;flex-direction:column;align-items:center;gap:8px;padding:15px;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-radius:6px;cursor:pointer;transition:border-color .15s ease,background .15s ease;width:100%;text-align:center}.welcome-profile-card:hover{border-color:#7aa2f7;background:#c0caf516}.welcome-profile-card.is-creating{opacity:.6;pointer-events:none}.welcome-profile-card .profile-name{font-size:14px;font-weight:600;color:#c0caf5}.welcome-profile-card .profile-desc{font-size:12px;color:#787c99;line-height:1.4}@media(max-width:768px){.welcome-profile-card{width:auto;padding:10px;gap:6px}.welcome-profile-card .profile-name{font-size:13px}.welcome-profile-card .profile-desc{font-size:11px;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}}.empty-chat{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center}.spinner{display:inline-block;width:14px;height:14px;border:2px solid rgba(192,202,245,.24);border-top-color:#7aa2f7;border-radius:50%;animation:spin .6s linear infinite;flex-shrink:0}@keyframes spin{to{transform:rotate(360deg)}}.fade-enter-active,.fade-leave-active{transition:opacity .15s ease}.fade-enter-from,.fade-leave-to{opacity:0}.msg-enter{animation:msgEnter .2s ease both}@keyframes msgEnter{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.slide-left-enter-active,.slide-left-leave-active{transition:transform .28s ease,opacity .28s ease}.slide-left-enter-from,.slide-left-leave-to{transform:translate(-100%);opacity:0}.modal-enter-active,.modal-leave-active{transition:opacity .28s ease}.modal-enter-active .modal-panel,.modal-leave-active .modal-panel{transition:opacity .28s ease,margin-top .28s ease}.modal-enter-from,.modal-leave-to{opacity:0}.modal-enter-from .modal-panel,.modal-leave-to .modal-panel{opacity:0;margin-top:200px}.tool-card[open]>summary .tool-chevron,.thinking-card[open]>summary .tool-chevron{transform:rotate(180deg)!important}.msg-flash{animation:msgFlash 2.5s ease-out}@keyframes msgFlash{0%{filter:brightness(1)}15%{filter:brightness(1.4);background-color:#7aa2f71f}40%{filter:brightness(1.4);background-color:#7aa2f71f}to{filter:brightness(1)}} diff --git a/webclient/dist/assets/index-CFZ4CERY.js b/webclient/dist/assets/index-CFZ4CERY.js deleted file mode 100644 index 2dbc753..0000000 --- a/webclient/dist/assets/index-CFZ4CERY.js +++ /dev/null @@ -1,119 +0,0 @@ -var db=Object.defineProperty;var _b=(e,t,n)=>t in e?db(e,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[t]=n;var It=(e,t,n)=>_b(e,typeof t!="symbol"?t+"":t,n);(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const r of document.querySelectorAll('link[rel="modulepreload"]'))a(r);new MutationObserver(r=>{for(const i of r)if(i.type==="childList")for(const o of i.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&a(o)}).observe(document,{childList:!0,subtree:!0});function n(r){const i={};return r.integrity&&(i.integrity=r.integrity),r.referrerPolicy&&(i.referrerPolicy=r.referrerPolicy),r.crossOrigin==="use-credentials"?i.credentials="include":r.crossOrigin==="anonymous"?i.credentials="omit":i.credentials="same-origin",i}function a(r){if(r.ep)return;r.ep=!0;const i=n(r);fetch(r.href,i)}})();/** -* @vue/shared v3.5.32 -* (c) 2018-present Yuxi (Evan) You and Vue contributors -* @license MIT -**/function Hu(e){const t=Object.create(null);for(const n of e.split(","))t[n]=1;return n=>n in t}const Dt={},pr=[],Jn=()=>{},kE=()=>!1,Wi=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),Ki=e=>e.startsWith("onUpdate:"),Vt=Object.assign,Vu=(e,t)=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)},pb=Object.prototype.hasOwnProperty,Tt=(e,t)=>pb.call(e,t),Qe=Array.isArray,mr=e=>ni(e)==="[object Map]",Cr=e=>ni(e)==="[object Set]",Ad=e=>ni(e)==="[object Date]",rt=e=>typeof e=="function",Ft=e=>typeof e=="string",On=e=>typeof e=="symbol",ht=e=>e!==null&&typeof e=="object",UE=e=>(ht(e)||rt(e))&&rt(e.then)&&rt(e.catch),FE=Object.prototype.toString,ni=e=>FE.call(e),mb=e=>ni(e).slice(8,-1),BE=e=>ni(e)==="[object Object]",Qi=e=>Ft(e)&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e,Fr=Hu(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),Xi=e=>{const t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},gb=/-\w/g,gn=Xi(e=>e.replace(gb,t=>t.slice(1).toUpperCase())),Eb=/\B([A-Z])/g,Da=Xi(e=>e.replace(Eb,"-$1").toLowerCase()),Zi=Xi(e=>e.charAt(0).toUpperCase()+e.slice(1)),Ri=Xi(e=>e?`on${Zi(e)}`:""),Qn=(e,t)=>!Object.is(e,t),Ci=(e,...t)=>{for(let n=0;n{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:a,value:n})},Ji=e=>{const t=parseFloat(e);return isNaN(t)?e:t},fb=e=>{const t=Ft(e)?Number(e):NaN;return isNaN(t)?e:t};let Id;const ji=()=>Id||(Id=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{});function jn(e){if(Qe(e)){const t={};for(let n=0;n{if(n){const a=n.split(bb);a.length>1&&(t[a[0].trim()]=a[1].trim())}}),t}function He(e){let t="";if(Ft(e))t=e;else if(Qe(e))for(let n=0;nOa(n,t))}const $E=e=>!!(e&&e.__v_isRef===!0),ie=e=>Ft(e)?e:e==null?"":Qe(e)||ht(e)&&(e.toString===FE||!rt(e.toString))?$E(e)?ie(e.value):JSON.stringify(e,qE,2):String(e),qE=(e,t)=>$E(t)?qE(e,t.value):mr(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((n,[a,r],i)=>(n[fo(a,i)+" =>"]=r,n),{})}:Cr(t)?{[`Set(${t.size})`]:[...t.values()].map(n=>fo(n))}:On(t)?fo(t):ht(t)&&!Qe(t)&&!BE(t)?String(t):t,fo=(e,t="")=>{var n;return On(e)?`Symbol(${(n=e.description)!=null?n:t})`:e};/** -* @vue/reactivity v3.5.32 -* (c) 2018-present Yuxi (Evan) You and Vue contributors -* @license MIT -**/let tn;class HE{constructor(t=!1){this.detached=t,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this.__v_skip=!0,this.parent=tn,!t&&tn&&(this.index=(tn.scopes||(tn.scopes=[])).push(this)-1)}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let t,n;if(this.scopes)for(t=0,n=this.scopes.length;t0&&--this._on===0&&(tn=this.prevScope,this.prevScope=void 0)}stop(t){if(this._active){this._active=!1;let n,a;for(n=0,a=this.effects.length;n0)return;if(Gr){let t=Gr;for(Gr=void 0;t;){const n=t.next;t.next=void 0,t.flags&=-9,t=n}}let e;for(;Br;){let t=Br;for(Br=void 0;t;){const n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(a){e||(e=a)}t=n}}if(e)throw e}function QE(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function XE(e){let t,n=e.depsTail,a=n;for(;a;){const r=a.prevDep;a.version===-1?(a===n&&(n=r),Xu(a),Ob(a)):t=a,a.dep.activeLink=a.prevActiveLink,a.prevActiveLink=void 0,a=r}e.deps=t,e.depsTail=n}function Su(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(ZE(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function ZE(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===Wr)||(e.globalVersion=Wr,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Su(e))))return;e.flags|=2;const t=e.dep,n=Lt,a=Pn;Lt=e,Pn=!0;try{QE(e);const r=e.fn(e._value);(t.version===0||Qn(r,e._value))&&(e.flags|=128,e._value=r,t.version++)}catch(r){throw t.version++,r}finally{Lt=n,Pn=a,XE(e),e.flags&=-3}}function Xu(e,t=!1){const{dep:n,prevSub:a,nextSub:r}=e;if(a&&(a.nextSub=r,e.prevSub=void 0),r&&(r.prevSub=a,e.nextSub=void 0),n.subs===e&&(n.subs=a,!a&&n.computed)){n.computed.flags&=-5;for(let i=n.computed.deps;i;i=i.nextDep)Xu(i,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ob(e){const{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}let Pn=!0;const JE=[];function pa(){JE.push(Pn),Pn=!1}function ma(){const e=JE.pop();Pn=e===void 0?!0:e}function Dd(e){const{cleanup:t}=e;if(e.cleanup=void 0,t){const n=Lt;Lt=void 0;try{t()}finally{Lt=n}}}let Wr=0;class Ab{constructor(t,n){this.sub=t,this.dep=n,this.version=n.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}}class Zu{constructor(t){this.computed=t,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(t){if(!Lt||!Pn||Lt===this.computed)return;let n=this.activeLink;if(n===void 0||n.sub!==Lt)n=this.activeLink=new Ab(Lt,this),Lt.deps?(n.prevDep=Lt.depsTail,Lt.depsTail.nextDep=n,Lt.depsTail=n):Lt.deps=Lt.depsTail=n,jE(n);else if(n.version===-1&&(n.version=this.version,n.nextDep)){const a=n.nextDep;a.prevDep=n.prevDep,n.prevDep&&(n.prevDep.nextDep=a),n.prevDep=Lt.depsTail,n.nextDep=void 0,Lt.depsTail.nextDep=n,Lt.depsTail=n,Lt.deps===n&&(Lt.deps=a)}return n}trigger(t){this.version++,Wr++,this.notify(t)}notify(t){Ku();try{for(let n=this.subs;n;n=n.prevSub)n.sub.notify()&&n.sub.dep.notify()}finally{Qu()}}}function jE(e){if(e.dep.sc++,e.sub.flags&4){const t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let a=t.deps;a;a=a.nextDep)jE(a)}const n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}const Ii=new WeakMap,Qa=Symbol(""),bu=Symbol(""),Kr=Symbol("");function nn(e,t,n){if(Pn&&Lt){let a=Ii.get(e);a||Ii.set(e,a=new Map);let r=a.get(n);r||(a.set(n,r=new Zu),r.map=a,r.key=n),r.track()}}function oa(e,t,n,a,r,i){const o=Ii.get(e);if(!o){Wr++;return}const s=l=>{l&&l.trigger()};if(Ku(),t==="clear")o.forEach(s);else{const l=Qe(e),c=l&&Qi(n);if(l&&n==="length"){const u=Number(a);o.forEach((d,_)=>{(_==="length"||_===Kr||!On(_)&&_>=u)&&s(d)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),c&&s(o.get(Kr)),t){case"add":l?c&&s(o.get("length")):(s(o.get(Qa)),mr(e)&&s(o.get(bu)));break;case"delete":l||(s(o.get(Qa)),mr(e)&&s(o.get(bu)));break;case"set":mr(e)&&s(o.get(Qa));break}}Qu()}function Ib(e,t){const n=Ii.get(e);return n&&n.get(t)}function sr(e){const t=dt(e);return t===e?t:(nn(t,"iterate",Kr),Nn(e)?t:t.map(kn))}function eo(e){return nn(e=dt(e),"iterate",Kr),e}function Wn(e,t){return ga(e)?br(da(e)?kn(t):t):kn(t)}const Db={__proto__:null,[Symbol.iterator](){return bo(this,Symbol.iterator,e=>Wn(this,e))},concat(...e){return sr(this).concat(...e.map(t=>Qe(t)?sr(t):t))},entries(){return bo(this,"entries",e=>(e[1]=Wn(this,e[1]),e))},every(e,t){return aa(this,"every",e,t,void 0,arguments)},filter(e,t){return aa(this,"filter",e,t,n=>n.map(a=>Wn(this,a)),arguments)},find(e,t){return aa(this,"find",e,t,n=>Wn(this,n),arguments)},findIndex(e,t){return aa(this,"findIndex",e,t,void 0,arguments)},findLast(e,t){return aa(this,"findLast",e,t,n=>Wn(this,n),arguments)},findLastIndex(e,t){return aa(this,"findLastIndex",e,t,void 0,arguments)},forEach(e,t){return aa(this,"forEach",e,t,void 0,arguments)},includes(...e){return To(this,"includes",e)},indexOf(...e){return To(this,"indexOf",e)},join(e){return sr(this).join(e)},lastIndexOf(...e){return To(this,"lastIndexOf",e)},map(e,t){return aa(this,"map",e,t,void 0,arguments)},pop(){return Nr(this,"pop")},push(...e){return Nr(this,"push",e)},reduce(e,...t){return xd(this,"reduce",e,t)},reduceRight(e,...t){return xd(this,"reduceRight",e,t)},shift(){return Nr(this,"shift")},some(e,t){return aa(this,"some",e,t,void 0,arguments)},splice(...e){return Nr(this,"splice",e)},toReversed(){return sr(this).toReversed()},toSorted(e){return sr(this).toSorted(e)},toSpliced(...e){return sr(this).toSpliced(...e)},unshift(...e){return Nr(this,"unshift",e)},values(){return bo(this,"values",e=>Wn(this,e))}};function bo(e,t,n){const a=eo(e),r=a[t]();return a!==e&&!Nn(e)&&(r._next=r.next,r.next=()=>{const i=r._next();return i.done||(i.value=n(i.value)),i}),r}const xb=Array.prototype;function aa(e,t,n,a,r,i){const o=eo(e),s=o!==e&&!Nn(e),l=o[t];if(l!==xb[t]){const d=l.apply(e,i);return s?kn(d):d}let c=n;o!==e&&(s?c=function(d,_){return n.call(this,Wn(e,d),_,e)}:n.length>2&&(c=function(d,_){return n.call(this,d,_,e)}));const u=l.call(o,c,a);return s&&r?r(u):u}function xd(e,t,n,a){const r=eo(e),i=r!==e&&!Nn(e);let o=n,s=!1;r!==e&&(i?(s=a.length===0,o=function(c,u,d){return s&&(s=!1,c=Wn(e,c)),n.call(this,c,Wn(e,u),d,e)}):n.length>3&&(o=function(c,u,d){return n.call(this,c,u,d,e)}));const l=r[t](o,...a);return s?Wn(e,l):l}function To(e,t,n){const a=dt(e);nn(a,"iterate",Kr);const r=a[t](...n);return(r===-1||r===!1)&&to(n[0])?(n[0]=dt(n[0]),a[t](...n)):r}function Nr(e,t,n=[]){pa(),Ku();const a=dt(e)[t].apply(e,n);return Qu(),ma(),a}const Mb=Hu("__proto__,__v_isRef,__isVue"),ef=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!=="arguments"&&e!=="caller").map(e=>Symbol[e]).filter(On));function wb(e){On(e)||(e=String(e));const t=dt(this);return nn(t,"has",e),t.hasOwnProperty(e)}class tf{constructor(t=!1,n=!1){this._isReadonly=t,this._isShallow=n}get(t,n,a){if(n==="__v_skip")return t.__v_skip;const r=this._isReadonly,i=this._isShallow;if(n==="__v_isReactive")return!r;if(n==="__v_isReadonly")return r;if(n==="__v_isShallow")return i;if(n==="__v_raw")return a===(r?i?qb:of:i?rf:af).get(t)||Object.getPrototypeOf(t)===Object.getPrototypeOf(a)?t:void 0;const o=Qe(t);if(!r){let l;if(o&&(l=Db[n]))return l;if(n==="hasOwnProperty")return wb}const s=Reflect.get(t,n,Gt(t)?t:a);if((On(n)?ef.has(n):Mb(n))||(r||nn(t,"get",n),i))return s;if(Gt(s)){const l=o&&Qi(n)?s:s.value;return r&&ht(l)?hu(l):l}return ht(s)?r?hu(s):ja(s):s}}class nf extends tf{constructor(t=!1){super(!1,t)}set(t,n,a,r){let i=t[n];const o=Qe(t)&&Qi(n);if(!this._isShallow){const c=ga(i);if(!Nn(a)&&!ga(a)&&(i=dt(i),a=dt(a)),!o&&Gt(i)&&!Gt(a))return c||(i.value=a),!0}const s=o?Number(n)e,mi=e=>Reflect.getPrototypeOf(e);function Fb(e,t,n){return function(...a){const r=this.__v_raw,i=dt(r),o=mr(i),s=e==="entries"||e===Symbol.iterator&&o,l=e==="keys"&&o,c=r[e](...a),u=n?Tu:t?br:kn;return!t&&nn(i,"iterate",l?bu:Qa),Vt(Object.create(c),{next(){const{value:d,done:_}=c.next();return _?{value:d,done:_}:{value:s?[u(d[0]),u(d[1])]:u(d),done:_}}})}}function gi(e){return function(...t){return e==="delete"?!1:e==="clear"?void 0:this}}function Bb(e,t){const n={get(r){const i=this.__v_raw,o=dt(i),s=dt(r);e||(Qn(r,s)&&nn(o,"get",r),nn(o,"get",s));const{has:l}=mi(o),c=t?Tu:e?br:kn;if(l.call(o,r))return c(i.get(r));if(l.call(o,s))return c(i.get(s));i!==o&&i.get(r)},get size(){const r=this.__v_raw;return!e&&nn(dt(r),"iterate",Qa),r.size},has(r){const i=this.__v_raw,o=dt(i),s=dt(r);return e||(Qn(r,s)&&nn(o,"has",r),nn(o,"has",s)),r===s?i.has(r):i.has(r)||i.has(s)},forEach(r,i){const o=this,s=o.__v_raw,l=dt(s),c=t?Tu:e?br:kn;return!e&&nn(l,"iterate",Qa),s.forEach((u,d)=>r.call(i,c(u),c(d),o))}};return Vt(n,e?{add:gi("add"),set:gi("set"),delete:gi("delete"),clear:gi("clear")}:{add(r){const i=dt(this),o=mi(i),s=dt(r),l=!t&&!Nn(r)&&!ga(r)?s:r;return o.has.call(i,l)||Qn(r,l)&&o.has.call(i,r)||Qn(s,l)&&o.has.call(i,s)||(i.add(l),oa(i,"add",l,l)),this},set(r,i){!t&&!Nn(i)&&!ga(i)&&(i=dt(i));const o=dt(this),{has:s,get:l}=mi(o);let c=s.call(o,r);c||(r=dt(r),c=s.call(o,r));const u=l.call(o,r);return o.set(r,i),c?Qn(i,u)&&oa(o,"set",r,i):oa(o,"add",r,i),this},delete(r){const i=dt(this),{has:o,get:s}=mi(i);let l=o.call(i,r);l||(r=dt(r),l=o.call(i,r)),s&&s.call(i,r);const c=i.delete(r);return l&&oa(i,"delete",r,void 0),c},clear(){const r=dt(this),i=r.size!==0,o=r.clear();return i&&oa(r,"clear",void 0,void 0),o}}),["keys","values","entries",Symbol.iterator].forEach(r=>{n[r]=Fb(r,e,t)}),n}function Ju(e,t){const n=Bb(e,t);return(a,r,i)=>r==="__v_isReactive"?!e:r==="__v_isReadonly"?e:r==="__v_raw"?a:Reflect.get(Tt(n,r)&&r in a?n:a,r,i)}const Gb={get:Ju(!1,!1)},Yb={get:Ju(!1,!0)},$b={get:Ju(!0,!1)};const af=new WeakMap,rf=new WeakMap,of=new WeakMap,qb=new WeakMap;function Hb(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function Vb(e){return e.__v_skip||!Object.isExtensible(e)?0:Hb(mb(e))}function ja(e){return ga(e)?e:ju(e,!1,Pb,Gb,af)}function sf(e){return ju(e,!1,Ub,Yb,rf)}function hu(e){return ju(e,!0,kb,$b,of)}function ju(e,t,n,a,r){if(!ht(e)||e.__v_raw&&!(t&&e.__v_isReactive))return e;const i=Vb(e);if(i===0)return e;const o=r.get(e);if(o)return o;const s=new Proxy(e,i===2?a:n);return r.set(e,s),s}function da(e){return ga(e)?da(e.__v_raw):!!(e&&e.__v_isReactive)}function ga(e){return!!(e&&e.__v_isReadonly)}function Nn(e){return!!(e&&e.__v_isShallow)}function to(e){return e?!!e.__v_raw:!1}function dt(e){const t=e&&e.__v_raw;return t?dt(t):e}function Sr(e){return!Tt(e,"__v_skip")&&Object.isExtensible(e)&&GE(e,"__v_skip",!0),e}const kn=e=>ht(e)?ja(e):e,br=e=>ht(e)?hu(e):e;function Gt(e){return e?e.__v_isRef===!0:!1}function j(e){return lf(e,!1)}function _r(e){return lf(e,!0)}function lf(e,t){return Gt(e)?e:new zb(e,t)}class zb{constructor(t,n){this.dep=new Zu,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=n?t:dt(t),this._value=n?t:kn(t),this.__v_isShallow=n}get value(){return this.dep.track(),this._value}set value(t){const n=this._rawValue,a=this.__v_isShallow||Nn(t)||ga(t);t=a?t:dt(t),Qn(t,n)&&(this._rawValue=t,this._value=a?t:kn(t),this.dep.trigger())}}function J(e){return Gt(e)?e.value:e}function De(e){return rt(e)?e():J(e)}const Wb={get:(e,t,n)=>t==="__v_raw"?e:J(Reflect.get(e,t,n)),set:(e,t,n,a)=>{const r=e[t];return Gt(r)&&!Gt(n)?(r.value=n,!0):Reflect.set(e,t,n,a)}};function cf(e){return da(e)?e:new Proxy(e,Wb)}function Kb(e){const t=Qe(e)?new Array(e.length):{};for(const n in e)t[n]=Xb(e,n);return t}class Qb{constructor(t,n,a){this._object=t,this._defaultValue=a,this.__v_isRef=!0,this._value=void 0,this._key=On(n)?n:String(n),this._raw=dt(t);let r=!0,i=t;if(!Qe(t)||On(this._key)||!Qi(this._key))do r=!to(i)||Nn(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let t=this._object[this._key];return this._shallow&&(t=J(t)),this._value=t===void 0?this._defaultValue:t}set value(t){if(this._shallow&&Gt(this._raw[this._key])){const n=this._object[this._key];if(Gt(n)){n.value=t;return}}this._object[this._key]=t}get dep(){return Ib(this._raw,this._key)}}function Xb(e,t,n){return new Qb(e,t,n)}class Zb{constructor(t,n,a){this.fn=t,this.setter=n,this._value=void 0,this.dep=new Zu(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=Wr-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!n,this.isSSR=a}notify(){if(this.flags|=16,!(this.flags&8)&&Lt!==this)return KE(this,!0),!0}get value(){const t=this.dep.track();return ZE(this),t&&(t.version=this.dep.version),this._value}set value(t){this.setter&&this.setter(t)}}function Jb(e,t,n=!1){let a,r;return rt(e)?a=e:(a=e.get,r=e.set),new Zb(a,r,n)}const Ei={},Di=new WeakMap;let $a;function jb(e,t=!1,n=$a){if(n){let a=Di.get(n);a||Di.set(n,a=[]),a.push(e)}}function eT(e,t,n=Dt){const{immediate:a,deep:r,once:i,scheduler:o,augmentJob:s,call:l}=n,c=w=>r?w:Nn(w)||r===!1||r===0?sa(w,1):sa(w);let u,d,_,m,p=!1,g=!1;if(Gt(e)?(d=()=>e.value,p=Nn(e)):da(e)?(d=()=>c(e),p=!0):Qe(e)?(g=!0,p=e.some(w=>da(w)||Nn(w)),d=()=>e.map(w=>{if(Gt(w))return w.value;if(da(w))return c(w);if(rt(w))return l?l(w,2):w()})):rt(e)?t?d=l?()=>l(e,2):e:d=()=>{if(_){pa();try{_()}finally{ma()}}const w=$a;$a=u;try{return l?l(e,3,[m]):e(m)}finally{$a=w}}:d=Jn,t&&r){const w=d,v=r===!0?1/0:r;d=()=>sa(w(),v)}const b=VE(),A=()=>{u.stop(),b&&b.active&&Vu(b.effects,u)};if(i&&t){const w=t;t=(...v)=>{w(...v),A()}}let O=g?new Array(e.length).fill(Ei):Ei;const M=w=>{if(!(!(u.flags&1)||!u.dirty&&!w))if(t){const v=u.run();if(r||p||(g?v.some((T,I)=>Qn(T,O[I])):Qn(v,O))){_&&_();const T=$a;$a=u;try{const I=[v,O===Ei?void 0:g&&O[0]===Ei?[]:O,m];O=v,l?l(t,3,I):t(...I)}finally{$a=T}}}else u.run()};return s&&s(M),u=new zE(d),u.scheduler=o?()=>o(M,!1):M,m=w=>jb(w,!1,u),_=u.onStop=()=>{const w=Di.get(u);if(w){if(l)l(w,4);else for(const v of w)v();Di.delete(u)}},t?a?M(!0):O=u.run():o?o(M.bind(null,!0),!0):u.run(),A.pause=u.pause.bind(u),A.resume=u.resume.bind(u),A.stop=A,A}function sa(e,t=1/0,n){if(t<=0||!ht(e)||e.__v_skip||(n=n||new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,Gt(e))sa(e.value,t,n);else if(Qe(e))for(let a=0;a{sa(a,t,n)});else if(BE(e)){for(const a in e)sa(e[a],t,n);for(const a of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,a)&&sa(e[a],t,n)}return e}/** -* @vue/runtime-core v3.5.32 -* (c) 2018-present Yuxi (Evan) You and Vue contributors -* @license MIT -**/function ai(e,t,n,a){try{return a?e(...a):e()}catch(r){no(r,t,n)}}function Un(e,t,n,a){if(rt(e)){const r=ai(e,t,n,a);return r&&UE(r)&&r.catch(i=>{no(i,t,n)}),r}if(Qe(e)){const r=[];for(let i=0;i>>1,r=pn[a],i=Qr(r);i=Qr(n)?pn.push(e):pn.splice(nT(t),0,e),e.flags|=1,df()}}function df(){xi||(xi=uf.then(pf))}function aT(e){Qe(e)?gr.push(...e):Na&&e.id===-1?Na.splice(cr+1,0,e):e.flags&1||(gr.push(e),e.flags|=1),df()}function Md(e,t,n=Vn+1){for(;nQr(n)-Qr(a));if(gr.length=0,Na){Na.push(...t);return}for(Na=t,cr=0;cre.id==null?e.flags&2?-1:1/0:e.id;function pf(e){try{for(Vn=0;Vn{a._d&&Pi(-1);const i=Mi(t);let o;try{o=e(...r)}finally{Mi(i),a._d&&Pi(1)}return o};return a._n=!0,a._c=!0,a._d=!0,a}function Ha(e,t){if(Jt===null)return e;const n=lo(Jt),a=e.dirs||(e.dirs=[]);for(let r=0;r1)return n&&rt(t)?t.call(a&&a.proxy):t}}function rT(){return!!(so()||Xa)}const iT=Symbol.for("v-scx"),oT=()=>_a(iT);function sT(e,t){return td(e,null,t)}function je(e,t,n){return td(e,t,n)}function td(e,t,n=Dt){const{immediate:a,deep:r,flush:i,once:o}=n,s=Vt({},n),l=t&&a||!t&&i!=="post";let c;if(jr){if(i==="sync"){const m=oT();c=m.__watcherHandles||(m.__watcherHandles=[])}else if(!l){const m=()=>{};return m.stop=Jn,m.resume=Jn,m.pause=Jn,m}}const u=rn;s.call=(m,p,g)=>Un(m,u,p,g);let d=!1;i==="post"?s.scheduler=m=>{_n(m,u&&u.suspense)}:i!=="sync"&&(d=!0,s.scheduler=(m,p)=>{p?m():ed(m)}),s.augmentJob=m=>{t&&(m.flags|=4),d&&(m.flags|=2,u&&(m.id=u.uid,m.i=u))};const _=eT(e,t,s);return jr&&(c?c.push(_):l&&_()),_}function lT(e,t,n){const a=this.proxy,r=Ft(e)?e.includes(".")?gf(a,e):()=>a[e]:e.bind(a,a);let i;rt(t)?i=t:(i=t.handler,n=t);const o=oi(this),s=td(r,i.bind(a),n);return o(),s}function gf(e,t){const n=t.split(".");return()=>{let a=e;for(let r=0;re.__isTeleport,za=e=>e&&(e.disabled||e.disabled===""),cT=e=>e&&(e.defer||e.defer===""),wd=e=>typeof SVGElement<"u"&&e instanceof SVGElement,Ld=e=>typeof MathMLElement=="function"&&e instanceof MathMLElement,vu=(e,t)=>{const n=e&&e.to;return Ft(n)?t?t(n):null:n},uT={name:"Teleport",__isTeleport:!0,process(e,t,n,a,r,i,o,s,l,c){const{mc:u,pc:d,pbc:_,o:{insert:m,querySelector:p,createText:g,createComment:b}}=c,A=za(t.props);let{dynamicChildren:O}=t;const M=(T,I,h)=>{T.shapeFlag&16&&u(T.children,I,h,r,i,o,s,l)},w=(T=t)=>{const I=za(T.props),h=T.target=vu(T.props,p),E=Ru(h,T,g,m);h&&(o!=="svg"&&wd(h)?o="svg":o!=="mathml"&&Ld(h)&&(o="mathml"),r&&r.isCE&&(r.ce._teleportTargets||(r.ce._teleportTargets=new Set)).add(h),I||(M(T,h,E),Lr(T,!1)))},v=T=>{const I=()=>{Fa.get(T)===I&&(Fa.delete(T),za(T.props)&&(M(T,n,T.anchor),Lr(T,!0)),w(T))};Fa.set(T,I),_n(I,i)};if(e==null){const T=t.el=g(""),I=t.anchor=g("");if(m(T,n,a),m(I,n,a),cT(t.props)||i&&i.pendingBranch){v(t);return}A&&(M(t,n,I),Lr(t,!0)),w()}else{t.el=e.el;const T=t.anchor=e.anchor,I=Fa.get(e);if(I){I.flags|=8,Fa.delete(e),v(t);return}t.targetStart=e.targetStart;const h=t.target=e.target,E=t.targetAnchor=e.targetAnchor,D=za(e.props),x=D?n:h,L=D?T:E;if(o==="svg"||wd(h)?o="svg":(o==="mathml"||Ld(h))&&(o="mathml"),O?(_(e.dynamicChildren,O,x,r,i,o,s),od(e,t,!0)):l||d(e,t,x,L,r,i,o,s,!1),A)D?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):fi(t,n,T,c,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){const ae=t.target=vu(t.props,p);ae&&fi(t,ae,null,c,0)}else D&&fi(t,h,E,c,1);Lr(t,A)}},remove(e,t,n,{um:a,o:{remove:r}},i){const{shapeFlag:o,children:s,anchor:l,targetStart:c,targetAnchor:u,target:d,props:_}=e;let m=i||!za(_);const p=Fa.get(e);if(p&&(p.flags|=8,Fa.delete(e),m=!1),d&&(r(c),r(u)),i&&r(l),o&16)for(let g=0;g{e.isMounted=!0}),Tn(()=>{e.isUnmounting=!0}),e}const Dn=[Function,Array],bf={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Dn,onEnter:Dn,onAfterEnter:Dn,onEnterCancelled:Dn,onBeforeLeave:Dn,onLeave:Dn,onAfterLeave:Dn,onLeaveCancelled:Dn,onBeforeAppear:Dn,onAppear:Dn,onAfterAppear:Dn,onAppearCancelled:Dn},Tf=e=>{const t=e.subTree;return t.component?Tf(t.component):t},_T={name:"BaseTransition",props:bf,setup(e,{slots:t}){const n=so(),a=Sf();return()=>{const r=t.default&&nd(t.default(),!0);if(!r||!r.length)return;const i=hf(r),o=dt(e),{mode:s}=o;if(a.isLeaving)return ho(i);const l=Pd(i);if(!l)return ho(i);let c=Xr(l,o,a,n,d=>c=d);l.type!==an&&er(l,c);let u=n.subTree&&Pd(n.subTree);if(u&&u.type!==an&&!Wa(u,l)&&Tf(n).type!==an){let d=Xr(u,o,a,n);if(er(u,d),s==="out-in"&&l.type!==an)return a.isLeaving=!0,d.afterLeave=()=>{a.isLeaving=!1,n.job.flags&8||n.update(),delete d.afterLeave,u=void 0},ho(i);s==="in-out"&&l.type!==an?d.delayLeave=(_,m,p)=>{const g=vf(a,u);g[String(u.key)]=u,_[zn]=()=>{m(),_[zn]=void 0,delete c.delayedLeave,u=void 0},c.delayedLeave=()=>{p(),delete c.delayedLeave,u=void 0}}:u=void 0}else u&&(u=void 0);return i}}};function hf(e){let t=e[0];if(e.length>1){for(const n of e)if(n.type!==an){t=n;break}}return t}const pT=_T;function vf(e,t){const{leavingVNodes:n}=e;let a=n.get(t.type);return a||(a=Object.create(null),n.set(t.type,a)),a}function Xr(e,t,n,a,r){const{appear:i,mode:o,persisted:s=!1,onBeforeEnter:l,onEnter:c,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:_,onLeave:m,onAfterLeave:p,onLeaveCancelled:g,onBeforeAppear:b,onAppear:A,onAfterAppear:O,onAppearCancelled:M}=t,w=String(e.key),v=vf(n,e),T=(E,D)=>{E&&Un(E,a,9,D)},I=(E,D)=>{const x=D[1];T(E,D),Qe(E)?E.every(L=>L.length<=1)&&x():E.length<=1&&x()},h={mode:o,persisted:s,beforeEnter(E){let D=l;if(!n.isMounted)if(i)D=b||l;else return;E[zn]&&E[zn](!0);const x=v[w];x&&Wa(e,x)&&x.el[zn]&&x.el[zn](),T(D,[E])},enter(E){if(v[w]===e)return;let D=c,x=u,L=d;if(!n.isMounted)if(i)D=A||c,x=O||u,L=M||d;else return;let ae=!1;E[Or]=xe=>{ae||(ae=!0,xe?T(L,[E]):T(x,[E]),h.delayedLeave&&h.delayedLeave(),E[Or]=void 0)};const Ee=E[Or].bind(null,!1);D?I(D,[E,Ee]):Ee()},leave(E,D){const x=String(e.key);if(E[Or]&&E[Or](!0),n.isUnmounting)return D();T(_,[E]);let L=!1;E[zn]=Ee=>{L||(L=!0,D(),Ee?T(g,[E]):T(p,[E]),E[zn]=void 0,v[x]===e&&delete v[x])};const ae=E[zn].bind(null,!1);v[x]=e,m?I(m,[E,ae]):ae()},clone(E){const D=Xr(E,t,n,a,r);return r&&r(D),D}};return h}function ho(e){if(ao(e))return e=Aa(e),e.children=null,e}function Pd(e){if(!ao(e))return ff(e.type)&&e.children?hf(e.children):e;if(e.component)return e.component.subTree;const{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&rt(n.default))return n.default()}}function er(e,t){e.shapeFlag&6&&e.component?(e.transition=t,er(e.component.subTree,t)):e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function nd(e,t=!1,n){let a=[],r=0;for(let i=0;i1)for(let i=0;iYr(g,t&&(Qe(t)?t[b]:t),n,a,r));return}if(Er(a)&&!r){a.shapeFlag&512&&a.type.__asyncResolved&&a.component.subTree.component&&Yr(e,t,n,a.component.subTree);return}const i=a.shapeFlag&4?lo(a.component):a.el,o=r?null:i,{i:s,r:l}=e,c=t&&t.r,u=s.refs===Dt?s.refs={}:s.refs,d=s.setupState,_=dt(d),m=d===Dt?kE:g=>kd(u,g)?!1:Tt(_,g),p=(g,b)=>!(b&&kd(u,b));if(c!=null&&c!==l){if(Ud(t),Ft(c))u[c]=null,m(c)&&(d[c]=null);else if(Gt(c)){const g=t;p(c,g.k)&&(c.value=null),g.k&&(u[g.k]=null)}}if(rt(l))ai(l,s,12,[o,u]);else{const g=Ft(l),b=Gt(l);if(g||b){const A=()=>{if(e.f){const O=g?m(l)?d[l]:u[l]:p()||!e.k?l.value:u[e.k];if(r)Qe(O)&&Vu(O,i);else if(Qe(O))O.includes(i)||O.push(i);else if(g)u[l]=[i],m(l)&&(d[l]=u[l]);else{const M=[i];p(l,e.k)&&(l.value=M),e.k&&(u[e.k]=M)}}else g?(u[l]=o,m(l)&&(d[l]=o)):b&&(p(l,e.k)&&(l.value=o),e.k&&(u[e.k]=o))};if(o){const O=()=>{A(),wi.delete(e)};O.id=-1,wi.set(e,O),_n(O,n)}else Ud(e),A()}}}function Ud(e){const t=wi.get(e);t&&(t.flags|=8,wi.delete(e))}ji().requestIdleCallback;ji().cancelIdleCallback;const Er=e=>!!e.type.__asyncLoader,ao=e=>e.type.__isKeepAlive;function ad(e,t){yf(e,"a",t)}function Cf(e,t){yf(e,"da",t)}function yf(e,t,n=rn){const a=e.__wdc||(e.__wdc=()=>{let r=n;for(;r;){if(r.isDeactivated)return;r=r.parent}return e()});if(ro(t,a,n),n){let r=n.parent;for(;r&&r.parent;)ao(r.parent.vnode)&&mT(a,t,n,r),r=r.parent}}function mT(e,t,n,a){const r=ro(t,e,a,!0);ea(()=>{Vu(a[t],r)},n)}function ro(e,t,n=rn,a=!1){if(n){const r=n[e]||(n[e]=[]),i=t.__weh||(t.__weh=(...o)=>{pa();const s=oi(n),l=Un(t,n,e,o);return s(),ma(),l});return a?r.unshift(i):r.push(i),i}}const Ea=e=>(t,n=rn)=>{(!jr||e==="sp")&&ro(e,(...a)=>t(...a),n)},gT=Ea("bm"),En=Ea("m"),ET=Ea("bu"),Nf=Ea("u"),Tn=Ea("bum"),ea=Ea("um"),fT=Ea("sp"),ST=Ea("rtg"),bT=Ea("rtc");function TT(e,t=rn){ro("ec",e,t)}const Of="components";function xt(e,t){return If(Of,e,!0,t)||e}const Af=Symbol.for("v-ndc");function ii(e){return Ft(e)?If(Of,e,!1)||e:e||Af}function If(e,t,n=!0,a=!1){const r=Jt||rn;if(r){const i=r.type;{const s=rh(i,!1);if(s&&(s===t||s===gn(t)||s===Zi(gn(t))))return i}const o=Fd(r[e]||i[e],t)||Fd(r.appContext[e],t);return!o&&a?i:o}}function Fd(e,t){return e&&(e[t]||e[gn(t)]||e[Zi(gn(t))])}function Ut(e,t,n,a){let r;const i=n,o=Qe(e);if(o||Ft(e)){const s=o&&da(e);let l=!1,c=!1;s&&(l=!Nn(e),c=ga(e),e=eo(e)),r=new Array(e.length);for(let u=0,d=e.length;ut(s,l,void 0,i));else{const s=Object.keys(e);r=new Array(s.length);for(let l=0,c=s.length;l{const i=a.fn(...r);return i&&(i.key=a.key),i}:a.fn)}return e}function Xn(e,t,n={},a,r){if(Jt.ce||Jt.parent&&Er(Jt.parent)&&Jt.parent.ce){const c=Object.keys(n).length>0;return t!=="default"&&(n.name=t),N(),ut(Ze,null,[we("slot",n,a)],c?-2:64)}let i=e[t];i&&i._c&&(i._d=!1),N();const o=i&&Df(i(n)),s=n.key||o&&o.key,l=ut(Ze,{key:(s&&!On(s)?s:`_${t}`)+(!o&&a?"_fb":"")},o||[],o&&e._===1?64:-2);return l.scopeId&&(l.slotScopeIds=[l.scopeId+"-s"]),i&&i._c&&(i._d=!0),l}function Df(e){return e.some(t=>Jr(t)?!(t.type===an||t.type===Ze&&!Df(t.children)):!0)?e:null}function vT(e,t){const n={};for(const a in e)n[Ri(a)]=e[a];return n}const Cu=e=>e?Zf(e)?lo(e):Cu(e.parent):null,$r=Vt(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>Cu(e.parent),$root:e=>Cu(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Mf(e),$forceUpdate:e=>e.f||(e.f=()=>{ed(e.update)}),$nextTick:e=>e.n||(e.n=Ht.bind(e.proxy)),$watch:e=>lT.bind(e)}),vo=(e,t)=>e!==Dt&&!e.__isScriptSetup&&Tt(e,t),RT={get({_:e},t){if(t==="__v_skip")return!0;const{ctx:n,setupState:a,data:r,props:i,accessCache:o,type:s,appContext:l}=e;if(t[0]!=="$"){const _=o[t];if(_!==void 0)switch(_){case 1:return a[t];case 2:return r[t];case 4:return n[t];case 3:return i[t]}else{if(vo(a,t))return o[t]=1,a[t];if(r!==Dt&&Tt(r,t))return o[t]=2,r[t];if(Tt(i,t))return o[t]=3,i[t];if(n!==Dt&&Tt(n,t))return o[t]=4,n[t];yu&&(o[t]=0)}}const c=$r[t];let u,d;if(c)return t==="$attrs"&&nn(e.attrs,"get",""),c(e);if((u=s.__cssModules)&&(u=u[t]))return u;if(n!==Dt&&Tt(n,t))return o[t]=4,n[t];if(d=l.config.globalProperties,Tt(d,t))return d[t]},set({_:e},t,n){const{data:a,setupState:r,ctx:i}=e;return vo(r,t)?(r[t]=n,!0):a!==Dt&&Tt(a,t)?(a[t]=n,!0):Tt(e.props,t)||t[0]==="$"&&t.slice(1)in e?!1:(i[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:a,appContext:r,props:i,type:o}},s){let l;return!!(n[s]||e!==Dt&&s[0]!=="$"&&Tt(e,s)||vo(t,s)||Tt(i,s)||Tt(a,s)||Tt($r,s)||Tt(r.config.globalProperties,s)||(l=o.__cssModules)&&l[s])},defineProperty(e,t,n){return n.get!=null?e._.accessCache[t]=0:Tt(n,"value")&&this.set(e,t,n.value,null),Reflect.defineProperty(e,t,n)}};function Bd(e){return Qe(e)?e.reduce((t,n)=>(t[n]=null,t),{}):e}let yu=!0;function CT(e){const t=Mf(e),n=e.proxy,a=e.ctx;yu=!1,t.beforeCreate&&Gd(t.beforeCreate,e,"bc");const{data:r,computed:i,methods:o,watch:s,provide:l,inject:c,created:u,beforeMount:d,mounted:_,beforeUpdate:m,updated:p,activated:g,deactivated:b,beforeDestroy:A,beforeUnmount:O,destroyed:M,unmounted:w,render:v,renderTracked:T,renderTriggered:I,errorCaptured:h,serverPrefetch:E,expose:D,inheritAttrs:x,components:L,directives:ae,filters:Ee}=t;if(c&&yT(c,a,null),o)for(const pe in o){const Le=o[pe];rt(Le)&&(a[pe]=Le.bind(n))}if(r){const pe=r.call(n,n);ht(pe)&&(e.data=ja(pe))}if(yu=!0,i)for(const pe in i){const Le=i[pe],be=rt(Le)?Le.bind(n,n):rt(Le.get)?Le.get.bind(n,n):Jn,Xe=!rt(Le)&&rt(Le.set)?Le.set.bind(n):Jn,et=ge({get:be,set:Xe});Object.defineProperty(a,pe,{enumerable:!0,configurable:!0,get:()=>et.value,set:it=>et.value=it})}if(s)for(const pe in s)xf(s[pe],a,n,pe);if(l){const pe=rt(l)?l.call(n):l;Reflect.ownKeys(pe).forEach(Le=>{Va(Le,pe[Le])})}u&&Gd(u,e,"c");function Se(pe,Le){Qe(Le)?Le.forEach(be=>pe(be.bind(n))):Le&&pe(Le.bind(n))}if(Se(gT,d),Se(En,_),Se(ET,m),Se(Nf,p),Se(ad,g),Se(Cf,b),Se(TT,h),Se(bT,T),Se(ST,I),Se(Tn,O),Se(ea,w),Se(fT,E),Qe(D))if(D.length){const pe=e.exposed||(e.exposed={});D.forEach(Le=>{Object.defineProperty(pe,Le,{get:()=>n[Le],set:be=>n[Le]=be,enumerable:!0})})}else e.exposed||(e.exposed={});v&&e.render===Jn&&(e.render=v),x!=null&&(e.inheritAttrs=x),L&&(e.components=L),ae&&(e.directives=ae),E&&Rf(e)}function yT(e,t,n=Jn){Qe(e)&&(e=Nu(e));for(const a in e){const r=e[a];let i;ht(r)?"default"in r?i=_a(r.from||a,r.default,!0):i=_a(r.from||a):i=_a(r),Gt(i)?Object.defineProperty(t,a,{enumerable:!0,configurable:!0,get:()=>i.value,set:o=>i.value=o}):t[a]=i}}function Gd(e,t,n){Un(Qe(e)?e.map(a=>a.bind(t.proxy)):e.bind(t.proxy),t,n)}function xf(e,t,n,a){let r=a.includes(".")?gf(n,a):()=>n[a];if(Ft(e)){const i=t[e];rt(i)&&je(r,i)}else if(rt(e))je(r,e.bind(n));else if(ht(e))if(Qe(e))e.forEach(i=>xf(i,t,n,a));else{const i=rt(e.handler)?e.handler.bind(n):t[e.handler];rt(i)&&je(r,i,e)}}function Mf(e){const t=e.type,{mixins:n,extends:a}=t,{mixins:r,optionsCache:i,config:{optionMergeStrategies:o}}=e.appContext,s=i.get(t);let l;return s?l=s:!r.length&&!n&&!a?l=t:(l={},r.length&&r.forEach(c=>Li(l,c,o,!0)),Li(l,t,o)),ht(t)&&i.set(t,l),l}function Li(e,t,n,a=!1){const{mixins:r,extends:i}=t;i&&Li(e,i,n,!0),r&&r.forEach(o=>Li(e,o,n,!0));for(const o in t)if(!(a&&o==="expose")){const s=NT[o]||n&&n[o];e[o]=s?s(e[o],t[o]):t[o]}return e}const NT={data:Yd,props:$d,emits:$d,methods:Pr,computed:Pr,beforeCreate:dn,created:dn,beforeMount:dn,mounted:dn,beforeUpdate:dn,updated:dn,beforeDestroy:dn,beforeUnmount:dn,destroyed:dn,unmounted:dn,activated:dn,deactivated:dn,errorCaptured:dn,serverPrefetch:dn,components:Pr,directives:Pr,watch:AT,provide:Yd,inject:OT};function Yd(e,t){return t?e?function(){return Vt(rt(e)?e.call(this,this):e,rt(t)?t.call(this,this):t)}:t:e}function OT(e,t){return Pr(Nu(e),Nu(t))}function Nu(e){if(Qe(e)){const t={};for(let n=0;nt==="modelValue"||t==="model-value"?e.modelModifiers:e[`${t}Modifiers`]||e[`${gn(t)}Modifiers`]||e[`${Da(t)}Modifiers`];function MT(e,t,...n){if(e.isUnmounted)return;const a=e.vnode.props||Dt;let r=n;const i=t.startsWith("update:"),o=i&&xT(a,t.slice(7));o&&(o.trim&&(r=n.map(u=>Ft(u)?u.trim():u)),o.number&&(r=n.map(Ji)));let s,l=a[s=Ri(t)]||a[s=Ri(gn(t))];!l&&i&&(l=a[s=Ri(Da(t))]),l&&Un(l,e,6,r);const c=a[s+"Once"];if(c){if(!e.emitted)e.emitted={};else if(e.emitted[s])return;e.emitted[s]=!0,Un(c,e,6,r)}}const wT=new WeakMap;function Lf(e,t,n=!1){const a=n?wT:t.emitsCache,r=a.get(e);if(r!==void 0)return r;const i=e.emits;let o={},s=!1;if(!rt(e)){const l=c=>{const u=Lf(c,t,!0);u&&(s=!0,Vt(o,u))};!n&&t.mixins.length&&t.mixins.forEach(l),e.extends&&l(e.extends),e.mixins&&e.mixins.forEach(l)}return!i&&!s?(ht(e)&&a.set(e,null),null):(Qe(i)?i.forEach(l=>o[l]=null):Vt(o,i),ht(e)&&a.set(e,o),o)}function io(e,t){return!e||!Wi(t)?!1:(t=t.slice(2).replace(/Once$/,""),Tt(e,t[0].toLowerCase()+t.slice(1))||Tt(e,Da(t))||Tt(e,t))}function qd(e){const{type:t,vnode:n,proxy:a,withProxy:r,propsOptions:[i],slots:o,attrs:s,emit:l,render:c,renderCache:u,props:d,data:_,setupState:m,ctx:p,inheritAttrs:g}=e,b=Mi(e);let A,O;try{if(n.shapeFlag&4){const w=r||a,v=w;A=Kn(c.call(v,w,u,d,m,_,p)),O=s}else{const w=t;A=Kn(w.length>1?w(d,{attrs:s,slots:o,emit:l}):w(d,null)),O=t.props?s:LT(s)}}catch(w){qr.length=0,no(w,e,1),A=we(an)}let M=A;if(O&&g!==!1){const w=Object.keys(O),{shapeFlag:v}=M;w.length&&v&7&&(i&&w.some(Ki)&&(O=PT(O,i)),M=Aa(M,O,!1,!0))}return n.dirs&&(M=Aa(M,null,!1,!0),M.dirs=M.dirs?M.dirs.concat(n.dirs):n.dirs),n.transition&&er(M,n.transition),A=M,Mi(b),A}const LT=e=>{let t;for(const n in e)(n==="class"||n==="style"||Wi(n))&&((t||(t={}))[n]=e[n]);return t},PT=(e,t)=>{const n={};for(const a in e)(!Ki(a)||!(a.slice(9)in t))&&(n[a]=e[a]);return n};function kT(e,t,n){const{props:a,children:r,component:i}=e,{props:o,children:s,patchFlag:l}=t,c=i.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&l>=0){if(l&1024)return!0;if(l&16)return a?Hd(a,o,c):!!o;if(l&8){const u=t.dynamicProps;for(let d=0;dObject.create(kf),Ff=e=>Object.getPrototypeOf(e)===kf;function FT(e,t,n,a=!1){const r={},i=Uf();e.propsDefaults=Object.create(null),Bf(e,t,r,i);for(const o in e.propsOptions[0])o in r||(r[o]=void 0);n?e.props=a?r:sf(r):e.type.props?e.props=r:e.props=i,e.attrs=i}function BT(e,t,n,a){const{props:r,attrs:i,vnode:{patchFlag:o}}=e,s=dt(r),[l]=e.propsOptions;let c=!1;if((a||o>0)&&!(o&16)){if(o&8){const u=e.vnode.dynamicProps;for(let d=0;d{l=!0;const[_,m]=Gf(d,t,!0);Vt(o,_),m&&s.push(...m)};!n&&t.mixins.length&&t.mixins.forEach(u),e.extends&&u(e.extends),e.mixins&&e.mixins.forEach(u)}if(!i&&!l)return ht(e)&&a.set(e,pr),pr;if(Qe(i))for(let u=0;ue==="_"||e==="_ctx"||e==="$stable",id=e=>Qe(e)?e.map(Kn):[Kn(e)],YT=(e,t,n)=>{if(t._n)return t;const a=_t((...r)=>id(t(...r)),n);return a._c=!1,a},Yf=(e,t,n)=>{const a=e._ctx;for(const r in e){if(rd(r))continue;const i=e[r];if(rt(i))t[r]=YT(r,i,a);else if(i!=null){const o=id(i);t[r]=()=>o}}},$f=(e,t)=>{const n=id(t);e.slots.default=()=>n},qf=(e,t,n)=>{for(const a in t)(n||!rd(a))&&(e[a]=t[a])},$T=(e,t,n)=>{const a=e.slots=Uf();if(e.vnode.shapeFlag&32){const r=t._;r?(qf(a,t,n),n&&GE(a,"_",r,!0)):Yf(t,a)}else t&&$f(e,t)},qT=(e,t,n)=>{const{vnode:a,slots:r}=e;let i=!0,o=Dt;if(a.shapeFlag&32){const s=t._;s?n&&s===1?i=!1:qf(r,t,n):(i=!t.$stable,Yf(t,r)),o=t}else t&&($f(e,t),o={default:1});if(i)for(const s in r)!rd(s)&&o[s]==null&&delete r[s]},_n=KT;function HT(e){return VT(e)}function VT(e,t){const n=ji();n.__VUE__=!0;const{insert:a,remove:r,patchProp:i,createElement:o,createText:s,createComment:l,setText:c,setElementText:u,parentNode:d,nextSibling:_,setScopeId:m=Jn,insertStaticContent:p}=e,g=(R,k,z,K=null,ee=null,X=null,_e=void 0,oe=null,le=!!k.dynamicChildren)=>{if(R===k)return;R&&!Wa(R,k)&&(K=V(R),it(R,ee,X,!0),R=null),k.patchFlag===-2&&(le=!1,k.dynamicChildren=null);const{type:re,ref:Me,shapeFlag:Ce}=k;switch(re){case oo:b(R,k,z,K);break;case an:A(R,k,z,K);break;case yi:R==null&&O(k,z,K,_e);break;case Ze:L(R,k,z,K,ee,X,_e,oe,le);break;default:Ce&1?v(R,k,z,K,ee,X,_e,oe,le):Ce&6?ae(R,k,z,K,ee,X,_e,oe,le):(Ce&64||Ce&128)&&re.process(R,k,z,K,ee,X,_e,oe,le,Ie)}Me!=null&&ee?Yr(Me,R&&R.ref,X,k||R,!k):Me==null&&R&&R.ref!=null&&Yr(R.ref,null,X,R,!0)},b=(R,k,z,K)=>{if(R==null)a(k.el=s(k.children),z,K);else{const ee=k.el=R.el;k.children!==R.children&&c(ee,k.children)}},A=(R,k,z,K)=>{R==null?a(k.el=l(k.children||""),z,K):k.el=R.el},O=(R,k,z,K)=>{[R.el,R.anchor]=p(R.children,k,z,K,R.el,R.anchor)},M=({el:R,anchor:k},z,K)=>{let ee;for(;R&&R!==k;)ee=_(R),a(R,z,K),R=ee;a(k,z,K)},w=({el:R,anchor:k})=>{let z;for(;R&&R!==k;)z=_(R),r(R),R=z;r(k)},v=(R,k,z,K,ee,X,_e,oe,le)=>{if(k.type==="svg"?_e="svg":k.type==="math"&&(_e="mathml"),R==null)T(k,z,K,ee,X,_e,oe,le);else{const re=R.el&&R.el._isVueCE?R.el:null;try{re&&re._beginPatch(),E(R,k,ee,X,_e,oe,le)}finally{re&&re._endPatch()}}},T=(R,k,z,K,ee,X,_e,oe)=>{let le,re;const{props:Me,shapeFlag:Ce,transition:Re,dirs:Pe}=R;if(le=R.el=o(R.type,X,Me&&Me.is,Me),Ce&8?u(le,R.children):Ce&16&&h(R.children,le,null,K,ee,Ro(R,X),_e,oe),Pe&&Ua(R,null,K,"created"),I(le,R,R.scopeId,_e,K),Me){for(const Ke in Me)Ke!=="value"&&!Fr(Ke)&&i(le,Ke,null,Me[Ke],X,K);"value"in Me&&i(le,"value",null,Me.value,X),(re=Me.onVnodeBeforeMount)&&$n(re,K,R)}Pe&&Ua(R,null,K,"beforeMount");const Ve=zT(ee,Re);Ve&&Re.beforeEnter(le),a(le,k,z),((re=Me&&Me.onVnodeMounted)||Ve||Pe)&&_n(()=>{try{re&&$n(re,K,R),Ve&&Re.enter(le),Pe&&Ua(R,null,K,"mounted")}finally{}},ee)},I=(R,k,z,K,ee)=>{if(z&&m(R,z),K)for(let X=0;X{for(let re=le;re{const oe=k.el=R.el;let{patchFlag:le,dynamicChildren:re,dirs:Me}=k;le|=R.patchFlag&16;const Ce=R.props||Dt,Re=k.props||Dt;let Pe;if(z&&Ba(z,!1),(Pe=Re.onVnodeBeforeUpdate)&&$n(Pe,z,k,R),Me&&Ua(k,R,z,"beforeUpdate"),z&&Ba(z,!0),(Ce.innerHTML&&Re.innerHTML==null||Ce.textContent&&Re.textContent==null)&&u(oe,""),re?D(R.dynamicChildren,re,oe,z,K,Ro(k,ee),X):_e||Le(R,k,oe,null,z,K,Ro(k,ee),X,!1),le>0){if(le&16)x(oe,Ce,Re,z,ee);else if(le&2&&Ce.class!==Re.class&&i(oe,"class",null,Re.class,ee),le&4&&i(oe,"style",Ce.style,Re.style,ee),le&8){const Ve=k.dynamicProps;for(let Ke=0;Ke{Pe&&$n(Pe,z,k,R),Me&&Ua(k,R,z,"updated")},K)},D=(R,k,z,K,ee,X,_e)=>{for(let oe=0;oe{if(k!==z){if(k!==Dt)for(const X in k)!Fr(X)&&!(X in z)&&i(R,X,k[X],null,ee,K);for(const X in z){if(Fr(X))continue;const _e=z[X],oe=k[X];_e!==oe&&X!=="value"&&i(R,X,oe,_e,ee,K)}"value"in z&&i(R,"value",k.value,z.value,ee)}},L=(R,k,z,K,ee,X,_e,oe,le)=>{const re=k.el=R?R.el:s(""),Me=k.anchor=R?R.anchor:s("");let{patchFlag:Ce,dynamicChildren:Re,slotScopeIds:Pe}=k;Pe&&(oe=oe?oe.concat(Pe):Pe),R==null?(a(re,z,K),a(Me,z,K),h(k.children||[],z,Me,ee,X,_e,oe,le)):Ce>0&&Ce&64&&Re&&R.dynamicChildren&&R.dynamicChildren.length===Re.length?(D(R.dynamicChildren,Re,z,ee,X,_e,oe),(k.key!=null||ee&&k===ee.subTree)&&od(R,k,!0)):Le(R,k,z,Me,ee,X,_e,oe,le)},ae=(R,k,z,K,ee,X,_e,oe,le)=>{k.slotScopeIds=oe,R==null?k.shapeFlag&512?ee.ctx.activate(k,z,K,_e,le):Ee(k,z,K,ee,X,_e,le):xe(R,k,le)},Ee=(R,k,z,K,ee,X,_e)=>{const oe=R.component=jT(R,K,ee);if(ao(R)&&(oe.ctx.renderer=Ie),eh(oe,!1,_e),oe.asyncDep){if(ee&&ee.registerDep(oe,Se,_e),!R.el){const le=oe.subTree=we(an);A(null,le,k,z),R.placeholder=le.el}}else Se(oe,R,k,z,ee,X,_e)},xe=(R,k,z)=>{const K=k.component=R.component;if(kT(R,k,z))if(K.asyncDep&&!K.asyncResolved){pe(K,k,z);return}else K.next=k,K.update();else k.el=R.el,K.vnode=k},Se=(R,k,z,K,ee,X,_e)=>{const oe=()=>{if(R.isMounted){let{next:Ce,bu:Re,u:Pe,parent:Ve,vnode:Ke}=R;{const q=Hf(R);if(q){Ce&&(Ce.el=Ke.el,pe(R,Ce,_e)),q.asyncDep.then(()=>{_n(()=>{R.isUnmounted||re()},ee)});return}}let y=Ce,B;Ba(R,!1),Ce?(Ce.el=Ke.el,pe(R,Ce,_e)):Ce=Ke,Re&&Ci(Re),(B=Ce.props&&Ce.props.onVnodeBeforeUpdate)&&$n(B,Ve,Ce,Ke),Ba(R,!0);const W=qd(R),Y=R.subTree;R.subTree=W,g(Y,W,d(Y.el),V(Y),R,ee,X),Ce.el=W.el,y===null&&UT(R,W.el),Pe&&_n(Pe,ee),(B=Ce.props&&Ce.props.onVnodeUpdated)&&_n(()=>$n(B,Ve,Ce,Ke),ee)}else{let Ce;const{el:Re,props:Pe}=k,{bm:Ve,m:Ke,parent:y,root:B,type:W}=R,Y=Er(k);Ba(R,!1),Ve&&Ci(Ve),!Y&&(Ce=Pe&&Pe.onVnodeBeforeMount)&&$n(Ce,y,k),Ba(R,!0);{B.ce&&B.ce._hasShadowRoot()&&B.ce._injectChildStyle(W,R.parent?R.parent.type:void 0);const q=R.subTree=qd(R);g(null,q,z,K,R,ee,X),k.el=q.el}if(Ke&&_n(Ke,ee),!Y&&(Ce=Pe&&Pe.onVnodeMounted)){const q=k;_n(()=>$n(Ce,y,q),ee)}(k.shapeFlag&256||y&&Er(y.vnode)&&y.vnode.shapeFlag&256)&&R.a&&_n(R.a,ee),R.isMounted=!0,k=z=K=null}};R.scope.on();const le=R.effect=new zE(oe);R.scope.off();const re=R.update=le.run.bind(le),Me=R.job=le.runIfDirty.bind(le);Me.i=R,Me.id=R.uid,le.scheduler=()=>ed(Me),Ba(R,!0),re()},pe=(R,k,z)=>{k.component=R;const K=R.vnode.props;R.vnode=k,R.next=null,BT(R,k.props,K,z),qT(R,k.children,z),pa(),Md(R),ma()},Le=(R,k,z,K,ee,X,_e,oe,le=!1)=>{const re=R&&R.children,Me=R?R.shapeFlag:0,Ce=k.children,{patchFlag:Re,shapeFlag:Pe}=k;if(Re>0){if(Re&128){Xe(re,Ce,z,K,ee,X,_e,oe,le);return}else if(Re&256){be(re,Ce,z,K,ee,X,_e,oe,le);return}}Pe&8?(Me&16&<(re,ee,X),Ce!==re&&u(z,Ce)):Me&16?Pe&16?Xe(re,Ce,z,K,ee,X,_e,oe,le):lt(re,ee,X,!0):(Me&8&&u(z,""),Pe&16&&h(Ce,z,K,ee,X,_e,oe,le))},be=(R,k,z,K,ee,X,_e,oe,le)=>{R=R||pr,k=k||pr;const re=R.length,Me=k.length,Ce=Math.min(re,Me);let Re;for(Re=0;ReMe?lt(R,ee,X,!0,!1,Ce):h(k,z,K,ee,X,_e,oe,le,Ce)},Xe=(R,k,z,K,ee,X,_e,oe,le)=>{let re=0;const Me=k.length;let Ce=R.length-1,Re=Me-1;for(;re<=Ce&&re<=Re;){const Pe=R[re],Ve=k[re]=le?ia(k[re]):Kn(k[re]);if(Wa(Pe,Ve))g(Pe,Ve,z,null,ee,X,_e,oe,le);else break;re++}for(;re<=Ce&&re<=Re;){const Pe=R[Ce],Ve=k[Re]=le?ia(k[Re]):Kn(k[Re]);if(Wa(Pe,Ve))g(Pe,Ve,z,null,ee,X,_e,oe,le);else break;Ce--,Re--}if(re>Ce){if(re<=Re){const Pe=Re+1,Ve=PeRe)for(;re<=Ce;)it(R[re],ee,X,!0),re++;else{const Pe=re,Ve=re,Ke=new Map;for(re=Ve;re<=Re;re++){const fe=k[re]=le?ia(k[re]):Kn(k[re]);fe.key!=null&&Ke.set(fe.key,re)}let y,B=0;const W=Re-Ve+1;let Y=!1,q=0;const ne=new Array(W);for(re=0;re=W){it(fe,ee,X,!0);continue}let ye;if(fe.key!=null)ye=Ke.get(fe.key);else for(y=Ve;y<=Re;y++)if(ne[y-Ve]===0&&Wa(fe,k[y])){ye=y;break}ye===void 0?it(fe,ee,X,!0):(ne[ye-Ve]=re+1,ye>=q?q=ye:Y=!0,g(fe,k[ye],z,null,ee,X,_e,oe,le),B++)}const de=Y?WT(ne):pr;for(y=de.length-1,re=W-1;re>=0;re--){const fe=Ve+re,ye=k[fe],Ue=k[fe+1],tt=fe+1{const{el:X,type:_e,transition:oe,children:le,shapeFlag:re}=R;if(re&6){et(R.component.subTree,k,z,K);return}if(re&128){R.suspense.move(k,z,K);return}if(re&64){_e.move(R,k,z,Ie);return}if(_e===Ze){a(X,k,z);for(let Ce=0;Ceoe.enter(X),ee);else{const{leave:Ce,delayLeave:Re,afterLeave:Pe}=oe,Ve=()=>{R.ctx.isUnmounted?r(X):a(X,k,z)},Ke=()=>{X._isLeaving&&X[zn](!0),Ce(X,()=>{Ve(),Pe&&Pe()})};Re?Re(X,Ve,Ke):Ke()}else a(X,k,z)},it=(R,k,z,K=!1,ee=!1)=>{const{type:X,props:_e,ref:oe,children:le,dynamicChildren:re,shapeFlag:Me,patchFlag:Ce,dirs:Re,cacheIndex:Pe,memo:Ve}=R;if(Ce===-2&&(ee=!1),oe!=null&&(pa(),Yr(oe,null,z,R,!0),ma()),Pe!=null&&(k.renderCache[Pe]=void 0),Me&256){k.ctx.deactivate(R);return}const Ke=Me&1&&Re,y=!Er(R);let B;if(y&&(B=_e&&_e.onVnodeBeforeUnmount)&&$n(B,k,R),Me&6)qe(R.component,z,K);else{if(Me&128){R.suspense.unmount(z,K);return}Ke&&Ua(R,null,k,"beforeUnmount"),Me&64?R.type.remove(R,k,z,Ie,K):re&&!re.hasOnce&&(X!==Ze||Ce>0&&Ce&64)?lt(re,k,z,!1,!0):(X===Ze&&Ce&384||!ee&&Me&16)&<(le,k,z),K&&St(R)}const W=Ve!=null&&Pe==null;(y&&(B=_e&&_e.onVnodeUnmounted)||Ke||W)&&_n(()=>{B&&$n(B,k,R),Ke&&Ua(R,null,k,"unmounted"),W&&(R.el=null)},z)},St=R=>{const{type:k,el:z,anchor:K,transition:ee}=R;if(k===Ze){Ot(z,K);return}if(k===yi){w(R);return}const X=()=>{r(z),ee&&!ee.persisted&&ee.afterLeave&&ee.afterLeave()};if(R.shapeFlag&1&&ee&&!ee.persisted){const{leave:_e,delayLeave:oe}=ee,le=()=>_e(z,X);oe?oe(R.el,X,le):le()}else X()},Ot=(R,k)=>{let z;for(;R!==k;)z=_(R),r(R),R=z;r(k)},qe=(R,k,z)=>{const{bum:K,scope:ee,job:X,subTree:_e,um:oe,m:le,a:re}=R;zd(le),zd(re),K&&Ci(K),ee.stop(),X&&(X.flags|=8,it(_e,R,k,z)),oe&&_n(oe,k),_n(()=>{R.isUnmounted=!0},k)},lt=(R,k,z,K=!1,ee=!1,X=0)=>{for(let _e=X;_e{if(R.shapeFlag&6)return V(R.component.subTree);if(R.shapeFlag&128)return R.suspense.next();const k=_(R.anchor||R.el),z=k&&k[Ef];return z?_(z):k};let te=!1;const ve=(R,k,z)=>{let K;R==null?k._vnode&&(it(k._vnode,null,null,!0),K=k._vnode.component):g(k._vnode||null,R,k,null,null,null,z),k._vnode=R,te||(te=!0,Md(K),_f(),te=!1)},Ie={p:g,um:it,m:et,r:St,mt:Ee,mc:h,pc:Le,pbc:D,n:V,o:e};return{render:ve,hydrate:void 0,createApp:DT(ve)}}function Ro({type:e,props:t},n){return n==="svg"&&e==="foreignObject"||n==="mathml"&&e==="annotation-xml"&&t&&t.encoding&&t.encoding.includes("html")?void 0:n}function Ba({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function zT(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function od(e,t,n=!1){const a=e.children,r=t.children;if(Qe(a)&&Qe(r))for(let i=0;i>1,e[n[s]]0&&(t[a]=n[i-1]),n[i]=a)}}for(i=n.length,o=n[i-1];i-- >0;)n[i]=o,o=t[o];return n}function Hf(e){const t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Hf(t)}function zd(e){if(e)for(let t=0;te.__isSuspense;function KT(e,t){t&&t.pendingBranch?Qe(e)?t.effects.push(...e):t.effects.push(e):aT(e)}const Ze=Symbol.for("v-fgt"),oo=Symbol.for("v-txt"),an=Symbol.for("v-cmt"),yi=Symbol.for("v-stc"),qr=[];let yn=null;function N(e=!1){qr.push(yn=e?null:[])}function QT(){qr.pop(),yn=qr[qr.length-1]||null}let Zr=1;function Pi(e,t=!1){Zr+=e,e<0&&yn&&t&&(yn.hasOnce=!0)}function Wf(e){return e.dynamicChildren=Zr>0?yn||pr:null,QT(),Zr>0&&yn&&yn.push(e),e}function U(e,t,n,a,r,i){return Wf(f(e,t,n,a,r,i,!0))}function ut(e,t,n,a,r){return Wf(we(e,t,n,a,r,!0))}function Jr(e){return e?e.__v_isVNode===!0:!1}function Wa(e,t){return e.type===t.type&&e.key===t.key}const Kf=({key:e})=>e??null,Ni=({ref:e,ref_key:t,ref_for:n})=>(typeof e=="number"&&(e=""+e),e!=null?Ft(e)||Gt(e)||rt(e)?{i:Jt,r:e,k:t,f:!!n}:e:null);function f(e,t=null,n=null,a=0,r=null,i=e===Ze?0:1,o=!1,s=!1){const l={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&Kf(t),ref:t&&Ni(t),scopeId:mf,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:i,patchFlag:a,dynamicProps:r,dynamicChildren:null,appContext:null,ctx:Jt};return s?(sd(l,n),i&128&&e.normalize(l)):n&&(l.shapeFlag|=Ft(n)?8:16),Zr>0&&!o&&yn&&(l.patchFlag>0||i&6)&&l.patchFlag!==32&&yn.push(l),l}const we=XT;function XT(e,t=null,n=null,a=0,r=null,i=!1){if((!e||e===Af)&&(e=an),Jr(e)){const s=Aa(e,t,!0);return n&&sd(s,n),Zr>0&&!i&&yn&&(s.shapeFlag&6?yn[yn.indexOf(e)]=s:yn.push(s)),s.patchFlag=-2,s}if(ih(e)&&(e=e.__vccOpts),t){t=Qf(t);let{class:s,style:l}=t;s&&!Ft(s)&&(t.class=He(s)),ht(l)&&(to(l)&&!Qe(l)&&(l=Vt({},l)),t.style=jn(l))}const o=Ft(e)?1:zf(e)?128:ff(e)?64:ht(e)?4:rt(e)?2:0;return f(e,t,n,a,r,o,i,!0)}function Qf(e){return e?to(e)||Ff(e)?Vt({},e):e:null}function Aa(e,t,n=!1,a=!1){const{props:r,ref:i,patchFlag:o,children:s,transition:l}=e,c=t?ki(r||{},t):r,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:c,key:c&&Kf(c),ref:t&&t.ref?n&&i?Qe(i)?i.concat(Ni(t)):[i,Ni(t)]:Ni(t):i,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:s,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==Ze?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:l,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Aa(e.ssContent),ssFallback:e.ssFallback&&Aa(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return l&&a&&er(u,l.clone(u)),u}function Et(e=" ",t=0){return we(oo,null,e,t)}function Xf(e,t){const n=we(yi,null,e);return n.staticCount=t,n}function ue(e="",t=!1){return t?(N(),ut(an,null,e)):we(an,null,e)}function Kn(e){return e==null||typeof e=="boolean"?we(an):Qe(e)?we(Ze,null,e.slice()):Jr(e)?ia(e):we(oo,null,String(e))}function ia(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Aa(e)}function sd(e,t){let n=0;const{shapeFlag:a}=e;if(t==null)t=null;else if(Qe(t))n=16;else if(typeof t=="object")if(a&65){const r=t.default;r&&(r._c&&(r._d=!1),sd(e,r()),r._c&&(r._d=!0));return}else{n=32;const r=t._;!r&&!Ff(t)?t._ctx=Jt:r===3&&Jt&&(Jt.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}else rt(t)?(t={default:t,_ctx:Jt},n=32):(t=String(t),a&64?(n=16,t=[Et(t)]):n=8);e.children=t,e.shapeFlag|=n}function ki(...e){const t={};for(let n=0;nrn||Jt;let Ui,Au;{const e=ji(),t=(n,a)=>{let r;return(r=e[n])||(r=e[n]=[]),r.push(a),i=>{r.length>1?r.forEach(o=>o(i)):r[0](i)}};Ui=t("__VUE_INSTANCE_SETTERS__",n=>rn=n),Au=t("__VUE_SSR_SETTERS__",n=>jr=n)}const oi=e=>{const t=rn;return Ui(e),e.scope.on(),()=>{e.scope.off(),Ui(t)}},Wd=()=>{rn&&rn.scope.off(),Ui(null)};function Zf(e){return e.vnode.shapeFlag&4}let jr=!1;function eh(e,t=!1,n=!1){t&&Au(t);const{props:a,children:r}=e.vnode,i=Zf(e);FT(e,a,i,t),$T(e,r,n||t);const o=i?th(e,t):void 0;return t&&Au(!1),o}function th(e,t){const n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,RT);const{setup:a}=n;if(a){pa();const r=e.setupContext=a.length>1?ah(e):null,i=oi(e),o=ai(a,e,0,[e.props,r]),s=UE(o);if(ma(),i(),(s||e.sp)&&!Er(e)&&Rf(e),s){if(o.then(Wd,Wd),t)return o.then(l=>{Kd(e,l)}).catch(l=>{no(l,e,0)});e.asyncDep=o}else Kd(e,o)}else Jf(e)}function Kd(e,t,n){rt(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:ht(t)&&(e.setupState=cf(t)),Jf(e)}function Jf(e,t,n){const a=e.type;e.render||(e.render=a.render||Jn);{const r=oi(e);pa();try{CT(e)}finally{ma(),r()}}}const nh={get(e,t){return nn(e,"get",""),e[t]}};function ah(e){const t=n=>{e.exposed=n||{}};return{attrs:new Proxy(e.attrs,nh),slots:e.slots,emit:e.emit,expose:t}}function lo(e){return e.exposed?e.exposeProxy||(e.exposeProxy=new Proxy(cf(Sr(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in $r)return $r[n](e)},has(t,n){return n in t||n in $r}})):e.proxy}function rh(e,t=!0){return rt(e)?e.displayName||e.name:e.name||t&&e.__name}function ih(e){return rt(e)&&"__vccOpts"in e}const ge=(e,t)=>Jb(e,t,jr);function C(e,t,n){try{Pi(-1);const a=arguments.length;return a===2?ht(t)&&!Qe(t)?Jr(t)?we(e,null,[t]):we(e,t):we(e,null,t):(a>3?n=Array.prototype.slice.call(arguments,2):a===3&&Jr(n)&&(n=[n]),we(e,t,n))}finally{Pi(1)}}const oh="3.5.32";/** -* @vue/runtime-dom v3.5.32 -* (c) 2018-present Yuxi (Evan) You and Vue contributors -* @license MIT -**/let Iu;const Qd=typeof window<"u"&&window.trustedTypes;if(Qd)try{Iu=Qd.createPolicy("vue",{createHTML:e=>e})}catch{}const jf=Iu?e=>Iu.createHTML(e):e=>e,sh="http://www.w3.org/2000/svg",lh="http://www.w3.org/1998/Math/MathML",ra=typeof document<"u"?document:null,Xd=ra&&ra.createElement("template"),ch={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,a)=>{const r=t==="svg"?ra.createElementNS(sh,e):t==="mathml"?ra.createElementNS(lh,e):n?ra.createElement(e,{is:n}):ra.createElement(e);return e==="select"&&a&&a.multiple!=null&&r.setAttribute("multiple",a.multiple),r},createText:e=>ra.createTextNode(e),createComment:e=>ra.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>ra.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,a,r,i){const o=n?n.previousSibling:t.lastChild;if(r&&(r===i||r.nextSibling))for(;t.insertBefore(r.cloneNode(!0),n),!(r===i||!(r=r.nextSibling)););else{Xd.innerHTML=jf(a==="svg"?`${e}`:a==="mathml"?`${e}`:e);const s=Xd.content;if(a==="svg"||a==="mathml"){const l=s.firstChild;for(;l.firstChild;)s.appendChild(l.firstChild);s.removeChild(l)}t.insertBefore(s,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},va="transition",Ar="animation",Tr=Symbol("_vtc"),eS={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},tS=Vt({},bf,eS),uh=e=>(e.displayName="Transition",e.props=tS,e),hr=uh((e,{slots:t})=>C(pT,nS(e),t)),Ga=(e,t=[])=>{Qe(e)?e.forEach(n=>n(...t)):e&&e(...t)},Zd=e=>e?Qe(e)?e.some(t=>t.length>1):e.length>1:!1;function nS(e){const t={};for(const L in e)L in eS||(t[L]=e[L]);if(e.css===!1)return t;const{name:n="v",type:a,duration:r,enterFromClass:i=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:l=i,appearActiveClass:c=o,appearToClass:u=s,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:_=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,p=dh(r),g=p&&p[0],b=p&&p[1],{onBeforeEnter:A,onEnter:O,onEnterCancelled:M,onLeave:w,onLeaveCancelled:v,onBeforeAppear:T=A,onAppear:I=O,onAppearCancelled:h=M}=t,E=(L,ae,Ee,xe)=>{L._enterCancelled=xe,Ca(L,ae?u:s),Ca(L,ae?c:o),Ee&&Ee()},D=(L,ae)=>{L._isLeaving=!1,Ca(L,d),Ca(L,m),Ca(L,_),ae&&ae()},x=L=>(ae,Ee)=>{const xe=L?I:O,Se=()=>E(ae,L,Ee);Ga(xe,[ae,Se]),Jd(()=>{Ca(ae,L?l:i),qn(ae,L?u:s),Zd(xe)||jd(ae,a,g,Se)})};return Vt(t,{onBeforeEnter(L){Ga(A,[L]),qn(L,i),qn(L,o)},onBeforeAppear(L){Ga(T,[L]),qn(L,l),qn(L,c)},onEnter:x(!1),onAppear:x(!0),onLeave(L,ae){L._isLeaving=!0;const Ee=()=>D(L,ae);qn(L,d),L._enterCancelled?(qn(L,_),Du(L)):(Du(L),qn(L,_)),Jd(()=>{L._isLeaving&&(Ca(L,d),qn(L,m),Zd(w)||jd(L,a,b,Ee))}),Ga(w,[L,Ee])},onEnterCancelled(L){E(L,!1,void 0,!0),Ga(M,[L])},onAppearCancelled(L){E(L,!0,void 0,!0),Ga(h,[L])},onLeaveCancelled(L){D(L),Ga(v,[L])}})}function dh(e){if(e==null)return null;if(ht(e))return[Co(e.enter),Co(e.leave)];{const t=Co(e);return[t,t]}}function Co(e){return fb(e)}function qn(e,t){t.split(/\s+/).forEach(n=>n&&e.classList.add(n)),(e[Tr]||(e[Tr]=new Set)).add(t)}function Ca(e,t){t.split(/\s+/).forEach(a=>a&&e.classList.remove(a));const n=e[Tr];n&&(n.delete(t),n.size||(e[Tr]=void 0))}function Jd(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let _h=0;function jd(e,t,n,a){const r=e._endId=++_h,i=()=>{r===e._endId&&a()};if(n!=null)return setTimeout(i,n);const{type:o,timeout:s,propCount:l}=aS(e,t);if(!o)return a();const c=o+"end";let u=0;const d=()=>{e.removeEventListener(c,_),i()},_=m=>{m.target===e&&++u>=l&&d()};setTimeout(()=>{u(n[p]||"").split(", "),r=a(`${va}Delay`),i=a(`${va}Duration`),o=e_(r,i),s=a(`${Ar}Delay`),l=a(`${Ar}Duration`),c=e_(s,l);let u=null,d=0,_=0;t===va?o>0&&(u=va,d=o,_=i.length):t===Ar?c>0&&(u=Ar,d=c,_=l.length):(d=Math.max(o,c),u=d>0?o>c?va:Ar:null,_=u?u===va?i.length:l.length:0);const m=u===va&&/\b(?:transform|all)(?:,|$)/.test(a(`${va}Property`).toString());return{type:u,timeout:d,propCount:_,hasTransform:m}}function e_(e,t){for(;e.lengtht_(n)+t_(e[a])))}function t_(e){return e==="auto"?0:Number(e.slice(0,-1).replace(",","."))*1e3}function Du(e){return(e?e.ownerDocument:document).body.offsetHeight}function ph(e,t,n){const a=e[Tr];a&&(t=(t?[t,...a]:[...a]).join(" ")),t==null?e.removeAttribute("class"):n?e.setAttribute("class",t):e.className=t}const n_=Symbol("_vod"),mh=Symbol("_vsh"),gh=Symbol(""),Eh=/(?:^|;)\s*display\s*:/;function fh(e,t,n){const a=e.style,r=Ft(n);let i=!1;if(n&&!r){if(t)if(Ft(t))for(const o of t.split(";")){const s=o.slice(0,o.indexOf(":")).trim();n[s]==null&&Oi(a,s,"")}else for(const o in t)n[o]==null&&Oi(a,o,"");for(const o in n)o==="display"&&(i=!0),Oi(a,o,n[o])}else if(r){if(t!==n){const o=a[gh];o&&(n+=";"+o),a.cssText=n,i=Eh.test(n)}}else t&&e.removeAttribute("style");n_ in e&&(e[n_]=i?a.display:"",e[mh]&&(a.display="none"))}const a_=/\s*!important$/;function Oi(e,t,n){if(Qe(n))n.forEach(a=>Oi(e,t,a));else if(n==null&&(n=""),t.startsWith("--"))e.setProperty(t,n);else{const a=Sh(e,t);a_.test(n)?e.setProperty(Da(a),n.replace(a_,""),"important"):e[a]=n}}const r_=["Webkit","Moz","ms"],yo={};function Sh(e,t){const n=yo[t];if(n)return n;let a=gn(t);if(a!=="filter"&&a in e)return yo[t]=a;a=Zi(a);for(let r=0;rNo||(vh.then(()=>No=0),No=Date.now());function Ch(e,t){const n=a=>{if(!a._vts)a._vts=Date.now();else if(a._vts<=n.attached)return;Un(yh(a,n.value),t,5,[a])};return n.value=e,n.attached=Rh(),n}function yh(e,t){if(Qe(t)){const n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(a=>r=>!r._stopped&&a&&a(r))}else return t}const u_=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,Nh=(e,t,n,a,r,i)=>{const o=r==="svg";t==="class"?ph(e,a,o):t==="style"?fh(e,n,a):Wi(t)?Ki(t)||Th(e,t,n,a,i):(t[0]==="."?(t=t.slice(1),!0):t[0]==="^"?(t=t.slice(1),!1):Oh(e,t,a,o))?(s_(e,t,a),!e.tagName.includes("-")&&(t==="value"||t==="checked"||t==="selected")&&o_(e,t,a,o,i,t!=="value")):e._isVueCE&&(Ah(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!Ft(a)))?s_(e,gn(t),a,i,t):(t==="true-value"?e._trueValue=a:t==="false-value"&&(e._falseValue=a),o_(e,t,a,o))};function Oh(e,t,n,a){if(a)return!!(t==="innerHTML"||t==="textContent"||t in e&&u_(t)&&rt(n));if(t==="spellcheck"||t==="draggable"||t==="translate"||t==="autocorrect"||t==="sandbox"&&e.tagName==="IFRAME"||t==="form"||t==="list"&&e.tagName==="INPUT"||t==="type"&&e.tagName==="TEXTAREA")return!1;if(t==="width"||t==="height"){const r=e.tagName;if(r==="IMG"||r==="VIDEO"||r==="CANVAS"||r==="SOURCE")return!1}return u_(t)&&Ft(n)?!1:t in e}function Ah(e,t){const n=e._def.props;if(!n)return!1;const a=gn(t);return Array.isArray(n)?n.some(r=>gn(r)===a):Object.keys(n).some(r=>gn(r)===a)}const rS=new WeakMap,iS=new WeakMap,Fi=Symbol("_moveCb"),d_=Symbol("_enterCb"),Ih=e=>(delete e.props.mode,e),Dh=Ih({name:"TransitionGroup",props:Vt({},tS,{tag:String,moveClass:String}),setup(e,{slots:t}){const n=so(),a=Sf();let r,i;return Nf(()=>{if(!r.length)return;const o=e.moveClass||`${e.name||"v"}-move`;if(!Ph(r[0].el,n.vnode.el,o)){r=[];return}r.forEach(Mh),r.forEach(wh);const s=r.filter(Lh);Du(n.vnode.el),s.forEach(l=>{const c=l.el,u=c.style;qn(c,o),u.transform=u.webkitTransform=u.transitionDuration="";const d=c[Fi]=_=>{_&&_.target!==c||(!_||_.propertyName.endsWith("transform"))&&(c.removeEventListener("transitionend",d),c[Fi]=null,Ca(c,o))};c.addEventListener("transitionend",d)}),r=[]}),()=>{const o=dt(e),s=nS(o);let l=o.tag||Ze;if(r=[],i)for(let c=0;c{s.split(/\s+/).forEach(l=>l&&a.classList.remove(l))}),n.split(/\s+/).forEach(s=>s&&a.classList.add(s)),a.style.display="none";const i=t.nodeType===1?t:t.parentNode;i.appendChild(a);const{hasTransform:o}=aS(a);return i.removeChild(a),o}const Ia=e=>{const t=e.props["onUpdate:modelValue"]||!1;return Qe(t)?n=>Ci(t,n):t};function kh(e){e.target.composing=!0}function __(e){const t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event("input")))}const Mn=Symbol("_assign");function p_(e,t,n){return t&&(e=e.trim()),n&&(e=Ji(e)),e}const Bi={created(e,{modifiers:{lazy:t,trim:n,number:a}},r){e[Mn]=Ia(r);const i=a||r.props&&r.props.type==="number";la(e,t?"change":"input",o=>{o.target.composing||e[Mn](p_(e.value,n,i))}),(n||i)&&la(e,"change",()=>{e.value=p_(e.value,n,i)}),t||(la(e,"compositionstart",kh),la(e,"compositionend",__),la(e,"change",__))},mounted(e,{value:t}){e.value=t??""},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:a,trim:r,number:i}},o){if(e[Mn]=Ia(o),e.composing)return;const s=(i||e.type==="number")&&!/^0\d/.test(e.value)?Ji(e.value):e.value,l=t??"";if(s===l)return;const c=e.getRootNode();(c instanceof Document||c instanceof ShadowRoot)&&c.activeElement===e&&e.type!=="range"&&(a&&t===n||r&&e.value.trim()===l)||(e.value=l)}},sS={deep:!0,created(e,t,n){e[Mn]=Ia(n),la(e,"change",()=>{const a=e._modelValue,r=vr(e),i=e.checked,o=e[Mn];if(Qe(a)){const s=zu(a,r),l=s!==-1;if(i&&!l)o(a.concat(r));else if(!i&&l){const c=[...a];c.splice(s,1),o(c)}}else if(Cr(a)){const s=new Set(a);i?s.add(r):s.delete(r),o(s)}else o(lS(e,i))})},mounted:m_,beforeUpdate(e,t,n){e[Mn]=Ia(n),m_(e,t,n)}};function m_(e,{value:t,oldValue:n},a){e._modelValue=t;let r;if(Qe(t))r=zu(t,a.props.value)>-1;else if(Cr(t))r=t.has(a.props.value);else{if(t===n)return;r=Oa(t,lS(e,!0))}e.checked!==r&&(e.checked=r)}const Uh={created(e,{value:t},n){e.checked=Oa(t,n.props.value),e[Mn]=Ia(n),la(e,"change",()=>{e[Mn](vr(e))})},beforeUpdate(e,{value:t,oldValue:n},a){e[Mn]=Ia(a),t!==n&&(e.checked=Oa(t,a.props.value))}},xu={deep:!0,created(e,{value:t,modifiers:{number:n}},a){const r=Cr(t);la(e,"change",()=>{const i=Array.prototype.filter.call(e.options,o=>o.selected).map(o=>n?Ji(vr(o)):vr(o));e[Mn](e.multiple?r?new Set(i):i:i[0]),e._assigning=!0,Ht(()=>{e._assigning=!1})}),e[Mn]=Ia(a)},mounted(e,{value:t}){g_(e,t)},beforeUpdate(e,t,n){e[Mn]=Ia(n)},updated(e,{value:t}){e._assigning||g_(e,t)}};function g_(e,t){const n=e.multiple,a=Qe(t);if(!(n&&!a&&!Cr(t))){for(let r=0,i=e.options.length;rString(c)===String(s)):o.selected=zu(t,s)>-1}else o.selected=t.has(s);else if(Oa(vr(o),t)){e.selectedIndex!==r&&(e.selectedIndex=r);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function vr(e){return"_value"in e?e._value:e.value}function lS(e,t){const n=t?"_trueValue":"_falseValue";return n in e?e[n]:t}const Fh={created(e,t,n){Si(e,t,n,null,"created")},mounted(e,t,n){Si(e,t,n,null,"mounted")},beforeUpdate(e,t,n,a){Si(e,t,n,a,"beforeUpdate")},updated(e,t,n,a){Si(e,t,n,a,"updated")}};function Bh(e,t){switch(e){case"SELECT":return xu;case"TEXTAREA":return Bi;default:switch(t){case"checkbox":return sS;case"radio":return Uh;default:return Bi}}}function Si(e,t,n,a,r){const o=Bh(e.tagName,n.props&&n.props.type)[r];o&&o(e,t,n,a)}const Gh=["ctrl","shift","alt","meta"],Yh={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>"button"in e&&e.button!==0,middle:e=>"button"in e&&e.button!==1,right:e=>"button"in e&&e.button!==2,exact:(e,t)=>Gh.some(n=>e[`${n}Key`]&&!t.includes(n))},tr=(e,t)=>{if(!e)return e;const n=e._withMods||(e._withMods={}),a=t.join(".");return n[a]||(n[a]=((r,...i)=>{for(let o=0;o{const n=e._withKeys||(e._withKeys={}),a=t.join(".");return n[a]||(n[a]=(r=>{if(!("key"in r))return;const i=Da(r.key);if(t.some(o=>o===i||$h[o]===i))return e(r)}))},qh=Vt({patchProp:Nh},ch);let E_;function Hh(){return E_||(E_=HT(qh))}const Vh=((...e)=>{const t=Hh().createApp(...e),{mount:n}=t;return t.mount=a=>{const r=Wh(a);if(!r)return;const i=t._component;!rt(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent="");const o=n(r,!1,zh(r));return r instanceof Element&&(r.removeAttribute("v-cloak"),r.setAttribute("data-v-app","")),o},t});function zh(e){if(e instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&e instanceof MathMLElement)return"mathml"}function Wh(e){return Ft(e)?document.querySelector(e):e}/*! - * pinia v3.0.4 - * (c) 2025 Eduardo San Martin Morote - * @license MIT - */let cS;const co=e=>cS=e,uS=Symbol();function Mu(e){return e&&typeof e=="object"&&Object.prototype.toString.call(e)==="[object Object]"&&typeof e.toJSON!="function"}var Hr;(function(e){e.direct="direct",e.patchObject="patch object",e.patchFunction="patch function"})(Hr||(Hr={}));function Kh(){const e=Wu(!0),t=e.run(()=>j({}));let n=[],a=[];const r=Sr({install(i){co(r),r._a=i,i.provide(uS,r),i.config.globalProperties.$pinia=r,a.forEach(o=>n.push(o)),a=[]},use(i){return this._a?n.push(i):a.push(i),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return r}const dS=()=>{};function f_(e,t,n,a=dS){e.add(t);const r=()=>{e.delete(t)&&a()};return!n&&VE()&&Nb(r),r}function lr(e,...t){e.forEach(n=>{n(...t)})}const Qh=e=>e(),S_=Symbol(),Oo=Symbol();function wu(e,t){e instanceof Map&&t instanceof Map?t.forEach((n,a)=>e.set(a,n)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(const n in t){if(!t.hasOwnProperty(n))continue;const a=t[n],r=e[n];Mu(r)&&Mu(a)&&e.hasOwnProperty(n)&&!Gt(a)&&!da(a)?e[n]=wu(r,a):e[n]=a}return e}const Xh=Symbol();function Zh(e){return!Mu(e)||!Object.prototype.hasOwnProperty.call(e,Xh)}const{assign:ya}=Object;function Jh(e){return!!(Gt(e)&&e.effect)}function jh(e,t,n,a){const{state:r,actions:i,getters:o}=t,s=n.state.value[e];let l;function c(){s||(n.state.value[e]=r?r():{});const u=Kb(n.state.value[e]);return ya(u,i,Object.keys(o||{}).reduce((d,_)=>(d[_]=Sr(ge(()=>{co(n);const m=n._s.get(e);return o[_].call(m,m)})),d),{}))}return l=_S(e,c,t,n,a,!0),l}function _S(e,t,n={},a,r,i){let o;const s=ya({actions:{}},n),l={deep:!0};let c,u,d=new Set,_=new Set,m;const p=a.state.value[e];!i&&!p&&(a.state.value[e]={});let g;function b(h){let E;c=u=!1,typeof h=="function"?(h(a.state.value[e]),E={type:Hr.patchFunction,storeId:e,events:m}):(wu(a.state.value[e],h),E={type:Hr.patchObject,payload:h,storeId:e,events:m});const D=g=Symbol();Ht().then(()=>{g===D&&(c=!0)}),u=!0,lr(d,E,a.state.value[e])}const A=i?function(){const{state:E}=n,D=E?E():{};this.$patch(x=>{ya(x,D)})}:dS;function O(){o.stop(),d.clear(),_.clear(),a._s.delete(e)}const M=(h,E="")=>{if(S_ in h)return h[Oo]=E,h;const D=function(){co(a);const x=Array.from(arguments),L=new Set,ae=new Set;function Ee(pe){L.add(pe)}function xe(pe){ae.add(pe)}lr(_,{args:x,name:D[Oo],store:v,after:Ee,onError:xe});let Se;try{Se=h.apply(this&&this.$id===e?this:v,x)}catch(pe){throw lr(ae,pe),pe}return Se instanceof Promise?Se.then(pe=>(lr(L,pe),pe)).catch(pe=>(lr(ae,pe),Promise.reject(pe))):(lr(L,Se),Se)};return D[S_]=!0,D[Oo]=E,D},w={_p:a,$id:e,$onAction:f_.bind(null,_),$patch:b,$reset:A,$subscribe(h,E={}){const D=f_(d,h,E.detached,()=>x()),x=o.run(()=>je(()=>a.state.value[e],L=>{(E.flush==="sync"?u:c)&&h({storeId:e,type:Hr.direct,events:m},L)},ya({},l,E)));return D},$dispose:O},v=ja(w);a._s.set(e,v);const I=(a._a&&a._a.runWithContext||Qh)(()=>a._e.run(()=>(o=Wu()).run(()=>t({action:M}))));for(const h in I){const E=I[h];if(Gt(E)&&!Jh(E)||da(E))i||(p&&Zh(E)&&(Gt(E)?E.value=p[h]:wu(E,p[h])),a.state.value[e][h]=E);else if(typeof E=="function"){const D=M(E,h);I[h]=D,s.actions[h]=E}}return ya(v,I),ya(dt(v),I),Object.defineProperty(v,"$state",{get:()=>a.state.value[e],set:h=>{b(E=>{ya(E,h)})}}),a._p.forEach(h=>{ya(v,o.run(()=>h({store:v,app:a._a,pinia:a,options:s})))}),p&&i&&n.hydrate&&n.hydrate(v.$state,p),c=!0,u=!0,v}/*! #__NO_SIDE_EFFECTS__ */function si(e,t,n){let a;const r=typeof t=="function";a=r?n:t;function i(o,s){const l=rT();return o=o||(l?_a(uS,null):null),o&&co(o),o=cS,o._s.has(e)||(r?_S(e,t,a,o):jh(e,a,o)),o._s.get(e)}return i.$id=e,i}const ev="modulepreload",tv=function(e){return"/"+e},b_={},nv=function(t,n,a){let r=Promise.resolve();if(n&&n.length>0){let o=function(c){return Promise.all(c.map(u=>Promise.resolve(u).then(d=>({status:"fulfilled",value:d}),d=>({status:"rejected",reason:d}))))};document.getElementsByTagName("link");const s=document.querySelector("meta[property=csp-nonce]"),l=(s==null?void 0:s.nonce)||(s==null?void 0:s.getAttribute("nonce"));r=o(n.map(c=>{if(c=tv(c),c in b_)return;b_[c]=!0;const u=c.endsWith(".css"),d=u?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${c}"]${d}`))return;const _=document.createElement("link");if(_.rel=u?"stylesheet":ev,u||(_.as="script"),_.crossOrigin="",_.href=c,l&&_.setAttribute("nonce",l),document.head.appendChild(_),u)return new Promise((m,p)=>{_.addEventListener("load",m),_.addEventListener("error",()=>p(new Error(`Unable to preload CSS for ${c}`)))})}))}function i(o){const s=new Event("vite:preloadError",{cancelable:!0});if(s.payload=o,window.dispatchEvent(s),!s.defaultPrevented)throw o}return r.then(o=>{for(const s of o||[])s.status==="rejected"&&i(s.reason);return t().catch(i)})},pS="";window.addEventListener("unhandledrejection",e=>{console.error("[API] Unhandled rejection:",e.reason)});async function Bt(e,t,n){const a={method:e,headers:{},credentials:"include"};n!==void 0&&(a.headers["Content-Type"]="application/json",a.body=JSON.stringify(n));const r=await fetch(`${pS}${t}`,a);if(r.status===401){try{const{useAuthStore:o}=await nv(async()=>{const{useAuthStore:l}=await Promise.resolve().then(()=>yv);return{useAuthStore:l}},void 0),s=o();s.user=null}catch{}const i=await r.text().catch(()=>"");throw new Error(`${e} ${t} → 401: ${i}`)}if(!r.ok){const i=await r.text().catch(()=>"");throw new Error(`${e} ${t} → ${r.status}: ${i}`)}return r.status===204?null:r.json()}function av(){return Bt("GET","/auth/me")}function rv(){return Bt("POST","/auth/logout")}function iv(){return Bt("GET","/agents/profiles")}function T_({limit:e=30,offset:t=0,profileId:n=null,search:a=null}={}){const r=new URLSearchParams({limit:String(e),offset:String(t)});return n&&r.set("profile_id",n),a&&r.set("search",a),Bt("GET",`/sessions?${r.toString()}`)}function h_(e){return Bt("GET",`/sessions/${e}`)}function ov(e){return Bt("POST","/sessions",{profile_id:e})}function sv(e){return Bt("DELETE",`/sessions/${e}`)}function lv(e,t){return Bt("PATCH",`/sessions/${e}/pin`,{pinned:t})}function cv(e){return Bt("POST",`/sessions/${e}/stop`)}function uv(e){return Bt("POST",`/sessions/${e}/generate-name`)}function dv(e){return Bt("GET",`/sessions/${e}/content`)}function _v(e,t,n=50){const a=new URLSearchParams({limit:String(n)});return t!=null&&a.set("before_seq",String(t)),Bt("GET",`/sessions/${e}/messages/archive?${a.toString()}`)}function pv(e){return Bt("GET",`/eval/feedback/${e}`)}function mv(e,t,n){return Bt("POST","/eval/feedback",{session_id:e,message_index:t,rating:n})}function gv(e){return Bt("GET",`/sessions/${e}/files`)}async function Ev(e,t){const n=new FormData;n.append("file",t);const a=await fetch(`${pS}/sessions/${e}/files`,{method:"POST",credentials:"include",body:n});if(!a.ok){const r=await a.text().catch(()=>"");throw new Error(`Upload failed: ${a.status}: ${r}`)}return a.json()}function fv(e){return Bt("GET",`/sessions/${e}/recall`)}function mS(e){return Bt("DELETE",`/sessions/${e}/recall`)}function gS(e){return Bt("POST",`/sessions/${e}/recall/skip`)}function Sv(){return Bt("GET","/api-tokens")}function bv(e){return Bt("POST","/api-tokens",{name:e})}function Tv(e){return Bt("DELETE",`/api-tokens/${e}`)}function hv(){return Bt("GET","/push/vapid-key")}function vv(e){return Bt("POST","/push/subscribe",e)}function Rv(e){return Bt("DELETE","/push/subscribe",{endpoint:e})}const Zn=si("sessions",()=>{const t=j([]),n=j(!1),a=j(!1),r=j(!0),i=j(0),o=j(null),s=j(""),l=j(!1),c=j(null),u=j(!1);async function d(h=null){o.value=h,n.value=!0;try{const E=await T_({limit:30,offset:0,profileId:l.value?null:h,search:l.value?s.value:null}),D=Array.isArray(E)?E:E.items;t.value=D,r.value=Array.isArray(E)?!1:E.has_more,i.value=Array.isArray(E)?D.length:E.next_offset,l.value&&(c.value={query:s.value,items:[...D],hasMore:r.value,nextOffset:i.value})}finally{n.value=!1}}async function _(){if(!(n.value||a.value||!r.value)){a.value=!0;try{const h=await T_({limit:30,offset:i.value,profileId:l.value?null:o.value,search:l.value?s.value:null}),E=Array.isArray(h)?h:h.items,D=new Set(t.value.map(x=>x.session_id));t.value=[...t.value,...E.filter(x=>!D.has(x.session_id))],r.value=Array.isArray(h)?!1:h.has_more,i.value=Array.isArray(h)?t.value.length:h.next_offset,l.value&&(c.value={query:s.value,items:[...t.value],hasMore:r.value,nextOffset:i.value})}finally{a.value=!1}}}function m(h){s.value=h,l.value=h.length>0}function p(){s.value&&(l.value=!0,c.value&&c.value.query===s.value?(t.value=c.value.items,r.value=c.value.hasMore,i.value=c.value.nextOffset):d())}function g(){s.value="",l.value=!1,c.value=null}function b(){l.value=!1}async function A(h){const E=await ov(h);return t.value.unshift({session_id:E.session_id,profile_id:E.profile_id,created_at:E.created_at,last_active:E.created_at,message_count:0,preview:"",pinned:!1}),i.value+=1,E}async function O(h){await sv(h),t.value=t.value.filter(E=>E.session_id!==h),i.value=Math.max(0,i.value-1)}async function M(h,E){await lv(h,E);const D=t.value.map(x=>x.session_id===h?{...x,pinned:E}:x);D.sort((x,L)=>(L.pinned?1:0)-(x.pinned?1:0)),t.value=D}function w(h,E){const D=t.value.find(x=>x.session_id===h);D&&(D.has_pending_recall=E)}function v(h,E){const D=t.value.find(x=>x.session_id===h);D&&(D.preview=E)}function T(h,E){const D=t.value.find(x=>x.session_id===h);D&&(D.name=E)}const I=ge(()=>u.value?t.value.filter(h=>h.has_pending_recall):t.value);return{sessions:t,filteredSessions:I,loading:n,loadingMore:a,hasMore:r,currentProfileId:o,searchQuery:s,searchActive:l,hasPendingRecallFilter:u,fetchSessions:d,fetchMoreSessions:_,createSession:A,deleteSession:O,pinSession:M,updatePreview:v,updateName:T,updateRecallStatus:w,setSearch:m,restoreSearch:p,clearSearch:g,exitSearch:b,searchCache:c}}),li=si("profiles",()=>{const e=j([]),t=j(null),n=j(!1);async function a(){n.value=!0;try{e.value=await iv(),e.value.length&&!t.value&&(t.value=e.value[0].id)}finally{n.value=!1}}function r(i){return e.value.find(o=>o.id===i)??null}return{profiles:e,selectedProfileId:t,loading:n,fetchProfiles:a,getProfile:r}});let v_=null;async function Cv(e){try{const t=Zn(),n=t.sessions.find(r=>r.session_id===e);if(n!=null&&n.name)return;const{name:a}=await uv(e);a&&t.updateName(e,a)}catch{}}const on=si("chat",()=>{const e=j(null),t=j(null),n=j([]),a=j(!1),r=j([]),i=j([]),o=j([]),s=j([]),l=j(0),c=j(0),u=j(!1),d=_r(null),_=j(!1),m=j(null),p=j(null),g=j({}),b=j({}),A=j({count:0,max:5}),O=new Map,M=j(!1),w=j(!1),v=j(null);async function T(y,B=null){if(!(e.value===y&&B==null)){v_=y,u.value=!0,n.value=[],o.value=[],s.value=[],a.value=!1,d.value=null,l.value=0,c.value=0,g.value={},b.value={},A.value={count:0,max:5},O.clear(),m.value=B;try{const W=await h_(y);if(v_!==y)return;t.value=W.profile_id??null,n.value=Ke(W.messages??[]),await E(y),await D(y),await x(y),W.context_token_count&&(l.value=W.context_token_count),W.max_context_tokens&&(c.value=W.max_context_tokens),M.value=!1,w.value=(W.archive_threshold||0)>0,v.value=null,e.value=y,location.hash=y}catch(W){console.error("[chat] loadSession failed",W)}finally{u.value=!1}}}function I(){e.value=null,t.value=null,n.value=[],o.value=[],s.value=[],a.value=!1,d.value=null,l.value=0,c.value=0,g.value={},b.value={},A.value={count:0,max:5},O.clear(),location.hash=""}async function h(y){if(y&&!a.value)try{const B=await h_(y);if(a.value)return;t.value=B.profile_id??null;const W=Ke(B.messages??[]);n.value=W,await E(y),await D(y),await x(y),B.context_token_count&&(l.value=B.context_token_count),B.max_context_tokens&&(c.value=B.max_context_tokens),d.value=null,a.value=!1}catch{}}async function E(y){var B,W;try{const{feedback:Y=[]}=await pv(y);if(!Y.length)return;const q=new Map(Y.map(ne=>[ne.message_index,ne.rating]));for(const ne of n.value){if(ne.role!=="assistant")continue;const de=(W=(B=ne.id)==null?void 0:B.startsWith)!=null&&W.call(B,"h_")?Number(ne.id.slice(2)):NaN;Number.isInteger(de)&&q.has(de)&&(ne.rating=q.get(de))}}catch{}}async function D(y=e.value){if(!y){o.value=[];return}try{const{content:B=[]}=await dv(y);o.value=B}catch{o.value=[]}}async function x(y=e.value){if(!y){s.value=[];return}try{const{files:B=[]}=await gv(y);s.value=B}catch{s.value=[]}}function L(y){if(!(y!=null&&y.filename))return;const B=y.id||y.filename,W=o.value.findIndex(q=>(q.id||q.filename)===B),Y={...y};W===-1?o.value.unshift(Y):o.value.splice(W,1,{...o.value[W],...Y})}async function ae(y,B){var ne,de;if(!e.value||!y)return;const W=(de=(ne=y.id)==null?void 0:ne.startsWith)!=null&&de.call(ne,"h_")?Number(y.id.slice(2)):NaN;if(!Number.isInteger(W))return;const Y=y.rating===B?0:B,q=y.rating??0;y.rating=Y;try{await mv(e.value,W,Y)}catch(fe){throw y.rating=q,fe}}function Ee(y){e.value&&(y?localStorage.setItem(`draft:${e.value}`,y):localStorage.removeItem(`draft:${e.value}`))}function xe(y){return localStorage.getItem(`draft:${y}`)??""}function Se(){if(d.value){const B=n.value.indexOf(d.value);B!==-1&&n.value.splice(B,1),d.value=null}a.value=!0,A.value={count:0,max:A.value.max},O.clear();const y={id:`stream_${Date.now()}`,role:"assistant",type:"stream",thinking:null,tools:[],text:"",done:!1,time:new Date().toISOString(),animate:!_.value,statusLabel:null};n.value.push(y),d.value=n.value[n.value.length-1]}function pe(){_.value=!0}function Le(){_.value=!1,d.value&&(d.value.animate=!0)}function be(y){const B=d.value;B&&(B.thinking||(B.thinking={text:"",done:!1}),B.thinking.text+=y)}function Xe(){const y=d.value;y!=null&&y.thinking&&(y.thinking.done=!0)}function et(y){for(let B=y.tools.length-1;B>=0;B--){const W=y.tools[B];if(W.kind==="tool"&&W.name==="spawn_agent")return W}}function it(y){const B=d.value;if(!B)return;const W={kind:"turn_thinking",isSubagent:y.is_subagent??!1,thinking:{text:y.thinking??"",done:!0}};if(y.is_subagent){const Y=et(B);if(Y){Y.steps.push(W);return}}B.tools.push(W)}function St(y){const B=d.value;if(B){if(y.is_subagent){const W=et(B);W&&(W.planningLabel=y.label??"");return}B.statusLabel=y.label??""}}function Ot(y){const B=d.value;if(B){if(y.is_subagent){const W=et(B);W&&(W.planningLabel=null,W.steps.push({kind:"plan",text:y.plan??""}));return}B.statusLabel=null,B.tools.push({kind:"plan",text:y.plan??""})}}function qe(y){var Y,q;const B=d.value;if(!B)return;const W={kind:"tool",id:`tool_${Date.now()}`,toolCallId:y.tool_call_id??null,name:y.tool,args:y.args,result:null,success:null,pending:!0,startedAt:Date.now(),isSubagent:y.is_subagent??!1,steps:[],terminalName:y.tool==="terminal"&&((Y=y.args)==null?void 0:Y.terminal_name)||null};if(W.toolCallId&&O.set(W.toolCallId,W),y.is_subagent){const ne=et(B);if(ne){ne.steps.push(W);return}}if(B.tools.push(W),y.tool==="terminal"&&((q=y.args)==null?void 0:q.action)==="open"){const ne=y.args.terminal_name;if(ne){const de=g.value[ne]||{};g.value={...g.value,[ne]:{...de,name:ne,description:y.args.description||"",command:y.args.command||"",background:y.args.background||!1,output:de.output||"",closed:!1}}}}}function lt(y){if(y.is_subagent&&!y.tool_call_id){const W=d.value??te(),Y=W?et(W):null;if(Y)for(let q=Y.steps.length-1;q>=0;q--){const ne=Y.steps[q];if(ne.kind==="tool"&&ne.name===y.tool&&ne.pending){V(ne,y);return}}}let B=y.tool_call_id?O.get(y.tool_call_id)??null:null;if(!B&&!y.tool_call_id){const W=d.value;if(W)for(let Y=W.tools.length-1;Y>=0;Y--){const q=W.tools[Y];if(q.kind==="tool"&&q.name===y.tool&&q.pending){B=q;break}}}B||(B=ve(y)),B&&V(B,y)}function V(y,B){var W,Y,q,ne,de;{if(y.result=B.result,y.success=B.success!==!1,y.pending=!1,B.metadata&&(y.metadata=B.metadata),B.tool==="mcp__navi_ui__render_component"&&y.success&&((W=B.metadata)!=null&&W.ui_component)&&msg.tools.push({kind:"ui_component",component:B.metadata.ui_component.component??"",payload:B.metadata.ui_component.payload??{}}),B.tool==="content_publish"&&y.success&&B.metadata&&L(B.metadata),B.tool==="filesystem"&&y.success&&e.value){const fe=typeof y.args=="object"?(Y=y.args)==null?void 0:Y.action:null;["write","edit","append","mkdir","rm","cp","mv"].includes(fe)&&x(e.value),["write","edit"].includes(fe)&&D(e.value)}if((B.tool==="terminal"||B.tool==="code_exec")&&y.success&&e.value&&x(e.value),B.tool==="terminal"&&y.success&&e.value){const fe=typeof y.args=="object"?(q=y.args)==null?void 0:q.action:null,ye=(ne=y.args)==null?void 0:ne.terminal_name;if(B.metadata){if(fe==="open"||fe==="status"){if(ye){const Ue=g.value[ye]||{};g.value={...g.value,[ye]:{...Ue,...B.metadata,name:ye,closed:!1}}}}else if(fe==="list"&&Array.isArray(B.metadata.terminals))for(const Ue of B.metadata.terminals){if(!Ue.name)continue;const tt=g.value[Ue.name]||{};g.value={...g.value,[Ue.name]:{...tt,...Ue,closed:!1}}}else if(fe==="close"&&ye){const Ue=g.value[ye]||{};g.value={...g.value,[ye]:{...Ue,closed:!0,closeReason:"explicit"}}}}}if(B.tool==="schedule_recall"&&y.success&&e.value&&(Me(e.value),Zn().updateRecallStatus(e.value,!0)),B.tool==="manage_recall"&&y.success&&e.value){const fe=(de=y.args)==null?void 0:de.action;fe==="cancel"?(p.value=null,Zn().updateRecallStatus(e.value,!1)):fe==="skip"&&Me(e.value)}}}function te(){for(let y=n.value.length-1;y>=0;y--){const B=n.value[y];if(B.role==="assistant"&&Array.isArray(B.tools))return B}return null}function ve(y){const B=d.value??te();if(!B)return null;const W={kind:"tool",id:`tool_${Date.now()}`,toolCallId:y.tool_call_id??null,name:y.tool,args:null,result:null,success:null,pending:!1,isSubagent:y.is_subagent??!1,steps:[]};if(W.toolCallId&&O.set(W.toolCallId,W),y.is_subagent){const Y=et(B);if(Y)return Y.steps.push(W),W}return B.tools.push(W),W}function Ie(y){const B=y.task_id;if(B){if(y.parent_tool_call_id){const W=O.get(y.parent_tool_call_id);W&&(W.steps.push({kind:"task_update",taskId:B,tool:y.tool,status:y.status,preview:y.result_preview??""}),y.subagent_tokens!=null&&(W.subagentTokens=y.subagent_tokens))}if(y.status!=="running"){if(b.value[B]){const W={...b.value};delete W[B],b.value=W}}else b.value={...b.value,[B]:{taskId:B,tool:y.tool,status:y.status,startedAt:y.started_at??null}}}}function Be(y){A.value={count:y.queue_len??1,max:y.max??5}}function R(y){const B=y.terminal_name;if(!B)return;const W=g.value[B]||{};g.value={...g.value,[B]:{...W,name:B,closed:!1}}}function k(y){const B=y.terminal_name;if(!B)return;const W=g.value[B]||{output:""},Y={...W,output:(W.output||"")+(y.delta||"")};g.value={...g.value,[B]:Y};const q=d.value;if(q)for(let ne=q.tools.length-1;ne>=0;ne--){const de=q.tools[ne];if(de.kind==="tool"&&de.name==="terminal"&&de.terminalName===B){de.terminalOutput=Y.output;break}}}function z(y){const B=y.terminal_name;if(!B)return;const Y={...g.value[B]||{},closed:!0,closeReason:y.reason||"unknown"};g.value={...g.value,[B]:Y};const q=d.value;if(q)for(let ne=q.tools.length-1;ne>=0;ne--){const de=q.tools[ne];if(de.kind==="tool"&&de.name==="terminal"&&de.terminalName===B&&de.pending){de.pending=!1,de.success=y.reason!=="error";break}}}function K(y){const B=d.value;B&&(B.statusLabel&&(B.statusLabel=null),B.text+=y)}function ee(y){const B=d.value;if(B){B.done=!0,B.elapsed_seconds=(y==null?void 0:y.elapsed_seconds)??null,B.tool_call_count=(y==null?void 0:y.tool_call_count)??null,B.token_count=(y==null?void 0:y.token_count)??null;const W=n.value.filter(Y=>Y.role==="assistant").length-1;B.id=`h_${W}`,d.value=null,!B.thinking&&!B.tools.length&&!B.text&&(n.value=n.value.filter(Y=>Y!==B))}a.value=!1,(y==null?void 0:y.context_tokens)!=null&&(l.value=y.context_tokens),(y==null?void 0:y.max_context_tokens)!=null&&(c.value=y.max_context_tokens),e.value&&(B!=null&&B.text)&&Zn().updatePreview(e.value,B.text.slice(0,80)),e.value&&Cv(e.value)}function X(){const y=d.value;if(y){y.done=!0;const B=n.value.filter(W=>W.role==="assistant").length-1;y.id=`h_${B}`,d.value=null,!y.thinking&&!y.tools.length&&!y.text&&(n.value=n.value.filter(W=>W!==y))}a.value=!1}function _e(y){t.value=y.profile_id}function oe(y){(y==null?void 0:y.context_tokens)!=null&&(l.value=y.context_tokens),(y==null?void 0:y.max_context_tokens)!=null&&(c.value=y.max_context_tokens),n.value.push({id:`compress_pending_${Date.now()}`,role:"system",type:"compression_pending",text:"Compressing context…"})}function le(y){(y==null?void 0:y.context_tokens)!=null&&(l.value=y.context_tokens),(y==null?void 0:y.max_context_tokens)!=null&&(c.value=y.max_context_tokens),n.value=n.value.filter(B=>B.type!=="compression_pending"),n.value.push({id:`compress_${Date.now()}`,role:"system",type:"compression_notice",before:y.messages_before,after:y.messages_after,summary:y.summary??""})}function re(y){a.value=!1,d.value=null,n.value.push({id:`err_${Date.now()}`,role:"system",type:"error",text:y.message??"An error occurred"})}async function Me(y=e.value){if(!y){p.value=null;return}try{const B=await fv(y);B&&B.id?p.value=B:p.value=null}catch{p.value=null}}async function Ce(){if(!(!e.value||M.value||!w.value)){M.value=!0;try{const y=await _v(e.value,v.value),B=Ke(y.items??[]);n.value=[...B,...n.value],w.value=y.has_more??!1,v.value=y.next_before_seq??null}catch(y){console.error("[chat] loadArchivedMessages failed",y)}finally{M.value=!1}}}function Re(y=!1,B=null){w.value=y,v.value=B}function Pe(y){if(!y.session_id)return;const B=Zn(),W=y.status==="pending";B.updateRecallStatus(y.session_id,W),y.session_id===e.value&&(W?Me(y.session_id):p.value=null)}function Ve(y,B,W){n.value.push({id:`user_${Date.now()}`,role:"user",text:y,images:[...B],files:[...W],time:new Date().toISOString(),animate:!0})}function Ke(y){var Y,q,ne;const B=[];let W=0;for(;Wtypeof ye=="string"&&ye.startsWith("data:")?ye:`data:image/jpeg;base64,${String(ye??"")}`);B.push({id:`h_${W}`,role:"user",text:de.content??"",images:fe,files:de.files??[],time:de.created_at??null,rawIndices:[W],isRecall:de.is_recall??!1}),W++;continue}if(de.role==="assistant"){const fe=W,ye=[];let Ue=null,tt="",Rt=null;for(;W=y.length||y[W].role!=="assistant")break}}if(Ue||ye.length||tt){const Fe=`h_${fe}`;let ct=null,at=null,ze=null;for(let P=fe;Pfe+Z)})}continue}W++}return B}return{currentId:e,currentProfileId:t,messages:n,streaming:a,pendingImages:r,pendingFiles:i,artifacts:o,files:s,contextTokens:l,maxContextTokens:c,loading:u,streamingMsg:d,scrollToMessageIndex:m,recall:p,terminals:g,backgroundTasks:b,queuedMessages:A,archiveLoading:M,archiveHasMore:w,archiveNextBefore:v,loadSession:T,clearSession:I,reloadSession:h,fetchArtifacts:D,fetchFiles:x,rateMessage:ae,saveDraft:Ee,loadDraft:xe,appendUserMessage:Ve,buildMessageList:Ke,onStreamStart:Se,onReplayStart:pe,onReplayEnd:Le,onThinkingDelta:be,onThinkingEnd:Xe,onTurnThinking:it,onPlanningStatus:St,onPlanReady:Ot,onToolStarted:qe,onToolCall:lt,onTerminalOutput:k,onTerminalClosed:z,onTerminalOpened:R,onTaskUpdate:Ie,onMessageQueued:Be,onStreamDelta:K,onStreamEnd:ee,onStreamStopped:X,onProfileSwitched:_e,onCompressionStarted:oe,onContextCompressed:le,onError:re,loadRecall:Me,onRecallUpdate:Pe,loadArchivedMessages:Ce,initArchiveState:Re}}),uo=si("auth",()=>{const e=j(null),t=j(!1),n=j(!1),a=ge(()=>e.value!==null),r=ge(()=>{var _;return((_=e.value)==null?void 0:_.role)==="admin"});function i(_){return e.value?e.value.role==="admin"?!0:(e.value.permissions||[]).includes(_):!1}async function o(){var _;console.log("[auth] fetchMe start"),t.value=!0;try{e.value=await av(),console.log("[auth] fetchMe success",e.value)}catch(m){console.log("[auth] fetchMe error",m.message),(_=m.message)!=null&&_.includes("401")&&(e.value=null)}finally{t.value=!1,console.log("[auth] fetchMe loading=false")}}const s=j(!0);async function l(){console.log("[auth] fetchStatus start");try{const _=await fetch("/auth/status");if(console.log("[auth] fetchStatus response",_.status,_.ok),_.ok){const m=await _.json();console.log("[auth] fetchStatus data",m),s.value=m.enabled!==!1,n.value=!!m.configured,console.log("[auth] fetchStatus authEnabled set to",s.value),console.log("[auth] fetchStatus authConfigured set to",n.value)}else console.log("[auth] fetchStatus not ok"),s.value=!0,n.value=!1}catch(_){console.log("[auth] fetchStatus error",_),s.value=!0,n.value=!1}}function c(){const _=navigator.userAgent.includes("NaviAndroid"),m=new URLSearchParams;_&&m.set("platform","android");const p=m.toString();window.location.href="/auth/login"+(p?"?"+p:"")}async function u(){try{await rv()}catch{}e.value=null,window.location.reload()}const d=ge(()=>!s.value);return{user:e,loading:t,authConfigured:n,authEnabled:s,isAuthenticated:a,isAdmin:r,isNoAuthMode:d,hasPermission:i,fetchMe:o,fetchStatus:l,login:c,logout:u}}),yv=Object.freeze(Object.defineProperty({__proto__:null,useAuthStore:uo},Symbol.toStringTag,{value:"Module"})),ld="/images/logo.svg";function Nv(e){return{all:e=e||new Map,on:function(t,n){var a=e.get(t);a&&a.push(n)||e.set(t,[n])},off:function(t,n){var a=e.get(t);a&&a.splice(a.indexOf(n)>>>0,1)},emit:function(t,n){(e.get(t)||[]).slice().map(function(a){a(n)}),(e.get("*")||[]).slice().map(function(a){a(t,n)})}}}function cd(e,t,n){if(!n)return t;const a=e==null?void 0:e[n];if(a==null)throw new Error(`Key is ${a} on item (keyField is '${n}')`);return a}function Ka(e,t){return e.map((n,a)=>cd(n,a,t))}function Ov(e,t,n){const a=[],r=[];for(let i=0;i0?l:null)}return{keys:a,sizes:r}}function Av(e,t,n){if(!e||e.keys.length!==t.length||e.sizes.length!==t.length)return!1;for(let a=0;a0&&(a[e.keys[r]]=i)}return a}function ES(e,t){if(!e.length||t.length<=e.length)return 0;const n=e[0],a=t.indexOf(n);if(a<=0||a+e.lengtht.length-a)return 0;for(let r=0;r=n&&l<=s?null:e{}:n.onVscrollUpdate(b),d=ge(()=>{const L=De(e);if(n.vscrollData.simpleArray){if(L.index==null)throw new Error("index is required when using simple-array mode with dynamic item measurement");return L.index}if(n.vscrollData.keyField in L.item)return L.item[n.vscrollData.keyField];throw new Error(`keyField '${n.vscrollData.keyField}' not found in your item. You should set a valid keyField prop on your Scroller`)}),_=ge(()=>n.vscrollData.sizes[d.value]||0),m=ge(()=>De(e).active&&n.vscrollData.active);function p(){m.value?i!==d.value&&(i=d.value,r=null,o=null,w(d.value)):r=d.value}function g(){De(e).watchData&&!n.resizeObserver?l=je(()=>De(e).item,()=>{A()},{deep:!0}):l&&(l(),l=null)}function b({force:L}){!m.value&&L&&(o=d.value),(r===d.value||L||!_.value)&&p()}function A(){p()}function O(L){n.undefinedMap[L]&&n.undefinedSizeCount.value--,n.undefinedMap[L]=void 0}function M(L,ae){if(n.vscrollData.sizes[L]){O(L);return}if(ae){n.undefinedMap[L]||n.undefinedSizeCount.value++,n.undefinedMap[L]=!0;return}n.undefinedMap[L]&&(n.undefinedSizeCount.value--,n.undefinedMap[L]=!1)}function w(L){Ht(()=>{if(d.value===L){const ae=De(t);if(!ae)return;const Ee=ae.offsetWidth,xe=ae.offsetHeight;v(Ee,xe)}i=null})}function v(L,ae){const Ee=~~(n.direction.value==="vertical"?ae:L);Ee&&_.value!==Ee&&T(Ee)}function T(L){var ae,Ee;O(d.value),n.vscrollData.sizes[d.value]=L,De(e).emitResize&&((Ee=(ae=De(a))==null?void 0:ae.onResize)==null||Ee.call(ae,d.value))}function I(){if(!n.resizeObserver||s)return;const L=De(t);L&&(n.resizeObserver.observe(L),L.$_vs_id=d.value,L.$_vs_onResize=E,s=!0)}function h(){if(!n.resizeObserver||!s)return;const L=De(t);L&&(n.resizeObserver.unobserve(L),L.$_vs_onResize=void 0,s=!1)}function E(L,ae,Ee){d.value===L&&v(ae,Ee)}c.push(je(()=>De(e).watchData,()=>{g()})),n.resizeObserver||c.push(je(()=>De(e).sizeDependencies,()=>{A()},{deep:!0})),c.push(je(d,(L,ae)=>{const Ee=De(t);Ee&&(Ee.$_vs_id=L),O(ae),M(L,m.value);const xe=n.vscrollData.sizes[L];if(!xe){r=L,A();return}O(L),s&&(n.vscrollData.sizes[L]=xe)})),c.push(je(m,L=>{M(d.value,L),n.resizeObserver?L?I():h():L&&o===d.value&&p()})),g();function D(){m.value&&(p(),I())}function x(){u(),h(),O(d.value);const L=De(t);L&&(L.$_vs_id=void 0,L.$_vs_onResize=void 0),l&&(l(),l=null);for(const ae of c)ae();c.length=0}return{id:d,size:_,finalActive:m,updateSize:p,mount:D,unmount:x}}const Iv={itemsLimit:1e3};function SS(e){return typeof window<"u"&&e===window}const Dv=(()=>{if(typeof document>"u")return"negative";const e=document.createElement("div"),t=document.createElement("div");e.style.width="4px",e.style.height="1px",e.style.overflow="auto",e.style.direction="rtl",t.style.width="8px",t.style.height="1px",e.appendChild(t),document.body.appendChild(e),e.scrollLeft=-1;const n=e.scrollLeft<0;return document.body.removeChild(e),n?"negative":"default"})();function ur(e,t,n){return t!=="horizontal"||!n||SS(n)||getComputedStyle(n).direction!=="rtl"?e:Dv==="negative"?-e:e}function xv(e,t,n){return ur(e,t,n)}function Ao(e,t,n,a){const r=xv(n,t,e),i=!!(a!=null&&a.smooth);if(SS(e)){t==="vertical"?e.scrollTo({top:r,behavior:i?"smooth":"auto"}):e.scrollTo({left:r,behavior:i?"smooth":"auto"});return}if(typeof e.scrollTo=="function"){e.scrollTo(t==="vertical"?{top:r,behavior:i?"smooth":"auto"}:{left:r,behavior:i?"smooth":"auto"});return}t==="vertical"?e.scrollTop=r:e.scrollLeft=r}function Mv(e,t,n){return n?t==="vertical"?window.innerHeight:window.innerWidth:t==="vertical"?e.clientHeight:e.clientWidth}const wv=/auto|scroll/;function bS(e,t){return e.parentNode===null?t:bS(e.parentNode,[...t,e])}function Io(e,t){return getComputedStyle(e,null).getPropertyValue(t)}function Lv(e){return Io(e,"overflow")+Io(e,"overflow-y")+Io(e,"overflow-x")}function Pv(e){return wv.test(Lv(e))}function bi(e){if(!(e instanceof HTMLElement||e instanceof SVGElement))return;const t=bS(e.parentNode,[]);for(let n=0;n{const Y=De(e);return Y.items.length>0&&typeof Y.items[0]!="object"}),ae=ge(()=>{const Y=De(e);if(Y.itemSize===null){const q={[-1]:{accumulator:0}},ne=Y.items,de=Y.sizeField??"size",fe=Y.minItemSize,ye=x.value;let Ue=1e4,tt=0,Rt;for(let Fe=0,ct=ne.length;Fei.value.filter(Y=>Y.nr.used).sort((Y,q)=>Y.nr.index-q.nr.index)),xe=ge(()=>{const Y=De(e),q=L.value?null:Y.keyField;return Ov(Y.items,q,(ne,de,fe)=>Y.itemSize!=null?Y.itemSize:x.value[fe]||(ne==null?void 0:ne[Y.sizeField??"size"])||void 0)});function Se(Y){const q=De(e);return x.value=Lu(Y,q.items,L.value?null:q.keyField),Object.keys(x.value).length>0}function pe(Y){let q=d.get(Y);return q||(q=[],d.set(Y,q)),q}function Le(Y,q,ne,de,fe){const ye=Sr({id:Uv++,index:q,used:!0,key:de,type:fe}),Ue=sf({item:ne,position:0,offset:0,nr:ye,_vs_styleStamp:0});return Y.push(Ue),Ue}function be(Y){const q=pe(Y);if(q&&q.length){const ne=q.pop();return ne.nr.used=!0,Do(ne),ne}}function Xe(Y){const q=Y.nr.type;pe(q).push(Y),Y.nr.used=!1,Y.position=-9999,Do(Y),u.delete(Y.nr.key)}function et(){u.clear(),d.clear();for(let Y=0,q=i.value.length;Y{D.delete(q),Y()}),D.add(q),q}function St(){for(const Y of D)cancelAnimationFrame(Y);D.clear()}function Ot(){b&&(clearTimeout(b),b=null),A&&(clearTimeout(A),A=null),O&&(clearTimeout(O),O=null),I&&(clearTimeout(I),I=null),h&&(clearTimeout(h),h=null)}function qe(){var Y;(Y=r==null?void 0:r.onResize)==null||Y.call(r),s.value&&Re(!1)}function lt(){T&&!E&&K();const Y=De(e);if(!_){if(_=!0,b)return;const q=()=>it(()=>{_=!1;const{continuous:ne}=Re(!1,!0);ne||(A&&clearTimeout(A),A=setTimeout(lt,Y.updateInterval+100))});q(),Y.updateInterval&&(b=setTimeout(()=>{b=null,_&&q()},Y.updateInterval))}}function V(Y,q){var ne,de;s.value&&(Y||q.boundingClientRect.width!==0||q.boundingClientRect.height!==0?((ne=r==null?void 0:r.onVisible)==null||ne.call(r),it(()=>{Re(!1)})):(de=r==null?void 0:r.onHidden)==null||de.call(r))}function te(){const Y=De(t),q=Y?bi(Y):void 0;return window.document&&(q===window.document.documentElement||q===window.document.body)?window:q||window}function ve(){const Y=De(n);return Y?De(e).direction==="vertical"?Y.scrollHeight:Y.scrollWidth:0}function Ie(){const Y=De(t);if(!Y)return{start:0,end:0};const q=De(e),ne=q.direction==="vertical";let de;if(q.pageMode){const fe=Y.getBoundingClientRect(),ye=ne?fe.height:fe.width;let Ue=-(ne?fe.top:fe.left),tt=ne?window.innerHeight:window.innerWidth;Ue<0&&(tt+=Ue,Ue=0),Ue+tt>ye&&(tt=ye-Ue),de={start:Ue,end:Ue+tt}}else ne?de={start:Y.scrollTop,end:Y.scrollTop+Y.clientHeight}:de={start:ur(Y.scrollLeft,q.direction,Y),end:ur(Y.scrollLeft,q.direction,Y)+Y.clientWidth};return de}function Be(){const Y=De(t);if(!Y)return{start:0,end:0};if(De(e).direction==="vertical"){const q=ur(Y.scrollLeft,"horizontal",Y);return{start:q,end:q+Y.clientWidth}}return{start:Y.scrollTop,end:Y.scrollTop+Y.clientHeight}}function R(Y){const q=De(e);if(q.itemSize!=null)return q.itemSize;const ne=ae.value[Y];return(ne==null?void 0:ne.size)||Number(q.minItemSize)||0}function k(Y){var q;const ne=De(e),de=ne.gridItems||1;return Y<=0?0:ne.itemSize!=null?Math.floor(Y/de)*ne.itemSize:((q=ae.value[Y-1])==null?void 0:q.accumulator)||0}function z(Y){const q=De(e),ne=q.items.length,de=q.gridItems||1;if(!ne)return 0;if(q.itemSize!=null){const tt=Math.floor(Y/q.itemSize)*de;return Math.min(Math.max(tt,0),ne-1)}let fe=0,ye=ne-1,Ue=0;for(;fe<=ye;){const tt=Math.floor((fe+ye)/2);k(tt)<=Y?(Ue=tt,fe=tt+1):ye=tt-1}return Ue}function K(){I&&(clearTimeout(I),I=null),T=null}function ee(){I&&clearTimeout(I),I=setTimeout(()=>{T=null,I=null},150)}function X(Y,q){if(!Y.length){K();return}const ne=Math.max(Ie().start-ve(),0),de=Math.min(z(ne),Y.length-1),fe=Y[de],ye=q?fe==null?void 0:fe[q]:de;if(ye==null){K();return}const Ue=ve()+k(de);T={key:ye,offset:Ie().start-Ue}}function _e(Y){if(!T)return!1;const q=De(e),ne=Y??q.items,de=L.value?null:q.keyField,fe=Ka(ne,de).indexOf(T.key);if(fe===-1)return K(),!1;const ye=ve()+k(fe)+T.offset,Ue=Ie().start;return Math.abs(ye-Ue)<.5?!1:(E=!0,B(ye),it(()=>{E=!1}),!0)}function oe(){De(e).pageMode?le():re()}function le(){w=te(),w.addEventListener("scroll",lt,kv()?{passive:!0}:!1),w.addEventListener("resize",qe)}function re(){w&&(w.removeEventListener("scroll",lt),w.removeEventListener("resize",qe),w=null)}function Me(Y,q,ne,de,fe,ye){const Ue=Math.ceil(Y/q)*ne,tt=Math.max(0,Math.floor(fe.start/ne)),Rt=Math.min(Math.ceil(fe.end/ne),Math.ceil(Y/q)),Fe=Math.max(0,Math.floor(ye.start/de)),ct=Math.min(Math.ceil(ye.end/de),q),at=[];for(let Z=tt;Z=Y)break;at.push($)}}const ze=at[0]??0,P=at.at(-1)??-1;return{renderedIndices:at,startIndex:ze,endIndex:P+1,visibleStartIndex:ze,visibleEndIndex:P,totalSize:Ue}}function Ce(){const Y=De(e);if(!Y.gridItems||Y.itemSize==null)return!1;const q=De(t);if(!q)return!1;const ne=Y.itemSecondarySize||Y.itemSize,de=Y.direction==="vertical"?q.clientWidth:q.clientHeight;return ne*Y.gridItems>de}function Re(Y,q=!1){var ne,de;const fe=De(e),ye=fe.itemSize,Ue=fe.gridItems||1,tt=fe.itemSecondarySize||ye,Rt=M,Fe=fe.typeField,ct=L.value?null:fe.keyField,at=fe.items,ze=at.length,P=ae.value,Z=u,he=i.value;let G=null,$=null,Ne,H,ce,Oe,Je;if(!ze)Ne=H=Oe=Je=ce=0;else if(g)Ne=Oe=0,H=Je=Math.min(fe.prerender,at.length),ce=0;else{const st=Ie(),Pt=Be();if(q){let Ct=st.start-m;Ct<0&&(Ct=-Ct);let In=Pt.start-p;In<0&&(In=-In);const Bn=ye===null&&Ct>=Rt||ye!==null&&Ct>=ye,At=Ue>1&&ye!=null&&In>=tt;if(!Bn&&!At)return{continuous:!0}}m=st.start,p=Pt.start;const Kt=fe.buffer;st.start-=Kt,st.end+=Kt,Pt.start-=Kt,Pt.end+=Kt;let hn=0;const Fn=De(n);Fn&&(hn=Fn.scrollHeight,st.start-=hn);const bt=De(a);if(bt){const Ct=bt.scrollHeight;st.end+=Ct}if(ye===null){let Ct,In=0,Bn=ze-1,At=~~(ze/2),ta;do ta=At,Ct=P[At].accumulator,Ctst.start&&(Bn=At),At=~~((In+Bn)/2);while(At!==ta);for(At<0&&(At=0),Ne=At,ce=P[ze-1].accumulator,H=At;Hze&&(H=ze)),Oe=Ne;Oe1){const Ct=Me(ze,Ue,ye,tt,st,Pt);G=Ct.renderedIndices,$=new Set(G),Ne=Ct.startIndex,H=Ct.endIndex,Oe=Ct.visibleStartIndex,Je=Ct.visibleEndIndex,ce=Ct.totalSize}else{Ne=~~(st.start/ye*Ue);const Ct=Ne%Ue;Ne-=Ct,H=Math.ceil(st.end/ye*Ue),Oe=Math.max(0,Math.floor((st.start-hn)/ye*Ue)),Je=Math.floor((st.end-hn)/ye*Ue),Ne<0&&(Ne=0),H>ze&&(H=ze),Oe<0&&(Oe=0),Je>ze&&(Je=ze),ce=Math.ceil(ze/Ue)*ye}}H-Ne>Iv.itemsLimit&&Pe(),o.value=ce;let $e;const Yt=Ne<=c&&H>=l;if(!Yt||Y)et();else for(let st=0,Pt=he.length;st=Ne&&$e.nr.indexNe+Pt);for(const st of An){if(!(ye||P[st]&&P[st].size))continue;$t=at[st];const Pt=ct?$t[ct]:st;if(Pt==null)throw new Error(`Key is ${Pt} on item (keyField is '${ct}')`);if($e=Z.get(Pt),$e)$e.item!==$t&&($e.item=$t),$e.nr.used||console.warn(`Expected existing view's used flag to be true, got ${$e.nr.used}`);else{if(Xt=$t[Fe],$e=be(Xt),$e){const Kt=$e.nr.index!==st||$e.nr.key!==Pt;$e.item=$t,$e.nr.index=st,$e.nr.key=Pt,$e.nr.type!==Xt&&console.warn("Reused view's type does not match pool's type"),Kt&&Do($e)}else $e=Le(he,st,$t,Pt,Xt);Z.set(Pt,$e)}ye===null?($e.position=((ne=P[st-1])==null?void 0:ne.accumulator)||0,$e.offset=0):($e.position=Math.floor(st/Ue)*ye,$e.offset=st%Ue*tt)}return l=Ne,c=H,fe.emitUpdate&&((de=r==null?void 0:r.onUpdate)==null||de.call(r,Ne,H,Oe,Je)),O&&clearTimeout(O),O=setTimeout(Ke,fe.updateInterval+300),{continuous:Yt}}function Pe(){throw h=setTimeout(()=>{h=null,console.warn("It seems the scroller element isn't scrolling, so it tries to render all the items at once.","Scroller:",De(t)),console.warn("Make sure the scroller has a fixed height (or width) and 'overflow-y' (or 'overflow-x') set to 'auto' so it can scroll correctly and only render the items visible in the scroll viewport.")}),new Error("Rendered items limit reached")}function Ve(){if(Ce())return!1;const Y=i.value.filter(({nr:q})=>q.used);for(let q=1;qY.nr.index-q.nr.index),Ve()&&(Re(!1),O&&clearTimeout(O))}function y(Y,q){const ne=De(e),de=De(t);if(!de)return;const fe=Math.max(0,Math.min(Y,ne.items.length-1)),ye=Ie().start,Ue=Mv(de,ne.direction,ne.pageMode),tt=k(fe),Rt=R(fe),Fe=R_(tt,Rt,ye,Ue,q==null?void 0:q.align,(q==null?void 0:q.offset)??0);if(Fe!=null&&(B(Fe,q),ne.gridItems&&ne.itemSize!=null)){const ct=De(t);if(!ct)return;const at=ne.gridItems,ze=ne.itemSecondarySize||ne.itemSize,P=fe%at*ze,Z=ne.direction==="vertical"?"horizontal":"vertical",he=Z==="horizontal"?ur(ct.scrollLeft,"horizontal",ct):ct.scrollTop,G=Z==="horizontal"?ct.clientWidth:ct.clientHeight,$=R_(P,ze,he,G,q==null?void 0:q.align,(q==null?void 0:q.offset)??0);$!=null&&Ao(ct,Z,$,q)}}function B(Y,q){const ne=De(e),de=De(t);if(de)if(ne.pageMode){const fe=bi(de),ye=fe.getBoundingClientRect(),Ue=de.getBoundingClientRect(),tt=ne.direction==="vertical"?"top":"left",Rt=bi(de)===document.documentElement||bi(de)===document.body?ne.direction==="vertical"?window.scrollY:window.scrollX:ur(ne.direction==="vertical"?fe.scrollTop:fe.scrollLeft,ne.direction,fe),Fe=Ue[tt]-ye[tt];Ao(fe.tagName==="HTML"?window:fe,ne.direction,Y+Rt+Fe,q)}else Ao(de,ne.direction,Y,q)}const W=De(e);return v=Ka(W.items,W.items.length>0&&typeof W.items[0]!="object"?null:W.keyField),W.cache&&Se(W.cache),W.prerender&&(g=!0,Re(!1)),W.gridItems&&!W.itemSize&&console.error("[vue-recycle-scroller] You must provide an itemSize when using gridItems"),En(()=>{oe(),Ht(()=>{g=!1,Re(!0),s.value=!0})}),ad(()=>{const Y=m;typeof Y=="number"&&Ht(()=>{B(Y)})}),Tn(()=>{Ot(),St(),re()}),je(()=>De(e).cache,Y=>{Se(Y),Re(!0)}),je(()=>De(e).items,(Y,q)=>{const ne=De(e),de=L.value?null:ne.keyField,fe=Ka(Y,de);if(ne.shift){const ye=q?Ka(q,de):v;ES(ye,fe)>0?X(q??[],de):K()}else K();v=fe,_e(Y),Re(!0)}),je(()=>De(e).pageMode,()=>{oe(),Re(!1)}),je(ae,()=>{_e()&&ee(),Re(!1)},{deep:!0}),je(()=>De(e).gridItems,()=>{Re(!0)}),je(()=>De(e).itemSecondarySize,()=>{Re(!0)}),{pool:i,visiblePool:Ee,totalSize:o,ready:s,sizes:ae,simpleArray:L,scrollToItem:y,scrollToPosition:B,getScroll:Ie,findItemIndex:z,getItemOffset:k,getItemSize:R,cacheSnapshot:xe,restoreCache:Se,updateVisibleItems:Re,handleScroll:lt,handleResize:qe,handleVisibilityChange:V,sortViews:Ke}}function ku(e){return e.item}function Bv(e){return e._vs_styleStamp??0}const hS=["position","top","left","transform","willChange","visibility","pointerEvents"];function C_(e){const t={};for(const n of hS)t[n]=e.style[n];return t}function vS(e,t){for(const n of hS)e.style[n]=t[n]??""}function y_(e,t,n,a){if(!("view"in t)){vS(e,a);return}const r=n==="vertical",i=e.tagName==="TR",o=r?`translateY(${t.view.position}px) translateX(${t.view.offset}px)`:`translateX(${t.view.position}px) translateY(${t.view.offset}px)`;e.style.position="absolute",e.style.top=r&&i?`${t.view.position}px`:"0px",e.style.left=!r&&i?`${t.view.position}px`:"0px",e.style.transform=i?"":o,e.style.willChange=i?"unset":"transform",e.style.visibility=t.view.nr.used?"visible":"hidden",e.style.pointerEvents=t.view.nr.used?"":"none"}function N_(e){return"view"in e?{item:ku(e.view).item,active:e.view.nr.used,index:e.view.nr.index,watchData:e.watchData??!1,emitResize:e.emitResize??!1,sizeDependencies:e.sizeDependencies??null,onResize:e.onResize}:{watchData:!1,emitResize:!1,sizeDependencies:null,...e}}function O_(e,t,n,a){return n?a??null:(e==null?void 0:e[t])??null}function Gv(e){let t=0,n={};const a=Nv();let r=!1,i,o=!1,s=[],l=null,c=null;const u=new Set,d=ja({active:!0,sizes:{},keyField:De(e).keyField,simpleArray:!1}),_=ge(()=>De(e).direction),m=ge(()=>De(De(e).el)),p=ge(()=>De(De(e).before)),g=ge(()=>De(De(e).after)),b=new Map;function A(V){let te=-1;return te=requestAnimationFrame(()=>{u.delete(te),V()}),u.add(te),te}function O(){for(const V of u)cancelAnimationFrame(V);u.clear()}typeof ResizeObserver<"u"&&(i=new ResizeObserver(V=>{A(()=>{if(Array.isArray(V)){for(const te of V)if(te.target&&te.target.$_vs_onResize){let ve,Ie;if(te.borderBoxSize){const Be=te.borderBoxSize[0];ve=Be.inlineSize,Ie=Be.blockSize}else ve=te.contentRect.width,Ie=te.contentRect.height;te.target.$_vs_onResize(te.target.$_vs_id,ve,Ie)}}})}));const M={vscrollData:d,resizeObserver:i,direction:_,undefinedMap:n,undefinedSizeCount:{get value(){return t},set value(V){t=V}},onVscrollUpdate(V){const te=ve=>{V(ve)};return a.on("vscroll:update",te),()=>a.off("vscroll:update",te)}};Va("vscrollData",d),Va("vscrollParent",{get $_undefinedSizes(){return t},set $_undefinedSizes(V){t=V},get $_undefinedMap(){return n},set $_undefinedMap(V){n=V},$_events:a,direction:_}),Va("vscrollResizeObserver",i),Va("vscrollMeasurementContext",M),Va("vscrollAnchorRegistry",{delete(V){b.delete(V)},set(V,te){b.set(V,te)}});const w=ge(()=>{const V=De(e);return V.items.length>0&&typeof V.items[0]!="object"}),v=ge(()=>{const V=[],te=De(e),{items:ve,keyField:Ie}=te,Be=w.value,R=d.sizes,k=ve.length;for(let z=0;z"u"&&!n[ee]&&(X=0),V.push({item:K,id:ee,size:X})}return V}),T=De(e);s=Ka(T.items,w.value?null:T.keyField),T.cache&&(d.sizes=Lu(T.cache,T.items,w.value?null:T.keyField));const I=ge(()=>{const V=De(e);return{items:v.value,keyField:"id",direction:V.direction,itemSize:null,gridItems:void 0,itemSecondarySize:void 0,minItemSize:V.minItemSize,sizeField:"size",typeField:"type",buffer:V.buffer??200,pageMode:V.pageMode??!1,shift:!1,cache:V.cache,prerender:V.prerender??0,emitUpdate:V.emitUpdate??!1,updateInterval:V.updateInterval??0}});function h(){var V,te;et(),(te=(V=De(e)).onResize)==null||te.call(V)}function E(){var V,te;a.emit("vscroll:update",{force:!1}),(te=(V=De(e)).onVisible)==null||te.call(V)}const D=TS(I,m,p,g,{onResize:h,onVisible:E,onHidden:()=>{var V,te;return(te=(V=De(e)).onHidden)==null?void 0:te.call(V)},onUpdate:(V,te,ve,Ie)=>{var Be,R;return(R=(Be=De(e)).onUpdate)==null?void 0:R.call(Be,V,te,ve,Ie)}}),x=new WeakMap;function L(){c!=null&&(cancelAnimationFrame(c),u.delete(c),c=null)}function ae(){L(),l=null}function Ee(){l==null||c!=null||(c=A(()=>{c=null,Le()}))}function xe(){const V=m.value;if(!V)return null;const te=V.getBoundingClientRect();let ve=null;for(const[Ie,Be]of b.entries()){if(!Be.active||getComputedStyle(Ie).visibility==="hidden")continue;const R=Ie.getBoundingClientRect();if(R.bottom<=te.top||R.top>=te.bottom)continue;const k=Math.max(R.top,te.top)-te.top;(!ve||k{o=!1}),!0)}function Le(){const V=l,te=m.value;if(!V||!te)return;const ve=v.value.findIndex(k=>k.id===V.logicalKey);if(ve===-1){ae();return}let Ie=!1;const Be=D.getItemOffset(ve)+V.logicalOffset;if(Ie=pe(Be)||Ie,V.visualKey!=null)for(const[k,z]of b.entries()){if(!z.active||z.id!==V.visualKey||getComputedStyle(k).visibility==="hidden")continue;const K=k.getBoundingClientRect().top-te.getBoundingClientRect().top-V.visualOffset;Ie=pe(te.scrollTop+K)||Ie;break}let R=!0;for(const k of V.pendingKeys)if(!(typeof d.sizes[k]=="number"&&d.sizes[k]>0)){R=!1;break}if(!Ie&&R){if(V.stableFrames++,V.stableFrames>=2){ae();return}}else V.stableFrames=0;Ee()}function be(V,te,ve,Ie){const Be=Wu(),R=_r(te),k=_r(ve),z=_r({onResize:ve.onResize}),K=_r(V),ee=Be.run(()=>(je(()=>{const X=R.value;if(!("view"in X))return{active:k.value.active,direction:_.value,id:O_(k.value.item,De(e).keyField,d.simpleArray,k.value.index),legacy:!0};const{view:_e}=X;return{active:_e.nr.used,direction:_.value,id:ku(_e).id,legacy:!1,position:_e.position,offset:_e.offset,styleStamp:Bv(_e)}},()=>{const X=K.value;if(X){const _e=R.value,oe="view"in _e?ku(_e.view).id:O_(k.value.item,De(e).keyField,d.simpleArray,k.value.index);oe!=null&&b.set(X,{active:k.value.active&&d.active,id:oe}),y_(X,R.value,_.value,Ie)}},{immediate:!0}),fS(k,K,M,z)));ee.mount(),x.set(V,{binding:R,scope:Be,options:k,callbacks:z,el:K,controller:ee,restoreStyles:Ie})}const Xe={mounted(V,te){const ve=C_(V);be(V,te.value,N_(te.value),ve)},updated(V,te){const ve=x.get(V),Ie=N_(te.value);if(!ve){const Be=C_(V);be(V,te.value,Ie,Be);return}ve.binding.value=te.value,ve.options.value=Ie,ve.callbacks.value={onResize:Ie.onResize},ve.el.value=V,y_(V,te.value,_.value,ve.restoreStyles)},unmounted(V){const te=x.get(V);te&&(te.controller.unmount(),te.scope.stop(),vS(V,te.restoreStyles),b.delete(V),x.delete(V))}};function et(V=!1){(V||w.value)&&(d.sizes={}),a.emit("vscroll:update",{force:!0})}function it(V,te){D.scrollToItem(V,te)}function St(V){const te=De(e);return d.sizes=Lu(V,te.items,w.value?null:te.keyField),D.restoreCache(V)}function Ot(V,te){const ve=De(e),Ie=w.value?te??ve.items.indexOf(V):V[ve.keyField];return d.sizes[Ie]||0}function qe(){const V=m.value;V&&(r||(r=!0,Ht(()=>{V.scrollTop=V.scrollHeight+5e3;const te=()=>{V.scrollTop=V.scrollHeight+5e3,A(()=>{V.scrollTop=V.scrollHeight+5e3,t===0?r=!1:A(te)})};A(te)})))}function lt(){l&&!o&&ae()}return je(()=>De(e).items,(V,te)=>{const ve=De(e),Ie=w.value?null:ve.keyField,Be=Ka(V,Ie);if(ve.shift){const R=te?Ka(te,Ie):s,k=ES(R,Be);k>0?(Se(R),l&&(l.pendingKeys=new Set(Be.slice(0,k)),l.stableFrames=0,Ht(()=>{l&&Le()}))):ae()}else ae();s=Be,et()},{flush:"sync"}),je(()=>De(e).cache,V=>{V&&St(V)}),je(w,V=>{d.simpleArray=V},{immediate:!0}),je(()=>De(e).direction,()=>{ae(),et(!0)}),je(m,(V,te)=>{te==null||te.removeEventListener("scroll",lt),V==null||V.addEventListener("scroll",lt)},{immediate:!0}),je(v,(V,te)=>{const ve=m.value;if(!ve)return;if(l){Le();return}const Ie=ve.scrollTop,Be=De(e);let R=0,k=0;const z=Math.min(V.length,te.length);for(let ee=0;ee=Ie);ee++)R+=te[ee].size||Be.minItemSize,k+=V[ee].size||Be.minItemSize;const K=k-R;K!==0&&(ve.scrollTop+=K)},{flush:"post"}),ad(()=>{d.active=!0}),Cf(()=>{d.active=!1}),ea(()=>{var V;L(),O(),(V=m.value)==null||V.removeEventListener("scroll",lt),a.all.clear()}),{vscrollData:d,itemsWithSize:v,resizeObserver:i,measurementContext:M,vDynamicScrollerItem:Xe,...D,simpleArray:w,forceUpdate:et,scrollToItem:it,restoreCache:St,getItemSize:Ot,scrollToBottom:qe,onScrollerResize:h,onScrollerVisible:E}}const ud=new WeakMap;function Yv(e){return typeof e=="function"?{callback:e,observer:null,intersection:void 0,visible:null}:{callback:e.callback,observer:null,intersection:e.intersection,visible:null}}function A_(e,t){RS(e);const n=Yv(t.value);if(ud.set(e,n),typeof IntersectionObserver>"u"){const a=e.getBoundingClientRect();n.visible=!0,n.callback(!0,{boundingClientRect:a});return}n.observer=new IntersectionObserver(a=>{const r=a[0],i=!!(r!=null&&r.isIntersecting);n.visible!==null&&n.visible===i||(n.visible=i,n.callback(i,r))},n.intersection),n.observer.observe(e)}function RS(e){const t=ud.get(e);t!=null&&t.observer&&(t.observer.disconnect(),t.observer=null)}const $v={mounted(e,t){A_(e,t)},updated(e,t){t.value!==t.oldValue&&A_(e,t)},unmounted(e){RS(e),ud.delete(e)}},qv=We({__name:"ItemView",props:{view:{},itemTag:{}},setup(e){const t=e;return(n,a)=>(N(),ut(ii(t.itemTag),{class:"vue-recycle-scroller__item-view"},{default:_t(()=>[Xn(n.$slots,"default",{item:t.view.item,index:t.view.nr.index,active:t.view.nr.used})]),_:3}))}}),Hv=We({__name:"ResizeObserver",emits:["notify"],setup(e,{emit:t}){const n=t,a=j();let r=null,i=null;function o(){n("notify")}return En(()=>{var s;const l=(s=a.value)==null?void 0:s.parentElement;if(l){if(typeof ResizeObserver<"u"){r=new ResizeObserver(()=>{o()}),r.observe(l);return}i=()=>o(),window.addEventListener("resize",i)}}),Tn(()=>{r&&(r.disconnect(),r=null),i&&(window.removeEventListener("resize",i),i=null)}),(s,l)=>(N(),U("div",{ref_key:"el",ref:a,class:"vue-recycle-scroller__resize-observer","aria-hidden":"true"},null,512))}}),Vv=(e,t)=>{const n=e.__vccOpts||e;for(const[a,r]of t)n[a]=r;return n},zv=Vv(Hv,[["__scopeId","data-v-08cc04ab"]]),Wv=We({__name:"RecycleScroller",props:{items:{},keyField:{default:"id"},direction:{default:"vertical"},listTag:{default:"div"},itemTag:{default:"div"},itemSize:{default:null},gridItems:{default:void 0},itemSecondarySize:{default:void 0},minItemSize:{default:null},sizeField:{default:"size"},typeField:{default:"type"},buffer:{default:200},pageMode:{type:Boolean,default:!1},shift:{type:Boolean,default:!1},cache:{default:void 0},prerender:{default:0},emitUpdate:{type:Boolean,default:!1},disableTransform:{type:Boolean,default:!1},updateInterval:{default:0},skipHover:{type:Boolean,default:!1},listClass:{default:""},itemClass:{default:""}},emits:["resize","visible","hidden","update","scrollStart","scrollEnd"],setup(e,{expose:t,emit:n}){const a=e,r=n,i=$v,o=j(),s=j(),l=j(),c=j(null),u=TS(a,o,s,l,{onResize:()=>r("resize"),onVisible:()=>r("visible"),onHidden:()=>r("hidden"),onUpdate:(Ee,xe,Se,pe)=>{r("update",Ee,xe,Se,pe),Se<=0&&r("scrollStart"),pe>=a.items.length-1&&r("scrollEnd")}}),{pool:d,visiblePool:_,totalSize:m,ready:p,scrollToItem:g,scrollToPosition:b,getScroll:A,findItemIndex:O,getItemOffset:M,getItemSize:w,cacheSnapshot:v,restoreCache:T,updateVisibleItems:I,handleScroll:h,handleResize:E,handleVisibilityChange:D}=u;function x(Ee){c.value=Ee}function L(){c.value=null}const ae=ge(()=>{const Ee={[a.direction==="vertical"?"minHeight":"minWidth"]:`${m.value}px`};if(a.gridItems&&a.itemSize!=null){const xe=(a.itemSecondarySize||a.itemSize)*a.gridItems;Ee[a.direction==="vertical"?"minWidth":"minHeight"]=`${xe}px`}return Ee});return t({el:o,visiblePool:_,scrollToItem:g,scrollToPosition:b,getScroll:A,findItemIndex:O,getItemOffset:M,getItemSize:w,cacheSnapshot:v,restoreCache:T,updateVisibleItems:I}),(Ee,xe)=>Ha((N(),U("div",{ref_key:"el",ref:o,class:He(["vue-recycle-scroller",{"grid-mode":a.gridItems,ready:J(p),"page-mode":a.pageMode,[`direction-${a.direction}`]:!0}]),onScrollPassive:xe[0]||(xe[0]=(...Se)=>J(h)&&J(h)(...Se))},[Ee.$slots.before?(N(),U("div",{key:0,ref_key:"before",ref:s,class:"vue-recycle-scroller__slot"},[Xn(Ee.$slots,"before")],512)):ue("",!0),(N(),ut(ii(a.listTag),{style:jn(ae.value),class:He(["vue-recycle-scroller__item-wrapper",a.listClass])},{default:_t(()=>[(N(!0),U(Ze,null,Ut(J(d),Se=>(N(),ut(qv,ki({key:Se.nr.id,view:Se,"item-tag":a.itemTag,style:J(p)?[a.disableTransform?{[a.direction==="vertical"?"top":"left"]:`${Se.position}px`,willChange:"unset"}:{transform:`translate${a.direction==="vertical"?"Y":"X"}(${Se.position}px) translate${a.direction==="vertical"?"X":"Y"}(${Se.offset}px)`},{width:a.gridItems?`${a.direction==="vertical"&&a.itemSecondarySize||a.itemSize}px`:void 0,height:a.gridItems?`${a.direction==="horizontal"&&a.itemSecondarySize||a.itemSize}px`:void 0,visibility:Se.nr.used?"visible":"hidden"}]:null,class:["vue-recycle-scroller__item-view",[a.itemClass,{hover:!a.skipHover&&c.value===Se.nr.key}]]},vT(a.skipHover?{}:{mouseenter:()=>{x(Se.nr.key)},mouseleave:()=>{L()}})),{default:_t(pe=>[Xn(Ee.$slots,"default",ki({ref_for:!0},pe))]),_:2},1040,["view","item-tag","style","class"]))),128)),a.items.length===0?Xn(Ee.$slots,"empty",{key:0}):ue("",!0)]),_:3},8,["style","class"])),Ee.$slots.after?(N(),U("div",{key:1,ref_key:"after",ref:l,class:"vue-recycle-scroller__slot"},[Xn(Ee.$slots,"after")],512)):ue("",!0),we(zv,{onNotify:J(E)},null,8,["onNotify"])],34)),[[J(i),J(D)]])}}),Kv=We({inheritAttrs:!1,__name:"DynamicScroller",props:{items:{},keyField:{default:"id"},direction:{default:"vertical"},listTag:{default:"div"},itemTag:{default:"div"},minItemSize:{},shift:{type:Boolean,default:!1},cache:{default:void 0}},emits:["resize","visible"],setup(e,{expose:t,emit:n}){const a=e,r=n,i=j(),o=ge(()=>{var T;const I=(T=i.value)==null?void 0:T.el;return I&&typeof I=="object"&&"value"in I?I.value:I}),s=ge(()=>({items:a.items,keyField:a.keyField,direction:a.direction,minItemSize:a.minItemSize,shift:a.shift,cache:a.cache,el:o.value,onResize:()=>r("resize"),onVisible:()=>r("visible")})),l=Gv(s),{itemsWithSize:c,forceUpdate:u,scrollToItem:d,scrollToPosition:_,findItemIndex:m,getItemOffset:p,getItemSize:g,cacheSnapshot:b,restoreCache:A,scrollToBottom:O,onScrollerResize:M,onScrollerVisible:w}=l;function v(T,I,h){return{item:T.item,index:I,active:h,itemWithSize:T}}return t({scrollToItem:d,scrollToPosition:_,findItemIndex:m,getItemOffset:p,scrollToBottom:O,getItemSize:g,cacheSnapshot:b,restoreCache:A,forceUpdate:u}),(T,I)=>(N(),ut(Wv,ki({ref_key:"scroller",ref:i,items:J(c),"min-item-size":a.minItemSize,direction:a.direction,cache:a.cache,"key-field":"id","list-tag":a.listTag,"item-tag":a.itemTag},T.$attrs,{onResize:J(M),onVisible:J(w)}),hT({default:_t(({item:h,index:E,active:D})=>[Xn(T.$slots,"default",vb(Qf(v(h,E,D))))]),empty:_t(()=>[Xn(T.$slots,"empty")]),_:2},[T.$slots.before?{name:"before",fn:_t(()=>[Xn(T.$slots,"before")]),key:"0"}:void 0,T.$slots.after?{name:"after",fn:_t(()=>[Xn(T.$slots,"after")]),key:"1"}:void 0]),1040,["items","min-item-size","direction","cache","list-tag","item-tag","onResize","onVisible"]))}});function Qv(e,t,n){const a=_a("vscrollMeasurementContext"),r=_a("vscrollAnchorRegistry",null),i=fS(e,t,a,n);return En(()=>{i.mount()}),r&&je([i.id,i.finalActive,()=>De(t)],([o,s,l],[c,u,d])=>{d&&d!==l&&r.delete(d),l&&r.set(l,{active:s,id:o})},{immediate:!0}),Tn(()=>{const o=De(t);r&&o&&r.delete(o),i.unmount()}),{id:i.id,size:i.size,finalActive:i.finalActive,updateSize:i.updateSize}}const Xv=We({__name:"DynamicScrollerItem",props:{item:{},watchData:{type:Boolean,default:!1},active:{type:Boolean},index:{default:void 0},sizeDependencies:{default:null},emitResize:{type:Boolean,default:!1},tag:{default:"div"}},emits:["resize"],setup(e,{emit:t}){const n=e,a=t,r=j();return Qv(n,r,{onResize:i=>a("resize",i)}),(i,o)=>(N(),ut(ii(n.tag),{ref_key:"el",ref:r},{default:_t(()=>[Xn(i.$slots,"default")]),_:3},512))}});function I_(e){if(!e)return"";const t=new Date(e);if(isNaN(t))return"";const n=Date.now()-t;return n<6e4?"just now":n<36e5?`${Math.floor(n/6e4)}m ago`:n<864e5?t.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"}):t.toLocaleDateString()}function dd(e){const t=j(I_(e.value));let n=null;function a(){t.value=I_(e.value)}return En(()=>{a(),n=setInterval(a,3e4)}),ea(()=>{n&&clearInterval(n)}),t}const Gi=j(!1),CS=_r(""),Uu=[];function Zv(){return{visible:Gi,message:CS}}function yS(){return function(t){return CS.value=t,Gi.value=!0,new Promise(n=>{Uu.push(n)})}}function D_(e){Gi.value=!1;const t=Uu.shift();t==null||t(e),Uu.length===0&&(Gi.value=!1)}const Mt=(e,t)=>{const n=e.__vccOpts||e;for(const[a,r]of t)n[a]=r;return n},Jv={class:"session-icons"},jv={key:0,class:"ph ph-push-pin session-pin-icon",title:"Pinned"},eR={key:1,class:"ph ph-clock session-recall-icon",title:"Scheduled recall pending"},tR={class:"session-info"},nR={class:"session-name-row"},aR=["innerHTML"],rR=["innerHTML"],iR={key:1,class:"session-time"},oR=["title"],sR={__name:"SessionItem",props:{session:{type:Object,required:!0},active:{type:Boolean,default:!1},searchQuery:{type:String,default:""}},emits:["select","delete","pin","cancel-recall","skip-recall"],setup(e,{emit:t}){const n=e,a=t,r=yS(),i=ge(()=>{const p=n.session.session_id??"";return n.session.name||p.slice(0,8)}),o=ge(()=>n.searchQuery&&n.session.match_preview?n.session.match_preview:n.session.preview),s=ge(()=>n.session.last_active),l=dd(s);function c(p){return typeof p!="string"?String(p??""):p.replace(/&/g,"&").replace(//g,">")}function u(p,g){if(!g||!p)return c(p);const b=c(g.toLowerCase()),A=c(p),O=[];let M=0;const w=A.toLowerCase();for(;;){const v=w.indexOf(b,M);if(v===-1)break;v>M&&O.push(A.slice(M,v)),O.push(`${A.slice(v,v+g.length)}`),M=v+g.length}return Mu(i.value,n.searchQuery)),_=ge(()=>u(o.value,n.searchQuery));async function m(){await r("Delete this conversation?")&&a("delete")}return(p,g)=>(N(),U("div",{class:He(["session-item",{"is-active":e.active,"is-pinned":e.session.pinned,"has-recall":e.session.has_pending_recall}]),onClick:g[4]||(g[4]=b=>a("select"))},[f("div",Jv,[e.session.pinned?(N(),U("i",jv)):ue("",!0),e.session.has_pending_recall?(N(),U("i",eR)):ue("",!0)]),f("div",tR,[f("div",nR,[f("span",{class:"session-name",innerHTML:d.value},null,8,aR)]),o.value?(N(),U("div",{key:0,class:"session-preview",innerHTML:_.value},null,8,rR)):ue("",!0),J(l)?(N(),U("div",iR,ie(J(l)),1)):ue("",!0)]),f("div",{class:"session-actions",onClick:g[3]||(g[3]=tr(()=>{},["stop"]))},[e.session.has_pending_recall?(N(),U("button",{key:0,class:"btn-icon",title:"Cancel recall",onClick:g[0]||(g[0]=b=>a("cancel-recall"))},[...g[5]||(g[5]=[f("i",{class:"ph ph-clock-slash"},null,-1)])])):ue("",!0),e.session.has_pending_recall?(N(),U("button",{key:1,class:"btn-icon",title:"Skip next",onClick:g[1]||(g[1]=b=>a("skip-recall"))},[...g[6]||(g[6]=[f("i",{class:"ph ph-skip-forward"},null,-1)])])):ue("",!0),f("button",{class:"btn-icon",title:e.session.pinned?"Unpin":"Pin",onClick:g[2]||(g[2]=b=>a("pin"))},[f("i",{class:He(e.session.pinned?"ph ph-push-pin-slash":"ph ph-push-pin")},null,2)],8,oR),f("button",{class:"btn-icon",title:"Delete",onClick:m},[...g[7]||(g[7]=[f("i",{class:"ph ph-trash"},null,-1)])])])],2))}},lR=Mt(sR,[["__scopeId","data-v-73f7dfc6"]]),cR={class:"ptr-label"},uR={key:0,class:"sessions-loading"},dR={key:1,class:"empty-sessions"},_R={key:2,class:"empty-sessions"},pR={key:4,class:"sessions-loading sessions-loading-more"},x_=80,mR=120,gR={__name:"SessionList",emits:["select"],setup(e,{emit:t}){const n=t,a=Zn(),r=on(),i=li();je(()=>i.selectedProfileId,I=>{I&&I!==a.currentProfileId&&a.fetchSessions(I)});async function o(I){await r.loadSession(I.session_id),n("select",I)}async function s(I){const h=I.session_id===r.currentId;await a.deleteSession(I.session_id),h&&r.clearSession()}async function l(I){await a.pinSession(I.session_id,!I.pinned)}async function c(I){try{await mS(I.session_id),a.updateRecallStatus(I.session_id,!1)}catch(h){console.error("cancel recall failed",h)}}async function u(I){try{await gS(I.session_id)}catch(h){console.error("skip recall failed",h)}}function d(I){const h=I.target;h.scrollHeight-h.scrollTop-h.clientHeight<160&&a.fetchMoreSessions()}const _=j(!1),m=j(0),p=j(!1),g=j(null),b=ge(()=>({transform:`translateY(${Math.min(m.value,mR)}px)`,opacity:_.value?Math.min(m.value/x_,1):0})),A=ge(()=>a.loading?"Refreshing...":p.value?"Release to refresh":"Pull to refresh");let O=0,M=0;function w(I){var E,D;const h=(E=g.value)==null?void 0:E.$el;h&&(M=h.scrollTop||0,!(M>2)&&(O=((D=I.touches[0])==null?void 0:D.clientY)??0,_.value=!1,m.value=0,p.value=!1))}function v(I){var D;if(M>2||!O)return;const E=(((D=I.touches[0])==null?void 0:D.clientY)??0)-O;if(E<=0){_.value=!1;return}E>4&&I.preventDefault(),_.value=!0,m.value=E,p.value=E>=x_}function T(){p.value&&!a.loading&&a.fetchSessions(i.selectedProfileId),_.value=!1,m.value=0,p.value=!1,O=0,M=0}return(I,h)=>(N(),U("div",{class:"session-list-wrap",onTouchstart:w,onTouchmove:v,onTouchend:T},[f("div",{class:He(["ptr-indicator",{"ptr-active":_.value&&!J(a).loading}]),style:jn(b.value)},[f("span",{class:He(["ptr-spinner",{"ptr-spinning":p.value}])},null,2),f("span",cR,ie(A.value),1)],6),J(a).loading&&!J(a).sessions.length?(N(),U("div",uR,[...h[0]||(h[0]=[f("span",{class:"sessions-spinner"},null,-1),f("p",null,"Loading conversations...",-1)])])):J(a).sessions.length?J(a).filteredSessions.length?ue("",!0):(N(),U("div",_R,[...h[2]||(h[2]=[f("i",{class:"ph ph-faders"},null,-1),f("p",null,"No conversations match the current filter",-1)])])):(N(),U("div",dR,[...h[1]||(h[1]=[f("i",{class:"ph ph-chat-dots"},null,-1),f("p",null,"No conversations yet",-1)])])),J(a).filteredSessions.length?(N(),ut(J(Kv),{key:3,ref_key:"scrollerRef",ref:g,class:He(["session-scroller",{"ptr-pulled":_.value}]),items:J(a).filteredSessions,"min-item-size":64,"key-field":"session_id",onScrollPassive:d},{default:_t(({item:E,index:D,active:x})=>[we(J(Xv),{item:E,active:x,"data-index":D},{default:_t(()=>[we(lR,{session:E,active:E.session_id===J(r).currentId,"search-query":J(a).searchActive?J(a).searchQuery:"",onSelect:L=>o(E),onDelete:L=>s(E),onPin:L=>l(E),onCancelRecall:L=>c(E),onSkipRecall:L=>u(E)},null,8,["session","active","search-query","onSelect","onDelete","onPin","onCancelRecall","onSkipRecall"])]),_:2},1032,["item","active","data-index"])]),_:1},8,["class","items"])):ue("",!0),J(a).loadingMore?(N(),U("div",pR,[...h[3]||(h[3]=[f("span",{class:"sessions-spinner"},null,-1)])])):ue("",!0)],32))}},ER=Mt(gR,[["__scopeId","data-v-b1f213b6"]]),fR={class:"sidebar-header"},SR={class:"sidebar-logo"},bR={class:"sidebar-controls-row"},TR={class:"sidebar-profile-select"},hR=["value"],vR=["value"],RR={class:"sidebar-sessions"},CR={class:"sessions-header"},yR={class:"sessions-label"},NR={class:"sessions-header-actions"},OR={class:"sidebar-footer"},AR={class:"user-info",title:"Authorization is disabled"},IR={class:"sidebar-footer-actions"},DR=["href"],xR={class:"user-name"},MR={class:"sidebar-footer-actions"},wR={key:0,href:"/admin",target:"_blank",rel:"noopener noreferrer",class:"btn-icon without-hover admin-link",title:"Admin"},LR={__name:"AppSidebar",props:{mobileOpen:Boolean},emits:["close"],setup(e,{emit:t}){const n=e,a=t,r=li(),i=Zn(),o=on(),s=uo(),l=j(!1),c=j(""),u=j(null);let d=null;function _(){var T;const w=((T=u.value)==null?void 0:T.$el)??u.value;if(!w)return;const v=w.querySelector("input");v==null||v.focus()}je(()=>o.currentProfileId,w=>{w&&(r.selectedProfileId=w)});function m(){l.value=!l.value,l.value&&(setTimeout(_,50),i.searchQuery&&(c.value=i.searchQuery,i.restoreSearch()))}function p(){l.value&&(l.value=!1,i.exitSearch(),i.fetchSessions(r.selectedProfileId))}function g(){c.value="",i.clearSearch(),i.fetchSessions(r.selectedProfileId)}je(c,w=>{if(d&&clearTimeout(d),!w){i.clearSearch(),i.fetchSessions(r.selectedProfileId);return}d=setTimeout(()=>{i.setSearch(w),i.fetchSessions()},300)}),je(()=>r.selectedProfileId,()=>{l.value&&(l.value=!1,i.exitSearch(),i.fetchSessions(r.selectedProfileId))});async function b(){const w=await i.createSession(r.selectedProfileId);await o.loadSession(w.session_id),a("close")}async function A(w){var v;i.searchActive&&w.profile_id&&(r.selectedProfileId=w.profile_id),await o.loadSession(w.session_id,(v=w.match_indices)==null?void 0:v[0]),l.value=!1,i.exitSearch(),i.fetchSessions(r.selectedProfileId),a("close")}function O(){location.hash="#settings",a("close")}function M(w){(w.ctrlKey||w.metaKey)&&w.key==="k"&&(w.preventDefault(),m())}return En(()=>window.addEventListener("keydown",M)),Tn(()=>window.removeEventListener("keydown",M)),(w,v)=>{var D,x,L,ae,Ee,xe,Se;const T=xt("GnIconButton"),I=xt("GnButton"),h=xt("GnSearchField"),E=xt("GnAvatar");return N(),U("aside",{class:He(["app-sidebar",{"is-mobile-open":n.mobileOpen}])},[f("div",fR,[f("div",SR,[v[5]||(v[5]=f("img",{src:ld,alt:"Navi"},null,-1)),v[6]||(v[6]=f("span",null,"Navi",-1)),we(T,{icon:"ph ph-x",label:"Close",class:"sidebar-close-btn",onClick:v[0]||(v[0]=pe=>a("close"))})]),f("div",bR,[f("div",TR,[f("select",{value:J(r).selectedProfileId,onChange:v[1]||(v[1]=pe=>J(r).selectedProfileId=pe.target.value)},[(N(!0),U(Ze,null,Ut(J(r).profiles,pe=>(N(),U("option",{key:pe.id,value:pe.id},ie(pe.name),9,vR))),128))],40,hR)]),we(I,{variant:"primary",icon:"ph ph-plus",onClick:b},{default:_t(()=>[...v[7]||(v[7]=[Et(" New Chat ",-1)])]),_:1})])]),f("div",{class:He(["sidebar-search",{"is-open":l.value}])},[f("div",{class:He(["sidebar-search-inner",{"is-loading":J(i).loading&&J(i).searchActive}])},[we(h,{ref_key:"searchFieldEl",ref:u,modelValue:c.value,"onUpdate:modelValue":v[2]||(v[2]=pe=>c.value=pe),placeholder:"Search conversations...",compact:"",clearable:"",onClear:g,onKeydown:ei(p,["esc"])},null,8,["modelValue"])],2)],2),f("div",RR,[f("div",CR,[f("div",yR,[J(i).searchActive?(N(),U(Ze,{key:0},[Et(ie(J(i).sessions.length)+" result"+ie(J(i).sessions.length===1?"":"s"),1)],64)):(N(),U(Ze,{key:1},[Et("Conversations")],64))]),f("div",NR,[we(T,{icon:"ph ph-clock",label:"Pending recalls only",class:He(["recall-filter-btn",{active:J(i).hasPendingRecallFilter}]),onClick:v[3]||(v[3]=pe=>J(i).hasPendingRecallFilter=!J(i).hasPendingRecallFilter)},null,8,["class"]),we(T,{icon:"ph ph-magnifying-glass",label:"Search",class:He(["search-toggle-btn",{active:l.value||J(i).searchActive}]),onClick:m},null,8,["class"]),we(T,{icon:"ph ph-arrow-clockwise",label:"Refresh",class:He(["sessions-refresh-btn",{"is-spinning":J(i).loading}]),onClick:v[4]||(v[4]=pe=>J(i).fetchSessions(J(r).selectedProfileId))},null,8,["class"])])]),we(ER,{onSelect:A})]),f("div",OR,[J(s).isNoAuthMode?(N(),U(Ze,{key:0},[f("div",AR,[we(E,{size:"sm",src:"",alt:"local",initials:"L"}),v[8]||(v[8]=f("span",{class:"user-name"},"Local mode",-1))]),f("div",IR,[we(T,{icon:"ph ph-gear",label:"Settings","without-hover":"",onClick:O}),v[9]||(v[9]=f("a",{href:"/admin",target:"_blank",rel:"noopener noreferrer",class:"btn-icon without-hover admin-link",title:"Admin"},[f("i",{class:"ph ph-shield-check"})],-1))])],64)):J(s).isAuthenticated?(N(),U(Ze,{key:1},[f("a",{class:"user-info",href:(D=J(s).user)==null?void 0:D.profile_url,target:"_blank",rel:"noopener noreferrer",title:"Open profile in gnexus-auth"},[we(E,{size:"sm",src:((x=J(s).user)==null?void 0:x.avatar_url)||"",alt:((L=J(s).user)==null?void 0:L.display_name)||"avatar",initials:(((ae=J(s).user)==null?void 0:ae.display_name)||((Ee=J(s).user)==null?void 0:Ee.email)||"?").charAt(0).toUpperCase()},null,8,["src","alt","initials"]),f("span",xR,ie(((xe=J(s).user)==null?void 0:xe.display_name)||((Se=J(s).user)==null?void 0:Se.email)),1)],8,DR),f("div",MR,[we(T,{icon:"ph ph-gear",label:"Settings","without-hover":"",onClick:O}),J(s).isAdmin?(N(),U("a",wR,[...v[10]||(v[10]=[f("i",{class:"ph ph-shield-check"},null,-1)])])):ue("",!0),we(T,{icon:"ph ph-sign-out",label:"Logout","without-hover":"",onClick:J(s).logout},null,8,["onClick"])])],64)):(N(),ut(I,{key:2,variant:"primary",icon:"ph ph-sign-in",onClick:J(s).login},{default:_t(()=>[...v[11]||(v[11]=[Et(" Login ",-1)])]),_:1},8,["onClick"]))])],2)}}},PR=Mt(LR,[["__scopeId","data-v-d94da62e"]]),NS={__name:"ConfirmDialog",setup(e){const{visible:t,message:n}=Zv();function a(){D_(!0)}function r(){D_(!1)}return(i,o)=>{const s=xt("GnConfirmDialog");return N(),ut(s,{open:J(t),"onUpdate:open":o[0]||(o[0]=l=>Gt(t)?t.value=l:null),message:J(n),title:"Requires confirmation","cancel-text":"No","confirm-text":"Yes","confirm-variant":"warning",onConfirm:a,onCancel:r},null,8,["open","message"])}}},kR=Object.freeze(Object.defineProperty({__proto__:null,default:NS},Symbol.toStringTag,{value:"Module"})),xo=j(null);function _o(){function e(n){xo.value=n}function t(){xo.value=null}return{src:xo,open:e,close:t}}const UR={key:0,class:"modal a-show","aria-hidden":"false"},FR={class:"modal-dialog lightbox-dialog",role:"dialog","aria-modal":"true",tabindex:"-1"},BR={class:"modal-header"},GR={class:"modal-panel lightbox-panel"},YR={class:"modal-body"},$R=["src"],qR={key:1,class:"lightbox-error"},OS={__name:"ImageLightbox",setup(e){const{src:t,close:n}=_o(),a=j(!1);return je(t,r=>{document.body.style.overflow=r?"hidden":"",a.value=!1}),(r,i)=>(N(),ut(ri,{to:"body"},[J(t)?(N(),U("div",UR,[f("div",{class:"modal-backdrop",onClick:i[0]||(i[0]=(...o)=>J(n)&&J(n)(...o))}),f("div",FR,[f("header",BR,[i[3]||(i[3]=f("h4",{class:"modal-title"},"Photo",-1)),f("button",{class:"btn-icon modal-close",type:"button","aria-label":"Close",onClick:i[1]||(i[1]=(...o)=>J(n)&&J(n)(...o))},"✕")]),f("div",GR,[f("div",YR,[a.value?(N(),U("div",qR,[...i[4]||(i[4]=[f("i",{class:"ph ph-image-broken"},null,-1),f("span",null,"Failed to load image",-1)])])):(N(),U("img",{key:0,src:J(t),class:"lightbox-img",onError:i[2]||(i[2]=o=>a.value=!0)},null,40,$R))])])])])):ue("",!0)]))}},HR=Object.freeze(Object.defineProperty({__proto__:null,default:OS},Symbol.toStringTag,{value:"Module"})),Ti=j("");function AS(){function e(n){Ti.value=n}function t(){const n=Ti.value;return Ti.value="",n}return{pendingQuote:Ti,requestQuote:e,consumeQuote:t}}const VR={__name:"SelectionToolbar",setup(e){const{requestQuote:t}=AS(),n=j(!1),a=j({x:0,y:0});let r="";function i(){const u=window.getSelection();if(!u||u.isCollapsed||!u.toString().trim())return null;const d=u.getRangeAt(0),_=d.commonAncestorContainer;return(_.nodeType===Node.TEXT_NODE?_.parentElement:_).closest(".msg-assistant-content")?{text:u.toString().trim(),range:d}:null}function o(){const u=window.getSelection();if(!u||u.isCollapsed||!u.rangeCount){n.value=!1;return}const _=u.getRangeAt(0).getBoundingClientRect();if(!_.width&&!_.height){n.value=!1;return}a.value={x:Math.round(_.left+_.width/2),y:Math.round(_.top-44)}}function s(){setTimeout(()=>{const u=i();if(!u){n.value=!1;return}r=u.text,o(),n.value=!0},10)}function l(){const u=window.getSelection();(!u||u.isCollapsed)&&(n.value=!1)}function c(){var u;r&&(t(r),(u=window.getSelection())==null||u.removeAllRanges(),n.value=!1)}return En(()=>{document.addEventListener("mouseup",s),document.addEventListener("selectionchange",l),document.addEventListener("scroll",o,!0)}),ea(()=>{document.removeEventListener("mouseup",s),document.removeEventListener("selectionchange",l),document.removeEventListener("scroll",o,!0)}),(u,d)=>{const _=xt("GnButton");return N(),ut(ri,{to:"body"},[n.value?(N(),U("div",{key:0,class:"selection-toolbar",style:jn({top:a.value.y+"px",left:a.value.x+"px"}),onMousedown:d[0]||(d[0]=tr(()=>{},["prevent"]))},[we(_,{variant:"warning",size:"sm",icon:"ph ph-quotes",style:{color:"#000"},title:"Reply to selection",onClick:c},{default:_t(()=>[...d[1]||(d[1]=[Et(" Reply ",-1)])]),_:1})],36)):ue("",!0)])}}},IS=Mt(VR,[["__scopeId","data-v-81606e7c"]]),zR=Object.freeze(Object.defineProperty({__proto__:null,default:IS},Symbol.toStringTag,{value:"Module"}));function Za(e){if(!e)return"";let t;try{t=new URL(e,window.location.origin)}catch{return e}return t.origin===window.location.origin?`${t.pathname}${t.search}${t.hash}`:t.href}function Yi(e){return e?new URL(e,window.location.origin).href:""}function WR(e,t){const n=Za(e);return!n||!t?n:`${n}${n.includes("?")?"&":"?"}v=${encodeURIComponent(t)}`}function DS(e,t){const n=new URL(`/content-viewers/${e}.html`,window.location.origin);return n.searchParams.set("url",t),n.href}function KR(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var Mo,M_;function QR(){if(M_)return Mo;M_=1;function e(P){return P instanceof Map?P.clear=P.delete=P.set=function(){throw new Error("map is read-only")}:P instanceof Set&&(P.add=P.clear=P.delete=function(){throw new Error("set is read-only")}),Object.freeze(P),Object.getOwnPropertyNames(P).forEach(Z=>{const he=P[Z],G=typeof he;(G==="object"||G==="function")&&!Object.isFrozen(he)&&e(he)}),P}class t{constructor(Z){Z.data===void 0&&(Z.data={}),this.data=Z.data,this.isMatchIgnored=!1}ignoreMatch(){this.isMatchIgnored=!0}}function n(P){return P.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function a(P,...Z){const he=Object.create(null);for(const G in P)he[G]=P[G];return Z.forEach(function(G){for(const $ in G)he[$]=G[$]}),he}const r="",i=P=>!!P.scope,o=(P,{prefix:Z})=>{if(P.startsWith("language:"))return P.replace("language:","language-");if(P.includes(".")){const he=P.split(".");return[`${Z}${he.shift()}`,...he.map((G,$)=>`${G}${"_".repeat($+1)}`)].join(" ")}return`${Z}${P}`};class s{constructor(Z,he){this.buffer="",this.classPrefix=he.classPrefix,Z.walk(this)}addText(Z){this.buffer+=n(Z)}openNode(Z){if(!i(Z))return;const he=o(Z.scope,{prefix:this.classPrefix});this.span(he)}closeNode(Z){i(Z)&&(this.buffer+=r)}value(){return this.buffer}span(Z){this.buffer+=``}}const l=(P={})=>{const Z={children:[]};return Object.assign(Z,P),Z};class c{constructor(){this.rootNode=l(),this.stack=[this.rootNode]}get top(){return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(Z){this.top.children.push(Z)}openNode(Z){const he=l({scope:Z});this.add(he),this.stack.push(he)}closeNode(){if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}walk(Z){return this.constructor._walk(Z,this.rootNode)}static _walk(Z,he){return typeof he=="string"?Z.addText(he):he.children&&(Z.openNode(he),he.children.forEach(G=>this._walk(Z,G)),Z.closeNode(he)),Z}static _collapse(Z){typeof Z!="string"&&Z.children&&(Z.children.every(he=>typeof he=="string")?Z.children=[Z.children.join("")]:Z.children.forEach(he=>{c._collapse(he)}))}}class u extends c{constructor(Z){super(),this.options=Z}addText(Z){Z!==""&&this.add(Z)}startScope(Z){this.openNode(Z)}endScope(){this.closeNode()}__addSublanguage(Z,he){const G=Z.root;he&&(G.scope=`language:${he}`),this.add(G)}toHTML(){return new s(this,this.options).value()}finalize(){return this.closeAllNodes(),!0}}function d(P){return P?typeof P=="string"?P:P.source:null}function _(P){return g("(?=",P,")")}function m(P){return g("(?:",P,")*")}function p(P){return g("(?:",P,")?")}function g(...P){return P.map(he=>d(he)).join("")}function b(P){const Z=P[P.length-1];return typeof Z=="object"&&Z.constructor===Object?(P.splice(P.length-1,1),Z):{}}function A(...P){return"("+(b(P).capture?"":"?:")+P.map(G=>d(G)).join("|")+")"}function O(P){return new RegExp(P.toString()+"|").exec("").length-1}function M(P,Z){const he=P&&P.exec(Z);return he&&he.index===0}const w=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;function v(P,{joinWith:Z}){let he=0;return P.map(G=>{he+=1;const $=he;let Ne=d(G),H="";for(;Ne.length>0;){const ce=w.exec(Ne);if(!ce){H+=Ne;break}H+=Ne.substring(0,ce.index),Ne=Ne.substring(ce.index+ce[0].length),ce[0][0]==="\\"&&ce[1]?H+="\\"+String(Number(ce[1])+$):(H+=ce[0],ce[0]==="("&&he++)}return H}).map(G=>`(${G})`).join(Z)}const T=/\b\B/,I="[a-zA-Z]\\w*",h="[a-zA-Z_]\\w*",E="\\b\\d+(\\.\\d+)?",D="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",x="\\b(0b[01]+)",L="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",ae=(P={})=>{const Z=/^#![ ]*\//;return P.binary&&(P.begin=g(Z,/.*\b/,P.binary,/\b.*/)),a({scope:"meta",begin:Z,end:/$/,relevance:0,"on:begin":(he,G)=>{he.index!==0&&G.ignoreMatch()}},P)},Ee={begin:"\\\\[\\s\\S]",relevance:0},xe={scope:"string",begin:"'",end:"'",illegal:"\\n",contains:[Ee]},Se={scope:"string",begin:'"',end:'"',illegal:"\\n",contains:[Ee]},pe={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/},Le=function(P,Z,he={}){const G=a({scope:"comment",begin:P,end:Z,contains:[]},he);G.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 $=A("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 G.contains.push({begin:g(/[ ]+/,"(",$,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),G},be=Le("//","$"),Xe=Le("/\\*","\\*/"),et=Le("#","$"),it={scope:"number",begin:E,relevance:0},St={scope:"number",begin:D,relevance:0},Ot={scope:"number",begin:x,relevance:0},qe={scope:"regexp",begin:/\/(?=[^/\n]*\/)/,end:/\/[gimuy]*/,contains:[Ee,{begin:/\[/,end:/\]/,relevance:0,contains:[Ee]}]},lt={scope:"title",begin:I,relevance:0},V={scope:"title",begin:h,relevance:0},te={begin:"\\.\\s*"+h,relevance:0};var Ie=Object.freeze({__proto__:null,APOS_STRING_MODE:xe,BACKSLASH_ESCAPE:Ee,BINARY_NUMBER_MODE:Ot,BINARY_NUMBER_RE:x,COMMENT:Le,C_BLOCK_COMMENT_MODE:Xe,C_LINE_COMMENT_MODE:be,C_NUMBER_MODE:St,C_NUMBER_RE:D,END_SAME_AS_BEGIN:function(P){return Object.assign(P,{"on:begin":(Z,he)=>{he.data._beginMatch=Z[1]},"on:end":(Z,he)=>{he.data._beginMatch!==Z[1]&&he.ignoreMatch()}})},HASH_COMMENT_MODE:et,IDENT_RE:I,MATCH_NOTHING_RE:T,METHOD_GUARD:te,NUMBER_MODE:it,NUMBER_RE:E,PHRASAL_WORDS_MODE:pe,QUOTE_STRING_MODE:Se,REGEXP_MODE:qe,RE_STARTERS_RE:L,SHEBANG:ae,TITLE_MODE:lt,UNDERSCORE_IDENT_RE:h,UNDERSCORE_TITLE_MODE:V});function Be(P,Z){P.input[P.index-1]==="."&&Z.ignoreMatch()}function R(P,Z){P.className!==void 0&&(P.scope=P.className,delete P.className)}function k(P,Z){Z&&P.beginKeywords&&(P.begin="\\b("+P.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",P.__beforeBegin=Be,P.keywords=P.keywords||P.beginKeywords,delete P.beginKeywords,P.relevance===void 0&&(P.relevance=0))}function z(P,Z){Array.isArray(P.illegal)&&(P.illegal=A(...P.illegal))}function K(P,Z){if(P.match){if(P.begin||P.end)throw new Error("begin & end are not supported with match");P.begin=P.match,delete P.match}}function ee(P,Z){P.relevance===void 0&&(P.relevance=1)}const X=(P,Z)=>{if(!P.beforeMatch)return;if(P.starts)throw new Error("beforeMatch cannot be used with starts");const he=Object.assign({},P);Object.keys(P).forEach(G=>{delete P[G]}),P.keywords=he.keywords,P.begin=g(he.beforeMatch,_(he.begin)),P.starts={relevance:0,contains:[Object.assign(he,{endsParent:!0})]},P.relevance=0,delete he.beforeMatch},_e=["of","and","for","in","not","or","if","then","parent","list","value"],oe="keyword";function le(P,Z,he=oe){const G=Object.create(null);return typeof P=="string"?$(he,P.split(" ")):Array.isArray(P)?$(he,P):Object.keys(P).forEach(function(Ne){Object.assign(G,le(P[Ne],Z,Ne))}),G;function $(Ne,H){Z&&(H=H.map(ce=>ce.toLowerCase())),H.forEach(function(ce){const Oe=ce.split("|");G[Oe[0]]=[Ne,re(Oe[0],Oe[1])]})}}function re(P,Z){return Z?Number(Z):Me(P)?0:1}function Me(P){return _e.includes(P.toLowerCase())}const Ce={},Re=P=>{console.error(P)},Pe=(P,...Z)=>{console.log(`WARN: ${P}`,...Z)},Ve=(P,Z)=>{Ce[`${P}/${Z}`]||(console.log(`Deprecated as of ${P}. ${Z}`),Ce[`${P}/${Z}`]=!0)},Ke=new Error;function y(P,Z,{key:he}){let G=0;const $=P[he],Ne={},H={};for(let ce=1;ce<=Z.length;ce++)H[ce+G]=$[ce],Ne[ce+G]=!0,G+=O(Z[ce-1]);P[he]=H,P[he]._emit=Ne,P[he]._multi=!0}function B(P){if(Array.isArray(P.begin)){if(P.skip||P.excludeBegin||P.returnBegin)throw Re("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),Ke;if(typeof P.beginScope!="object"||P.beginScope===null)throw Re("beginScope must be object"),Ke;y(P,P.begin,{key:"beginScope"}),P.begin=v(P.begin,{joinWith:""})}}function W(P){if(Array.isArray(P.end)){if(P.skip||P.excludeEnd||P.returnEnd)throw Re("skip, excludeEnd, returnEnd not compatible with endScope: {}"),Ke;if(typeof P.endScope!="object"||P.endScope===null)throw Re("endScope must be object"),Ke;y(P,P.end,{key:"endScope"}),P.end=v(P.end,{joinWith:""})}}function Y(P){P.scope&&typeof P.scope=="object"&&P.scope!==null&&(P.beginScope=P.scope,delete P.scope)}function q(P){Y(P),typeof P.beginScope=="string"&&(P.beginScope={_wrap:P.beginScope}),typeof P.endScope=="string"&&(P.endScope={_wrap:P.endScope}),B(P),W(P)}function ne(P){function Z(H,ce){return new RegExp(d(H),"m"+(P.case_insensitive?"i":"")+(P.unicodeRegex?"u":"")+(ce?"g":""))}class he{constructor(){this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}addRule(ce,Oe){Oe.position=this.position++,this.matchIndexes[this.matchAt]=Oe,this.regexes.push([Oe,ce]),this.matchAt+=O(ce)+1}compile(){this.regexes.length===0&&(this.exec=()=>null);const ce=this.regexes.map(Oe=>Oe[1]);this.matcherRe=Z(v(ce,{joinWith:"|"}),!0),this.lastIndex=0}exec(ce){this.matcherRe.lastIndex=this.lastIndex;const Oe=this.matcherRe.exec(ce);if(!Oe)return null;const Je=Oe.findIndex((Yt,$t)=>$t>0&&Yt!==void 0),$e=this.matchIndexes[Je];return Oe.splice(0,Je),Object.assign(Oe,$e)}}class G{constructor(){this.rules=[],this.multiRegexes=[],this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(ce){if(this.multiRegexes[ce])return this.multiRegexes[ce];const Oe=new he;return this.rules.slice(ce).forEach(([Je,$e])=>Oe.addRule(Je,$e)),Oe.compile(),this.multiRegexes[ce]=Oe,Oe}resumingScanAtSamePosition(){return this.regexIndex!==0}considerAll(){this.regexIndex=0}addRule(ce,Oe){this.rules.push([ce,Oe]),Oe.type==="begin"&&this.count++}exec(ce){const Oe=this.getMatcher(this.regexIndex);Oe.lastIndex=this.lastIndex;let Je=Oe.exec(ce);if(this.resumingScanAtSamePosition()&&!(Je&&Je.index===this.lastIndex)){const $e=this.getMatcher(0);$e.lastIndex=this.lastIndex+1,Je=$e.exec(ce)}return Je&&(this.regexIndex+=Je.position+1,this.regexIndex===this.count&&this.considerAll()),Je}}function $(H){const ce=new G;return H.contains.forEach(Oe=>ce.addRule(Oe.begin,{rule:Oe,type:"begin"})),H.terminatorEnd&&ce.addRule(H.terminatorEnd,{type:"end"}),H.illegal&&ce.addRule(H.illegal,{type:"illegal"}),ce}function Ne(H,ce){const Oe=H;if(H.isCompiled)return Oe;[R,K,q,X].forEach($e=>$e(H,ce)),P.compilerExtensions.forEach($e=>$e(H,ce)),H.__beforeBegin=null,[k,z,ee].forEach($e=>$e(H,ce)),H.isCompiled=!0;let Je=null;return typeof H.keywords=="object"&&H.keywords.$pattern&&(H.keywords=Object.assign({},H.keywords),Je=H.keywords.$pattern,delete H.keywords.$pattern),Je=Je||/\w+/,H.keywords&&(H.keywords=le(H.keywords,P.case_insensitive)),Oe.keywordPatternRe=Z(Je,!0),ce&&(H.begin||(H.begin=/\B|\b/),Oe.beginRe=Z(Oe.begin),!H.end&&!H.endsWithParent&&(H.end=/\B|\b/),H.end&&(Oe.endRe=Z(Oe.end)),Oe.terminatorEnd=d(Oe.end)||"",H.endsWithParent&&ce.terminatorEnd&&(Oe.terminatorEnd+=(H.end?"|":"")+ce.terminatorEnd)),H.illegal&&(Oe.illegalRe=Z(H.illegal)),H.contains||(H.contains=[]),H.contains=[].concat(...H.contains.map(function($e){return fe($e==="self"?H:$e)})),H.contains.forEach(function($e){Ne($e,Oe)}),H.starts&&Ne(H.starts,ce),Oe.matcher=$(Oe),Oe}if(P.compilerExtensions||(P.compilerExtensions=[]),P.contains&&P.contains.includes("self"))throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");return P.classNameAliases=a(P.classNameAliases||{}),Ne(P)}function de(P){return P?P.endsWithParent||de(P.starts):!1}function fe(P){return P.variants&&!P.cachedVariants&&(P.cachedVariants=P.variants.map(function(Z){return a(P,{variants:null},Z)})),P.cachedVariants?P.cachedVariants:de(P)?a(P,{starts:P.starts?a(P.starts):null}):Object.isFrozen(P)?a(P):P}var ye="11.11.1";class Ue extends Error{constructor(Z,he){super(Z),this.name="HTMLInjectionError",this.html=he}}const tt=n,Rt=a,Fe=Symbol("nomatch"),ct=7,at=function(P){const Z=Object.create(null),he=Object.create(null),G=[];let $=!0;const Ne="Could not find the language '{}', did you forget to load/include a language module?",H={disableAutodetect:!0,name:"Plain text",contains:[]};let ce={ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",cssSelector:"pre code",languages:null,__emitter:u};function Oe(Te){return ce.noHighlightRe.test(Te)}function Je(Te){let Ge=Te.className+" ";Ge+=Te.parentNode?Te.parentNode.className:"";const ot=ce.languageDetectRe.exec(Ge);if(ot){const yt=At(ot[1]);return yt||(Pe(Ne.replace("{}",ot[1])),Pe("Falling back to no-highlight mode for this block.",Te)),yt?ot[1]:"no-highlight"}return Ge.split(/\s+/).find(yt=>Oe(yt)||At(yt))}function $e(Te,Ge,ot){let yt="",kt="";typeof Ge=="object"?(yt=Te,ot=Ge.ignoreIllegals,kt=Ge.language):(Ve("10.7.0","highlight(lang, code, ...args) has been deprecated."),Ve("10.7.0",`Please use highlight(code, options) instead. -https://github.com/highlightjs/highlight.js/issues/2277`),kt=Te,yt=Ge),ot===void 0&&(ot=!0);const sn={code:yt,language:kt};xa("before:highlight",sn);const Ln=sn.result?sn.result:Yt(sn.language,sn.code,ot);return Ln.code=sn.code,xa("after:highlight",Ln),Ln}function Yt(Te,Ge,ot,yt){const kt=Object.create(null);function sn(S,F){return S.keywords[F]}function Ln(){if(!nt.keywords){qt.addText(ft);return}let S=0;nt.keywordPatternRe.lastIndex=0;let F=nt.keywordPatternRe.exec(ft),Q="";for(;F;){Q+=ft.substring(S,F.index);const se=ln.case_insensitive?F[0].toLowerCase():F[0],Ae=sn(nt,se);if(Ae){const[Ye,Nt]=Ae;if(qt.addText(Q),Q="",kt[se]=(kt[se]||0)+1,kt[se]<=ct&&(Yn+=Nt),Ye.startsWith("_"))Q+=F[0];else{const wt=ln.classNameAliases[Ye]||Ye;jt(F[0],wt)}}else Q+=F[0];S=nt.keywordPatternRe.lastIndex,F=nt.keywordPatternRe.exec(ft)}Q+=ft.substring(S),qt.addText(Q)}function Sa(){if(ft==="")return;let S=null;if(typeof nt.subLanguage=="string"){if(!Z[nt.subLanguage]){qt.addText(ft);return}S=Yt(nt.subLanguage,ft,!0,ka[nt.subLanguage]),ka[nt.subLanguage]=S._top}else S=Xt(ft,nt.subLanguage.length?nt.subLanguage:null);nt.relevance>0&&(Yn+=S.relevance),qt.__addSublanguage(S._emitter,S.language)}function Zt(){nt.subLanguage!=null?Sa():Ln(),ft=""}function jt(S,F){S!==""&&(qt.startScope(F),qt.addText(S),qt.endScope())}function Ma(S,F){let Q=1;const se=F.length-1;for(;Q<=se;){if(!S._emit[Q]){Q++;continue}const Ae=ln.classNameAliases[S[Q]]||S[Q],Ye=F[Q];Ae?jt(Ye,Ae):(ft=Ye,Ln(),ft=""),Q++}}function ba(S,F){return S.scope&&typeof S.scope=="string"&&qt.openNode(ln.classNameAliases[S.scope]||S.scope),S.beginScope&&(S.beginScope._wrap?(jt(ft,ln.classNameAliases[S.beginScope._wrap]||S.beginScope._wrap),ft=""):S.beginScope._multi&&(Ma(S.beginScope,F),ft="")),nt=Object.create(S,{parent:{value:nt}}),nt}function Gn(S,F,Q){let se=M(S.endRe,Q);if(se){if(S["on:end"]){const Ae=new t(S);S["on:end"](F,Ae),Ae.isMatchIgnored&&(se=!1)}if(se){for(;S.endsParent&&S.parent;)S=S.parent;return S}}if(S.endsWithParent)return Gn(S.parent,F,Q)}function Ta(S){return nt.matcher.regexIndex===0?(ft+=S[0],1):(me=!0,0)}function vn(S){const F=S[0],Q=S.rule,se=new t(Q),Ae=[Q.__beforeBegin,Q["on:begin"]];for(const Ye of Ae)if(Ye&&(Ye(S,se),se.isMatchIgnored))return Ta(F);return Q.skip?ft+=F:(Q.excludeBegin&&(ft+=F),Zt(),!Q.returnBegin&&!Q.excludeBegin&&(ft=F)),ba(Q,S),Q.returnBegin?0:F.length}function pi(S){const F=S[0],Q=Ge.substring(S.index),se=Gn(nt,S,Q);if(!se)return Fe;const Ae=nt;nt.endScope&&nt.endScope._wrap?(Zt(),jt(F,nt.endScope._wrap)):nt.endScope&&nt.endScope._multi?(Zt(),Ma(nt.endScope,S)):Ae.skip?ft+=F:(Ae.returnEnd||Ae.excludeEnd||(ft+=F),Zt(),Ae.excludeEnd&&(ft=F));do nt.scope&&qt.closeNode(),!nt.skip&&!nt.subLanguage&&(Yn+=nt.relevance),nt=nt.parent;while(nt!==se.parent);return se.starts&&ba(se.starts,S),Ae.returnEnd?0:F.length}function wa(){const S=[];for(let F=nt;F!==ln;F=F.parent)F.scope&&S.unshift(F.scope);S.forEach(F=>qt.openNode(F))}let La={};function Pa(S,F){const Q=F&&F[0];if(ft+=S,Q==null)return Zt(),0;if(La.type==="begin"&&F.type==="end"&&La.index===F.index&&Q===""){if(ft+=Ge.slice(F.index,F.index+1),!$){const se=new Error(`0 width match regex (${Te})`);throw se.languageName=Te,se.badRule=La.rule,se}return 1}if(La=F,F.type==="begin")return vn(F);if(F.type==="illegal"&&!ot){const se=new Error('Illegal lexeme "'+Q+'" for mode "'+(nt.scope||"")+'"');throw se.mode=nt,se}else if(F.type==="end"){const se=pi(F);if(se!==Fe)return se}if(F.type==="illegal"&&Q==="")return ft+=` -`,1;if(na>1e5&&na>F.index*3)throw new Error("potential infinite loop, way more iterations than matches");return ft+=Q,Q.length}const ln=At(Te);if(!ln)throw Re(Ne.replace("{}",Te)),new Error('Unknown language: "'+Te+'"');const or=ne(ln);let ha="",nt=yt||or;const ka={},qt=new ce.__emitter(ce);wa();let ft="",Yn=0,cn=0,na=0,me=!1;try{if(ln.__emitTokens)ln.__emitTokens(Ge,qt);else{for(nt.matcher.considerAll();;){na++,me?me=!1:nt.matcher.considerAll(),nt.matcher.lastIndex=cn;const S=nt.matcher.exec(Ge);if(!S)break;const F=Ge.substring(cn,S.index),Q=Pa(F,S);cn=S.index+Q}Pa(Ge.substring(cn))}return qt.finalize(),ha=qt.toHTML(),{language:Te,value:ha,relevance:Yn,illegal:!1,_emitter:qt,_top:nt}}catch(S){if(S.message&&S.message.includes("Illegal"))return{language:Te,value:tt(Ge),illegal:!0,relevance:0,_illegalBy:{message:S.message,index:cn,context:Ge.slice(cn-100,cn+100),mode:S.mode,resultSoFar:ha},_emitter:qt};if($)return{language:Te,value:tt(Ge),illegal:!1,relevance:0,errorRaised:S,_emitter:qt,_top:nt};throw S}}function $t(Te){const Ge={value:tt(Te),illegal:!1,relevance:0,_top:H,_emitter:new ce.__emitter(ce)};return Ge._emitter.addText(Te),Ge}function Xt(Te,Ge){Ge=Ge||ce.languages||Object.keys(Z);const ot=$t(Te),yt=Ge.filter(At).filter(ir).map(Zt=>Yt(Zt,Te,!1));yt.unshift(ot);const kt=yt.sort((Zt,jt)=>{if(Zt.relevance!==jt.relevance)return jt.relevance-Zt.relevance;if(Zt.language&&jt.language){if(At(Zt.language).supersetOf===jt.language)return 1;if(At(jt.language).supersetOf===Zt.language)return-1}return 0}),[sn,Ln]=kt,Sa=sn;return Sa.secondBest=Ln,Sa}function An(Te,Ge,ot){const yt=Ge&&he[Ge]||ot;Te.classList.add("hljs"),Te.classList.add(`language-${yt}`)}function st(Te){let Ge=null;const ot=Je(Te);if(Oe(ot))return;if(xa("before:highlightElement",{el:Te,language:ot}),Te.dataset.highlighted){console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",Te);return}if(Te.children.length>0&&(ce.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(Te)),ce.throwUnescapedHTML))throw new Ue("One of your code blocks includes unescaped HTML.",Te.innerHTML);Ge=Te;const yt=Ge.textContent,kt=ot?$e(yt,{language:ot,ignoreIllegals:!0}):Xt(yt);Te.innerHTML=kt.value,Te.dataset.highlighted="yes",An(Te,ot,kt.language),Te.result={language:kt.language,re:kt.relevance,relevance:kt.relevance},kt.secondBest&&(Te.secondBest={language:kt.secondBest.language,relevance:kt.secondBest.relevance}),xa("after:highlightElement",{el:Te,result:kt,text:yt})}function Pt(Te){ce=Rt(ce,Te)}const Kt=()=>{bt(),Ve("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")};function hn(){bt(),Ve("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")}let Fn=!1;function bt(){function Te(){bt()}if(document.readyState==="loading"){Fn||window.addEventListener("DOMContentLoaded",Te,!1),Fn=!0;return}document.querySelectorAll(ce.cssSelector).forEach(st)}function Ct(Te,Ge){let ot=null;try{ot=Ge(P)}catch(yt){if(Re("Language definition for '{}' could not be registered.".replace("{}",Te)),$)Re(yt);else throw yt;ot=H}ot.name||(ot.name=Te),Z[Te]=ot,ot.rawDefinition=Ge.bind(null,P),ot.aliases&&ta(ot.aliases,{languageName:Te})}function In(Te){delete Z[Te];for(const Ge of Object.keys(he))he[Ge]===Te&&delete he[Ge]}function Bn(){return Object.keys(Z)}function At(Te){return Te=(Te||"").toLowerCase(),Z[Te]||Z[he[Te]]}function ta(Te,{languageName:Ge}){typeof Te=="string"&&(Te=[Te]),Te.forEach(ot=>{he[ot.toLowerCase()]=Ge})}function ir(Te){const Ge=At(Te);return Ge&&!Ge.disableAutodetect}function ui(Te){Te["before:highlightBlock"]&&!Te["before:highlightElement"]&&(Te["before:highlightElement"]=Ge=>{Te["before:highlightBlock"](Object.assign({block:Ge.el},Ge))}),Te["after:highlightBlock"]&&!Te["after:highlightElement"]&&(Te["after:highlightElement"]=Ge=>{Te["after:highlightBlock"](Object.assign({block:Ge.el},Ge))})}function di(Te){ui(Te),G.push(Te)}function _i(Te){const Ge=G.indexOf(Te);Ge!==-1&&G.splice(Ge,1)}function xa(Te,Ge){const ot=Te;G.forEach(function(yt){yt[ot]&&yt[ot](Ge)})}function wn(Te){return Ve("10.7.0","highlightBlock will be removed entirely in v12.0"),Ve("10.7.0","Please use highlightElement now."),st(Te)}Object.assign(P,{highlight:$e,highlightAuto:Xt,highlightAll:bt,highlightElement:st,highlightBlock:wn,configure:Pt,initHighlighting:Kt,initHighlightingOnLoad:hn,registerLanguage:Ct,unregisterLanguage:In,listLanguages:Bn,getLanguage:At,registerAliases:ta,autoDetection:ir,inherit:Rt,addPlugin:di,removePlugin:_i}),P.debugMode=function(){$=!1},P.safeMode=function(){$=!0},P.versionString=ye,P.regex={concat:g,lookahead:_,either:A,optional:p,anyNumberOfTimes:m};for(const Te in Ie)typeof Ie[Te]=="object"&&e(Ie[Te]);return Object.assign(P,Ie),P},ze=at({});return ze.newInstance=()=>at({}),Mo=ze,ze.HighlightJS=ze,ze.default=ze,Mo}var wo,w_;function XR(){if(w_)return wo;w_=1;function e(t){const n="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]+",i="далее "+"возврат вызватьисключение выполнить для если и из или иначе иначеесли исключение каждого конецесли конецпопытки конеццикла не новый перейти перем по пока попытка прервать продолжить тогда цикл экспорт ",l="загрузитьизфайла "+"вебклиент вместо внешнеесоединение клиент конецобласти мобильноеприложениеклиент мобильноеприложениесервер наклиенте наклиентенасервере наклиентенасерверебезконтекста насервере насерверебезконтекста область перед после сервер толстыйклиентобычноеприложение толстыйклиентуправляемоеприложение тонкийклиент ",m="разделительстраниц разделительстрок символтабуляции "+"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 файловыепотоки фоновыезадания хранилищанастроек хранилищевариантовотчетов хранилищенастроекданныхформ хранилищеобщихнастроек хранилищепользовательскихнастроекдинамическихсписков хранилищепользовательскихнастроекотчетов хранилищесистемныхнастроек ",Xe="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 типэлементаинформацииовыполненииобновленияконфигурациибазыданных уровеньизоляциитранзакций хешфункция частидаты",St="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 деревозначений массив соответствие списокзначений структура таблицазначений фиксированнаяструктура фиксированноесоответствие фиксированныймассив ",Ot="null истина ложь неопределено",qe=t.inherit(t.NUMBER_MODE),lt={className:"string",begin:'"|\\|',end:'"|$',contains:[{begin:'""'}]},V={begin:"'",end:"'",excludeBegin:!0,excludeEnd:!0,contains:[{className:"number",begin:"\\d{4}([\\.\\\\/:-]?\\d{2}){0,5}"}]},te={match:/[;()+\-:=,]/,className:"punctuation",relevance:0},ve=t.inherit(t.C_LINE_COMMENT_MODE),Ie={className:"meta",begin:"#|&",end:"$",keywords:{$pattern:n,keyword:i+l},contains:[ve]},Be={className:"symbol",begin:"~",end:";|:",excludeEnd:!0},R={className:"function",variants:[{begin:"процедура|функция",end:"\\)",keywords:"процедура функция"},{begin:"конецпроцедуры|конецфункции",keywords:"конецпроцедуры конецфункции"}],contains:[{begin:"\\(",end:"\\)",endsParent:!0,contains:[{className:"params",begin:n,end:",",excludeEnd:!0,endsWithParent:!0,keywords:{$pattern:n,keyword:"знач",literal:Ot},contains:[qe,lt,V]},ve]},t.inherit(t.TITLE_MODE,{begin:n})]};return{name:"1C:Enterprise",case_insensitive:!0,keywords:{$pattern:n,keyword:i,built_in:m,class:Xe,type:St,literal:Ot},contains:[Ie,R,ve,Be,qe,lt,V,te]}}return wo=e,wo}var Lo,L_;function ZR(){if(L_)return Lo;L_=1;function e(t){const n=t.regex,a=/^[a-zA-Z][a-zA-Z0-9-]*/,r=["ALPHA","BIT","CHAR","CR","CRLF","CTL","DIGIT","DQUOTE","HEXDIG","HTAB","LF","LWSP","OCTET","SP","VCHAR","WSP"],i=t.COMMENT(/;/,/$/),o={scope:"symbol",match:/%b[0-1]+(-[0-1]+|(\.[0-1]+)+)?/},s={scope:"symbol",match:/%d[0-9]+(-[0-9]+|(\.[0-9]+)+)?/},l={scope:"symbol",match:/%x[0-9A-F]+(-[0-9A-F]+|(\.[0-9A-F]+)+)?/},c={scope:"symbol",match:/%[si](?=".*")/},u={scope:"attribute",match:n.concat(a,/(?=\s*=)/)};return{name:"Augmented Backus-Naur Form",illegal:/[!@#$^&',?+~`|:]/,keywords:r,contains:[{scope:"operator",match:/=\/?/},u,i,o,s,l,c,t.QUOTE_STRING_MODE,t.NUMBER_MODE]}}return Lo=e,Lo}var Po,P_;function JR(){if(P_)return Po;P_=1;function e(t){const n=t.regex,a=["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:n.concat(/"/,n.either(...a)),end:/"/,keywords:a,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 Po=e,Po}var ko,k_;function jR(){if(k_)return ko;k_=1;function e(t){const n=t.regex,a=/[a-zA-Z_$][a-zA-Z0-9_$]*/,r=n.concat(a,n.concat("(\\.",a,")*")),i=/([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/,o={className:"rest_arg",begin:/[.]{3}/,end:a,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:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.C_NUMBER_MODE,{match:[/\bpackage/,/\s+/,r],className:{1:"keyword",3:"title.class"}},{match:[/\b(?:class|interface|extends|implements)/,/\s+/,a],className:{1:"keyword",3:"title.class"}},{className:"meta",beginKeywords:"import include",end:/;/,keywords:{keyword:"import include"}},{beginKeywords:"function",end:/[{;]/,excludeEnd:!0,illegal:/\S/,contains:[t.inherit(t.TITLE_MODE,{className:"title.function"}),{className:"params",begin:/\(/,end:/\)/,contains:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,o]},{begin:n.concat(/:\s*/,i)}]},t.METHOD_GUARD],illegal:/#/}}return ko=e,ko}var Uo,U_;function eC(){if(U_)return Uo;U_=1;function e(t){const n="\\d(_|\\d)*",a="[eE][-+]?"+n,r=n+"(\\."+n+")?("+a+")?",i="\\w+",s="\\b("+(n+"#"+i+"(\\."+i+")?#("+a+")?")+"|"+r+")",l="[A-Za-z](_?[A-Za-z0-9.])*",c=`[]\\{\\}%#'"`,u=t.COMMENT("--","$"),d={begin:"\\s+:\\s+",end:"\\s*(:=|;|\\)|=>|$)",illegal:c,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:[u,{className:"string",begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{className:"string",begin:/'.'/},{className:"number",begin:s,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:c},{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:[u,{className:"title",begin:"(\\bwith\\s+)?\\b(function|procedure)\\s+",end:"(\\(|\\s+|$)",excludeBegin:!0,excludeEnd:!0,illegal:c},d,{className:"type",begin:"\\breturn\\s+",end:"(\\s+|;|$)",keywords:"return",excludeBegin:!0,excludeEnd:!0,endsParent:!0,illegal:c}]},{className:"type",begin:"\\b(sub)?type\\s+",end:"\\s+",keywords:"type",excludeBegin:!0,illegal:c},d]}}return Uo=e,Uo}var Fo,F_;function tC(){if(F_)return Fo;F_=1;function e(t){const n={className:"built_in",begin:"\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)"},a={className:"symbol",begin:"[a-zA-Z0-9_]+@"},r={className:"keyword",begin:"<",end:">",contains:[n,a]};return n.contains=[r],a.contains=[r],{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:[t.BACKSLASH_ESCAPE],relevance:0},{className:"string",begin:'"""',end:'"""'},{className:"string",begin:'"',end:'"',illegal:"\\n",contains:[t.BACKSLASH_ESCAPE],relevance:0},t.C_LINE_COMMENT_MODE,t.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_]+"}]}]}]},n,a,{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 Fo=e,Fo}var Bo,B_;function nC(){if(B_)return Bo;B_=1;function e(t){const n={className:"number",begin:/[$%]\d+/},a={className:"number",begin:/\b\d+/},r={className:"number",begin:/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?/},i={className:"number",begin:/:\d{1,5}/};return{name:"Apache config",aliases:["apacheconf"],case_insensitive:!0,contains:[t.HASH_COMMENT_MODE,{className:"section",begin:/<\/?/,end:/>/,contains:[r,i,t.inherit(t.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",n]},r,a,t.QUOTE_STRING_MODE]}}],illegal:/\S/}}return Bo=e,Bo}var Go,G_;function aC(){if(G_)return Go;G_=1;function e(t){const n=t.regex,a=t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),r={className:"params",begin:/\(/,end:/\)/,contains:["self",t.C_NUMBER_MODE,a]},i=t.COMMENT(/--/,/$/),o=t.COMMENT(/\(\*/,/\*\)/,{contains:["self",i]}),s=[i,o,t.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/],c=[/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:[a,t.C_NUMBER_MODE,{className:"built_in",begin:n.concat(/\b/,n.either(...c),/\b/)},{className:"built_in",begin:/^\s*return\b/},{className:"literal",begin:/\b(text item delimiters|current application|missing value)\b/},{className:"keyword",begin:n.concat(/\b/,n.either(...l),/\b/)},{beginKeywords:"on",illegal:/[${=;\n]/,contains:[t.UNDERSCORE_TITLE_MODE,r]},...s],illegal:/\/\/|->|=>|\[\[/}}return Go=e,Go}var Yo,Y_;function rC(){if(Y_)return Yo;Y_=1;function e(t){const n=t.regex,a="[A-Za-z_][0-9A-Za-z_]*",r={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"]},i=["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"],o={className:"symbol",begin:"\\$"+n.either(...i)},s={className:"number",variants:[{begin:"\\b(0[bB][01]+)"},{begin:"\\b(0[oO][0-7]+)"},{begin:t.C_NUMBER_RE}],relevance:0},l={className:"subst",begin:"\\$\\{",end:"\\}",keywords:r,contains:[]},c={className:"string",begin:"`",end:"`",contains:[t.BACKSLASH_ESCAPE,l]};l.contains=[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,c,s,t.REGEXP_MODE];const u=l.contains.concat([t.C_BLOCK_COMMENT_MODE,t.C_LINE_COMMENT_MODE]);return{name:"ArcGIS Arcade",case_insensitive:!0,keywords:r,contains:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,c,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,o,s,{begin:/[{,]\s*/,relevance:0,contains:[{begin:a+"\\s*:",returnBegin:!0,relevance:0,contains:[{className:"attr",begin:a,relevance:0}]}]},{begin:"("+t.RE_STARTERS_RE+"|\\b(return)\\b)\\s*",keywords:"return",contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.REGEXP_MODE,{className:"function",begin:"(\\(.*?\\)|"+a+")\\s*=>",returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:a},{begin:/\(\s*\)/},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:r,contains:u}]}]}],relevance:0},{beginKeywords:"function",end:/\{/,excludeEnd:!0,contains:[t.inherit(t.TITLE_MODE,{className:"title.function",begin:a}),{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:u}],illegal:/\[|%/},{begin:/\$[(.]/}],illegal:/#(?!!)/}}return Yo=e,Yo}var $o,$_;function iC(){if($_)return $o;$_=1;function e(n){const a=n.regex,r=n.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",o="[a-zA-Z_]\\w*::",l="(?!struct)("+i+"|"+a.optional(o)+"[a-zA-Z_]\\w*"+a.optional("<[^<>]+>")+")",c={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},d={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[n.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:"."},n.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},_={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},m={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},n.inherit(d,{className:"string"}),{className:"string",begin:/<.*?>/},r,n.C_BLOCK_COMMENT_MODE]},p={className:"title",begin:a.optional(o)+n.IDENT_RE,relevance:0},g=a.optional(o)+n.IDENT_RE+"\\s*\\(",b=["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"],A=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],O=["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"],M=["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:A,keyword:b,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:O},I={className:"function.dispatch",relevance:0,keywords:{_hint:M},begin:a.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,n.IDENT_RE,a.lookahead(/(<[^<>]+>|)\s*\(/))},h=[I,m,c,r,n.C_BLOCK_COMMENT_MODE,_,d],E={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:T,contains:h.concat([{begin:/\(/,end:/\)/,keywords:T,contains:h.concat(["self"]),relevance:0}]),relevance:0},D={className:"function",begin:"("+l+"[\\*&\\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,_]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:T,relevance:0,contains:[r,n.C_BLOCK_COMMENT_MODE,d,_,c,{begin:/\(/,end:/\)/,keywords:T,relevance:0,contains:["self",r,n.C_BLOCK_COMMENT_MODE,d,_,c]}]},c,r,n.C_BLOCK_COMMENT_MODE,m]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:T,illegal:"",keywords:T,contains:["self",c]},{begin:n.IDENT_RE+"::",keywords:T},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}function t(n){const a={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"]},r=e(n),i=r.keywords;return i.type=[...i.type,...a.type],i.literal=[...i.literal,...a.literal],i.built_in=[...i.built_in,...a.built_in],i._hints=a._hints,r.name="Arduino",r.aliases=["ino"],r.supersetOf="cpp",r}return $o=t,$o}var qo,q_;function oC(){if(q_)return qo;q_=1;function e(t){const n={variants:[t.COMMENT("^[ \\t]*(?=#)","$",{relevance:0,excludeBegin:!0}),t.COMMENT("[;@]","$",{relevance:0}),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]};return{name:"ARM Assembly",case_insensitive:!0,aliases:["arm"],keywords:{$pattern:"\\.?"+t.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)"},n,t.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 qo=e,qo}var Ho,H_;function sC(){if(H_)return Ho;H_=1;function e(t){const n=t.regex,a=n.concat(/[\p{L}_]/u,n.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),r=/[\p{L}0-9._:-]+/u,i={className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},o={begin:/\s/,contains:[{className:"keyword",begin:/#?[a-z_][a-z1-9_-]+/,illegal:/\n/}]},s=t.inherit(o,{begin:/\(/,end:/\)/}),l=t.inherit(t.APOS_STRING_MODE,{className:"string"}),c=t.inherit(t.QUOTE_STRING_MODE,{className:"string"}),u={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:[o,c,l,s,{begin:/\[/,end:/\]/,contains:[{className:"meta",begin://,contains:[o,s,c,l]}]}]},t.COMMENT(//,{relevance:10}),{begin://,relevance:10},i,{className:"meta",end:/\?>/,variants:[{begin:/<\?xml/,relevance:10,contains:[c]},{begin:/<\?[a-z][a-z0-9]+/}]},{className:"tag",begin:/)/,end:/>/,keywords:{name:"style"},contains:[u],starts:{end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",begin:/)/,end:/>/,keywords:{name:"script"},contains:[u],starts:{end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{className:"tag",begin:/<>|<\/>/},{className:"tag",begin:n.concat(//,/>/,/\s/)))),end:/\/?>/,contains:[{className:"name",begin:a,relevance:0,starts:u}]},{className:"tag",begin:n.concat(/<\//,n.lookahead(n.concat(a,/>/))),contains:[{className:"name",begin:a,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}}return Ho=e,Ho}var Vo,V_;function lC(){if(V_)return Vo;V_=1;function e(t){const n=t.regex,a={begin:"^'{3,}[ \\t]*$",relevance:10},r=[{begin:/\\[*_`]/},{begin:/\\\\\*{2}[^\n]*?\*{2}/},{begin:/\\\\_{2}[^\n]*_{2}/},{begin:/\\\\`{2}[^\n]*`{2}/},{begin:/[:;}][*_`](?![*_`])/}],i=[{className:"strong",begin:/\*{2}([^\n]+?)\*{2}/},{className:"strong",begin:n.concat(/\*\*/,/((\*(?!\*)|\\[^\n]|[^*\n\\])+\n)+/,/(\*(?!\*)|\\[^\n]|[^*\n\\])*/,/\*\*/),relevance:0},{className:"strong",begin:/\B\*(\S|\S[^\n]*?\S)\*(?!\w)/},{className:"strong",begin:/\*[^\s]([^\n]+\n)+([^\n]+)\*/}],o=[{className:"emphasis",begin:/_{2}([^\n]+?)_{2}/},{className:"emphasis",begin:n.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}],s={className:"symbol",begin:"^(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\\s+",relevance:10},l={className:"bullet",begin:"^(\\*+|-+|\\.+|[^\\n]+?::)\\s+"};return{name:"AsciiDoc",aliases:["adoc"],contains:[t.COMMENT("^/{4,}\\n","\\n/{4,}$",{relevance:10}),t.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,s,...r,...i,...o,{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},a,{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 Vo=e,Vo}var zo,z_;function cC(){if(z_)return zo;z_=1;function e(t){const n=t.regex,a=["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"],r=["get","set","args","call"];return{name:"AspectJ",keywords:a,illegal:/<\/|#/,contains:[t.COMMENT(/\/\*\*/,/\*\//,{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:/@[A-Za-z]+/}]}),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{className:"class",beginKeywords:"aspect",end:/[{;=]/,excludeEnd:!0,illegal:/[:;"\[\]]/,contains:[{beginKeywords:"extends implements pertypewithin perthis pertarget percflowbelow percflow issingleton"},t.UNDERSCORE_TITLE_MODE,{begin:/\([^\)]*/,end:/[)]+/,keywords:a.concat(r),excludeEnd:!1}]},{className:"class",beginKeywords:"class interface",end:/[{;=]/,excludeEnd:!0,relevance:0,keywords:"class interface",illegal:/[:"\[\]]/,contains:[{beginKeywords:"extends implements"},t.UNDERSCORE_TITLE_MODE]},{beginKeywords:"pointcut after before around throwing returning",end:/[)]/,excludeEnd:!1,illegal:/["\[\]]/,contains:[{begin:n.concat(t.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,contains:[t.UNDERSCORE_TITLE_MODE]}]},{begin:/[:]/,returnBegin:!0,end:/[{;]/,relevance:0,excludeEnd:!1,keywords:a,illegal:/["\[\]]/,contains:[{begin:n.concat(t.UNDERSCORE_IDENT_RE,/\s*\(/),keywords:a.concat(r),relevance:0},t.QUOTE_STRING_MODE]},{beginKeywords:"new throw",relevance:0},{className:"function",begin:/\w+ +\w+(\.\w+)?\s*\([^\)]*\)\s*((throws)[\w\s,]+)?[\{;]/,returnBegin:!0,end:/[{;=]/,keywords:a,excludeEnd:!0,contains:[{begin:n.concat(t.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,relevance:0,contains:[t.UNDERSCORE_TITLE_MODE]},{className:"params",begin:/\(/,end:/\)/,relevance:0,keywords:a,contains:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},t.C_NUMBER_MODE,{className:"meta",begin:/@[A-Za-z]+/}]}}return zo=e,zo}var Wo,W_;function uC(){if(W_)return Wo;W_=1;function e(t){const n={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:[n,t.inherit(t.QUOTE_STRING_MODE,{contains:[n]}),t.COMMENT(";","$",{relevance:0}),t.C_BLOCK_COMMENT_MODE,{className:"number",begin:t.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 Wo=e,Wo}var Ko,K_;function dC(){if(K_)return Ko;K_=1;function e(t){const n="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",a=["EndRegion","forcedef","forceref","ignorefunc","include","include-once","NoTrayIcon","OnAutoItStartRegister","pragma","Region","RequireAdmin","Tidy_Off","Tidy_On","Tidy_Parameters"],r="True False And Null Not Or Default",i="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",o={variants:[t.COMMENT(";","$",{relevance:0}),t.COMMENT("#cs","#ce"),t.COMMENT("#comments-start","#comments-end")]},s={begin:"\\$[A-z0-9_]+"},l={className:"string",variants:[{begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]}]},c={variants:[t.BINARY_NUMBER_MODE,t.C_NUMBER_MODE]},u={className:"meta",begin:"#",end:"$",keywords:{keyword:a},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,o]},d={className:"symbol",begin:"@[A-z0-9_]+"},_={beginKeywords:"Func",end:"$",illegal:"\\$|\\[|%",contains:[t.inherit(t.UNDERSCORE_TITLE_MODE,{className:"title.function"}),{className:"params",begin:"\\(",end:"\\)",contains:[s,l,c]}]};return{name:"AutoIt",case_insensitive:!0,illegal:/\/\*/,keywords:{keyword:n,built_in:i,literal:r},contains:[o,s,l,c,u,d,_]}}return Ko=e,Ko}var Qo,Q_;function _C(){if(Q_)return Qo;Q_=1;function e(t){return{name:"AVR Assembly",case_insensitive:!0,keywords:{$pattern:"\\.?"+t.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:[t.C_BLOCK_COMMENT_MODE,t.COMMENT(";","$",{relevance:0}),t.C_NUMBER_MODE,t.BINARY_NUMBER_MODE,{className:"number",begin:"\\b(\\$[a-zA-Z0-9]+|0o[0-7]+)"},t.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 Qo=e,Qo}var Xo,X_;function pC(){if(X_)return Xo;X_=1;function e(t){const n={className:"variable",variants:[{begin:/\$[\w\d#@][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},a="BEGIN END if else while do for in break continue delete next nextfile function func exit|10",r={className:"string",contains:[t.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:/"/},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE]};return{name:"Awk",keywords:{keyword:a},contains:[n,r,t.REGEXP_MODE,t.HASH_COMMENT_MODE,t.NUMBER_MODE]}}return Xo=e,Xo}var Zo,Z_;function mC(){if(Z_)return Zo;Z_=1;function e(t){const n=t.UNDERSCORE_IDENT_RE,o={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"]},s={variants:[{match:[/(class|interface)\s+/,n,/\s+(extends|implements)\s+/,n]},{match:[/class\s+/,n]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:o};return{name:"X++",aliases:["x++"],keywords:o,contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,{className:"meta",begin:"#",end:"$"},s]}}return Zo=e,Zo}var Jo,J_;function gC(){if(J_)return Jo;J_=1;function e(t){const n=t.regex,a={},r={begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[a]}]};Object.assign(a,{className:"variable",variants:[{begin:n.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},r]});const i={className:"subst",begin:/\$\(/,end:/\)/,contains:[t.BACKSLASH_ESCAPE]},o=t.inherit(t.COMMENT(),{match:[/(^|\s)/,/#.*$/],scope:{2:"comment"}}),s={begin:/<<-?\s*(?=\w+)/,starts:{contains:[t.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,className:"string"})]}},l={className:"string",begin:/"/,end:/"/,contains:[t.BACKSLASH_ESCAPE,a,i]};i.contains.push(l);const c={match:/\\"/},u={className:"string",begin:/'/,end:/'/},d={match:/\\'/},_={begin:/\$?\(\(/,end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},t.NUMBER_MODE,a]},m=["fish","bash","zsh","sh","csh","ksh","tcsh","dash","scsh"],p=t.SHEBANG({binary:`(${m.join("|")})`,relevance:10}),g={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,contains:[t.inherit(t.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0},b=["if","then","else","elif","fi","time","for","while","until","in","do","done","case","esac","coproc","function","select"],A=["true","false"],O={match:/(\/[a-z._-]+)+/},M=["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset"],w=["alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","sudo","type","typeset","ulimit","unalias"],v=["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"],T=["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:b,literal:A,built_in:[...M,...w,"set","shopt",...v,...T]},contains:[p,t.SHEBANG(),g,_,o,s,O,l,c,u,d,a]}}return Jo=e,Jo}var jo,j_;function EC(){if(j_)return jo;j_=1;function e(t){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:[t.BACKSLASH_ESCAPE]},t.COMMENT("REM","$",{relevance:10}),t.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 jo=e,jo}var es,ep;function fC(){if(ep)return es;ep=1;function e(t){return{name:"Backus–Naur Form",contains:[{className:"attribute",begin://},{begin:/::=/,end:/$/,contains:[{begin://},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE]}]}}return es=e,es}var ts,tp;function SC(){if(tp)return ts;tp=1;function e(t){const n={className:"literal",begin:/[+-]+/,relevance:0};return{name:"Brainfuck",aliases:["bf"],contains:[t.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:[n]},n]}}return ts=e,ts}var ns,np;function bC(){if(np)return ns;np=1;function e(t){const n=t.regex,a=t.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),r="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",s="("+r+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",l={className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{match:/\batomic_[a-z]{3,6}\b/}]},u={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[t.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:"."},t.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},d={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},_={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},t.inherit(u,{className:"string"}),{className:"string",begin:/<.*?>/},a,t.C_BLOCK_COMMENT_MODE]},m={className:"title",begin:n.optional(i)+t.IDENT_RE,relevance:0},p=n.optional(i)+t.IDENT_RE+"\\s*\\(",A={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"},O=[_,l,a,t.C_BLOCK_COMMENT_MODE,d,u],M={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:A,contains:O.concat([{begin:/\(/,end:/\)/,keywords:A,contains:O.concat(["self"]),relevance:0}]),relevance:0},w={begin:"("+s+"[\\*&\\s]+)+"+p,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:A,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:r,keywords:A,relevance:0},{begin:p,returnBegin:!0,contains:[t.inherit(m,{className:"title.function"})],relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:A,relevance:0,contains:[a,t.C_BLOCK_COMMENT_MODE,u,d,l,{begin:/\(/,end:/\)/,keywords:A,relevance:0,contains:["self",a,t.C_BLOCK_COMMENT_MODE,u,d,l]}]},l,a,t.C_BLOCK_COMMENT_MODE,_]};return{name:"C",aliases:["h"],keywords:A,disableAutodetect:!0,illegal:"=]/,contains:[{beginKeywords:"final class struct"},t.TITLE_MODE]}]),exports:{preprocessor:_,strings:u,keywords:A}}}return ns=e,ns}var as,ap;function TC(){if(ap)return as;ap=1;function e(t){const n=t.regex,a=["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"],r="false true",i=[t.C_LINE_COMMENT_MODE,t.COMMENT(/\{/,/\}/,{relevance:0}),t.COMMENT(/\(\*/,/\*\)/,{relevance:10})],o={className:"string",begin:/'/,end:/'/,contains:[{begin:/''/}]},s={className:"string",begin:/(#\d+)+/},l={className:"number",begin:"\\b\\d+(\\.\\d+)?(DT|D|T)",relevance:0},c={className:"string",begin:'"',end:'"'},u={match:[/procedure/,/\s+/,/[a-zA-Z_][\w@]*/,/\s*/],scope:{1:"keyword",3:"title.function"},contains:[{className:"params",begin:/\(/,end:/\)/,keywords:a,contains:[o,s,t.NUMBER_MODE]},...i]},d=["Table","Form","Report","Dataport","Codeunit","XMLport","MenuSuite","Page","Query"],_={match:[/OBJECT/,/\s+/,n.either(...d),/\s+/,/\d+/,/\s+(?=[^\s])/,/.*/,/$/],relevance:3,scope:{1:"keyword",3:"type",5:"number",7:"title"}};return{name:"C/AL",case_insensitive:!0,keywords:{keyword:a,literal:r},illegal:/\/\*/,contains:[{match:/[\w]+(?=\=)/,scope:"attribute",relevance:0},o,s,l,c,t.NUMBER_MODE,_,u]}}return as=e,as}var rs,rp;function hC(){if(rp)return rs;rp=1;function e(t){const n=["struct","enum","interface","union","group","import","using","const","annotation","extends","in","of","on","as","with","from","fixed"],a=["Void","Bool","Int8","Int16","Int32","Int64","UInt8","UInt16","UInt32","UInt64","Float32","Float64","Text","Data","AnyPointer","AnyStruct","Capability","List"],r=["true","false"],i={variants:[{match:[/(struct|enum|interface)/,/\s+/,t.IDENT_RE]},{match:[/extends/,/\s*\(/,t.IDENT_RE,/\s*\)/]}],scope:{1:"keyword",3:"title.class"}};return{name:"Cap’n Proto",aliases:["capnp"],keywords:{keyword:n,type:a,literal:r},contains:[t.QUOTE_STRING_MODE,t.NUMBER_MODE,t.HASH_COMMENT_MODE,{className:"meta",begin:/@0x[\w\d]{16};/,illegal:/\n/},{className:"symbol",begin:/@\d+\b/},i]}}return rs=e,rs}var is,ip;function vC(){if(ip)return is;ip=1;function e(t){const n=["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"],a=["shared","abstract","formal","default","actual","variable","late","native","deprecated","final","sealed","annotation","suppressWarnings","small"],r=["doc","by","license","see","throws","tagged"],i={className:"subst",excludeBegin:!0,excludeEnd:!0,begin:/``/,end:/``/,keywords:n,relevance:10},o=[{className:"string",begin:'"""',end:'"""',relevance:10},{className:"string",begin:'"',end:'"',contains:[i]},{className:"string",begin:"'",end:"'"},{className:"number",begin:"#[0-9a-fA-F_]+|\\$[01_]+|[0-9_]+(?:\\.[0-9_](?:[eE][+-]?\\d+)?)?[kMGTPmunpf]?",relevance:0}];return i.contains=o,{name:"Ceylon",keywords:{keyword:n.concat(a),meta:r},illegal:"\\$[^01]|#[^0-9a-fA-F]",contains:[t.C_LINE_COMMENT_MODE,t.COMMENT("/\\*","\\*/",{contains:["self"]}),{className:"meta",begin:'@[a-z]\\w*(?::"[^"]*")?'}].concat(o)}}return is=e,is}var os,op;function RC(){if(op)return os;op=1;function e(t){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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,{begin:"->|<-[|:]?|#!?|>>=|\\{\\||\\|\\}|:==|=:|<>"}]}}return os=e,os}var ss,sp;function CC(){if(sp)return ss;sp=1;function e(t){const n="a-zA-Z_\\-!.?+*=<>&'",a="[#]?["+n+"]["+n+"0-9/;:$#]*",r="def defonce defprotocol defstruct defmulti defmethod defn- defn defmacro deftype defrecord",i={$pattern:a,built_in:r+" 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"},o={begin:a,relevance:0},s={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}]},c={scope:"regex",begin:/#"/,end:/"/,contains:[t.BACKSLASH_ESCAPE]},u=t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),d={scope:"punctuation",match:/,/,relevance:0},_=t.COMMENT(";","$",{relevance:0}),m={className:"literal",begin:/\b(true|false|nil)\b/},p={begin:"\\[|(#::?"+a+")?\\{",end:"[\\]\\}]",relevance:0},g={className:"symbol",begin:"[:]{1,2}"+a},b={begin:"\\(",end:"\\)"},A={endsWithParent:!0,relevance:0},O={keywords:i,className:"name",begin:a,relevance:0,starts:A},M=[d,b,l,c,u,_,g,p,s,m,o],w={beginKeywords:r,keywords:{$pattern:a,keyword:r},end:'(\\[|#|\\d|"|:|\\{|\\)|\\(|$)',contains:[{className:"title",begin:a,relevance:0,excludeEnd:!0,endsParent:!0}].concat(M)};return b.contains=[w,O,A],A.contains=M,p.contains=M,{name:"Clojure",aliases:["clj","edn"],illegal:/\S/,contains:[d,b,l,c,u,_,g,p,s,m]}}return ss=e,ss}var ls,lp;function yC(){if(lp)return ls;lp=1;function e(t){return{name:"Clojure REPL",contains:[{className:"meta.prompt",begin:/^([\w.-]+|\s*#_)?=>/,starts:{end:/$/,subLanguage:"clojure"}}]}}return ls=e,ls}var cs,cp;function NC(){if(cp)return cs;cp=1;function e(t){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:/\}/},t.COMMENT(/#\[\[/,/]]/),t.HASH_COMMENT_MODE,t.QUOTE_STRING_MODE,t.NUMBER_MODE]}}return cs=e,cs}var us,up;function OC(){if(up)return us;up=1;const 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"],t=["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"],a=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],r=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],i=[].concat(r,n,a);function o(s){const l=["npm","print"],c=["yes","no","on","off"],u=["then","unless","until","loop","by","when","and","or","is","isnt","not"],d=["var","const","let","function","static"],_=v=>T=>!v.includes(T),m={keyword:e.concat(u).filter(_(d)),literal:t.concat(c),built_in:i.concat(l)},p="[A-Za-z$_][0-9A-Za-z$_]*",g={className:"subst",begin:/#\{/,end:/\}/,keywords:m},b=[s.BINARY_NUMBER_MODE,s.inherit(s.C_NUMBER_MODE,{starts:{end:"(\\s*/)?",relevance:0}}),{className:"string",variants:[{begin:/'''/,end:/'''/,contains:[s.BACKSLASH_ESCAPE]},{begin:/'/,end:/'/,contains:[s.BACKSLASH_ESCAPE]},{begin:/"""/,end:/"""/,contains:[s.BACKSLASH_ESCAPE,g]},{begin:/"/,end:/"/,contains:[s.BACKSLASH_ESCAPE,g]}]},{className:"regexp",variants:[{begin:"///",end:"///",contains:[g,s.HASH_COMMENT_MODE]},{begin:"//[gim]{0,3}(?=\\W)",relevance:0},{begin:/\/(?![ *]).*?(?![\\]).\/[gim]{0,3}(?=\W)/}]},{begin:"@"+p},{subLanguage:"javascript",excludeBegin:!0,excludeEnd:!0,variants:[{begin:"```",end:"```"},{begin:"`",end:"`"}]}];g.contains=b;const A=s.inherit(s.TITLE_MODE,{begin:p}),O="(\\(.*\\)\\s*)?\\B[-=]>",M={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:m,contains:["self"].concat(b)}]},w={variants:[{match:[/class\s+/,p,/\s+extends\s+/,p]},{match:[/class\s+/,p]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:m};return{name:"CoffeeScript",aliases:["coffee","cson","iced"],keywords:m,illegal:/\/\*/,contains:[...b,s.COMMENT("###","###"),s.HASH_COMMENT_MODE,{className:"function",begin:"^\\s*"+p+"\\s*=\\s*"+O,end:"[-=]>",returnBegin:!0,contains:[A,M]},{begin:/[:\(,=]\s*/,relevance:0,contains:[{className:"function",begin:O,end:"[-=]>",returnBegin:!0,contains:[M]}]},w,{begin:p+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}]}}return us=o,us}var ds,dp;function AC(){if(dp)return ds;dp=1;function e(t){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:[t.QUOTE_STRING_MODE,t.COMMENT("\\(\\*","\\*\\)"),t.C_NUMBER_MODE,{className:"type",excludeBegin:!0,begin:"\\|\\s*",end:"\\w+"},{begin:/[-=]>/}]}}return ds=e,ds}var _s,_p;function IC(){if(_p)return _s;_p=1;function e(t){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}]}]},t.C_LINE_COMMENT_MODE,t.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 _s=e,_s}var ps,pp;function DC(){if(pp)return ps;pp=1;function e(t){const n=t.regex,a=t.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),r="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",s="(?!struct)("+r+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",l={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},u={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[t.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:"."},t.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},d={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},_={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},t.inherit(u,{className:"string"}),{className:"string",begin:/<.*?>/},a,t.C_BLOCK_COMMENT_MODE]},m={className:"title",begin:n.optional(i)+t.IDENT_RE,relevance:0},p=n.optional(i)+t.IDENT_RE+"\\s*\\(",g=["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"],b=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],A=["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"],O=["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"],v={type:b,keyword:g,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:A},T={className:"function.dispatch",relevance:0,keywords:{_hint:O},begin:n.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,t.IDENT_RE,n.lookahead(/(<[^<>]+>|)\s*\(/))},I=[T,_,l,a,t.C_BLOCK_COMMENT_MODE,d,u],h={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:v,contains:I.concat([{begin:/\(/,end:/\)/,keywords:v,contains:I.concat(["self"]),relevance:0}]),relevance:0},E={className:"function",begin:"("+s+"[\\*&\\s]+)+"+p,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:v,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:r,keywords:v,relevance:0},{begin:p,returnBegin:!0,contains:[m],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[u,d]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:v,relevance:0,contains:[a,t.C_BLOCK_COMMENT_MODE,u,d,l,{begin:/\(/,end:/\)/,keywords:v,relevance:0,contains:["self",a,t.C_BLOCK_COMMENT_MODE,u,d,l]}]},l,a,t.C_BLOCK_COMMENT_MODE,_]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:v,illegal:"",keywords:v,contains:["self",l]},{begin:t.IDENT_RE+"::",keywords:v},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}return ps=e,ps}var ms,mp;function xC(){if(mp)return ms;mp=1;function e(t){const n="primitive rsc_template",a="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:[t.HASH_COMMENT_MODE,{beginKeywords:"node",starts:{end:"\\s*([\\w_-]+:)?",starts:{className:"title",end:"\\s*[\\$\\w_][\\w_-]*"}}},{beginKeywords:n,starts:{className:"title",end:"\\s*[\\$\\w_][\\w_-]*",starts:{end:"\\s*@?[\\w_][\\w_\\.:-]*"}}},{begin:"\\b("+a.split(" ").join("|")+")\\s+",keywords:a,starts:{className:"title",end:"[\\$\\w_][\\w_-]*"}},{beginKeywords:"property rsc_defaults op_defaults",starts:{className:"title",end:"\\s*([\\w_-]+:)?"}},t.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 ms=e,ms}var gs,gp;function MC(){if(gp)return gs;gp=1;function e(t){const n="(_?[ui](8|16|32|64|128))?",a="(_?f(32|64))?",r="[a-zA-Z_]\\w*[!?=]?",i="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?",o="[A-Za-z_]\\w*(::\\w+)*(\\?|!)?",s={$pattern:r,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:s},c={className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},u={className:"template-variable",variants:[{begin:"\\{\\{",end:"\\}\\}"},{begin:"\\{%",end:"%\\}"}],keywords:s};function d(O,M){const w=[{begin:O,end:M}];return w[0].contains=w,w}const _={className:"string",contains:[t.BACKSLASH_ESCAPE,l],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:"%[Qwi]?\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%[Qwi]?\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%[Qwi]?\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%[Qwi]?<",end:">",contains:d("<",">")},{begin:"%[Qwi]?\\|",end:"\\|"},{begin:/<<-\w+$/,end:/^\s*\w+$/}],relevance:0},m={className:"string",variants:[{begin:"%q\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%q\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%q\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%q<",end:">",contains:d("<",">")},{begin:"%q\\|",end:"\\|"},{begin:/<<-'\w+'$/,end:/^\s*\w+$/}],relevance:0},p={begin:"(?!%\\})("+t.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:[t.BACKSLASH_ESCAPE,l],variants:[{begin:"//[a-z]*",relevance:0},{begin:"/(?!\\/)",end:"/[a-z]*"}]}],relevance:0},g={className:"regexp",contains:[t.BACKSLASH_ESCAPE,l],variants:[{begin:"%r\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%r\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%r\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%r<",end:">",contains:d("<",">")},{begin:"%r\\|",end:"\\|"}],relevance:0},b={className:"meta",begin:"@\\[",end:"\\]",contains:[t.inherit(t.QUOTE_STRING_MODE,{className:"string"})]},A=[u,_,m,g,p,b,c,t.HASH_COMMENT_MODE,{className:"class",beginKeywords:"class module struct",end:"$|;",illegal:/=/,contains:[t.HASH_COMMENT_MODE,t.inherit(t.TITLE_MODE,{begin:o}),{begin:"<"}]},{className:"class",beginKeywords:"lib enum union",end:"$|;",illegal:/=/,contains:[t.HASH_COMMENT_MODE,t.inherit(t.TITLE_MODE,{begin:o})]},{beginKeywords:"annotation",end:"$|;",illegal:/=/,contains:[t.HASH_COMMENT_MODE,t.inherit(t.TITLE_MODE,{begin:o})],relevance:2},{className:"function",beginKeywords:"def",end:/\B\b/,contains:[t.inherit(t.TITLE_MODE,{begin:i,endsParent:!0})]},{className:"function",beginKeywords:"fun macro",end:/\B\b/,contains:[t.inherit(t.TITLE_MODE,{begin:i,endsParent:!0})],relevance:2},{className:"symbol",begin:t.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":",contains:[_,{begin:i}],relevance:0},{className:"number",variants:[{begin:"\\b0b([01_]+)"+n},{begin:"\\b0o([0-7_]+)"+n},{begin:"\\b0x([A-Fa-f0-9_]+)"+n},{begin:"\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?"+a+"(?!_)"},{begin:"\\b([1-9][0-9_]*|0)"+n}],relevance:0}];return l.contains=A,u.contains=A.slice(1),{name:"Crystal",aliases:["cr"],keywords:s,contains:A}}return gs=e,gs}var Es,Ep;function wC(){if(Ep)return Es;Ep=1;function e(t){const n=["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],a=["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"],r=["default","false","null","true"],i=["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"],o=["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"],s={keyword:i.concat(o),built_in:n,literal:r},l=t.inherit(t.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),c={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},u={className:"string",begin:/"""("*)(?!")(.|\n)*?"""\1/,relevance:1},d={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},_=t.inherit(d,{illegal:/\n/}),m={className:"subst",begin:/\{/,end:/\}/,keywords:s},p=t.inherit(m,{illegal:/\n/}),g={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},t.BACKSLASH_ESCAPE,p]},b={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},m]},A=t.inherit(b,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},p]});m.contains=[b,g,d,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,c,t.C_BLOCK_COMMENT_MODE],p.contains=[A,g,_,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,c,t.inherit(t.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const O={variants:[u,b,g,d,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE]},M={begin:"<",end:">",contains:[{beginKeywords:"in out"},l]},w=t.IDENT_RE+"(<"+t.IDENT_RE+"(\\s*,\\s*"+t.IDENT_RE+")*>)?(\\[\\])?",v={begin:"@"+t.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],keywords:s,illegal:/::/,contains:[t.COMMENT("///","$",{returnBegin:!0,contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{begin:""},{begin:""}]}]}),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elif endif define undef warning error line region endregion pragma checksum"}},O,c,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},l,M,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[l,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[l,M,t.C_LINE_COMMENT_MODE,t.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:"("+w+"\\s+)+"+t.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:s,contains:[{beginKeywords:a.join(" "),relevance:0},{begin:t.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,contains:[t.TITLE_MODE,M],relevance:0},{match:/\(\)/},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:s,relevance:0,contains:[O,c,t.C_BLOCK_COMMENT_MODE]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},v]}}return Es=e,Es}var fs,fp;function LC(){if(fp)return fs;fp=1;function e(t){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 fs=e,fs}var Ss,Sp;function PC(){if(Sp)return Ss;Sp=1;const e=c=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:c.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:[c.APOS_STRING_MODE,c.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:c.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_-]*/}}),t=["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"],n=["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"],a=[...t,...n],r=["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(),i=["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(),o=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),s=["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(c){const u=c.regex,d=e(c),_={begin:/-(webkit|moz|ms|o)-(?=[a-z])/},m="and or not only",p=/@-?\w[\w]*(-\w+)*/,g="[a-zA-Z-][a-zA-Z0-9_-]*",b=[c.APOS_STRING_MODE,c.QUOTE_STRING_MODE];return{name:"CSS",case_insensitive:!0,illegal:/[=|'\$]/,keywords:{keyframePosition:"from to"},classNameAliases:{keyframePosition:"selector-tag"},contains:[d.BLOCK_COMMENT,_,d.CSS_NUMBER_MODE,{className:"selector-id",begin:/#[A-Za-z0-9_-]+/,relevance:0},{className:"selector-class",begin:"\\."+g,relevance:0},d.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",variants:[{begin:":("+i.join("|")+")"},{begin:":(:)?("+o.join("|")+")"}]},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+s.join("|")+")\\b"},{begin:/:/,end:/[;}{]/,contains:[d.BLOCK_COMMENT,d.HEXCOLOR,d.IMPORTANT,d.CSS_NUMBER_MODE,...b,{begin:/(url|data-uri)\(/,end:/\)/,relevance:0,keywords:{built_in:"url data-uri"},contains:[...b,{className:"string",begin:/[^)]/,endsWithParent:!0,excludeEnd:!0}]},d.FUNCTION_DISPATCH]},{begin:u.lookahead(/@/),end:"[{;]",relevance:0,illegal:/:/,contains:[{className:"keyword",begin:p},{begin:/\s/,endsWithParent:!0,excludeEnd:!0,relevance:0,keywords:{$pattern:/[a-z-]+/,keyword:m,attribute:r.join(" ")},contains:[{begin:/[a-z-]+(?=:)/,className:"attribute"},...b,d.CSS_NUMBER_MODE]}]},{className:"selector-tag",begin:"\\b("+a.join("|")+")\\b"}]}}return Ss=l,Ss}var bs,bp;function kC(){if(bp)return bs;bp=1;function e(t){const n={$pattern:t.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"},a="(0|[1-9][\\d_]*)",r="(0|[1-9][\\d_]*|\\d[\\d_]*|[\\d_]+?\\d)",i="0[bB][01_]+",o="([\\da-fA-F][\\da-fA-F_]*|_[\\da-fA-F][\\da-fA-F_]*)",s="0[xX]"+o,l="([eE][+-]?"+r+")",c="("+r+"(\\.\\d*|"+l+")|\\d+\\."+r+"|\\."+a+l+"?)",u="(0[xX]("+o+"\\."+o+"|\\.?"+o+")[pP][+-]?"+r+")",d="("+a+"|"+i+"|"+s+")",_="("+u+"|"+c+")",m=`\\\\(['"\\?\\\\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,};`,p={className:"number",begin:"\\b"+d+"(L|u|U|Lu|LU|uL|UL)?",relevance:0},g={className:"number",begin:"\\b("+_+"([fF]|L|i|[fF]i|Li)?|"+d+"(i|[fF]i|Li))",relevance:0},b={className:"string",begin:"'("+m+"|.)",end:"'",illegal:"."},O={className:"string",begin:'"',contains:[{begin:m,relevance:0}],end:'"[cwd]?'},M={className:"string",begin:'[rq]"',end:'"[cwd]?',relevance:5},w={className:"string",begin:"`",end:"`[cwd]?"},v={className:"string",begin:'x"[\\da-fA-F\\s\\n\\r]*"[cwd]?',relevance:10},T={className:"string",begin:'q"\\{',end:'\\}"'},I={className:"meta",begin:"^#!",end:"$",relevance:5},h={className:"meta",begin:"#(line)",end:"$",relevance:5},E={className:"keyword",begin:"@[a-zA-Z_][a-zA-Z_\\d]*"},D=t.COMMENT("\\/\\+","\\+\\/",{contains:["self"],relevance:10});return{name:"D",keywords:n,contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,D,v,O,M,w,T,g,p,b,I,h,E]}}return bs=e,bs}var Ts,Tp;function UC(){if(Tp)return Ts;Tp=1;function e(t){const n=t.regex,a={begin:/<\/?[A-Za-z_]/,end:">",subLanguage:"xml",relevance:0},r={begin:"^[-\\*]{3,}",end:"$"},i={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}]},o={className:"bullet",begin:"^[ ]*([*+-]|(\\d+\\.))(?=\\s+)",end:"\\s+",excludeEnd:!0},s={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+.-]*/,c={variants:[{begin:/\[.+?\]\[.*?\]/,relevance:0},{begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,relevance:2},{begin:n.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}]},u={className:"strong",contains:[],variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]},d={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{begin:/_(?![_\s])/,end:/_/,relevance:0}]},_=t.inherit(u,{contains:[]}),m=t.inherit(d,{contains:[]});u.contains.push(m),d.contains.push(_);let p=[a,c];return[u,d,_,m].forEach(O=>{O.contains=O.contains.concat(p)}),p=p.concat(u,d),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:p},{begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",contains:p}]}]},a,o,u,d,{className:"quote",begin:"^>\\s+",contains:p,end:"$"},i,r,c,s,{scope:"literal",match:/&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/}]}}return Ts=e,Ts}var hs,hp;function FC(){if(hp)return hs;hp=1;function e(t){const n={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"}]},a={className:"subst",variants:[{begin:/\$\{/,end:/\}/}],keywords:"true false null this is new super"},r={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/}]},i={className:"string",variants:[{begin:"r'''",end:"'''"},{begin:'r"""',end:'"""'},{begin:"r'",end:"'",illegal:"\\n"},{begin:'r"',end:'"',illegal:"\\n"},{begin:"'''",end:"'''",contains:[t.BACKSLASH_ESCAPE,n,a]},{begin:'"""',end:'"""',contains:[t.BACKSLASH_ESCAPE,n,a]},{begin:"'",end:"'",illegal:"\\n",contains:[t.BACKSLASH_ESCAPE,n,a]},{begin:'"',end:'"',illegal:"\\n",contains:[t.BACKSLASH_ESCAPE,n,a]}]};a.contains=[r,i];const o=["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"],s=o.map(u=>`${u}?`);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:o.concat(s).concat(["Never","Null","dynamic","print","document","querySelector","querySelectorAll","window"]),$pattern:/[A-Za-z][A-Za-z0-9_]*\??/},contains:[i,t.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),t.COMMENT(/\/{3,} ?/,/$/,{contains:[{subLanguage:"markdown",begin:".",end:"$",relevance:0}]}),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},t.UNDERSCORE_TITLE_MODE]},r,{className:"meta",begin:"@[A-Za-z]+"},{begin:"=>"}]}}return hs=e,hs}var vs,vp;function BC(){if(vp)return vs;vp=1;function e(t){const n=["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"],a=[t.C_LINE_COMMENT_MODE,t.COMMENT(/\{/,/\}/,{relevance:0}),t.COMMENT(/\(\*/,/\*\)/,{relevance:10})],r={className:"meta",variants:[{begin:/\{\$/,end:/\}/},{begin:/\(\*\$/,end:/\*\)/}]},i={className:"string",begin:/'/,end:/'/,contains:[{begin:/''/}]},o={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}]},s={className:"string",variants:[{match:/#\d[\d_]*/},{match:/#\$[\dA-Fa-f][\dA-Fa-f_]*/},{match:/#&[0-7][0-7_]*/},{match:/#%[01][01_]*/}]},l={begin:t.IDENT_RE+"\\s*=\\s*class\\s*\\(",returnBegin:!0,contains:[t.TITLE_MODE]},c={className:"function",beginKeywords:"function constructor destructor procedure",end:/[:;]/,keywords:"function constructor|10 destructor|10 procedure|10",contains:[t.TITLE_MODE,{className:"params",begin:/\(/,end:/\)/,keywords:n,contains:[i,s,r].concat(a)},r].concat(a)};return{name:"Delphi",aliases:["dpr","dfm","pas","pascal"],case_insensitive:!0,keywords:n,illegal:/"|\$[G-Zg-z]|\/\*|<\/|\|/,contains:[i,s,o,l,c,r].concat(a)}}return vs=e,vs}var Rs,Rp;function GC(){if(Rp)return Rs;Rp=1;function e(t){const n=t.regex;return{name:"Diff",aliases:["patch"],contains:[{className:"meta",relevance:10,match:n.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,/^\*\*\* +\d+,\d+ +\*\*\*\*$/,/^--- +\d+,\d+ +----$/)},{className:"comment",variants:[{begin:n.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 Rs=e,Rs}var Cs,Cp;function YC(){if(Cp)return Cs;Cp=1;function e(t){const n={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:[t.QUOTE_STRING_MODE,t.APOS_STRING_MODE]};return{name:"Django",aliases:["jinja"],case_insensitive:!0,subLanguage:"xml",contains:[t.COMMENT(/\{%\s*comment\s*%\}/,/\{%\s*endcomment\s*%\}/),t.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:[n],relevance:0}}]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[n]}]}}return Cs=e,Cs}var ys,yp;function $C(){if(yp)return ys;yp=1;function e(t){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:[t.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"},t.inherit(t.NUMBER_MODE,{begin:/\b\d+[dhwm]?/})]}}return ys=e,ys}var Ns,Np;function qC(){if(Np)return Ns;Np=1;function e(t){return{name:"Dockerfile",aliases:["docker"],case_insensitive:!0,keywords:["from","maintainer","expose","env","arg","user","onbuild","stopsignal"],contains:[t.HASH_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.NUMBER_MODE,{beginKeywords:"run cmd entrypoint volume add copy workdir label healthcheck shell",starts:{end:/[^\\]$/,subLanguage:"bash"}}],illegal:"",illegal:"\\n"}]},n,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},i={className:"variable",begin:/&[a-z\d_]*\b/},o={className:"keyword",begin:"/[a-z][a-z\\d-]*/"},s={className:"symbol",begin:"^\\s*[a-zA-Z_][a-zA-Z\\d_]*:"},l={className:"params",relevance:0,begin:"<",end:">",contains:[a,i]},c={className:"title.class",begin:/[a-zA-Z_][a-zA-Z\d_@-]*(?=\s\{)/,relevance:.2},u={className:"title.class",begin:/^\/(?=\s*\{)/,relevance:10},d={match:/[a-z][a-z-,]+(?=;)/,relevance:0,scope:"attr"},_={relevance:0,match:[/[a-z][a-z-,]+/,/\s*/,/=/],scope:{1:"attr",3:"operator"}},m={scope:"punctuation",relevance:0,match:/\};|[;{}]/};return{name:"Device Tree",contains:[u,i,o,s,c,_,d,l,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,a,n,r,m,{begin:t.IDENT_RE+"::",keywords:""}]}}return Is=e,Is}var Ds,Dp;function WC(){if(Dp)return Ds;Dp=1;function e(t){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:[t.QUOTE_STRING_MODE]}}]},{className:"template-variable",begin:/\{/,end:/\}/,illegal:/;/,keywords:"if eq ne lt lte gt gte select default math sep"}]}}return Ds=e,Ds}var xs,xp;function KC(){if(xp)return xs;xp=1;function e(t){const n=t.COMMENT(/\(\*/,/\*\)/),a={className:"attribute",begin:/^[ ]*[a-zA-Z]+([\s_-]+[a-zA-Z]+)*/},i={begin:/=/,end:/[.;]/,contains:[n,{className:"meta",begin:/\?.*\?/},{className:"string",variants:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{begin:"`",end:"`"}]}]};return{name:"Extended Backus-Naur Form",illegal:/\S/,contains:[n,a,i]}}return xs=e,xs}var Ms,Mp;function QC(){if(Mp)return Ms;Mp=1;function e(t){const n=t.regex,a="[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?",r="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?",s={$pattern:a,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:s},c={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},d={match:/\\[\s\S]/,scope:"char.escape",relevance:0},_=`[/|([{<"']`,m=[{begin:/"/,end:/"/},{begin:/'/,end:/'/},{begin:/\//,end:/\//},{begin:/\|/,end:/\|/},{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/},{begin:/\{/,end:/\}/},{begin://}],p=T=>({scope:"char.escape",begin:n.concat(/\\/,T),relevance:0}),g={className:"string",begin:"~[a-z](?="+_+")",contains:m.map(T=>t.inherit(T,{contains:[p(T.end),d,l]}))},b={className:"string",begin:"~[A-Z](?="+_+")",contains:m.map(T=>t.inherit(T,{contains:[p(T.end)]}))},A={className:"regex",variants:[{begin:"~r(?="+_+")",contains:m.map(T=>t.inherit(T,{end:n.concat(T.end,/[uismxfU]{0,7}/),contains:[p(T.end),d,l]}))},{begin:"~R(?="+_+")",contains:m.map(T=>t.inherit(T,{end:n.concat(T.end,/[uismxfU]{0,7}/),contains:[p(T.end)]}))}]},O={className:"string",contains:[t.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:/"/}]},M={className:"function",beginKeywords:"def defp defmacro defmacrop",end:/\B\b/,contains:[t.inherit(t.TITLE_MODE,{begin:a,endsParent:!0})]},w=t.inherit(M,{className:"class",beginKeywords:"defimpl defmodule defprotocol defrecord",end:/\bdo\b|$|;/}),v=[O,A,b,g,t.HASH_COMMENT_MODE,w,M,{begin:"::"},{className:"symbol",begin:":(?![\\s:])",contains:[O,{begin:r}],relevance:0},{className:"symbol",begin:a+":(?!:)",relevance:0},{className:"title.class",begin:/(\b[A-Z][a-zA-Z0-9_]+)/,relevance:0},c,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))"}];return l.contains=v,{name:"Elixir",aliases:["ex","exs"],keywords:s,contains:v}}return Ms=e,Ms}var ws,wp;function XC(){if(wp)return ws;wp=1;function e(t){const n={variants:[t.COMMENT("--","$"),t.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},a={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},r={begin:"\\(",end:"\\)",illegal:'"',contains:[{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},n]},i={begin:/\{/,end:/\}/,contains:r.contains},o={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:[r,n],illegal:"\\W\\.|;"},{begin:"import",end:"$",keywords:"import as exposing",contains:[r,n],illegal:"\\W\\.|;"},{begin:"type",end:"$",keywords:"type alias",contains:[a,r,i,n]},{beginKeywords:"infix infixl infixr",end:"$",contains:[t.C_NUMBER_MODE,n]},{begin:"port",end:"$",keywords:"port",contains:[n]},o,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,a,t.inherit(t.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),n,{begin:"->|<-"}],illegal:/;/}}return ws=e,ws}var Ls,Lp;function ZC(){if(Lp)return Ls;Lp=1;function e(t){const n=t.regex,a="([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",r=n.either(/\b([A-Z]+[a-z0-9]+)+/,/\b([A-Z]+[a-z0-9]+)+[A-Z]+/),i=n.concat(r,/(::\w+)*/),s={"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]+"},c={begin:"#<",end:">"},u=[t.COMMENT("#","$",{contains:[l]}),t.COMMENT("^=begin","^=end",{contains:[l],relevance:10}),t.COMMENT("^__END__",t.MATCH_NOTHING_RE)],d={className:"subst",begin:/#\{/,end:/\}/,keywords:s},_={className:"string",contains:[t.BACKSLASH_ESCAPE,d],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:n.concat(/<<[-~]?'?/,n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),contains:[t.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,contains:[t.BACKSLASH_ESCAPE,d]})]}]},m="[1-9](_?[0-9])*|0",p="[0-9](_?[0-9])*",g={className:"number",relevance:0,variants:[{begin:`\\b(${m})(\\.(${p}))?([eE][+-]?(${p})|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"}]},b={variants:[{match:/\(\)/},{className:"params",begin:/\(/,end:/(?=\))/,excludeBegin:!0,endsParent:!0,keywords:s}]},I=[_,{variants:[{match:[/class\s+/,i,/\s+<\s+/,i]},{match:[/\b(class|module)\s+/,i]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:s},{match:[/(include|extend)\s+/,i],scope:{2:"title.class"},keywords:s},{relevance:0,match:[i,/\.new[. (]/],scope:{1:"title.class"}},{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},{relevance:0,match:r,scope:"title.class"},{match:[/def/,/\s+/,a],scope:{1:"keyword",3:"title.function"},contains:[b]},{begin:t.IDENT_RE+"::"},{className:"symbol",begin:t.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":(?!\\s)",contains:[_,{begin:a}],relevance:0},g,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},{className:"params",begin:/\|(?!=)/,end:/\|/,excludeBegin:!0,excludeEnd:!0,relevance:0,keywords:s},{begin:"("+t.RE_STARTERS_RE+"|unless)\\s*",keywords:"unless",contains:[{className:"regexp",contains:[t.BACKSLASH_ESCAPE,d],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(c,u),relevance:0}].concat(c,u);d.contains=I,b.contains=I;const x=[{begin:/^\s*=>/,starts:{end:"$",contains:I}},{className:"meta.prompt",begin:"^("+"[>?]>"+"|"+"[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]"+"|"+"(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>"+")(?=[ ])",starts:{end:"$",keywords:s,contains:I}}];return u.unshift(c),{name:"Ruby",aliases:["rb","gemspec","podspec","thor","irb"],keywords:s,illegal:/\/\*/,contains:[t.SHEBANG({binary:"ruby"})].concat(x).concat(u).concat(I)}}return Ls=e,Ls}var Ps,Pp;function JC(){if(Pp)return Ps;Pp=1;function e(t){return{name:"ERB",subLanguage:"xml",contains:[t.COMMENT("<%#","%>"),{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0}]}}return Ps=e,Ps}var ks,kp;function jC(){if(kp)return ks;kp=1;function e(t){const n=t.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},t.COMMENT("%","$"),{className:"number",begin:"\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",relevance:0},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{begin:n.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 ks=e,ks}var Us,Up;function ey(){if(Up)return Us;Up=1;function e(t){const n="[a-z'][a-zA-Z0-9_']*",a="("+n+":"+n+"|"+n+")",r={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"},i=t.COMMENT("%","$"),o={className:"number",begin:"\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",relevance:0},s={begin:"fun\\s+"+n+"/\\d+"},l={begin:a+"\\(",end:"\\)",returnBegin:!0,relevance:0,contains:[{begin:a,relevance:0},{begin:"\\(",end:"\\)",endsWithParent:!0,returnEnd:!0,relevance:0}]},c={begin:/\{/,end:/\}/,relevance:0},u={begin:"\\b_([A-Z][A-Za-z0-9_]*)?",relevance:0},d={begin:"[A-Z][a-zA-Z0-9_]*",relevance:0},_={begin:"#"+t.UNDERSCORE_IDENT_RE,relevance:0,returnBegin:!0,contains:[{begin:"#"+t.UNDERSCORE_IDENT_RE,relevance:0},{begin:/\{/,end:/\}/,relevance:0}]},m={scope:"string",match:/\$(\\([^0-9]|[0-9]{1,3}|)|.)/},p={scope:"string",match:/"""("*)(?!")[\s\S]*?"""\1/},g={scope:"string",contains:[t.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:/#/}]},b={beginKeywords:"fun receive if try case maybe",end:"end",keywords:r};b.contains=[i,s,t.inherit(t.APOS_STRING_MODE,{className:""}),b,l,g,p,t.QUOTE_STRING_MODE,o,c,u,d,_,m];const A=[i,s,b,l,g,p,t.QUOTE_STRING_MODE,o,c,u,d,_,m];l.contains[1].contains=A,c.contains=A,_.contains[1].contains=A;const O=["-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"],M={className:"params",begin:"\\(",end:"\\)",contains:A};return{name:"Erlang",aliases:["erl"],keywords:r,illegal:"(",returnBegin:!0,illegal:"\\(|#|//|/\\*|\\\\|:|;",contains:[M,t.inherit(t.TITLE_MODE,{begin:n})],starts:{end:";|\\.",keywords:r,contains:A}},i,{begin:"^-",end:"\\.",relevance:0,excludeEnd:!0,returnBegin:!0,keywords:{$pattern:"-"+t.IDENT_RE,keyword:O.map(w=>`${w}|1.5`).join(" ")},contains:[M,g,p,t.QUOTE_STRING_MODE]},o,g,p,t.QUOTE_STRING_MODE,_,u,d,c,m,{begin:/\.$/}]}}return Us=e,Us}var Fs,Fp;function ty(){if(Fp)return Fs;Fp=1;function e(t){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},t.BACKSLASH_ESCAPE,t.QUOTE_STRING_MODE,{className:"number",begin:t.NUMBER_RE+"(%)?",relevance:0},t.COMMENT(/\bN\(/,/\)/,{excludeBegin:!0,excludeEnd:!0,illegal:/\n/})]}}return Fs=e,Fs}var Bs,Bp;function ny(){if(Bp)return Bs;Bp=1;function e(t){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 Bs=e,Bs}var Gs,Gp;function ay(){if(Gp)return Gs;Gp=1;function e(t){const n={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},a={className:"string",variants:[{begin:'"',end:'"'}]},i={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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,n,a,i,t.C_NUMBER_MODE]}}return Gs=e,Gs}var Ys,Yp;function ry(){if(Yp)return Ys;Yp=1;function e(t){const n=t.regex,a={className:"params",begin:"\\(",end:"\\)"},r={variants:[t.COMMENT("!","$",{relevance:0}),t.COMMENT("^C[ ]","$",{relevance:0}),t.COMMENT("^C$","$",{relevance:0})]},i=/(_[a-z_\d]+)?/,o=/([de][+-]?\d+)?/,s={className:"number",variants:[{begin:n.concat(/\b\d+/,/\.(\d*)/,o,i)},{begin:n.concat(/\b\d+/,o,i)},{begin:n.concat(/\.\d+/,o,i)}],relevance:0},l={className:"function",beginKeywords:"subroutine function program",illegal:"[${=\\n]",contains:[t.UNDERSCORE_TITLE_MODE,a]},c={className:"string",relevance:0,variants:[t.APOS_STRING_MODE,t.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:[c,l,{begin:/^C\s*=(?!=)/,relevance:0},r,s]}}return Ys=e,Ys}var $s,$p;function iy(){if($p)return $s;$p=1;function e(s){return new RegExp(s.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}function t(s){return s?typeof s=="string"?s:s.source:null}function n(s){return a("(?=",s,")")}function a(...s){return s.map(c=>t(c)).join("")}function r(s){const l=s[s.length-1];return typeof l=="object"&&l.constructor===Object?(s.splice(s.length-1,1),l):{}}function i(...s){return"("+(r(s).capture?"":"?:")+s.map(u=>t(u)).join("|")+")"}function o(s){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"],c={scope:"keyword",match:/\b(yield|return|let|do|match|use)!/},u=["if","else","endif","line","nowarn","light","r","i","I","load","time","help","quit"],d=["true","false","null","Some","None","Ok","Error","infinity","infinityf","nan","nanf"],_=["__LINE__","__SOURCE_DIRECTORY__","__SOURCE_FILE__"],m=["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"],g={keyword:l,literal:d,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":_},A={variants:[s.COMMENT(/\(\*(?!\))/,/\*\)/,{contains:["self"]}),s.C_LINE_COMMENT_MODE]},O=/[a-zA-Z_](\w|')*/,M={scope:"variable",begin:/``/,end:/``/},w=/\B('|\^)/,v={scope:"symbol",variants:[{match:a(w,/``.*?``/)},{match:a(w,s.UNDERSCORE_IDENT_RE)}],relevance:0},T=function({includeEqual:qe}){let lt;qe?lt="!%&*+-/<=>@^|~?":lt="!%&*+-/<>@^|~?";const V=Array.from(lt),te=a("[",...V.map(e),"]"),ve=i(te,/\./),Ie=a(ve,n(ve)),Be=i(a(Ie,ve,"*"),a(te,"+"));return{scope:"operator",match:i(Be,/:\?>/,/:\?/,/:>/,/:=/,/::?/,/\$/),relevance:0}},I=T({includeEqual:!0}),h=T({includeEqual:!1}),E=function(qe,lt){return{begin:a(qe,n(a(/\s*/,i(/\w/,/'/,/\^/,/#/,/``/,/\(/,/{\|/)))),beginScope:lt,end:n(i(/\n/,/=/)),relevance:0,keywords:s.inherit(g,{type:m}),contains:[A,v,s.inherit(M,{scope:null}),h]}},D=E(/:/,"operator"),x=E(/\bof\b/,"keyword"),L={begin:[/(^|\s+)/,/type/,/\s+/,O],beginScope:{2:"keyword",4:"title.class"},end:n(/\(|=|$/),keywords:g,contains:[A,s.inherit(M,{scope:null}),v,{scope:"operator",match:/<|>/},D]},ae={scope:"computation-expression",match:/\b[_a-z]\w*(?=\s*\{)/},Ee={begin:[/^\s*/,a(/#/,i(...u)),/\b/],beginScope:{2:"meta"},end:n(/\s|$/)},xe={variants:[s.BINARY_NUMBER_MODE,s.C_NUMBER_MODE]},Se={scope:"string",begin:/"/,end:/"/,contains:[s.BACKSLASH_ESCAPE]},pe={scope:"string",begin:/@"/,end:/"/,contains:[{match:/""/},s.BACKSLASH_ESCAPE]},Le={scope:"string",begin:/"""/,end:/"""/,relevance:2},be={scope:"subst",begin:/\{/,end:/\}/,keywords:g},Xe={scope:"string",begin:/\$"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},s.BACKSLASH_ESCAPE,be]},et={scope:"string",begin:/(\$@|@\$)"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},{match:/""/},s.BACKSLASH_ESCAPE,be]},it={scope:"string",begin:/\$"""/,end:/"""/,contains:[{match:/\{\{/},{match:/\}\}/},be],relevance:2},St={scope:"string",match:a(/'/,i(/[^\\']/,/\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/),/'/)};return be.contains=[et,Xe,pe,Se,St,c,A,M,D,ae,Ee,xe,v,I],{name:"F#",aliases:["fs","f#"],keywords:g,illegal:/\/\*/,classNameAliases:{"computation-expression":"keyword"},contains:[c,{variants:[it,et,Xe,Le,pe,Se,St]},A,M,L,{scope:"meta",begin:/\[\]/,relevance:2,contains:[M,Le,pe,Se,St,xe]},x,D,ae,Ee,xe,v,I]}}return $s=o,$s}var qs,qp;function oy(){if(qp)return qs;qp=1;function e(t){const n=t.regex,a={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"},r={className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0},i={className:"symbol",variants:[{begin:/=[lgenxc]=/},{begin:/\$/}]},o={className:"comment",variants:[{begin:"'",end:"'"},{begin:'"',end:'"'}],illegal:"\\n",contains:[t.BACKSLASH_ESCAPE]},s={begin:"/",end:"/",keywords:a,contains:[o,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,t.C_NUMBER_MODE]},l=/[a-z0-9&#*=?@\\><:,()$[\]_.{}!+%^-]+/,c={begin:/[a-z][a-z0-9_]*(\([a-z0-9_, ]*\))?[ \t]+/,excludeBegin:!0,end:"$",endsWithParent:!0,contains:[o,s,{className:"comment",begin:n.concat(l,n.anyNumberOfTimes(n.concat(/[ ]+/,l))),relevance:0}]};return{name:"GAMS",aliases:["gms"],case_insensitive:!0,keywords:a,contains:[t.COMMENT(/^\$ontext/,/^\$offtext/),{className:"meta",begin:"^\\$[a-z0-9]+",end:"$",returnBegin:!0,contains:[{className:"keyword",begin:"^\\$[a-z0-9]+"}]},t.COMMENT("^\\*","$"),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,{beginKeywords:"set sets parameter parameters variable variables scalar scalars equation equations",end:";",contains:[t.COMMENT("^\\*","$"),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,s,c]},{beginKeywords:"table",end:";",returnBegin:!0,contains:[{beginKeywords:"table",end:"$",contains:[c]},t.COMMENT("^\\*","$"),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,t.C_NUMBER_MODE]},{className:"function",begin:/^[a-z][a-z0-9_,\-+' ()$]+\.{2}/,returnBegin:!0,contains:[{className:"title",begin:/^[a-z0-9_]+/},r,i]},t.C_NUMBER_MODE,i]}}return qs=e,qs}var Hs,Hp;function sy(){if(Hp)return Hs;Hp=1;function e(t){const n={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"},a=t.COMMENT("@","@"),r={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"}]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,a]},i={begin:/\bstruct\s+/,end:/\s/,keywords:"struct",contains:[{className:"type",begin:t.UNDERSCORE_IDENT_RE,relevance:0}]},o=[{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,endsWithParent:!0,relevance:0,contains:[{className:"literal",begin:/\.\.\./},t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE,a,i]}],s={className:"title",begin:t.UNDERSCORE_IDENT_RE,relevance:0},l=function(m,p,g){const b=t.inherit({className:"function",beginKeywords:m,end:p,excludeEnd:!0,contains:[].concat(o)},{});return b.contains.push(s),b.contains.push(t.C_NUMBER_MODE),b.contains.push(t.C_BLOCK_COMMENT_MODE),b.contains.push(a),b},c={className:"built_in",begin:"\\b("+n.built_in.split(" ").join("|")+")\\b"},u={className:"string",begin:'"',end:'"',contains:[t.BACKSLASH_ESCAPE],relevance:0},d={begin:t.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,keywords:n,relevance:0,contains:[{beginKeywords:n.keyword},c,{className:"built_in",begin:t.UNDERSCORE_IDENT_RE,relevance:0}]},_={begin:/\(/,end:/\)/,relevance:0,keywords:{built_in:n.built_in,literal:n.literal},contains:[t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE,a,c,d,u,"self"]};return d.contains.push(_),{name:"GAUSS",aliases:["gss"],case_insensitive:!0,keywords:n,illegal:/(\{[%#]|[%#]\}| <- )/,contains:[t.C_NUMBER_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,a,u,r,{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:[t.C_BLOCK_COMMENT_MODE,a,_]},{variants:[{begin:t.UNDERSCORE_IDENT_RE+"\\."+t.UNDERSCORE_IDENT_RE},{begin:t.UNDERSCORE_IDENT_RE+"\\s*="}],relevance:0},d,i]}}return Hs=e,Hs}var Vs,Vp;function ly(){if(Vp)return Vs;Vp=1;function e(t){const n=t.regex,a={$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"]},r=/\b/;function i(p,g){if(p.index===0)return;const b=p.input[p.index-1];b>="0"&&b<="9"||b!=="_"&&g.ignoreMatch()}const o=/[+-]?((\.\d+)|(\d+)(\.\d*)?)/,s=/[GM]\s*\d+(\.\d+)?/,l=/T\s*\d+/,c=/O\s*\d+/,u=/O<.+>/,d=/[ABCUVWXYZ]\s*/,_=/[FHIJKPQRS]\s*/,m=[t.COMMENT(/\(/,/\)/),t.COMMENT(/;/,/$/),t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,{scope:"title.function",variants:[{match:n.concat(r,s)},{begin:s,"on:begin":i},{match:n.concat(r,l)},{begin:l,"on:begin":i}]},{scope:"symbol",variants:[{match:n.concat(r,c)},{begin:c,"on:begin":i},{match:n.concat(r,u)},{begin:u,"on:begin":i},{match:/\*\s*\d+\s*$/}]},{scope:"operator",match:/^N\s*\d+/},{scope:"variable",match:/-?#\s*\d+/},{scope:"property",variants:[{match:n.concat(r,d,o)},{begin:n.concat(d,o),"on:begin":i}]},{scope:"params",variants:[{match:n.concat(r,_,o)},{begin:n.concat(_,o),"on:begin":i}]}];return{name:"G-code (ISO 6983)",aliases:["nc"],case_insensitive:!0,disableAutodetect:!0,keywords:a,contains:m}}return Vs=e,Vs}var zs,zp;function cy(){if(zp)return zs;zp=1;function e(t){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:">"},t.HASH_COMMENT_MODE,{className:"string",begin:'"""',end:'"""'},t.QUOTE_STRING_MODE]}}return zs=e,zs}var Ws,Wp;function uy(){if(Wp)return Ws;Wp=1;function e(t){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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.C_NUMBER_MODE,{className:"meta",begin:"#",end:"$"}]}}return Ws=e,Ws}var Ks,Kp;function dy(){if(Kp)return Ks;Kp=1;function e(t){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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE]}}return Ks=e,Ks}var Qs,Qp;function _y(){if(Qp)return Qs;Qp=1;function e(t){const o={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:o,illegal:"",end:",\\s+",returnBegin:!0,endsWithParent:!0,contains:[{className:"attr",begin:":\\w+"},t.APOS_STRING_MODE,t.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},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{begin:"\\w+",relevance:0}]}]}]},{begin:"^\\s*[=~]\\s*"},{begin:/#\{/,end:/\}/,subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0}]}}return el=e,el}var tl,tm;function Sy(){if(tm)return tl;tm=1;function e(t){const n=t.regex,a={$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"]},r={$pattern:/[\w.\/]+/,literal:["true","false","undefined","null"]},i=/""|"[^"]+"/,o=/''|'[^']+'/,s=/\[\]|\[[^\]]+\]/,l=/[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/,c=/(\.|\/)/,u=n.either(i,o,s,l),d=n.concat(n.optional(/\.|\.\/|\//),u,n.anyNumberOfTimes(n.concat(c,u))),_=n.concat("(",s,"|",l,")(?==)"),m={begin:d},p=t.inherit(m,{keywords:r}),g={begin:/\(/,end:/\)/},b={className:"attr",begin:_,relevance:0,starts:{begin:/=/,end:/=/,starts:{contains:[t.NUMBER_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,p,g]}}},A={begin:/as\s+\|/,keywords:{keyword:"as"},end:/\|/,contains:[{begin:/\w+/}]},O={contains:[t.NUMBER_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,A,b,p,g],returnEnd:!0},M=t.inherit(m,{className:"name",keywords:a,starts:t.inherit(O,{end:/\)/})});g.contains=[M];const w=t.inherit(m,{keywords:a,className:"name",starts:t.inherit(O,{end:/\}\}/})}),v=t.inherit(m,{keywords:a,className:"name"}),T=t.inherit(m,{className:"name",keywords:a,starts:t.inherit(O,{end:/\}\}/})});return{name:"Handlebars",aliases:["hbs","html.hbs","html.handlebars","htmlbars"],case_insensitive:!0,subLanguage:"xml",contains:[{begin:/\\\{\{/,skip:!0},{begin:/\\\\(?=\{\{)/,skip:!0},t.COMMENT(/\{\{!--/,/--\}\}/),t.COMMENT(/\{\{!/,/\}\}/),{className:"template-tag",begin:/\{\{\{\{(?!\/)/,end:/\}\}\}\}/,contains:[w],starts:{end:/\{\{\{\{\//,returnEnd:!0,subLanguage:"xml"}},{className:"template-tag",begin:/\{\{\{\{\//,end:/\}\}\}\}/,contains:[v]},{className:"template-tag",begin:/\{\{#/,end:/\}\}/,contains:[w]},{className:"template-tag",begin:/\{\{(?=else\}\})/,end:/\}\}/,keywords:"else"},{className:"template-tag",begin:/\{\{(?=else if)/,end:/\}\}/,keywords:"else if"},{className:"template-tag",begin:/\{\{\//,end:/\}\}/,contains:[v]},{className:"template-variable",begin:/\{\{\{/,end:/\}\}\}/,contains:[T]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[T]}]}}return tl=e,tl}var nl,nm;function by(){if(nm)return nl;nm=1;function e(t){const n="([0-9]_*)+",a="([0-9a-fA-F]_*)+",r="([01]_*)+",i="([0-7]_*)+",c="([!#$%&*+.\\/<=>?@\\\\^~-]|(?!([(),;\\[\\]`|{}]|[_:\"']))(\\p{S}|\\p{P}))",u={variants:[t.COMMENT("--+","$"),t.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},d={className:"meta",begin:/\{-#/,end:/#-\}/},_={className:"meta",begin:"^#",end:"$"},m={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},p={begin:"\\(",end:"\\)",illegal:'"',contains:[d,_,{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},t.inherit(t.TITLE_MODE,{begin:"[_a-z][\\w']*"}),u]},g={begin:/\{/,end:/\}/,contains:p.contains},b={className:"number",relevance:0,variants:[{match:`\\b(${n})(\\.(${n}))?([eE][+-]?(${n}))?\\b`},{match:`\\b0[xX]_*(${a})(\\.(${a}))?([pP][+-]?(${n}))?\\b`},{match:`\\b0[oO](${i})\\b`},{match:`\\b0[bB](${r})\\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:[p,u],illegal:"\\W\\.|;"},{begin:"\\bimport\\b",end:"$",keywords:"import qualified as hiding",contains:[p,u],illegal:"\\W\\.|;"},{className:"class",begin:"^(\\s*)?(class|instance)\\b",end:"where",keywords:"class family instance where",contains:[m,p,u]},{className:"class",begin:"\\b(data|(new)?type)\\b",end:"$",keywords:"data family type newtype deriving",contains:[d,m,p,g,u]},{beginKeywords:"default",end:"$",contains:[m,p,u]},{beginKeywords:"infix infixl infixr",end:"$",contains:[t.C_NUMBER_MODE,u]},{begin:"\\bforeign\\b",end:"$",keywords:"foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",contains:[m,t.QUOTE_STRING_MODE,u]},{className:"meta",begin:"#!\\/usr\\/bin\\/env runhaskell",end:"$"},d,_,{scope:"string",begin:/'(?=\\?.')/,end:/'/,contains:[{scope:"char.escape",match:/\\./}]},t.QUOTE_STRING_MODE,b,m,t.inherit(t.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),{begin:`(?!-)${c}--+|--+(?!-)${c}`},u,{begin:"->|<-"}]}}return nl=e,nl}var al,am;function Ty(){if(am)return al;am=1;function e(t){const n="[a-zA-Z_$][a-zA-Z0-9_$]*",a=/(-?)(\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:[t.BACKSLASH_ESCAPE,{className:"subst",begin:/\$\{/,end:/\}/},{className:"subst",begin:/\$/,end:/\W\}/}]},t.QUOTE_STRING_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"number",begin:a,relevance:0},{className:"variable",begin:"\\$"+n},{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:[t.TITLE_MODE]},{className:"title.class",begin:"\\babstract\\b(?=\\s*"+t.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},t.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:t.IDENT_RE,relevance:0}]},t.TITLE_MODE]},{className:"title.function",beginKeywords:"function",end:/\(/,excludeEnd:!0,illegal:/\S/,contains:[t.TITLE_MODE]}],illegal:/<\//}}return al=e,al}var rl,rm;function hy(){if(rm)return rl;rm=1;function e(t){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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,{className:"string",begin:/\{"/,end:/"\}/,contains:[t.BACKSLASH_ESCAPE]},t.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:[t.inherit(t.QUOTE_STRING_MODE,{className:"string"}),t.NUMBER_MODE,t.C_NUMBER_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},{className:"symbol",begin:"^\\*(\\w+|@)"},t.NUMBER_MODE,t.C_NUMBER_MODE]}}return rl=e,rl}var il,im;function vy(){if(im)return il;im=1;function e(t){const n=t.regex,a="HTTP/([32]|1\\.[01])",r=/[A-Za-z][A-Za-z0-9-]*/,i={className:"attribute",begin:n.concat("^",r,"(?=\\:\\s)"),starts:{contains:[{className:"punctuation",begin:/: /,relevance:0,starts:{end:"$",relevance:0}}]}},o=[i,{begin:"\\n\\n",starts:{subLanguage:[],endsWithParent:!0}}];return{name:"HTTP",aliases:["https"],illegal:/\S/,contains:[{begin:"^(?="+a+" \\d{3})",end:/$/,contains:[{className:"meta",begin:a},{className:"number",begin:"\\b\\d{3}\\b"}],starts:{end:/\b\B/,illegal:/\S/,contains:o}},{begin:"(?=^[A-Z]+ (.*?) "+a+"$)",end:/$/,contains:[{className:"string",begin:" ",end:" ",excludeBegin:!0,excludeEnd:!0},{className:"meta",begin:a},{className:"keyword",begin:"[A-Z]+"}],starts:{end:/\b\B/,illegal:/\S/,contains:o}},t.inherit(i,{relevance:0})]}}return il=e,il}var ol,om;function Ry(){if(om)return ol;om=1;function e(t){const n="a-zA-Z_\\-!.?+*=<>&#'",a="["+n+"]["+n+"0-9/;:]*",r={$pattern:a,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 | |= ~"},i="[-+]?\\d+(\\.\\d+)?",o={begin:a,relevance:0},s={className:"number",begin:i,relevance:0},l=t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),c=t.COMMENT(";","$",{relevance:0}),u={className:"literal",begin:/\b([Tt]rue|[Ff]alse|nil|None)\b/},d={begin:"[\\[\\{]",end:"[\\]\\}]",relevance:0},_={className:"comment",begin:"\\^"+a},m=t.COMMENT("\\^\\{","\\}"),p={className:"symbol",begin:"[:]{1,2}"+a},g={begin:"\\(",end:"\\)"},b={endsWithParent:!0,relevance:0},A={className:"name",relevance:0,keywords:r,begin:a,starts:b},O=[g,l,_,m,c,p,d,s,u,o];return g.contains=[t.COMMENT("comment",""),A,b],b.contains=O,d.contains=O,{name:"Hy",aliases:["hylang"],illegal:/\S/,contains:[t.SHEBANG(),g,l,_,m,c,p,d,s,u]}}return ol=e,ol}var sl,sm;function Cy(){if(sm)return sl;sm=1;function e(t){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 sl=e,sl}var ll,lm;function yy(){if(lm)return ll;lm=1;function e(t){const n=t.regex,a={className:"number",relevance:0,variants:[{begin:/([+-]+)?[\d]+_[\d_]+/},{begin:t.NUMBER_RE}]},r=t.COMMENT();r.variants=[{begin:/;/,end:/$/},{begin:/#/,end:/$/}];const i={className:"variable",variants:[{begin:/\$[\w\d"][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},o={className:"literal",begin:/\bon|off|true|false|yes|no\b/},s={className:"string",contains:[t.BACKSLASH_ESCAPE],variants:[{begin:"'''",end:"'''",relevance:10},{begin:'"""',end:'"""',relevance:10},{begin:'"',end:'"'},{begin:"'",end:"'"}]},l={begin:/\[/,end:/\]/,contains:[r,o,i,s,a,"self"],relevance:0},c=/[A-Za-z0-9_-]+/,u=/"(\\"|[^"])*"/,d=/'[^']*'/,_=n.either(c,u,d),m=n.concat(_,"(\\s*\\.\\s*",_,")*",n.lookahead(/\s*=\s*[^#\s]/));return{name:"TOML, also INI",aliases:["toml"],case_insensitive:!0,illegal:/\S/,contains:[r,{className:"section",begin:/\[+/,end:/\]+/},{begin:m,className:"attr",starts:{end:/$/,contains:[r,l,o,i,s,a]}}]}}return ll=e,ll}var cl,cm;function Ny(){if(cm)return cl;cm=1;function e(t){const n=t.regex,a={className:"params",begin:"\\(",end:"\\)"},r=/(_[a-z_\d]+)?/,i=/([de][+-]?\d+)?/,o={className:"number",variants:[{begin:n.concat(/\b\d+/,/\.(\d*)/,i,r)},{begin:n.concat(/\b\d+/,i,r)},{begin:n.concat(/\.\d+/,i,r)}],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:[t.inherit(t.APOS_STRING_MODE,{className:"string",relevance:0}),t.inherit(t.QUOTE_STRING_MODE,{className:"string",relevance:0}),{className:"function",beginKeywords:"subroutine function program",illegal:"[${=\\n]",contains:[t.UNDERSCORE_TITLE_MODE,a]},t.COMMENT("!","$",{relevance:0}),t.COMMENT("begin_doc","end_doc",{relevance:10}),o]}}return cl=e,cl}var ul,um;function Oy(){if(um)return ul;um=1;function e(t){const n="[A-Za-zА-Яа-яёЁ_!][A-Za-zА-Яа-яёЁ_0-9]*",a="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]*",r="and и else иначе endexcept endfinally endforeach конецвсе endif конецесли endwhile конецпока except exitfor finally foreach все if если in в not не or или try while пока ",qe="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 ",Pa="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 ",ln="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Дат ФмтДат ФмтСтр ФмтЧсл Формат ЦМассивЭлемент ЦНаборДанныхРеквизит ЦПодстр ",or="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 ВызовСпособ ИмяОтчета РеквЗнач ",ha="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 ",nt=qe+Pa,ka=or,qt="null true false nil ",ft={className:"number",begin:t.NUMBER_RE,relevance:0},Yn={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"}]},cn={className:"doctag",begin:"\\b(?:TODO|DONE|BEGIN|END|STUB|CHG|FIXME|NOTE|BUG|XXX)\\b",relevance:0},na={className:"comment",begin:"//",end:"$",relevance:0,contains:[t.PHRASAL_WORDS_MODE,cn]},me={className:"comment",begin:"/\\*",end:"\\*/",relevance:0,contains:[t.PHRASAL_WORDS_MODE,cn]},S={variants:[na,me]},F={$pattern:n,keyword:r,built_in:nt,class:ka,literal:qt},Q={begin:"\\.\\s*"+t.UNDERSCORE_IDENT_RE,keywords:F,relevance:0},se={className:"type",begin:":[ \\t]*("+ha.trim().replace(/\s/g,"|")+")",end:"[ \\t]*=",excludeEnd:!0},Ae={className:"variable",keywords:F,begin:n,relevance:0,contains:[se,Q]},Ye=a+"\\(";return{name:"ISBL",case_insensitive:!0,keywords:F,illegal:"\\$|\\?|%|,|;$|~|#|@|r(o,s,l-1))}function i(o){const s=o.regex,l="[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*",c=l+r("(?:<"+l+"~~~(?:\\s*,\\s*"+l+"~~~)*>)?",/~~~/g,2),p={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"]},g={className:"meta",begin:"@"+l,contains:[{begin:/\(/,end:/\)/,contains:["self"]}]},b={className:"params",begin:/\(/,end:/\)/,keywords:p,relevance:0,contains:[o.C_BLOCK_COMMENT_MODE],endsParent:!0};return{name:"Java",aliases:["jsp"],keywords:p,illegal:/<\/|#/,contains:[o.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]}),{begin:/import java\.[a-z]+\./,keywords:"import",relevance:2},o.C_LINE_COMMENT_MODE,o.C_BLOCK_COMMENT_MODE,{begin:/"""/,end:/"""/,className:"string",contains:[o.BACKSLASH_ESCAPE]},o.APOS_STRING_MODE,o.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:[s.concat(/(?!else)/,l),/\s+/,l,/\s+/,/=(?!=)/],className:{1:"type",3:"variable",5:"operator"}},{begin:[/record/,/\s+/,l],className:{1:"keyword",3:"title.class"},contains:[b,o.C_LINE_COMMENT_MODE,o.C_BLOCK_COMMENT_MODE]},{beginKeywords:"new throw return else",relevance:0},{begin:["(?:"+c+"\\s+)",o.UNDERSCORE_IDENT_RE,/\s*(?=\()/],className:{2:"title.function"},keywords:p,contains:[{className:"params",begin:/\(/,end:/\)/,keywords:p,relevance:0,contains:[g,o.APOS_STRING_MODE,o.QUOTE_STRING_MODE,a,o.C_BLOCK_COMMENT_MODE]},o.C_LINE_COMMENT_MODE,o.C_BLOCK_COMMENT_MODE]},a,g]}}return dl=i,dl}var _l,_m;function Iy(){if(_m)return _l;_m=1;const e="[A-Za-z$_][0-9A-Za-z$_]*",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"],n=["true","false","null","undefined","NaN","Infinity"],a=["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"],r=["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"],o=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],s=[].concat(i,a,r);function l(c){const u=c.regex,d=(V,{after:te})=>{const ve="",end:""},p=/<[A-Za-z0-9\\._:-]+\s*\/>/,g={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(V,te)=>{const ve=V[0].length+V.index,Ie=V.input[ve];if(Ie==="<"||Ie===","){te.ignoreMatch();return}Ie===">"&&(d(V,{after:ve})||te.ignoreMatch());let Be;const R=V.input.substring(ve);if(Be=R.match(/^\s*=/)){te.ignoreMatch();return}if((Be=R.match(/^\s+extends\s+/))&&Be.index===0){te.ignoreMatch();return}}},b={$pattern:e,keyword:t,literal:n,built_in:s,"variable.language":o},A="[0-9](_?[0-9])*",O=`\\.(${A})`,M="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",w={className:"number",variants:[{begin:`(\\b(${M})((${O})|\\.)?|(${O}))[eE][+-]?(${A})\\b`},{begin:`\\b(${M})\\b((${O})\\b|\\.)?|(${O})\\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},v={className:"subst",begin:"\\$\\{",end:"\\}",keywords:b,contains:[]},T={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[c.BACKSLASH_ESCAPE,v],subLanguage:"xml"}},I={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[c.BACKSLASH_ESCAPE,v],subLanguage:"css"}},h={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[c.BACKSLASH_ESCAPE,v],subLanguage:"graphql"}},E={className:"string",begin:"`",end:"`",contains:[c.BACKSLASH_ESCAPE,v]},x={className:"comment",variants:[c.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:_+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),c.C_BLOCK_COMMENT_MODE,c.C_LINE_COMMENT_MODE]},L=[c.APOS_STRING_MODE,c.QUOTE_STRING_MODE,T,I,h,E,{match:/\$\d+/},w];v.contains=L.concat({begin:/\{/,end:/\}/,keywords:b,contains:["self"].concat(L)});const ae=[].concat(x,v.contains),Ee=ae.concat([{begin:/(\s*)\(/,end:/\)/,keywords:b,contains:["self"].concat(ae)}]),xe={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:b,contains:Ee},Se={variants:[{match:[/class/,/\s+/,_,/\s+/,/extends/,/\s+/,u.concat(_,"(",u.concat(/\./,_),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,_],scope:{1:"keyword",3:"title.class"}}]},pe={relevance:0,match:u.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:{_:[...a,...r]}},Le={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},be={variants:[{match:[/function/,/\s+/,_,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[xe],illegal:/%/},Xe={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function et(V){return u.concat("(?!",V.join("|"),")")}const it={match:u.concat(/\b/,et([...i,"super","import"].map(V=>`${V}\\s*\\(`)),_,u.lookahead(/\s*\(/)),className:"title.function",relevance:0},St={begin:u.concat(/\./,u.lookahead(u.concat(_,/(?![0-9A-Za-z$_(])/))),end:_,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},Ot={match:[/get|set/,/\s+/,_,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},xe]},qe="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+c.UNDERSCORE_IDENT_RE+")\\s*=>",lt={match:[/const|var|let/,/\s+/,_,/\s*/,/=\s*/,/(async\s*)?/,u.lookahead(qe)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[xe]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:b,exports:{PARAMS_CONTAINS:Ee,CLASS_REFERENCE:pe},illegal:/#(?![$_A-z])/,contains:[c.SHEBANG({label:"shebang",binary:"node",relevance:5}),Le,c.APOS_STRING_MODE,c.QUOTE_STRING_MODE,T,I,h,E,x,{match:/\$\d+/},w,pe,{scope:"attr",match:_+u.lookahead(":"),relevance:0},lt,{begin:"("+c.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[x,c.REGEXP_MODE,{className:"function",begin:qe,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:c.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:b,contains:Ee}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:m.begin,end:m.end},{match:p},{begin:g.begin,"on:begin":g.isTrulyOpeningTag,end:g.end}],subLanguage:"xml",contains:[{begin:g.begin,end:g.end,skip:!0,contains:["self"]}]}]},be,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+c.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[xe,c.inherit(c.TITLE_MODE,{begin:_,className:"title.function"})]},{match:/\.\.\./,relevance:0},St,{match:"\\$"+_,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[xe]},it,Xe,Se,Ot,{match:/\$[(.]/}]}}return _l=l,_l}var pl,pm;function Dy(){if(pm)return pl;pm=1;function e(t){const a={className:"params",begin:/\(/,end:/\)/,contains:[{begin:/[\w-]+ *=/,returnBegin:!0,relevance:0,contains:[{className:"attr",begin:/[\w-]+/}]}],relevance:0},r={className:"function",begin:/:[\w\-.]+/,relevance:0},i={className:"string",begin:/\B([\/.])[\w\-.\/=]+/},o={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:[t.HASH_COMMENT_MODE,t.QUOTE_STRING_MODE,o,r,i,a]}}return pl=e,pl}var ml,mm;function xy(){if(mm)return ml;mm=1;function e(t){const n={className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/,relevance:1.01},a={match:/[{}[\],:]/,className:"punctuation",relevance:0},r=["true","false","null"],i={scope:"literal",beginKeywords:r.join(" ")};return{name:"JSON",aliases:["jsonc"],keywords:{literal:r},contains:[n,a,t.QUOTE_STRING_MODE,i,t.C_NUMBER_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE],illegal:"\\S"}}return ml=e,ml}var gl,gm;function My(){if(gm)return gl;gm=1;function e(t){const n="[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*",o={$pattern:n,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"]},s={keywords:o,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},c={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},u={className:"subst",begin:/\$\(/,end:/\)/,keywords:o},d={className:"variable",begin:"\\$"+n},_={className:"string",contains:[t.BACKSLASH_ESCAPE,u,d],variants:[{begin:/\w*"""/,end:/"""\w*/,relevance:10},{begin:/\w*"/,end:/"\w*/}]},m={className:"string",contains:[t.BACKSLASH_ESCAPE,u,d],begin:"`",end:"`"},p={className:"meta",begin:"@"+n},g={className:"comment",variants:[{begin:"#=",end:"=#",relevance:10},{begin:"#",end:"$"}]};return s.name="Julia",s.contains=[l,c,_,m,p,g,t.HASH_COMMENT_MODE,{className:"keyword",begin:"\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b"},{begin:/<:/}],u.contains=s.contains,s}return gl=e,gl}var El,Em;function wy(){if(Em)return El;Em=1;function e(t){return{name:"Julia REPL",contains:[{className:"meta.prompt",begin:/^julia>/,relevance:10,starts:{end:/^(?![ ]{6})/,subLanguage:"julia"}}],aliases:["jldoctest"]}}return El=e,El}var fl,fm;function Ly(){if(fm)return fl;fm=1;var e="[0-9](_*[0-9])*",t=`\\.(${e})`,n="[0-9a-fA-F](_*[0-9a-fA-F])*",a={className:"number",variants:[{begin:`(\\b(${e})((${t})|\\.)?|(${t}))[eE][+-]?(${e})[fFdD]?\\b`},{begin:`\\b(${e})((${t})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{begin:`(${t})[fFdD]?\\b`},{begin:`\\b(${e})[fFdD]\\b`},{begin:`\\b0[xX]((${n})\\.?|(${n})?\\.(${n}))[pP][+-]?(${e})[fFdD]?\\b`},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${n})[lL]?\\b`},{begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],relevance:0};function r(i){const o={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"},s={className:"keyword",begin:/\b(break|continue|return|this)\b/,starts:{contains:[{className:"symbol",begin:/@\w+/}]}},l={className:"symbol",begin:i.UNDERSCORE_IDENT_RE+"@"},c={className:"subst",begin:/\$\{/,end:/\}/,contains:[i.C_NUMBER_MODE]},u={className:"variable",begin:"\\$"+i.UNDERSCORE_IDENT_RE},d={className:"string",variants:[{begin:'"""',end:'"""(?=[^"])',contains:[u,c]},{begin:"'",end:"'",illegal:/\n/,contains:[i.BACKSLASH_ESCAPE]},{begin:'"',end:'"',illegal:/\n/,contains:[i.BACKSLASH_ESCAPE,u,c]}]};c.contains.push(d);const _={className:"meta",begin:"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*"+i.UNDERSCORE_IDENT_RE+")?"},m={className:"meta",begin:"@"+i.UNDERSCORE_IDENT_RE,contains:[{begin:/\(/,end:/\)/,contains:[i.inherit(d,{className:"string"}),"self"]}]},p=a,g=i.COMMENT("/\\*","\\*/",{contains:[i.C_BLOCK_COMMENT_MODE]}),b={variants:[{className:"type",begin:i.UNDERSCORE_IDENT_RE},{begin:/\(/,end:/\)/,contains:[]}]},A=b;return A.variants[1].contains=[b],b.variants[1].contains=[A],{name:"Kotlin",aliases:["kt","kts"],keywords:o,contains:[i.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"}]}),i.C_LINE_COMMENT_MODE,g,s,l,_,m,{className:"function",beginKeywords:"fun",end:"[(]|$",returnBegin:!0,excludeEnd:!0,keywords:o,relevance:5,contains:[{begin:i.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,contains:[i.UNDERSCORE_TITLE_MODE]},{className:"type",begin://,keywords:"reified",relevance:0},{className:"params",begin:/\(/,end:/\)/,endsParent:!0,keywords:o,relevance:0,contains:[{begin:/:/,end:/[=,\/]/,endsWithParent:!0,contains:[b,i.C_LINE_COMMENT_MODE,g],relevance:0},i.C_LINE_COMMENT_MODE,g,_,m,d,i.C_NUMBER_MODE]},g]},{begin:[/class|interface|trait/,/\s+/,i.UNDERSCORE_IDENT_RE],beginScope:{3:"title.class"},keywords:"class interface trait",end:/[:\{(]|$/,excludeEnd:!0,illegal:"extends implements",contains:[{beginKeywords:"public protected internal private constructor"},i.UNDERSCORE_TITLE_MODE,{className:"type",begin://,excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:/[,:]\s*/,end:/[<\(,){\s]|$/,excludeBegin:!0,returnEnd:!0},_,m]},d,{className:"meta",begin:"^#!/usr/bin/env",end:"$",illegal:` -`},p]}}return fl=r,fl}var Sl,Sm;function Py(){if(Sm)return Sl;Sm=1;function e(t){const n="[a-zA-Z_][\\w.]*",a="<\\?(lasso(script)?|=)",r="\\]|\\?>",i={$pattern:n+"|&[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"},o=t.COMMENT("",{relevance:0}),s={className:"meta",begin:"\\[noprocess\\]",starts:{end:"\\[/noprocess\\]",returnEnd:!0,contains:[o]}},l={className:"meta",begin:"\\[/noprocess|"+a},c={className:"symbol",begin:"'"+n+"'"},u=[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.inherit(t.C_NUMBER_MODE,{begin:t.C_NUMBER_RE+"|(-?infinity|NaN)\\b"}),t.inherit(t.APOS_STRING_MODE,{illegal:null}),t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),{className:"string",begin:"`",end:"`"},{variants:[{begin:"[#$]"+n},{begin:"#",end:"\\d+",illegal:"\\W"}]},{className:"type",begin:"::\\s*",end:n,illegal:"\\W"},{className:"params",variants:[{begin:"-(?!infinity)"+n,relevance:0},{begin:"(\\.\\.\\.)"}]},{begin:/(->|\.)\s*/,relevance:0,contains:[c]},{className:"class",beginKeywords:"define",returnEnd:!0,end:"\\(|=>",contains:[t.inherit(t.TITLE_MODE,{begin:n+"(=(?!>))?|[-+*/%](?!>)"})]}];return{name:"Lasso",aliases:["ls","lassoscript"],case_insensitive:!0,keywords:i,contains:[{className:"meta",begin:r,relevance:0,starts:{end:"\\[|"+a,returnEnd:!0,relevance:0,contains:[o]}},s,l,{className:"meta",begin:"\\[no_square_brackets",starts:{end:"\\[/no_square_brackets\\]",keywords:i,contains:[{className:"meta",begin:r,relevance:0,starts:{end:"\\[noprocess\\]|"+a,returnEnd:!0,contains:[o]}},s,l].concat(u)}},{className:"meta",begin:"\\[",relevance:0},{className:"meta",begin:"^#!",end:"lasso9$",relevance:10}].concat(u)}}return Sl=e,Sl}var bl,bm;function ky(){if(bm)return bl;bm=1;function e(t){const a=t.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(x=>x+"(?![a-zA-Z@:_])")),r=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(x=>x+"(?![a-zA-Z:_])").join("|")),i=[{begin:/[a-zA-Z@]+/},{begin:/[^a-zA-Z@]?/}],o=[{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]/}],s={className:"keyword",begin:/\\/,relevance:0,contains:[{endsParent:!0,begin:a},{endsParent:!0,begin:r},{endsParent:!0,variants:o},{endsParent:!0,relevance:0,variants:i}]},l={className:"params",relevance:0,begin:/#+\d?/},c={variants:o},u={className:"built_in",relevance:0,begin:/[$&^_]/},d={className:"meta",begin:/% ?!(T[eE]X|tex|BIB|bib)/,end:"$",relevance:10},_=t.COMMENT("%","$",{relevance:0}),m=[s,l,c,u,d,_],p={begin:/\{/,end:/\}/,relevance:0,contains:["self",...m]},g=t.inherit(p,{relevance:0,endsParent:!0,contains:[p,...m]}),b={begin:/\[/,end:/\]/,endsParent:!0,relevance:0,contains:[p,...m]},A={begin:/\s+/,relevance:0},O=[g],M=[b],w=function(x,L){return{contains:[A],starts:{relevance:0,contains:x,starts:L}}},v=function(x,L){return{begin:"\\\\"+x+"(?![a-zA-Z@:_])",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\"+x},relevance:0,contains:[A],starts:L}},T=function(x,L){return t.inherit({begin:"\\\\begin(?=[ ]*(\\r?\\n[ ]*)?\\{"+x+"\\})",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\begin"},relevance:0},w(O,L))},I=(x="string")=>t.END_SAME_AS_BEGIN({className:x,begin:/(.|\r?\n)/,end:/(.|\r?\n)/,excludeBegin:!0,excludeEnd:!0,endsParent:!0}),h=function(x){return{className:"string",end:"(?=\\\\end\\{"+x+"\\})"}},E=(x="string")=>({relevance:0,begin:/\{/,starts:{endsParent:!0,contains:[{className:x,end:/(?=\})/,endsParent:!0,contains:[{begin:/\{/,end:/\}/,relevance:0,contains:["self"]}]}]}}),D=[...["verb","lstinline"].map(x=>v(x,{contains:[I()]})),v("mint",w(O,{contains:[I()]})),v("mintinline",w(O,{contains:[E(),I()]})),v("url",{contains:[E("link"),E("link")]}),v("hyperref",{contains:[E("link")]}),v("href",w(M,{contains:[E("link")]})),...[].concat(...["","\\*"].map(x=>[T("verbatim"+x,h("verbatim"+x)),T("filecontents"+x,w(O,h("filecontents"+x))),...["","B","L"].map(L=>T(L+"Verbatim"+x,w(M,h(L+"Verbatim"+x))))])),T("minted",w(M,w(O,h("minted"))))];return{name:"LaTeX",aliases:["tex"],contains:[...D,...m]}}return bl=e,bl}var Tl,Tm;function Uy(){if(Tm)return Tl;Tm=1;function e(t){return{name:"LDIF",contains:[{className:"attribute",match:"^dn(?=:)",relevance:10},{className:"attribute",match:"^\\w+(?=:)"},{className:"literal",match:"^-"},t.HASH_COMMENT_MODE]}}return Tl=e,Tl}var hl,hm;function Fy(){if(hm)return hl;hm=1;function e(t){const n=/([A-Za-z_][A-Za-z_0-9]*)?/,r={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:/\+|\-|\*|\/|\%|\=\=|\=|\!|\>|\<|\&\&|\|\|/}]},i={match:[n,/(?=\()/],scope:{1:"keyword"},contains:[r]};return r.contains.unshift(i),{name:"Leaf",contains:[{match:[/#+/,n,/(?=\()/],scope:{1:"punctuation",2:"keyword"},starts:{contains:[{match:/\:/,scope:"punctuation"}]},contains:[r]},{match:[/#+/,n,/:?/],scope:{1:"punctuation",2:"keyword",3:"punctuation"}}]}}return hl=e,hl}var vl,vm;function By(){if(vm)return vl;vm=1;const e=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_-]*/}}),t=["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"],n=["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"],a=[...t,...n],r=["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(),i=["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(),o=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),s=["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=i.concat(o).sort().reverse();function c(u){const d=e(u),_=l,m="and or not only",p="[\\w-]+",g="("+p+"|@\\{"+p+"\\})",b=[],A=[],O=function(ae){return{className:"string",begin:"~?"+ae+".*?"+ae}},M=function(ae,Ee,xe){return{className:ae,begin:Ee,relevance:xe}},w={$pattern:/[a-z-]+/,keyword:m,attribute:r.join(" ")},v={begin:"\\(",end:"\\)",contains:A,keywords:w,relevance:0};A.push(u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,O("'"),O('"'),d.CSS_NUMBER_MODE,{begin:"(url|data-uri)\\(",starts:{className:"string",end:"[\\)\\n]",excludeEnd:!0}},d.HEXCOLOR,v,M("variable","@@?"+p,10),M("variable","@\\{"+p+"\\}"),M("built_in","~?`[^`]*?`"),{className:"attribute",begin:p+"\\s*:",end:":",returnBegin:!0,excludeEnd:!0},d.IMPORTANT,{beginKeywords:"and not"},d.FUNCTION_DISPATCH);const T=A.concat({begin:/\{/,end:/\}/,contains:b}),I={beginKeywords:"when",endsWithParent:!0,contains:[{beginKeywords:"and not"}].concat(A)},h={begin:g+"\\s*:",returnBegin:!0,end:/[;}]/,relevance:0,contains:[{begin:/-(webkit|moz|ms|o)-/},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+s.join("|")+")\\b",end:/(?=:)/,starts:{endsWithParent:!0,illegal:"[<=$]",relevance:0,contains:A}}]},E={className:"keyword",begin:"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",starts:{end:"[;{}]",keywords:w,returnEnd:!0,contains:A,relevance:0}},D={className:"variable",variants:[{begin:"@"+p+"\\s*:",relevance:15},{begin:"@"+p}],starts:{end:"[;}]",returnEnd:!0,contains:T}},x={variants:[{begin:"[\\.#:&\\[>]",end:"[;{}]"},{begin:g,end:/\{/}],returnBegin:!0,returnEnd:!0,illegal:`[<='$"]`,relevance:0,contains:[u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,I,M("keyword","all\\b"),M("variable","@\\{"+p+"\\}"),{begin:"\\b("+a.join("|")+")\\b",className:"selector-tag"},d.CSS_NUMBER_MODE,M("selector-tag",g,0),M("selector-id","#"+g),M("selector-class","\\."+g,0),M("selector-tag","&",0),d.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",begin:":("+i.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+o.join("|")+")"},{begin:/\(/,end:/\)/,relevance:0,contains:T},{begin:"!important"},d.FUNCTION_DISPATCH]},L={begin:p+`:(:)?(${_.join("|")})`,returnBegin:!0,contains:[x]};return b.push(u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,E,D,L,h,x,I,d.FUNCTION_DISPATCH),{name:"Less",case_insensitive:!0,illegal:`[=>'/<($"]`,contains:b}}return vl=c,vl}var Rl,Rm;function Gy(){if(Rm)return Rl;Rm=1;function e(t){const n="[a-zA-Z_\\-+\\*\\/<=>&#][a-zA-Z0-9_\\-+*\\/<=>&#!]*",a="\\|[^]*?\\|",r="(-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|-)?\\d+)?",i={className:"literal",begin:"\\b(t{1}|nil)\\b"},o={className:"number",variants:[{begin:r,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)\\("+r+" +"+r,end:"\\)"}]},s=t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),l=t.COMMENT(";","$",{relevance:0}),c={begin:"\\*",end:"\\*"},u={className:"symbol",begin:"[:&]"+n},d={begin:n,relevance:0},_={begin:a},p={contains:[o,s,c,u,{begin:"\\(",end:"\\)",contains:["self",i,s,o,d]},d],variants:[{begin:"['`]\\(",end:"\\)"},{begin:"\\(quote ",end:"\\)",keywords:{name:"quote"}},{begin:"'"+a}]},g={variants:[{begin:"'"+n},{begin:"#'"+n+"(::"+n+")*"}]},b={begin:"\\(\\s*",end:"\\)"},A={endsWithParent:!0,relevance:0};return b.contains=[{className:"name",variants:[{begin:n,relevance:0},{begin:a}]},A],A.contains=[p,g,b,i,o,s,l,c,u,_,d],{name:"Lisp",illegal:/\S/,contains:[o,t.SHEBANG(),i,s,l,p,g,b,d]}}return Rl=e,Rl}var Cl,Cm;function Yy(){if(Cm)return Cl;Cm=1;function e(t){const n={className:"variable",variants:[{begin:"\\b([gtps][A-Z]{1}[a-zA-Z0-9]*)(\\[.+\\])?(?:\\s*?)"},{begin:"\\$_[A-Z]+"}],relevance:0},a=[t.C_BLOCK_COMMENT_MODE,t.HASH_COMMENT_MODE,t.COMMENT("--","$"),t.COMMENT("[^:]//","$")],r=t.inherit(t.TITLE_MODE,{variants:[{begin:"\\b_*rig[A-Z][A-Za-z0-9_\\-]*"},{begin:"\\b_[a-z0-9\\-]+"}]}),i=t.inherit(t.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:[n,{className:"keyword",begin:"\\bend\\sif\\b"},{className:"function",beginKeywords:"function",end:"$",contains:[n,i,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.BINARY_NUMBER_MODE,t.C_NUMBER_MODE,r]},{className:"function",begin:"\\bend\\s+",end:"$",keywords:"end",contains:[i,r],relevance:0},{beginKeywords:"command on",end:"$",contains:[n,i,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.BINARY_NUMBER_MODE,t.C_NUMBER_MODE,r]},{className:"meta",variants:[{begin:"<\\?(rev|lc|livecode)",relevance:10},{begin:"<\\?"},{begin:"\\?>"}]},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.BINARY_NUMBER_MODE,t.C_NUMBER_MODE,r].concat(a),illegal:";$|^\\[|^=|&|\\{"}}return Cl=e,Cl}var yl,ym;function $y(){if(ym)return yl;ym=1;const 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"],t=["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"],a=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],r=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],i=[].concat(r,n,a);function o(s){const l=["npm","print"],c=["yes","no","on","off","it","that","void"],u=["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"],d={keyword:e.concat(u),literal:t.concat(c),built_in:i.concat(l)},_="[A-Za-z$_](?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*",m=s.inherit(s.TITLE_MODE,{begin:_}),p={className:"subst",begin:/#\{/,end:/\}/,keywords:d},g={className:"subst",begin:/#[A-Za-z$_]/,end:/(?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*/,keywords:d},b=[s.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:[s.BACKSLASH_ESCAPE]},{begin:/'/,end:/'/,contains:[s.BACKSLASH_ESCAPE]},{begin:/"""/,end:/"""/,contains:[s.BACKSLASH_ESCAPE,p,g]},{begin:/"/,end:/"/,contains:[s.BACKSLASH_ESCAPE,p,g]},{begin:/\\/,end:/(\s|$)/,excludeEnd:!0}]},{className:"regexp",variants:[{begin:"//",end:"//[gim]*",contains:[p,s.HASH_COMMENT_MODE]},{begin:/\/(?![ *])(\\.|[^\\\n])*?\/[gim]*(?=\W)/}]},{begin:"@"+_},{begin:"``",end:"``",excludeBegin:!0,excludeEnd:!0,subLanguage:"javascript"}];p.contains=b;const A={className:"params",begin:"\\(",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:d,contains:["self"].concat(b)}]},O={begin:"(#=>|=>|\\|>>|-?->|!->)"},M={variants:[{match:[/class\s+/,_,/\s+extends\s+/,_]},{match:[/class\s+/,_]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:d};return{name:"LiveScript",aliases:["ls"],keywords:d,illegal:/\/\*/,contains:b.concat([s.COMMENT("\\/\\*","\\*\\/"),s.HASH_COMMENT_MODE,O,{className:"function",contains:[m,A],returnBegin:!0,variants:[{begin:"("+_+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B->\\*?",end:"->\\*?"},{begin:"("+_+"\\s*(?:=|:=)\\s*)?!?(\\(.*\\)\\s*)?\\B[-~]{1,2}>\\*?",end:"[-~]{1,2}>\\*?"},{begin:"("+_+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B!?[-~]{1,2}>\\*?",end:"!?[-~]{1,2}>\\*?"}]},M,{begin:_+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return yl=o,yl}var Nl,Nm;function qy(){if(Nm)return Nl;Nm=1;function e(t){const n=t.regex,a=/([-a-zA-Z$._][\w$.-]*)/,r={className:"type",begin:/\bi\d+(?=\s|\b)/},i={className:"operator",relevance:0,begin:/=/},o={className:"punctuation",relevance:0,begin:/,/},s={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},c={className:"variable",variants:[{begin:n.concat(/%/,a)},{begin:/%\d+/},{begin:/#\d+/}]},u={className:"title",variants:[{begin:n.concat(/@/,a)},{begin:/@\d+/},{begin:n.concat(/!/,a)},{begin:n.concat(/!\d+/,a)},{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:[r,t.COMMENT(/;\s*$/,null,{relevance:0}),t.COMMENT(/;/,/$/),{className:"string",begin:/"/,end:/"/,contains:[{className:"char.escape",match:/\\\d\d/}]},u,o,i,c,l,s]}}return Nl=e,Nl}var Ol,Om;function Hy(){if(Om)return Ol;Om=1;function e(t){const a={className:"string",begin:'"',end:'"',contains:[{className:"subst",begin:/\\[tn"\\]/}]},r={className:"number",relevance:0,begin:t.C_NUMBER_RE},i={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"}]},o={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:[a,{className:"comment",variants:[t.COMMENT("//","$"),t.COMMENT("/\\*","\\*/")],relevance:0},r,{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"}]},o,i,{className:"type",begin:"\\b(integer|float|string|key|vector|quaternion|rotation|list)\\b"}]}}return Ol=e,Ol}var Al,Am;function Vy(){if(Am)return Al;Am=1;function e(t){const n="\\[=*\\[",a="\\]=*\\]",r={begin:n,end:a,contains:["self"]},i=[t.COMMENT("--(?!"+n+")","$"),t.COMMENT("--"+n,a,{contains:[r],relevance:10})];return{name:"Lua",aliases:["pluto"],keywords:{$pattern:t.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:i.concat([{className:"function",beginKeywords:"function",end:"\\)",contains:[t.inherit(t.TITLE_MODE,{begin:"([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"}),{className:"params",begin:"\\(",endsWithParent:!0,contains:i}].concat(i)},t.C_NUMBER_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{className:"string",begin:n,end:a,contains:[r],relevance:5}])}}return Al=e,Al}var Il,Im;function zy(){if(Im)return Il;Im=1;function e(t){const n={className:"variable",variants:[{begin:"\\$\\("+t.UNDERSCORE_IDENT_RE+"\\)",contains:[t.BACKSLASH_ESCAPE]},{begin:/\$[@%{g.has(I[0])||h.ignoreMatch()}},{className:"symbol",relevance:0,begin:p}]},A={className:"named-character",begin:/\\\[[$a-zA-Z][$a-zA-Z0-9]+\]/},O={className:"operator",relevance:0,begin:/[+\-*/,;.:@~=><&|_`'^?!%]+/},M={className:"pattern",relevance:0,begin:/([a-zA-Z$][a-zA-Z0-9$]*)?_+([a-zA-Z$][a-zA-Z0-9$]*)?/},w={className:"slot",relevance:0,begin:/#[a-zA-Z$][a-zA-Z0-9$]*|#+[0-9]?/},v={className:"brace",relevance:0,begin:/[[\](){}]/},T={className:"message-name",relevance:0,begin:a.concat("::",p)};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:[n.COMMENT(/\(\*/,/\*\)/,{contains:["self"]}),M,w,T,b,A,n.QUOTE_STRING_MODE,m,O,v]}}return Dl=t,Dl}var xl,xm;function Ky(){if(xm)return xl;xm=1;function e(t){const n="('|\\.')+",a={relevance:0,contains:[{begin:n}]};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:[t.UNDERSCORE_TITLE_MODE,{className:"params",variants:[{begin:"\\(",end:"\\)"},{begin:"\\[",end:"\\]"}]}]},{className:"built_in",begin:/true|false/,relevance:0,starts:a},{begin:"[a-zA-Z][a-zA-Z_0-9]*"+n,relevance:0},{className:"number",begin:t.C_NUMBER_RE,relevance:0,starts:a},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{begin:/\]|\}|\)/,relevance:0,starts:a},{className:"string",begin:'"',end:'"',contains:[{begin:'""'}],starts:a},t.COMMENT("^\\s*%\\{\\s*$","^\\s*%\\}\\s*$"),t.COMMENT("%","$")]}}return xl=e,xl}var Ml,Mm;function Qy(){if(Mm)return Ml;Mm=1;function e(t){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"]},t.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 Ml=e,Ml}var wl,wm;function Xy(){if(wm)return wl;wm=1;function e(t){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}]},a,t.C_BLOCK_COMMENT_MODE,r,t.NUMBER_MODE,i,o,{begin:/:-/},{begin:/\.$/}]}}return Ll=e,Ll}var Pl,Pm;function Jy(){if(Pm)return Pl;Pm=1;function e(t){return{name:"MIPS Assembly",case_insensitive:!0,aliases:["mips"],keywords:{$pattern:"\\.?"+t.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"},t.COMMENT("[;#](?!\\s*$)","$"),t.C_BLOCK_COMMENT_MODE,t.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 Pl=e,Pl}var kl,km;function jy(){if(km)return kl;km=1;function e(t){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:[t.COMMENT("::","$")]}}return kl=e,kl}var Ul,Um;function eN(){if(Um)return Ul;Um=1;function e(t){const n=t.regex,a=["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"],r=/[dualxmsipngr]{0,12}/,i={$pattern:/[\w.]+/,keyword:a.join(" ")},o={className:"subst",begin:"[$@]\\{",end:"\\}",keywords:i},s={begin:/->\{/,end:/\}/},l={scope:"attr",match:/\s+:\s*\w+(\s*\(.*?\))?/},c={scope:"variable",variants:[{begin:/\$\d/},{begin:n.concat(/[$%@](?!")(\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,"(?![A-Za-z])(?![@$%])")},{begin:/[$%@](?!")[^\s\w{=]|\$=/,relevance:0}],contains:[l]},u={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},d=[t.BACKSLASH_ESCAPE,o,c],_=[/!/,/\//,/\|/,/\?/,/'/,/"/,/#/],m=(b,A,O="\\1")=>{const M=O==="\\1"?O:n.concat(O,A);return n.concat(n.concat("(?:",b,")"),A,/(?:\\.|[^\\\/])*?/,M,/(?:\\.|[^\\\/])*?/,O,r)},p=(b,A,O)=>n.concat(n.concat("(?:",b,")"),A,/(?:\\.|[^\\\/])*?/,O,r),g=[c,t.HASH_COMMENT_MODE,t.COMMENT(/^=\w/,/=cut/,{endsWithParent:!0}),s,{className:"string",contains:d,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:[t.BACKSLASH_ESCAPE]},{begin:'"',end:'"'},{begin:"`",end:"`",contains:[t.BACKSLASH_ESCAPE]},{begin:/\{\w+\}/,relevance:0},{begin:"-?\\w+\\s*=>",relevance:0}]},u,{begin:"(\\/\\/|"+t.RE_STARTERS_RE+"|\\b(split|return|print|reverse|grep)\\b)\\s*",keywords:"split return print reverse grep",relevance:0,contains:[t.HASH_COMMENT_MODE,{className:"regexp",variants:[{begin:m("s|tr|y",n.either(..._,{capture:!0}))},{begin:m("s|tr|y","\\(","\\)")},{begin:m("s|tr|y","\\[","\\]")},{begin:m("s|tr|y","\\{","\\}")}],relevance:2},{className:"regexp",variants:[{begin:/(m|qr)\/\//,relevance:0},{begin:p("(?:m|qr)?",/\//,/\//)},{begin:p("m|qr",n.either(..._,{capture:!0}),/\1/)},{begin:p("m|qr",/\(/,/\)/)},{begin:p("m|qr",/\[/,/\]/)},{begin:p("m|qr",/\{/,/\}/)}]}]},{className:"function",beginKeywords:"sub method",end:"(\\s*\\(.*?\\))?[;{]",excludeEnd:!0,relevance:5,contains:[t.TITLE_MODE,l]},{className:"class",beginKeywords:"class",end:"[;{]",excludeEnd:!0,relevance:5,contains:[t.TITLE_MODE,l,u]},{begin:"-\\w\\b",relevance:0},{begin:"^__DATA__$",end:"^__END__$",subLanguage:"mojolicious",contains:[{begin:"^@@.*",end:"$",className:"comment"}]}];return o.contains=g,s.contains=g,{name:"Perl",aliases:["pl","pm"],keywords:i,contains:g}}return Ul=e,Ul}var Fl,Fm;function tN(){if(Fm)return Fl;Fm=1;function e(t){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 Fl=e,Fl}var Bl,Bm;function nN(){if(Bm)return Bl;Bm=1;function e(t){const n={className:"number",relevance:0,variants:[{begin:"[$][a-fA-F0-9]+"},t.NUMBER_MODE]},a={variants:[{match:[/(function|method)/,/\s+/,t.UNDERSCORE_IDENT_RE]}],scope:{1:"keyword",3:"title.function"}},r={variants:[{match:[/(class|interface|extends|implements)/,/\s+/,t.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:[t.COMMENT("#rem","#end"),t.COMMENT("'","$",{relevance:0}),a,r,{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:[t.UNDERSCORE_TITLE_MODE]},t.QUOTE_STRING_MODE,n]}}return Bl=e,Bl}var Gl,Gm;function aN(){if(Gm)return Gl;Gm=1;function e(t){const n={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"},a="[A-Za-z$_][0-9A-Za-z$_]*",r={className:"subst",begin:/#\{/,end:/\}/,keywords:n},i=[t.inherit(t.C_NUMBER_MODE,{starts:{end:"(\\s*/)?",relevance:0}}),{className:"string",variants:[{begin:/'/,end:/'/,contains:[t.BACKSLASH_ESCAPE]},{begin:/"/,end:/"/,contains:[t.BACKSLASH_ESCAPE,r]}]},{className:"built_in",begin:"@__"+t.IDENT_RE},{begin:"@"+t.IDENT_RE},{begin:t.IDENT_RE+"\\\\"+t.IDENT_RE}];r.contains=i;const o=t.inherit(t.TITLE_MODE,{begin:a}),s="(\\(.*\\)\\s*)?\\B[-=]>",l={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:n,contains:["self"].concat(i)}]};return{name:"MoonScript",aliases:["moon"],keywords:n,illegal:/\/\*/,contains:i.concat([t.COMMENT("--","$"),{className:"function",begin:"^\\s*"+a+"\\s*=\\s*"+s,end:"[-=]>",returnBegin:!0,contains:[o,l]},{begin:/[\(,:=]\s*/,relevance:0,contains:[{className:"function",begin:s,end:"[-=]>",returnBegin:!0,contains:[l]}]},{className:"class",beginKeywords:"class",end:"$",illegal:/[:="\[\]]/,contains:[{beginKeywords:"extends",endsWithParent:!0,illegal:/[:="\[\]]/,contains:[o]},o]},{className:"name",begin:a+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return Gl=e,Gl}var Yl,Ym;function rN(){if(Ym)return Yl;Ym=1;function e(t){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:[t.BACKSLASH_ESCAPE]},{className:"string",begin:'"',end:'"',contains:[t.BACKSLASH_ESCAPE]},{className:"symbol",begin:"`",end:"`",contains:[t.BACKSLASH_ESCAPE]},t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE]},t.C_BLOCK_COMMENT_MODE]}}return Yl=e,Yl}var $l,$m;function iN(){if($m)return $l;$m=1;function e(t){const n={match:[/^\s*(?=\S)/,/[^:]+/,/:\s*/,/$/],className:{2:"attribute",3:"punctuation"}},a={match:[/^\s*(?=\S)/,/[^:]*[^: ]/,/[ ]*:/,/[ ]/,/.*$/],className:{2:"attribute",3:"punctuation",5:"string"}},r={match:[/^\s*/,/>/,/[ ]/,/.*$/],className:{2:"punctuation",4:"string"}},i={variants:[{match:[/^\s*/,/-/,/[ ]/,/.*$/]},{match:[/^\s*/,/-$/]}],className:{2:"bullet",4:"string"}};return{name:"Nested Text",aliases:["nt"],contains:[t.inherit(t.HASH_COMMENT_MODE,{begin:/^\s*(?=#)/,excludeBegin:!0}),i,r,n,a]}}return $l=e,$l}var ql,qm;function oN(){if(qm)return ql;qm=1;function e(t){const n=t.regex,a={className:"variable",variants:[{begin:/\$\d+/},{begin:/\$\{\w+\}/},{begin:n.concat(/[$@]/,t.UNDERSCORE_IDENT_RE)}]},i={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:[t.HASH_COMMENT_MODE,{className:"string",contains:[t.BACKSLASH_ESCAPE,a],variants:[{begin:/"/,end:/"/},{begin:/'/,end:/'/}]},{begin:"([a-z]+):/",end:"\\s",endsWithParent:!0,excludeEnd:!0,contains:[a]},{className:"regexp",contains:[t.BACKSLASH_ESCAPE,a],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},a]};return{name:"Nginx config",aliases:["nginxconf"],contains:[t.HASH_COMMENT_MODE,{beginKeywords:"upstream location",end:/;|\{/,contains:i.contains,keywords:{section:"upstream location"}},{className:"section",begin:n.concat(t.UNDERSCORE_IDENT_RE+n.lookahead(/\s+\{/)),relevance:0},{begin:n.lookahead(t.UNDERSCORE_IDENT_RE+"\\s"),end:";|\\{",contains:[{className:"attribute",begin:t.UNDERSCORE_IDENT_RE,starts:i}],relevance:0}],illegal:"[^\\s\\}\\{]"}}return ql=e,ql}var Hl,Hm;function sN(){if(Hm)return Hl;Hm=1;function e(t){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:/"""/},t.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))?/}]},t.HASH_COMMENT_MODE]}}return Hl=e,Hl}var Vl,Vm;function lN(){if(Vm)return Vl;Vm=1;function e(t){const n=t.regex,a={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"]},r={scope:"built_in",match:n.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(I=>`builtins\\.${I}`)),relevance:10},i="[A-Za-z_][A-Za-z0-9_'-]*",o={scope:"symbol",match:new RegExp(`<${i}(/${i})*>`)},s="[A-Za-z0-9_\\+\\.-]+",l={scope:"symbol",match:new RegExp(`(\\.\\.|\\.|~)?/(${s})?(/${s})*(?=[\\s;])`)},c=n.either("==","=","\\+\\+","\\+","<=","<\\|","<",">=",">","->","//","/","!=","!","\\|\\|","\\|>","\\?","\\*","&&"),u={scope:"operator",match:n.concat(c,/(?!-)/),relevance:0},d={scope:"number",match:new RegExp(`${t.NUMBER_RE}(?!-)`),relevance:0},_={variants:[{scope:"operator",beforeMatch:/\s/,begin:/-(?!>)/},{begin:[new RegExp(`${t.NUMBER_RE}`),/-/,/(?!>)/],beginScope:{1:"number",2:"operator"}},{begin:[c,/-/,/(?!>)/],beginScope:{1:"operator",2:"operator"}}],relevance:0},m={beforeMatch:/(^|\{|;)\s*/,begin:new RegExp(`${i}(\\.${i})*\\s*=(?!=)`),returnBegin:!0,relevance:0,contains:[{scope:"attr",match:new RegExp(`${i}(\\.${i})*(?=\\s*=)`),relevance:.2}]},p={scope:"char.escape",match:/\\\$/},g={scope:"char.escape",match:/''\$/},b={scope:"subst",begin:/\$\{/,end:/\}/,keywords:a},A={scope:"char.escape",match:/'''/},O={scope:"char.escape",match:/\\(?!\$)./},M={scope:"string",variants:[{begin:"''",end:"''",contains:[g,b,A,O]},{begin:'"',end:'"',contains:[p,b,O]}]},w={scope:"params",match:new RegExp(`${i}\\s*:(?=\\s)`)},v=[d,t.HASH_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),r,M,o,l,w,m,_,u];b.contains=v;const T=[{scope:"meta.prompt",match:/^nix-repl>(?=\s)/,relevance:10},{scope:"meta",beforeMatch:/\s+/,begin:/:([a-z]+|\?)/}];return{name:"Nix",aliases:["nixos"],keywords:a,contains:v.concat(T)}}return Vl=e,Vl}var zl,zm;function cN(){if(zm)return zl;zm=1;function e(t){return{name:"Node REPL",contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"javascript"}},variants:[{begin:/^>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return zl=e,zl}var Wl,Wm;function uN(){if(Wm)return Wl;Wm=1;function e(t){const n=t.regex,a=["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"],r=["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"],i=["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"],o={className:"variable.constant",begin:n.concat(/\$/,n.either(...a))},s={className:"variable",begin:/\$+\{[\!\w.:-]+\}/},l={className:"variable",begin:/\$+\w[\w\.]*/,illegal:/\(\)\{\}/},c={className:"variable",begin:/\$+\([\w^.:!-]+\)/},u={className:"params",begin:n.either(...r)},d={className:"keyword",begin:n.concat(/!/,n.either(...i))},_={className:"char.escape",begin:/\$(\\[nrt]|\$)/},m={className:"title.function",begin:/\w+::\w+/},p={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"},{begin:"`",end:"`"}],illegal:/\n/,contains:[_,o,s,l,c]},g=["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"],b=["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"],A={match:[/Function/,/\s+/,n.concat(/(\.)?/,t.IDENT_RE)],scope:{1:"keyword",3:"title.function"}},M={match:[/Var/,/\s+/,/(?:\/GLOBAL\s+)?/,/[A-Za-z][\w.]*/],scope:{1:"keyword",3:"params",4:"variable"}};return{name:"NSIS",case_insensitive:!0,keywords:{keyword:g,literal:b},contains:[t.HASH_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.COMMENT(";","$",{relevance:0}),M,A,{beginKeywords:"Function PageEx Section SectionGroup FunctionEnd SectionEnd"},p,d,s,l,c,u,m,t.NUMBER_MODE]}}return Wl=e,Wl}var Kl,Km;function dN(){if(Km)return Kl;Km=1;function e(t){const n={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+"},a=/[a-zA-Z@][a-zA-Z0-9_]*/,l={"variable.language":["this","super"],$pattern:a,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"]},c={$pattern:a,keyword:["@interface","@class","@protocol","@implementation"]};return{name:"Objective-C",aliases:["mm","objc","obj-c","obj-c++","objective-c++"],keywords:l,illegal:"/,end:/$/,illegal:"\\n"},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},{className:"class",begin:"("+c.keyword.join("|")+")\\b",end:/(\{|$)/,excludeEnd:!0,keywords:c,contains:[t.UNDERSCORE_TITLE_MODE]},{begin:"\\."+t.UNDERSCORE_IDENT_RE,relevance:0}]}}return Kl=e,Kl}var Ql,Qm;function _N(){if(Qm)return Ql;Qm=1;function e(t){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},t.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},t.inherit(t.APOS_STRING_MODE,{className:"string",relevance:0}),t.inherit(t.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 Ql=e,Ql}var Xl,Xm;function pN(){if(Xm)return Xl;Xm=1;function e(t){const n={className:"keyword",begin:"\\$(f[asn]|t|vp[rtd]|children)"},a={className:"literal",begin:"false|true|PI|undef"},r={className:"number",begin:"\\b\\d+(\\.\\d+)?(e-?\\d+)?",relevance:0},i=t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),o={className:"meta",keywords:{keyword:"include use"},begin:"include|use <",end:">"},s={className:"params",begin:"\\(",end:"\\)",contains:["self",r,i,n,a]},l={begin:"[*!#%]",relevance:0},c={className:"function",beginKeywords:"module function",end:/=|\{/,contains:[s,t.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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,r,o,i,n,l,c]}}return Xl=e,Xl}var Zl,Zm;function mN(){if(Zm)return Zl;Zm=1;function e(t){const n={$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"},a=t.COMMENT(/\{/,/\}/,{relevance:0}),r=t.COMMENT("\\(\\*","\\*\\)",{relevance:10}),i={className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},o={className:"string",begin:"(#\\d+)+"},s={beginKeywords:"function constructor destructor procedure method",end:"[:;]",keywords:"function constructor|10 destructor|10 procedure|10 method|10",contains:[t.inherit(t.TITLE_MODE,{scope:"title.function"}),{className:"params",begin:"\\(",end:"\\)",keywords:n,contains:[i,o]},a,r]},l={scope:"punctuation",match:/;/,relevance:0};return{name:"Oxygene",case_insensitive:!0,keywords:n,illegal:'("|\\$[G-Zg-z]|\\/\\*||->)',contains:[a,r,t.C_LINE_COMMENT_MODE,i,o,t.NUMBER_MODE,s,l]}}return Zl=e,Zl}var Jl,Jm;function gN(){if(Jm)return Jl;Jm=1;function e(t){const n=t.COMMENT(/\{/,/\}/,{contains:["self"]});return{name:"Parser3",subLanguage:"xml",relevance:0,contains:[t.COMMENT("^#","$"),t.COMMENT(/\^rem\{/,/\}/,{relevance:10,contains:[n]}),{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]+"},t.C_NUMBER_MODE]}}return Jl=e,Jl}var jl,jm;function EN(){if(jm)return jl;jm=1;function e(t){const n={className:"variable",begin:/\$[\w\d#@][\w\d_]*/,relevance:0},a={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:[t.HASH_COMMENT_MODE,t.NUMBER_MODE,t.QUOTE_STRING_MODE,n,a]}}return jl=e,jl}var ec,eg;function fN(){if(eg)return ec;eg=1;function e(t){const n=t.COMMENT("--","$"),a="[a-zA-Z_][a-zA-Z_0-9$]*",r="\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",i="<<\\s*"+a+"\\s*>>",o="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 ",s="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 ",c="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 ",u=c.trim().split(" ").map(function(b){return b.split("|")[0]}).join("|"),d="CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURRENT_CATALOG|10 CURRENT_DATE LOCALTIME LOCALTIMESTAMP CURRENT_ROLE|10 CURRENT_SCHEMA|10 SESSION_USER PUBLIC ",_="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 ",m="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 ",g="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(b){return b.split("|")[0]}).join("|");return{name:"PostgreSQL",aliases:["postgres","postgresql"],supersetOf:"sql",case_insensitive:!0,keywords:{keyword:o+l+s,built_in:d+_+m},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:t.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("+g+")\\s*\\("},{begin:"\\.("+u+")\\b"},{begin:"\\b("+u+")\\s+PATH\\b",keywords:{keyword:"PATH",type:c.replace("PATH ","")}},{className:"type",begin:"\\b("+u+")\\b"},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{className:"string",begin:"(e|E|u&|U&)'",end:"'",contains:[{begin:"\\\\."}],relevance:10},t.END_SAME_AS_BEGIN({begin:r,end:r,contains:[{subLanguage:["pgsql","perl","python","tcl","r","lua","java","php","ruby","bash","scheme","xml","json"],endsWithParent:!0}]}),{begin:'"',end:'"',contains:[{begin:'""'}]},t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE,n,{className:"meta",variants:[{begin:"%(ROW)?TYPE",relevance:10},{begin:"\\$\\d+"},{begin:"^#\\w",end:"$"}]},{className:"symbol",begin:i,relevance:10}]}}return ec=e,ec}var tc,tg;function SN(){if(tg)return tc;tg=1;function e(t){const n=t.regex,a=/(?![A-Za-z0-9])(?![$])/,r=n.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,a),i=n.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,a),o=n.concat(/[A-Z]+/,a),s={scope:"variable",match:"\\$+"+r},l={scope:"meta",variants:[{begin:/<\?php/,relevance:10},{begin:/<\?=/},{begin:/<\?/,relevance:.1},{begin:/\?>/}]},c={scope:"subst",variants:[{begin:/\$\w+/},{begin:/\{\$/,end:/\}/}]},u=t.inherit(t.APOS_STRING_MODE,{illegal:null}),d=t.inherit(t.QUOTE_STRING_MODE,{illegal:null,contains:t.QUOTE_STRING_MODE.contains.concat(c)}),_={begin:/<<<[ \t]*(?:(\w+)|"(\w+)")\n/,end:/[ \t]*(\w+)\b/,contains:t.QUOTE_STRING_MODE.contains.concat(c),"on:begin":(xe,Se)=>{Se.data._beginMatch=xe[1]||xe[2]},"on:end":(xe,Se)=>{Se.data._beginMatch!==xe[1]&&Se.ignoreMatch()}},m=t.END_SAME_AS_BEGIN({begin:/<<<[ \t]*'(\w+)'\n/,end:/[ \t]*(\w+)\b/}),p=`[ -]`,g={scope:"string",variants:[d,u,_,m]},b={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},A=["false","null","true"],O=["__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"],M=["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"],v={keyword:O,literal:(xe=>{const Se=[];return xe.forEach(pe=>{Se.push(pe),pe.toLowerCase()===pe?Se.push(pe.toUpperCase()):Se.push(pe.toLowerCase())}),Se})(A),built_in:M},T=xe=>xe.map(Se=>Se.replace(/\|\d+$/,"")),I={variants:[{match:[/new/,n.concat(p,"+"),n.concat("(?!",T(M).join("\\b|"),"\\b)"),i],scope:{1:"keyword",4:"title.class"}}]},h=n.concat(r,"\\b(?!\\()"),E={variants:[{match:[n.concat(/::/,n.lookahead(/(?!class\b)/)),h],scope:{2:"variable.constant"}},{match:[/::/,/class/],scope:{2:"variable.language"}},{match:[i,n.concat(/::/,n.lookahead(/(?!class\b)/)),h],scope:{1:"title.class",3:"variable.constant"}},{match:[i,n.concat("::",n.lookahead(/(?!class\b)/))],scope:{1:"title.class"}},{match:[i,/::/,/class/],scope:{1:"title.class",3:"variable.language"}}]},D={scope:"attr",match:n.concat(r,n.lookahead(":"),n.lookahead(/(?!::)/))},x={relevance:0,begin:/\(/,end:/\)/,keywords:v,contains:[D,s,E,t.C_BLOCK_COMMENT_MODE,g,b,I]},L={relevance:0,match:[/\b/,n.concat("(?!fn\\b|function\\b|",T(O).join("\\b|"),"|",T(M).join("\\b|"),"\\b)"),r,n.concat(p,"*"),n.lookahead(/(?=\()/)],scope:{3:"title.function.invoke"},contains:[x]};x.contains.push(L);const ae=[D,E,t.C_BLOCK_COMMENT_MODE,g,b,I],Ee={begin:n.concat(/#\[\s*\\?/,n.either(i,o)),beginScope:"meta",end:/]/,endScope:"meta",keywords:{literal:A,keyword:["new","array"]},contains:[{begin:/\[/,end:/]/,keywords:{literal:A,keyword:["new","array"]},contains:["self",...ae]},...ae,{scope:"meta",variants:[{match:i},{match:o}]}]};return{case_insensitive:!1,keywords:v,contains:[Ee,t.HASH_COMMENT_MODE,t.COMMENT("//","$"),t.COMMENT("/\\*","\\*/",{contains:[{scope:"doctag",match:"@[A-Za-z]+"}]}),{match:/__halt_compiler\(\);/,keywords:"__halt_compiler",starts:{scope:"comment",end:t.MATCH_NOTHING_RE,contains:[{match:/\?>/,scope:"meta",endsParent:!0}]}},l,{scope:"variable.language",match:/\$this\b/},s,L,E,{match:[/const/,/\s/,r],scope:{1:"keyword",3:"variable.constant"}},I,{scope:"function",relevance:0,beginKeywords:"fn function",end:/[;{]/,excludeEnd:!0,illegal:"[$%\\[]",contains:[{beginKeywords:"use"},t.UNDERSCORE_TITLE_MODE,{begin:"=>",endsParent:!0},{scope:"params",begin:"\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0,keywords:v,contains:["self",Ee,s,E,t.C_BLOCK_COMMENT_MODE,g,b]}]},{scope:"class",variants:[{beginKeywords:"enum",illegal:/[($"]/},{beginKeywords:"class interface trait",illegal:/[:($"]/}],relevance:0,end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},t.UNDERSCORE_TITLE_MODE]},{beginKeywords:"namespace",relevance:0,end:";",illegal:/[.']/,contains:[t.inherit(t.UNDERSCORE_TITLE_MODE,{scope:"title.class"})]},{beginKeywords:"use",relevance:0,end:";",contains:[{match:/\b(as|const|function)\b/,scope:"keyword"},t.UNDERSCORE_TITLE_MODE]},g,b]}}return tc=e,tc}var nc,ng;function bN(){if(ng)return nc;ng=1;function e(t){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},t.inherit(t.APOS_STRING_MODE,{illegal:null,className:null,contains:null,skip:!0}),t.inherit(t.QUOTE_STRING_MODE,{illegal:null,className:null,contains:null,skip:!0})]}]}}return nc=e,nc}var ac,ag;function TN(){if(ag)return ac;ag=1;function e(t){return{name:"Plain text",aliases:["text","txt"],disableAutodetect:!0}}return ac=e,ac}var rc,rg;function hN(){if(rg)return rc;rg=1;function e(t){const n={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"},a={className:"string",begin:'"""',end:'"""',relevance:10},r={className:"string",begin:'"',end:'"',contains:[t.BACKSLASH_ESCAPE]},i={className:"string",begin:"'",end:"'",contains:[t.BACKSLASH_ESCAPE],relevance:0},o={className:"type",begin:"\\b_?[A-Z][\\w]*",relevance:0},s={begin:t.IDENT_RE+"'",relevance:0};return{name:"Pony",keywords:n,contains:[o,a,r,i,s,{className:"number",begin:"(-?)(\\b0[xX][a-fA-F0-9]+|\\b0[bB][01]+|(\\b\\d+(_\\d+)?(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",relevance:0},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]}}return rc=e,rc}var ic,ig;function vN(){if(ig)return ic;ig=1;function e(t){const n=["string","char","byte","int","long","bool","decimal","single","double","DateTime","xml","array","hashtable","void"],a="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",r="-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",i={$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"},o=/\w[\w\d]*((-)[\w\d]+)*/,s={begin:"`[\\s\\S]",relevance:0},l={className:"variable",variants:[{begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]},c={className:"literal",begin:/\$(null|true|false)\b/},u={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],contains:[s,l,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},d={className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]},_={className:"doctag",variants:[{begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/},{begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/}]},m=t.inherit(t.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,end:/#>/}],contains:[_]}),p={className:"built_in",variants:[{begin:"(".concat(a,")+(-)[\\w\\d]+")}]},g={className:"class",beginKeywords:"class enum",end:/\s*[{]/,excludeEnd:!0,relevance:0,contains:[t.TITLE_MODE]},b={className:"function",begin:/function\s+/,end:/\s*\{|$/,excludeEnd:!0,returnBegin:!0,relevance:0,contains:[{begin:"function",relevance:0,className:"keyword"},{className:"title",begin:o,relevance:0},{begin:/\(/,end:/\)/,className:"params",relevance:0,contains:[l]}]},A={begin:/using\s/,end:/$/,returnBegin:!0,contains:[u,d,{className:"keyword",begin:/(using|assembly|command|module|namespace|type)/}]},O={variants:[{className:"operator",begin:"(".concat(r,")\\b")},{className:"literal",begin:/(-){1,2}[\w\d-]+/,relevance:0}]},M={className:"selector-tag",begin:/@\B/,relevance:0},w={className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,relevance:0,contains:[{className:"keyword",begin:"(".concat(i.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,relevance:0},t.inherit(t.TITLE_MODE,{endsParent:!0})]},v=[w,m,s,t.NUMBER_MODE,u,d,p,l,c,M],T={begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",v,{begin:"("+n.join("|")+")",className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,relevance:0})};return w.contains.unshift(T),{name:"PowerShell",aliases:["pwsh","ps","ps1"],case_insensitive:!0,keywords:i,contains:v.concat(g,b,A,O,T)}}return ic=e,ic}var oc,og;function RN(){if(og)return oc;og=1;function e(t){const n=t.regex,a=["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"],r=t.IDENT_RE,i={variants:[{match:n.concat(n.either(...a),n.lookahead(/\s*\(/)),className:"built_in"},{relevance:0,match:n.concat(/\b(?!for|if|while)/,r,n.lookahead(/\s*\(/)),className:"title.function"}]},o={match:[/new\s+/,r],className:{1:"keyword",2:"class.title"}},s={relevance:0,match:[/\./,r],className:{2:"property"}},l={variants:[{match:[/class/,/\s+/,r,/\s+/,/extends/,/\s+/,r]},{match:[/class/,/\s+/,r]}],className:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},c=["boolean","byte","char","color","double","float","int","long","short"],u=["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:[...a,...u],type:c},contains:[l,o,i,s,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE]}}return oc=e,oc}var sc,sg;function CN(){if(sg)return sc;sg=1;function e(t){return{name:"Python profiler",contains:[t.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:[t.C_NUMBER_MODE],relevance:10},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{className:"string",begin:"\\(",end:"\\)$",excludeBegin:!0,excludeEnd:!0,relevance:0}]}}return sc=e,sc}var lc,lg;function yN(){if(lg)return lc;lg=1;function e(t){const n={begin:/[a-z][A-Za-z0-9_]*/,relevance:0},a={className:"symbol",variants:[{begin:/[A-Z][a-zA-Z0-9_]*/},{begin:/_[A-Za-z0-9_]*/}],relevance:0},r={begin:/\(/,end:/\)/,relevance:0},i={begin:/\[/,end:/\]/},o={className:"comment",begin:/%/,end:/$/,contains:[t.PHRASAL_WORDS_MODE]},s={className:"string",begin:/`/,end:/`/,contains:[t.BACKSLASH_ESCAPE]},l={className:"string",begin:/0'(\\'|.)/},c={className:"string",begin:/0'\\s/},d=[n,a,r,{begin:/:-/},i,o,t.C_BLOCK_COMMENT_MODE,t.QUOTE_STRING_MODE,t.APOS_STRING_MODE,s,l,c,t.C_NUMBER_MODE];return r.contains=d,i.contains=d,{name:"Prolog",contains:d.concat([{begin:/\.$/}])}}return lc=e,lc}var cc,cg;function NN(){if(cg)return cc;cg=1;function e(t){const n="[ \\t\\f]*",a="[ \\t\\f]+",r=n+"[:=]"+n,i=a,o="("+r+"|"+i+")",s="([^\\\\:= \\t\\f\\n]|\\\\.)+",l={end:o,relevance:0,starts:{className:"string",end:/$/,relevance:0,contains:[{begin:"\\\\\\\\"},{begin:"\\\\\\n"}]}};return{name:".properties",disableAutodetect:!0,case_insensitive:!0,illegal:/\S/,contains:[t.COMMENT("^\\s*[!#]","$"),{returnBegin:!0,variants:[{begin:s+r},{begin:s+i}],contains:[{className:"attr",begin:s,endsParent:!0}],starts:l},{className:"attr",begin:s+n+"$"}]}}return cc=e,cc}var uc,ug;function ON(){if(ug)return uc;ug=1;function e(t){const n=["package","import","option","optional","required","repeated","group","oneof"],a=["double","float","int32","int64","uint32","uint64","sint32","sint64","fixed32","fixed64","sfixed32","sfixed64","bool","string","bytes"],r={match:[/(message|enum|service)\s+/,t.IDENT_RE],scope:{1:"keyword",2:"title.class"}};return{name:"Protocol Buffers",aliases:["proto"],keywords:{keyword:n,type:a,literal:["true","false"]},contains:[t.QUOTE_STRING_MODE,t.NUMBER_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,r,{className:"function",beginKeywords:"rpc",end:/[{;]/,excludeEnd:!0,keywords:"rpc returns"},{begin:/^\s*[A-Z_]+(?=\s*=[^\n]+;$)/}]}}return uc=e,uc}var dc,dg;function AN(){if(dg)return dc;dg=1;function e(t){const n={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"},a=t.COMMENT("#","$"),r="([A-Za-z_]|::)(\\w|::)*",i=t.inherit(t.TITLE_MODE,{begin:r}),o={className:"variable",begin:"\\$"+r},s={className:"string",contains:[t.BACKSLASH_ESCAPE,o],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]};return{name:"Puppet",aliases:["pp"],contains:[a,o,s,{beginKeywords:"class",end:"\\{|;",illegal:/=/,contains:[i,a]},{beginKeywords:"define",end:/\{/,contains:[{className:"section",begin:t.IDENT_RE,endsParent:!0}]},{begin:t.IDENT_RE+"\\s+\\{",returnBegin:!0,end:/\S/,contains:[{className:"keyword",begin:t.IDENT_RE,relevance:.2},{begin:/\{/,end:/\}/,keywords:n,relevance:0,contains:[s,a,{begin:"[a-zA-Z_]+\\s*=>",returnBegin:!0,end:"=>",contains:[{className:"attr",begin:t.IDENT_RE}]},{className:"number",begin:"(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",relevance:0},o]}],relevance:0}]}}return dc=e,dc}var _c,_g;function IN(){if(_g)return _c;_g=1;function e(t){const n={className:"string",begin:'(~)?"',end:'"',illegal:"\\n"},a={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:[t.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*"},t.UNDERSCORE_TITLE_MODE]},n,a]}}return _c=e,_c}var pc,pg;function DN(){if(pg)return pc;pg=1;function e(t){const n=t.regex,a=new RegExp("[\\p{XID_Start}_]\\p{XID_Continue}*","u"),r=["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:r,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"]},c={className:"meta",begin:/^(>>>|\.\.\.) /},u={className:"subst",begin:/\{/,end:/\}/,keywords:l,illegal:/#/},d={begin:/\{\{/,relevance:0},_={className:"string",contains:[t.BACKSLASH_ESCAPE],variants:[{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/,contains:[t.BACKSLASH_ESCAPE,c],relevance:10},{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/,contains:[t.BACKSLASH_ESCAPE,c],relevance:10},{begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/,contains:[t.BACKSLASH_ESCAPE,c,d,u]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/,end:/"""/,contains:[t.BACKSLASH_ESCAPE,c,d,u]},{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:[t.BACKSLASH_ESCAPE,d,u]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/,contains:[t.BACKSLASH_ESCAPE,d,u]},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE]},m="[0-9](_?[0-9])*",p=`(\\b(${m}))?\\.(${m})|\\b(${m})\\.`,g=`\\b|${r.join("|")}`,b={className:"number",relevance:0,variants:[{begin:`(\\b(${m})|(${p}))[eE][+-]?(${m})[jJ]?(?=${g})`},{begin:`(${p})[jJ]?`},{begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${g})`},{begin:`\\b0[bB](_?[01])+[lL]?(?=${g})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${g})`},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${g})`},{begin:`\\b(${m})[jJ](?=${g})`}]},A={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:l,contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},O={className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:l,contains:["self",c,b,_,t.HASH_COMMENT_MODE]}]};return u.contains=[_,b,c],{name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:l,illegal:/(<\/|\?)|=>/,contains:[c,b,{scope:"variable.language",match:/\bself\b/},{beginKeywords:"if",relevance:0},{match:/\bor\b/,scope:"keyword"},_,A,t.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,a],scope:{1:"keyword",3:"title.function"},contains:[O]},{variants:[{match:[/\bclass/,/\s+/,a,/\s*/,/\(\s*/,a,/\s*\)/]},{match:[/\bclass/,/\s+/,a]}],scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[b,O,_]}]}}return pc=e,pc}var mc,mg;function xN(){if(mg)return mc;mg=1;function e(t){return{aliases:["pycon"],contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"python"}},variants:[{begin:/^>>>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return mc=e,mc}var gc,gg;function MN(){if(gg)return gc;gg=1;function e(t){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:[t.C_LINE_COMMENT_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE]}}return gc=e,gc}var Ec,Eg;function wN(){if(Eg)return Ec;Eg=1;function e(t){const n=t.regex,a={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"},r="[a-zA-Z_][a-zA-Z0-9\\._]*",i={className:"keyword",begin:"\\bproperty\\b",starts:{className:"string",end:"(:|=|;|,|//|/\\*|$)",returnEnd:!0}},o={className:"keyword",begin:"\\bsignal\\b",starts:{className:"string",end:"(\\(|:|=|;|,|//|/\\*|$)",returnEnd:!0}},s={className:"attribute",begin:"\\bid\\s*:",starts:{className:"string",end:r,returnEnd:!1}},l={begin:r+"\\s*:",returnBegin:!0,contains:[{className:"attribute",begin:r,end:"\\s*:",excludeEnd:!0,relevance:0}],relevance:0},c={begin:n.concat(r,/\s*\{/),end:/\{/,returnBegin:!0,relevance:0,contains:[t.inherit(t.TITLE_MODE,{begin:r})]};return{name:"QML",aliases:["qt"],case_insensitive:!1,keywords:a,contains:[{className:"meta",begin:/^\s*['"]use (strict|asm)['"]/},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,{className:"string",begin:"`",end:"`",contains:[t.BACKSLASH_ESCAPE,{className:"subst",begin:"\\$\\{",end:"\\}"}]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"number",variants:[{begin:"\\b(0[bB][01]+)"},{begin:"\\b(0[oO][0-7]+)"},{begin:t.C_NUMBER_RE}],relevance:0},{begin:"("+t.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.REGEXP_MODE,{begin:/\s*[);\]]/,relevance:0,subLanguage:"xml"}],relevance:0},o,i,{className:"function",beginKeywords:"function",end:/\{/,excludeEnd:!0,contains:[t.inherit(t.TITLE_MODE,{begin:/[A-Za-z$_][0-9A-Za-z$_]*/}),{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]}],illegal:/\[|%/},{begin:"\\."+t.IDENT_RE,relevance:0},s,l,c],illegal:/#/}}return Ec=e,Ec}var fc,fg;function LN(){if(fg)return fc;fg=1;function e(t){const n=t.regex,a=/(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,r=n.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]?/),i=/[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/,o=n.either(/[()]/,/[{}]/,/\[\[/,/[[\]]/,/\\/,/,/);return{name:"R",keywords:{$pattern:a,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:[t.COMMENT(/#'/,/$/,{contains:[{scope:"doctag",match:/@examples/,starts:{end:n.lookahead(n.either(/\n^#'\s*(?=@[a-zA-Z]+)/,/\n^(?!#')/)),endsParent:!0}},{scope:"doctag",begin:"@param",end:/$/,contains:[{scope:"variable",variants:[{match:a},{match:/`(?:\\.|[^`\\])+`/}],endsParent:!0}]},{scope:"doctag",match:/@[a-zA-Z]+/},{scope:"keyword",match:/\\[a-zA-Z]+/}]}),t.HASH_COMMENT_MODE,{scope:"string",contains:[t.BACKSLASH_ESCAPE],variants:[t.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\(/,end:/\)(-*)"/}),t.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\{/,end:/\}(-*)"/}),t.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\[/,end:/\](-*)"/}),t.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\(/,end:/\)(-*)'/}),t.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\{/,end:/\}(-*)'/}),t.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\[/,end:/\](-*)'/}),{begin:'"',end:'"',relevance:0},{begin:"'",end:"'",relevance:0}]},{relevance:0,variants:[{scope:{1:"operator",2:"number"},match:[i,r]},{scope:{1:"operator",2:"number"},match:[/%[^%]*%/,r]},{scope:{1:"punctuation",2:"number"},match:[o,r]},{scope:{2:"number"},match:[/[^a-zA-Z0-9._]|^/,r]}]},{scope:{3:"operator"},match:[a,/\s+/,/<-/,/\s+/]},{scope:"operator",relevance:0,variants:[{match:i},{match:/%[^%]*%/}]},{scope:"punctuation",relevance:0,match:o},{begin:"`",end:"`",contains:[{begin:/\\./}]}]}}return fc=e,fc}var Sc,Sg;function PN(){if(Sg)return Sc;Sg=1;function e(t){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},t.C_LINE_COMMENT_MODE,t.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},t.inherit(t.APOS_STRING_MODE,{scope:"string",relevance:0}),t.inherit(t.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 Sc=e,Sc}var bc,bg;function kN(){if(bg)return bc;bg=1;function e(t){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:/./},t.COMMENT("^#","$"),l,c,s,{begin:/[\w-]+=([^\s{}[\]()>]+)/,relevance:0,returnBegin:!0,contains:[{className:"attribute",begin:/[^=]+/},{begin:/=/,endsWithParent:!0,relevance:0,contains:[l,c,s,{className:"literal",begin:"\\b("+i.split(" ").join("|")+")\\b"},{begin:/("[^"]*"|[^\s{}[\]]+)/}]}]},{className:"number",begin:/\*[0-9a-fA-F]+/},{begin:"\\b("+r.split(" ").join("|")+")([\\s[(\\]|])",returnBegin:!0,contains:[{className:"built_in",begin:/\w+/}]},{className:"built_in",variants:[{begin:"(\\.\\./|/|\\s)(("+o.split(" ").join("|")+");?\\s)+"},{begin:/\.\./,relevance:0}]}]}}return hc=e,hc}var vc,vg;function BN(){if(vg)return vc;vg=1;function e(t){const n=["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"],a=["matrix","float","color","point","normal","vector"],r=["while","for","if","do","return","else","break","extern","continue"],i={match:[/(surface|displacement|light|volume|imager)/,/\s+/,t.IDENT_RE],scope:{1:"keyword",3:"title.class"}};return{name:"RenderMan RSL",keywords:{keyword:r,built_in:n,type:a},illegal:""},o]}}return Cc=e,Cc}var yc,yg;function $N(){if(yg)return yc;yg=1;function e(t){const n=t.regex,a=["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"],r=["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"],i=["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:a},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:"%"+n.either(...i)},{className:"title.function",begin:/%[a-zA-Z_][a-zA-Z_0-9]*/},{className:"meta",begin:n.either(...r)+"(?=\\()"},{className:"string",variants:[t.APOS_STRING_MODE,t.QUOTE_STRING_MODE]},t.COMMENT("\\*",";"),t.C_BLOCK_COMMENT_MODE]}}return yc=e,yc}var Nc,Ng;function qN(){if(Ng)return Nc;Ng=1;function e(t){const n=t.regex,a={className:"meta",begin:"@[A-Za-z]+"},r={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"},{begin:/\$\{/,end:/\}/}]},i={className:"string",variants:[{begin:'"""',end:'"""'},{begin:'"',end:'"',illegal:"\\n",contains:[t.BACKSLASH_ESCAPE]},{begin:'[a-z]+"',end:'"',illegal:"\\n",contains:[t.BACKSLASH_ESCAPE,r]},{className:"string",begin:'[a-z]+"""',end:'"""',contains:[r],relevance:10}]},o={className:"type",begin:"\\b[A-Z][A-Za-z0-9_]*",relevance:0},s={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:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{beginKeywords:"extends with",relevance:10},{begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[o,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[o,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]},s]},c={className:"function",beginKeywords:"def",end:n.lookahead(/[:={\[(\n;]/),contains:[s]},u={begin:[/^\s*/,"extension",/\s+(?=[[(])/],beginScope:{2:"keyword"}},d={begin:[/^\s*/,/end/,/\s+/,/(extension\b)?/],beginScope:{2:"keyword",4:"keyword"}},_=[{match:/\.inline\b/},{begin:/\binline(?=\s)/,keywords:"inline"}],m={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+/}]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,i,o,c,l,t.C_NUMBER_MODE,u,d,..._,m,a]}}return Nc=e,Nc}var Oc,Og;function HN(){if(Og)return Oc;Og=1;function e(t){const n="[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",a="(-|\\+)?\\d+([./]\\d+)?",r=a+"[+\\-]"+a+"i",i={$pattern:n,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?"},o={className:"literal",begin:"(#t|#f|#\\\\"+n+"|#\\\\.)"},s={className:"number",variants:[{begin:a,relevance:0},{begin:r,relevance:0},{begin:"#b[0-1]+(/[0-1]+)?"},{begin:"#o[0-7]+(/[0-7]+)?"},{begin:"#x[0-9a-f]+(/[0-9a-f]+)?"}]},l=t.QUOTE_STRING_MODE,c=[t.COMMENT(";","$",{relevance:0}),t.COMMENT("#\\|","\\|#")],u={begin:n,relevance:0},d={className:"symbol",begin:"'"+n},_={endsWithParent:!0,relevance:0},m={variants:[{begin:/'/},{begin:"`"}],contains:[{begin:"\\(",end:"\\)",contains:["self",o,l,s,u,d]}]},p={className:"name",relevance:0,begin:n,keywords:i},b={variants:[{begin:"\\(",end:"\\)"},{begin:"\\[",end:"\\]"}],contains:[{begin:/lambda/,endsWithParent:!0,returnBegin:!0,contains:[p,{endsParent:!0,variants:[{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/}],contains:[u]}]},p,_]};return _.contains=[o,s,l,u,d,m,b].concat(c),{name:"Scheme",aliases:["scm"],illegal:/\S/,contains:[t.SHEBANG(),s,l,d,m,b].concat(c)}}return Oc=e,Oc}var Ac,Ag;function VN(){if(Ag)return Ac;Ag=1;function e(t){const n=[t.C_NUMBER_MODE,{className:"string",begin:`'|"`,end:`'|"`,contains:[t.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:[t.UNDERSCORE_TITLE_MODE,{className:"params",begin:"\\(",end:"\\)"}]},{begin:"[a-zA-Z_][a-zA-Z_0-9]*[\\.']+",relevance:0},{begin:"\\[",end:"\\][\\.']*",relevance:0,contains:n},t.COMMENT("//","$")].concat(n)}}return Ac=e,Ac}var Ic,Ig;function zN(){if(Ig)return Ic;Ig=1;const e=c=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:c.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:[c.APOS_STRING_MODE,c.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:c.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_-]*/}}),t=["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"],n=["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"],a=[...t,...n],r=["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(),i=["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(),o=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),s=["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(c){const u=e(c),d=o,_=i,m="@[a-z-]+",p="and or not only",b={className:"variable",begin:"(\\$"+"[a-zA-Z-][a-zA-Z0-9_-]*"+")\\b",relevance:0};return{name:"SCSS",case_insensitive:!0,illegal:"[=/|']",contains:[c.C_LINE_COMMENT_MODE,c.C_BLOCK_COMMENT_MODE,u.CSS_NUMBER_MODE,{className:"selector-id",begin:"#[A-Za-z0-9_-]+",relevance:0},{className:"selector-class",begin:"\\.[A-Za-z0-9_-]+",relevance:0},u.ATTRIBUTE_SELECTOR_MODE,{className:"selector-tag",begin:"\\b("+a.join("|")+")\\b",relevance:0},{className:"selector-pseudo",begin:":("+_.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+d.join("|")+")"},b,{begin:/\(/,end:/\)/,contains:[u.CSS_NUMBER_MODE]},u.CSS_VARIABLE,{className:"attribute",begin:"\\b("+s.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:[u.BLOCK_COMMENT,b,u.HEXCOLOR,u.CSS_NUMBER_MODE,c.QUOTE_STRING_MODE,c.APOS_STRING_MODE,u.IMPORTANT,u.FUNCTION_DISPATCH]},{begin:"@(page|font-face)",keywords:{$pattern:m,keyword:"@page @font-face"}},{begin:"@",end:"[{;]",returnBegin:!0,keywords:{$pattern:/[a-z-]+/,keyword:p,attribute:r.join(" ")},contains:[{begin:m,className:"keyword"},{begin:/[a-z-]+(?=:)/,className:"attribute"},b,c.QUOTE_STRING_MODE,c.APOS_STRING_MODE,u.HEXCOLOR,u.CSS_NUMBER_MODE]},u.FUNCTION_DISPATCH]}}return Ic=l,Ic}var Dc,Dg;function WN(){if(Dg)return Dc;Dg=1;function e(t){return{name:"Shell Session",aliases:["console","shellsession"],contains:[{className:"meta.prompt",begin:/^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,starts:{end:/[^\\](?=\s*$)/,subLanguage:"bash"}}]}}return Dc=e,Dc}var xc,xg;function KN(){if(xg)return xc;xg=1;function e(t){const n=["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"],a=["aget","aput","array","check","execute","fill","filled","goto/16","goto/32","iget","instance","invoke","iput","monitor","packed","sget","sparse"],r=["transient","constructor","abstract","final","synthetic","public","private","protected","static","bridge","system"];return{name:"Smali",contains:[{className:"string",begin:'"',end:'"',relevance:0},t.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("+r.join("|")+")"}]},{className:"built_in",variants:[{begin:"\\s("+n.join("|")+")\\s"},{begin:"\\s("+n.join("|")+")((-|/)[a-zA-Z0-9]+)+\\s",relevance:10},{begin:"\\s("+a.join("|")+")((-|/)[a-zA-Z0-9]+)*\\s",relevance:10}]},{className:"class",begin:`L[^(;: -]*;`,relevance:0},{begin:"[vp][0-9]+"}]}}return xc=e,xc}var Mc,Mg;function QN(){if(Mg)return Mc;Mg=1;function e(t){const n="[a-z][a-zA-Z0-9_]*",a={className:"string",begin:"\\$.{1}"},r={className:"symbol",begin:"#"+t.UNDERSCORE_IDENT_RE};return{name:"Smalltalk",aliases:["st"],keywords:["self","super","nil","true","false","thisContext"],contains:[t.COMMENT('"','"'),t.APOS_STRING_MODE,{className:"type",begin:"\\b[A-Z][A-Za-z0-9_]*",relevance:0},{begin:n+":",relevance:0},t.C_NUMBER_MODE,r,a,{begin:"\\|[ ]*"+n+"([ ]+"+n+")*[ ]*\\|",returnBegin:!0,end:/\|/,illegal:/\S/,contains:[{begin:"(\\|[ ]*)?"+n}]},{begin:"#\\(",end:"\\)",contains:[t.APOS_STRING_MODE,a,t.C_NUMBER_MODE,r]}]}}return Mc=e,Mc}var wc,wg;function XN(){if(wg)return wc;wg=1;function e(t){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},t.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']*"},t.inherit(t.APOS_STRING_MODE,{className:"string",relevance:0}),t.inherit(t.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 wc=e,wc}var Lc,Lg;function ZN(){if(Lg)return Lc;Lg=1;function e(t){const n={className:"variable",begin:/\b_+[a-zA-Z]\w*/},a={className:"title",begin:/[a-zA-Z][a-zA-Z_0-9]*_fnc_[a-zA-Z_0-9]+/},r={className:"string",variants:[{begin:'"',end:'"',contains:[{begin:'""',relevance:0}]},{begin:"'",end:"'",contains:[{begin:"''",relevance:0}]}]},i=["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"],o=["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"],s=["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},t.inherit(r,{className:"string"}),{begin:/<[^\n>]*>/,end:/$/,illegal:"\\n"},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]};return{name:"SQF",case_insensitive:!0,keywords:{keyword:i,built_in:s,literal:o},contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.NUMBER_MODE,n,a,r,l],illegal:[/\$[^a-fA-F0-9]/,/\w\$/,/\?/,/@/,/ \| /,/[a-zA-Z_]\./,/\:\=/,/\[\:/]}}return Lc=e,Lc}var Pc,Pg;function JN(){if(Pg)return Pc;Pg=1;function e(t){const n=t.regex,a=t.COMMENT("--","$"),r={scope:"string",variants:[{begin:/'/,end:/'/,contains:[{match:/''/}]}]},i={begin:/"/,end:/"/,contains:[{match:/""/}]},o=["true","false","unknown"],s=["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"],c=["add","asc","collation","desc","final","first","last","view"],u=["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"],d=["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"],_=["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"],m=["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"],p=d,g=[...u,...c].filter(T=>!d.includes(T)),b={scope:"variable",match:/@[a-z0-9][a-z0-9_]*/},A={scope:"operator",match:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,relevance:0},O={match:n.concat(/\b/,n.either(...p),/\s*\(/),relevance:0,keywords:{built_in:p}};function M(T){return n.concat(/\b/,n.either(...T.map(I=>I.replace(/\s+/,"\\s+"))),/\b/)}const w={scope:"keyword",match:M(m),relevance:0};function v(T,{exceptions:I,when:h}={}){const E=h;return I=I||[],T.map(D=>D.match(/\|\d+$/)||I.includes(D)?D:E(D)?`${D}|0`:D)}return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{$pattern:/\b[\w\.]+/,keyword:v(g,{when:T=>T.length<3}),literal:o,type:l,built_in:_},contains:[{scope:"type",match:M(s)},w,O,b,r,i,t.C_NUMBER_MODE,t.C_BLOCK_COMMENT_MODE,a,A]}}return Pc=e,Pc}var kc,kg;function jN(){if(kg)return kc;kg=1;function e(t){const n=t.regex,a=["functions","model","data","parameters","quantities","transformed","generated"],r=["for","in","if","else","while","break","continue","return"],i=["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"],o=["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"],s=["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=t.COMMENT(/\/\*/,/\*\//,{relevance:0,contains:[{scope:"doctag",match:/@(return|param)/}]}),c={scope:"meta",begin:/#include\b/,end:/$/,contains:[{match:/[a-z][a-z-._]+/,scope:"string"},t.C_LINE_COMMENT_MODE]},u=["lower","upper","offset","multiplier"];return{name:"Stan",aliases:["stanfuncs"],keywords:{$pattern:t.IDENT_RE,title:a,type:i,keyword:r,built_in:o},contains:[t.C_LINE_COMMENT_MODE,c,t.HASH_COMMENT_MODE,l,{scope:"built_in",match:/\s(pi|e|sqrt2|log2|log10)(?=\()/,relevance:0},{match:n.concat(/[<,]\s*/,n.either(...u),/\s*=/),keywords:u},{scope:"keyword",match:/\btarget(?=\s*\+=)/},{match:[/~\s*/,n.either(...s),/(?:\(\))/,/\s*T(?=\s*\[)/],scope:{2:"built_in",4:"keyword"}},{scope:"built_in",keywords:s,begin:n.concat(/\w*/,n.either(...s),/(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/)},{begin:[/~/,/\s*/,n.concat(n.either(...s),/(?=\s*[\(.*\)])/)],scope:{3:"built_in"}},{begin:[/~/,/\s*\w+(?=\s*[\(.*\)])/,"(?!.*/\b("+n.either(...s)+")\b)"],scope:{2:"title.function"}},{scope:"title.function",begin:/\w*(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/},{scope:"number",match:n.concat(/(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)/,/(?:[eE][+-]?\d+(?:_\d+)*)?i?(?!\w)/),relevance:0},{scope:"string",begin:/"/,end:/"/}]}}return kc=e,kc}var Uc,Ug;function eO(){if(Ug)return Uc;Ug=1;function e(t){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)(?=\\()"}]},t.COMMENT("^[ ]*\\*.*$",!1),t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE]}}return Uc=e,Uc}var Fc,Fg;function tO(){if(Fg)return Fc;Fg=1;function e(t){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},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,t.COMMENT("/\\*\\*!","\\*/"),t.C_NUMBER_MODE,t.inherit(t.APOS_STRING_MODE,{illegal:null}),t.inherit(t.QUOTE_STRING_MODE,{illegal:null}),{className:"string",begin:"'",end:"'"},{className:"symbol",variants:[{begin:"#",end:"\\d+",illegal:"\\W"}]}]}}return Fc=e,Fc}var Bc,Bg;function nO(){if(Bg)return Bc;Bg=1;const e=c=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:c.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:[c.APOS_STRING_MODE,c.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:c.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_-]*/}}),t=["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"],n=["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"],a=[...t,...n],r=["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(),i=["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(),o=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"].sort().reverse(),s=["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(c){const u=e(c),d="and or not only",_={className:"variable",begin:"\\$"+c.IDENT_RE},m=["charset","css","debug","extend","font-face","for","import","include","keyframes","media","mixin","page","warn","while"],p="(?=[.\\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:[c.QUOTE_STRING_MODE,c.APOS_STRING_MODE,c.C_LINE_COMMENT_MODE,c.C_BLOCK_COMMENT_MODE,u.HEXCOLOR,{begin:"\\.[a-zA-Z][a-zA-Z0-9_-]*"+p,className:"selector-class"},{begin:"#[a-zA-Z][a-zA-Z0-9_-]*"+p,className:"selector-id"},{begin:"\\b("+a.join("|")+")"+p,className:"selector-tag"},{className:"selector-pseudo",begin:"&?:("+i.join("|")+")"+p},{className:"selector-pseudo",begin:"&?:(:)?("+o.join("|")+")"+p},u.ATTRIBUTE_SELECTOR_MODE,{className:"keyword",begin:/@media/,starts:{end:/[{;}]/,keywords:{$pattern:/[a-z-]+/,keyword:d,attribute:r.join(" ")},contains:[u.CSS_NUMBER_MODE]}},{className:"keyword",begin:"@((-(o|moz|ms|webkit)-)?("+m.join("|")+"))\\b"},_,u.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:[u.HEXCOLOR,_,c.APOS_STRING_MODE,u.CSS_NUMBER_MODE,c.QUOTE_STRING_MODE]}]},u.CSS_VARIABLE,{className:"attribute",begin:"\\b("+s.join("|")+")\\b",starts:{end:/;|$/,contains:[u.HEXCOLOR,_,c.APOS_STRING_MODE,c.QUOTE_STRING_MODE,u.CSS_NUMBER_MODE,c.C_BLOCK_COMMENT_MODE,u.IMPORTANT,u.FUNCTION_DISPATCH],illegal:/\./,relevance:0}},u.FUNCTION_DISPATCH]}}return Bc=l,Bc}var Gc,Gg;function aO(){if(Gg)return Gc;Gg=1;function e(t){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 Gc=e,Gc}var Yc,Yg;function rO(){if(Yg)return Yc;Yg=1;function e(h){return h?typeof h=="string"?h:h.source:null}function t(h){return n("(?=",h,")")}function n(...h){return h.map(D=>e(D)).join("")}function a(h){const E=h[h.length-1];return typeof E=="object"&&E.constructor===Object?(h.splice(h.length-1,1),E):{}}function r(...h){return"("+(a(h).capture?"":"?:")+h.map(x=>e(x)).join("|")+")"}const i=h=>n(/\b/,h,/\w$/.test(h)?/\b/:/\B/),o=["Protocol","Type"].map(i),s=["init","self"].map(i),l=["Any","Self"],c=["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"],u=["false","nil","true"],d=["assignment","associativity","higherThan","left","lowerThan","none","right"],_=["#colorLiteral","#column","#dsohandle","#else","#elseif","#endif","#error","#file","#fileID","#fileLiteral","#filePath","#function","#if","#imageLiteral","#keyPath","#line","#selector","#sourceLocation","#warning"],m=["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"],p=r(/[/=\-+!*%<>&|^~?]/,/[\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]/),g=r(p,/[\u0300-\u036F]/,/[\u1DC0-\u1DFF]/,/[\u20D0-\u20FF]/,/[\uFE00-\uFE0F]/,/[\uFE20-\uFE2F]/),b=n(p,g,"*"),A=r(/[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]/),O=r(A,/\d/,/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),M=n(A,O,"*"),w=n(/[A-Z]/,O,"*"),v=["attached","autoclosure",n(/convention\(/,r("swift","block","c"),/\)/),"discardableResult","dynamicCallable","dynamicMemberLookup","escaping","freestanding","frozen","GKInspectable","IBAction","IBDesignable","IBInspectable","IBOutlet","IBSegueAction","inlinable","main","nonobjc","NSApplicationMain","NSCopying","NSManaged",n(/objc\(/,M,/\)/),"objc","objcMembers","propertyWrapper","requires_stored_property_inits","resultBuilder","Sendable","testable","UIApplicationMain","unchecked","unknown","usableFromInline","warn_unqualified_access"],T=["iOS","iOSApplicationExtension","macOS","macOSApplicationExtension","macCatalyst","macCatalystApplicationExtension","watchOS","watchOSApplicationExtension","tvOS","tvOSApplicationExtension","swift"];function I(h){const E={match:/\s+/,relevance:0},D=h.COMMENT("/\\*","\\*/",{contains:["self"]}),x=[h.C_LINE_COMMENT_MODE,D],L={match:[/\./,r(...o,...s)],className:{2:"keyword"}},ae={match:n(/\./,r(...c)),relevance:0},Ee=c.filter(Fe=>typeof Fe=="string").concat(["_|0"]),xe=c.filter(Fe=>typeof Fe!="string").concat(l).map(i),Se={variants:[{className:"keyword",match:r(...xe,...s)}]},pe={$pattern:r(/\b\w+/,/#\w+/),keyword:Ee.concat(_),literal:u},Le=[L,ae,Se],be={match:n(/\./,r(...m)),relevance:0},Xe={className:"built_in",match:n(/\b/,r(...m),/(?=\()/)},et=[be,Xe],it={match:/->/,relevance:0},St={className:"operator",relevance:0,variants:[{match:b},{match:`\\.(\\.|${g})+`}]},Ot=[it,St],qe="([0-9]_*)+",lt="([0-9a-fA-F]_*)+",V={className:"number",relevance:0,variants:[{match:`\\b(${qe})(\\.(${qe}))?([eE][+-]?(${qe}))?\\b`},{match:`\\b0x(${lt})(\\.(${lt}))?([pP][+-]?(${qe}))?\\b`},{match:/\b0o([0-7]_*)+\b/},{match:/\b0b([01]_*)+\b/}]},te=(Fe="")=>({className:"subst",variants:[{match:n(/\\/,Fe,/[0\\tnr"']/)},{match:n(/\\/,Fe,/u\{[0-9a-fA-F]{1,8}\}/)}]}),ve=(Fe="")=>({className:"subst",match:n(/\\/,Fe,/[\t ]*(?:[\r\n]|\r\n)/)}),Ie=(Fe="")=>({className:"subst",label:"interpol",begin:n(/\\/,Fe,/\(/),end:/\)/}),Be=(Fe="")=>({begin:n(Fe,/"""/),end:n(/"""/,Fe),contains:[te(Fe),ve(Fe),Ie(Fe)]}),R=(Fe="")=>({begin:n(Fe,/"/),end:n(/"/,Fe),contains:[te(Fe),Ie(Fe)]}),k={className:"string",variants:[Be(),Be("#"),Be("##"),Be("###"),R(),R("#"),R("##"),R("###")]},z=[h.BACKSLASH_ESCAPE,{begin:/\[/,end:/\]/,relevance:0,contains:[h.BACKSLASH_ESCAPE]}],K={begin:/\/[^\s](?=[^/\n]*\/)/,end:/\//,contains:z},ee=Fe=>{const ct=n(Fe,/\//),at=n(/\//,Fe);return{begin:ct,end:at,contains:[...z,{scope:"comment",begin:`#(?!.*${at})`,end:/$/}]}},X={scope:"regexp",variants:[ee("###"),ee("##"),ee("#"),K]},_e={match:n(/`/,M,/`/)},oe={className:"variable",match:/\$\d+/},le={className:"variable",match:`\\$${O}+`},re=[_e,oe,le],Me={match:/(@|#(un)?)available/,scope:"keyword",starts:{contains:[{begin:/\(/,end:/\)/,keywords:T,contains:[...Ot,V,k]}]}},Ce={scope:"keyword",match:n(/@/,r(...v),t(r(/\(/,/\s+/)))},Re={scope:"meta",match:n(/@/,M)},Pe=[Me,Ce,Re],Ve={match:t(/\b[A-Z]/),relevance:0,contains:[{className:"type",match:n(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,O,"+")},{className:"type",match:w,relevance:0},{match:/[?!]+/,relevance:0},{match:/\.\.\./,relevance:0},{match:n(/\s+&\s+/,t(w)),relevance:0}]},Ke={begin://,keywords:pe,contains:[...x,...Le,...Pe,it,Ve]};Ve.contains.push(Ke);const y={match:n(M,/\s*:/),keywords:"_|0",relevance:0},B={begin:/\(/,end:/\)/,relevance:0,keywords:pe,contains:["self",y,...x,X,...Le,...et,...Ot,V,k,...re,...Pe,Ve]},W={begin://,keywords:"repeat each",contains:[...x,Ve]},Y={begin:r(t(n(M,/\s*:/)),t(n(M,/\s+/,M,/\s*:/))),end:/:/,relevance:0,contains:[{className:"keyword",match:/\b_\b/},{className:"params",match:M}]},q={begin:/\(/,end:/\)/,keywords:pe,contains:[Y,...x,...Le,...Ot,V,k,...Pe,Ve,B],endsParent:!0,illegal:/["']/},ne={match:[/(func|macro)/,/\s+/,r(_e.match,M,b)],className:{1:"keyword",3:"title.function"},contains:[W,q,E],illegal:[/\[/,/%/]},de={match:[/\b(?:subscript|init[?!]?)/,/\s*(?=[<(])/],className:{1:"keyword"},contains:[W,q,E],illegal:/\[|%/},fe={match:[/operator/,/\s+/,b],className:{1:"keyword",3:"title"}},ye={begin:[/precedencegroup/,/\s+/,w],className:{1:"keyword",3:"title"},contains:[Ve],keywords:[...d,...u],end:/}/},Ue={match:[/class\b/,/\s+/,/func\b/,/\s+/,/\b[A-Za-z_][A-Za-z0-9_]*\b/],scope:{1:"keyword",3:"keyword",5:"title.function"}},tt={match:[/class\b/,/\s+/,/var\b/],scope:{1:"keyword",3:"keyword"}},Rt={begin:[/(struct|protocol|class|extension|enum|actor)/,/\s+/,M,/\s*/],beginScope:{1:"keyword",3:"title.class"},keywords:pe,contains:[W,...Le,{begin:/:/,end:/\{/,keywords:pe,contains:[{scope:"title.class.inherited",match:w},...Le],relevance:0}]};for(const Fe of k.variants){const ct=Fe.contains.find(ze=>ze.label==="interpol");ct.keywords=pe;const at=[...Le,...et,...Ot,V,k,...re];ct.contains=[...at,{begin:/\(/,end:/\)/,contains:["self",...at]}]}return{name:"Swift",keywords:pe,contains:[...x,ne,de,Ue,tt,Rt,fe,ye,{beginKeywords:"import",end:/$/,contains:[...x],relevance:0},X,...Le,...et,...Ot,V,k,...re,...Pe,Ve,B]}}return Yc=I,Yc}var $c,$g;function iO(){if($g)return $c;$g=1;function e(t){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 $c=e,$c}var qc,qg;function oO(){if(qg)return qc;qg=1;function e(t){const n="true false yes no null",a="[\\w#;/?:@&=+$,.~*'()[\\]]+",r={className:"attr",variants:[{begin:/[\w*@][\w*@ :()\./-]*:(?=[ \t]|$)/},{begin:/"[\w*@][\w*@ :()\./-]*":(?=[ \t]|$)/},{begin:/'[\w*@][\w*@ :()\./-]*':(?=[ \t]|$)/}]},i={className:"template-variable",variants:[{begin:/\{\{/,end:/\}\}/},{begin:/%\{/,end:/\}/}]},o={className:"string",relevance:0,begin:/'/,end:/'/,contains:[{match:/''/,scope:"char.escape",relevance:0}]},s={className:"string",relevance:0,variants:[{begin:/"/,end:/"/},{begin:/\S+/}],contains:[t.BACKSLASH_ESCAPE,i]},l=t.inherit(s,{variants:[{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),m={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"},p={end:",",endsWithParent:!0,excludeEnd:!0,keywords:n,relevance:0},g={begin:/\{/,end:/\}/,contains:[p],illegal:"\\n",relevance:0},b={begin:"\\[",end:"\\]",contains:[p],illegal:"\\n",relevance:0},A=[r,{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+!"+a},{className:"type",begin:"!<"+a+">"},{className:"type",begin:"!"+a},{className:"type",begin:"!!"+a},{className:"meta",begin:"&"+t.UNDERSCORE_IDENT_RE+"$"},{className:"meta",begin:"\\*"+t.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",relevance:0},t.HASH_COMMENT_MODE,{beginKeywords:n,keywords:{literal:n}},m,{className:"number",begin:t.C_NUMBER_RE+"\\b",relevance:0},g,b,o,s],O=[...A];return O.pop(),O.push(l),p.contains=O,{name:"YAML",case_insensitive:!0,aliases:["yml"],contains:A}}return qc=e,qc}var Hc,Hg;function sO(){if(Hg)return Hc;Hg=1;function e(t){return{name:"Test Anything Protocol",case_insensitive:!0,contains:[t.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 Hc=e,Hc}var Vc,Vg;function lO(){if(Vg)return Vc;Vg=1;function e(t){const n=t.regex,a=/[a-zA-Z_][a-zA-Z0-9_]*/,r={className:"number",variants:[t.BINARY_NUMBER_MODE,t.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:[t.COMMENT(";[ \\t]*#","$"),t.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:n.concat(/\$/,n.optional(/::/),a,"(::",a,")*")},{begin:"\\$\\{(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",end:"\\}",contains:[r]}]},{className:"string",contains:[t.BACKSLASH_ESCAPE],variants:[t.inherit(t.QUOTE_STRING_MODE,{illegal:null})]},r]}}return Vc=e,Vc}var zc,zg;function cO(){if(zg)return zc;zg=1;function e(t){const n=["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:n,literal:"true false"},contains:[t.QUOTE_STRING_MODE,t.NUMBER_MODE,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"class",beginKeywords:"struct enum service exception",end:/\{/,illegal:/\n/,contains:[t.inherit(t.TITLE_MODE,{starts:{endsWithParent:!0,excludeEnd:!0}})]},{begin:"\\b(set|list|map)\\s*<",keywords:{type:[...n,"set","list","map"]},end:">",contains:["self"]}]}}return zc=e,zc}var Wc,Wg;function uO(){if(Wg)return Wc;Wg=1;function e(t){const n={className:"number",begin:"[1-9][0-9]*",relevance:0},a={className:"symbol",begin:":[^\\]]+"},r={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",n,a]},i={className:"built_in",begin:"(AI|AO|DI|DO|F|RI|RO|UI|UO|GI|GO|SI|SO)\\[",end:"\\]",contains:["self",n,t.QUOTE_STRING_MODE,a]};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:[r,i,{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},t.COMMENT("//","[;$]"),t.COMMENT("!","[;$]"),t.COMMENT("--eg:","$"),t.QUOTE_STRING_MODE,{className:"string",begin:"'",end:"'"},t.C_NUMBER_MODE,{className:"variable",begin:"\\$[A-Za-z0-9_]+"}]}}return Wc=e,Wc}var Kc,Kg;function dO(){if(Kg)return Kc;Kg=1;function e(t){const n=t.regex,a=["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"],r=["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 i=["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"];i=i.concat(i.map(g=>`end${g}`));const o={scope:"string",variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]},s={scope:"number",match:/\d+/},l={begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:[o,s]},c={beginKeywords:a.join(" "),keywords:{name:a},relevance:0,contains:[l]},u={match:/\|(?=[A-Za-z_]+:?)/,beginScope:"punctuation",relevance:0,contains:[{match:/[A-Za-z_]+:?/,keywords:r}]},d=(g,{relevance:b})=>({beginScope:{1:"template-tag",3:"name"},relevance:b||2,endScope:"template-tag",begin:[/\{%/,/\s*/,n.either(...g)],end:/%\}/,keywords:"in",contains:[u,c,o,s]}),_=/[a-z_]+/,m=d(i,{relevance:2}),p=d([_],{relevance:1});return{name:"Twig",aliases:["craftcms"],case_insensitive:!0,subLanguage:"xml",contains:[t.COMMENT(/\{#/,/#\}/),m,p,{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:["self",u,c,o,s]}]}}return Kc=e,Kc}var Qc,Qg;function _O(){if(Qg)return Qc;Qg=1;const e="[A-Za-z$_][0-9A-Za-z$_]*",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"],n=["true","false","null","undefined","NaN","Infinity"],a=["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"],r=["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"],o=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],s=[].concat(i,a,r);function l(u){const d=u.regex,_=(te,{after:ve})=>{const Ie="",end:""},g=/<[A-Za-z0-9\\._:-]+\s*\/>/,b={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(te,ve)=>{const Ie=te[0].length+te.index,Be=te.input[Ie];if(Be==="<"||Be===","){ve.ignoreMatch();return}Be===">"&&(_(te,{after:Ie})||ve.ignoreMatch());let R;const k=te.input.substring(Ie);if(R=k.match(/^\s*=/)){ve.ignoreMatch();return}if((R=k.match(/^\s+extends\s+/))&&R.index===0){ve.ignoreMatch();return}}},A={$pattern:e,keyword:t,literal:n,built_in:s,"variable.language":o},O="[0-9](_?[0-9])*",M=`\\.(${O})`,w="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",v={className:"number",variants:[{begin:`(\\b(${w})((${M})|\\.)?|(${M}))[eE][+-]?(${O})\\b`},{begin:`\\b(${w})\\b((${M})\\b|\\.)?|(${M})\\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:A,contains:[]},I={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"xml"}},h={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"css"}},E={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,T],subLanguage:"graphql"}},D={className:"string",begin:"`",end:"`",contains:[u.BACKSLASH_ESCAPE,T]},L={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:m+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),u.C_BLOCK_COMMENT_MODE,u.C_LINE_COMMENT_MODE]},ae=[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,I,h,E,D,{match:/\$\d+/},v];T.contains=ae.concat({begin:/\{/,end:/\}/,keywords:A,contains:["self"].concat(ae)});const Ee=[].concat(L,T.contains),xe=Ee.concat([{begin:/(\s*)\(/,end:/\)/,keywords:A,contains:["self"].concat(Ee)}]),Se={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:A,contains:xe},pe={variants:[{match:[/class/,/\s+/,m,/\s+/,/extends/,/\s+/,d.concat(m,"(",d.concat(/\./,m),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,m],scope:{1:"keyword",3:"title.class"}}]},Le={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:{_:[...a,...r]}},be={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},Xe={variants:[{match:[/function/,/\s+/,m,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[Se],illegal:/%/},et={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function it(te){return d.concat("(?!",te.join("|"),")")}const St={match:d.concat(/\b/,it([...i,"super","import"].map(te=>`${te}\\s*\\(`)),m,d.lookahead(/\s*\(/)),className:"title.function",relevance:0},Ot={begin:d.concat(/\./,d.lookahead(d.concat(m,/(?![0-9A-Za-z$_(])/))),end:m,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},qe={match:[/get|set/,/\s+/,m,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},Se]},lt="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+u.UNDERSCORE_IDENT_RE+")\\s*=>",V={match:[/const|var|let/,/\s+/,m,/\s*/,/=\s*/,/(async\s*)?/,d.lookahead(lt)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[Se]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:A,exports:{PARAMS_CONTAINS:xe,CLASS_REFERENCE:Le},illegal:/#(?![$_A-z])/,contains:[u.SHEBANG({label:"shebang",binary:"node",relevance:5}),be,u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,I,h,E,D,L,{match:/\$\d+/},v,Le,{scope:"attr",match:m+d.lookahead(":"),relevance:0},V,{begin:"("+u.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[L,u.REGEXP_MODE,{className:"function",begin:lt,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:A,contains:xe}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:p.begin,end:p.end},{match:g},{begin:b.begin,"on:begin":b.isTrulyOpeningTag,end:b.end}],subLanguage:"xml",contains:[{begin:b.begin,end:b.end,skip:!0,contains:["self"]}]}]},Xe,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+u.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[Se,u.inherit(u.TITLE_MODE,{begin:m,className:"title.function"})]},{match:/\.\.\./,relevance:0},Ot,{match:"\\$"+m,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[Se]},St,et,pe,qe,{match:/\$[(.]/}]}}function c(u){const d=u.regex,_=l(u),m=e,p=["any","void","number","boolean","string","object","never","symbol","bigint","unknown"],g={begin:[/namespace/,/\s+/,u.IDENT_RE],beginScope:{1:"keyword",3:"title.class"}},b={beginKeywords:"interface",end:/\{/,excludeEnd:!0,keywords:{keyword:"interface extends",built_in:p},contains:[_.exports.CLASS_REFERENCE]},A={className:"meta",relevance:10,begin:/^\s*['"]use strict['"]/},O=["type","interface","public","private","protected","implements","declare","abstract","readonly","enum","override","satisfies"],M={$pattern:e,keyword:t.concat(O),literal:n,built_in:s.concat(p),"variable.language":o},w={className:"meta",begin:"@"+m},v=(E,D,x)=>{const L=E.contains.findIndex(ae=>ae.label===D);if(L===-1)throw new Error("can not find mode to replace");E.contains.splice(L,1,x)};Object.assign(_.keywords,M),_.exports.PARAMS_CONTAINS.push(w);const T=_.contains.find(E=>E.scope==="attr"),I=Object.assign({},T,{match:d.concat(m,d.lookahead(/\s*\?:/))});_.exports.PARAMS_CONTAINS.push([_.exports.CLASS_REFERENCE,T,I]),_.contains=_.contains.concat([w,g,b,I]),v(_,"shebang",u.SHEBANG()),v(_,"use_strict",A);const h=_.contains.find(E=>E.label==="func.def");return h.relevance=0,Object.assign(_,{name:"TypeScript",aliases:["ts","tsx","mts","cts"]}),_}return Qc=c,Qc}var Xc,Xg;function pO(){if(Xg)return Xc;Xg=1;function e(t){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:[t.UNDERSCORE_TITLE_MODE]},t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,{className:"string",begin:'"""',end:'"""',relevance:5},t.APOS_STRING_MODE,t.QUOTE_STRING_MODE,t.C_NUMBER_MODE,{className:"meta",begin:"^#",end:"$"}]}}return Xc=e,Xc}var Zc,Zg;function mO(){if(Zg)return Zc;Zg=1;function e(t){const n=t.regex,a={className:"string",begin:/"(""|[^/n])"C\b/},r={className:"string",begin:/"/,end:/"/,illegal:/\n/,contains:[{begin:/""/}]},i=/\d{1,2}\/\d{1,2}\/\d{4}/,o=/\d{4}-\d{1,2}-\d{1,2}/,s=/(\d|1[012])(:\d+){0,2} *(AM|PM)/,l=/\d{1,2}(:\d{1,2}){1,2}/,c={className:"literal",variants:[{begin:n.concat(/# */,n.either(o,i),/ *#/)},{begin:n.concat(/# */,l,/ *#/)},{begin:n.concat(/# */,s,/ *#/)},{begin:n.concat(/# */,n.either(o,i),/ +/,n.either(s,l),/ *#/)}]},u={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])|[%&])?/}]},d={className:"label",begin:/^\w+:/},_=t.COMMENT(/'''/,/$/,{contains:[{className:"doctag",begin:/<\/?/,end:/>/}]}),m=t.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:[a,r,c,u,d,_,m,{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:[m]}]}}return Zc=e,Zc}var Jc,Jg;function gO(){if(Jg)return Jc;Jg=1;function e(t){const n=t.regex,a=["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"],r=["server","response","request","scriptengine","scriptenginebuildversion","scriptengineminorversion","scriptenginemajorversion"],i={begin:n.concat(n.either(...a),"\\s*\\("),relevance:0,keywords:{built_in:a}};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:r,literal:["true","false","null","nothing","empty"]},illegal:"//",contains:[i,t.inherit(t.QUOTE_STRING_MODE,{contains:[{begin:'""'}]}),t.COMMENT(/'/,/$/,{relevance:0}),t.C_NUMBER_MODE]}}return Jc=e,Jc}var jc,jg;function EO(){if(jg)return jc;jg=1;function e(t){return{name:"VBScript in HTML",subLanguage:"xml",contains:[{begin:"<%",end:"%>",subLanguage:"vbscript"}]}}return jc=e,jc}var eu,eE;function fO(){if(eE)return eu;eE=1;function e(t){const n=t.regex,a={$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"]},r=["__FILE__","__LINE__"],i=["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:a,contains:[t.C_BLOCK_COMMENT_MODE,t.C_LINE_COMMENT_MODE,t.QUOTE_STRING_MODE,{scope:"number",contains:[t.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:n.concat(/`/,n.either(...r))},{scope:"meta",begin:n.concat(/`/,n.either(...i)),end:/$|\/\/|\/\*/,returnEnd:!0,keywords:i}]}}return eu=e,eu}var tu,tE;function SO(){if(tE)return tu;tE=1;function e(t){const n="\\d(_|\\d)*",a="[eE][-+]?"+n,r=n+"(\\."+n+")?("+a+")?",i="\\w+",s="\\b("+(n+"#"+i+"(\\."+i+")?#("+a+")?")+"|"+r+")";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:[t.C_BLOCK_COMMENT_MODE,t.COMMENT("--","$"),t.QUOTE_STRING_MODE,{className:"number",begin:s,relevance:0},{className:"string",begin:"'(U|X|0|1|Z|W|L|H|-)'",contains:[t.BACKSLASH_ESCAPE]},{className:"symbol",begin:"'[A-Za-z](_?[A-Za-z0-9])*",contains:[t.BACKSLASH_ESCAPE]}]}}return tu=e,tu}var nu,nE;function bO(){if(nE)return nu;nE=1;function e(t){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:[t.NUMBER_MODE,{className:"string",begin:"'",end:"'",illegal:"\\n"},{className:"string",begin:/"(\\"|\n\\|[^"\n])*"/},t.COMMENT('"',"$"),{className:"variable",begin:/[bwtglsav]:[\w\d_]+/},{begin:[/\b(?:function|function!)/,/\s+/,t.IDENT_RE],className:{1:"keyword",3:"title"},end:"$",relevance:0,contains:[{className:"params",begin:"\\(",end:"\\)"}]},{className:"symbol",begin:/<[\w-]+>/}]}}return nu=e,nu}var au,aE;function TO(){if(aE)return au;aE=1;function e(t){t.regex;const n=t.COMMENT(/\(;/,/;\)/);n.contains.push("self");const a=t.COMMENT(/;;/,/$/),r=["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"],i={begin:[/(?:func|call|call_indirect)/,/\s+/,/\$[^\s)]+/],className:{1:"keyword",3:"title.function"}},o={className:"variable",begin:/\$[\w_]+/},s={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/},c={match:/(i32|i64|f32|f64)(?!\.)/,className:"type"},u={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:r},contains:[a,n,{match:[/(?:offset|align)/,/\s*/,/=/],className:{1:"keyword",3:"operator"}},o,s,i,t.QUOTE_STRING_MODE,c,u,l]}}return au=e,au}var ru,rE;function hO(){if(rE)return ru;rE=1;function e(t){const n=t.regex,a=/[a-zA-Z]\w*/,r=["as","break","class","construct","continue","else","for","foreign","if","import","in","is","return","static","var","while"],i=["true","false","null"],o=["this","super"],s=["Bool","Class","Fiber","Fn","List","Map","Null","Num","Object","Range","Sequence","String","System"],l=["-","~",/\*/,"%",/\.\.\./,/\.\./,/\+/,"<<",">>",">=","<=","<",">",/\^/,/!=/,/!/,/\bis\b/,"==","&&","&",/\|\|/,/\|/,/\?:/,"="],c={relevance:0,match:n.concat(/\b(?!(if|while|for|else|super)\b)/,a,/(?=\s*[({])/),className:"title.function"},u={match:n.concat(n.either(n.concat(/\b(?!(if|while|for|else|super)\b)/,a),n.either(...l)),/(?=\s*\([^)]+\)\s*\{)/),className:"title.function",starts:{contains:[{begin:/\(/,end:/\)/,contains:[{relevance:0,scope:"params",match:a}]}]}},d={variants:[{match:[/class\s+/,a,/\s+is\s+/,a]},{match:[/class\s+/,a]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:r},_={relevance:0,match:n.either(...l),className:"operator"},m={className:"string",begin:/"""/,end:/"""/},p={className:"property",begin:n.concat(/\./,n.lookahead(a)),end:a,excludeBegin:!0,relevance:0},g={relevance:0,match:n.concat(/\b_/,a),scope:"variable"},b={relevance:0,match:/\b[A-Z]+[a-z]+([A-Z]+[a-z]+)*/,scope:"title.class",keywords:{_:s}},A=t.C_NUMBER_MODE,O={match:[a,/\s*/,/=/,/\s*/,/\(/,a,/\)\s*\{/],scope:{1:"title.function",3:"operator",6:"params"}},M=t.COMMENT(/\/\*\*/,/\*\//,{contains:[{match:/@[a-z]+/,scope:"doctag"},"self"]}),w={scope:"subst",begin:/%\(/,end:/\)/,contains:[A,b,c,g,_]},v={scope:"string",begin:/"/,end:/"/,contains:[w,{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}/}]}]};w.contains.push(v);const T=[...r,...o,...i],I={relevance:0,match:n.concat("\\b(?!",T.join("|"),"\\b)",/[a-zA-Z_]\w*(?:[?!]|\b)/),className:"variable"};return{name:"Wren",keywords:{keyword:r,"variable.language":o,literal:i},contains:[{scope:"comment",variants:[{begin:[/#!?/,/[A-Za-z_]+(?=\()/],beginScope:{},keywords:{literal:i},contains:[],end:/\)/},{begin:[/#!?/,/[A-Za-z_]+/],beginScope:{},end:/$/}]},A,v,m,M,t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,b,d,O,u,c,_,g,p,I]}}return ru=e,ru}var iu,iE;function vO(){if(iE)return iu;iE=1;function e(t){return{name:"Intel x86 Assembly",case_insensitive:!0,keywords:{$pattern:"[.%]?"+t.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:[t.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"}]},t.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 iu=e,iu}var ou,oE;function RO(){if(oE)return ou;oE=1;function e(t){const n=["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"],a=["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"],r=["ObjectLoader","Animate","MovieCredits","Slides","Filters","Shading","Materials","LensFlare","Mapping","VLCAudioVideo","StereoDecoder","PointCloud","NetworkAccess","RemoteControl","RegExp","ChromaKey","Snowfall","NodeJS","Speech","Charts"],o={$pattern:/[a-zA-Z][a-zA-Z0-9_?]*/,keyword:n,literal:["true","false","nil"],built_in:a.concat(r)},s={className:"string",begin:'"',end:'"',illegal:"\\n"},l={className:"string",begin:"'",end:"'",illegal:"\\n"},c={className:"string",begin:"<<",end:">>"},u={className:"number",begin:"[0-9]+#[0-9A-Z_]+(\\.[0-9-A-Z_]+)?#?([Ee][+-]?[0-9]+)?"},d={beginKeywords:"import",end:"$",keywords:o,contains:[s]},_={className:"function",begin:/[a-z][^\n]*->/,returnBegin:!0,end:/->/,contains:[t.inherit(t.TITLE_MODE,{starts:{endsWithParent:!0,keywords:o}})]};return{name:"XL",aliases:["tao"],keywords:o,contains:[t.C_LINE_COMMENT_MODE,t.C_BLOCK_COMMENT_MODE,s,l,c,_,d,u,t.NUMBER_MODE]}}return ou=e,ou}var su,sE;function CO(){if(sE)return su;sE=1;function e(t){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 su=e,su}var lu,lE;function yO(){if(lE)return lu;lE=1;function e(t){const n={className:"string",contains:[t.BACKSLASH_ESCAPE],variants:[t.inherit(t.APOS_STRING_MODE,{illegal:null}),t.inherit(t.QUOTE_STRING_MODE,{illegal:null})]},a=t.UNDERSCORE_TITLE_MODE,r={variants:[t.BINARY_NUMBER_MODE,t.C_NUMBER_MODE]},i="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:i,contains:[t.C_LINE_COMMENT_MODE,t.COMMENT(/\/\*/,/\*\//,{contains:[{className:"doctag",begin:/@[A-Za-z]+/}]}),{className:"string",begin:/<<<['"]?\w+['"]?$/,end:/^\w+;/,contains:[t.BACKSLASH_ESCAPE]},{begin:/(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/},{className:"function",beginKeywords:"function fn",end:/[;{]/,excludeEnd:!0,illegal:/\$|\[|%/,contains:[a,{className:"params",begin:/\(/,end:/\)/,keywords:i,contains:["self",t.C_BLOCK_COMMENT_MODE,n,r]}]},{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,illegal:/[:($"]/,contains:[{beginKeywords:"extends implements"},a]},{beginKeywords:"namespace",end:/;/,illegal:/[.']/,contains:[a]},{beginKeywords:"use",end:/;/,contains:[a]},{begin:/=>/},n,r]}}return lu=e,lu}var cu,cE;function NO(){if(cE)return cu;cE=1;var e=QR();return e.registerLanguage("1c",XR()),e.registerLanguage("abnf",ZR()),e.registerLanguage("accesslog",JR()),e.registerLanguage("actionscript",jR()),e.registerLanguage("ada",eC()),e.registerLanguage("angelscript",tC()),e.registerLanguage("apache",nC()),e.registerLanguage("applescript",aC()),e.registerLanguage("arcade",rC()),e.registerLanguage("arduino",iC()),e.registerLanguage("armasm",oC()),e.registerLanguage("xml",sC()),e.registerLanguage("asciidoc",lC()),e.registerLanguage("aspectj",cC()),e.registerLanguage("autohotkey",uC()),e.registerLanguage("autoit",dC()),e.registerLanguage("avrasm",_C()),e.registerLanguage("awk",pC()),e.registerLanguage("axapta",mC()),e.registerLanguage("bash",gC()),e.registerLanguage("basic",EC()),e.registerLanguage("bnf",fC()),e.registerLanguage("brainfuck",SC()),e.registerLanguage("c",bC()),e.registerLanguage("cal",TC()),e.registerLanguage("capnproto",hC()),e.registerLanguage("ceylon",vC()),e.registerLanguage("clean",RC()),e.registerLanguage("clojure",CC()),e.registerLanguage("clojure-repl",yC()),e.registerLanguage("cmake",NC()),e.registerLanguage("coffeescript",OC()),e.registerLanguage("coq",AC()),e.registerLanguage("cos",IC()),e.registerLanguage("cpp",DC()),e.registerLanguage("crmsh",xC()),e.registerLanguage("crystal",MC()),e.registerLanguage("csharp",wC()),e.registerLanguage("csp",LC()),e.registerLanguage("css",PC()),e.registerLanguage("d",kC()),e.registerLanguage("markdown",UC()),e.registerLanguage("dart",FC()),e.registerLanguage("delphi",BC()),e.registerLanguage("diff",GC()),e.registerLanguage("django",YC()),e.registerLanguage("dns",$C()),e.registerLanguage("dockerfile",qC()),e.registerLanguage("dos",HC()),e.registerLanguage("dsconfig",VC()),e.registerLanguage("dts",zC()),e.registerLanguage("dust",WC()),e.registerLanguage("ebnf",KC()),e.registerLanguage("elixir",QC()),e.registerLanguage("elm",XC()),e.registerLanguage("ruby",ZC()),e.registerLanguage("erb",JC()),e.registerLanguage("erlang-repl",jC()),e.registerLanguage("erlang",ey()),e.registerLanguage("excel",ty()),e.registerLanguage("fix",ny()),e.registerLanguage("flix",ay()),e.registerLanguage("fortran",ry()),e.registerLanguage("fsharp",iy()),e.registerLanguage("gams",oy()),e.registerLanguage("gauss",sy()),e.registerLanguage("gcode",ly()),e.registerLanguage("gherkin",cy()),e.registerLanguage("glsl",uy()),e.registerLanguage("gml",dy()),e.registerLanguage("go",_y()),e.registerLanguage("golo",py()),e.registerLanguage("gradle",my()),e.registerLanguage("graphql",gy()),e.registerLanguage("groovy",Ey()),e.registerLanguage("haml",fy()),e.registerLanguage("handlebars",Sy()),e.registerLanguage("haskell",by()),e.registerLanguage("haxe",Ty()),e.registerLanguage("hsp",hy()),e.registerLanguage("http",vy()),e.registerLanguage("hy",Ry()),e.registerLanguage("inform7",Cy()),e.registerLanguage("ini",yy()),e.registerLanguage("irpf90",Ny()),e.registerLanguage("isbl",Oy()),e.registerLanguage("java",Ay()),e.registerLanguage("javascript",Iy()),e.registerLanguage("jboss-cli",Dy()),e.registerLanguage("json",xy()),e.registerLanguage("julia",My()),e.registerLanguage("julia-repl",wy()),e.registerLanguage("kotlin",Ly()),e.registerLanguage("lasso",Py()),e.registerLanguage("latex",ky()),e.registerLanguage("ldif",Uy()),e.registerLanguage("leaf",Fy()),e.registerLanguage("less",By()),e.registerLanguage("lisp",Gy()),e.registerLanguage("livecodeserver",Yy()),e.registerLanguage("livescript",$y()),e.registerLanguage("llvm",qy()),e.registerLanguage("lsl",Hy()),e.registerLanguage("lua",Vy()),e.registerLanguage("makefile",zy()),e.registerLanguage("mathematica",Wy()),e.registerLanguage("matlab",Ky()),e.registerLanguage("maxima",Qy()),e.registerLanguage("mel",Xy()),e.registerLanguage("mercury",Zy()),e.registerLanguage("mipsasm",Jy()),e.registerLanguage("mizar",jy()),e.registerLanguage("perl",eN()),e.registerLanguage("mojolicious",tN()),e.registerLanguage("monkey",nN()),e.registerLanguage("moonscript",aN()),e.registerLanguage("n1ql",rN()),e.registerLanguage("nestedtext",iN()),e.registerLanguage("nginx",oN()),e.registerLanguage("nim",sN()),e.registerLanguage("nix",lN()),e.registerLanguage("node-repl",cN()),e.registerLanguage("nsis",uN()),e.registerLanguage("objectivec",dN()),e.registerLanguage("ocaml",_N()),e.registerLanguage("openscad",pN()),e.registerLanguage("oxygene",mN()),e.registerLanguage("parser3",gN()),e.registerLanguage("pf",EN()),e.registerLanguage("pgsql",fN()),e.registerLanguage("php",SN()),e.registerLanguage("php-template",bN()),e.registerLanguage("plaintext",TN()),e.registerLanguage("pony",hN()),e.registerLanguage("powershell",vN()),e.registerLanguage("processing",RN()),e.registerLanguage("profile",CN()),e.registerLanguage("prolog",yN()),e.registerLanguage("properties",NN()),e.registerLanguage("protobuf",ON()),e.registerLanguage("puppet",AN()),e.registerLanguage("purebasic",IN()),e.registerLanguage("python",DN()),e.registerLanguage("python-repl",xN()),e.registerLanguage("q",MN()),e.registerLanguage("qml",wN()),e.registerLanguage("r",LN()),e.registerLanguage("reasonml",PN()),e.registerLanguage("rib",kN()),e.registerLanguage("roboconf",UN()),e.registerLanguage("routeros",FN()),e.registerLanguage("rsl",BN()),e.registerLanguage("ruleslanguage",GN()),e.registerLanguage("rust",YN()),e.registerLanguage("sas",$N()),e.registerLanguage("scala",qN()),e.registerLanguage("scheme",HN()),e.registerLanguage("scilab",VN()),e.registerLanguage("scss",zN()),e.registerLanguage("shell",WN()),e.registerLanguage("smali",KN()),e.registerLanguage("smalltalk",QN()),e.registerLanguage("sml",XN()),e.registerLanguage("sqf",ZN()),e.registerLanguage("sql",JN()),e.registerLanguage("stan",jN()),e.registerLanguage("stata",eO()),e.registerLanguage("step21",tO()),e.registerLanguage("stylus",nO()),e.registerLanguage("subunit",aO()),e.registerLanguage("swift",rO()),e.registerLanguage("taggerscript",iO()),e.registerLanguage("yaml",oO()),e.registerLanguage("tap",sO()),e.registerLanguage("tcl",lO()),e.registerLanguage("thrift",cO()),e.registerLanguage("tp",uO()),e.registerLanguage("twig",dO()),e.registerLanguage("typescript",_O()),e.registerLanguage("vala",pO()),e.registerLanguage("vbnet",mO()),e.registerLanguage("vbscript",gO()),e.registerLanguage("vbscript-html",EO()),e.registerLanguage("verilog",fO()),e.registerLanguage("vhdl",SO()),e.registerLanguage("vim",bO()),e.registerLanguage("wasm",TO()),e.registerLanguage("wren",hO()),e.registerLanguage("x86asm",vO()),e.registerLanguage("xl",RO()),e.registerLanguage("xquery",CO()),e.registerLanguage("zephir",yO()),e.HighlightJS=e,e.default=e,cu=e,cu}var OO=NO();const $i=KR(OO),AO={css:"css",htm:"xml",html:"xml",js:"javascript",json:"json",md:"markdown",scad:"openscad",svg:"xml",ts:"typescript",xml:"xml"},IO={html:"xml",svg:"xml",stl:"openscad"};function xS(e){return e&&$i.getLanguage(e)?e:"plaintext"}function DO(e){const t=String(e||"").split("?")[0].split("#")[0];return t.includes(".")?t.split(".").pop().toLowerCase():""}function MS(e={}){const t=e.source_filename||e.filename||e.url||"",n=AO[DO(t)]||IO[e.content_type];return xS(n)}function wS(e,t){return $i.highlight(e||"",{language:xS(t)}).value}const xO={class:"artifacts-header"},MO={class:"artifacts-tabs"},wO={class:"artifacts-tab-count"},LO={class:"artifacts-tab-count"},PO={class:"artifacts-tab-count"},kO={class:"artifacts-tab-count"},UO={key:0,class:"artifacts-empty"},FO={class:"artifacts-list"},BO=["onClick"],GO={class:"artifact-icon"},YO={class:"artifact-info"},$O={class:"artifact-title"},qO={class:"artifact-meta"},HO={key:0,class:"artifact-detail"},VO={class:"artifact-detail-header"},zO={class:"artifact-detail-title"},WO={class:"artifact-detail-filename"},KO={class:"artifact-actions"},QO=["href"],XO=["href"],ZO=["href"],JO=["title"],jO={class:"artifact-preview"},eA={key:0,class:"artifact-source"},tA={key:0,class:"artifact-source-state"},nA={key:1,class:"artifact-source-error"},aA={key:2,class:"artifact-source-code"},rA=["innerHTML"],iA=["src"],oA=["src","alt"],sA=["src"],lA={key:4,class:"artifact-no-preview"},cA={key:0,class:"artifacts-empty"},uA={class:"artifacts-list links-list"},dA=["href"],_A={class:"artifact-info"},pA={class:"artifact-title"},mA={class:"artifact-meta"},gA={class:"link-detail"},EA={class:"link-detail-header"},fA={class:"link-detail-count"},SA={class:"ptr-label"},bA=["disabled"],TA={key:0,class:"artifacts-empty"},hA={class:"artifact-icon"},vA={class:"artifact-info"},RA={class:"artifact-title"},CA={class:"artifact-meta"},yA={key:0,class:"file-row-actions"},NA=["href"],OA=["href"],AA={key:0,class:"artifacts-empty"},IA={class:"artifacts-list terminals-list"},DA=["onClick"],xA={class:"artifact-icon"},MA={class:"artifact-info"},wA={class:"artifact-title"},LA={class:"artifact-meta"},PA={key:0,class:"terminal-detail"},kA={class:"terminal-detail-header"},UA={class:"terminal-detail-title"},FA={class:"terminal-detail-meta"},BA={class:"terminal-detail-grid"},GA={class:"terminal-detail-row"},YA={class:"terminal-detail-row"},$A={class:"terminal-detail-value"},qA={class:"terminal-detail-row"},HA={class:"terminal-detail-value terminal-detail-command"},VA={class:"terminal-detail-row"},zA={class:"terminal-detail-value"},WA={key:0,class:"terminal-detail-row"},KA={class:"terminal-detail-value"},QA={key:1,class:"terminal-detail-row"},XA={class:"terminal-detail-value"},ZA={key:2,class:"terminal-detail-row"},JA={class:"terminal-detail-value"},jA={key:0,class:"terminal-output-wrap"},eI={class:"terminal-output"},uE=80,tI=120,nI=980,aI=500,dE="navi:artifacts-drawer-width",rI={__name:"ArtifactsPanel",props:{open:{type:Boolean,default:!1}},emits:["close"],setup(e,{emit:t}){const n=t,a=on(),r=j(null),i=j(null),o=j(!1),s=j(""),l=j(!1),c=j(""),u=j(!1),d=j(typeof window>"u"?0:window.innerWidth),_=j("artifacts"),m=j(null),p=ge(()=>Object.values(a.terminals).filter(G=>!G.closed||G.output).sort((G,$)=>(G.name||"").localeCompare($.name||""))),g=ge(()=>m.value&&a.terminals[m.value]||null),b=ge(()=>Object.values(a.terminals).filter(G=>!G.closed).length);function A(G){m.value=m.value===G.name?null:G.name}function O(){m.value=null}function M(G){if(G<60)return`${Math.round(G)}s`;if(G<3600)return`${Math.floor(G/60)}m ${Math.round(G%60)}s`;const $=Math.floor(G/3600),Ne=Math.floor(G%3600/60);return`${$}h ${Ne}m`}const w=j(!1);async function v(){if(!(w.value||!a.currentId)){w.value=!0;try{await a.fetchFiles(a.currentId)}finally{w.value=!1}}}const T=j(!1),I=j(0),h=j(!1),E=j(null),D=ge(()=>({transform:`translateY(${Math.min(I.value,tI)}px)`,opacity:T.value?Math.min(I.value/uE,1):0})),x=ge(()=>w.value?"Refreshing...":h.value?"Release to refresh":"Pull to refresh");let L=0,ae=0;function Ee(G){var Ne;const $=E.value;$&&(ae=$.scrollTop||0,!(ae>2)&&(L=((Ne=G.touches[0])==null?void 0:Ne.clientY)??0,T.value=!1,I.value=0,h.value=!1))}function xe(G){var H;if(ae>2||!L)return;const Ne=(((H=G.touches[0])==null?void 0:H.clientY)??0)-L;if(Ne<=0){T.value=!1;return}Ne>4&&G.preventDefault(),T.value=!0,I.value=Ne,h.value=Ne>=uE}function Se(){h.value&&!w.value&&v(),T.value=!1,I.value=0,h.value=!1,L=0,ae=0}const pe=j(re()),Le=ge(()=>a.artifacts),be=ge(()=>Le.value.find(G=>ve(G)===r.value)||Le.value[0]||null);function Xe(G){return G.replace(/[.,;:!?)\]}+]+$/,"")}function et(G){try{const $=Xe(G),Ne=new URL($,window.location.origin),H=Ne.hostname.toLowerCase().replace(/^www\./,"");let ce=Ne.pathname.toLowerCase();return ce=ce.replace(/\/$/,""),`${H}${ce}`}catch{return Xe(G).toLowerCase()}}const it=ge(()=>{const G=new Set,$=[],Ne=[];for(let H=a.messages.length-1;H>=0;H--){const ce=a.messages[H];if(ce.role!=="assistant")continue;const Oe=ce.text||"";let Je;const $e=/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;for(;(Je=$e.exec(Oe))!==null;){let Yt=Je[2].trim();const $t=et(Yt);if(G.has($t))continue;G.add($t),$.push({url:Yt,text:Je[1].trim(),snippet:Rt(Oe,Je.index),domain:tt(Yt)});const Xt=Je[0].lastIndexOf(Je[2]),An=Je.index+Xt;Ne.push({start:An,end:An+Je[2].length})}}for(let H=a.messages.length-1;H>=0;H--){const ce=a.messages[H];if(ce.role!=="assistant")continue;const Oe=ce.text||"";let Je;const $e=/https?:\/\/[^\s<>"{}|\\^`[\]]+/g;for(;(Je=$e.exec(Oe))!==null;){let Yt=Je[0].trim();Yt=Xe(Yt);const $t=et(Yt);if(G.has($t))continue;const Xt=Je.index,An=Je.index+Je[0].length;Ne.some(Pt=>Xt>=Pt.start&&An<=Pt.end)||(G.add($t),$.push({url:Yt,text:"",snippet:Rt(Oe,Je.index),domain:tt(Yt)}))}}return $}),St=ge(()=>a.files),Ot=ge(()=>St.value.map($=>{const Ne=$.path.split("/"),H=Ne[Ne.length-1],ce=Ne.length-1;return{...$,name:H,depth:ce}})),qe=ge(()=>be.value?MS(be.value):"plaintext"),lt=ge(()=>wS(s.value,qe.value)),V=ge(()=>d.value>nI),te=ge(()=>V.value?{"--artifacts-width":`${ee()}px`}:{});je(Le,G=>{if(!G.length){r.value=null;return}(!r.value||!G.some($=>ve($)===r.value))&&(r.value=ve(G[0]))},{immediate:!0});function ve(G){return G.id||G.filename}function Ie(G){r.value=ve(G),o.value=!1,s.value="",c.value=""}function Be(G){return G.content_type||"unknown"}function R(G){return{stl:"ph ph-cube",html:"ph ph-browser",svg:"ph ph-bezier-curve",pdf:"ph ph-file-pdf",image:"ph ph-image",video:"ph ph-video"}[Be(G)]||"ph ph-paperclip"}function k(){return Math.round(Math.min(600,d.value*.42))}function z(){return Math.max(k(),d.value-aI)}function K(G){return Math.min(Math.max(Math.round(G),k()),z())}function ee(){return K(pe.value??k())}function X(){d.value=window.innerWidth,pe.value!==null&&(pe.value=ee())}function _e(G){V.value&&(G.preventDefault(),u.value=!0,document.body.style.cursor="col-resize",document.body.style.userSelect="none",window.addEventListener("pointermove",oe),window.addEventListener("pointerup",le,{once:!0}))}function oe(G){pe.value=K(d.value-G.clientX)}function le(){u.value=!1,Me(),document.body.style.cursor="",document.body.style.userSelect="",window.removeEventListener("pointermove",oe),window.removeEventListener("pointerup",le)}function re(){if(typeof window>"u")return null;try{const G=Number(window.localStorage.getItem(dE));return Number.isFinite(G)&&G>0?G:null}catch{return null}}function Me(){if(!(typeof window>"u"||pe.value===null))try{window.localStorage.setItem(dE,String(ee()))}catch{}}En(()=>{window.addEventListener("resize",X)}),Tn(()=>{window.removeEventListener("resize",X),window.removeEventListener("pointermove",oe),window.removeEventListener("pointerup",le),u.value&&le()});function Ce(G){const $=Be(G).toUpperCase(),Ne=G.updated_at||G.created_at;return Ne?`${$} · ${Re(Ne)}`:$}function Re(G){const $=new Date(G);return Number.isNaN($.getTime())?G:$.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"})}function Pe(G){return WR(G.url,G.updated_at||G.created_at||"")}function Ve(G,$){return DS($,Pe(G))}function Ke(G){const $=Be(G);return["stl","html","svg","pdf"].includes($)?Ve(G,$):Yi(Pe(G))}function y(G){return Za(G.url)}function B(G){const $=Be(G);return["html","svg"].includes($)?y(G):$==="stl"&&G.source_url?Za(G.source_url):""}function W(G){return!!B(G)}async function Y(G){o.value=!o.value,o.value&&await q(G)}async function q(G){const $=B(G);if(!(!$||s.value||l.value)){l.value=!0,c.value="";try{const Ne=await fetch($);if(!Ne.ok)throw new Error(`HTTP ${Ne.status}`);s.value=await Ne.text()}catch(Ne){c.value=`Failed to load source: ${(Ne==null?void 0:Ne.message)||Ne}`}finally{l.value=!1}}}function ne(G){return Be(G)==="stl"?Ke(G):Yi(Pe(G))}function de(G){const $=Za(G.download_url||G.url);return G.download_url||!$?$:`${$}${$.includes("?")?"&":"?"}download=1`}function fe(G){return["stl","html","svg","pdf"].includes(Be(G))}async function ye(G){try{await navigator.clipboard.writeText(ne(G)),i.value=ve(G),setTimeout(()=>{i.value===ve(G)&&(i.value=null)},1500)}catch{}}function Ue(G){return i.value===ve(G)?"ph ph-check":"ph ph-copy"}function tt(G){try{return new URL(G).hostname.replace(/^www\./,"")}catch{return G.split("/")[2]||G}}function Rt(G,$,Ne=60){const H=Math.max(0,$-Ne),ce=Math.min(G.length,$+Ne);let Oe=G.slice(H,ce).replace(/\s+/g," ").trim();return H>0&&(Oe="…"+Oe),ce$.url);G.length&&navigator.clipboard.writeText(G.join(` -`)).catch(()=>{})}function ct(){for(const G of it.value.slice(0,8))window.open(G.url,"_blank","noopener,noreferrer")}function at(G){var H;if(G.is_dir)return"ph ph-folder";const $=((H=G.name.split(".").pop())==null?void 0:H.toLowerCase())||"";return{js:"ph ph-file-js",ts:"ph ph-file-ts",py:"ph ph-file-py",html:"ph ph-file-html",css:"ph ph-file-css",json:"ph ph-file-json",md:"ph ph-file-text",txt:"ph ph-file-text",jpg:"ph ph-file-image",jpeg:"ph ph-file-image",png:"ph ph-file-image",gif:"ph ph-file-image",svg:"ph ph-file-image",webp:"ph ph-file-image",mp4:"ph ph-file-video",webm:"ph ph-file-video",mov:"ph ph-file-video",mp3:"ph ph-file-audio",wav:"ph ph-file-audio",ogg:"ph ph-file-audio",pdf:"ph ph-file-pdf",zip:"ph ph-file-zip",tar:"ph ph-file-zip",gz:"ph ph-file-zip",rar:"ph ph-file-zip"}[$]||"ph ph-file"}function ze(G){if(G.is_dir)return"Directory";const $=G.size;return $<1024?`${$} B`:$<1024*1024?`${($/1024).toFixed(1)} KB`:`${($/(1024*1024)).toFixed(1)} MB`}function P(G){return{paddingLeft:`${12+G.depth*16}px`}}function Z(G){const $=a.currentId;return $?`/api/sessions/${$}/files/${encodeURIComponent(G)}?download=1`:"#"}function he(G){var H;const $=((H=G.split(".").pop())==null?void 0:H.toLowerCase())||"";return["jpg","jpeg","png","gif","svg","webp","html","txt","md","pdf"].includes($)}return(G,$)=>{const Ne=xt("GnIconButton");return N(),U("aside",{class:He(["artifacts-panel",{"is-open":e.open,"is-resizing":u.value}]),style:jn(te.value),"aria-label":"Session artifacts"},[f("div",{class:"artifacts-resize-handle",role:"separator","aria-orientation":"vertical",title:"Resize artifacts",onPointerdown:_e},null,32),f("div",xO,[f("div",MO,[f("button",{class:He(["artifacts-tab",{"is-active":_.value==="artifacts"}]),onClick:$[0]||($[0]=H=>_.value="artifacts")},[$[7]||($[7]=f("i",{class:"ph ph-files"},null,-1)),$[8]||($[8]=f("span",null,"Artifacts",-1)),f("span",wO,ie(Le.value.length),1)],2),f("button",{class:He(["artifacts-tab",{"is-active":_.value==="links"}]),onClick:$[1]||($[1]=H=>_.value="links")},[$[9]||($[9]=f("i",{class:"ph ph-link"},null,-1)),$[10]||($[10]=f("span",null,"Links",-1)),f("span",LO,ie(it.value.length),1)],2),f("button",{class:He(["artifacts-tab",{"is-active":_.value==="files"}]),onClick:$[2]||($[2]=H=>_.value="files")},[$[11]||($[11]=f("i",{class:"ph ph-folder"},null,-1)),$[12]||($[12]=f("span",null,"Files",-1)),f("span",PO,ie(St.value.length),1)],2),f("button",{class:He(["artifacts-tab",{"is-active":_.value==="terminals"}]),onClick:$[3]||($[3]=H=>_.value="terminals")},[$[13]||($[13]=f("i",{class:"ph ph-terminal"},null,-1)),$[14]||($[14]=f("span",null,"Terminals",-1)),f("span",kO,ie(b.value),1)],2)]),we(Ne,{icon:"ph ph-x",label:"Close artifacts",class:"artifacts-close",onClick:$[4]||($[4]=H=>n("close"))})]),_.value==="artifacts"?(N(),U(Ze,{key:0},[Le.value.length?(N(),U(Ze,{key:1},[f("div",FO,[(N(!0),U(Ze,null,Ut(Le.value,H=>(N(),U("button",{key:H.id||H.filename,class:He(["artifact-item",{"is-active":r.value===ve(H)}]),onClick:ce=>Ie(H)},[f("span",GO,[f("i",{class:He(R(H))},null,2)]),f("span",YO,[f("span",$O,ie(H.title||H.filename),1),f("span",qO,ie(Ce(H)),1)])],10,BO))),128))]),be.value?(N(),U("div",HO,[f("div",VO,[f("div",zO,ie(be.value.title||be.value.filename),1),f("div",WO,ie(be.value.filename),1)]),f("div",KO,[f("a",{class:"artifact-action",href:Ke(be.value),target:"_blank",rel:"noopener noreferrer",title:"Open preview"},[...$[16]||($[16]=[f("i",{class:"ph ph-arrow-square-out"},null,-1)])],8,QO),f("a",{class:"artifact-action",href:y(be.value),target:"_blank",rel:"noopener noreferrer",title:"Open raw file"},[...$[17]||($[17]=[f("i",{class:"ph ph-file"},null,-1)])],8,XO),f("a",{class:"artifact-action",href:de(be.value),title:"Download"},[...$[18]||($[18]=[f("i",{class:"ph ph-download-simple"},null,-1)])],8,ZO),W(be.value)?(N(),U("button",{key:0,class:"artifact-action",title:o.value?"Show preview":"Show source",onClick:$[5]||($[5]=H=>Y(be.value))},[f("i",{class:He(o.value?"ph ph-eye":"ph ph-code")},null,2)],8,JO)):ue("",!0),f("button",{class:"artifact-action",title:"Copy file link",onClick:$[6]||($[6]=H=>ye(be.value))},[f("i",{class:He(Ue(be.value))},null,2)])]),f("div",jO,[o.value?(N(),U("div",eA,[l.value?(N(),U("div",tA,[...$[19]||($[19]=[f("span",{class:"spinner"},null,-1),f("span",null,"Loading source...",-1)])])):c.value?(N(),U("pre",nA,ie(c.value),1)):(N(),U("pre",aA,[f("code",{class:He(["hljs",`language-${qe.value}`]),innerHTML:lt.value},null,10,rA)]))])):fe(be.value)?(N(),U("iframe",{key:1,src:Ke(be.value),class:"artifact-frame",sandbox:"allow-scripts allow-same-origin"},null,8,iA)):Be(be.value)==="image"?(N(),U("img",{key:2,src:Pe(be.value),alt:be.value.title||be.value.filename,class:"artifact-image"},null,8,oA)):Be(be.value)==="video"?(N(),U("video",{key:3,src:Pe(be.value),class:"artifact-video",controls:"",playsinline:""},null,8,sA)):(N(),U("div",lA,[...$[20]||($[20]=[f("i",{class:"ph ph-file"},null,-1),f("span",null,"Preview unavailable",-1)])]))])])):ue("",!0)],64)):(N(),U("div",UO,[...$[15]||($[15]=[f("i",{class:"ph ph-files"},null,-1),f("span",null,"No published files",-1)])]))],64)):ue("",!0),_.value==="links"?(N(),U(Ze,{key:1},[it.value.length?(N(),U(Ze,{key:1},[f("div",uA,[(N(!0),U(Ze,null,Ut(it.value,H=>(N(),U("a",{key:H.url,class:"artifact-item link-item",href:H.url,target:"_blank",rel:"noopener noreferrer"},[$[22]||($[22]=f("span",{class:"artifact-icon"},[f("i",{class:"ph ph-link"})],-1)),f("span",_A,[f("span",pA,ie(H.text||H.url),1),f("span",mA,ie(H.domain)+" · "+ie(H.snippet),1)])],8,dA))),128))]),f("div",gA,[f("div",EA,[f("div",fA,ie(it.value.length)+" link"+ie(it.value.length===1?"":"s")+" in session",1)]),f("div",{class:"link-actions"},[f("button",{class:"artifact-action",title:"Copy all links",onClick:Fe},[...$[23]||($[23]=[f("i",{class:"ph ph-copy"},null,-1)])]),f("button",{class:"artifact-action",title:"Open all links",onClick:ct},[...$[24]||($[24]=[f("i",{class:"ph ph-arrow-square-out"},null,-1)])])])])],64)):(N(),U("div",cA,[...$[21]||($[21]=[f("i",{class:"ph ph-link"},null,-1),f("span",null,"No links found yet",-1)])]))],64)):ue("",!0),_.value==="files"?(N(),U("div",{key:2,class:"files-tab-wrap",onTouchstart:Ee,onTouchmove:xe,onTouchend:Se},[f("div",{class:He(["ptr-indicator files-ptr",{"ptr-active":T.value&&!w.value}]),style:jn(D.value)},[f("span",{class:He(["ptr-spinner",{"ptr-spinning":h.value}])},null,2),f("span",SA,ie(x.value),1)],6),f("button",{class:"files-refresh-btn",title:"Refresh files",disabled:w.value,onClick:v},[f("i",{class:He(["ph ph-arrows-clockwise",{spinning:w.value}])},null,2)],8,bA),St.value.length?(N(),U("div",{key:1,ref_key:"filesListRef",ref:E,class:He(["artifacts-list files-list",{"ptr-pulled":T.value}])},[(N(!0),U(Ze,null,Ut(Ot.value,H=>(N(),U("div",{key:H.path,class:He(["artifact-item file-item",{"is-dir":H.is_dir}]),style:jn(P(H))},[f("span",hA,[f("i",{class:He(at(H))},null,2)]),f("span",vA,[f("span",RA,ie(H.name),1),f("span",CA,ie(ze(H)),1)]),H.is_dir?ue("",!0):(N(),U("div",yA,[f("a",{class:"artifact-action file-row-action",href:Z(H.path),title:"Download",target:"_blank",rel:"noopener noreferrer"},[...$[26]||($[26]=[f("i",{class:"ph ph-download-simple"},null,-1)])],8,NA),he(H.path)?(N(),U("a",{key:0,class:"artifact-action file-row-action",href:Z(H.path),title:"Open inline",target:"_blank",rel:"noopener noreferrer"},[...$[27]||($[27]=[f("i",{class:"ph ph-eye"},null,-1)])],8,OA)):ue("",!0)]))],6))),128))],2)):(N(),U("div",TA,[...$[25]||($[25]=[f("i",{class:"ph ph-folder"},null,-1),f("span",null,"No files in session directory",-1)])]))],32)):ue("",!0),_.value==="terminals"?(N(),U(Ze,{key:3},[p.value.length?(N(),U(Ze,{key:1},[f("div",IA,[(N(!0),U(Ze,null,Ut(p.value,H=>(N(),U("button",{key:H.name,class:He(["artifact-item terminal-item",{"is-active":m.value===H.name,"is-closed":H.closed}]),onClick:ce=>A(H)},[f("span",xA,[f("i",{class:He(H.closed?"ph ph-x-circle":H.status==="busy"?"ph ph-play-circle":"ph ph-pause-circle")},null,2)]),f("span",MA,[f("span",wA,ie(H.name),1),f("span",LA,ie(H.description||H.command||"Terminal"),1)]),f("span",{class:He(["terminal-status-badge",H.status==="busy"?"status-busy":H.closed?"status-closed":"status-idle"])},ie(H.closed?"Closed":H.status==="busy"?"Busy":"Idle"),3)],10,DA))),128))]),g.value?(N(),U("div",PA,[f("div",kA,[f("div",null,[f("div",UA,ie(g.value.name),1),f("div",FA,ie(g.value.description||g.value.command||"Terminal"),1)]),f("button",{class:"terminal-detail-close",title:"Close details",onClick:O},[...$[29]||($[29]=[f("i",{class:"ph ph-x"},null,-1)])])]),f("div",BA,[f("div",GA,[$[30]||($[30]=f("span",{class:"terminal-detail-label"},"Status",-1)),f("span",{class:He(["terminal-detail-value",g.value.status==="busy"?"status-busy":g.value.closed?"status-closed":"status-idle"])},ie(g.value.closed?"Closed":g.value.status==="busy"?"Busy":"Idle"),3)]),f("div",YA,[$[31]||($[31]=f("span",{class:"terminal-detail-label"},"PID",-1)),f("span",$A,ie(g.value.pid||"N/A"),1)]),f("div",qA,[$[32]||($[32]=f("span",{class:"terminal-detail-label"},"Command",-1)),f("span",HA,ie(g.value.command||"N/A"),1)]),f("div",VA,[$[33]||($[33]=f("span",{class:"terminal-detail-label"},"CWD",-1)),f("span",zA,ie(g.value.cwd||"N/A"),1)]),g.value.uptime_seconds!=null?(N(),U("div",WA,[$[34]||($[34]=f("span",{class:"terminal-detail-label"},"Uptime",-1)),f("span",KA,ie(M(g.value.uptime_seconds)),1)])):ue("",!0),g.value.background!=null?(N(),U("div",QA,[$[35]||($[35]=f("span",{class:"terminal-detail-label"},"Background",-1)),f("span",XA,ie(g.value.background?"Yes":"No"),1)])):ue("",!0),g.value.closeReason?(N(),U("div",ZA,[$[36]||($[36]=f("span",{class:"terminal-detail-label"},"Reason",-1)),f("span",JA,ie(g.value.closeReason),1)])):ue("",!0)]),g.value.output?(N(),U("div",jA,[$[37]||($[37]=f("div",{class:"terminal-output-header"},"Live output",-1)),f("pre",eI,ie(g.value.output),1)])):ue("",!0)])):ue("",!0)],64)):(N(),U("div",AA,[...$[28]||($[28]=[f("i",{class:"ph ph-terminal"},null,-1),f("span",null,"No active terminals",-1)])]))],64)):ue("",!0)],6)}}},iI=Mt(rI,[["__scopeId","data-v-9dbbe7c1"]]),oI={class:"login-overlay"},sI={class:"login-card"},lI={__name:"LoginScreen",setup(e){function t(){window.location.href="/auth/login"}return(n,a)=>{const r=xt("GnButton");return N(),U("div",oI,[f("div",sI,[a[1]||(a[1]=f("img",{src:ld,alt:"Navi",class:"login-logo"},null,-1)),a[2]||(a[2]=f("h1",{class:"login-title"},"Welcome to Navi",-1)),a[3]||(a[3]=f("p",{class:"login-subtitle"},"Your personal AI assistant",-1)),we(r,{variant:"primary",class:"login-btn",icon:"ph ph-sign-in",onClick:t},{default:_t(()=>[...a[0]||(a[0]=[Et(" Login with GNEXUS ",-1)])]),_:1})])])}}},LS=Mt(lI,[["__scopeId","data-v-6939826e"]]),cI=Object.freeze(Object.defineProperty({__proto__:null,default:LS},Symbol.toStringTag,{value:"Module"}));function uI(){const e=j(navigator.onLine);function t(){e.value=!0}function n(){e.value=!1}return En(()=>{window.addEventListener("online",t),window.addEventListener("offline",n)}),ea(()=>{window.removeEventListener("online",t),window.removeEventListener("offline",n)}),{online:e}}const dI={key:0,class:"offline-banner"},_I={__name:"OfflineBanner",setup(e){const{online:t}=uI();return(n,a)=>(N(),ut(hr,{name:"offline-slide"},{default:_t(()=>[J(t)?ue("",!0):(N(),U("div",dI,[...a[0]||(a[0]=[f("i",{class:"ph ph-wifi-slash"},null,-1),f("span",null,"Нет сети — интерфейс открыт из кэша, сообщения не отправляются",-1)])]))]),_:1}))}},PS=Mt(_I,[["__scopeId","data-v-2f8cc0a8"]]),pI=Object.freeze(Object.defineProperty({__proto__:null,default:PS},Symbol.toStringTag,{value:"Module"})),mI={class:"welcome-screen"},gI={key:0,class:"welcome-profiles"},EI=["onClick"],fI={class:"profile-name"},SI={class:"profile-desc"},bI={__name:"WelcomeScreen",emits:["toggle-sidebar"],setup(e,{emit:t}){var d;const n=t,a=li(),r=Zn(),i=on(),o=j(a.selectedProfileId??((d=a.profiles[0])==null?void 0:d.id)??null),s=j(!1),l={secretary:"ph-briefcase",server_admin:"ph-terminal",developer:"ph-code",tool_developer:"ph-wrench",discuss:"ph-chats"};function c(_){return`ph ${l[_.id]??"ph-robot"}`}async function u(){if(!(!o.value||s.value)){s.value=!0;try{a.selectedProfileId=o.value;const _=await r.createSession(o.value);await i.loadSession(_.session_id)}catch(_){console.error("[welcome] start failed",_)}finally{s.value=!1}}}return(_,m)=>{const p=xt("GnIconButton"),g=xt("GnAvatar"),b=xt("GnButton");return N(),U("div",mI,[we(p,{icon:"ph ph-sidebar",label:"Menu",class:"welcome-sidebar-btn",onClick:m[0]||(m[0]=A=>n("toggle-sidebar"))}),m[2]||(m[2]=f("div",{class:"welcome-logo"},[f("img",{src:ld,alt:"Navi"}),f("h1",null,"Navi"),f("p",null,"Your personal AI assistant")],-1)),J(a).profiles.length?(N(),U("div",gI,[(N(!0),U(Ze,null,Ut(J(a).profiles,A=>(N(),U("div",{key:A.id,class:He(["welcome-profile-card",{"is-selected":o.value===A.id}]),onClick:O=>o.value=A.id},[we(g,{size:"md",variant:"secondary",icon:c(A)},null,8,["icon"]),f("div",fI,ie(A.name),1),f("div",SI,ie(A.description),1)],10,EI))),128))])):ue("",!0),we(b,{variant:"primary",disabled:!o.value||s.value,loading:s.value,icon:"ph ph-chat-centered-text",onClick:u},{default:_t(()=>[...m[1]||(m[1]=[Et(" Start a conversation ",-1)])]),_:1},8,["disabled","loading"])])}}},kS=Mt(bI,[["__scopeId","data-v-43638b99"]]),TI=Object.freeze(Object.defineProperty({__proto__:null,default:kS},Symbol.toStringTag,{value:"Module"}));var hI=new Set(["primary","secondary","accent","success","warning","danger","error","info"]);function ke(...e){return e.flatMap(t=>t?Array.isArray(t)?t:typeof t=="object"?Object.entries(t).filter(([,n])=>n).map(([n])=>n):[t]:[]).filter(Boolean).join(" ")}function fa(e,t="primary"){return hI.has(e)?e:t}function mt(e,t=""){if(!e)return null;const n=e.includes("ph ")||e.startsWith("ph-")?e:`ph ${e}`;return C("i",{class:ke(n,t),"aria-hidden":"true"})}function yr(e){const t=e.target;return t.type==="checkbox"?t.checked:t.value}var vI=["a[href]","button:not([disabled])","input:not([disabled])","select:not([disabled])","textarea:not([disabled])","[tabindex]:not([tabindex='-1'])"].join(",");function US(e,t){if(e.key!=="Tab"||!t)return;const n=[...t.querySelectorAll(vI)].filter(i=>!i.hasAttribute("disabled")&&i.offsetParent!==null);if(!n.length){e.preventDefault(),t.focus();return}const a=n[0],r=n[n.length-1];e.shiftKey&&document.activeElement===a?(e.preventDefault(),r.focus()):!e.shiftKey&&document.activeElement===r&&(e.preventDefault(),a.focus())}var RI=We({name:"GnAccordion",props:{items:{type:Array,required:!0},modelValue:{type:[String,Array],default:""},multiple:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(e,{emit:t,slots:n}){const a=j(e.multiple?[]:""),r=()=>e.modelValue||a.value,i=s=>e.multiple?r().includes(s):r()===s,o=s=>{let l;if(e.multiple){const c=[...r()];l=c.includes(s)?c.filter(u=>u!==s):[...c,s]}else l=i(s)?"":s;a.value=l,t("update:modelValue",l)};return()=>C("div",{class:"accordion"},e.items.map(s=>{var l;const c=i(s.id);return C("section",{class:"accordion-item",open:c?"":void 0},[C("button",{class:"accordion-summary",type:"button","aria-expanded":c?"true":"false",onClick:()=>o(s.id)},[C("span",{class:"accordion-summary-content"},[mt(s.icon),s.label]),C("i",{class:ke("ph ph-caret-down accordion-icon",{"is-open":c}),"aria-hidden":"true"})]),c&&C("div",{class:"accordion-panel"},((l=n[s.id])==null?void 0:l.call(n,{item:s,open:c}))||s.content)])}))}}),CI=We({name:"GnActionCard",props:{kicker:{type:String,default:""},title:{type:String,required:!0},text:{type:String,default:""}},setup(e,{slots:t}){return()=>{var n,a,r;return C("article",{class:"card action-card"},[C("div",{class:"card-content"},[(e.kicker||t.kicker)&&C("span",{class:"action-card-kicker"},((n=t.kicker)==null?void 0:n.call(t))||e.kicker),C("h3",{class:"action-card-title"},((a=t.title)==null?void 0:a.call(t))||e.title),(e.text||t.default)&&C("p",{class:"action-card-text"},((r=t.default)==null?void 0:r.call(t))||e.text),t.actions&&C("div",{class:"action-card-actions"},t.actions())])])}}}),yI=We({name:"GnActionList",props:{items:{type:Array,default:()=>[]}},setup(e,{attrs:t,slots:n}){return()=>C("ul",{...t,class:ke("list list-actions",t.class)},e.items.map(a=>{var r,i;return C("li",{class:ke("list-item",a.muted&&"list-item-muted")},[C("div",{class:"list-content"},[C("div",{class:"list-title"},((r=n.title)==null?void 0:r.call(n,{item:a}))||a.title),(a.subtitle||n.subtitle)&&C("div",{class:"list-subtitle"},((i=n.subtitle)==null?void 0:i.call(n,{item:a}))||a.subtitle)]),n.controls&&C("div",{class:"list-controls"},n.controls({item:a}))])}))}}),NI=We({name:"GnActivityLog",props:{items:{type:Array,default:()=>[]}},setup(e,{attrs:t,slots:n}){return()=>C("div",{...t,class:ke("activity-log",t.class)},e.items.map(a=>{var r;return C("div",{class:"activity-log-row"},[C("time",{class:"activity-log-time"},a.time),C("span",{class:"activity-log-title"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.title),n.actions&&C("span",{},n.actions({item:a}))])}))}}),OI=We({name:"GnAlert",props:{variant:{type:String,default:"primary"},role:{type:String,default:"status"}},setup(e,{attrs:t,slots:n}){return()=>{var a;const r=fa(e.variant);return C("div",{...t,role:e.role,class:ke("alert",`alert-${r}`,t.class)},(a=n.default)==null?void 0:a.call(n))}}}),_d=We({name:"GnAvatar",props:{src:{type:String,default:""},alt:{type:String,default:""},initials:{type:String,default:""},icon:{type:String,default:""},size:{type:String,default:"md"},variant:{type:String,default:"primary"},outline:{type:Boolean,default:!1},status:{type:String,default:""}},setup(e,{attrs:t}){return()=>{const n=fa(e.variant);return C("span",{...t,class:ke("avatar",`avatar-${n}`,{"avatar-sm":e.size==="sm","avatar-lg":e.size==="lg","avatar-outline":e.outline,"is-online":e.status==="online","is-busy":e.status==="busy","is-offline":e.status==="offline"},t.class)},[e.src?C("img",{src:e.src,alt:e.alt}):mt(e.icon)||e.initials,e.status&&C("span",{class:"avatar-status","aria-hidden":"true"})])}}}),AI=We({name:"GnAvatarStack",props:{items:{type:Array,default:()=>[]},count:{type:[Number,String],default:""}},setup(e,{slots:t}){return()=>{var n;return C("span",{class:"avatar-stack"},[e.items.map(a=>C(_d,{...a,size:a.size||"sm"})),(n=t.default)==null?void 0:n.call(t),e.count&&C("span",{class:"avatar-stack-count"},`+${e.count}`)])}}}),FS=We({name:"GnBadge",props:{variant:{type:String,default:"primary"},outline:{type:Boolean,default:!1}},setup(e,{attrs:t,slots:n}){return()=>{var a;const r=fa(e.variant);return C("span",{...t,class:ke("badge",e.outline&&r==="primary"?"badge-primary-outline":`badge-${r}`,t.class)},(a=n.default)==null?void 0:a.call(n))}}}),Rr=We({name:"GnButton",props:{variant:{type:String,default:"primary"},size:{type:String,default:"md"},icon:{type:String,default:""},loading:{type:Boolean,default:!1},disabled:{type:Boolean,default:!1},type:{type:String,default:"button"}},setup(e,{attrs:t,slots:n}){return()=>{var a;const r=!!(e.icon||e.loading),i=fa(e.variant);return C("button",{...t,type:e.type,disabled:e.disabled||e.loading,class:ke("btn",`btn-${i}`,{"btn-small":e.size==="sm","btn-large":e.size==="lg","with-icon":r,"loading-state":e.loading},t.class)},[e.loading?mt("ph-bold ph-spinner"):mt(e.icon),(a=n.default)==null?void 0:a.call(n)])}}}),II=We({name:"GnCard",props:{title:{type:String,default:""},variant:{type:String,default:""}},setup(e,{attrs:t,slots:n}){return()=>{var a,r;return C("article",{...t,class:ke("card",e.variant&&`card-${e.variant}`,t.class)},[(e.title||n.title)&&C("header",{class:"card-title"},((a=n.title)==null?void 0:a.call(n))||e.title),C("div",{class:"card-content"},(r=n.default)==null?void 0:r.call(n)),n.footer&&C("footer",{class:"card-footer"},n.footer())])}}}),_E=We({name:"GnCheckbox",inheritAttrs:!1,props:{modelValue:{type:Boolean,default:!1},label:{type:String,default:""},disabled:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n,slots:a}){return()=>{var r;return C("label",{class:ke("checkbox",t.class)},[C("input",{...t,type:"checkbox",checked:e.modelValue,disabled:e.disabled,onChange:i=>n("update:modelValue",i.target.checked)}),C("span",{class:"checkbox-control","aria-hidden":"true"}),C("span",{class:"checkbox-label"},((r=a.default)==null?void 0:r.call(a))||e.label)])}}}),DI=We({name:"GnChip",props:{variant:{type:String,default:""},icon:{type:String,default:""},selected:{type:Boolean,default:!1},disabled:{type:Boolean,default:!1},removable:{type:Boolean,default:!1}},emits:["remove"],setup(e,{attrs:t,emit:n,slots:a}){return()=>{var r;const i=t.onClick?"button":"span",o=e.variant?fa(e.variant):"";return C(i,{...t,type:i==="button"?"button":void 0,disabled:i==="button"?e.disabled:void 0,"aria-pressed":i==="button"?String(e.selected):void 0,class:ke("chip",o&&`chip-${o}`,{"chip-selected":e.selected,"chip-disabled":e.disabled},t.class)},[mt(e.icon),(r=a.default)==null?void 0:r.call(a),e.removable&&C("button",{class:"chip-remove",type:"button","aria-label":"Remove",onClick:s=>{s.stopPropagation(),n("remove")}},[mt("ph-x")])])}}}),xI=We({name:"GnChipGroup",setup(e,{attrs:t,slots:n}){return()=>{var a;return C("div",{...t,class:ke("chip-group",t.class)},(a=n.default)==null?void 0:a.call(n))}}}),MI=0,wI=We({name:"GnCombobox",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},icon:{type:String,default:""},options:{type:Array,default:()=>[]},placeholder:{type:String,default:"Search"},notFoundText:{type:String,default:"Nothing found"},state:{type:String,default:""},help:{type:String,default:""}},emits:["update:modelValue","select"],setup(e,{attrs:t,emit:n}){const a=`gn-combobox-${++MI}`,r=`${a}-listbox`,i=j(!1),o=j(-1),s=j(null),l=ge(()=>e.options.map(p=>typeof p=="object"?p:{value:p,label:p})),c=ge(()=>{var p;return String((p=e.modelValue)!=null?p:"").toLowerCase()}),u=ge(()=>l.value.filter(p=>String(p.label).toLowerCase().includes(c.value))),d=p=>{p&&(n("update:modelValue",p.label),n("select",p),i.value=!1,o.value=-1)},_=p=>{u.value.length&&(i.value=!0,o.value=(o.value+p+u.value.length)%u.value.length,Ht(()=>{var g,b,A;const O=(b=(g=s.value)==null?void 0:g.closest(".form-group"))==null?void 0:b.querySelector(".advanced-select");(A=O==null?void 0:O.querySelector(".option.focus"))==null||A.scrollIntoView({block:"nearest"})}))},m=p=>{p.key==="ArrowDown"?(p.preventDefault(),_(1)):p.key==="ArrowUp"?(p.preventDefault(),_(-1)):p.key==="Enter"?(p.preventDefault(),d(u.value[o.value])):p.key==="Escape"&&(i.value=!1,o.value=-1)};return()=>C("div",{class:"form-group"},[C("label",{class:ke("label",e.state)},[e.label,mt(e.icon),C("input",{...t,ref:s,id:a,type:"text",value:e.modelValue,placeholder:e.placeholder,autocomplete:"off",role:"combobox","aria-autocomplete":"list","aria-expanded":i.value?"true":"false","aria-controls":r,"aria-activedescendant":o.value>=0?`${a}-option-${o.value}`:void 0,class:ke("input",t.class),onFocus:()=>{i.value=!0},onBlur:()=>{setTimeout(()=>{i.value=!1},120)},onInput:p=>{o.value=-1,i.value=!0,n("update:modelValue",yr(p))},onKeydown:m})]),C("div",{class:"advanced-select-container"},[C("div",{class:ke("advanced-select",{"a-show":i.value})},[C("div",{class:"popup-options-container"},[C("div",{class:ke("not-found",{show:!u.value.length})},e.notFoundText),C("div",{id:r,class:ke("options",{show:u.value.length}),role:"listbox"},u.value.map((p,g)=>C("div",{id:`${a}-option-${g}`,class:ke("option",{focus:g===o.value}),role:"option","aria-selected":g===o.value?"true":"false","data-value":p.value,"data-display-value":p.label,onMousedown:b=>{b.preventDefault(),d(p)}},p.label)))])])]),e.help&&C("div",{class:ke("input-info",e.state==="error"&&"error")},e.help)])}}),LI=0,BS=We({name:"GnModal",props:{open:{type:Boolean,default:!1},title:{type:String,default:""},closeOnBackdrop:{type:Boolean,default:!0}},emits:["update:open","close"],setup(e,{emit:t,slots:n}){const a=`gn-modal-title-${++LI}`,r=j(null);let i=null;const o=()=>{t("update:open",!1),t("close")},s=c=>{c.key==="Escape"?(c.preventDefault(),o()):US(c,r.value)},l=()=>{Ht(()=>{var c;(c=r.value)==null||c.focus()})};return je(()=>e.open,c=>{var u;c?(i=document.activeElement,document.addEventListener("keydown",s),l()):(document.removeEventListener("keydown",s),(u=i==null?void 0:i.focus)==null||u.call(i),i=null)},{flush:"post"}),Tn(()=>{document.removeEventListener("keydown",s)}),()=>{var c,u,d;return e.open?C(ri,{to:"body"},[C("div",{class:"modal a-show","aria-hidden":"false"},[C("div",{class:"modal-backdrop",onClick:()=>e.closeOnBackdrop&&o()}),C("div",{ref:r,class:"modal-dialog",role:"dialog","aria-modal":"true","aria-labelledby":a,tabindex:"-1"},[C("header",{class:"modal-header"},[C("h4",{class:"modal-title",id:a},((c=n.title)==null?void 0:c.call(n))||e.title),C("button",{class:"btn-icon modal-close",type:"button","aria-label":"Close",onClick:o},[mt("ph-x")])]),C("div",{class:"modal-panel"},[C("div",{class:"modal-body"},(u=n.default)==null?void 0:u.call(n)),(n.footer||n.actions)&&C("footer",{class:"modal-footer"},[(d=n.footer)==null?void 0:d.call(n),n.actions&&C("div",{class:"actions"},n.actions({close:o}))])])])])]):null}}}),PI=We({name:"GnConfirmDialog",props:{open:{type:Boolean,default:!1},title:{type:String,default:"Requires confirmation"},message:{type:String,default:""},confirmText:{type:String,default:"YES"},cancelText:{type:String,default:"NO"},confirmVariant:{type:String,default:"warning"}},emits:["update:open","confirm","cancel"],setup(e,{emit:t,slots:n}){const a=()=>t("update:open",!1),r=()=>{t("cancel"),a()},i=()=>{t("confirm"),a()};return()=>C(BS,{open:e.open,title:e.title,"onUpdate:open":o=>t("update:open",o)},{default:()=>{var o;return((o=n.default)==null?void 0:o.call(n))||C("p",{},e.message)},actions:()=>[C(Rr,{variant:"primary",onClick:r},()=>e.cancelText),C(Rr,{variant:e.confirmVariant,onClick:i},()=>e.confirmText)]})}}),kI=We({name:"GnDescriptionList",props:{items:{type:Array,default:()=>[]},compact:{type:Boolean,default:!1}},setup(e,{attrs:t,slots:n}){return()=>C("dl",{...t,class:ke("description-list",{"description-list-compact":e.compact},t.class)},e.items.map(a=>{var r;return C("div",{class:"description-list-row"},[C("dt",{class:"description-list-term"},a.term||a.label),C("dd",{class:ke("description-list-value",a.muted&&"description-list-value-muted")},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.value)])}))}}),UI=We({name:"GnDefinitionList",props:{items:{type:Array,default:()=>[]}},setup(e,{attrs:t,slots:n}){return()=>C("dl",{...t,class:ke("list list-definition",t.class)},e.items.map(a=>{var r;return C("div",{class:"list-row"},[C("dt",{class:"list-term"},a.term||a.label),C("dd",{class:"list-desc"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.description||a.value)])}))}}),FI=We({name:"GnDropdown",props:{label:{type:String,default:"Actions"},icon:{type:String,default:"ph-dots-three-outline"},variant:{type:String,default:"secondary"},items:{type:Array,default:()=>[]}},emits:["select"],setup(e,{emit:t,slots:n}){const a=j(!1),r=j(null),i=()=>{a.value=!1,document.removeEventListener("click",o),document.removeEventListener("keydown",s)},o=u=>{r.value&&!r.value.contains(u.target)&&i()},s=u=>{u.key==="Escape"&&(u.preventDefault(),i())},l=()=>{a.value=!a.value,a.value?(setTimeout(()=>document.addEventListener("click",o),0),document.addEventListener("keydown",s)):i()},c=u=>{var d;u.disabled||((d=u.onSelect)==null||d.call(u,u),t("select",u),i())};return Tn(i),()=>{var u,d;return C("div",{ref:r,class:ke("dropdown",{"is-open":a.value})},[((u=n.trigger)==null?void 0:u.call(n,{open:a.value,toggle:l}))||C(Rr,{variant:e.variant,icon:e.icon,"aria-expanded":a.value?"true":"false",onClick:l},()=>e.label),C("div",{class:"dropdown-menu",role:"menu"},((d=n.default)==null?void 0:d.call(n,{close:i}))||e.items.map(_=>C("button",{class:ke("dropdown-item",_.danger&&"dropdown-item-danger"),type:"button",role:"menuitem",disabled:_.disabled,onClick:()=>c(_)},[mt(_.icon),_.label])))])}}}),BI=0,GI=We({name:"GnDrawer",props:{open:{type:Boolean,default:!1},title:{type:String,default:""},position:{type:String,default:"right"}},emits:["update:open","close"],setup(e,{emit:t,slots:n}){const a=`gn-drawer-title-${++BI}`,r=j(null);let i=null;const o=()=>{t("update:open",!1),t("close")},s=l=>{l.key==="Escape"?(l.preventDefault(),o()):US(l,r.value)};return je(()=>e.open,l=>{var c;l?(i=document.activeElement,document.addEventListener("keydown",s),Ht(()=>{var u;return(u=r.value)==null?void 0:u.focus()})):(document.removeEventListener("keydown",s),(c=i==null?void 0:i.focus)==null||c.call(i),i=null)},{flush:"post"}),Tn(()=>{document.removeEventListener("keydown",s)}),()=>{var l,c;return e.open?C(ri,{to:"body"},[C("div",{class:ke("drawer a-show",{"drawer-left":e.position==="left"}),"aria-hidden":"false"},[C("div",{class:"drawer-backdrop",onClick:o}),C("aside",{ref:r,class:"drawer-panel",role:"dialog","aria-modal":"true","aria-labelledby":a,tabindex:"-1"},[C("header",{class:"drawer-header"},[C("h4",{class:"drawer-title",id:a},((l=n.title)==null?void 0:l.call(n))||e.title),C("button",{class:"btn-icon drawer-close",type:"button","aria-label":"Close",onClick:o},[mt("ph-x")])]),C("div",{class:"drawer-body"},(c=n.default)==null?void 0:c.call(n)),n.footer&&C("footer",{class:"drawer-footer"},n.footer({close:o}))])])]):null}}}),YI=We({name:"GnEmptyState",props:{title:{type:String,required:!0},text:{type:String,default:""},icon:{type:String,default:"ph-package"},variant:{type:String,default:""}},setup(e,{attrs:t,slots:n}){return()=>{var a,r;return C("div",{...t,class:ke("empty-state",e.variant&&`empty-state-${e.variant}`,t.class)},[C("div",{class:"empty-state-icon"},[mt(e.icon)]),C("h3",{class:"empty-state-title"},((a=n.title)==null?void 0:a.call(n))||e.title),(e.text||n.default)&&C("p",{class:"empty-state-text"},((r=n.default)==null?void 0:r.call(n))||e.text),n.actions&&C("div",{class:"empty-state-actions"},n.actions())])}}});function pE(e){const t=e.name.split(".").pop();return t?t.slice(0,6).toUpperCase():"FILE"}function $I(e){if(!e.size)return"0 B";const t=["B","KB","MB","GB"],n=Math.min(Math.floor(Math.log(e.size)/Math.log(1024)),t.length-1),a=e.size/Math.pow(1024,n);return`${a.toFixed(a>=10||n===0?0:1)} ${t[n]}`}var qI=We({name:"GnFileUpload",props:{modelValue:{type:Array,default:()=>[]},title:{type:String,default:"Upload files"},description:{type:String,default:"Attach documents, archives or images."},primary:{type:String,default:"Choose files"},secondary:{type:String,default:"Images get thumbnails, other files show their type"},badge:{type:String,default:""},multiple:{type:Boolean,default:!0},accept:{type:String,default:""}},emits:["update:modelValue","change"],setup(e,{emit:t,slots:n}){const a=j(new Map),r=c=>{const u=a.value.get(c);u&&(URL.revokeObjectURL(u),a.value.delete(c))},i=()=>{a.value.forEach(c=>URL.revokeObjectURL(c)),a.value.clear()},o=c=>{const u=Array.from(c||[]);t("update:modelValue",u),t("change",u)},s=c=>{r(e.modelValue[c]);const u=e.modelValue.filter((d,_)=>_!==c);t("update:modelValue",u),t("change",u)},l=c=>{var u;return(u=c.type)!=null&&u.startsWith("image/")?(a.value.has(c)||a.value.set(c,URL.createObjectURL(c)),a.value.get(c)):""};return je(()=>e.modelValue,c=>{const u=new Set(c);[...a.value.keys()].forEach(d=>{u.has(d)||r(d)})}),Tn(i),()=>{var c,u;return C("div",{class:"file-upload-panel"},[C("div",{class:"file-upload-form"},[C("div",{class:"file-upload-header"},[C("div",{class:"file-upload-heading"},[C("h3",{class:"file-upload-title"},((c=n.title)==null?void 0:c.call(n))||e.title),C("p",{class:"file-upload-description"},((u=n.description)==null?void 0:u.call(n))||e.description)]),e.badge&&C(FS,{variant:"info"},()=>e.badge)]),C("label",{class:"file-upload-dropzone"},[C("span",{class:"file-upload-icon","aria-hidden":"true"},[mt("ph-cloud-arrow-up")]),C("span",{class:"file-upload-body"},[C("span",{class:"file-upload-primary"},e.primary),C("span",{class:"file-upload-secondary"},e.secondary)]),C("input",{type:"file",multiple:e.multiple,accept:e.accept||void 0,onChange:d=>o(d.target.files)})]),C("div",{class:"file-upload-preview",hidden:!e.modelValue.length},e.modelValue.map((d,_)=>C("figure",{class:"file-upload-preview-item"},[C("button",{class:"file-upload-preview-remove",type:"button","aria-label":`Remove ${d.name}`,onClick:()=>s(_)},[mt("ph-x")]),C("div",{class:"file-upload-preview-visual"},l(d)?C("img",{src:l(d),alt:""}):C("span",{class:"file-upload-preview-type"},pE(d))),C("figcaption",{},[C("span",{class:"file-upload-preview-name"},d.name),C("span",{class:"file-upload-preview-meta"},`${pE(d)} / ${$I(d)}`)])]))),n.actions&&C("div",{class:"file-upload-actions"},n.actions()),!n.actions&&e.modelValue.length>0&&C("div",{class:"file-upload-actions"},[C(Rr,{variant:"secondary",size:"sm",onClick:()=>{i(),o([])}},()=>"Reset")])])])}}}),kr=We({name:"GnIconButton",props:{icon:{type:String,required:!0},label:{type:String,required:!0},type:{type:String,default:"button"},withoutHover:{type:Boolean,default:!1}},setup(e,{attrs:t}){return()=>C("button",{...t,type:e.type,"aria-label":e.label,class:ke("btn-icon",{"without-hover":e.withoutHover},t.class)},[mt(e.icon)])}}),HI=We({name:"GnIdentity",props:{title:{type:String,required:!0},meta:{type:String,default:""},avatar:{type:Object,default:()=>({})}},setup(e,{slots:t}){return()=>{var n,a,r;return C("span",{class:"identity"},[((n=t.avatar)==null?void 0:n.call(t))||C(_d,e.avatar),C("span",{class:"identity-content"},[C("span",{class:"identity-title"},((a=t.title)==null?void 0:a.call(t))||e.title),(e.meta||t.meta)&&C("span",{class:"identity-meta"},((r=t.meta)==null?void 0:r.call(t))||e.meta)])])}}}),VI=We({name:"GnInput",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},type:{type:String,default:"text"},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n}){return()=>C("div",{class:"form-group"},[C("label",{class:ke("label",e.state)},[e.label,mt(e.icon),C("input",{...t,type:e.type,value:e.modelValue,class:ke("input",t.class),onInput:a=>n("update:modelValue",yr(a))})]),e.help&&C("div",{class:ke("input-info",e.state==="error"&&"error")},e.help)])}}),zI=We({name:"GnInputGroup",props:{compact:{type:Boolean,default:!1},addon:{type:String,default:""},icon:{type:String,default:""}},setup(e,{attrs:t,slots:n}){return()=>{var a,r;return C("div",{...t,class:ke("input-group",{"input-group-compact":e.compact},t.class)},[(e.addon||e.icon||n.addon)&&C("span",{class:"input-group-addon"},((a=n.addon)==null?void 0:a.call(n))||mt(e.icon)||e.addon),(r=n.default)==null?void 0:r.call(n),n.action&&C("span",{class:"input-group-action"},n.action())])}}}),WI=We({name:"GnList",props:{items:{type:Array,default:()=>[]},ordered:{type:Boolean,default:!1},icons:{type:Boolean,default:!1}},setup(e,{attrs:t,slots:n}){const a=e.ordered?"ol":"ul";return()=>C(a,{...t,class:ke("list",{"list-ordered":e.ordered,"with-icons":e.icons},t.class)},e.items.map(r=>{var i;return C("li",{class:"list-item"},[mt(r.icon),((i=n.item)==null?void 0:i.call(n,{item:r}))||r.label||r])}))}}),KI=We({name:"GnLoader",props:{circle:{type:Boolean,default:!1},label:{type:String,default:"Loading"}},setup(e,{attrs:t}){return()=>e.circle?C("div",{...t,class:ke("circle-loader",t.class)},[mt("ph-bold ph-spinner normalize"),e.label]):C("div",{...t,class:ke("loader",t.class),role:"status","aria-label":e.label})}}),QI=We({name:"GnMetricCard",props:{label:{type:String,required:!0},value:{type:[String,Number],required:!0},icon:{type:String,default:"ph-chart-line-up"},delta:{type:String,default:""},negative:{type:Boolean,default:!1},meta:{type:String,default:""}},setup(e,{attrs:t,slots:n}){return()=>{var a,r,i;return C("article",{...t,class:ke("card metric-card",t.class)},[C("div",{class:"card-content"},[C("div",{class:"metric-card-header"},[C("p",{class:"metric-card-label"},((a=n.label)==null?void 0:a.call(n))||e.label),C("span",{class:"metric-card-icon"},[mt(e.icon)])]),C("p",{class:"metric-card-value"},((r=n.value)==null?void 0:r.call(n))||e.value),(e.delta||e.meta||n.meta)&&C("div",{class:"metric-card-meta"},[e.delta&&C("span",{class:ke("metric-card-delta",{"metric-card-delta-negative":e.negative})},e.delta),((i=n.meta)==null?void 0:i.call(n))||e.meta])])])}}}),GS=We({name:"GnNavList",props:{items:{type:Array,default:()=>[]}},emits:["select"],setup(e,{attrs:t,emit:n,slots:a}){return()=>C("ul",{...t,class:ke("list list-nav",t.class)},e.items.map(r=>{var i,o;return C("li",{class:ke("list-item",{"list-item-active":r.active})},[C(r.href?"a":"button",{class:"list-action",href:r.href,type:r.href?void 0:"button",onClick:s=>{var l;(l=r.onSelect)==null||l.call(r,r,s),n("select",r)}},[C("span",{class:"list-label"},[mt(r.icon),((i=a.label)==null?void 0:i.call(a,{item:r}))||r.label]),(r.meta||a.meta)&&C("span",{class:"list-meta"},((o=a.meta)==null?void 0:o.call(a,{item:r}))||r.meta)])])}))}}),XI=0,ZI=We({name:"GnNavigationShell",props:{brand:{type:String,default:"GNexus UI Kit"},logoSrc:{type:String,default:"/assets/imgs/gnexus-mark.svg"},current:{type:String,default:""},title:{type:String,default:"Sections"},subtitle:{type:String,default:"Navigation"},footerLeft:{type:String,default:""},footerRight:{type:String,default:""},items:{type:Array,default:()=>[]}},emits:["select"],setup(e,{emit:t,slots:n}){const a=j(!1),r=`gn-nav-drawer-${++XI}`,i=j(null);let o=null;const s=()=>{a.value=!1},l=()=>{a.value=!a.value},c=u=>{u.key==="Escape"&&(u.preventDefault(),s())};return je(a,u=>{var d;u?(o=document.activeElement,document.body.classList.add("nav-drawer-open"),document.addEventListener("keydown",c),Ht(()=>{var _;return(_=i.value)==null?void 0:_.focus()})):(document.body.classList.remove("nav-drawer-open"),document.removeEventListener("keydown",c),(d=o==null?void 0:o.focus)==null||d.call(o),o=null)}),Tn(()=>{document.body.classList.remove("nav-drawer-open"),document.removeEventListener("keydown",c)}),()=>{var u,d,_,m,p,g,b;return[C("header",{class:"nav-topbar"},[C("button",{class:"nav-topbar-toggle",type:"button","aria-controls":r,"aria-expanded":a.value?"true":"false",onClick:l},[mt("ph-sidebar-simple"),C("span",{},"Menu")]),C("div",{class:"nav-topbar-brand"},[e.logoSrc&&C("img",{src:e.logoSrc,alt:"","aria-hidden":"true"}),C("span",{},((u=n.brand)==null?void 0:u.call(n))||e.brand)]),C("div",{class:"nav-topbar-current"},((d=n.current)==null?void 0:d.call(n))||e.current)]),C("div",{class:"nav-drawer-backdrop",onClick:s}),C("aside",{ref:i,class:["nav-drawer",{"is-open":a.value}],id:r,"aria-label":"Navigation","aria-hidden":a.value?"false":"true",tabindex:"-1"},[C("header",{class:"nav-drawer-header"},[C("div",{},[C("div",{class:"nav-drawer-title"},((_=n.title)==null?void 0:_.call(n))||e.title),C("div",{class:"nav-drawer-subtitle"},((m=n.subtitle)==null?void 0:m.call(n))||e.subtitle)]),C("button",{class:"nav-drawer-close",type:"button","aria-label":"Close navigation",onClick:s},[mt("ph-x")])]),C("nav",{class:"nav-drawer-body"},[((p=n.default)==null?void 0:p.call(n,{close:s}))||C(GS,{items:e.items,onSelect:A=>{t("select",A),s()}})]),(n.footer||e.footerLeft||e.footerRight)&&C("footer",{class:"nav-drawer-footer"},((g=n.footer)==null?void 0:g.call(n))||[C("span",{},e.footerLeft),C("span",{},e.footerRight)])]),(b=n.content)==null?void 0:b.call(n)]}}}),JI=We({name:"GnPageHeader",props:{title:{type:String,required:!0},subtitle:{type:String,default:""},kicker:{type:String,default:""},compact:{type:Boolean,default:!1},accent:{type:Boolean,default:!1}},setup(e,{attrs:t,slots:n}){return()=>{var a,r,i;return C("header",{...t,class:ke("page-header",{"page-header-compact":e.compact,"page-header-accent":e.accent},t.class)},[C("div",{class:"page-header-content"},[(e.kicker||n.kicker)&&C("div",{class:"page-header-kicker"},((a=n.kicker)==null?void 0:a.call(n))||e.kicker),C("h1",{class:"page-header-title"},((r=n.title)==null?void 0:r.call(n))||e.title),(e.subtitle||n.subtitle)&&C("p",{class:"page-header-subtitle"},((i=n.subtitle)==null?void 0:i.call(n))||e.subtitle),n.meta&&C("div",{class:"page-header-meta"},n.meta())]),n.actions&&C("div",{class:"page-header-actions"},n.actions())])}}}),jI=We({name:"GnPagination",props:{page:{type:Number,required:!0},totalPages:{type:Number,required:!0},ariaLabel:{type:String,default:"Pagination"}},emits:["update:page"],setup(e,{emit:t}){const n=a=>{a>=1&&a<=e.totalPages&&a!==e.page&&t("update:page",a)};return()=>{const a=Array.from({length:e.totalPages},(r,i)=>i+1);return C("nav",{class:"pagination","aria-label":e.ariaLabel},[C("button",{class:"pagination-item",type:"button",disabled:e.page<=1,onClick:()=>n(e.page-1)},[mt("ph-arrow-left")]),a.map(r=>C("button",{class:ke("pagination-item",{"pagination-item-active":r===e.page}),type:"button","aria-current":r===e.page?"page":void 0,onClick:()=>n(r)},r)),C("button",{class:"pagination-item",type:"button",disabled:e.page>=e.totalPages,onClick:()=>n(e.page+1)},[mt("ph-arrow-right")])])}}}),eD=We({name:"GnPopover",props:{label:{type:String,default:"Details"},title:{type:String,default:""},text:{type:String,default:""},icon:{type:String,default:"ph-info"},variant:{type:String,default:"accent"}},setup(e,{slots:t}){const n=j(!1),a=j(null),r=()=>{n.value=!1,document.removeEventListener("click",i),document.removeEventListener("keydown",o)},i=l=>{a.value&&!a.value.contains(l.target)&&r()},o=l=>{l.key==="Escape"&&(l.preventDefault(),r())},s=()=>{n.value=!n.value,n.value?(setTimeout(()=>document.addEventListener("click",i),0),document.addEventListener("keydown",o)):r()};return Tn(r),()=>{var l,c,u;return C("div",{ref:a,class:ke("popover",{"is-open":n.value})},[((l=t.trigger)==null?void 0:l.call(t,{open:n.value,toggle:s}))||C(Rr,{variant:e.variant,icon:e.icon,"aria-expanded":n.value?"true":"false",onClick:s},()=>e.label),C("div",{class:"popover-panel"},[(e.title||t.title)&&C("h3",{class:"popover-title"},((c=t.title)==null?void 0:c.call(t))||e.title),(e.text||t.default)&&C("p",{class:"popover-text"},((u=t.default)==null?void 0:u.call(t))||e.text)])])}}}),YS=We({name:"GnProgress",props:{value:{type:Number,required:!0},max:{type:Number,default:100},label:{type:String,default:""},variant:{type:String,default:"secondary"},striped:{type:Boolean,default:!1},animated:{type:Boolean,default:!1}},setup(e,{attrs:t,slots:n}){return()=>{var a;const r=Math.max(0,Math.min(100,Math.round(e.value/e.max*100))),i=fa(e.variant,"secondary");return C("div",{...t,class:ke("progress",`progress-${i}`,{"progress-striped":e.striped,"progress-animated":e.animated},t.class),style:{"--progress-value":`${r}%`}},[(e.label||n.label)&&C("div",{class:"progress-header"},[C("span",{},((a=n.label)==null?void 0:a.call(n))||e.label),C("span",{class:"progress-value"},`${r}%`)]),C("div",{class:"progress-track"},[C("span",{class:"progress-bar",role:"progressbar","aria-valuenow":e.value,"aria-valuemin":0,"aria-valuemax":e.max})])])}}}),tD=We({name:"GnProgressStages",props:{items:{type:Array,default:()=>[]}},setup(e,{attrs:t}){return()=>C("div",{...t,class:ke("progress-stages",t.class)},e.items.map(n=>C("div",{class:ke("progress-stage",{"progress-stage-complete":n.status==="complete","progress-stage-current":n.status==="current"})},n.label||n)))}}),$S=We({name:"GnRadio",inheritAttrs:!1,props:{modelValue:{type:[String,Number,Boolean],default:""},value:{type:[String,Number,Boolean],required:!0},label:{type:String,default:""},name:{type:String,default:""},disabled:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n,slots:a}){return()=>{var r;return C("label",{class:ke("radio",t.class)},[C("input",{...t,type:"radio",name:e.name,value:e.value,checked:e.modelValue===e.value,disabled:e.disabled,onChange:()=>n("update:modelValue",e.value)}),C("span",{class:"radio-control","aria-hidden":"true"}),C("span",{class:"radio-label"},((r=a.default)==null?void 0:r.call(a))||e.label)])}}}),nD=We({name:"GnRadioGroup",props:{modelValue:{type:[String,Number,Boolean],default:""},name:{type:String,default:"gn-radio-group"},label:{type:String,default:""},options:{type:Array,default:()=>[]}},emits:["update:modelValue"],setup(e,{emit:t,slots:n}){return()=>{var a;return C("div",{class:"form-group",role:"radiogroup","aria-label":e.label||void 0},[e.label&&C("div",{class:"label"},e.label),((a=n.default)==null?void 0:a.call(n))||e.options.map(r=>C($S,{modelValue:e.modelValue,"onUpdate:modelValue":i=>t("update:modelValue",i),name:e.name,value:r.value,label:r.label,disabled:r.disabled}))])}}}),aD=We({name:"GnRange",inheritAttrs:!1,props:{modelValue:{type:[Number,String],default:0},label:{type:String,default:""},min:{type:[Number,String],default:0},max:{type:[Number,String],default:100},step:{type:[Number,String],default:1}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n}){return()=>C("div",{class:"range"},[C("label",{class:"label"},[e.label,C("input",{...t,type:"range",value:e.modelValue,min:e.min,max:e.max,step:e.step,onInput:a=>n("update:modelValue",yr(a))})])])}}),rD=We({name:"GnSearchField",inheritAttrs:!1,props:{modelValue:{type:String,default:""},placeholder:{type:String,default:"Search"},compact:{type:Boolean,default:!0},clearable:{type:Boolean,default:!0}},emits:["update:modelValue","clear"],setup(e,{attrs:t,emit:n}){const a=()=>{n("update:modelValue",""),n("clear")};return()=>C("div",{class:ke("input-group search-field",{"input-group-compact":e.compact})},[C("span",{class:"input-group-addon"},[mt("ph-magnifying-glass")]),C("input",{...t,type:"search",value:e.modelValue,placeholder:e.placeholder,class:ke("input-group-input",t.class),onInput:r=>n("update:modelValue",yr(r))}),e.clearable&&C("button",{class:"input-group-action",type:"button","aria-label":"Clear search",onClick:a},[mt("ph-x")])])}}),iD=We({name:"GnSelect",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""},options:{type:Array,default:()=>[]}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n,slots:a}){const r=()=>e.options.map(i=>{const o=typeof i=="object"?i.value:i,s=typeof i=="object"?i.label:i;return C("option",{value:o},s)});return()=>{var i;return C("div",{class:"form-group"},[C("label",{class:ke("label",e.state)},[e.label,mt(e.icon),C("div",{class:"select-wrap"},[C("select",{...t,value:e.modelValue,class:ke("input select",t.class),onChange:o=>n("update:modelValue",yr(o))},((i=a.default)==null?void 0:i.call(a))||r())])]),e.help&&C("div",{class:ke("input-info",e.state==="error"&&"error")},e.help)])}}}),oD=We({name:"GnSkeleton",props:{type:{type:String,default:"line"},stack:{type:Boolean,default:!1},count:{type:Number,default:1}},setup(e,{attrs:t}){const n=a=>C("span",{key:a,...t,class:ke("skeleton",`skeleton-${e.type}`,t.class)});return()=>e.stack?C("div",{class:"skeleton-stack"},Array.from({length:e.count},(a,r)=>n(r))):n(0)}}),sD=We({name:"GnSteps",props:{items:{type:Array,required:!0},vertical:{type:Boolean,default:!1}},setup(e,{attrs:t}){return()=>C("ol",{...t,class:ke("steps",{"steps-vertical":e.vertical},t.class)},e.items.map((n,a)=>C("li",{class:ke("step",{"step-complete":n.status==="complete","step-current":n.status==="current","step-disabled":n.disabled||n.status==="disabled"})},[C("span",{class:"step-marker"},n.marker||String(a+1)),C("h3",{class:"step-title"},n.title),n.text&&C("p",{class:"step-text"},n.text)])))}}),lD=We({name:"GnStatusCard",props:{title:{type:String,required:!0},text:{type:String,default:""},icon:{type:String,default:"ph-stack"},variant:{type:String,default:"primary"}},setup(e,{attrs:t,slots:n}){const a=fa(e.variant);return()=>{var r,i,o;return C("article",{...t,class:ke("card status-card",`card-${a}`,t.class)},[C("span",{class:"card-title"},((r=n.title)==null?void 0:r.call(n))||e.title),C("div",{class:"card-content"},[C("div",{class:"status-icon-container"},[C("div",{class:"status-icon"},((i=n.icon)==null?void 0:i.call(n))||[mt(e.icon)])]),(e.text||n.default)&&C("p",{class:"status-name"},((o=n.default)==null?void 0:o.call(n))||e.text)])])}}}),cD=We({name:"GnTable",props:{columns:{type:Array,required:!0},rows:{type:Array,default:()=>[]},caption:{type:String,default:""},emptyText:{type:String,default:"Empty"}},setup(e,{attrs:t,slots:n}){return()=>{var a;return C("div",{class:"table-wrapper"},[C("table",{class:ke("table data-list",{"table-empty":!e.rows.length},t.class)},[e.caption&&C("caption",{class:"table-caption"},e.caption),C("thead",{class:"table-head"},[C("tr",{class:"table-row"},e.columns.map(r=>C("th",{scope:"col"},r.label)))]),C("tbody",{class:"table-body"},e.rows.length?e.rows.map(r=>C("tr",{class:"table-row"},e.columns.map(i=>{var o;const s=`cell-${i.key}`;return C("td",{},((o=n[s])==null?void 0:o.call(n,{row:r,column:i,value:r[i.key]}))||r[i.key])}))):C("tr",{},[C("td",{class:"is-empty",colspan:e.columns.length},((a=n.empty)==null?void 0:a.call(n))||e.emptyText)]))])])}}}),uD=We({name:"GnTabs",props:{modelValue:{type:String,default:""},items:{type:Array,required:!0},compact:{type:Boolean,default:!1},vertical:{type:Boolean,default:!1},ariaLabel:{type:String,default:"Tabs"}},emits:["update:modelValue"],setup(e,{emit:t,slots:n}){const a=ge(()=>{var l,c;return e.modelValue||((l=e.items.find(u=>!u.disabled))==null?void 0:l.id)||((c=e.items[0])==null?void 0:c.id)}),r=l=>{l.disabled||t("update:modelValue",l.id)},i=()=>e.items.filter(l=>!l.disabled),o=(l,c)=>{const u=i(),d=u.findIndex(m=>m.id===l.id),_=u[(d+c+u.length)%u.length];r(_)},s=(l,c)=>{if(l.key==="ArrowRight"||l.key==="ArrowDown")l.preventDefault(),o(c,1);else if(l.key==="ArrowLeft"||l.key==="ArrowUp")l.preventDefault(),o(c,-1);else if(l.key==="Home")l.preventDefault(),r(i()[0]);else if(l.key==="End"){l.preventDefault();const u=i();r(u[u.length-1])}};return()=>C("div",{class:ke("tabs",{"tabs-compact":e.compact,"tabs-vertical":e.vertical})},[C("div",{class:"tabs-list",role:"tablist","aria-label":e.ariaLabel},e.items.map(l=>{const c=l.id===a.value,u=`${l.id}-panel`;return C("button",{class:ke("tab",{"tab-active":c}),type:"button",role:"tab","aria-selected":c?"true":"false","aria-controls":u,"aria-disabled":l.disabled?"true":void 0,tabindex:c?"0":"-1",onClick:()=>r(l),onKeydown:d=>s(d,l)},[mt(l.icon),l.label])})),C("div",{class:"tabs-panels"},e.items.map(l=>{var c,u;const d=l.id===a.value;return C("div",{id:`${l.id}-panel`,class:ke("tab-panel",{"tab-panel-active":d}),role:"tabpanel",hidden:!d},((c=n[l.id])==null?void 0:c.call(n,{item:l,active:d}))||d&&((u=n.default)==null?void 0:u.call(n,{item:l,active:d})))}))])}}),dD=We({name:"GnTextarea",inheritAttrs:!1,props:{modelValue:{type:String,default:""},label:{type:String,default:""},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""}},emits:["update:modelValue"],setup(e,{attrs:t,emit:n}){return()=>C("div",{class:"form-group"},[C("label",{class:ke("label",e.state)},[e.label,mt(e.icon),C("textarea",{...t,value:e.modelValue,class:ke("input",t.class),onInput:a=>n("update:modelValue",yr(a))})]),e.help&&C("div",{class:ke("input-info",e.state==="error"&&"error")},e.help)])}}),_D=We({name:"GnTimeline",props:{items:{type:Array,default:()=>[]}},setup(e,{attrs:t,slots:n}){return()=>C("ol",{...t,class:ke("timeline",t.class)},e.items.map(a=>{var r,i;const o=a.variant?fa(a.variant):"";return C("li",{class:ke("timeline-item",o&&`timeline-item-${o}`)},[C("span",{class:"timeline-marker"},[mt(a.icon||"ph-circle")]),C("div",{class:"timeline-content"},[C("article",{class:"timeline-card"},[C("header",{class:"timeline-header"},[C("h3",{class:"timeline-title"},a.title),a.time&&C("time",{class:"timeline-time"},a.time)]),C("p",{class:"timeline-text"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.text),(a.meta||n.meta)&&C("div",{class:"timeline-meta"},((i=n.meta)==null?void 0:i.call(n,{item:a}))||a.meta)])])])}))}}),pD=We({name:"GnTooltip",props:{text:{type:String,default:""}},setup(e,{attrs:t,slots:n}){const a=j(!1);return()=>{var r,i;return C("span",{...t,class:ke("tooltip",{"is-open":a.value},t.class),onFocusin:()=>{a.value=!0},onFocusout:()=>{a.value=!1}},[(r=n.default)==null?void 0:r.call(n),C("span",{class:"tooltip-panel",role:"tooltip"},((i=n.panel)==null?void 0:i.call(n))||e.text)])}}}),mD=We({name:"GnToolbar",props:{title:{type:String,default:""},meta:{type:String,default:""}},setup(e,{attrs:t,slots:n}){return()=>{var a,r,i,o;return C("div",{...t,class:ke("toolbar",t.class)},[C("div",{class:"toolbar-group"},[C("div",{},[(e.title||n.title)&&C("h3",{class:"toolbar-title"},((a=n.title)==null?void 0:a.call(n))||e.title),(e.meta||n.meta)&&C("span",{class:"toolbar-meta"},((r=n.meta)==null?void 0:r.call(n))||e.meta)])]),(n.default||n.actions)&&C("div",{class:"toolbar-group"},((i=n.actions)==null?void 0:i.call(n))||((o=n.default)==null?void 0:o.call(n)))])}}}),qS=Symbol("gnexus-ui-kit-toast"),mE={info:"ph-info",success:"ph-check-circle",warning:"ph-warning",danger:"ph-warning-octagon",error:"ph-warning-octagon",primary:"ph-info",secondary:"ph-info"},gD=We({name:"GnToastProvider",props:{lifetime:{type:Number,default:4e3}},setup(e,{slots:t,expose:n}){const a=j(null);let r=null;const i=()=>{a.value=null,window.clearTimeout(r),r=null},o=l=>{const c=fa(l.variant||l.type||"info","info");a.value={id:Date.now(),variant:c==="error"?"danger":c,title:l.title||"",text:l.text||l.message||"",icon:l.icon||mE[c]||mE.info},window.clearTimeout(r),l.lifetime!==0&&(r=window.setTimeout(i,l.lifetime||e.lifetime))},s={show:o,close:i,info:l=>o({...l,variant:"info"}),success:l=>o({...l,variant:"success"}),warning:l=>o({...l,variant:"warning"}),danger:l=>o({...l,variant:"danger"}),error:l=>o({...l,variant:"danger"})};return Va(qS,s),n(s),()=>{var l;return[(l=t.default)==null?void 0:l.call(t),a.value&&C("div",{class:ke("toast a-show",`toast-${a.value.variant}`),role:"alert"},[C("div",{class:"toast-content"},[C("h4",{class:"toast-title"},[mt(a.value.icon),a.value.title]),C("p",{class:"toast-text"},a.value.text)]),C("button",{class:"btn-icon toast-close",type:"button","aria-label":"Close",onClick:i},[mt("ph-x")])])]}}}),ED=We({name:"GnUsageMeter",props:{title:{type:String,required:!0},value:{type:Number,required:!0},max:{type:Number,default:100},meta:{type:String,default:""}},setup(e,{slots:t}){return()=>{var n,a;const r=Math.max(0,Math.min(100,Math.round(e.value/e.max*100)));return C("section",{class:"usage-meter"},[C("h3",{class:"usage-meter-title"},[((n=t.title)==null?void 0:n.call(t))||e.title,C("span",{class:"usage-meter-value"},`${r}%`)]),C(YS,{value:e.value,max:e.max}),(e.meta||t.meta)&&C("p",{class:"usage-meter-meta"},((a=t.meta)==null?void 0:a.call(t))||e.meta)])}}});function pd(){const e=_a(qS,null);if(e)return e;const t=()=>{throw new Error("GNexus UI Kit: useToast() requires near the app root.")};return{show:t,info:t,success:t,warning:t,danger:t,error:t,close:t}}var fD={GnAccordion:RI,GnActionCard:CI,GnActionList:yI,GnActivityLog:NI,GnAlert:OI,GnAvatar:_d,GnAvatarStack:AI,GnBadge:FS,GnButton:Rr,GnCard:II,GnCheckbox:_E,GnChip:DI,GnChipGroup:xI,GnCombobox:wI,GnConfirmDialog:PI,GnDescriptionList:kI,GnDefinitionList:UI,GnDropdown:FI,GnDrawer:GI,GnEmptyState:YI,GnFileUpload:qI,GnIconButton:kr,GnIdentity:HI,GnInput:VI,GnInputGroup:zI,GnList:WI,GnLoader:KI,GnMetricCard:QI,GnModal:BS,GnNavList:GS,GnNavigationShell:ZI,GnPageHeader:JI,GnPagination:jI,GnPopover:eD,GnProgress:YS,GnProgressStages:tD,GnRadio:$S,GnRadioGroup:nD,GnRange:aD,GnSearchField:rD,GnSelect:iD,GnSkeleton:oD,GnSteps:sD,GnStatusCard:lD,GnSwitch:_E,GnTable:cD,GnTabs:uD,GnTextarea:dD,GnTimeline:_D,GnTooltip:pD,GnToolbar:mD,GnToastProvider:gD,GnUsageMeter:ED},SD={install(e){Object.entries(fD).forEach(([t,n])=>{e.component(t,n)})}};const bD=location.protocol==="https:"?"wss":"ws",TD=`${bD}://${location.host}`,hD=3,vD=1e3,RD=15e3,CD=20;function yD(e){const t=`${TD}/ws/sessions/${e}`,n=localStorage.getItem("navi_api_token");return n?`${t}?api_token=${encodeURIComponent(n)}`:t}function ND(){const e=on(),t=pd(),n=j(!1),a=j(!1),r=j(!1);let i=null,o=null,s=0,l=null,c=!1,u=!1,d=[];function _(M){c=!1,o=M,s=0,r.value=!1,d=[],g()}function m(){c=!0,clearTimeout(l),i==null||i.close(),i=null,d=[],n.value=!1,a.value=!1}function p(M){return(i==null?void 0:i.readyState)===WebSocket.OPEN?(i.send(JSON.stringify(M)),!0):(d.length>=CD&&d.shift(),d.push(M),a.value=!0,(!i||i.readyState===WebSocket.CLOSED||i.readyState===WebSocket.CLOSING)&&g(),!1)}function g(){c||u||(u=!0,i&&(i.onclose=null,i.close()),i=new WebSocket(yD(o)),i.onopen=()=>{u=!1,n.value=!0,a.value=!1,r.value=!1,s=0,b()},i.onmessage=M=>{let w;try{w=JSON.parse(M.data)}catch{return}O(w)},i.onclose=()=>{u=!1,n.value=!1,c||A()},i.onerror=()=>{})}function b(){if(!i||i.readyState!==WebSocket.OPEN||!d.length)return;const M=d;d=[];for(const w of M)i.send(JSON.stringify(w))}function A(){if(!c)if(a.value=!0,s++,s<=hD){const M=vD*Math.pow(2,s-1);l=setTimeout(g,M)}else r.value=!0,a.value=!1,l=setTimeout(()=>{c||(a.value=!0,g())},RD)}function O(M){switch(M.type){case"stream_start":e.onStreamStart();break;case"thinking_delta":e.onThinkingDelta(M.delta??"");break;case"thinking_end":e.onThinkingEnd();break;case"turn_thinking":e.onTurnThinking(M);break;case"planning_status":e.onPlanningStatus(M);break;case"plan_ready":e.onPlanReady(M);break;case"tool_started":e.onToolStarted(M);break;case"tool_call":e.onToolCall(M);break;case"terminal_output":e.onTerminalOutput(M);break;case"terminal_closed":e.onTerminalClosed(M);break;case"terminal_opened":e.onTerminalOpened(M);break;case"task_update":e.onTaskUpdate(M);break;case"message_queued":e.onMessageQueued(M);break;case"stream_delta":e.onStreamDelta(M.delta??"");break;case"stream_end":e.onStreamEnd(M);break;case"stream_stopped":e.onStreamStopped();break;case"profile_switched":e.onProfileSwitched(M);break;case"compression_started":e.onCompressionStarted(M);break;case"context_compressed":e.onContextCompressed(M);break;case"error":e.onError(M);break;case"replay_start":e.onReplayStart();break;case"replay_end":e.onReplayEnd();break;case"heartbeat":break;case"recall_update":e.onRecallUpdate(M);break;case"session_sync":o&&!e.streaming&&e.reloadSession(o);break;case"mcp_status_update":M.status==="connected"?t.success({title:"MCP server connected",text:`${M.server_name} (${M.tool_count??"?"} tools)`}):t.error({title:"MCP server disconnected",text:M.server_name});break}}return ea(m),{connected:n,reconnecting:a,reconnectFailed:r,connect:_,disconnect:m,send:p}}const OD={key:0,class:"profile-badge"},AD={class:"profile-badge-name"},HS={__name:"ProfileBadge",props:{profileId:{type:String,default:null},showAvatar:{type:Boolean,default:!0}},setup(e){const t=e,n=li(),a=ge(()=>t.profileId?n.getProfile(t.profileId):null);function r(i){return i?i.split(/\s+/).map(o=>o[0]).join("").slice(0,2).toUpperCase():"?"}return(i,o)=>{const s=xt("GnAvatar");return a.value?(N(),U("div",OD,[e.showAvatar?(N(),ut(s,{key:0,size:"sm",initials:r(a.value.name)},null,8,["initials"])):ue("",!0),f("span",AD,ie(a.value.name),1)])):ue("",!0)}}},ID=Object.freeze(Object.defineProperty({__proto__:null,default:HS},Symbol.toStringTag,{value:"Module"})),DD=["title"],xD={__name:"ContextBar",setup(e){const t=on(),n=ge(()=>t.maxContextTokens?Math.min(100,Math.round(t.contextTokens/t.maxContextTokens*100)):0),a=ge(()=>n.value>=80?"is-crit":n.value>=60?"is-warn":"");function r(i){return i>=1e3?(i/1e3).toFixed(1).replace(".0","")+"k":String(i)}return(i,o)=>J(t).maxContextTokens>0?(N(),U("div",{key:0,class:"context-bar",title:`${r(J(t).contextTokens)} / ${r(J(t).maxContextTokens)} tokens`},[f("span",{class:He(["context-bar-pct",a.value])},ie(n.value)+"%",3)],8,DD)):ue("",!0)}},VS=Mt(xD,[["__scopeId","data-v-fe8d0787"]]),MD=Object.freeze(Object.defineProperty({__proto__:null,default:VS},Symbol.toStringTag,{value:"Module"})),wD={class:"chat-header"},LD={class:"chat-header-info"},PD={class:"chat-header-title"},kD={key:0,class:"artifact-count"},UD={key:0,class:"recall-banner"},FD={class:"recall-text"},BD={__name:"ChatHeader",emits:["toggle-sidebar","toggle-artifacts"],setup(e,{emit:t}){const n=t,a=on(),r=Zn(),i=ge(()=>{var d;const u=r.sessions.find(_=>_.session_id===a.currentId);return(u==null?void 0:u.name)||(((d=a.currentId)==null?void 0:d.slice(0,8))??"Navi")}),o=ge(()=>a.artifacts.length);function s(u){return u?new Date(u).toLocaleString():""}je(()=>a.currentId,a.loadRecall,{immediate:!0});async function l(){if(a.currentId)try{await mS(a.currentId),a.recall=null,r.updateRecallStatus(a.currentId,!1)}catch(u){console.error("cancel recall failed",u)}}async function c(){if(a.currentId)try{await gS(a.currentId),await a.loadRecall()}catch(u){console.error("skip recall failed",u)}}return(u,d)=>{const _=xt("GnIconButton");return N(),U(Ze,null,[f("div",wD,[we(_,{icon:"ph ph-sidebar",label:"Menu",class:"btn-sidebar-toggle",onClick:d[0]||(d[0]=m=>n("toggle-sidebar"))}),f("div",LD,[f("span",PD,ie(i.value),1),we(HS,{"profile-id":J(a).currentProfileId,"show-avatar":!1},null,8,["profile-id"])]),we(VS),we(_,{icon:"ph ph-files",label:"Artifacts",class:"btn-artifacts-toggle",onClick:d[1]||(d[1]=m=>n("toggle-artifacts"))},{default:_t(()=>[o.value?(N(),U("span",kD,ie(o.value),1)):ue("",!0)]),_:1})]),J(a).recall?(N(),U("div",UD,[d[4]||(d[4]=f("i",{class:"ph ph-clock"},null,-1)),f("span",FD," Scheduled "+ie(J(a).recall.call_type)+" recall at "+ie(s(J(a).recall.trigger_at)),1),f("button",{class:"recall-btn",title:"Cancel",onClick:l},[...d[2]||(d[2]=[f("i",{class:"ph ph-clock-slash"},null,-1)])]),J(a).recall.call_type==="recurring"?(N(),U("button",{key:0,class:"recall-btn",title:"Skip next",onClick:c},[...d[3]||(d[3]=[f("i",{class:"ph ph-skip-forward"},null,-1)])])):ue("",!0)])):ue("",!0)],64)}}},GD=Mt(BD,[["__scopeId","data-v-a43d8e5c"]]);function md(){const e=j(!1);async function t(n){var a;if(n){if((a=navigator.clipboard)!=null&&a.writeText)await navigator.clipboard.writeText(n);else{const r=document.createElement("textarea");r.value=n,r.style.cssText="position:fixed;opacity:0",document.body.appendChild(r),r.select();try{document.execCommand("copy")}finally{document.body.removeChild(r)}}e.value=!0,setTimeout(()=>{e.value=!1},1500)}}return{copied:e,copy:t}}const YD={class:"msg-user-wrap"},$D={key:0,class:"msg-recall-badge"},qD=["innerHTML"],HD={key:1,class:"msg-user-attachments"},VD=["src","onClick"],zD={class:"msg-user-footer"},WD={key:0,class:"msg-time msg-time--user"},KD={__name:"UserMessage",props:{msg:{type:Object,required:!0},isFlashing:{type:Boolean,default:!1}},setup(e){const t=e,n=ge(()=>t.msg.time),a=dd(n),{open:r}=_o(),{copied:i,copy:o}=md();function s(c){return c.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function l(c){if(!c)return"";const u=c.split(` -`);let d=[],_=[];for(const g of u)g.startsWith("> ")?d.push(s(g.slice(2))):g.trim()&&_.push(s(g));const m=d.length?`
${d.join("
")}
`:"",p=_.join(" ");return m+p}return(c,u)=>{var _,m;const d=xt("GnIconButton");return N(),U("div",{class:He(["msg-user",{"msg-user--recall":e.msg.isRecall}])},[f("div",YD,[f("div",{class:He(["msg-user-bubble",{"msg-flash":t.isFlashing}])},[e.msg.isRecall?(N(),U("div",$D,[...u[1]||(u[1]=[f("i",{class:"ph ph-clock"},null,-1),f("span",null,"Scheduled recall",-1)])])):ue("",!0),f("div",{class:"msg-user-text",innerHTML:l(e.msg.text)},null,8,qD),(_=e.msg.images)!=null&&_.length||(m=e.msg.files)!=null&&m.length?(N(),U("div",HD,[(N(!0),U(Ze,null,Ut(e.msg.images,(p,g)=>(N(),U("img",{key:`img-${g}`,src:p,class:"msg-user-image",onClick:b=>J(r)(p)},null,8,VD))),128)),(N(!0),U(Ze,null,Ut(e.msg.files,(p,g)=>(N(),U("span",{key:`file-${g}`,class:"msg-user-file-pill"},[u[2]||(u[2]=f("i",{class:"ph ph-file"},null,-1)),Et(" "+ie(p.name),1)]))),128))])):ue("",!0)],2),f("div",zD,[J(a)?(N(),U("span",WD,ie(J(a)),1)):ue("",!0),we(d,{icon:J(i)?"ph ph-check":"ph ph-copy",label:J(i)?"Copied!":"Copy",class:"msg-copy-btn",onClick:u[0]||(u[0]=p=>J(o)(e.msg.text))},null,8,["icon","label"])])])],2)}}},QD={key:0,class:"spinner"},XD={class:"thinking-body"},Fu={__name:"ThinkingCard",props:{msg:{type:Object,required:!0}},setup(e){const t=e,n=j(null),a=ge(()=>{var i;return(((i=t.msg.thinking)==null?void 0:i.text)??"").replace(/^\s*/i,"").replace(/\s*<\/thought>\s*$/i,"").replace(/^thought\s*:?\s*\n+/i,"").trim()});return(r,i)=>(N(),U("details",{ref_key:"detailsEl",ref:n,class:"thinking-card"},[f("summary",null,[i[0]||(i[0]=f("i",{class:"ph ph-brain"},null,-1)),i[1]||(i[1]=Et(" Thinking ",-1)),e.msg.thinking.done?ue("",!0):(N(),U("span",QD)),i[2]||(i[2]=f("i",{class:"ph ph-caret-down thinking-chevron"},null,-1))]),f("div",XD,ie(a.value),1)],512))}};/*! @license DOMPurify 3.4.15 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.15/LICENSE */function gE(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,a=Array(t);n2?a-2:0),i=2;i1?n-1:0),r=1;r"u"?null:zt(BigInt.prototype.toString),hE=typeof Symbol>"u"?null:zt(Symbol.prototype.toString),bn=zt(Object.prototype.hasOwnProperty),xr=zt(Object.prototype.toString),en=zt(RegExp.prototype.test),Ya=ux(TypeError);function zt(e){return function(t){t instanceof RegExp&&(t.lastIndex=0);for(var n=arguments.length,a=new Array(n>1?n-1:0),r=1;r2&&arguments[2]!==void 0?arguments[2]:Ur;if(EE&&EE(e,null),!fr(t))return e;let a=t.length;for(;a--;){let r=t[a];if(typeof r=="string"){const i=n(r);i!==r&&(nx(t)||(t[a]=i),r=i)}e[r]=!0}return e}function dx(e){for(let t=0;t/g),Sx=Qt(/\${[\w\W]*/g),bx=Qt(/^data-[\-\w.\u00B7-\uFFFF]+$/),Tx=Qt(/^aria-[\-\w]+$/),NE=Qt(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),hx=Qt(/^(?:\w+script|data):/i),vx=Qt(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),Rx=Qt(/^html$/i),Cx=Qt(/^[a-z][.\w]*(-[.\w]+)+$/i),OE=Qt(/<[/\w!]/g),AE=Qt(/<[/\w]/g),yx=Qt(/<\/no(script|embed|frames)/i),Nx=Qt(/\/>/i),Rn={element:1,attribute:2,text:3,cdataSection:4,entityReference:5,entityNode:6,processingInstruction:7,comment:8,document:9,documentType:10,documentFragment:11,notation:12},KS=["style","script","xmp","iframe","noembed","noframes","plaintext","noscript"],Ox=Wt(pt({},KS)),Ax=(function(){const e={};return qa(KS,t=>{e[t]=Qt(new RegExp("])","i"))}),Wt(e)})(),Ix=function(){return typeof window>"u"?null:window},Dx=function(t,n){if(typeof t!="object"||typeof t.createPolicy!="function")return null;let a=null;const r="data-tt-policy-suffix";n&&n.hasAttribute(r)&&(a=n.getAttribute(r));const i="dompurify"+(a?"#"+a:"");try{return t.createPolicy(i,{createHTML(o){return o},createScriptURL(o){return o}})}catch{return console.warn("TrustedTypes policy "+i+" could not be created."),null}},IE=function(){return{afterSanitizeAttributes:[],afterSanitizeElements:[],afterSanitizeShadowDOM:[],beforeSanitizeAttributes:[],beforeSanitizeElements:[],beforeSanitizeShadowDOM:[],uponSanitizeAttribute:[],uponSanitizeElement:[],uponSanitizeShadowNode:[]}},Ra=function(t,n,a,r){return bn(t,n)&&fr(t[n])?pt(r.base?Cn(r.base):{},t[n],r.transform):a},gu=function(t,n,a){const r=bn(t,n)?t[n]:void 0;return r&&typeof r=="object"?Cn(r):a()};function QS(){let e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:Ix();const t=me=>QS(me);if(t.version="3.4.15",t.removed=[],!e||!e.document||e.document.nodeType!==Rn.document||!e.Element)return t.isSupported=!1,t;let n=e.document;const a=n,r=a.currentScript;e.DocumentFragment;const i=e.HTMLTemplateElement,o=e.Node,s=e.Element,l=e.NodeFilter,c=e.NamedNodeMap;c===void 0&&(e.NamedNodeMap||e.MozNamedAttrMap),e.HTMLFormElement;const u=e.DOMParser,d=e.trustedTypes,_=s.prototype,m=xn(_,"cloneNode"),p=xn(_,"remove"),g=xn(_,"removeAttributeNode"),b=xn(_,"nextSibling"),A=xn(_,"childNodes"),O=xn(_,"parentNode"),M=xn(_,"shadowRoot"),w=xn(_,"attributes"),v=o&&o.prototype?xn(o.prototype,"nodeType"):null,T=o&&o.prototype?xn(o.prototype,"nodeName"):null,I=o&&o.prototype?xn(o.prototype,"ownerDocument"):null,h=function(S){return v?v(S):S.nodeType},E=function(S){return T?T(S):S.nodeName};if(typeof i=="function"){const me=n.createElement("template");me.content&&me.content.ownerDocument&&(n=me.content.ownerDocument)}let D,x="",L,ae=!1,Ee=0;const xe=function(){if(Ee>0)throw Ya('A configured TRUSTED_TYPES_POLICY callback (createHTML or createScriptURL) must not call DOMPurify.sanitize, as that causes infinite recursion. Do not pass a policy whose callbacks wrap DOMPurify as TRUSTED_TYPES_POLICY; see the "DOMPurify and Trusted Types" section of the README.')},Se=function(S){xe(),Ee++;try{return D.createHTML(S)}finally{Ee--}},pe=function(S){xe(),Ee++;try{return D.createScriptURL(S)}finally{Ee--}},Le=function(){return ae||(L=Dx(d,r),ae=!0),L},be=n,Xe=be.implementation,et=be.createNodeIterator,it=be.createDocumentFragment,St=be.getElementsByTagName,Ot=a.importNode;let qe=IE();t.isSupported=typeof zS=="function"&&typeof O=="function"&&Xe&&Xe.createHTMLDocument!==void 0;const lt=Ex,V=fx,te=Sx,ve=bx,Ie=Tx,Be=hx,R=vx,k=Cx;let z=NE,K=null;const ee=pt({},[...vE,...du,..._u,...pu,...RE]);let X=null;const _e=pt({},[...CE,...mu,...yE,...hi]);let oe=Object.seal(dr(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),le=null,re=null;const Me=Object.seal(dr(null,{tagCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeCheck:{writable:!0,configurable:!1,enumerable:!0,value:null}}));let Ce=!0,Re=!0,Pe=!1,Ve=!0,Ke=!1,y=!0,B=!1,W=!1,Y=null,q=null,ne=!1,de=!1,fe=!1,ye=!1,Ue=!0,tt=!1;const Rt="user-content-";let Fe=!0,ct=!1,at={},ze=null;const P=pt({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","selectedcontent","style","svg","template","thead","title","video","xmp"]);let Z=null;const he=pt({},["audio","video","img","source","image","track"]);let G=null;const $=pt({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),Ne="http://www.w3.org/1998/Math/MathML",H="http://www.w3.org/2000/svg",ce="http://www.w3.org/1999/xhtml";let Oe=ce,Je=!1,$e=null;const Yt=pt({},[Ne,H,ce],uu),$t=Wt(["mi","mo","mn","ms","mtext"]);let Xt=pt({},$t);const An=Wt(["annotation-xml"]);let st=pt({},An);const Pt=pt({},["title","style","font","a","script"]);let Kt=null;const hn=["application/xhtml+xml","text/html"],Fn="text/html";let bt=null,Ct=null;const In=n.createElement("form"),Bn=function(S){return S instanceof RegExp||S instanceof Function},At=function(){let S=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};if(Ct&&Ct===S)return;(!S||typeof S!="object")&&(S={}),S=Cn(S),Kt=hn.indexOf(S.PARSER_MEDIA_TYPE)===-1?Fn:S.PARSER_MEDIA_TYPE,bt=Kt==="application/xhtml+xml"?uu:Ur,K=Ra(S,"ALLOWED_TAGS",ee,{transform:bt}),X=Ra(S,"ALLOWED_ATTR",_e,{transform:bt}),$e=Ra(S,"ALLOWED_NAMESPACES",Yt,{transform:uu}),G=Ra(S,"ADD_URI_SAFE_ATTR",$,{transform:bt,base:$}),Z=Ra(S,"ADD_DATA_URI_TAGS",he,{transform:bt,base:he}),ze=Ra(S,"FORBID_CONTENTS",P,{transform:bt}),le=Ra(S,"FORBID_TAGS",Cn({}),{transform:bt}),re=Ra(S,"FORBID_ATTR",Cn({}),{transform:bt}),at=bn(S,"USE_PROFILES")?S.USE_PROFILES&&typeof S.USE_PROFILES=="object"?Cn(S.USE_PROFILES):S.USE_PROFILES:!1,Ce=S.ALLOW_ARIA_ATTR!==!1,Re=S.ALLOW_DATA_ATTR!==!1,Pe=S.ALLOW_UNKNOWN_PROTOCOLS||!1,Ve=S.ALLOW_SELF_CLOSE_IN_ATTR!==!1,Ke=S.SAFE_FOR_TEMPLATES||!1,y=S.SAFE_FOR_XML!==!1,B=S.WHOLE_DOCUMENT||!1,de=S.RETURN_DOM||!1,fe=S.RETURN_DOM_FRAGMENT||!1,ye=S.RETURN_TRUSTED_TYPE||!1,ne=S.FORCE_BODY||!1,Ue=S.SANITIZE_DOM!==!1,tt=S.SANITIZE_NAMED_PROPS||!1,Fe=S.KEEP_CONTENT!==!1,ct=S.IN_PLACE||!1,z=px(S.ALLOWED_URI_REGEXP)?S.ALLOWED_URI_REGEXP:NE,Oe=typeof S.NAMESPACE=="string"?S.NAMESPACE:ce,Xt=gu(S,"MATHML_TEXT_INTEGRATION_POINTS",()=>pt({},$t)),st=gu(S,"HTML_INTEGRATION_POINTS",()=>pt({},An));const F=gu(S,"CUSTOM_ELEMENT_HANDLING",()=>dr(null));if(oe=dr(null),bn(F,"tagNameCheck")&&Bn(F.tagNameCheck)&&(oe.tagNameCheck=F.tagNameCheck),bn(F,"attributeNameCheck")&&Bn(F.attributeNameCheck)&&(oe.attributeNameCheck=F.attributeNameCheck),bn(F,"allowCustomizedBuiltInElements")&&typeof F.allowCustomizedBuiltInElements=="boolean"&&(oe.allowCustomizedBuiltInElements=F.allowCustomizedBuiltInElements),Qt(oe),Ke&&(Re=!1),fe&&(de=!0),at&&(K=pt({},RE),X=dr(null),at.html===!0&&(pt(K,vE),pt(X,CE)),at.svg===!0&&(pt(K,du),pt(X,mu),pt(X,hi)),at.svgFilters===!0&&(pt(K,_u),pt(X,mu),pt(X,hi)),at.mathMl===!0&&(pt(K,pu),pt(X,yE),pt(X,hi))),Me.tagCheck=null,Me.attributeCheck=null,bn(S,"ADD_TAGS")&&(typeof S.ADD_TAGS=="function"?Me.tagCheck=S.ADD_TAGS:fr(S.ADD_TAGS)&&(K===ee&&(K=Cn(K)),pt(K,S.ADD_TAGS,bt))),bn(S,"ADD_ATTR")&&(typeof S.ADD_ATTR=="function"?Me.attributeCheck=S.ADD_ATTR:fr(S.ADD_ATTR)&&(X===_e&&(X=Cn(X)),pt(X,S.ADD_ATTR,bt))),bn(S,"ADD_FORBID_CONTENTS")&&fr(S.ADD_FORBID_CONTENTS)&&(ze===P&&(ze=Cn(ze)),pt(ze,S.ADD_FORBID_CONTENTS,bt)),Fe&&(K["#text"]=!0),B&&pt(K,["html","head","body"]),K.table&&(pt(K,["tbody"]),delete le.tbody),S.TRUSTED_TYPES_POLICY){if(typeof S.TRUSTED_TYPES_POLICY.createHTML!="function")throw Ya('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if(typeof S.TRUSTED_TYPES_POLICY.createScriptURL!="function")throw Ya('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');const Q=D;D=S.TRUSTED_TYPES_POLICY;try{x=Se("")}catch(se){throw D=Q,se}}else S.TRUSTED_TYPES_POLICY===null?(D=void 0,x=""):(D===void 0&&(D=Le()),D&&typeof x=="string"&&(x=Se("")));Wt&&Wt(S),Ct=S},ta=pt({},[...du,..._u,...mx]),ir=pt({},[...pu,...gx]),ui=function(S,F,Q){return F.namespaceURI===ce?S==="svg":F.namespaceURI===Ne?S==="svg"&&(Q==="annotation-xml"||Xt[Q]):!!ta[S]},di=function(S,F,Q){return F.namespaceURI===ce?S==="math":F.namespaceURI===H?S==="math"&&st[Q]:!!ir[S]},_i=function(S,F,Q){return F.namespaceURI===H&&!st[Q]||F.namespaceURI===Ne&&!Xt[Q]?!1:!ir[S]&&(Pt[S]||!ta[S])},xa=function(S){let F=O(S);(!F||!F.tagName)&&(F={namespaceURI:Oe,tagName:"template"});const Q=Ur(S.tagName),se=Ur(F.tagName);return $e[S.namespaceURI]?S.namespaceURI===H?ui(Q,F,se):S.namespaceURI===Ne?di(Q,F,se):S.namespaceURI===ce?_i(Q,F,se):!!(Kt==="application/xhtml+xml"&&$e[S.namespaceURI]):!1},wn=function(S){Ir(t.removed,{element:S});try{O(S).removeChild(S)}catch{if(p(S),!O(S))throw Ya("a node selected for removal could not be detached from its tree and cannot be safely returned; refusing to sanitize in place")}},Te=function(S,F,Q){try{g(S,F)}catch{try{S.removeAttribute(Q)}catch{}}},Ge=function(S){kt(S);const F=A(S);if(F){const se=[];qa(F,Ae=>{Ir(se,Ae)}),qa(se,Ae=>{try{p(Ae)}catch{}})}const Q=w(S);if(Q)for(let se=Q.length-1;se>=0;--se){const Ae=Q[se],Ye=Ae&&Ae.name;typeof Ye=="string"&&Te(S,Ae,Ye)}},ot=function(S,F,Q){if(!Q)try{Q=F.getAttributeNode(S)}catch{Q=null}Ir(t.removed,{attribute:Q||null,from:F});try{Q?g(F,Q):F.removeAttribute(S)}catch{try{F.removeAttribute(S)}catch{}}if(S==="is")if(de||fe)try{wn(F)}catch{}else try{F.setAttribute(S,"")}catch{}},yt=function(S){const F=w(S);if(F)for(let Q=F.length-1;Q>=0;--Q){const se=F[Q],Ae=se&&se.name;typeof Ae!="string"||X[bt(Ae)]||Te(S,se,Ae)}},kt=function(S){const F=[S];for(;F.length>0;){const Q=F.pop();h(Q)===Rn.element&&yt(Q);const Ae=A(Q);if(Ae)for(let Ye=Ae.length-1;Ye>=0;--Ye)F.push(Ae[Ye])}},sn=function(S,F){return y?S==="patchsrc"?!0:S==="for"&&F!=="label"&&F!=="output":!1},Ln=function(S){if(!y)return;const F=[S];for(;F.length>0;){const Q=F.pop(),se=h(Q);if(se===Rn.processingInstruction||se===Rn.comment&&en(AE,Q.data)){try{p(Q)}catch{}continue}if(se===Rn.element){const Ye=Q,Nt=bt(E(Q));try{Ye.hasAttribute&&Ye.hasAttribute("patchsrc")&&Ye.removeAttribute("patchsrc"),Ye.hasAttribute&&Ye.hasAttribute("for")&&sn("for",Nt)&&Ye.removeAttribute("for")}catch{}}const Ae=A(Q);if(Ae)for(let Ye=Ae.length-1;Ye>=0;--Ye)F.push(Ae[Ye])}},Sa=function(S){let F=null,Q=null;if(ne)S=""+S;else{const Ye=SE(S,/^[\r\n\t ]+/);Q=Ye&&Ye[0]}Kt==="application/xhtml+xml"&&Oe===ce&&(S=''+S+"");const se=D?Se(S):S;if(Oe===ce)try{F=new u().parseFromString(se,Kt)}catch{}if(!F||!F.documentElement){F=Xe.createDocument(Oe,"template",null);try{F.documentElement.innerHTML=Je?x:se}catch{}}const Ae=F.body||F.documentElement;return S&&Q&&Ae.insertBefore(n.createTextNode(Q),Ae.childNodes[0]||null),Oe===ce?St.call(F,B?"html":"body")[0]:B?F.documentElement:Ae},Zt=function(S){const F=I?I(S):S.ownerDocument;return et.call(F||S,S,l.SHOW_ELEMENT|l.SHOW_COMMENT|l.SHOW_TEXT|l.SHOW_PROCESSING_INSTRUCTION|l.SHOW_CDATA_SECTION,null)},jt=function(S){return S=Dr(S,lt," "),S=Dr(S,V," "),S=Dr(S,te," "),S},Ma=function(S){var F;S.normalize();const Q=I?I(S):S.ownerDocument,se=et.call(Q||S,S,l.SHOW_TEXT|l.SHOW_COMMENT|l.SHOW_CDATA_SECTION|l.SHOW_PROCESSING_INSTRUCTION,null);let Ae=se.nextNode();for(;Ae;)Ae.data=jt(Ae.data),Ae=se.nextNode();const Ye=(F=S.querySelectorAll)===null||F===void 0?void 0:F.call(S,"template");Ye&&qa(Ye,Nt=>{Gn(Nt.content)&&Ma(Nt.content)})},ba=function(S){const F=T?T(S):null;return typeof F!="string"||bt(F)!=="form"?!1:typeof S.nodeName!="string"||typeof S.textContent!="string"||typeof S.removeChild!="function"||S.attributes!==w(S)||typeof S.removeAttribute!="function"||typeof S.removeAttributeNode!="function"||typeof S.getAttributeNode!="function"||typeof S.setAttribute!="function"||typeof S.namespaceURI!="string"||typeof S.insertBefore!="function"||typeof S.hasChildNodes!="function"||S.nodeType!==v(S)||S.childNodes!==A(S)},Gn=function(S){if(!v||typeof S!="object"||S===null)return!1;try{return v(S)===Rn.documentFragment}catch{return!1}},Ta=function(S){if(!v||typeof S!="object"||S===null)return!1;try{return typeof v(S)=="number"}catch{return!1}};function vn(me,S,F){me.length!==0&&qa(me,Q=>{Q.call(t,S,F,Ct)})}const pi=function(S,F){return!!(y&&S.hasChildNodes()&&!Ta(S.firstElementChild)&&en(OE,S.textContent)&&en(OE,S.innerHTML)||y&&S.namespaceURI===ce&&Ox[F]&&(Ta(S.firstElementChild)||typeof S.textContent=="string"&&en(Ax[F],S.textContent))||S.nodeType===Rn.processingInstruction||y&&S.nodeType===Rn.comment&&en(AE,S.data))},wa=function(S,F){if(S instanceof RegExp)return en(S,F);if(S instanceof Function){for(var Q=arguments.length,se=new Array(Q>2?Q-2:0),Ae=2;Ae=0;--Nt){const wt=S===Q?m(Ae[Nt],!0):Ae[Nt];se.insertBefore(wt,b(S))}}}return wn(S),!0},Pa=function(S,F,Q,se){return S.length===0?F:F===Q||F===se?Cn(F):F},ln=function(S,F){return S===F||O(S)!==null?!1:(ct&&kt(S),!0)},or=function(S,F){if(vn(qe.beforeSanitizeElements,S,null),ln(S,F))return!0;if(ba(S))return wn(S),!0;const Q=bt(E(S));if(K=Pa(qe.uponSanitizeElement,K,ee,Y),vn(qe.uponSanitizeElement,S,{tagName:Q,allowedTags:K}),ln(S,F))return!0;if(pi(S,Q))return wn(S),!0;if(le[Q]||!(Me.tagCheck instanceof Function&&Me.tagCheck(Q))&&!K[Q]){const Ae=La(S,Q,F);return Ae===!1&&vn(qe.afterSanitizeElements,S,null),Ae}if(h(S)===Rn.element&&!xa(S)||(Q==="noscript"||Q==="noembed"||Q==="noframes")&&en(yx,S.innerHTML))return wn(S),!0;if(Ke&&S.nodeType===Rn.text){const Ae=jt(S.textContent);S.textContent!==Ae&&(Ir(t.removed,{element:S.cloneNode()}),S.textContent=Ae)}return vn(qe.afterSanitizeElements,S,null),!1},ha=function(S,F,Q){if(re[F]||sn(F,S)||Ue&&(F==="id"||F==="name")&&(Q in n||Q in In))return!1;const se=X[F]||Me.attributeCheck instanceof Function&&Me.attributeCheck(F,S);return Re&&en(ve,F)||Ce&&en(Ie,F)?!0:se?G[F]||en(z,Dr(Q,R,""))||(F==="src"||F==="xlink:href"||F==="href")&&S!=="script"&&bE(Q,"data:")===0&&Z[S]||Pe&&!en(Be,Dr(Q,R,""))?!0:!Q:ka(S)&&wa(oe.tagNameCheck,S)&&wa(oe.attributeNameCheck,F,S)||F==="is"&&oe.allowCustomizedBuiltInElements&&wa(oe.tagNameCheck,Q)},nt=pt({},["annotation-xml","color-profile","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","missing-glyph"]),ka=function(S){return!nt[Ur(S)]&&en(k,S)},qt=function(S,F,Q,se){if(D&&typeof d=="object"&&typeof d.getAttributeType=="function"&&!Q)switch(d.getAttributeType(S,F)){case"TrustedHTML":return Se(se);case"TrustedScriptURL":return pe(se)}return se},ft=function(S,F,Q,se){try{return Q?S.setAttributeNS(Q,F,se):S.setAttribute(F,se),ba(S)?(wn(S),!1):!0}catch{return ot(F,S),!1}},Yn=function(S){vn(qe.beforeSanitizeAttributes,S,null);const F=S.attributes;if(!F||ba(S))return;X=Pa(qe.uponSanitizeAttribute,X,_e,q);const Q={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:X,forceKeepAttr:void 0};let se=F.length;const Ae=bt(S.nodeName);for(;se--;){const Ye=F[se],Nt=Ye.name,wt=Ye.namespaceURI,fn=Ye.value,Sn=bt(Nt),Eo=fn;let un=Nt==="value"?Eo:sx(Eo),Od=!1;if(Q.attrName=Sn,Q.attrValue=un,Q.keepAttr=!0,Q.forceKeepAttr=void 0,vn(qe.uponSanitizeAttribute,S,Q),un=Q.attrValue,tt&&(Sn==="id"||Sn==="name")&&bE(un,Rt)!==0&&(ot(Nt,S,Ye),un=Rt+un,Od=!0),y&&en(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i,un)){ot(Nt,S,Ye);continue}if(Sn==="attributename"&&SE(un,"href")){ot(Nt,S,Ye);continue}if(!Q.forceKeepAttr){if(!Q.keepAttr){ot(Nt,S,Ye);continue}if(!Ve&&en(Nx,un)){ot(Nt,S,Ye);continue}if(Ke&&(un=jt(un)),!ha(Ae,Sn,un)){ot(Nt,S,Ye);continue}un=qt(Ae,Sn,wt,un),un!==Eo&&ft(S,Nt,wt,un)&&Od&&fE(t.removed)}}vn(qe.afterSanitizeAttributes,S,null)},cn=function(S){let F=null;const Q=Zt(S);for(vn(qe.beforeSanitizeShadowDOM,S,null);F=Q.nextNode();)if(vn(qe.uponSanitizeShadowNode,F,null),or(F,S),Yn(F),Gn(F.content)&&cn(F.content),h(F)===Rn.element){const se=M(F);Gn(se)&&(na(se),cn(se))}vn(qe.afterSanitizeShadowDOM,S,null)},na=function(S){const F=[{node:S,shadow:null}];for(;F.length>0;){const Q=F.pop();if(Q.shadow){cn(Q.shadow);continue}const se=Q.node,Ye=h(se)===Rn.element,Nt=A(se);if(Nt)for(let wt=Nt.length-1;wt>=0;--wt)F.push({node:Nt[wt],shadow:null});if(Ye){const wt=T?T(se):null;if(typeof wt=="string"&&bt(wt)==="template"){const fn=se.content;Gn(fn)&&F.push({node:fn,shadow:null})}}if(Ye){const wt=M(se);Gn(wt)&&F.push({node:null,shadow:wt},{node:wt,shadow:null})}}};return t.sanitize=function(me){let S=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},F=null,Q=null,se=null,Ae=null;if(Je=!me,Je&&(me=""),typeof me!="string"&&!Ta(me)&&(me=_x(me),typeof me!="string"))throw Ya("dirty is not a string, aborting");if(!t.isSupported)return me;W?(K=Y,X=q):At(S),(qe.uponSanitizeElement.length>0||qe.uponSanitizeAttribute.length>0)&&(K=Cn(K)),qe.uponSanitizeAttribute.length>0&&(X=Cn(X)),t.removed=[];const Ye=ct&&typeof me!="string"&&Ta(me);if(Ye){Ln(me);const fn=E(me);if(typeof fn=="string"){const Sn=bt(fn);if(!K[Sn]||le[Sn])throw Ge(me),Ya("root node is forbidden and cannot be sanitized in-place")}if(ba(me))throw Ge(me),Ya("root node is clobbered and cannot be sanitized in-place");try{na(me)}catch(Sn){throw Ge(me),Sn}}else if(Ta(me))F=Sa(""),Q=F.ownerDocument.importNode(me,!0),Q.nodeType===Rn.element&&Q.nodeName==="BODY"||Q.nodeName==="HTML"?F=Q:F.appendChild(Q),na(F);else{if(!de&&!Ke&&!B&&me.indexOf("<")===-1)return D&&ye?Se(me):me;if(F=Sa(me),!F)return de?null:ye?x:""}F&&ne&&wn(F.firstChild);const Nt=Ye?me:F;try{const fn=Zt(Nt);for(;se=fn.nextNode();)or(se,Nt),Yn(se),Gn(se.content)&&cn(se.content)}catch(fn){throw Ye&&(Ge(me),qa(t.removed,Sn=>{Sn.element&&kt(Sn.element)})),fn}if(Ye)return qa(t.removed,fn=>{fn.element&&kt(fn.element)}),Ke&&Ma(me),me;if(de){if(Ke&&Ma(F),fe)for(Ae=it.call(F.ownerDocument);F.firstChild;)Ae.appendChild(F.firstChild);else Ae=F;return(X.shadowroot||X.shadowrootmode)&&(Ae=Ot.call(a,Ae,!0)),Ae}let wt=B?F.outerHTML:F.innerHTML;return B&&K["!doctype"]&&F.ownerDocument&&F.ownerDocument.doctype&&F.ownerDocument.doctype.name&&en(Rx,F.ownerDocument.doctype.name)&&(wt=" -`+wt),Ke&&(wt=jt(wt)),D&&ye?Se(wt):wt},t.setConfig=function(){let me=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};At(me),W=!0,Y=K,q=X},t.clearConfig=function(){Ct=null,W=!1,Y=null,q=null,D=L,x=""},t.isValidAttribute=function(me,S,F){Ct||At({});const Q=bt(me),se=bt(S);return ha(Q,se,F)},t.addHook=function(me,S){typeof S=="function"&&bn(qe,me)&&Ir(qe[me],S)},t.removeHook=function(me,S){if(bn(qe,me)){if(S!==void 0){const F=ix(qe[me],S);return F===-1?void 0:ox(qe[me],F,1)[0]}return fE(qe[me])}},t.removeHooks=function(me){bn(qe,me)&&(qe[me]=[])},t.removeAllHooks=function(){qe=IE()},t}var xx=QS();function gd(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var rr=gd();function XS(e){rr=e}var Vr={exec:()=>null};function vt(e,t=""){let n=typeof e=="string"?e:e.source;const a={replace:(r,i)=>{let o=typeof i=="string"?i:i.source;return o=o.replace(mn.caret,"$1"),n=n.replace(r,o),a},getRegex:()=>new RegExp(n,t)};return a}var mn={codeRemoveIndent:/^(?: {1,4}| {0,3}\t)/gm,outputLinkReplace:/\\([\[\]])/g,indentCodeCompensation:/^(\s+)(?:```)/,beginningSpace:/^\s+/,endingHash:/#$/,startingSpaceChar:/^ /,endingSpaceChar:/ $/,nonSpaceChar:/[^ ]/,newLineCharGlobal:/\n/g,tabCharGlobal:/\t/g,multipleSpaceGlobal:/\s+/g,blankLine:/^[ \t]*$/,doubleBlankLine:/\n[ \t]*\n[ \t]*$/,blockquoteStart:/^ {0,3}>/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceTabs:/^\t+/,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] /,listReplaceTask:/^\[[ xX]\] +/,anyLine:/\n.*\n/,hrefBrackets:/^<(.*)>$/,tableDelimiter:/[:|]/,tableAlignChars:/^\||\| *$/g,tableRowBlankLine:/\n[ \t]*$/,tableAlignRight:/^ *-+: *$/,tableAlignCenter:/^ *:-+: *$/,tableAlignLeft:/^ *:-+ *$/,startATag:/^/i,startPreScriptTag:/^<(pre|code|kbd|script)(\s|>)/i,endPreScriptTag:/^<\/(pre|code|kbd|script)(\s|>)/i,startAngleBracket:/^$/,pedanticHrefTitle:/^([^'"]*[^\s])\s+(['"])(.*)\2/,unicodeAlphaNumeric:/[\p{L}\p{N}]/u,escapeTest:/[&<>"']/,escapeReplace:/[&<>"']/g,escapeTestNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,escapeReplaceNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,unescapeTest:/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:e=>new RegExp(`^( {0,3}${e})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`),hrRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),fencesBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:\`\`\`|~~~)`),headingBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}#`),htmlBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}<(?:[a-z].*>|!--)`,"i")},Mx=/^(?:[ \t]*(?:\n|$))+/,wx=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,Lx=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,ci=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,Px=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,Ed=/(?:[*+-]|\d{1,9}[.)])/,ZS=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,JS=vt(ZS).replace(/bull/g,Ed).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/\|table/g,"").getRegex(),kx=vt(ZS).replace(/bull/g,Ed).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/table/g,/ {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(),fd=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,Ux=/^[^\n]+/,Sd=/(?!\s*\])(?:\\.|[^\[\]\\])+/,Fx=vt(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",Sd).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),Bx=vt(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g,Ed).getRegex(),po="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",bd=/|$))/,Gx=vt("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$))","i").replace("comment",bd).replace("tag",po).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),jS=vt(fd).replace("hr",ci).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("|table","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",po).getRegex(),Yx=vt(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",jS).getRegex(),Td={blockquote:Yx,code:wx,def:Fx,fences:Lx,heading:Px,hr:ci,html:Gx,lheading:JS,list:Bx,newline:Mx,paragraph:jS,table:Vr,text:Ux},DE=vt("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",ci).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("blockquote"," {0,3}>").replace("code","(?: {4}| {0,3} )[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",po).getRegex(),$x={...Td,lheading:kx,table:DE,paragraph:vt(fd).replace("hr",ci).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",DE).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",po).getRegex()},qx={...Td,html:vt(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment",bd).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:Vr,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:vt(fd).replace("hr",ci).replace("heading",` *#{1,6} *[^ -]`).replace("lheading",JS).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},Hx=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,Vx=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,eb=/^( {2,}|\\)\n(?!\s*$)/,zx=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\]*?>/g,ab=/^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/,Zx=vt(ab,"u").replace(/punct/g,mo).getRegex(),Jx=vt(ab,"u").replace(/punct/g,nb).getRegex(),rb="^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)",jx=vt(rb,"gu").replace(/notPunctSpace/g,tb).replace(/punctSpace/g,hd).replace(/punct/g,mo).getRegex(),eM=vt(rb,"gu").replace(/notPunctSpace/g,Qx).replace(/punctSpace/g,Kx).replace(/punct/g,nb).getRegex(),tM=vt("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,tb).replace(/punctSpace/g,hd).replace(/punct/g,mo).getRegex(),nM=vt(/\\(punct)/,"gu").replace(/punct/g,mo).getRegex(),aM=vt(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme",/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email",/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(),rM=vt(bd).replace("(?:-->|$)","-->").getRegex(),iM=vt("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment",rM).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),qi=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,oM=vt(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label",qi).replace("href",/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),ib=vt(/^!?\[(label)\]\[(ref)\]/).replace("label",qi).replace("ref",Sd).getRegex(),ob=vt(/^!?\[(ref)\](?:\[\])?/).replace("ref",Sd).getRegex(),sM=vt("reflink|nolink(?!\\()","g").replace("reflink",ib).replace("nolink",ob).getRegex(),vd={_backpedal:Vr,anyPunctuation:nM,autolink:aM,blockSkip:Xx,br:eb,code:Vx,del:Vr,emStrongLDelim:Zx,emStrongRDelimAst:jx,emStrongRDelimUnd:tM,escape:Hx,link:oM,nolink:ob,punctuation:Wx,reflink:ib,reflinkSearch:sM,tag:iM,text:zx,url:Vr},lM={...vd,link:vt(/^!?\[(label)\]\((.*?)\)/).replace("label",qi).getRegex(),reflink:vt(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",qi).getRegex()},Yu={...vd,emStrongRDelimAst:eM,emStrongLDelim:Jx,url:vt(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,"i").replace("email",/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),_backpedal:/(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":">",'"':""","'":"'"},xE=e=>uM[e];function Hn(e,t){if(t){if(mn.escapeTest.test(e))return e.replace(mn.escapeReplace,xE)}else if(mn.escapeTestNoEncode.test(e))return e.replace(mn.escapeReplaceNoEncode,xE);return e}function ME(e){try{e=encodeURI(e).replace(mn.percentDecode,"%")}catch{return null}return e}function wE(e,t){var i;const n=e.replace(mn.findPipe,(o,s,l)=>{let c=!1,u=s;for(;--u>=0&&l[u]==="\\";)c=!c;return c?"|":" |"}),a=n.split(mn.splitPipe);let r=0;if(a[0].trim()||a.shift(),a.length>0&&!((i=a.at(-1))!=null&&i.trim())&&a.pop(),t)if(a.length>t)a.splice(t);else for(;a.length0?-2:-1}function LE(e,t,n,a,r){const i=t.href,o=t.title||null,s=e[1].replace(r.other.outputLinkReplace,"$1");a.state.inLink=!0;const l={type:e[0].charAt(0)==="!"?"image":"link",raw:n,href:i,title:o,text:s,tokens:a.inlineTokens(s)};return a.state.inLink=!1,l}function _M(e,t,n){const a=e.match(n.other.indentCodeCompensation);if(a===null)return t;const r=a[1];return t.split(` -`).map(i=>{const o=i.match(n.other.beginningSpace);if(o===null)return i;const[s]=o;return s.length>=r.length?i.slice(r.length):i}).join(` -`)}var Hi=class{constructor(e){It(this,"options");It(this,"rules");It(this,"lexer");this.options=e||rr}space(e){const t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:"space",raw:t[0]}}code(e){const t=this.rules.block.code.exec(e);if(t){const n=t[0].replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:t[0],codeBlockStyle:"indented",text:this.options.pedantic?n:wr(n,` -`)}}}fences(e){const t=this.rules.block.fences.exec(e);if(t){const n=t[0],a=_M(n,t[3]||"",this.rules);return{type:"code",raw:n,lang:t[2]?t[2].trim().replace(this.rules.inline.anyPunctuation,"$1"):t[2],text:a}}}heading(e){const t=this.rules.block.heading.exec(e);if(t){let n=t[2].trim();if(this.rules.other.endingHash.test(n)){const a=wr(n,"#");(this.options.pedantic||!a||this.rules.other.endingSpaceChar.test(a))&&(n=a.trim())}return{type:"heading",raw:t[0],depth:t[1].length,text:n,tokens:this.lexer.inline(n)}}}hr(e){const t=this.rules.block.hr.exec(e);if(t)return{type:"hr",raw:wr(t[0],` -`)}}blockquote(e){const t=this.rules.block.blockquote.exec(e);if(t){let n=wr(t[0],` -`).split(` -`),a="",r="";const i=[];for(;n.length>0;){let o=!1;const s=[];let l;for(l=0;l1,r={type:"list",raw:"",ordered:a,start:a?+n.slice(0,-1):"",loose:!1,items:[]};n=a?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=a?n:"[*+-]");const i=this.rules.other.listItemRegex(n);let o=!1;for(;e;){let l=!1,c="",u="";if(!(t=i.exec(e))||this.rules.block.hr.test(e))break;c=t[0],e=e.substring(c.length);let d=t[2].split(` -`,1)[0].replace(this.rules.other.listReplaceTabs,A=>" ".repeat(3*A.length)),_=e.split(` -`,1)[0],m=!d.trim(),p=0;if(this.options.pedantic?(p=2,u=d.trimStart()):m?p=t[1].length+1:(p=t[2].search(this.rules.other.nonSpaceChar),p=p>4?1:p,u=d.slice(p),p+=t[1].length),m&&this.rules.other.blankLine.test(_)&&(c+=_+` -`,e=e.substring(_.length+1),l=!0),!l){const A=this.rules.other.nextBulletRegex(p),O=this.rules.other.hrRegex(p),M=this.rules.other.fencesBeginRegex(p),w=this.rules.other.headingBeginRegex(p),v=this.rules.other.htmlBeginRegex(p);for(;e;){const T=e.split(` -`,1)[0];let I;if(_=T,this.options.pedantic?(_=_.replace(this.rules.other.listReplaceNesting," "),I=_):I=_.replace(this.rules.other.tabCharGlobal," "),M.test(_)||w.test(_)||v.test(_)||A.test(_)||O.test(_))break;if(I.search(this.rules.other.nonSpaceChar)>=p||!_.trim())u+=` -`+I.slice(p);else{if(m||d.replace(this.rules.other.tabCharGlobal," ").search(this.rules.other.nonSpaceChar)>=4||M.test(d)||w.test(d)||O.test(d))break;u+=` -`+_}!m&&!_.trim()&&(m=!0),c+=T+` -`,e=e.substring(T.length+1),d=I.slice(p)}}r.loose||(o?r.loose=!0:this.rules.other.doubleBlankLine.test(c)&&(o=!0));let g=null,b;this.options.gfm&&(g=this.rules.other.listIsTask.exec(u),g&&(b=g[0]!=="[ ] ",u=u.replace(this.rules.other.listReplaceTask,""))),r.items.push({type:"list_item",raw:c,task:!!g,checked:b,loose:!1,text:u,tokens:[]}),r.raw+=c}const s=r.items.at(-1);if(s)s.raw=s.raw.trimEnd(),s.text=s.text.trimEnd();else return;r.raw=r.raw.trimEnd();for(let l=0;ld.type==="space"),u=c.length>0&&c.some(d=>this.rules.other.anyLine.test(d.raw));r.loose=u}if(r.loose)for(let l=0;l({text:l,tokens:this.lexer.inline(l),header:!1,align:i.align[c]})));return i}}lheading(e){const t=this.rules.block.lheading.exec(e);if(t)return{type:"heading",raw:t[0],depth:t[2].charAt(0)==="="?1:2,text:t[1],tokens:this.lexer.inline(t[1])}}paragraph(e){const t=this.rules.block.paragraph.exec(e);if(t){const n=t[1].charAt(t[1].length-1)===` -`?t[1].slice(0,-1):t[1];return{type:"paragraph",raw:t[0],text:n,tokens:this.lexer.inline(n)}}}text(e){const t=this.rules.block.text.exec(e);if(t)return{type:"text",raw:t[0],text:t[0],tokens:this.lexer.inline(t[0])}}escape(e){const t=this.rules.inline.escape.exec(e);if(t)return{type:"escape",raw:t[0],text:t[1]}}tag(e){const t=this.rules.inline.tag.exec(e);if(t)return!this.lexer.state.inLink&&this.rules.other.startATag.test(t[0])?this.lexer.state.inLink=!0:this.lexer.state.inLink&&this.rules.other.endATag.test(t[0])&&(this.lexer.state.inLink=!1),!this.lexer.state.inRawBlock&&this.rules.other.startPreScriptTag.test(t[0])?this.lexer.state.inRawBlock=!0:this.lexer.state.inRawBlock&&this.rules.other.endPreScriptTag.test(t[0])&&(this.lexer.state.inRawBlock=!1),{type:"html",raw:t[0],inLink:this.lexer.state.inLink,inRawBlock:this.lexer.state.inRawBlock,block:!1,text:t[0]}}link(e){const t=this.rules.inline.link.exec(e);if(t){const n=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(n)){if(!this.rules.other.endAngleBracket.test(n))return;const i=wr(n.slice(0,-1),"\\");if((n.length-i.length)%2===0)return}else{const i=dM(t[2],"()");if(i===-2)return;if(i>-1){const s=(t[0].indexOf("!")===0?5:4)+t[1].length+i;t[2]=t[2].substring(0,i),t[0]=t[0].substring(0,s).trim(),t[3]=""}}let a=t[2],r="";if(this.options.pedantic){const i=this.rules.other.pedanticHrefTitle.exec(a);i&&(a=i[1],r=i[3])}else r=t[3]?t[3].slice(1,-1):"";return a=a.trim(),this.rules.other.startAngleBracket.test(a)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(n)?a=a.slice(1):a=a.slice(1,-1)),LE(t,{href:a&&a.replace(this.rules.inline.anyPunctuation,"$1"),title:r&&r.replace(this.rules.inline.anyPunctuation,"$1")},t[0],this.lexer,this.rules)}}reflink(e,t){let n;if((n=this.rules.inline.reflink.exec(e))||(n=this.rules.inline.nolink.exec(e))){const a=(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal," "),r=t[a.toLowerCase()];if(!r){const i=n[0].charAt(0);return{type:"text",raw:i,text:i}}return LE(n,r,n[0],this.lexer,this.rules)}}emStrong(e,t,n=""){let a=this.rules.inline.emStrongLDelim.exec(e);if(!a||a[3]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(a[1]||a[2]||"")||!n||this.rules.inline.punctuation.exec(n)){const i=[...a[0]].length-1;let o,s,l=i,c=0;const u=a[0][0]==="*"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(u.lastIndex=0,t=t.slice(-1*e.length+i);(a=u.exec(t))!=null;){if(o=a[1]||a[2]||a[3]||a[4]||a[5]||a[6],!o)continue;if(s=[...o].length,a[3]||a[4]){l+=s;continue}else if((a[5]||a[6])&&i%3&&!((i+s)%3)){c+=s;continue}if(l-=s,l>0)continue;s=Math.min(s,s+l+c);const d=[...a[0]][0].length,_=e.slice(0,i+a.index+d+s);if(Math.min(i,s)%2){const p=_.slice(1,-1);return{type:"em",raw:_,text:p,tokens:this.lexer.inlineTokens(p)}}const m=_.slice(2,-2);return{type:"strong",raw:_,text:m,tokens:this.lexer.inlineTokens(m)}}}}codespan(e){const t=this.rules.inline.code.exec(e);if(t){let n=t[2].replace(this.rules.other.newLineCharGlobal," ");const a=this.rules.other.nonSpaceChar.test(n),r=this.rules.other.startingSpaceChar.test(n)&&this.rules.other.endingSpaceChar.test(n);return a&&r&&(n=n.substring(1,n.length-1)),{type:"codespan",raw:t[0],text:n}}}br(e){const t=this.rules.inline.br.exec(e);if(t)return{type:"br",raw:t[0]}}del(e){const t=this.rules.inline.del.exec(e);if(t)return{type:"del",raw:t[0],text:t[2],tokens:this.lexer.inlineTokens(t[2])}}autolink(e){const t=this.rules.inline.autolink.exec(e);if(t){let n,a;return t[2]==="@"?(n=t[1],a="mailto:"+n):(n=t[1],a=n),{type:"link",raw:t[0],text:n,href:a,tokens:[{type:"text",raw:n,text:n}]}}}url(e){var n;let t;if(t=this.rules.inline.url.exec(e)){let a,r;if(t[2]==="@")a=t[0],r="mailto:"+a;else{let i;do i=t[0],t[0]=((n=this.rules.inline._backpedal.exec(t[0]))==null?void 0:n[0])??"";while(i!==t[0]);a=t[0],t[1]==="www."?r="http://"+t[0]:r=t[0]}return{type:"link",raw:t[0],text:a,href:r,tokens:[{type:"text",raw:a,text:a}]}}}inlineText(e){const t=this.rules.inline.text.exec(e);if(t){const n=this.lexer.state.inRawBlock;return{type:"text",raw:t[0],text:t[0],escaped:n}}}},ca=class $u{constructor(t){It(this,"tokens");It(this,"options");It(this,"state");It(this,"tokenizer");It(this,"inlineQueue");this.tokens=[],this.tokens.links=Object.create(null),this.options=t||rr,this.options.tokenizer=this.options.tokenizer||new Hi,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};const n={other:mn,block:vi.normal,inline:Mr.normal};this.options.pedantic?(n.block=vi.pedantic,n.inline=Mr.pedantic):this.options.gfm&&(n.block=vi.gfm,this.options.breaks?n.inline=Mr.breaks:n.inline=Mr.gfm),this.tokenizer.rules=n}static get rules(){return{block:vi,inline:Mr}}static lex(t,n){return new $u(n).lex(t)}static lexInline(t,n){return new $u(n).inlineTokens(t)}lex(t){t=t.replace(mn.carriageReturn,` -`),this.blockTokens(t,this.tokens);for(let n=0;n(s=c.call({lexer:this},t,n))?(t=t.substring(s.raw.length),n.push(s),!0):!1))continue;if(s=this.tokenizer.space(t)){t=t.substring(s.raw.length);const c=n.at(-1);s.raw.length===1&&c!==void 0?c.raw+=` -`:n.push(s);continue}if(s=this.tokenizer.code(t)){t=t.substring(s.raw.length);const c=n.at(-1);(c==null?void 0:c.type)==="paragraph"||(c==null?void 0:c.type)==="text"?(c.raw+=` -`+s.raw,c.text+=` -`+s.text,this.inlineQueue.at(-1).src=c.text):n.push(s);continue}if(s=this.tokenizer.fences(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.heading(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.hr(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.blockquote(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.list(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.html(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.def(t)){t=t.substring(s.raw.length);const c=n.at(-1);(c==null?void 0:c.type)==="paragraph"||(c==null?void 0:c.type)==="text"?(c.raw+=` -`+s.raw,c.text+=` -`+s.raw,this.inlineQueue.at(-1).src=c.text):this.tokens.links[s.tag]||(this.tokens.links[s.tag]={href:s.href,title:s.title});continue}if(s=this.tokenizer.table(t)){t=t.substring(s.raw.length),n.push(s);continue}if(s=this.tokenizer.lheading(t)){t=t.substring(s.raw.length),n.push(s);continue}let l=t;if((o=this.options.extensions)!=null&&o.startBlock){let c=1/0;const u=t.slice(1);let d;this.options.extensions.startBlock.forEach(_=>{d=_.call({lexer:this},u),typeof d=="number"&&d>=0&&(c=Math.min(c,d))}),c<1/0&&c>=0&&(l=t.substring(0,c+1))}if(this.state.top&&(s=this.tokenizer.paragraph(l))){const c=n.at(-1);a&&(c==null?void 0:c.type)==="paragraph"?(c.raw+=` -`+s.raw,c.text+=` -`+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=c.text):n.push(s),a=l.length!==t.length,t=t.substring(s.raw.length);continue}if(s=this.tokenizer.text(t)){t=t.substring(s.raw.length);const c=n.at(-1);(c==null?void 0:c.type)==="text"?(c.raw+=` -`+s.raw,c.text+=` -`+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=c.text):n.push(s);continue}if(t){const c="Infinite loop on byte: "+t.charCodeAt(0);if(this.options.silent){console.error(c);break}else throw new Error(c)}}return this.state.top=!0,n}inline(t,n=[]){return this.inlineQueue.push({src:t,tokens:n}),n}inlineTokens(t,n=[]){var s,l,c;let a=t,r=null;if(this.tokens.links){const u=Object.keys(this.tokens.links);if(u.length>0)for(;(r=this.tokenizer.rules.inline.reflinkSearch.exec(a))!=null;)u.includes(r[0].slice(r[0].lastIndexOf("[")+1,-1))&&(a=a.slice(0,r.index)+"["+"a".repeat(r[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(r=this.tokenizer.rules.inline.anyPunctuation.exec(a))!=null;)a=a.slice(0,r.index)+"++"+a.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);for(;(r=this.tokenizer.rules.inline.blockSkip.exec(a))!=null;)a=a.slice(0,r.index)+"["+"a".repeat(r[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);let i=!1,o="";for(;t;){i||(o=""),i=!1;let u;if((l=(s=this.options.extensions)==null?void 0:s.inline)!=null&&l.some(_=>(u=_.call({lexer:this},t,n))?(t=t.substring(u.raw.length),n.push(u),!0):!1))continue;if(u=this.tokenizer.escape(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.tag(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.link(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.reflink(t,this.tokens.links)){t=t.substring(u.raw.length);const _=n.at(-1);u.type==="text"&&(_==null?void 0:_.type)==="text"?(_.raw+=u.raw,_.text+=u.text):n.push(u);continue}if(u=this.tokenizer.emStrong(t,a,o)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.codespan(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.br(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.del(t)){t=t.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.autolink(t)){t=t.substring(u.raw.length),n.push(u);continue}if(!this.state.inLink&&(u=this.tokenizer.url(t))){t=t.substring(u.raw.length),n.push(u);continue}let d=t;if((c=this.options.extensions)!=null&&c.startInline){let _=1/0;const m=t.slice(1);let p;this.options.extensions.startInline.forEach(g=>{p=g.call({lexer:this},m),typeof p=="number"&&p>=0&&(_=Math.min(_,p))}),_<1/0&&_>=0&&(d=t.substring(0,_+1))}if(u=this.tokenizer.inlineText(d)){t=t.substring(u.raw.length),u.raw.slice(-1)!=="_"&&(o=u.raw.slice(-1)),i=!0;const _=n.at(-1);(_==null?void 0:_.type)==="text"?(_.raw+=u.raw,_.text+=u.text):n.push(u);continue}if(t){const _="Infinite loop on byte: "+t.charCodeAt(0);if(this.options.silent){console.error(_);break}else throw new Error(_)}}return n}},Vi=class{constructor(e){It(this,"options");It(this,"parser");this.options=e||rr}space(e){return""}code({text:e,lang:t,escaped:n}){var i;const a=(i=(t||"").match(mn.notSpaceStart))==null?void 0:i[0],r=e.replace(mn.endingNewline,"")+` -`;return a?'
'+(n?r:Hn(r,!0))+`
-`:"
"+(n?r:Hn(r,!0))+`
-`}blockquote({tokens:e}){return`
-${this.parser.parse(e)}
-`}html({text:e}){return e}heading({tokens:e,depth:t}){return`${this.parser.parseInline(e)} -`}hr(e){return`
-`}list(e){const t=e.ordered,n=e.start;let a="";for(let o=0;o -`+a+" -`}listitem(e){var n;let t="";if(e.task){const a=this.checkbox({checked:!!e.checked});e.loose?((n=e.tokens[0])==null?void 0:n.type)==="paragraph"?(e.tokens[0].text=a+" "+e.tokens[0].text,e.tokens[0].tokens&&e.tokens[0].tokens.length>0&&e.tokens[0].tokens[0].type==="text"&&(e.tokens[0].tokens[0].text=a+" "+Hn(e.tokens[0].tokens[0].text),e.tokens[0].tokens[0].escaped=!0)):e.tokens.unshift({type:"text",raw:a+" ",text:a+" ",escaped:!0}):t+=a+" "}return t+=this.parser.parse(e.tokens,!!e.loose),`
  • ${t}
    • -`}checkbox({checked:e}){return"'}paragraph({tokens:e}){return`

    ${this.parser.parseInline(e)}

    -`}table(e){let t="",n="";for(let r=0;r${a}`),` - -`+t+` -`+a+`
    -`}tablerow({text:e}){return` -${e} -`}tablecell(e){const t=this.parser.parseInline(e.tokens),n=e.header?"th":"td";return(e.align?`<${n} align="${e.align}">`:`<${n}>`)+t+` -`}strong({tokens:e}){return`${this.parser.parseInline(e)}`}em({tokens:e}){return`${this.parser.parseInline(e)}`}codespan({text:e}){return`${Hn(e,!0)}`}br(e){return"
    "}del({tokens:e}){return`${this.parser.parseInline(e)}`}link({href:e,title:t,tokens:n}){const a=this.parser.parseInline(n),r=ME(e);if(r===null)return a;e=r;let i='    ",i}image({href:e,title:t,text:n,tokens:a}){a&&(n=this.parser.parseInline(a,this.parser.textRenderer));const r=ME(e);if(r===null)return Hn(n);e=r;let i=`${n}{const l=o[s].flat(1/0);n=n.concat(this.walkTokens(l,t))}):o.tokens&&(n=n.concat(this.walkTokens(o.tokens,t)))}}return n}use(...e){const t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach(n=>{const a={...n};if(a.async=this.defaults.async||a.async||!1,n.extensions&&(n.extensions.forEach(r=>{if(!r.name)throw new Error("extension name required");if("renderer"in r){const i=t.renderers[r.name];i?t.renderers[r.name]=function(...o){let s=r.renderer.apply(this,o);return s===!1&&(s=i.apply(this,o)),s}:t.renderers[r.name]=r.renderer}if("tokenizer"in r){if(!r.level||r.level!=="block"&&r.level!=="inline")throw new Error("extension level must be 'block' or 'inline'");const i=t[r.level];i?i.unshift(r.tokenizer):t[r.level]=[r.tokenizer],r.start&&(r.level==="block"?t.startBlock?t.startBlock.push(r.start):t.startBlock=[r.start]:r.level==="inline"&&(t.startInline?t.startInline.push(r.start):t.startInline=[r.start]))}"childTokens"in r&&r.childTokens&&(t.childTokens[r.name]=r.childTokens)}),a.extensions=t),n.renderer){const r=this.defaults.renderer||new Vi(this.defaults);for(const i in n.renderer){if(!(i in r))throw new Error(`renderer '${i}' does not exist`);if(["options","parser"].includes(i))continue;const o=i,s=n.renderer[o],l=r[o];r[o]=(...c)=>{let u=s.apply(r,c);return u===!1&&(u=l.apply(r,c)),u||""}}a.renderer=r}if(n.tokenizer){const r=this.defaults.tokenizer||new Hi(this.defaults);for(const i in n.tokenizer){if(!(i in r))throw new Error(`tokenizer '${i}' does not exist`);if(["options","rules","lexer"].includes(i))continue;const o=i,s=n.tokenizer[o],l=r[o];r[o]=(...c)=>{let u=s.apply(r,c);return u===!1&&(u=l.apply(r,c)),u}}a.tokenizer=r}if(n.hooks){const r=this.defaults.hooks||new Ai;for(const i in n.hooks){if(!(i in r))throw new Error(`hook '${i}' does not exist`);if(["options","block"].includes(i))continue;const o=i,s=n.hooks[o],l=r[o];Ai.passThroughHooks.has(i)?r[o]=c=>{if(this.defaults.async)return Promise.resolve(s.call(r,c)).then(d=>l.call(r,d));const u=s.call(r,c);return l.call(r,u)}:r[o]=(...c)=>{let u=s.apply(r,c);return u===!1&&(u=l.apply(r,c)),u}}a.hooks=r}if(n.walkTokens){const r=this.defaults.walkTokens,i=n.walkTokens;a.walkTokens=function(o){let s=[];return s.push(i.call(this,o)),r&&(s=s.concat(r.call(this,o))),s}}this.defaults={...this.defaults,...a}}),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return ca.lex(e,t??this.defaults)}parser(e,t){return ua.parse(e,t??this.defaults)}parseMarkdown(e){return(n,a)=>{const r={...a},i={...this.defaults,...r},o=this.onError(!!i.silent,!!i.async);if(this.defaults.async===!0&&r.async===!1)return o(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));if(typeof n>"u"||n===null)return o(new Error("marked(): input parameter is undefined or null"));if(typeof n!="string")return o(new Error("marked(): input parameter is of type "+Object.prototype.toString.call(n)+", string expected"));i.hooks&&(i.hooks.options=i,i.hooks.block=e);const s=i.hooks?i.hooks.provideLexer():e?ca.lex:ca.lexInline,l=i.hooks?i.hooks.provideParser():e?ua.parse:ua.parseInline;if(i.async)return Promise.resolve(i.hooks?i.hooks.preprocess(n):n).then(c=>s(c,i)).then(c=>i.hooks?i.hooks.processAllTokens(c):c).then(c=>i.walkTokens?Promise.all(this.walkTokens(c,i.walkTokens)).then(()=>c):c).then(c=>l(c,i)).then(c=>i.hooks?i.hooks.postprocess(c):c).catch(o);try{i.hooks&&(n=i.hooks.preprocess(n));let c=s(n,i);i.hooks&&(c=i.hooks.processAllTokens(c)),i.walkTokens&&this.walkTokens(c,i.walkTokens);let u=l(c,i);return i.hooks&&(u=i.hooks.postprocess(u)),u}catch(c){return o(c)}}}onError(e,t){return n=>{if(n.message+=` -Please report this to https://github.com/markedjs/marked.`,e){const a="

    An error occurred:

    "+Hn(n.message+"",!0)+"
    ";return t?Promise.resolve(a):a}if(t)return Promise.reject(n);throw n}}},nr=new pM;function gt(e,t){return nr.parse(e,t)}gt.options=gt.setOptions=function(e){return nr.setOptions(e),gt.defaults=nr.defaults,XS(gt.defaults),gt};gt.getDefaults=gd;gt.defaults=rr;gt.use=function(...e){return nr.use(...e),gt.defaults=nr.defaults,XS(gt.defaults),gt};gt.walkTokens=function(e,t){return nr.walkTokens(e,t)};gt.parseInline=nr.parseInline;gt.Parser=ua;gt.parser=ua.parse;gt.Renderer=Vi;gt.TextRenderer=Rd;gt.Lexer=ca;gt.lexer=ca.lex;gt.Tokenizer=Hi;gt.Hooks=Ai;gt.parse=gt;gt.options;gt.setOptions;gt.use;gt.walkTokens;gt.parseInline;ua.parse;ca.lex;gt.setOptions({breaks:!0,gfm:!0});const Cd=new gt.Renderer;Cd.code=function({text:e,lang:t}){const n=t&&$i.getLanguage(t)?t:"plaintext",a=$i.highlight(e,{language:n}).value;return`
    ${n}
    ${a}
    `};function mM(e){const t=String(e??"").trim();return/^data:image\//i.test(t)||/^https?:\/\//i.test(t)||t.startsWith("/")&&!t.startsWith("//")?t:""}Cd.image=function({href:e,title:t,text:n}){const a=mM(e),r=String(n??"").replace(/"/g,""");return a?`    ${r}`:``};gt.use({renderer:Cd});function gM(e){const t=e.split(` -`),n=[],a=s=>s.trim().startsWith("|")&&s.includes("|",1),r=s=>/^:?-+:?$/.test(s.trim()),i=s=>s.split("|").slice(1,-1).length;let o=!1;for(let s=0;s!r(m));if(d){o||(o=!0,n.push(l));continue}a(c)&&(o||(_?s+1]*)?>/g,'
    ').replace(/<\/table>/g,"
    ");return xx.sanitize(n)}function SM(e){e==null||e.querySelectorAll(".copy-btn").forEach(t=>{t.onclick=()=>{var r;const n=decodeURIComponent(t.dataset.code??""),a=()=>{t.innerHTML='',setTimeout(()=>{t.innerHTML=''},1500)};if((r=navigator.clipboard)!=null&&r.writeText)navigator.clipboard.writeText(n).then(a);else{const i=document.createElement("textarea");i.value=n,i.style.cssText="position:fixed;opacity:0",document.body.appendChild(i),i.select(),document.execCommand("copy"),document.body.removeChild(i),a()}}})}const{open:bM}=_o();function TM(e){e==null||e.querySelectorAll("img.msg-md-image").forEach(t=>{t.addEventListener("error",()=>{var n;t.classList.add("is-broken"),(n=t.closest(".msg-md-image-link"))==null||n.classList.add("is-broken")})}),e==null||e.querySelectorAll("a.msg-md-image-link").forEach(t=>{t.addEventListener("click",n=>{if(t.classList.contains("is-broken"))return;n.preventDefault();const a=t.dataset.lightbox||t.getAttribute("href");a&&bM(a)})})}const hM={class:"tool-status-icon"},vM={key:0,class:"spinner"},RM={key:1,class:"ph ph-check-circle"},CM={key:2,class:"ph ph-x-circle"},yM={class:"tool-name"},NM={key:0,class:"tool-running-time"},OM={class:"tool-card-body"},AM={key:0,class:"tool-args"},IM={class:"tool-section"},DM=["innerHTML"],xM={key:1,class:"tool-section tool-result-section"},MM=["innerHTML"],wM={__name:"SubagentStep",props:{tool:{type:Object,required:!0}},setup(e){function t(c){return typeof c!="string"?!1:[/#{1,6} /,/\*\*|__/,/`[^`]+`/,/```/,/^\s*[-*+]\s/m,/^\s*\d+\.\s/m,/\[[^\]]+\]\([^)]+\)/,/\|.*\|/,/^\s*>\s/m].some(d=>d.test(c))}const n=e,a=j(null);je(()=>n.tool.pending,(c,u)=>{a.value&&(c?a.value.setAttribute("open",""):u!==void 0&&a.value.removeAttribute("open"))},{immediate:!0});function r(c){return o(c)}function i(c){if(typeof c=="string"){try{const u=JSON.parse(c);return o(u)}catch{}return t(c)?ar(c):l(c).split(` -`).map((u,d)=>`
    ${u||" "}
    `).join("")}return o(c)}function o(c){if(typeof c=="string")try{c=JSON.parse(c)}catch{return l(c)}if(c===null||typeof c!="object")return l(String(c));if(Array.isArray(c))return c.length===0?'[]':`
    ${c.map((m,p)=>`
    - ${p} - : - ${s(m)} -
    `).join("")}
    `;const u=Object.entries(c);return u.length===0?'{}':`
    ${u.map(([_,m])=>`
    - ${l(_)} - : - ${s(m)} -
    `).join("")}
    `}function s(c){if(c===null)return'null';if(typeof c=="boolean")return`${c}`;if(typeof c=="number")return`${c}`;if(typeof c=="string"){const d=l(c);return d.length<=200?`${d}`:`${d.slice(0,200)}…`}return Array.isArray(c)?`[${c.length} items]`:`{${Object.keys(c).length} keys}`}function l(c){return typeof c!="string"?String(c??""):c.replace(/&/g,"&").replace(//g,">")}return(c,u)=>(N(),U("details",{ref_key:"detailsEl",ref:a,class:He(["subagent-step",{"is-success":!e.tool.pending&&e.tool.success,"is-error":!e.tool.pending&&!e.tool.success}])},[f("summary",null,[f("span",hM,[e.tool.pending?(N(),U("span",vM)):e.tool.success?(N(),U("i",RM)):(N(),U("i",CM))]),f("span",yM,ie(e.tool.name),1),e.tool.pending?(N(),U("span",NM,"running")):ue("",!0),u[0]||(u[0]=f("i",{class:"ph ph-caret-down tool-chevron"},null,-1))]),f("div",OM,[e.tool.args?(N(),U("details",AM,[u[1]||(u[1]=f("summary",null,[f("span",{class:"tool-section-label"},"Arguments"),f("i",{class:"ph ph-caret-down tool-chevron"})],-1)),f("div",IM,[f("pre",{class:"tool-code",innerHTML:r(e.tool.args)},null,8,DM)])])):ue("",!0),e.tool.result!=null?(N(),U("div",xM,[u[2]||(u[2]=f("div",{class:"tool-section-label"},"Result",-1)),f("div",{class:"tool-result",innerHTML:i(e.tool.result)},null,8,MM)])):ue("",!0)])],2))}},LM={class:"tool-status-icon"},PM={key:0,class:"spinner"},kM={key:1,class:"ph ph-check-circle"},UM={key:2,class:"ph ph-x-circle"},FM={class:"tool-name"},BM={key:0,class:"tool-running-time"},GM={class:"tool-card-body"},YM={key:0,class:"tool-running-banner"},$M={key:1,class:"tool-args"},qM={class:"tool-section"},HM=["innerHTML"],VM={key:2,class:"tool-section tool-result-section"},zM=["innerHTML"],WM={key:3,class:"tool-section terminal-output-section"},KM={class:"terminal-output"},QM={key:4,class:"subagent-planning-indicator"},XM={class:"planning-label"},ZM={key:5,class:"subagent-steps"},JM={key:1,class:"plan-card",open:""},jM=["innerHTML"],ew={class:"task-step-tool"},tw={class:"task-step-status"},nw={key:0,class:"task-step-preview"},aw={__name:"ToolCard",props:{tool:{type:Object,required:!0}},setup(e){function t(v){return typeof v!="string"?!1:[/#{1,6} /,/\*\*|__/,/`[^`]+`/,/```/,/^\s*[-*+]\s/m,/^\s*\d+\.\s/m,/\[[^\]]+\]\([^)]+\)/,/\|.*\|/,/^\s*>\s/m].some(I=>I.test(v))}const n=e,a=j(null),r=j(Date.now());let i=null;je(()=>n.tool.pending,(v,T)=>{a.value&&(v?a.value.setAttribute("open",""):T!==void 0&&a.value.removeAttribute("open"))},{immediate:!0}),je(()=>n.tool.pending,v=>{v?l():c()},{immediate:!0}),Tn(c);const o=ge(()=>{var v;return n.tool.name==="filesystem"&&((v=n.tool.args)!=null&&v.action)?`Running filesystem ${n.tool.args.action}...`:`Running ${n.tool.name}...`}),s=ge(()=>{if(!n.tool.startedAt)return"";const v=Math.max(0,Math.floor((r.value-n.tool.startedAt)/1e3));return v<1?"starting":`${v}s`});function l(){i||(r.value=Date.now(),i=setInterval(()=>{r.value=Date.now()},1e3))}function c(){i&&(clearInterval(i),i=null)}function u(v){return O(v)}function d(v,T){var I,h;if(typeof v=="string"){try{const E=JSON.parse(v);return O(E)}catch{}return t(v)?ar(v):T&&T.name==="filesystem"&&["diff","edit_lines","smart_edit"].includes((I=T.args)==null?void 0:I.action)?_(v):T&&T.name==="filesystem"&&((h=T.args)==null?void 0:h.action)==="read"?A(v):w(v).split(` -`).map((E,D)=>`
    ${E||" "}
    `).join("")}return O(v)}function _(v){let T="",I=v;const h=v.indexOf(` - -`);if(h!==-1){const D=v.slice(h+2);(D.includes("@@")||/^[ +\-]/m.test(D))&&(T=v.slice(0,h),I=D)}const E=[];T&&E.push(`
    ${w(T)||" "}
    `);for(const D of I.split(` -`))E.push(p(D));return E.join("")}const m=/^([ +\-])( +)(\d+)│ ?(.*)$/;function p(v){const T=m.exec(v);if(T){const h=T[1],E=h==="+"?"diff-add":h==="-"?"diff-del":"diff-ctx",D=`${T[2]}${T[3]} ${h} `,x=T[4];return`
    ${w(D)}${w(x)||" "}
    `}return`
    ${w(v)||" "}
    `}function g(v){return v.startsWith("@@")?"diff-hunk":v.startsWith("+")?"diff-add":v.startsWith("-")?"diff-del":"diff-ctx"}const b=/^(\s*)(\d+): (.*)$/;function A(v){const T=v.split(` -`),I=[];let h=0;if(T.length&&T[0].startsWith("[")){const E=T[0],D=E.replace(/^\[/,"").replace(/\]$/,""),x=D.indexOf(" | ");if(x!==-1){const L=D.slice(0,x),ae=D.slice(x+5);I.push(`
    ${w(L)} | ${w(ae)}
    `)}else I.push(`
    ${w(E)||" "}
    `);h=1}for(h${w(T[h])||" "}`),h+=1);h ');continue}const D=b.exec(E);D?I.push(`
    ${w(D[1]+D[2])}: ${w(D[3])}
    `):I.push(`
    ${w(E)}
    `)}return I.join("")}function O(v){if(typeof v=="string")try{v=JSON.parse(v)}catch{return w(v)}if(v===null||typeof v!="object")return w(String(v));if(Array.isArray(v))return v.length===0?'[]':`
    ${v.map((E,D)=>`
    - ${D} - : - ${M(E)} -
    `).join("")}
    `;const T=Object.entries(v);return T.length===0?'{}':`
    ${T.map(([h,E])=>`
    - ${w(h)} - : - ${M(E)} -
    `).join("")}
    `}function M(v){if(v===null)return'null';if(typeof v=="boolean")return`${v}`;if(typeof v=="number")return`${v}`;if(typeof v=="string"){const I=w(v);return I.length<=200?`${I}`:`${I.slice(0,200)}…`}return Array.isArray(v)?`[${v.length} items]`:`{${Object.keys(v).length} keys}`}function w(v){return typeof v!="string"?String(v??""):v.replace(/&/g,"&").replace(//g,">")}return(v,T)=>{var I;return N(),U("details",{ref_key:"detailsEl",ref:a,class:He(["tool-card",{"is-success":!e.tool.pending&&e.tool.success,"is-error":!e.tool.pending&&!e.tool.success}])},[f("summary",null,[f("span",LM,[e.tool.pending?(N(),U("span",PM)):e.tool.success?(N(),U("i",kM)):(N(),U("i",UM))]),f("span",FM,ie(e.tool.name),1),e.tool.pending?(N(),U("span",BM,ie(s.value),1)):ue("",!0),T[0]||(T[0]=f("i",{class:"ph ph-caret-down tool-chevron"},null,-1))]),f("div",GM,[e.tool.pending&&e.tool.name!=="spawn_agent"?(N(),U("div",YM,[T[1]||(T[1]=f("span",{class:"spinner"},null,-1)),f("span",null,ie(o.value),1)])):ue("",!0),e.tool.args?(N(),U("details",$M,[T[2]||(T[2]=f("summary",null,[f("span",{class:"tool-section-label"},"Arguments"),f("i",{class:"ph ph-caret-down tool-chevron"})],-1)),f("div",qM,[f("pre",{class:"tool-code",innerHTML:u(e.tool.args)},null,8,HM)])])):ue("",!0),e.tool.result!=null?(N(),U("div",VM,[T[3]||(T[3]=f("div",{class:"tool-section-label"},"Result",-1)),f("div",{class:"tool-result",innerHTML:d(e.tool.result,e.tool)},null,8,zM)])):ue("",!0),e.tool.name==="terminal"&&e.tool.terminalOutput?(N(),U("div",WM,[T[4]||(T[4]=f("div",{class:"tool-section-label"},"Live output",-1)),f("pre",KM,ie(e.tool.terminalOutput),1)])):ue("",!0),e.tool.planningLabel!=null?(N(),U("div",QM,[f("span",XM,ie(e.tool.planningLabel),1)])):ue("",!0),(I=e.tool.steps)!=null&&I.length?(N(),U("div",ZM,[(N(!0),U(Ze,null,Ut(e.tool.steps,(h,E)=>(N(),U(Ze,{key:E},[h.kind==="turn_thinking"?(N(),ut(Fu,{key:0,msg:h},null,8,["msg"])):h.kind==="plan"?(N(),U("details",JM,[T[5]||(T[5]=f("summary",null,[f("i",{class:"ph ph-map-trifold"}),Et(" Plan "),f("i",{class:"ph ph-caret-down plan-chevron"})],-1)),f("div",{class:"plan-body",innerHTML:J(ar)(h.text)},null,8,jM)])):h.kind==="task_update"?(N(),U("div",{key:2,class:He(["task-update-step",h.status])},[f("i",{class:He(v.stepIcon(h.status))},null,2),f("span",ew,ie(h.tool),1),f("span",tw,ie(h.status),1),h.preview?(N(),U("span",nw,ie(h.preview),1)):ue("",!0)],2)):(N(),ut(wM,{key:3,tool:h},null,8,["tool"]))],64))),128))])):ue("",!0)])],2)}}},rw=["open"],iw={class:"content-icon"},ow={class:"content-title"},sw={class:"content-badge"},lw=["href"],cw=["href"],uw=["title"],dw={key:0,class:"content-body"},_w={key:0,class:"content-source"},pw={key:0,class:"content-source-state"},mw={key:1,class:"content-source-error"},gw={key:2,class:"content-source-code"},Ew=["innerHTML"],fw=["src"],Sw=["src"],bw=["src"],Tw=["src"],hw=["src","alt"],vw=["src"],Rw={key:7,class:"content-unknown"},Cw={class:"unknown-icon"},yw={class:"unknown-name"},Nw=["href"],Ow=["open"],Aw={class:"tool-card-body"},Iw={class:"tool-section"},Dw={class:"tool-code"},xw={class:"tool-section"},Mw={class:"tool-code"},ww={__name:"ContentCard",props:{tool:{type:Object,required:!0},defaultOpen:{type:Boolean,default:!1},collapseToken:{type:String,default:""}},setup(e){const t=e,n=j(null),a=j(t.defaultOpen),r=j(!1),i=j(!1),o=j(""),s=j(!1),l=j(""),{open:c}=_o();je(()=>[t.defaultOpen,t.collapseToken],([be])=>{a.value=be});const u=ge(()=>t.tool.success===!1?!0:!t.tool.metadata||!t.tool.metadata.url?!String(t.tool.result??"").match(/URL: (.+)/):!1),d=ge(()=>{if(t.tool.metadata)return t.tool.metadata;const be=String(t.tool.result??""),Xe=be.match(/URL: (.+)/);if(Xe){const et=be.match(/Published: .+ \(([^)]+)\)/),it=be.match(/Published: (.+) \(/);return{url:Xe[1].trim(),content_type:et?et[1].trim():"unknown",title:it?it[1].trim():"Content"}}return{}}),_=ge(()=>d.value.url||""),m=ge(()=>Za(_.value)),p=ge(()=>d.value.content_type||"unknown"),g=ge(()=>d.value.title||d.value.filename||"Content"),b=ge(()=>{var et;if(p.value!=="unknown")return p.value;const be=(et=_.value.split(".").pop())==null?void 0:et.toLowerCase();return{svg:"svg",html:"html",htm:"html",pdf:"pdf",stl:"stl",png:"image",jpg:"image",jpeg:"image",gif:"image",webp:"image",bmp:"image",mp4:"video",webm:"video",mov:"video",mkv:"video"}[be]||"unknown"}),A={stl:"🧊",html:"🌐",svg:"🎨",pdf:"📄",image:"🖼️",video:"🎬",unknown:"📎"},O=ge(()=>A[p.value]||A.unknown),M=ge(()=>`is-${b.value}`),w=ge(()=>{const be=b.value;return["stl","html","svg","pdf"].includes(be)?L(be):Yi(m.value)}),v=ge(()=>b.value==="stl"?w.value:Yi(m.value)),T=ge(()=>["html","svg"].includes(b.value)?m.value:b.value==="stl"&&d.value.source_url?Za(d.value.source_url):""),I=ge(()=>!!T.value),h=ge(()=>MS({...d.value,content_type:b.value,filename:d.value.source_filename||d.value.filename||_.value})),E=ge(()=>wS(o.value,h.value)),D=ge(()=>r.value?"ph ph-check":"ph ph-copy"),x=ge(()=>{const be=Za(d.value.download_url||_.value);return d.value.download_url||!be?be:`${be}${be.includes("?")?"&":"?"}download=1`});function L(be){return DS(be,m.value)}function ae(){p.value==="image"&&c(m.value)}function Ee(be){a.value=be.currentTarget.open}async function xe(){i.value=!i.value,i.value&&await Se()}async function Se(){if(!(!T.value||o.value||s.value)){s.value=!0,l.value="";try{const be=await fetch(T.value);if(!be.ok)throw new Error(`HTTP ${be.status}`);o.value=await be.text()}catch(be){l.value=`Failed to load source: ${(be==null?void 0:be.message)||be}`}finally{s.value=!1}}}async function pe(){try{await navigator.clipboard.writeText(v.value),r.value=!0,setTimeout(()=>{r.value=!1},1500)}catch{}}function Le(be){if(typeof be=="string")try{return JSON.stringify(JSON.parse(be),null,2)}catch{return be}return JSON.stringify(be,null,2)}return(be,Xe)=>u.value?(N(),U("details",{key:1,ref_key:"detailsEl",ref:n,class:"tool-card is-error",open:a.value,onToggle:Ee},[Xe[7]||(Xe[7]=Xf('📎content_publish',1)),f("div",Aw,[f("div",Iw,[Xe[5]||(Xe[5]=f("div",{class:"tool-section-label"},"Arguments",-1)),f("pre",Dw,ie(Le(e.tool.args)),1)]),f("div",xw,[Xe[6]||(Xe[6]=f("div",{class:"tool-section-label"},"Result",-1)),f("pre",Mw,ie(e.tool.result),1)])])],40,Ow)):(N(),U("details",{key:0,ref_key:"detailsEl",ref:n,class:He(["content-card",M.value]),open:a.value,onToggle:Ee},[f("summary",null,[f("span",iw,ie(O.value),1),f("span",ow,ie(g.value),1),f("span",sw,ie(p.value),1),f("span",{class:"content-actions",onClick:Xe[0]||(Xe[0]=tr(()=>{},["stop"]))},[f("a",{href:w.value,target:"_blank",rel:"noopener noreferrer",title:"Open preview"},[...Xe[1]||(Xe[1]=[f("i",{class:"ph ph-arrow-square-out"},null,-1)])],8,lw),f("a",{href:x.value,title:"Download"},[...Xe[2]||(Xe[2]=[f("i",{class:"ph ph-download-simple"},null,-1)])],8,cw),I.value?(N(),U("button",{key:0,type:"button",title:i.value?"Show preview":"Show source",onClick:xe},[f("i",{class:He(i.value?"ph ph-eye":"ph ph-code")},null,2)],8,uw)):ue("",!0),f("button",{type:"button",title:"Copy file link",onClick:pe},[f("i",{class:He(D.value)},null,2)])]),Xe[3]||(Xe[3]=f("i",{class:"ph ph-caret-down content-chevron"},null,-1))]),a.value?(N(),U("div",dw,[i.value?(N(),U("div",_w,[s.value?(N(),U("div",pw,[...Xe[4]||(Xe[4]=[f("span",{class:"spinner"},null,-1),f("span",null,"Loading source...",-1)])])):l.value?(N(),U("pre",mw,ie(l.value),1)):(N(),U("pre",gw,[f("code",{class:He(["hljs",`language-${h.value}`]),innerHTML:E.value},null,10,Ew)]))])):b.value==="stl"?(N(),U("iframe",{key:1,src:L("stl"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,fw)):b.value==="html"?(N(),U("iframe",{key:2,src:L("html"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,Sw)):b.value==="svg"?(N(),U("iframe",{key:3,src:L("svg"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,bw)):b.value==="pdf"?(N(),U("iframe",{key:4,src:L("pdf"),class:"content-iframe",loading:"lazy"},null,8,Tw)):b.value==="image"?(N(),U("img",{key:5,src:m.value,class:"content-image",alt:g.value,loading:"lazy",onClick:ae},null,8,hw)):b.value==="video"?(N(),U("video",{key:6,src:m.value,class:"content-video",controls:"",playsinline:""},null,8,vw)):(N(),U("div",Rw,[f("div",Cw,ie(O.value),1),f("div",yw,ie(g.value),1),f("a",{href:m.value,target:"_blank",rel:"noopener noreferrer",class:"unknown-open"}," Open file ",8,Nw)]))])):ue("",!0)],42,rw))}},Lw=Mt(ww,[["__scopeId","data-v-49cee8cc"]]),Pw={class:"card-grid"},kw={key:0,class:"card-grid-title"},Uw={class:"card-grid-items"},Fw=["onClick","onKeydown"],Bw=["src"],Gw={key:1,class:"card-no-image"},Yw={class:"card-content"},$w={class:"card-title"},qw={key:0,class:"card-subtitle"},Hw={key:1,class:"card-meta"},Vw={class:"card-meta-label"},zw={class:"card-meta-value"},Ww={key:2,class:"card-description"},Kw={key:1,class:"card-grid-more"},Qw={class:"card-grid-more-text"},Xw={class:"card-modal",role:"dialog","aria-modal":"true"},Zw={class:"card-modal-scroll"},Jw=["src"],jw={class:"card-modal-content"},eL={class:"card-modal-title"},tL={key:0,class:"card-modal-subtitle"},nL={key:1,class:"card-modal-section"},aL={class:"card-modal-meta-grid"},rL={class:"card-modal-meta-label"},iL={class:"card-modal-meta-value"},oL={key:2,class:"card-modal-section"},sL={class:"card-modal-text"},lL={key:3,class:"card-modal-section"},cL={class:"card-modal-details"},uL={key:4,class:"card-modal-actions"},dL=["href"],Eu=4,_L={__name:"CardGrid",props:{data:{type:Object,default:()=>({})}},setup(e){const t=e,n=j(null),a=ge(()=>Array.isArray(t.data.cards)?t.data.cards:[]),r=ge(()=>a.value.slice(0,Eu)),i=ge(()=>a.value.length>Eu),o=ge(()=>a.value.length-Eu);sT(()=>{var c;Array.isArray((c=t.data)==null?void 0:c.cards)||console.warn('[CardGrid] payload is missing a "cards" array',t.data)});function s(c){n.value=c}function l(){n.value=null}return(c,u)=>{var d,_,m,p;return N(),U("div",Pw,[e.data.title?(N(),U("div",kw,ie(e.data.title),1)):ue("",!0),f("div",Uw,[(N(!0),U(Ze,null,Ut(r.value,g=>{var b,A;return N(),U("div",{key:g.id,class:"card-grid-item",tabindex:"0",onClick:O=>s(g),onKeydown:ei(O=>s(g),["enter"])},[(b=g.image)!=null&&b.trim()?(N(),U("img",{key:0,src:g.image,class:"card-image",alt:"",loading:"lazy"},null,8,Bw)):(N(),U("div",Gw,[...u[0]||(u[0]=[f("i",{class:"ph ph-image"},null,-1)])])),f("div",Yw,[f("div",$w,ie(g.title),1),g.subtitle?(N(),U("div",qw,ie(g.subtitle),1)):ue("",!0),(A=g.meta)!=null&&A.length?(N(),U("div",Hw,[(N(!0),U(Ze,null,Ut(g.meta,(O,M)=>(N(),U("span",{key:M,class:"card-meta-item"},[f("span",Vw,ie(O.label),1),f("span",zw,ie(O.value),1)]))),128))])):ue("",!0),g.description?(N(),U("div",Ww,ie(g.description),1)):ue("",!0)])],40,Fw)}),128))]),i.value?(N(),U("div",Kw,[f("span",Qw,"+"+ie(o.value)+" more",1)])):ue("",!0),(N(),ut(ri,{to:"body"},[n.value?(N(),U("div",{key:0,class:"card-modal-overlay",onClick:tr(l,["self"])},[f("div",Xw,[f("button",{class:"card-modal-close",onClick:l,"aria-label":"Close"},[...u[1]||(u[1]=[f("i",{class:"ph ph-x"},null,-1)])]),f("div",Zw,[(d=n.value.image)!=null&&d.trim()?(N(),U("img",{key:0,src:n.value.image,class:"card-modal-image",alt:""},null,8,Jw)):ue("",!0),f("div",jw,[f("h2",eL,ie(n.value.title),1),n.value.subtitle?(N(),U("div",tL,ie(n.value.subtitle),1)):ue("",!0),(_=n.value.meta)!=null&&_.length?(N(),U("div",nL,[u[2]||(u[2]=f("div",{class:"card-modal-section-title"},"Overview",-1)),f("div",aL,[(N(!0),U(Ze,null,Ut(n.value.meta,(g,b)=>(N(),U("div",{key:b,class:"card-modal-meta-cell"},[f("div",rL,ie(g.label),1),f("div",iL,ie(g.value),1)]))),128))])])):ue("",!0),n.value.description?(N(),U("div",oL,[u[3]||(u[3]=f("div",{class:"card-modal-section-title"},"Description",-1)),f("p",sL,ie(n.value.description),1)])):ue("",!0),(m=n.value.details)!=null&&m.length?(N(),U("div",lL,[u[4]||(u[4]=f("div",{class:"card-modal-section-title"},"Details",-1)),f("dl",cL,[(N(!0),U(Ze,null,Ut(n.value.details,(g,b)=>(N(),U("div",{key:b,class:"card-modal-detail-row"},[f("dt",null,ie(g.label),1),f("dd",null,ie(g.value),1)]))),128))])])):ue("",!0),(p=n.value.actions)!=null&&p.length?(N(),U("div",uL,[(N(!0),U(Ze,null,Ut(n.value.actions,(g,b)=>(N(),U("a",{key:b,href:g.url,target:"_blank",rel:"noopener noreferrer",class:"card-modal-action"},ie(g.label),9,dL))),128))])):ue("",!0)])])])])):ue("",!0)]))])}}},pL=Mt(_L,[["__scopeId","data-v-61f4362e"]]),mL=Object.freeze(Object.defineProperty({__proto__:null,default:pL},Symbol.toStringTag,{value:"Module"})),gL={class:"ui-form"},EL={key:0,class:"ui-form-submitted"},fL={key:0,class:"ui-form-title"},SL={class:"ui-form-summary"},bL={key:1,class:"ui-form-body"},TL={key:0,class:"ui-form-title"},hL={key:1,class:"ui-form-description"},vL=["for"],RL={key:0,class:"ui-form-required"},CL={key:0,class:"ui-form-field-hint"},yL=["id","onUpdate:modelValue","placeholder","required","minlength","maxlength","onBlur","onInput"],NL=["id","onUpdate:modelValue","required","onBlur","onChange"],OL={key:0,value:""},AL=["value"],IL=["id","onUpdate:modelValue","required","onBlur","onChange"],DL=["value"],xL={key:4,class:"ui-form-checkbox"},ML=["id","onUpdate:modelValue","onChange"],wL=["id","onUpdate:modelValue","type","placeholder","required","min","max","minlength","maxlength","pattern","onBlur","onInput"],LL={key:6,class:"ui-form-error"},PL=["disabled"],kL={key:0,class:"ui-form-spinner"},UL={__name:"Form",props:{data:{type:Object,default:()=>({})}},setup(e){const t=e,n=on(),a=_a("wsSend"),r=ja({}),i=j(new Set),o=ja({}),s=j(!1),l=j(!1),c=ge(()=>{var E;return((E=t.data)==null?void 0:E.form_id)||""}),u=ge(()=>{var E;return Array.isArray((E=t.data)==null?void 0:E.fields)?t.data.fields:[]}),d=ge(()=>`navi_submitted_forms:${n.currentId||"unknown"}`);function _(E){return`form-${c.value}-${E}`}function m(E){return E==="email"||E==="url"||E==="date"||E==="number"?E:"text"}function p(E,D){var x;if(E==null||E==="")return"—";if(D.type==="checkbox")return E?"Yes":"No";if(D.type==="select"||D.type==="multiselect"){const L=Array.isArray(D.options)?D.options:[];return Array.isArray(E)?E.map(Ee=>{var xe;return((xe=L.find(Se=>Se.value===Ee))==null?void 0:xe.label)||Ee}).join(", ")||"—":((x=L.find(ae=>ae.value===E))==null?void 0:x.label)||E}return Array.isArray(E)?E.join(", "):String(E)}function g(E){return E==null||E===""||Array.isArray(E)&&E.length===0}function b(E){const D=E.name,x=r[D];if(delete o[D],E.required&&g(x)){o[D]=`${E.label} is required`;return}if(!g(x)){if(E.type==="email"&&(/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(x))||(o[D]="Enter a valid email address")),E.type==="url")try{const L=new URL(x);if(L.protocol!=="http:"&&L.protocol!=="https:")throw new Error("bad protocol")}catch{o[D]="Enter a valid http:// or https:// URL"}if(E.type==="number"){const L=Number(x);Number.isNaN(L)?o[D]="Must be a number":(E.min!==void 0&&E.min!==null&&LE.max&&(o[D]=`Maximum value is ${E.max}`))}if(E.minLength!==void 0&&E.minLength!==null&&String(x).lengthE.maxLength&&(o[D]=`Maximum length is ${E.maxLength} characters`),E.pattern)try{new RegExp(E.pattern).test(String(x))||(o[D]="Invalid format")}catch{}}}function A(E){i.value.add(E);const D=u.value.find(x=>x.name===E);D&&b(D)}function O(){for(const E of u.value)b(E)}const M=ge(()=>(O(),u.value.every(E=>!o[E.name])));function w(E){return i.value.has(E)&&o[E]}function v(){if(c.value)try{if(JSON.parse(localStorage.getItem(d.value)||"[]").includes(c.value)){l.value=!0;const D=JSON.parse(localStorage.getItem(`${d.value}:${c.value}`)||"{}");Object.assign(r,D)}}catch{}}function T(){if(c.value)try{const E=d.value,D=JSON.parse(localStorage.getItem(E)||"[]");D.includes(c.value)||(D.push(c.value),localStorage.setItem(E,JSON.stringify(D))),localStorage.setItem(`${E}:${c.value}`,JSON.stringify({...r}))}catch{}}function I(){const E={};for(const D of u.value){const x=r[D.name];D.type==="number"?E[D.name]=x===""||x===void 0?null:Number(x):D.type==="checkbox"?E[D.name]=!!x:E[D.name]=x===void 0?null:x}return E}function h(){if(s.value||l.value||!M.value)return;s.value=!0,O();for(const D of u.value)i.value.add(D.name);if(!M.value){s.value=!1;return}const E={type:"form_submit",form_id:c.value,values:I()};typeof a=="function"?a(E):console.error("[Form] wsSend is not available"),T(),l.value=!0,s.value=!1}return En(()=>{for(const E of u.value)E.type==="checkbox"?r[E.name]=!!E.default:E.type==="multiselect"?r[E.name]=Array.isArray(E.default)?[...E.default]:[]:r[E.name]=E.default??(E.type==="select"&&E.required,"");v()}),(E,D)=>(N(),U("div",gL,[l.value?(N(),U("div",EL,[e.data.title?(N(),U("div",fL,ie(e.data.title),1)):ue("",!0),D[0]||(D[0]=f("div",{class:"ui-form-submitted-note"},[f("i",{class:"ph ph-check-circle"}),Et(" Submitted ")],-1)),f("dl",SL,[(N(!0),U(Ze,null,Ut(u.value,x=>(N(),U("div",{key:x.name,class:"ui-form-summary-row"},[f("dt",null,ie(x.label),1),f("dd",null,ie(p(r[x.name],x)),1)]))),128))])])):(N(),U("div",bL,[e.data.title?(N(),U("div",TL,ie(e.data.title),1)):ue("",!0),e.data.description?(N(),U("div",hL,ie(e.data.description),1)):ue("",!0),f("form",{class:"ui-form-fields",onSubmit:tr(h,["prevent"])},[(N(!0),U(Ze,null,Ut(u.value,x=>(N(),U("div",{key:x.name,class:He(["ui-form-field",{"has-error":w(x.name)}])},[f("label",{class:"ui-form-label",for:_(x.name)},[Et(ie(x.label)+" ",1),x.required?(N(),U("span",RL,"*")):ue("",!0)],8,vL),x.description?(N(),U("div",CL,ie(x.description),1)):ue("",!0),x.type==="textarea"?Ha((N(),U("textarea",{key:1,id:_(x.name),"onUpdate:modelValue":L=>r[x.name]=L,class:"ui-form-input",placeholder:x.placeholder||"",required:x.required,minlength:x.minLength,maxlength:x.maxLength,rows:"3",onBlur:L=>A(x.name),onInput:L=>A(x.name)},null,40,yL)),[[Bi,r[x.name]]]):x.type==="select"?Ha((N(),U("select",{key:2,id:_(x.name),"onUpdate:modelValue":L=>r[x.name]=L,class:"ui-form-input",required:x.required,onBlur:L=>A(x.name),onChange:L=>A(x.name)},[x.required?ue("",!0):(N(),U("option",OL,"—")),(N(!0),U(Ze,null,Ut(x.options,L=>(N(),U("option",{key:L.value,value:L.value},ie(L.label),9,AL))),128))],40,NL)),[[xu,r[x.name]]]):x.type==="multiselect"?Ha((N(),U("select",{key:3,id:_(x.name),"onUpdate:modelValue":L=>r[x.name]=L,class:"ui-form-input",multiple:"",required:x.required,onBlur:L=>A(x.name),onChange:L=>A(x.name)},[(N(!0),U(Ze,null,Ut(x.options,L=>(N(),U("option",{key:L.value,value:L.value},ie(L.label),9,DL))),128))],40,IL)),[[xu,r[x.name]]]):x.type==="checkbox"?(N(),U("label",xL,[Ha(f("input",{id:_(x.name),"onUpdate:modelValue":L=>r[x.name]=L,type:"checkbox",onChange:L=>A(x.name)},null,40,ML),[[sS,r[x.name]]]),f("span",null,ie(x.label),1)])):Ha((N(),U("input",{key:5,id:_(x.name),"onUpdate:modelValue":L=>r[x.name]=L,class:"ui-form-input",type:m(x.type),placeholder:x.placeholder||"",required:x.required,min:x.min,max:x.max,minlength:x.minLength,maxlength:x.maxLength,pattern:x.pattern,onBlur:L=>A(x.name),onInput:L=>A(x.name)},null,40,wL)),[[Fh,r[x.name]]]),w(x.name)?(N(),U("div",LL,ie(o[x.name]),1)):ue("",!0)],2))),128)),f("button",{type:"submit",class:"ui-form-submit",disabled:!M.value||s.value||l.value},[s.value?(N(),U("span",kL)):ue("",!0),f("span",null,ie(e.data.submit_label||"Submit"),1)],8,PL)],32)]))]))}},FL=Mt(UL,[["__scopeId","data-v-d136f18e"]]),BL=Object.freeze(Object.defineProperty({__proto__:null,default:FL},Symbol.toStringTag,{value:"Module"})),PE=Object.assign({"./CardGrid.vue":mL,"./ConfirmDialog.vue":kR,"./ContextBar.vue":MD,"./Form.vue":BL,"./ImageLightbox.vue":HR,"./LoginScreen.vue":cI,"./OfflineBanner.vue":pI,"./ProfileBadge.vue":ID,"./SelectionToolbar.vue":zR,"./WelcomeScreen.vue":TI});function GL(e){return e.split("_").map(t=>t.charAt(0).toUpperCase()+t.slice(1)).join("")}const zr=new Map;for(const e in PE){const t=e.replace(/^.*\//,"").replace(/\.vue$/,""),n=PE[e].default;if(!n)continue;zr.set(t,Sr(n));const a=t.replace(/([a-z0-9])([A-Z])/g,"$1_$2").toLowerCase();zr.set(a,Sr(n))}function YL(e){if(!e||typeof e!="string")return null;if(zr.has(e))return zr.get(e);const t=GL(e);return zr.get(t)||null}const $L={class:"ui-component-card"},qL={class:"ui-component-header"},HL={class:"ui-component-name"},VL={class:"ui-component-body"},zL={key:1,class:"ui-component-fallback"},WL={class:"ui-component-fallback-title"},KL={class:"ui-component-fallback-json"},QL={__name:"UiComponentCard",props:{component:{type:Object,required:!0}},setup(e){const t=e,n=ge(()=>{const a=t.component.component??"";return YL(a)});return(a,r)=>(N(),U("div",$L,[f("div",qL,[r[0]||(r[0]=f("span",{class:"ui-component-icon"},"🧩",-1)),f("span",HL,ie(t.component.component),1),r[1]||(r[1]=f("span",{class:"ui-component-badge"},"UI",-1))]),f("div",VL,[n.value?(N(),ut(ii(n.value),{key:0,data:t.component.payload},null,8,["data"])):(N(),U("div",zL,[f("div",WL," Unknown UI component: "+ie(t.component.component??"?"),1),f("pre",KL,ie(JSON.stringify(t.component.payload,null,2)),1)]))])]))}},XL=Mt(QL,[["__scopeId","data-v-df498067"]]),ZL={key:0,class:"msg-assistant"},JL={key:0,class:"tool-cards-summary"},jL={class:"eyebrow"},eP={key:4,class:"plan-card"},tP=["innerHTML"],nP=["innerHTML"],aP={class:"planning-label"},rP={key:3,class:"stream-cursor"},iP={key:4,class:"msg-meta-row"},oP={key:0,class:"msg-meta-item"},sP={key:1,class:"msg-meta-item"},lP={key:2,class:"msg-meta-item"},cP={key:3,class:"msg-meta-item msg-meta-time"},uP={__name:"AssistantMessage",props:{msg:{type:Object,required:!0},isFlashing:{type:Boolean,default:!1}},setup(e){const t=e,n=j(null),a=on(),r=j(!1),i=ge(()=>ar(t.msg.text)),o=ge(()=>t.msg.done?t.msg.time:null),s=dd(o),l=ge(()=>{var I;let T=null;for(const h of a.messages)(I=h==null?void 0:h.tools)!=null&&I.length&&h.tools.forEach((E,D)=>{E.kind==="tool"&&E.name==="content_publish"&&(T=b(h,D))});return T}),c=ge(()=>{const T=A(t.msg.tools||[]);return T?`Running ${M(T)}...`:""}),u=ge(()=>t.msg.done?"":t.msg.statusLabel?t.msg.statusLabel:c.value?c.value:t.msg.text?"":O(t.msg.tools||[])?"Preparing next action...":"Thinking..."),d=ge(()=>typeof t.msg.id=="string"&&t.msg.id.startsWith("h_")),{copied:_,copy:m}=md();async function p(T){try{await a.rateMessage(t.msg,T)}catch(I){console.error("rate failed",I)}}function g(T){return T?T>=1e3?(T/1e3).toFixed(1).replace(".0","")+"k":String(T):""}function b(T,I){return`${T.id}:content:${I}`}function A(T){var I;for(let h=T.length-1;h>=0;h--){const E=T[h];if(E.kind==="tool"&&E.pending)return E;if((I=E.steps)!=null&&I.length){const D=A(E.steps);if(D)return D}}return null}function O(T){return T.some(I=>{var h;return I.kind==="tool"||I.kind==="plan"||I.kind==="turn_thinking"?!0:(h=I.steps)!=null&&h.length?O(I.steps):!1})}function M(T){var I;return T.name==="filesystem"&&((I=T.args)!=null&&I.action)?`filesystem ${T.args.action}`:T.name}function w(T){return T.kind==="ui_component"?!1:T.kind==="tool"&&T.name!=="content_publish"}const v=ge(()=>{const T=t.msg.tools||[],I=T.map((x,L)=>({item:x,i:L})).filter(({item:x})=>w(x));if(I.length===0||I.length<4)return T.map((x,L)=>({type:"item",item:x,i:L,key:L}));const h=r.value,E=new Set(h?I.map(({i:x})=>x):I.slice(-3).map(({i:x})=>x)),D=[];for(let x=0;xt.msg.done,T=>{T&&Ht(()=>{SM(n.value),TM(n.value)})},{immediate:!0}),(T,I)=>{var h;return e.msg.thinking||(h=e.msg.tools)!=null&&h.length||e.msg.text||e.msg.type==="ui_component"||!e.msg.done?(N(),U("div",ZL,[e.msg.thinking?(N(),ut(Fu,{key:0,msg:e.msg},null,8,["msg"])):ue("",!0),we(xh,{name:"tool-fade",tag:"div"},{default:_t(()=>[(N(!0),U(Ze,null,Ut(v.value,E=>(N(),U("div",{key:E.key,class:"tool-fade-item"},[E.type==="summary"?(N(),U("div",JL,[f("span",jL,ie(E.total)+" tools",1),we(J(kr),{size:"sm",icon:r.value?"ph ph-caret-up":"ph ph-caret-down",onClick:I[0]||(I[0]=D=>r.value=!r.value)},null,8,["icon"])])):E.item.kind==="turn_thinking"?(N(),ut(Fu,{key:1,msg:E.item},null,8,["msg"])):E.item.kind==="tool"&&E.item.name==="content_publish"?(N(),ut(Lw,{key:2,tool:E.item,"default-open":b(e.msg,E.i)===l.value,"collapse-token":l.value},null,8,["tool","default-open","collapse-token"])):E.item.kind==="ui_component"?(N(),ut(XL,{key:3,component:E.item},null,8,["component"])):E.item.kind==="plan"?(N(),U("details",eP,[I[4]||(I[4]=f("summary",null,[f("i",{class:"ph ph-map-trifold"}),Et(" Plan "),f("i",{class:"ph ph-caret-down plan-chevron"})],-1)),f("div",{class:"plan-body",innerHTML:J(ar)(E.item.text)},null,8,tP)])):(N(),ut(aw,{key:5,tool:E.item},null,8,["tool"]))]))),128))]),_:1}),e.msg.text?(N(),U("div",{key:1,ref_key:"contentEl",ref:n,class:He(["msg-assistant-content",{"msg-flash":t.isFlashing}]),innerHTML:i.value},null,10,nP)):ue("",!0),u.value?(N(),U("div",{key:2,class:He(["planning-indicator",{"is-executing":c.value}])},[I[5]||(I[5]=f("span",{class:"spinner"},null,-1)),f("span",aP,ie(u.value),1)],2)):!e.msg.done&&e.msg.text?(N(),U("span",rP)):ue("",!0),e.msg.done?(N(),U("div",iP,[e.msg.elapsed_seconds!=null?(N(),U("span",oP,[I[6]||(I[6]=f("i",{class:"ph ph-timer"},null,-1)),Et(ie(e.msg.elapsed_seconds)+"s ",1)])):ue("",!0),e.msg.tool_call_count?(N(),U("span",sP,[I[7]||(I[7]=f("i",{class:"ph ph-wrench"},null,-1)),Et(ie(e.msg.tool_call_count),1)])):ue("",!0),e.msg.token_count?(N(),U("span",lP,[I[8]||(I[8]=f("i",{class:"ph ph-coins"},null,-1)),Et(ie(g(e.msg.token_count)),1)])):ue("",!0),J(s)?(N(),U("span",cP,ie(J(s)),1)):ue("",!0),e.msg.text?(N(),ut(J(kr),{key:4,icon:J(_)?"ph ph-check":"ph ph-copy",label:J(_)?"Copied!":"Copy",class:"msg-copy-btn",onClick:I[1]||(I[1]=E=>J(m)(e.msg.text))},null,8,["icon","label"])):ue("",!0),d.value?(N(),ut(J(kr),{key:5,icon:"ph ph-thumbs-up",label:"Useful",class:He(["msg-rate-btn",{active:e.msg.rating===1}]),onClick:I[2]||(I[2]=E=>p(1))},null,8,["class"])):ue("",!0),d.value?(N(),ut(J(kr),{key:6,icon:"ph ph-thumbs-down",label:"Not useful",class:He(["msg-rate-btn",{active:e.msg.rating===-1}]),onClick:I[3]||(I[3]=E=>p(-1))},null,8,["class"])):ue("",!0)])):ue("",!0)])):ue("",!0)}}},dP=Mt(uP,[["__scopeId","data-v-9372d2e4"]]),_P={class:"summary-card"},pP=["innerHTML"],mP={__name:"SummaryCard",props:{msg:{type:Object,required:!0}},setup(e){return(t,n)=>(N(),U("details",_P,[n[0]||(n[0]=f("summary",null,[f("i",{class:"ph ph-article"}),Et(" Context summary ")],-1)),f("div",{class:"thinking-body",innerHTML:J(ar)(e.msg.text)},null,8,pP)]))}},gP={key:0,class:"compression-notice compression-pending"},EP=["open"],fP={key:0,class:"compression-counts"},SP={key:1,class:"ph ph-caret-down compression-chevron"},bP=["innerHTML"],TP={__name:"CompressionNotice",props:{msg:{type:Object,required:!0}},setup(e){return(t,n)=>e.msg.type==="compression_pending"?(N(),U("div",gP,[n[0]||(n[0]=f("i",{class:"ph ph-spinner ph-spin"},null,-1)),f("span",null,ie(e.msg.text||"Compressing context…"),1)])):(N(),U("details",{key:1,class:"compression-notice",open:!e.msg.summary},[f("summary",null,[n[1]||(n[1]=f("i",{class:"ph ph-arrows-in"},null,-1)),n[2]||(n[2]=Et(" Context compressed ",-1)),e.msg.before!=null&&e.msg.after!=null?(N(),U("span",fP," ("+ie(e.msg.before)+" → "+ie(e.msg.after)+" messages) ",1)):ue("",!0),e.msg.summary?(N(),U("i",SP)):ue("",!0)]),e.msg.summary?(N(),U("div",{key:0,class:"compression-body",innerHTML:J(ar)(e.msg.summary)},null,8,bP)):ue("",!0)],8,EP))}},hP=Mt(TP,[["__scopeId","data-v-83aba3a0"]]),vP={__name:"ErrorMessage",props:{msg:{type:Object,required:!0}},setup(e){return(t,n)=>{const a=xt("GnAlert");return N(),ut(a,{variant:"danger",role:"alert"},{default:_t(()=>[n[0]||(n[0]=f("i",{class:"ph ph-warning-octagon"},null,-1)),Et(" "+ie(e.msg.text),1)]),_:1})}}},RP={class:"message-list-wrap"},CP={key:0,class:"archive-loading"},yP={class:"messages-group"},NP=["data-msg-index"],OP={__name:"MessageList",setup(e){const t=on(),n=j(null),a=j(!1),r=j(!1),i=j(null);let o=!1,s=null,l=null;function c(p){const g=n.value;if(!g)return;const b=t.messages.findIndex(O=>{var M;return(M=O.rawIndices)==null?void 0:M.includes(p)});if(b===-1)return;const A=g.querySelector(`[data-msg-index="${b}"]`);A&&(A.scrollIntoView({behavior:"smooth",block:"center"}),i.value=b,l&&clearTimeout(l),l=setTimeout(()=>{i.value=null,l=null},3e3))}function u(p){return p.role==="user"?KD:p.type==="summary"?mP:p.type==="compression_notice"||p.type==="compression_pending"?hP:p.type==="error"?vP:dP}function d(p=!1){const g=n.value;g&&g.scrollTo({top:g.scrollHeight,behavior:p?"smooth":"instant"})}function _(){const p=n.value;if(!p)return;const g=p.scrollHeight-p.scrollTop-p.clientHeight;o=g>100,r.value=g>200,p.scrollTop<80&&t.archiveHasMore&&!t.archiveLoading&&(s={scrollHeight:p.scrollHeight,scrollTop:p.scrollTop},t.loadArchivedMessages())}je(()=>t.messages.length,()=>{!o&&!t.loading&&!t.archiveLoading&&Ht(()=>d())}),je(()=>t.streamingMsg,()=>{o||Ht(()=>d())},{deep:!0});function m(p){Ht(()=>requestAnimationFrame(()=>requestAnimationFrame(p)))}return je(()=>t.archiveLoading,p=>{!p&&s&&Ht(()=>{const g=n.value;if(g&&s){const b=g.scrollHeight-s.scrollHeight;g.scrollTop=s.scrollTop+b}s=null})}),je(()=>t.currentId,()=>{o=!1,r.value=!1,a.value=!1,s=null}),je(()=>t.loading,p=>{p||(t.scrollToMessageIndex!=null?(a.value=!0,m(()=>{c(t.scrollToMessageIndex),t.scrollToMessageIndex=null})):(a.value=!1,m(()=>{d(),a.value=!0})))}),En(()=>{!t.loading&&t.messages.length?m(()=>{d(),a.value=!0}):t.loading||(a.value=!0)}),ea(()=>{l&&clearTimeout(l)}),(p,g)=>(N(),U("div",RP,[f("div",{ref_key:"containerEl",ref:n,class:"message-list",onScrollPassive:_},[f("div",{class:He(["message-list-inner",{"is-hidden":!a.value}])},[J(t).archiveLoading?(N(),U("div",CP,[...g[1]||(g[1]=[f("i",{class:"ph ph-spinner animate-spin"},null,-1),f("span",null,"Loading older messages…",-1)])])):ue("",!0),f("div",yP,[(N(!0),U(Ze,null,Ut(J(t).messages,(b,A)=>(N(),U("div",{key:b.id,"data-msg-index":A,class:He({"msg-enter":b.animate})},[(N(),ut(ii(u(b)),{msg:b,"is-flashing":i.value===A},null,8,["msg","is-flashing"]))],10,NP))),128))])],2)],544),we(hr,{name:"scroll-btn"},{default:_t(()=>[r.value?(N(),U("button",{key:0,class:"scroll-to-bottom-btn",title:"Scroll to bottom",onClick:g[0]||(g[0]=b=>d(!0))},[...g[2]||(g[2]=[f("i",{class:"ph ph-arrow-down"},null,-1)])])):ue("",!0)]),_:1})]))}},AP=Mt(OP,[["__scopeId","data-v-00d715bb"]]);function sb(){const e=on(),t=j(!1),n=j(0),a=j(!1);function r(O){return new Promise((M,w)=>{const v=new FileReader;v.onload=async T=>{try{const I=await i(T.target.result,1024,.9);e.pendingImages.push(I),M()}catch(I){w(I)}},v.onerror=w,v.readAsDataURL(O)})}function i(O,M=1024,w=.9){return new Promise((v,T)=>{const I=new Image;I.onload=()=>{let h=I.width,E=I.height;if(h>M||E>M){const L=M/Math.max(h,E);h=Math.round(h*L),E=Math.round(E*L)}const D=document.createElement("canvas");D.width=h,D.height=E,D.getContext("2d").drawImage(I,0,0,h,E),D.toBlob(L=>{if(!L){T(new Error("Canvas toBlob failed"));return}const ae=new FileReader;ae.onload=Ee=>v(Ee.target.result),ae.onerror=T,ae.readAsDataURL(L)},"image/jpeg",w)},I.onerror=T,I.src=O})}function o(O){e.pendingImages.splice(O,1)}async function s(O){if(e.currentId){a.value=!0,n.value=0;try{const M=await Ev(e.currentId,O);e.pendingFiles.push(M),e.fetchFiles(e.currentId)}finally{a.value=!1,n.value=0}}}function l(O){e.pendingFiles.splice(O,1)}async function c(O){const M=Array.from(O.target.files??[]);O.target.value="",await g(M)}async function u(O){var v;const w=Array.from(((v=O.clipboardData)==null?void 0:v.items)??[]).filter(T=>T.type.startsWith("image/"));if(w.length){O.preventDefault();for(const T of w){const I=T.getAsFile();I&&await r(I)}}}function d(O){O.preventDefault(),A(O)&&(t.value=!0)}function _(O){O.preventDefault()}function m(O){O.currentTarget.contains(O.relatedTarget)||(t.value=!1)}async function p(O){var w;O.preventDefault(),t.value=!1;const M=Array.from(((w=O.dataTransfer)==null?void 0:w.files)??[]);await g(M)}async function g(O){for(const M of O)M.type.startsWith("image/")?await r(M):await s(M)}function b(){e.pendingImages=[],e.pendingFiles=[]}function A(O){var M;return Array.from(((M=O.dataTransfer)==null?void 0:M.types)??[]).includes("Files")}return{isDragging:t,uploading:a,uploadProgress:n,handleFileInput:c,handlePaste:u,handleDragEnter:d,handleDragOver:_,handleDragLeave:m,handleDrop:p,removeImage:o,removeFile:l,clearPending:b}}const IP={class:"file-preview-strip"},DP=["src"],xP=["onClick"],MP=["title"],wP=["onClick"],LP={__name:"FilePreviewStrip",setup(e){const t=on(),{removeImage:n,removeFile:a}=sb();return(r,i)=>(N(),U("div",IP,[(N(!0),U(Ze,null,Ut(J(t).pendingImages,(o,s)=>(N(),U("div",{key:`img-${s}`,class:"file-preview-image"},[f("img",{src:o,alt:"attachment"},null,8,DP),f("button",{class:"file-preview-remove",onClick:l=>J(n)(s),title:"Remove"},[...i[0]||(i[0]=[f("i",{class:"ph ph-x"},null,-1)])],8,xP)]))),128)),(N(!0),U(Ze,null,Ut(J(t).pendingFiles,(o,s)=>(N(),U("div",{key:`file-${s}`,class:"file-preview-pill"},[i[2]||(i[2]=f("i",{class:"ph ph-file"},null,-1)),f("span",{title:o.name},ie(o.name),9,MP),f("button",{class:"file-preview-remove",onClick:l=>J(a)(s),title:"Remove"},[...i[1]||(i[1]=[f("i",{class:"ph ph-x"},null,-1)])],8,wP)]))),128))]))}},PP=Mt(LP,[["__scopeId","data-v-0239fe0c"]]),kP={key:1,class:"upload-progress"},UP={key:2,class:"reconnect-notice"},FP={class:"input-row"},BP=["disabled"],GP=["disabled","onKeydown"],YP=["disabled"],$P={__name:"InputBar",props:{ws:{type:Object,required:!0}},setup(e){const t=e,n=on(),{isDragging:a,uploading:r,handleFileInput:i,handlePaste:o,handleDragEnter:s,handleDragOver:l,handleDragLeave:c,handleDrop:u,clearPending:d}=sb(),_=j(""),m=j(null),p=j(null),g=j(!1),b=ge(()=>!!n.currentId&&!n.streaming&&!g.value&&(_.value.trim()||n.pendingImages.length||n.pendingFiles.length));je(()=>n.currentId,h=>{_.value=h?n.loadDraft(h):"",Ht(w)},{immediate:!0});let A=null;je(_,h=>{A&&clearTimeout(A),A=setTimeout(()=>n.saveDraft(h),300)});const{pendingQuote:O,consumeQuote:M}=AS();je(O,h=>{if(!h)return;const E=h.split(` -`).map(D=>`> ${D}`).join(` -`);_.value=E+` - -`+_.value,M(),Ht(()=>{var x;w(),(x=m.value)==null||x.focus();const D=m.value;D&&(D.selectionStart=D.selectionEnd=D.value.length)})});function w(){const h=m.value;h&&(h.style.height="auto",h.style.height=Math.min(h.scrollHeight,144)+"px")}function v(){if(!(!b.value||g.value)){g.value=!0;try{const h=_.value.trim(),E=[...n.pendingImages],D=[...n.pendingFiles];n.appendUserMessage(h,E,D),d(),_.value="",Ht(w);const x=E.map(ae=>ae.split(",",2)[1]).filter(Boolean),L={type:"message",content:h||" "};x.length&&(L.images=x),D.length&&(L.files=D),t.ws.send(L)}finally{g.value=!1}}}function T(){const h=m.value;if(!h)return;const E=h.selectionStart,D=h.selectionEnd;_.value=_.value.slice(0,E)+` -`+_.value.slice(D),Ht(()=>{h.selectionStart=h.selectionEnd=E+1,w()})}async function I(){n.currentId&&await cv(n.currentId)}return(h,E)=>(N(),U("div",{class:He(["input-bar input-dropzone",{"is-dragging":J(a)}]),onDragenter:E[4]||(E[4]=(...D)=>J(s)&&J(s)(...D)),onDragover:E[5]||(E[5]=(...D)=>J(l)&&J(l)(...D)),onDragleave:E[6]||(E[6]=(...D)=>J(c)&&J(c)(...D)),onDrop:E[7]||(E[7]=(...D)=>J(u)&&J(u)(...D))},[J(n).pendingImages.length||J(n).pendingFiles.length?(N(),ut(PP,{key:0})):ue("",!0),J(r)?(N(),U("div",kP,[...E[8]||(E[8]=[f("div",{class:"upload-progress-fill",style:{width:"60%"}},null,-1)])])):ue("",!0),t.ws.reconnectFailed.value?(N(),U("div",UP,[...E[9]||(E[9]=[f("i",{class:"ph ph-warning"},null,-1),Et(" Connection lost — retrying in background ",-1)])])):ue("",!0),f("div",FP,[f("input",{ref_key:"fileInputEl",ref:p,type:"file",multiple:"",style:{display:"none"},onChange:E[0]||(E[0]=(...D)=>J(i)&&J(i)(...D))},null,544),f("button",{class:"btn-icon",title:"Attach files",disabled:!J(n).currentId,onClick:E[1]||(E[1]=D=>p.value.click())},[...E[10]||(E[10]=[f("i",{class:"ph ph-paperclip"},null,-1)])],8,BP),Ha(f("textarea",{ref_key:"textareaEl",ref:m,"onUpdate:modelValue":E[2]||(E[2]=D=>_.value=D),class:"input-textarea",placeholder:"Message Navi…",rows:"1",disabled:!J(n).currentId,onKeydown:[ei(tr(v,["exact","prevent"]),["enter"]),ei(tr(T,["ctrl","prevent"]),["enter"])],onInput:w,onPaste:E[3]||(E[3]=(...D)=>J(o)&&J(o)(...D))},null,40,GP),[[Bi,_.value]]),J(n).streaming?(N(),U("button",{key:0,class:"btn-icon",title:"Stop generation",onClick:I},[...E[11]||(E[11]=[f("i",{class:"ph ph-stop-circle"},null,-1)])])):(N(),U("button",{key:1,class:"btn-icon",title:"Send (Enter)",disabled:!b.value,onClick:v},[...E[12]||(E[12]=[f("i",{class:"ph ph-paper-plane-tilt"},null,-1)])],8,YP))])],34))}},qP=Mt($P,[["__scopeId","data-v-150985a2"]]),HP={key:0,class:"task-chips"},VP=["title"],zP={key:1,class:"task-chip queued"},WP={__name:"BackgroundTasksChip",setup(e){const t=on(),n=ge(()=>Object.values(t.backgroundTasks)),a=ge(()=>[...new Set(n.value.map(o=>o.tool))].join(", ")),r=ge(()=>n.value.map(i=>`${i.tool} — ${i.status}`).join(` -`));return(i,o)=>(N(),ut(hr,{name:"fade"},{default:_t(()=>[n.value.length||J(t).queuedMessages.count?(N(),U("div",HP,[n.value.length?(N(),U("div",{key:0,class:"task-chip",title:r.value},[o[0]||(o[0]=f("i",{class:"ph ph-arrows-out"},null,-1)),f("span",null,ie(n.value.length)+" in background — "+ie(a.value),1)],8,VP)):ue("",!0),J(t).queuedMessages.count?(N(),U("div",zP,[o[1]||(o[1]=f("i",{class:"ph ph-inbox"},null,-1)),f("span",null,ie(J(t).queuedMessages.count)+" message"+ie(J(t).queuedMessages.count===1?"":"s")+" queued ",1)])):ue("",!0)])):ue("",!0)]),_:1}))}},KP=Mt(WP,[["__scopeId","data-v-6cc8cea3"]]),QP={class:"chat-area"},XP={key:0,class:"reconnect-banner"},ZP={key:1,class:"empty-chat"},JP={__name:"ChatArea",emits:["toggle-sidebar","toggle-artifacts"],setup(e,{emit:t}){const n=t,a=on(),r=ND();je(()=>a.currentId,o=>{o?r.connect(o):r.disconnect()},{immediate:!0});function i(){a.currentId&&r.connect(a.currentId)}return ea(()=>r.disconnect()),(o,s)=>{const l=xt("GnIconButton");return N(),U("div",QP,[we(GD,{onToggleSidebar:s[0]||(s[0]=c=>n("toggle-sidebar")),onToggleArtifacts:s[1]||(s[1]=c=>n("toggle-artifacts"))}),we(hr,{name:"fade"},{default:_t(()=>[J(r).reconnectFailed.value?(N(),U("div",XP,[s[2]||(s[2]=f("i",{class:"ph ph-wifi-slash"},null,-1)),s[3]||(s[3]=Et(" Connection lost. Retrying in background… ",-1)),we(l,{icon:"ph ph-arrows-clockwise",label:"Retry",onClick:i})])):ue("",!0)]),_:1}),J(a).currentId?(N(),U(Ze,{key:0},[we(AP),we(KP),we(qP,{ws:J(r)},null,8,["ws"])],64)):(N(),U("div",ZP,[...s[4]||(s[4]=[f("i",{class:"ph ph-chat-dots empty-icon"},null,-1),f("p",null,"Select a conversation or start a new one",-1)])]))])}}},jP=Mt(JP,[["__scopeId","data-v-51c70097"]]),ek=si("apiTokens",()=>{const e=j([]),t=j(!1),n=j(!1);async function a(){t.value=!0;try{const o=await Sv();e.value=o.items||[]}finally{t.value=!1}}async function r(o){n.value=!0;try{const s=await bv(o);return e.value.unshift({id:s.id,name:s.name,token_prefix:s.token_prefix,created_at:s.created_at,last_used_at:null}),s}finally{n.value=!1}}async function i(o){await Tv(o),e.value=e.value.filter(s=>s.id!==o)}return{tokens:e,loading:t,creating:n,fetchTokens:a,createToken:r,revokeToken:i}}),tk={class:"create-key-body"},nk={__name:"CreateKeyModal",props:{open:Boolean,creating:Boolean},emits:["close","submit"],setup(e,{emit:t}){const n=e,a=t,r=j("");je(()=>n.open,o=>{o&&(r.value="")});function i(){const o=r.value.trim();o&&a("submit",o)}return(o,s)=>{const l=xt("GnInput"),c=xt("GnButton"),u=xt("GnModal");return N(),ut(u,{open:n.open,title:"Create API Key","onUpdate:open":s[2]||(s[2]=d=>a("close"))},{actions:_t(()=>[we(c,{variant:"secondary",onClick:s[1]||(s[1]=d=>a("close")),disabled:n.creating},{default:_t(()=>[...s[3]||(s[3]=[Et(" Cancel ",-1)])]),_:1},8,["disabled"]),we(c,{variant:"primary",loading:n.creating,onClick:i},{default:_t(()=>[...s[4]||(s[4]=[Et(" Create ",-1)])]),_:1},8,["loading"])]),default:_t(()=>[f("div",tk,[we(l,{modelValue:r.value,"onUpdate:modelValue":s[0]||(s[0]=d=>r.value=d),label:"Name",placeholder:"e.g. Smart Watch, Automation Script",disabled:n.creating,onKeydown:ei(i,["enter"])},null,8,["modelValue","disabled"])])]),_:1},8,["open"])}}},ak=Mt(nk,[["__scopeId","data-v-45469a93"]]),rk={class:"show-token-body"},ik={class:"show-token-field"},ok={class:"show-token-value"},sk={__name:"ShowTokenModal",props:{open:Boolean,token:String},emits:["close"],setup(e,{emit:t}){const n=e,a=t,{copied:r,copy:i}=md();return(o,s)=>{const l=xt("GnIconButton"),c=xt("GnButton"),u=xt("GnModal");return N(),ut(u,{open:n.open,title:"API Key Created","onUpdate:open":s[2]||(s[2]=d=>a("close"))},{actions:_t(()=>[we(c,{variant:"primary",onClick:s[1]||(s[1]=d=>a("close"))},{default:_t(()=>[...s[4]||(s[4]=[Et(" Done ",-1)])]),_:1})]),default:_t(()=>[f("div",rk,[s[3]||(s[3]=f("p",{class:"show-token-warning"},[f("i",{class:"ph ph-warning-circle"}),Et(" Copy this token now — it will "),f("strong",null,"never be shown again"),Et(". ")],-1)),f("div",ik,[f("code",ok,ie(n.token),1),we(l,{icon:J(r)?"ph ph-check":"ph ph-copy",label:J(r)?"Copied!":"Copy to clipboard",onClick:s[0]||(s[0]=d=>J(i)(n.token))},null,8,["icon","label"])])])]),_:1},8,["open"])}}},lk=Mt(sk,[["__scopeId","data-v-508ff6f7"]]),ck={class:"api-keys-panel"},uk={class:"api-keys-header"},dk={key:0,class:"api-keys-warning"},_k={key:1,class:"api-keys-loading"},pk={key:2,class:"api-keys-empty"},mk={key:3,class:"api-keys-table-wrapper"},gk={class:"api-keys-table"},Ek={class:"col-name"},fk={class:"col-prefix"},Sk={class:"col-created"},bk={class:"col-last-used"},Tk={class:"col-actions"},hk={__name:"ApiKeysPanel",setup(e){const t=ek(),n=uo(),a=yS(),r=pd(),i=j(!1),o=j(!1),s=j("");En(()=>{t.fetchTokens()});function l(){i.value=!0}async function c(_){try{const m=await t.createToken(_);i.value=!1,s.value=m.token,o.value=!0}catch(m){r.error({title:"Failed to create key",text:m.message})}}async function u(_,m){if(await a(`Revoke API key "${m}"? This cannot be undone.`))try{await t.revokeToken(_),r.success({title:"API key revoked"})}catch(g){r.error({title:"Failed to revoke key",text:g.message})}}function d(_){return _?new Date(_).toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"}):null}return(_,m)=>{const p=xt("GnButton"),g=xt("GnIconButton");return N(),U("div",ck,[f("div",uk,[m[3]||(m[3]=f("h2",{class:"api-keys-title"},"API Keys",-1)),we(p,{variant:"primary",icon:"ph ph-plus",onClick:l},{default:_t(()=>[...m[2]||(m[2]=[Et(" New Key ",-1)])]),_:1})]),m[6]||(m[6]=f("p",{class:"api-keys-description"}," API keys allow headless clients (scripts, voice assistants, IoT devices) to authenticate without browser-based OAuth. ",-1)),J(n).isNoAuthMode?(N(),U("div",dk,[...m[4]||(m[4]=[f("i",{class:"ph ph-warning-circle"},null,-1),Et(" Authorization is currently disabled. Any keys created here are tied to the local anonymous user and grant full access to this Navi instance. ",-1)])])):ue("",!0),J(t).loading?(N(),U("div",_k,"Loading...")):J(t).tokens.length?(N(),U("div",mk,[f("div",gk,[m[5]||(m[5]=Xf('
    NameKeyCreatedLast used
    ',1)),(N(!0),U(Ze,null,Ut(J(t).tokens,b=>(N(),U("div",{key:b.id,class:"api-keys-row"},[f("span",Ek,ie(b.name),1),f("span",fk,ie(b.token_prefix),1),f("span",Sk,ie(d(b.created_at)),1),f("span",bk,ie(d(b.last_used_at)||"Never"),1),f("span",Tk,[we(g,{icon:"ph ph-trash",label:"Revoke",variant:"ghost",onClick:A=>u(b.id,b.name)},null,8,["onClick"])])]))),128))])])):(N(),U("div",pk," No API keys yet. Create one to get started. ")),we(ak,{open:i.value,creating:J(t).creating,onClose:m[0]||(m[0]=b=>i.value=!1),onSubmit:c},null,8,["open","creating"]),we(lk,{open:o.value,token:s.value,onClose:m[1]||(m[1]=b=>o.value=!1)},null,8,["open","token"])])}}},vk=Mt(hk,[["__scopeId","data-v-a118e6d3"]]);function Rk(e){const t="=".repeat((4-e.length%4)%4),n=(e+t).replace(/-/g,"+").replace(/_/g,"/"),a=atob(n),r=new Uint8Array(a.length);for(let i=0;igo()&&lb()),zi=j(lb()?Notification.permission:"denied"),ti=j(!1),Ja=j(!1);async function ub(){if(!yd()||!go())return null;const e=await navigator.serviceWorker.getRegistration();return e?e.pushManager.getSubscription():null}async function Ck(){if(!(!yd()||!go()))try{const e=await ub();ti.value=!!e,zi.value=notificationsSupported?Notification.permission:"denied"}catch{ti.value=!1}}async function yk(){if(!(!cb.value||Ja.value)){Ja.value=!0;try{if(zi.value=await Notification.requestPermission(),zi.value!=="granted")return!1;const{public_key:e}=await hv();if(!e)return!1;const t=await navigator.serviceWorker.ready;let n=await t.pushManager.getSubscription();n||(n=await t.pushManager.subscribe({userVisibleOnly:!0,applicationServerKey:Rk(e)}));const a=n.toJSON();return await vv({endpoint:a.endpoint,keys:a.keys,user_agent:navigator.userAgent}),ti.value=!0,!0}finally{Ja.value=!1}}}async function Nk(){if(!(!yd()||!go()||Ja.value)){Ja.value=!0;try{const e=await ub();if(e){try{await Rv(e.endpoint)}catch{}await e.unsubscribe()}ti.value=!1}finally{Ja.value=!1}}}function Ok(){return{supported:cb,permission:zi,subscribed:ti,busy:Ja,enable:yk,disable:Nk,syncState:Ck}}const Ak={class:"notifications-panel"},Ik={key:0,class:"notifications-unsupported"},Dk={key:1,class:"notifications-row"},xk={class:"notifications-row-text"},Mk={class:"notifications-row-status"},wk={__name:"NotificationSettingsPanel",setup(e){const{supported:t,permission:n,subscribed:a,busy:r,enable:i,disable:o,syncState:s}=Ok(),l=pd();En(()=>{s()});async function c(u){try{if(u){const d=await i();d===!1&&n.value==="denied"?l.error({title:"Permission denied",text:"Allow notifications in the browser site settings."}):d===!1&&l.error({title:"Push unavailable",text:"The server does not accept push subscriptions right now."})}else await o()}catch(d){l.error({title:"Push error",text:d.message})}}return(u,d)=>{const _=xt("GnSwitch");return N(),U("div",Ak,[d[2]||(d[2]=f("h2",{class:"notifications-title"},"Notifications",-1)),d[3]||(d[3]=f("p",{class:"notifications-description"}," Push notifications let Navi ping you when a reply is ready — even when the tab is closed. You get one notification per finished reply, but only when no Navi window is open on that session. ",-1)),J(t)?(N(),U("div",Dk,[f("div",xk,[d[1]||(d[1]=f("div",{class:"notifications-row-title"},"Push notifications",-1)),f("div",Mk,[J(a)?(N(),U(Ze,{key:0},[Et("Enabled — this device is subscribed.")],64)):J(n)==="denied"?(N(),U(Ze,{key:1},[Et("Blocked in browser site settings.")],64)):(N(),U(Ze,{key:2},[Et("Disabled.")],64))])]),we(_,{"model-value":J(a),disabled:J(r)||J(n)==="denied","onUpdate:modelValue":c},null,8,["model-value","disabled"])])):(N(),U("div",Ik,[...d[0]||(d[0]=[f("i",{class:"ph ph-info"},null,-1),f("span",null," This browser does not support web push (needs HTTPS, a service worker and the Push API). Try Chrome or a recent Firefox. ",-1)])]))])}}},Lk=Mt(wk,[["__scopeId","data-v-ae387b36"]]),Pk={class:"settings-view"},kk={class:"settings-header"},Uk={class:"settings-body"},Fk={__name:"SettingsView",emits:["toggle-sidebar"],setup(e,{emit:t}){const n=t;return(a,r)=>{const i=xt("GnIconButton");return N(),U("div",Pk,[f("div",kk,[we(i,{icon:"ph ph-list",label:"Toggle sidebar",class:"settings-sidebar-toggle",onClick:r[0]||(r[0]=o=>n("toggle-sidebar"))}),r[1]||(r[1]=f("h1",{class:"settings-title"},"Settings",-1))]),f("div",Uk,[we(vk),we(Lk)])])}}},Bk=Mt(Fk,[["__scopeId","data-v-3b76b25d"]]),Gk={class:"app-shell"},Yk={class:"app-main"},$k={__name:"App",setup(e){const t=Zn(),n=li(),a=on(),r=uo(),i=j(!1),o=j(!1);function s(){return location.hash==="#settings"?"settings":"chat"}const l=j(s()),c=ge(()=>l.value==="chat"&&!a.currentId&&!a.loading),u=ge(()=>{if(l.value==="settings")return"Navi — Settings";if(!a.currentId)return"Navi";const b=t.sessions.find(A=>A.session_id===a.currentId);return(b==null?void 0:b.name)||a.currentId.slice(0,8)});je(u,b=>{document.title=b},{immediate:!0});function d(){i.value=!1}function _(){o.value=!1}function m(){const b=!i.value;b&&(o.value=!1),i.value=b}function p(){const b=!o.value;b&&(i.value=!1),o.value=b}function g(){l.value=s();const b=location.hash;if(b==="#settings")return;const A=b.slice(1);A&&A!==a.currentId&&a.loadSession(A)}return En(async()=>{if(window.addEventListener("hashchange",g),await r.fetchStatus(),r.authConfigured)try{await r.fetchMe()}catch{}if(!r.authConfigured||r.isAuthenticated)try{await n.fetchProfiles(),await t.fetchSessions(n.selectedProfileId)}catch{}if(location.hash&&location.hash!=="#settings"){const b=location.hash.slice(1);b&&a.loadSession(b)}}),ea(()=>{window.removeEventListener("hashchange",g)}),(b,A)=>{const O=xt("GnToastProvider");return N(),ut(O,null,{default:_t(()=>[f("div",Gk,[i.value?(N(),U("div",{key:0,class:"sidebar-backdrop",onClick:d})):ue("",!0),we(hr,{name:"backdrop-fade"},{default:_t(()=>[o.value?(N(),U("div",{key:0,class:"artifacts-backdrop",onClick:_})):ue("",!0)]),_:1}),we(PR,{"mobile-open":i.value,class:He({"is-hidden-by-artifacts":o.value}),onClose:d},null,8,["mobile-open","class"]),we(NS),we(OS),we(IS),we(PS),f("div",Yk,[we(hr,{name:"fade",mode:"out-in"},{default:_t(()=>[c.value?(N(),ut(kS,{key:"welcome",onToggleSidebar:m})):l.value==="settings"?(N(),ut(Bk,{key:"settings",onToggleSidebar:m})):(N(),ut(jP,{key:"chat",onToggleSidebar:m,onToggleArtifacts:p}))]),_:1})]),we(iI,{open:o.value,onClose:_},null,8,["open"]),J(r).authConfigured&&!J(r).isAuthenticated&&!J(r).loading?(N(),ut(LS,{key:1})):ue("",!0)])]),_:1})}}},qk=Mt($k,[["__scopeId","data-v-a29c0392"]]),Nd=Vh(qk);Nd.use(Kh());Nd.use(SD);Nd.mount("#app");"serviceWorker"in navigator&&navigator.serviceWorker.register("/sw.js").catch(()=>{}); diff --git a/webclient/dist/assets/index-CVywHeX3.css b/webclient/dist/assets/index-CVywHeX3.css deleted file mode 100644 index aa16d8c..0000000 --- a/webclient/dist/assets/index-CVywHeX3.css +++ /dev/null @@ -1 +0,0 @@ -@charset "UTF-8";.vue-recycle-scroller__resize-observer[data-v-08cc04ab]{position:absolute;top:0;right:0;bottom:0;left:0;opacity:0;pointer-events:none;z-index:-1}.vue-recycle-scroller{position:relative}.vue-recycle-scroller.direction-vertical:not(.page-mode){overflow-y:auto}.vue-recycle-scroller.direction-horizontal:not(.page-mode){overflow-x:auto}.vue-recycle-scroller.grid-mode:not(.page-mode){overflow:auto}.vue-recycle-scroller.direction-horizontal{display:flex}.vue-recycle-scroller__slot{flex:auto 0 0}.vue-recycle-scroller__item-wrapper{flex:1;box-sizing:border-box;overflow:hidden;position:relative}.vue-recycle-scroller.ready .vue-recycle-scroller__item-view{position:absolute;top:0;left:0;will-change:transform}.vue-recycle-scroller.direction-vertical .vue-recycle-scroller__item-wrapper{width:100%}.vue-recycle-scroller.direction-horizontal .vue-recycle-scroller__item-wrapper{height:100%}.vue-recycle-scroller.ready.direction-vertical .vue-recycle-scroller__item-view{width:100%}.vue-recycle-scroller.ready.direction-horizontal .vue-recycle-scroller__item-view{height:100%}.container[data-v-73f7dfc6]{padding:18px}.section[data-v-73f7dfc6]{margin-bottom:48px}.section-title[data-v-73f7dfc6],.block[data-v-73f7dfc6]{margin-bottom:34px}.block-title[data-v-73f7dfc6]{margin-bottom:22px}p[data-v-73f7dfc6],.text[data-v-73f7dfc6]{margin-bottom:15px}.hint[data-v-73f7dfc6]{margin-top:8px}.list[data-v-73f7dfc6]{padding-left:22px;margin-bottom:15px}.list-item[data-v-73f7dfc6]{margin-bottom:8px}.list-nested[data-v-73f7dfc6]{margin-top:8px}.table[data-v-73f7dfc6]{margin-bottom:22px}.table-caption[data-v-73f7dfc6]{margin-bottom:8px}.form-group[data-v-73f7dfc6]{margin-bottom:15px}.label[data-v-73f7dfc6]{margin-bottom:5px;display:block}.input[data-v-73f7dfc6],.textarea[data-v-73f7dfc6],.select[data-v-73f7dfc6]{margin-top:5px}.toast[data-v-73f7dfc6]{padding:15px}.toast-stack[data-v-73f7dfc6]{gap:8px}.search-highlight[data-v-73f7dfc6]{background:#7aa2f740;color:#7aa2f7;font-weight:600;padding:0 2px;border-radius:2px}.session-name-row[data-v-73f7dfc6]{display:flex;align-items:center;gap:6px;font-weight:500;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.recall-badge[data-v-73f7dfc6]{color:var(--color-accent, #f59e0b);font-size:.85em;flex-shrink:0}.session-list-wrap[data-v-b1f213b6]{flex:1;overflow:hidden;display:flex;flex-direction:column}.session-scroller[data-v-b1f213b6]{flex:1;overflow-y:auto}.empty-sessions[data-v-b1f213b6]{display:flex;flex-direction:column;align-items:center;gap:8px;padding:32px 16px;color:var(--color-text-dark, #787c99);font-size:13px}.empty-sessions i[data-v-b1f213b6]{font-size:32px;opacity:.4}.empty-sessions p[data-v-b1f213b6]{margin:0}.sessions-loading[data-v-b1f213b6]{display:flex;align-items:center;justify-content:center;gap:10px;padding:28px 16px;color:var(--color-text-dark, #787c99);font-size:12px}.sessions-loading-more[data-v-b1f213b6]{padding:10px 16px 14px}.sessions-spinner[data-v-b1f213b6]{width:16px;height:16px;border:2px solid var(--color-border, #3b4261);border-top-color:var(--color-accent, #7aa2f7);border-radius:50%;animation:sessions-spin-b1f213b6 .8s linear infinite}@keyframes sessions-spin-b1f213b6{to{transform:rotate(360deg)}}.ptr-indicator[data-v-b1f213b6]{position:absolute;top:0;left:0;right:0;z-index:10;display:flex;align-items:center;justify-content:center;gap:8px;padding:8px;font-size:12px;color:var(--color-text-dark, #787c99);pointer-events:none;transition:opacity .15s,transform .15s;will-change:transform,opacity}.ptr-spinner[data-v-b1f213b6]{width:16px;height:16px;border:2px solid var(--color-border, #3b4261);border-top-color:var(--color-accent, #7aa2f7);border-radius:50%;transition:transform .15s}.ptr-spinning[data-v-b1f213b6]{animation:sessions-spin-b1f213b6 .8s linear infinite}.ptr-pulled[data-v-b1f213b6]{transition:transform .15s}@media(min-width:769px){.ptr-indicator[data-v-b1f213b6]{display:none}}.container[data-v-d94da62e]{padding:18px}.section[data-v-d94da62e]{margin-bottom:48px}.section-title[data-v-d94da62e],.block[data-v-d94da62e]{margin-bottom:34px}.block-title[data-v-d94da62e]{margin-bottom:22px}p[data-v-d94da62e],.text[data-v-d94da62e]{margin-bottom:15px}.hint[data-v-d94da62e]{margin-top:8px}.list[data-v-d94da62e]{padding-left:22px;margin-bottom:15px}.list-item[data-v-d94da62e]{margin-bottom:8px}.list-nested[data-v-d94da62e]{margin-top:8px}.table[data-v-d94da62e]{margin-bottom:22px}.table-caption[data-v-d94da62e]{margin-bottom:8px}.form-group[data-v-d94da62e]{margin-bottom:15px}.label[data-v-d94da62e]{margin-bottom:5px;display:block}.input[data-v-d94da62e],.textarea[data-v-d94da62e],.select[data-v-d94da62e]{margin-top:5px}.toast[data-v-d94da62e]{padding:15px}.toast-stack[data-v-d94da62e]{gap:8px}.sidebar-close-btn[data-v-d94da62e]{display:none}@media(max-width:1280px){.sidebar-close-btn[data-v-d94da62e]{display:flex;margin-left:auto}}.sidebar-search[data-v-d94da62e]{display:none;padding:0 15px}.sidebar-search.is-open[data-v-d94da62e]{display:block;padding-top:8px;padding-bottom:8px;border-bottom:1px solid var(--color-border)}.sidebar-search-inner[data-v-d94da62e]{position:relative;display:flex;align-items:center;gap:5px}.sidebar-search-inner[data-v-d94da62e] .search-field{flex:1;min-width:0}.sidebar-search-inner.is-loading[data-v-d94da62e] .input-group-addon{position:relative!important}.sidebar-search-inner.is-loading[data-v-d94da62e] .input-group-addon>i{display:none!important}.sidebar-search-inner.is-loading[data-v-d94da62e] .input-group-addon:after{content:"";display:block;width:12px;height:12px;border:2px solid rgba(192,202,245,.24);border-top-color:#7aa2f7;border-radius:50%;animation:spin .6s linear infinite;margin:auto}.sessions-header-actions[data-v-d94da62e]{display:flex;align-items:center;gap:2px}.search-toggle-btn[data-v-d94da62e]{font-size:14px;color:#787c99;transition:color .15s}.search-toggle-btn.active[data-v-d94da62e],.search-toggle-btn[data-v-d94da62e]:hover{color:#c0caf5}.recall-filter-btn[data-v-d94da62e]{font-size:14px;color:#787c99;transition:color .15s}.recall-filter-btn.active[data-v-d94da62e],.recall-filter-btn[data-v-d94da62e]:hover{color:var(--color-accent, #7aa2f7)}.sidebar-footer[data-v-d94da62e]{padding:12px 16px;border-top:1px solid var(--color-border);display:flex;align-items:center;justify-content:space-between;gap:8px}.user-info[data-v-d94da62e]{display:flex;align-items:center;gap:8px;text-decoration:none;color:inherit;flex:1;min-width:0;cursor:pointer}.user-info:hover .user-name[data-v-d94da62e]{color:var(--color-text-primary)}.user-name[data-v-d94da62e]{font-size:13px;color:var(--color-text-secondary);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sidebar-footer-actions[data-v-d94da62e]{display:flex;align-items:center;gap:8px}.admin-link[data-v-d94da62e]{text-decoration:none}.lightbox-dialog{width:fit-content;max-width:90vw;min-width:280px}.lightbox-panel{max-width:90vw;min-height:unset;width:fit-content;cursor:default}body .modal .lightbox-panel .modal-body{max-height:90vh;padding:0}.lightbox-img{display:block;width:auto;height:auto;max-width:100%;max-height:90vh}.lightbox-error{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;padding:32px;color:#787c99;font-size:13px}.lightbox-error i{font-size:32px}.selection-toolbar[data-v-81606e7c]{position:fixed;transform:translate(-50%);z-index:900;pointer-events:all;background:#e0af68;color:#000}.artifacts-panel[data-v-9dbbe7c1]{width:var(--artifacts-width, min(600px, 42vw));min-width:var(--artifacts-width, min(600px, 42vw));max-width:var(--artifacts-width, min(600px, 42vw));display:flex;flex-direction:column;background:#16161e;border-left:2px solid rgba(192,202,245,.24);min-height:0;margin-right:calc(-1 * var(--artifacts-width, min(600px, 42vw)));opacity:0;pointer-events:none;transform:translate(100%);position:relative;transition:margin-right .22s ease,opacity .22s ease,transform .22s ease}.artifacts-panel.is-open[data-v-9dbbe7c1]{margin-right:0;opacity:1;pointer-events:auto;transform:translate(0)}.artifacts-panel.is-resizing[data-v-9dbbe7c1]{transition:none}.artifacts-resize-handle[data-v-9dbbe7c1]{position:absolute;top:0;left:-4px;bottom:0;width:8px;z-index:2;cursor:col-resize;touch-action:none}.artifacts-resize-handle[data-v-9dbbe7c1]:after{content:"";position:absolute;top:0;left:3px;width:1px;height:100%;background:transparent;transition:background .15s ease}.artifacts-resize-handle[data-v-9dbbe7c1]:hover:after,.artifacts-panel.is-resizing .artifacts-resize-handle[data-v-9dbbe7c1]:after{background:#ff9e64}.artifacts-header[data-v-9dbbe7c1]{height:58px;display:flex;align-items:center;justify-content:space-between;gap:12px;padding:0 15px;border-bottom:2px solid rgba(192,202,245,.24)}.artifacts-empty[data-v-9dbbe7c1]{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:#787c99;font-size:13px}.artifacts-empty i[data-v-9dbbe7c1]{font-size:28px}.artifacts-tabs[data-v-9dbbe7c1]{display:flex;align-items:center;flex:1}.artifacts-tab[data-v-9dbbe7c1]{position:relative;display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:46px;padding:12px 15px;border:0;border-right:2px solid rgba(192,202,245,.08);background:transparent;color:#a9b1d6;font-size:13px;font-weight:700;text-transform:uppercase;letter-spacing:.05em;cursor:pointer;transition:background .2s ease,color .2s ease}.artifacts-tab[data-v-9dbbe7c1]:hover{background:#7aa2f7;color:#16161e}.artifacts-tab.is-active[data-v-9dbbe7c1]{background:#c0caf5;color:#16161e}.artifacts-tab-count[data-v-9dbbe7c1]{display:inline-flex;align-items:center;justify-content:center;min-width:18px;height:18px;padding:0 5px;background:#1f2335;color:#787c99;font-size:11px;font-weight:600}.artifacts-tab.is-active .artifacts-tab-count[data-v-9dbbe7c1]{background:#16161e33;color:#16161e}.artifacts-list[data-v-9dbbe7c1]{max-height:232px;overflow-y:auto;border-bottom:2px solid rgba(192,202,245,.24)}.artifact-item[data-v-9dbbe7c1]{width:100%;min-height:50px;display:flex;align-items:center;gap:10px;padding:8px 12px;border:2px solid transparent;background:#c0caf50b;color:#c0caf5;text-align:left;cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease}.artifact-item[data-v-9dbbe7c1]:hover{background:#7aa2f7;color:#16161e}.artifact-item.is-active[data-v-9dbbe7c1]{border-color:#7aa2f7;background:#7aa2f7;color:#16161e}.artifact-icon[data-v-9dbbe7c1]{width:28px;height:28px;display:inline-flex;align-items:center;justify-content:center;color:#ff9e64;background:#c0caf516}.artifact-item:hover .artifact-icon[data-v-9dbbe7c1],.artifact-item.is-active .artifact-icon[data-v-9dbbe7c1]{color:#16161e;background:#16161e1f}.artifact-info[data-v-9dbbe7c1]{min-width:0;flex:1;display:flex;flex-direction:column;gap:2px}.artifact-title[data-v-9dbbe7c1],.artifact-detail-title[data-v-9dbbe7c1],.artifact-detail-filename[data-v-9dbbe7c1]{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.artifact-title[data-v-9dbbe7c1]{font-size:13px;font-weight:500}.artifact-meta[data-v-9dbbe7c1]{font-size:11px;color:#787c99}.artifact-item:hover .artifact-meta[data-v-9dbbe7c1],.artifact-item.is-active .artifact-meta[data-v-9dbbe7c1]{color:#16161eb8}.artifact-detail[data-v-9dbbe7c1]{flex:1;min-height:0;display:flex;flex-direction:column}.artifact-detail-header[data-v-9dbbe7c1]{padding:12px 15px 8px}.artifact-detail-title[data-v-9dbbe7c1]{font-size:14px;font-weight:600;color:#c0caf5}.artifact-detail-filename[data-v-9dbbe7c1]{margin-top:3px;font-size:12px;color:#787c99}.artifact-actions[data-v-9dbbe7c1]{display:grid;grid-template-columns:repeat(auto-fit,minmax(42px,1fr));gap:6px;padding:0 15px 12px}.artifact-action[data-v-9dbbe7c1]{height:32px;display:inline-flex;align-items:center;justify-content:center;border:2px solid rgba(192,202,245,.24);background:#1f2335;color:#c0caf5;text-decoration:none;cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease}.artifact-action[data-v-9dbbe7c1]:hover{background:#7aa2f7;border-color:#7aa2f7;color:#16161e}.artifact-preview[data-v-9dbbe7c1]{flex:1;min-height:0;border-top:2px solid rgba(192,202,245,.24);background:#0f0f14}.artifact-frame[data-v-9dbbe7c1],.artifact-image[data-v-9dbbe7c1],.artifact-video[data-v-9dbbe7c1]{width:100%;height:100%;border:0;display:block}.artifact-image[data-v-9dbbe7c1],.artifact-video[data-v-9dbbe7c1]{object-fit:contain}.artifact-source[data-v-9dbbe7c1]{height:100%;overflow:auto;background:#0f0f14}.artifact-source-code[data-v-9dbbe7c1],.artifact-source-error[data-v-9dbbe7c1]{margin:0;padding:14px;white-space:pre;font-family:IBM Plex Mono,monospace;font-size:12px;line-height:1.6;color:#c0caf5}.artifact-source-error[data-v-9dbbe7c1]{color:#f7768e}.artifact-source-state[data-v-9dbbe7c1]{display:flex;align-items:center;gap:8px;padding:14px;color:#787c99;font-size:12px}.artifact-no-preview[data-v-9dbbe7c1]{height:100%;min-height:220px;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;color:#787c99;font-size:13px}.artifact-no-preview i[data-v-9dbbe7c1]{font-size:28px}.links-list[data-v-9dbbe7c1]{max-height:none;flex:1;overflow-y:auto}.link-item[data-v-9dbbe7c1]{text-decoration:none}.link-item .artifact-title[data-v-9dbbe7c1]{color:#ff9e64}.link-item:hover .artifact-title[data-v-9dbbe7c1],.link-item.is-active .artifact-title[data-v-9dbbe7c1]{color:#16161e}.link-detail[data-v-9dbbe7c1]{padding:12px 15px;border-top:2px solid rgba(192,202,245,.24)}.link-detail-header[data-v-9dbbe7c1]{margin-bottom:8px}.link-detail-count[data-v-9dbbe7c1]{font-size:12px;color:#787c99}.link-actions[data-v-9dbbe7c1]{display:flex;gap:6px}.files-list[data-v-9dbbe7c1]{max-height:none;flex:1;overflow-y:auto}.file-item[data-v-9dbbe7c1],.file-item.is-dir[data-v-9dbbe7c1]{cursor:default}.file-item.is-dir .artifact-title[data-v-9dbbe7c1]{color:#a9b1d6}.file-row-actions[data-v-9dbbe7c1]{display:flex;gap:4px;flex-shrink:0;opacity:0;transition:opacity .15s ease}.file-item:hover .file-row-actions[data-v-9dbbe7c1]{opacity:1}.file-row-action[data-v-9dbbe7c1]{width:28px;height:28px;min-height:0;padding:0}@media(max-width:980px){.artifacts-panel[data-v-9dbbe7c1]{position:fixed;top:0;right:0;bottom:0;z-index:120;margin-right:0;transform:translate(100%);width:100vw;min-width:100vw;max-width:100vw}.artifacts-resize-handle[data-v-9dbbe7c1]{display:none}.artifacts-panel.is-open[data-v-9dbbe7c1]{transform:translate(0)}.artifacts-header[data-v-9dbbe7c1]{gap:6px;padding:0 10px}.artifacts-tab[data-v-9dbbe7c1]{padding:8px 10px;gap:4px}.artifacts-tab>span[data-v-9dbbe7c1]:not(.artifacts-tab-count){display:none}}@media(prefers-reduced-motion:reduce){.artifacts-panel[data-v-9dbbe7c1]{transition:none}}.files-tab-wrap[data-v-9dbbe7c1]{position:relative;flex:1;display:flex;flex-direction:column;overflow:hidden}.files-refresh-btn[data-v-9dbbe7c1]{position:absolute;top:8px;right:8px;z-index:2;width:28px;height:28px;display:inline-flex;align-items:center;justify-content:center;border:2px solid rgba(192,202,245,.24);background:#1f2335;color:#c0caf5;font-size:14px;cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease}.files-refresh-btn[data-v-9dbbe7c1]:hover{background:#7aa2f7;border-color:#7aa2f7;color:#16161e}.files-refresh-btn[data-v-9dbbe7c1]:disabled{opacity:.5;cursor:not-allowed}.files-refresh-btn i.spinning[data-v-9dbbe7c1]{display:inline-block;animation:refresh-spin-9dbbe7c1 .8s linear infinite}@keyframes refresh-spin-9dbbe7c1{to{transform:rotate(360deg)}}@media(max-width:980px){.files-refresh-btn[data-v-9dbbe7c1]{display:none}}.files-ptr[data-v-9dbbe7c1]{position:absolute;top:0;left:0;right:0;z-index:10;display:flex;align-items:center;justify-content:center;gap:8px;padding:8px;font-size:12px;color:var(--color-text-dark, #787c99);pointer-events:none;transition:opacity .15s,transform .15s;will-change:transform,opacity}.ptr-pulled[data-v-9dbbe7c1]{transition:transform .15s}@media(min-width:981px){.files-ptr[data-v-9dbbe7c1]{display:none}}.terminals-list[data-v-9dbbe7c1]{max-height:none;flex:1;overflow-y:auto}.terminal-item.is-closed[data-v-9dbbe7c1]{opacity:.6}.terminal-item .artifact-meta[data-v-9dbbe7c1]{white-space:normal;word-break:break-word;line-height:1.4;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}.terminal-status-badge[data-v-9dbbe7c1]{display:inline-flex;align-items:center;justify-content:center;padding:2px 8px;font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.05em;border:2px solid transparent}.status-busy[data-v-9dbbe7c1]{background:#73daca;color:#16161e;border-color:#73daca}.status-idle[data-v-9dbbe7c1]{background:#7aa2f7;color:#16161e;border-color:#7aa2f7}.status-closed[data-v-9dbbe7c1]{background:#f7768e;color:#16161e;border-color:#f7768e}.terminal-detail[data-v-9dbbe7c1]{flex:1;min-height:0;display:flex;flex-direction:column;border-top:2px solid rgba(192,202,245,.24);overflow-y:auto}.terminal-detail-header[data-v-9dbbe7c1]{padding:12px 15px 8px;display:flex;align-items:flex-start;justify-content:space-between;gap:8px}.terminal-detail-title[data-v-9dbbe7c1]{font-size:14px;font-weight:600;color:#c0caf5;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.terminal-detail-close[data-v-9dbbe7c1]{width:28px;height:28px;display:inline-flex;align-items:center;justify-content:center;flex-shrink:0;border:2px solid rgba(192,202,245,.24);background:#1f2335;color:#c0caf5;font-size:14px;cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease}.terminal-detail-close[data-v-9dbbe7c1]:hover{background:#7aa2f7;border-color:#7aa2f7;color:#16161e}.terminal-detail-meta[data-v-9dbbe7c1]{margin-top:3px;font-size:12px;color:#787c99;word-break:break-word;line-height:1.5}.terminal-detail-grid[data-v-9dbbe7c1]{display:flex;flex-direction:column;gap:6px;padding:0 15px 12px;border-bottom:2px solid rgba(192,202,245,.12)}.terminal-detail-row[data-v-9dbbe7c1]{display:flex;align-items:center;justify-content:space-between;gap:8px;font-size:12px}.terminal-detail-label[data-v-9dbbe7c1]{color:#787c99;flex-shrink:0}.terminal-detail-value[data-v-9dbbe7c1]{color:#c0caf5;text-align:right;word-break:break-all}.terminal-detail-value.status-busy[data-v-9dbbe7c1]{color:#73daca}.terminal-detail-value.status-idle[data-v-9dbbe7c1]{color:#7aa2f7}.terminal-detail-value.status-closed[data-v-9dbbe7c1]{color:#f7768e}.terminal-detail-command[data-v-9dbbe7c1]{font-family:IBM Plex Mono,monospace;font-size:11px;color:#ff9e64}.terminal-output-wrap[data-v-9dbbe7c1]{flex:1;min-height:0;display:flex;flex-direction:column;background:#0f0f14}.terminal-output-header[data-v-9dbbe7c1]{padding:8px 15px;font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:.05em;color:#787c99;border-bottom:2px solid rgba(192,202,245,.12)}.terminal-output[data-v-9dbbe7c1]{flex:1;margin:0;padding:14px;overflow:auto;white-space:pre-wrap;word-break:break-word;font-family:IBM Plex Mono,monospace;font-size:12px;line-height:1.6;color:#c0caf5}.login-overlay[data-v-6939826e]{position:fixed;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;background:#111;z-index:9999}.login-card[data-v-6939826e]{display:flex;flex-direction:column;align-items:center;gap:16px;padding:48px 40px;border:1px solid var(--color-border);border-radius:16px;max-width:360px;width:90%}.login-logo[data-v-6939826e]{width:64px;height:64px}.login-title[data-v-6939826e]{font-size:24px;font-weight:700;color:var(--color-text-primary);margin:0}.login-subtitle[data-v-6939826e]{font-size:14px;color:var(--color-text-secondary);margin:0}.login-btn[data-v-6939826e]{margin-top:8px;width:100%;justify-content:center}.container[data-v-2f8cc0a8]{padding:18px}.section[data-v-2f8cc0a8]{margin-bottom:48px}.section-title[data-v-2f8cc0a8],.block[data-v-2f8cc0a8]{margin-bottom:34px}.block-title[data-v-2f8cc0a8]{margin-bottom:22px}p[data-v-2f8cc0a8],.text[data-v-2f8cc0a8]{margin-bottom:15px}.hint[data-v-2f8cc0a8]{margin-top:8px}.list[data-v-2f8cc0a8]{padding-left:22px;margin-bottom:15px}.list-item[data-v-2f8cc0a8]{margin-bottom:8px}.list-nested[data-v-2f8cc0a8]{margin-top:8px}.table[data-v-2f8cc0a8]{margin-bottom:22px}.table-caption[data-v-2f8cc0a8]{margin-bottom:8px}.form-group[data-v-2f8cc0a8]{margin-bottom:15px}.label[data-v-2f8cc0a8]{margin-bottom:5px;display:block}.input[data-v-2f8cc0a8],.textarea[data-v-2f8cc0a8],.select[data-v-2f8cc0a8]{margin-top:5px}.toast[data-v-2f8cc0a8]{padding:15px}.toast-stack[data-v-2f8cc0a8]{gap:8px}.offline-banner[data-v-2f8cc0a8]{display:flex;align-items:center;justify-content:center;gap:8px;padding:5px 15px;background:#ff9e6426;color:#ff9e64;font-size:12px;border-bottom:1px solid rgba(255,158,100,.3)}.offline-banner i[data-v-2f8cc0a8]{font-size:16px;flex-shrink:0}.offline-slide-enter-active[data-v-2f8cc0a8],.offline-slide-leave-active[data-v-2f8cc0a8]{transition:max-height .25s ease,opacity .25s ease;overflow:hidden}.offline-slide-enter-from[data-v-2f8cc0a8],.offline-slide-leave-to[data-v-2f8cc0a8]{max-height:0;opacity:0}.offline-slide-enter-to[data-v-2f8cc0a8],.offline-slide-leave-from[data-v-2f8cc0a8]{max-height:48px;opacity:1}.welcome-sidebar-btn[data-v-43638b99]{display:none;position:absolute;top:12px;left:12px}@media(max-width:1280px){.welcome-sidebar-btn[data-v-43638b99]{display:flex}}.context-bar-pct[data-v-fe8d0787]{font-size:11px;font-weight:600;font-variant-numeric:tabular-nums;color:var(--color-success);white-space:nowrap}.context-bar-pct.is-warn[data-v-fe8d0787]{color:var(--color-warning)}.context-bar-pct.is-crit[data-v-fe8d0787]{color:var(--color-error)}.btn-artifacts-toggle[data-v-a43d8e5c]{position:relative}.artifact-count[data-v-a43d8e5c]{position:absolute;top:-3px;right:-3px;min-width:16px;height:16px;display:inline-flex;align-items:center;justify-content:center;padding:0 4px;font-size:10px;line-height:1;background:var(--accent, #4ec9b0);color:#11111b}.recall-banner[data-v-a43d8e5c]{display:flex;align-items:center;gap:8px;padding:6px 12px;background:rgba(var(--color-accent-rgb, 122, 162, 247),.12);border-bottom:1px solid var(--color-border, #3b4261);font-size:12px;color:var(--color-text, #a9b1d6)}.recall-banner i[data-v-a43d8e5c]{color:var(--color-accent, #7aa2f7);font-size:14px}.recall-text[data-v-a43d8e5c]{flex:1;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.recall-btn[data-v-a43d8e5c]{background:none;border:none;color:var(--color-text-dark, #787c99);cursor:pointer;padding:2px 4px;font-size:14px;line-height:1;border-radius:4px;transition:color .15s,background .15s}.recall-btn[data-v-a43d8e5c]:hover{color:var(--color-text, #a9b1d6);background:#ffffff0f}.content-card[data-v-49cee8cc]{margin:8px 0;background:var(--surface, #1e1e2e);border:1px solid var(--border, #2a2a3e);overflow:hidden}.content-card summary[data-v-49cee8cc]{display:flex;align-items:center;gap:8px;padding:10px 14px;cursor:pointer;-webkit-user-select:none;user-select:none;list-style:none}.content-card summary[data-v-49cee8cc]::-webkit-details-marker{display:none}.content-icon[data-v-49cee8cc]{font-size:1.2em;line-height:1}.content-title[data-v-49cee8cc]{flex:1;font-size:.9em;font-weight:500;color:var(--text, #cdd6f4);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.content-badge[data-v-49cee8cc]{font-size:.7em;text-transform:uppercase;padding:2px 8px;background:var(--accent-muted, #313244);color:var(--accent, #4ec9b0)}.content-actions[data-v-49cee8cc]{display:inline-flex;align-items:center;gap:4px}.content-actions a[data-v-49cee8cc],.content-actions button[data-v-49cee8cc]{width:26px;height:26px;display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--border, #2a2a3e);background:var(--surface-elevated, #242438);color:var(--text, #cdd6f4);text-decoration:none;cursor:pointer}.content-actions a[data-v-49cee8cc]:hover,.content-actions button[data-v-49cee8cc]:hover{color:var(--accent, #4ec9b0);border-color:var(--accent, #4ec9b0)}.content-chevron[data-v-49cee8cc]{transition:transform .2s;color:var(--text-muted, #6c7086)}.content-card[open] .content-chevron[data-v-49cee8cc]{transform:rotate(180deg)}.content-body[data-v-49cee8cc]{border-top:1px solid var(--border, #2a2a3e);overflow:auto}.content-iframe[data-v-49cee8cc]{width:100%;height:300px;border:none;display:block}@media(min-width:768px){.content-iframe[data-v-49cee8cc]{height:500px}}.content-image[data-v-49cee8cc]{width:100%;max-height:60vh;object-fit:contain;cursor:zoom-in;display:block;background:var(--surface, #1e1e2e)}.content-video[data-v-49cee8cc]{width:100%;max-height:60vh;display:block;background:var(--surface, #1e1e2e)}.content-source[data-v-49cee8cc]{max-height:500px;overflow:auto;background:#11111b}.content-source-code[data-v-49cee8cc],.content-source-error[data-v-49cee8cc]{margin:0;padding:14px;white-space:pre;font-family:IBM Plex Mono,monospace;font-size:12px;line-height:1.6;color:var(--text, #cdd6f4)}.content-source-error[data-v-49cee8cc]{color:var(--error, #f7768e)}.content-source-state[data-v-49cee8cc]{display:flex;align-items:center;gap:8px;padding:14px;color:var(--text-muted, #6c7086);font-size:12px}.content-unknown[data-v-49cee8cc]{padding:24px;text-align:center;color:var(--text-muted, #6c7086);display:flex;flex-direction:column;align-items:center;gap:10px}.unknown-icon[data-v-49cee8cc]{font-size:2em;line-height:1}.unknown-name[data-v-49cee8cc]{font-size:.95em;font-weight:500;color:var(--text, #cdd6f4);word-break:break-word;max-width:100%}.unknown-open[data-v-49cee8cc]{display:inline-block;margin-top:4px;padding:6px 14px;border-radius:0;background:var(--accent-muted, #313244);color:var(--accent, #4ec9b0);text-decoration:none;font-size:.85em;font-weight:500;transition:background .15s}.unknown-open[data-v-49cee8cc]:hover{background:var(--border, #2a2a3e)}.content-card.is-stl .content-badge[data-v-49cee8cc]{color:#f5c2e7}.content-card.is-html .content-badge[data-v-49cee8cc]{color:#89b4fa}.content-card.is-svg .content-badge[data-v-49cee8cc]{color:#a6e3a1}.content-card.is-pdf .content-badge[data-v-49cee8cc]{color:#fab387}.content-card.is-image .content-badge[data-v-49cee8cc]{color:#89dceb}.content-card.is-video .content-badge[data-v-49cee8cc]{color:#f38ba8}.card-grid[data-v-61f4362e]{display:flex;flex-direction:column;gap:12px}.card-grid-title[data-v-61f4362e]{font-size:1rem;font-weight:600;color:var(--text, #cdd6f4)}.card-grid-items[data-v-61f4362e]{display:grid;grid-template-columns:repeat(2,1fr);gap:12px}@media(max-width:640px){.card-grid-items[data-v-61f4362e]{grid-template-columns:1fr}}.card-grid-item[data-v-61f4362e]{display:flex;flex-direction:column;background:var(--surface-elevated, #242438);border:1px solid var(--border, #2a2a3e);overflow:hidden;cursor:pointer;transition:border-color .15s,transform .1s}.card-grid-item[data-v-61f4362e]:hover,.card-grid-item[data-v-61f4362e]:focus{border-color:var(--accent, #4ec9b0);outline:none}.card-grid-item[data-v-61f4362e]:active{transform:scale(.99)}.card-image[data-v-61f4362e]{width:100%;height:140px;object-fit:cover;background:var(--surface, #1e1e2e)}.card-no-image[data-v-61f4362e]{width:100%;height:140px;display:flex;align-items:center;justify-content:center;color:var(--text-muted, #6c7086);font-size:2rem;background:var(--surface, #1e1e2e)}.card-content[data-v-61f4362e]{padding:12px;display:flex;flex-direction:column;gap:8px;flex:1}.card-title[data-v-61f4362e]{font-weight:600;font-size:.95rem;color:var(--text, #cdd6f4);line-height:1.3}.card-subtitle[data-v-61f4362e]{font-size:.8rem;color:var(--text-muted, #6c7086)}.card-meta[data-v-61f4362e]{display:flex;flex-wrap:wrap;gap:8px}.card-meta-item[data-v-61f4362e]{display:flex;gap:4px;font-size:.75rem}.card-meta-label[data-v-61f4362e]{color:var(--text-muted, #6c7086)}.card-meta-value[data-v-61f4362e]{color:var(--text, #cdd6f4);font-weight:500}.card-description[data-v-61f4362e]{font-size:.8rem;color:var(--text, #cdd6f4);line-height:1.4;opacity:.85;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}.card-grid-more[data-v-61f4362e]{text-align:center;font-size:.8rem;color:var(--text-muted, #6c7086)}.card-modal-overlay[data-v-61f4362e]{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1000;background:#0009;display:flex;align-items:center;justify-content:center;padding:16px}.card-modal[data-v-61f4362e]{position:relative;width:100%;max-width:560px;max-height:90vh;background:var(--surface, #1e1e2e);border:1px solid var(--border, #2a2a3e);overflow:hidden;display:flex;flex-direction:column}.card-modal-close[data-v-61f4362e]{position:absolute;top:12px;right:12px;width:32px;height:32px;display:flex;align-items:center;justify-content:center;background:var(--surface-elevated, #242438);border:1px solid var(--border, #2a2a3e);color:var(--text, #cdd6f4);cursor:pointer;z-index:2}.card-modal-close[data-v-61f4362e]:hover{border-color:var(--accent, #4ec9b0);color:var(--accent, #4ec9b0)}.card-modal-scroll[data-v-61f4362e]{overflow-y:auto;max-height:90vh}.card-modal-image[data-v-61f4362e]{width:100%;max-height:320px;object-fit:cover;background:var(--surface, #1e1e2e)}.card-modal-content[data-v-61f4362e]{padding:20px;display:flex;flex-direction:column;gap:18px}.card-modal-title[data-v-61f4362e]{margin:0;font-size:1.3rem;font-weight:600;color:var(--text, #cdd6f4)}.card-modal-subtitle[data-v-61f4362e]{color:var(--text-muted, #6c7086);font-size:.9rem}.card-modal-section[data-v-61f4362e]{display:flex;flex-direction:column;gap:10px}.card-modal-section-title[data-v-61f4362e]{font-size:.75rem;text-transform:uppercase;letter-spacing:.05em;color:var(--text-muted, #6c7086)}.card-modal-meta-grid[data-v-61f4362e]{display:grid;grid-template-columns:repeat(2,1fr);gap:10px}.card-modal-meta-cell[data-v-61f4362e]{background:var(--surface-elevated, #242438);border:1px solid var(--border, #2a2a3e);padding:10px}.card-modal-meta-label[data-v-61f4362e]{font-size:.7rem;color:var(--text-muted, #6c7086);margin-bottom:4px}.card-modal-meta-value[data-v-61f4362e]{font-size:.9rem;color:var(--text, #cdd6f4);font-weight:500}.card-modal-text[data-v-61f4362e]{margin:0;line-height:1.5;color:var(--text, #cdd6f4)}.card-modal-details[data-v-61f4362e]{margin:0;display:grid;gap:8px}.card-modal-detail-row[data-v-61f4362e]{display:flex;justify-content:space-between;gap:12px;padding:8px 0;border-bottom:1px solid var(--border, #2a2a3e)}.card-modal-detail-row[data-v-61f4362e]:last-child{border-bottom:none}.card-modal-detail-row dt[data-v-61f4362e]{color:var(--text-muted, #6c7086);font-size:.85rem}.card-modal-detail-row dd[data-v-61f4362e]{margin:0;color:var(--text, #cdd6f4);font-size:.85rem;text-align:right;word-break:break-word}.card-modal-actions[data-v-61f4362e]{display:flex;gap:10px;flex-wrap:wrap}.card-modal-action[data-v-61f4362e]{display:inline-flex;align-items:center;padding:8px 14px;background:var(--accent-muted, #313244);color:var(--accent, #4ec9b0);text-decoration:none;font-size:.85rem;font-weight:500}.card-modal-action[data-v-61f4362e]:hover{background:var(--border, #2a2a3e)}.ui-form[data-v-d136f18e]{display:flex;flex-direction:column;gap:14px}.ui-form-title[data-v-d136f18e]{font-size:1rem;font-weight:600;color:var(--text, #cdd6f4)}.ui-form-description[data-v-d136f18e]{font-size:.85rem;color:var(--text-muted, #6c7086);line-height:1.4}.ui-form-fields[data-v-d136f18e]{display:flex;flex-direction:column;gap:14px}.ui-form-field[data-v-d136f18e]{display:flex;flex-direction:column;gap:4px}.ui-form-field.has-error .ui-form-input[data-v-d136f18e]{border-color:var(--color-error, #f38ba8)}.ui-form-label[data-v-d136f18e]{font-size:.85rem;font-weight:500;color:var(--text, #cdd6f4)}.ui-form-required[data-v-d136f18e]{color:var(--color-error, #f38ba8);margin-left:2px}.ui-form-field-hint[data-v-d136f18e]{font-size:.75rem;color:var(--text-muted, #6c7086)}.ui-form-input[data-v-d136f18e]{padding:10px 12px;background:var(--surface, #1e1e2e);border:1px solid var(--border, #2a2a3e);color:var(--text, #cdd6f4);font-size:.9rem;outline:none;transition:border-color .15s}.ui-form-input[data-v-d136f18e]:focus{border-color:var(--accent, #4ec9b0)}.ui-form-input[data-v-d136f18e]::placeholder{color:var(--text-muted, #6c7086)}select.ui-form-input[data-v-d136f18e]{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='%236c7086' viewBox='0 0 256 256'%3E%3Cpath d='M213.66 101.66l-80 80a8 8 0 0 1-11.32 0l-80-80A8 8 0 0 1 48 88h160a8 8 0 0 1 5.66 13.66z'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 12px center;padding-right:32px}select.ui-form-input[multiple][data-v-d136f18e]{background-image:none;padding-right:12px;min-height:100px}.ui-form-checkbox[data-v-d136f18e]{display:flex;align-items:center;gap:8px;font-size:.9rem;color:var(--text, #cdd6f4);cursor:pointer}.ui-form-checkbox input[data-v-d136f18e]{width:18px;height:18px;accent-color:var(--accent, #4ec9b0);cursor:pointer}.ui-form-error[data-v-d136f18e]{font-size:.8rem;color:var(--color-error, #f38ba8)}.ui-form-submit[data-v-d136f18e]{display:inline-flex;align-items:center;justify-content:center;gap:8px;align-self:flex-start;padding:10px 18px;background:var(--accent, #4ec9b0);color:var(--surface, #1e1e2e);border:none;font-size:.9rem;font-weight:600;cursor:pointer;transition:opacity .15s}.ui-form-submit[data-v-d136f18e]:disabled{opacity:.5;cursor:not-allowed}.ui-form-submit[data-v-d136f18e]:not(:disabled):hover{opacity:.9}.ui-form-spinner[data-v-d136f18e]{width:14px;height:14px;border:2px solid currentColor;border-top-color:transparent;border-radius:50%;animation:ui-form-spin-d136f18e .8s linear infinite}@keyframes ui-form-spin-d136f18e{to{transform:rotate(360deg)}}.ui-form-submitted[data-v-d136f18e]{display:flex;flex-direction:column;gap:10px}.ui-form-submitted-note[data-v-d136f18e]{display:flex;align-items:center;gap:6px;font-size:.85rem;color:var(--accent, #4ec9b0)}.ui-form-summary[data-v-d136f18e]{margin:0;display:grid;gap:8px}.ui-form-summary-row[data-v-d136f18e]{display:flex;justify-content:space-between;gap:12px;padding:8px 0;border-bottom:1px solid var(--border, #2a2a3e)}.ui-form-summary-row[data-v-d136f18e]:last-child{border-bottom:none}.ui-form-summary-row dt[data-v-d136f18e]{color:var(--text-muted, #6c7086);font-size:.85rem}.ui-form-summary-row dd[data-v-d136f18e]{margin:0;color:var(--text, #cdd6f4);font-size:.85rem;text-align:right;word-break:break-word}.ui-component-card[data-v-df498067]{margin:8px 0;background:var(--surface, #1e1e2e);border:1px solid var(--border, #2a2a3e);overflow:hidden}.ui-component-header[data-v-df498067]{display:flex;align-items:center;gap:8px;padding:10px 14px;border-bottom:1px solid var(--border, #2a2a3e);-webkit-user-select:none;user-select:none}.ui-component-icon[data-v-df498067]{font-size:1.2em;line-height:1}.ui-component-name[data-v-df498067]{flex:1;font-size:.9em;font-weight:500;color:var(--text, #cdd6f4);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.ui-component-badge[data-v-df498067]{font-size:.7em;text-transform:uppercase;padding:2px 8px;background:var(--accent-muted, #313244);color:var(--accent, #4ec9b0)}.ui-component-body[data-v-df498067]{padding:12px 14px}.ui-component-fallback[data-v-df498067]{color:var(--text-muted, #6c7086)}.ui-component-fallback-title[data-v-df498067]{font-size:.8rem;margin-bottom:8px;font-weight:500}.ui-component-fallback-json[data-v-df498067]{margin:0;font-family:monospace;font-size:.8rem;white-space:pre-wrap}.stream-cursor[data-v-9372d2e4]{display:inline-block;width:2px;height:1em;background:currentColor;margin-left:2px;vertical-align:text-bottom;animation:blink-9372d2e4 1s step-end infinite}@keyframes blink-9372d2e4{0%,to{opacity:1}50%{opacity:0}}.msg-rate-btn[data-v-9372d2e4]{opacity:.55;transition:opacity .15s,color .15s}.msg-rate-btn[data-v-9372d2e4]:hover{opacity:1}.msg-rate-btn.active[data-v-9372d2e4]{opacity:1;color:var(--accent, #4ec9b0)}.compression-pending[data-v-83aba3a0]{display:flex;align-items:center;gap:8px;padding:8px 12px;border-radius:8px;background:var(--color-bg-tertiary, #2a2b3d);color:var(--color-text-muted, #8b8fa3);font-size:13px}.compression-pending i[data-v-83aba3a0]{font-size:16px}.message-list-wrap[data-v-00d715bb]{flex:1;min-height:0;position:relative;display:flex;flex-direction:column}.messages-group[data-v-00d715bb]{display:flex;flex-direction:column;gap:32px}.archive-loading[data-v-00d715bb]{display:flex;align-items:center;justify-content:center;gap:8px;padding:16px;font-size:13px;color:var(--color-fg-muted, #a9b1d6)}.animate-spin[data-v-00d715bb]{animation:spin-00d715bb 1s linear infinite}@keyframes spin-00d715bb{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.scroll-to-bottom-btn[data-v-00d715bb]{position:absolute;bottom:16px;right:16px;width:40px;height:40px;border-radius:50%;background:var(--color-secondary, #7aa2f7);color:var(--color-black, #1a1b2e);border:none;cursor:pointer;display:flex;align-items:center;justify-content:center;font-size:18px;box-shadow:0 2px 12px #0006;opacity:.9;transition:opacity .15s ease,transform .15s ease;z-index:10}.scroll-to-bottom-btn[data-v-00d715bb]:hover{opacity:1;transform:translateY(-2px)}.scroll-btn-enter-active[data-v-00d715bb],.scroll-btn-leave-active[data-v-00d715bb]{transition:opacity .2s ease,transform .2s ease}.scroll-btn-enter-from[data-v-00d715bb],.scroll-btn-leave-to[data-v-00d715bb]{opacity:0;transform:translateY(8px)}.file-preview-image[data-v-0239fe0c]{position:relative}.file-preview-image .file-preview-remove[data-v-0239fe0c]{position:absolute;top:-4px;right:-4px;background:var(--surface-panel, #1f2335);border:1px solid var(--border-color-muted);width:18px;height:18px;display:flex;align-items:center;justify-content:center;font-size:10px;cursor:pointer;color:var(--color-text-dark)}.file-preview-image .file-preview-remove[data-v-0239fe0c]:hover{color:var(--color-error)}.reconnect-notice[data-v-150985a2]{display:flex;align-items:center;gap:6px;padding:4px 8px;font-size:12px;color:var(--color-warning, #e0af68);margin-bottom:4px}.task-chips[data-v-6cc8cea3]{display:flex;gap:8px;padding:4px 16px 0;flex-wrap:wrap}.task-chip[data-v-6cc8cea3]{display:inline-flex;align-items:center;gap:6px;padding:3px 10px;border-radius:999px;border:1px solid var(--border-color-muted, rgba(128, 128, 128, .25));background:var(--surface-panel-muted, rgba(128, 128, 128, .08));font-size:12px;color:var(--color-text-medium, #999);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}.task-chip i[data-v-6cc8cea3]{color:var(--color-warning, #e0af68)}.task-chip.queued i[data-v-6cc8cea3]{color:var(--color-primary, #7aa2f7)}.fade-enter-active[data-v-6cc8cea3],.fade-leave-active[data-v-6cc8cea3]{transition:opacity .2s}.fade-enter-from[data-v-6cc8cea3],.fade-leave-to[data-v-6cc8cea3]{opacity:0}.reconnect-banner[data-v-51c70097]{display:flex;align-items:center;gap:8px;padding:6px 16px;background:#e0af681a;border-bottom:1px solid rgba(224,175,104,.3);font-size:13px;color:var(--color-warning, #e0af68)}.create-key-body[data-v-45469a93]{min-width:320px}.show-token-body[data-v-508ff6f7]{min-width:420px}.show-token-warning[data-v-508ff6f7]{margin:0 0 16px;font-size:.875rem;color:var(--color-warning, #e0af68);display:flex;align-items:center;gap:6px}.show-token-warning i[data-v-508ff6f7]{font-size:1.1rem}.show-token-field[data-v-508ff6f7]{display:flex;align-items:center;gap:8px;padding:10px 12px;background:var(--surface-panel, #1f2335);border:1px solid var(--color-border, #3b4261);border-radius:6px}.show-token-value[data-v-508ff6f7]{flex:1 1 0;font-family:monospace;font-size:.85rem;word-break:break-all;color:var(--color-text, #a9b1d6)}.api-keys-panel[data-v-a118e6d3]{max-width:800px}.api-keys-header[data-v-a118e6d3]{display:flex;align-items:center;justify-content:space-between;margin-bottom:12px}.api-keys-title[data-v-a118e6d3]{font-size:1.1rem;font-weight:600;margin:0;color:var(--color-text, #a9b1d6)}.api-keys-description[data-v-a118e6d3]{margin:0 0 16px;font-size:.875rem;color:var(--color-text-secondary, #a9b1d6)}.api-keys-loading[data-v-a118e6d3],.api-keys-empty[data-v-a118e6d3]{padding:24px;text-align:center;color:var(--color-text-dark, #787c99);font-size:.9rem}.api-keys-warning[data-v-a118e6d3]{display:flex;align-items:flex-start;gap:8px;padding:12px;margin-bottom:16px;border:1px solid var(--color-warning, #e0af68);border-radius:8px;color:var(--color-text-secondary, #a9b1d6);font-size:.875rem}.api-keys-warning i[data-v-a118e6d3]{color:var(--color-warning, #e0af68);font-size:16px;flex-shrink:0}.api-keys-row[data-v-a118e6d3]{display:grid;grid-template-columns:2fr 1fr 1fr 1fr auto;gap:12px;align-items:center;padding:10px 12px;font-size:.875rem;border-bottom:1px solid var(--color-border, #3b4261)}.api-keys-header-row[data-v-a118e6d3]{font-weight:600;color:var(--color-text-secondary, #a9b1d6);border-bottom-width:2px}.col-name[data-v-a118e6d3]{color:var(--color-text, #a9b1d6)}.col-prefix[data-v-a118e6d3]{font-family:monospace;color:var(--color-text-secondary, #a9b1d6)}.col-created[data-v-a118e6d3],.col-last-used[data-v-a118e6d3]{color:var(--color-text-dark, #787c99)}.col-actions[data-v-a118e6d3]{text-align:right}.notifications-panel[data-v-ae387b36]{max-width:800px;margin-bottom:24px}.notifications-title[data-v-ae387b36]{font-size:1.1rem;font-weight:600;margin:0 0 12px;color:var(--color-text, #a9b1d6)}.notifications-description[data-v-ae387b36]{margin:0 0 16px;font-size:.875rem;color:var(--color-text-secondary, #a9b1d6)}.notifications-unsupported[data-v-ae387b36]{display:flex;align-items:flex-start;gap:8px;padding:12px;border:1px solid var(--color-border, #3b4261);border-radius:8px;color:var(--color-text-dark, #787c99);font-size:.875rem}.notifications-unsupported i[data-v-ae387b36]{font-size:16px;flex-shrink:0}.notifications-row[data-v-ae387b36]{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:14px 16px;border:1px solid var(--color-border, #3b4261);border-radius:8px}.notifications-row-title[data-v-ae387b36]{font-size:.9rem;color:var(--color-text, #a9b1d6)}.notifications-row-status[data-v-ae387b36]{font-size:.8rem;color:var(--color-text-dark, #787c99);margin-top:2px}.settings-view[data-v-3b76b25d]{display:flex;flex-direction:column;height:100%;overflow:hidden}.settings-header[data-v-3b76b25d]{display:flex;align-items:center;gap:12px;padding:16px 20px;border-bottom:1px solid var(--color-border, #3b4261);background:var(--surface-panel, #1f2335)}.settings-sidebar-toggle[data-v-3b76b25d]{display:none}@media(max-width:1280px){.settings-sidebar-toggle[data-v-3b76b25d]{display:flex}}.settings-title[data-v-3b76b25d]{font-size:1.25rem;font-weight:600;margin:0;color:var(--color-text, #a9b1d6)}.settings-body[data-v-3b76b25d]{flex:1 1 0;overflow-y:auto;padding:20px}.app-shell[data-v-a29c0392]{display:flex;flex:1 1 0;min-height:0;min-width:0;overflow:hidden}.sidebar-backdrop[data-v-a29c0392]{display:none;position:fixed;top:0;right:0;bottom:0;left:0;background:#0009;z-index:99}@media(max-width:1280px){.sidebar-backdrop[data-v-a29c0392]{display:block}}.artifacts-backdrop[data-v-a29c0392]{display:none;position:fixed;top:0;right:0;bottom:0;left:0;background:#00000073;z-index:119}@media(max-width:980px){.artifacts-backdrop[data-v-a29c0392]{display:block}}.backdrop-fade-enter-active[data-v-a29c0392],.backdrop-fade-leave-active[data-v-a29c0392]{transition:opacity .18s ease}.backdrop-fade-enter-from[data-v-a29c0392],.backdrop-fade-leave-to[data-v-a29c0392]{opacity:0}@font-face{font-family:IBM Plex Mono;src:url(/assets/fonts/IBM_Plex_Mono/IBMPlexMono-Regular.ttf) format("truetype");font-weight:400;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/fonts/IBM_Plex_Mono/IBMPlexMono-Medium.ttf) format("truetype");font-weight:500;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/fonts/IBM_Plex_Mono/IBMPlexMono-SemiBold.ttf) format("truetype");font-weight:600;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/fonts/IBM_Plex_Mono/IBMPlexMono-Bold.ttf) format("truetype");font-weight:700;font-style:normal;font-display:swap}@font-face{font-family:IBM Plex Mono;src:url(/assets/fonts/IBM_Plex_Mono/IBMPlexMono-Italic.ttf) format("truetype");font-weight:400;font-style:italic;font-display:swap}.container{padding:18px}.section{margin-bottom:48px}.section-title,.block{margin-bottom:34px}.block-title{margin-bottom:22px}p,.text{margin-bottom:15px}.hint{margin-top:8px}.list{padding-left:22px;margin-bottom:15px}.list-item{margin-bottom:8px}.list-nested{margin-top:8px}.table{margin-bottom:22px}.table-caption{margin-bottom:8px}.form-group{margin-bottom:15px}.label{margin-bottom:5px;display:block}.input,.textarea,.select{margin-top:5px}.toast{padding:15px}.toast-stack{gap:8px}@keyframes terminal_scan_x{0%{transform:translate(-120%)}to{transform:translate(220%)}}@keyframes terminal_scan_y{0%{transform:translateY(-120%)}to{transform:translateY(220%)}}@keyframes terminal_pulse{0%,to{box-shadow:0 0 #c0caf500}50%{box-shadow:0 0 0 4px #c0caf52e}}@keyframes panel_boot{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}@keyframes overlay_reveal{0%{opacity:0;transform:translateY(-8px)}to{opacity:1;transform:translateY(0)}}@keyframes tooltip_reveal{0%{opacity:0;transform:translate(-50%) translateY(5px)}to{opacity:1;transform:translate(-50%) translateY(0)}}@media(prefers-reduced-motion:reduce){*,*:before,*:after{animation-duration:.01ms!important;animation-iteration-count:1!important;scroll-behavior:auto!important;transition-duration:.01ms!important}}html{font-size:100%}body{font-family:IBM Plex Mono,monospace;font-size:15px;font-weight:400;line-height:1.6;letter-spacing:0;color:#c0caf5}h1,h2,h3,h4,h5,h6{font-family:IBM Plex Mono,monospace;font-weight:600;line-height:1.25;margin:0}h1.contrast,h2.contrast,h3.contrast,h4.contrast,h5.contrast,h6.contrast{background:#c0caf5;color:#16161e;display:inline;padding:0 8px}h1{font-size:34px;letter-spacing:0}h2{font-size:26px}h3{font-size:22px}h4{font-size:20px}h5{font-size:18px}h6{font-size:16px;font-weight:500}.text,p{font-size:15px;line-height:1.6}.text-sm{font-size:13px;line-height:1.4}.text-lg{font-size:16px;line-height:1.6}.text-lead{max-width:760px;color:#c0caf5;font-size:16px;font-weight:500;line-height:1.6}.text-muted{font-size:13px;color:#787c99}.text-strong,strong{font-weight:600}.text-bold{font-weight:700}.text-italic,em{font-style:italic}.text-success{color:#9ece6a}.text-warning{color:#e0af68}.text-danger,.text-error{color:#f7768e}.text-info{color:#bb9af7}.eyebrow{display:inline-flex;width:max-content;max-width:100%;padding:5px 8px;color:#16161e;background:#7aa2f7;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase}.caption{color:#787c99;font-size:12px;line-height:1.4}code,pre,.code{font-family:IBM Plex Mono,monospace;font-size:15px;line-height:1.4;background-color:#1f2335}.text-primary{color:#c0caf5}.text-secondary{color:#a9b1d6}pre{font-size:15px;line-height:1.6;white-space:pre-wrap}pre code,.code{tab-size:2;-moz-tab-size:2}.code{display:inline-flex;padding:0 5px;color:#7aa2f7;border:2px solid rgba(122,162,247,.24)}.kbd{display:inline-flex;align-items:center;min-height:24px;padding:0 8px;border:2px solid rgba(192,202,245,.24);border-bottom-color:#7aa2f7;color:#c0caf5;background:#c0caf50b;font-family:IBM Plex Mono,monospace;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase}.quote{max-width:760px;margin:0;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;color:#a9b1d6;background:#c0caf50b;font-size:15px;line-height:1.6}.quote cite{display:block;margin-top:12px;color:#7aa2f7;font-size:13px;font-style:normal;text-transform:uppercase}a{font-weight:500;text-decoration:none;color:#7aa2f7}@media(hover:hover)and (pointer:fine){a:hover{color:#e0af68}}@media(hover:none)and (pointer:coarse){a:active{color:#e0af68}}.link{font-size:inherit;font-weight:500}.label{font-size:13px;font-weight:500;line-height:1.4}.hint,.meta{font-size:12px;line-height:1.4}.table{font-size:13px;line-height:1.4}.table th{font-weight:600}.table td{font-weight:400}.list{font-size:15px;line-height:1.6}.list-item{font-size:inherit}.modal-title{font-size:20px;font-weight:600}.modal-body{font-size:15px}.toast-title{font-size:14px;font-weight:600}.toast-text{font-size:13px;line-height:1.4}.palette{display:flex;flex-direction:row;flex-wrap:wrap;gap:8px}.palette .color .color-box{width:92px;height:68px}body .bg-primary{background:#c0caf5}body .bg-secondary{background:#7aa2f7}body .bg-success{background:#9ece6a}body .bg-accent{background:#ff9e64}body .bg-info{background:#bb9af7}body .bg-warning{background:#e0af68}body .bg-error{background:#f7768e}body .text-color-primary{color:#c0caf5}body .text-color-secondary{color:#7aa2f7}body .text-color-success{color:#9ece6a}body .text-color-accent{color:#ff9e64}body .text-color-info{color:#bb9af7}body .text-color-warning{color:#e0af68}body .text-color-error{color:#f7768e}.loader{width:32px;aspect-ratio:1;--c:no-repeat linear-gradient(#FF3C00 0 0);background:var(--c) 0 0,var(--c) 0 100%,var(--c) 50% 0,var(--c) 50% 100%,var(--c) 100% 0,var(--c) 100% 100%;animation:l12 1s infinite}@keyframes l12{0%,to{background-size:20% 50%}16.67%{background-size:20% 30%,20% 30%,20% 50%,20% 50%,20% 50%,20% 50%}33.33%{background-size:20% 30%,20% 30%,20% 30%,20% 30%,20% 50%,20% 50%}50%{background-size:20% 30%,20% 30%,20% 30%,20% 30%,20% 30%,20% 30%}66.67%{background-size:20% 50%,20% 50%,20% 30%,20% 30%,20% 30%,20% 30%}83.33%{background-size:20% 50%,20% 50%,20% 50%,20% 50%,20% 30%,20% 30%}}.circle-loader{display:flex;flex-direction:row;align-items:center;gap:8px}.circle-loader .ph,.circle-loader .ph-bold{font-size:26px;transform-origin:50% 50%;animation:icon_spin 1.2s linear infinite}.progress{display:flex;flex-direction:column;gap:8px;width:100%;max-width:640px}.progress .progress-header{display:flex;align-items:center;justify-content:space-between;gap:12px;color:#a9b1d6;font-size:13px;font-weight:600;text-transform:uppercase}.progress .progress-value{color:#c0caf5;font-family:IBM Plex Mono,monospace}.progress .progress-track{position:relative;width:100%;height:18px;overflow:hidden;border:2px solid rgba(192,202,245,.24);background:#c0caf50b}.progress .progress-bar{display:block;position:relative;overflow:hidden;width:var(--progress-value, 0%);height:100%;background:#7aa2f7;transition:width .28s ease}.progress.progress-success .progress-bar{background:#9ece6a}.progress.progress-warning .progress-bar{background:#e0af68}.progress.progress-danger .progress-bar,.progress.progress-error .progress-bar{background:#f7768e}.progress.progress-striped .progress-bar{background-image:repeating-linear-gradient(90deg,transparent 0,transparent 14px,rgba(22,22,30,.2) 14px,rgba(22,22,30,.2) 16px)}.progress.progress-animated .progress-bar:after{content:"";position:absolute;top:0;right:0;bottom:0;left:0;width:48%;background:linear-gradient(90deg,transparent,rgba(192,202,245,.28),transparent);transform:translate(-120%);animation:progress_scan 1.4s ease infinite}.usage-meter{display:grid;gap:12px;width:100%;max-width:420px;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.usage-meter .usage-meter-title{display:flex;align-items:center;justify-content:space-between;gap:12px;margin:0;font-size:16px;font-weight:700;line-height:1;text-transform:uppercase}.usage-meter .usage-meter-value{color:#7aa2f7;font-family:IBM Plex Mono,monospace;font-size:13px}.usage-meter .usage-meter-meta{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.progress-stages{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:8px;width:100%;max-width:720px}.progress-stages .progress-stage{min-height:42px;padding:8px 12px;border:2px solid rgba(192,202,245,.24);color:#787c99;background:#c0caf50b;font-size:13px;font-weight:600;line-height:1.4;text-transform:uppercase}.progress-stages .progress-stage-complete{color:#16161e;background:#9ece6a;border-color:#9ece6a}.progress-stages .progress-stage-current{color:#16161e;background:#e0af68;border-color:#e0af68}@media(max-width:767px){.progress-stages{grid-template-columns:1fr 1fr}}@media(max-width:479px){.progress-stages{grid-template-columns:1fr}}@keyframes progress_scan{0%{transform:translate(-120%)}to{transform:translate(220%)}}@keyframes icon_spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.btn{display:inline-flex;align-items:center;justify-content:center;min-height:46px;font-family:IBM Plex Mono,monospace;font-size:15px;font-weight:600;line-height:1;letter-spacing:.04em;padding:12px 22px;border-radius:0;border-width:2px;border-left-width:6px;border-style:solid;border-color:#c0caf5;text-transform:uppercase;background-color:transparent;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background-color,border-color,color,opacity}.btn:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.btn.with-icon{border-left-width:46px;position:relative}.btn.with-icon .ph,.btn.with-icon .ph-bold{position:absolute;color:#16161e;left:-46px;top:1px;font-size:26px;height:100%;display:inline-flex;align-items:center;width:46px;justify-content:center;transition-duration:.2s;transition-property:color,left}@media(hover:hover)and (pointer:fine){.btn:hover.with-icon:not(.loading-state):not(.btn-small) .ph,.btn:hover.with-icon:not(.loading-state):not(.btn-small) .ph-bold{left:-28px}}@media(hover:none)and (pointer:coarse){.btn:active.with-icon:not(.loading-state):not(.btn-small) .ph,.btn:active.with-icon:not(.loading-state):not(.btn-small) .ph-bold{left:-28px}}.btn.btn-primary{color:#c0caf5;border-color:#c0caf5}@media(hover:hover)and (pointer:fine){.btn.btn-primary:hover{background-color:#c0caf5;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-primary:active{background-color:#c0caf5;color:#16161e}}.btn.btn-secondary{color:#7aa2f7;border-color:#7aa2f7}@media(hover:hover)and (pointer:fine){.btn.btn-secondary:hover{background-color:#7aa2f7;color:#16161e}.btn.btn-secondary:hover.with-icon .ph,.btn.btn-secondary:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-secondary:active{background-color:#7aa2f7;color:#16161e}.btn.btn-secondary:active.with-icon .ph,.btn.btn-secondary:active.with-icon .ph-bold{color:#16161e}}.btn.btn-accent{color:#ff9e64;border-color:#ff9e64}@media(hover:hover)and (pointer:fine){.btn.btn-accent:hover{background-color:#ff9e64;color:#16161e}.btn.btn-accent:hover.with-icon .ph,.btn.btn-accent:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-accent:active{background-color:#ff9e64;color:#16161e}.btn.btn-accent:active.with-icon .ph,.btn.btn-accent:active.with-icon .ph-bold{color:#16161e}}.btn.btn-danger{color:#f7768e;border-color:#f7768e}@media(hover:hover)and (pointer:fine){.btn.btn-danger:hover{background-color:#f7768e;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-danger:active{background-color:#f7768e;color:#16161e}}.btn.btn-warning{color:#e0af68;border-color:#e0af68}@media(hover:hover)and (pointer:fine){.btn.btn-warning:hover{background-color:#e0af68;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-warning:active{background-color:#e0af68;color:#16161e}}.btn.btn-success{color:#9ece6a;border-color:#9ece6a}@media(hover:hover)and (pointer:fine){.btn.btn-success:hover{background-color:#9ece6a;color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-success:active{background-color:#9ece6a;color:#16161e}}.btn.btn-info{color:#bb9af7;border-color:#bb9af7}@media(hover:hover)and (pointer:fine){.btn.btn-info:hover{background-color:#bb9af7;color:#16161e}.btn.btn-info:hover.with-icon .ph,.btn.btn-info:hover.with-icon .ph-bold{color:#16161e}}@media(hover:none)and (pointer:coarse){.btn.btn-info:active{background-color:#bb9af7;color:#16161e}.btn.btn-info:active.with-icon .ph,.btn.btn-info:active.with-icon .ph-bold{color:#16161e}}.btn[disabled]:not(.loading-state){color:#787c99;border-color:#c0caf53d;background-color:#1f2335;cursor:not-allowed;opacity:.72}.btn[disabled]:not(.loading-state).with-icon .ph,.btn[disabled]:not(.loading-state).with-icon .ph-bold{color:#787c99}@media(hover:hover)and (pointer:fine){.btn[disabled]:not(.loading-state):hover{background-color:#1f2335;color:#787c99}.btn[disabled]:not(.loading-state):hover.with-icon .ph,.btn[disabled]:not(.loading-state):hover.with-icon .ph-bold{color:#787c99}}@media(hover:none)and (pointer:coarse){.btn[disabled]:not(.loading-state):active{background-color:#1f2335;color:#787c99}.btn[disabled]:not(.loading-state):active.with-icon .ph,.btn[disabled]:not(.loading-state):active.with-icon .ph-bold{color:#787c99}}.btn[disabled]:not(.loading-state).with-icon:not(.btn-small) .ph,.btn[disabled]:not(.loading-state).with-icon:not(.btn-small) .ph-bold{left:-28px}.btn.btn-small{font-size:13px;font-weight:500;min-height:38px;padding:8px}.btn.btn-small.with-icon{border-left-width:32px}.btn.btn-small.with-icon .ph,.btn.btn-small.with-icon .ph-bold{top:0;left:-40px;font-size:22px}.btn.btn-small.with-icon.loading-state .ph,.btn.btn-small.with-icon.loading-state .ph-bold{font-size:26px}.btn.btn-large{font-size:16px;font-weight:700;min-height:54px;padding:15px 48px}.btn.loading-state{color:#16161e!important;border-color:#c0caf5!important;background-color:#c0caf5!important}.btn.loading-state .ph,.btn.loading-state .ph-bold{font-size:26px;transform-origin:50% 50%;animation:icon_spin 1.2s linear infinite}.btn-icon{display:flex;justify-content:center;align-items:center;width:38px;height:38px;background:transparent;color:#c0caf5;font-size:22px;border:2px solid transparent;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.btn-icon:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.btn-icon .ph{transform:rotate(0);transition-duration:.2s;transition-property:transform}@media(hover:hover)and (pointer:fine){.btn-icon:not(.without-hover):hover{color:#e0af68;border-color:#e0af68}.btn-icon:not(.without-hover):hover .ph{transform:rotate(90deg)}}@media(hover:none)and (pointer:coarse){.btn-icon:not(.without-hover):active{color:#e0af68;border-color:#e0af68}.btn-icon:not(.without-hover):active .ph{transform:rotate(90deg)}}.form-group{width:100%;max-width:600px}.form-group .label{display:flex;flex-direction:column;font-size:15px;width:100%;position:relative}.form-group .label>.ph{position:absolute;color:#c0caf5;left:0;bottom:1px;font-size:26px;height:54px;display:inline-flex;align-items:center;width:46px;justify-content:center;transition-duration:.2s;transition-property:color,left}.form-group .label .input{min-height:54px;font-family:IBM Plex Mono,monospace;font-size:15px;font-weight:500;line-height:1;letter-spacing:.04em;padding:12px 22px;margin-top:8px;border-radius:0;border-width:2px;border-bottom-width:6px;border-style:solid;border-color:#c0caf5;color:#c0caf5;background-color:#c0caf50b;transition-duration:.2s;transition-timing-function:ease;transition-property:background-color,border-color,color}@media(hover:hover)and (pointer:fine){.form-group .label .input:hover{border-bottom-color:#787c99}}@media(hover:none)and (pointer:coarse){.form-group .label .input:active{border-bottom-color:#787c99}}.form-group .label .input:focus{outline:2px solid #E0AF68;outline-offset:3px;border-color:#7aa2f7;background-color:transparent}.form-group .label .input:disabled{color:#787c99;border-color:#c0caf53d;background:#1f2335;cursor:not-allowed;opacity:.72}.form-group .label .input[readonly]{color:#a9b1d6;border-color:#c0caf53d;background:#c0caf508}.form-group .label .input::placeholder{color:#787c99}.form-group .label .input::-webkit-search-cancel-button,.form-group .label .input::-webkit-search-decoration,.form-group .label .input::-webkit-search-results-button,.form-group .label .input::-webkit-search-results-decoration{display:none;-webkit-appearance:none}.form-group .label .input[type=date],.form-group .label .input[type=time],.form-group .label .input[type=datetime-local],.form-group .label .input[type=month]{color-scheme:dark;cursor:pointer;min-width:0;padding-right:46px;text-transform:uppercase}.form-group .label .input[type=date]::-webkit-calendar-picker-indicator,.form-group .label .input[type=time]::-webkit-calendar-picker-indicator,.form-group .label .input[type=datetime-local]::-webkit-calendar-picker-indicator,.form-group .label .input[type=month]::-webkit-calendar-picker-indicator{width:46px;height:100%;margin:0;padding:0;background:transparent;cursor:pointer;opacity:0}.form-group .label .input[type=date]::-webkit-datetime-edit,.form-group .label .input[type=time]::-webkit-datetime-edit,.form-group .label .input[type=datetime-local]::-webkit-datetime-edit,.form-group .label .input[type=month]::-webkit-datetime-edit{padding:0}.form-group .label .input[type=date]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=time]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=datetime-local]::-webkit-datetime-edit-fields-wrapper,.form-group .label .input[type=month]::-webkit-datetime-edit-fields-wrapper{color:#c0caf5}.form-group .label textarea.input{height:108px;line-height:1.25;resize:none}.form-group .label .ph+.input,.form-group .label .ph+.select-wrap .select{padding-left:46px}.form-group .label .select-wrap{margin-top:8px}.form-group .label .select{width:100%;height:54px;margin-top:0;appearance:none;-webkit-appearance:none;-moz-appearance:none}.form-group .label .select:focus{outline:none}.form-group .label .select option{color:#c0caf5;background:#1f2335}.form-group .label .select-wrap:after{content:"";position:absolute;right:22px;bottom:18px;transform:translateY(-50%);width:0;height:0;border-left:8px solid transparent;border-right:8px solid transparent;border-top:10px solid #C0CAF5;pointer-events:none}.form-group .label.error .input:not(:focus){border-color:#f7768e}.form-group .label.error+.input-info{color:#e0af68}.form-group .label.success .input:not(:focus){border-color:#9ece6a}.form-group .label.success+.input-info{color:#9ece6a}.form-group .label.warning .input:not(:focus){border-color:#e0af68}.form-group .label.warning+.input-info{color:#e0af68}.form-group .input-info{font-size:14px;margin-top:8px}.form-group .input-info .ph{position:relative;top:1px}.form-group .input-info.error{color:#e0af68}.form-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:15px;width:100%;max-width:760px}.fieldset{width:100%;max-width:760px;margin:0;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.legend{padding:5px 8px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}.file-upload{display:inline-flex;align-items:center;gap:8px;min-height:46px;padding:8px 12px;border:2px solid #7AA2F7;border-left-width:6px;color:#7aa2f7;background:#c0caf50b;font-size:13px;font-weight:700;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.file-upload input[type=file]{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}@media(hover:hover)and (pointer:fine){.file-upload:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.file-upload:active{color:#16161e;background:#7aa2f7}}.file-upload:focus-within{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-panel{width:100%;max-width:760px;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);border-left-width:6px}.file-upload-form{display:flex;flex-direction:column;gap:15px;margin:0}.file-upload-header{display:flex;align-items:flex-start;justify-content:space-between;gap:15px;padding:15px 15px 0}.file-upload-heading{display:flex;flex-direction:column;gap:5px;min-width:0}.file-upload-title{margin:0;color:#c0caf5;font-size:16px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-description{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.file-upload-dropzone{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:center;gap:15px;margin:0 15px;padding:18px;border:2px dashed #7AA2F7;background:#7aa2f714;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color}.file-upload-dropzone input[type=file]{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap}@media(hover:hover)and (pointer:fine){.file-upload-dropzone:hover{border-color:#c0caf5;background:#c0caf51a}}@media(hover:none)and (pointer:coarse){.file-upload-dropzone:active{border-color:#c0caf5;background:#c0caf51a}}.file-upload-dropzone:focus-within{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-icon{display:inline-flex;align-items:center;justify-content:center;width:54px;height:54px;color:#16161e;background:#7aa2f7;font-size:26px}.file-upload-body{display:flex;flex-direction:column;gap:5px;min-width:0}.file-upload-primary{color:#c0caf5;font-size:15px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-secondary{color:#a9b1d6;font-size:13px;line-height:1.4}.file-upload-preview{display:grid;grid-template-columns:repeat(auto-fill,minmax(148px,1fr));gap:12px;margin:0 15px}.file-upload-preview[hidden]{display:none}.file-upload-preview-item{position:relative;min-width:0;margin:0;border:2px solid rgba(192,202,245,.24);background:#c0caf50b}.file-upload-preview-remove{position:absolute;top:8px;right:8px;z-index:1;display:inline-flex;align-items:center;justify-content:center;width:32px;height:32px;padding:0;border:2px solid #F7768E;color:#f7768e;background:#1f2335;font-size:18px;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}@media(hover:hover)and (pointer:fine){.file-upload-preview-remove:hover{color:#16161e;background:#f7768e}}@media(hover:none)and (pointer:coarse){.file-upload-preview-remove:active{color:#16161e;background:#f7768e}}.file-upload-preview-remove:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.file-upload-preview-visual{display:flex;align-items:center;justify-content:center;aspect-ratio:1;background:#1f2335}.file-upload-preview-visual img{display:block;width:100%;height:100%;object-fit:cover}.file-upload-preview-type{display:inline-flex;align-items:center;justify-content:center;min-width:54px;min-height:54px;padding:8px;color:#16161e;background:#7aa2f7;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}.file-upload-preview-item figcaption{display:flex;flex-direction:column;gap:5px;overflow:hidden;padding:8px}.file-upload-preview-name{overflow:hidden;color:#c0caf5;font-size:12px;font-weight:700;line-height:1.25;text-overflow:ellipsis;white-space:nowrap}.file-upload-preview-meta{color:#a9b1d6;font-size:12px;font-weight:700;line-height:1.25;text-transform:uppercase}.file-upload-actions{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px;padding:0 15px 15px}.range{width:100%;max-width:600px;accent-color:#7AA2F7}.range input[type=range]{-webkit-appearance:none;-moz-appearance:none;appearance:none;width:100%;height:46px;margin:0;background:transparent;cursor:pointer}.range input[type=range]::-webkit-slider-runnable-track{height:6px;background:#c0caf516;border:2px solid rgba(192,202,245,.24)}.range input[type=range]::-webkit-slider-thumb{width:18px;height:38px;margin-top:-19px;border:2px solid #7AA2F7;background:#7aa2f7;-webkit-appearance:none}.range input[type=range]::-moz-range-track{height:6px;background:#c0caf516;border:2px solid rgba(192,202,245,.24)}.range input[type=range]::-moz-range-thumb{width:18px;height:38px;border:2px solid #7AA2F7;border-radius:0;background:#7aa2f7}@media(max-width:767px){.form-grid{grid-template-columns:1fr}.file-upload-header{flex-direction:column;align-items:stretch}.file-upload-dropzone{grid-template-columns:1fr}.file-upload-actions{justify-content:stretch}.file-upload-actions .btn{width:100%}}.radio{display:inline-flex;flex-direction:row;gap:8px;align-items:center}.radio input[type=radio]{display:none}.radio .radio-control{display:inline-block;border-radius:100%;border:2px solid #C0CAF5;width:18px;height:18px;background:transparent;transition-duration:.2s;transition-property:background,border-color}@media(hover:hover)and (pointer:fine){.radio:hover .radio-control{background:#414868}}@media(hover:none)and (pointer:coarse){.radio:active .radio-control{background:#414868}}.radio input[type=radio]:checked+.radio-control{background:#c0caf5}.radio input[type=radio]:disabled+.radio-control{background:#414868;border-color:#414868}.radio input[type=radio]:focus-visible+.radio-control{outline:2px solid #E0AF68;outline-offset:3px}.radio .radio-label{font-size:15px}.checkbox{display:inline-flex;flex-direction:row;gap:8px;align-items:center}.checkbox input[type=checkbox]{display:none}.checkbox .checkbox-control{height:16px;width:32px;border:2px solid #C0CAF5;position:relative;background:transparent;transition-duration:.2s;transition-property:border-color,background;display:block}.checkbox .checkbox-control:before{content:"";display:block;height:20px;width:20px;background:#c0caf5;position:absolute;left:-5px;top:-5px;transition-duration:.2s;transition-property:left,background}@media(hover:hover)and (pointer:fine){.checkbox:hover .checkbox-control{background:#414868}}@media(hover:none)and (pointer:coarse){.checkbox:active .checkbox-control{background:#414868}}.checkbox input[type=checkbox]:checked:not(:disabled)+.checkbox-control{background:#7aa2f7;border-color:#7aa2f7}.checkbox input[type=checkbox]:checked+.checkbox-control:before{left:17px}.checkbox input[type=checkbox]:disabled+.checkbox-control{border-color:#414868}.checkbox input[type=checkbox]:focus-visible+.checkbox-control{outline:2px solid #E0AF68;outline-offset:3px}.checkbox input[type=checkbox]:disabled+.checkbox-control:before{background:#414868}.input-group{display:flex;align-items:stretch;width:100%;max-width:600px;min-height:54px;border:2px solid #C0CAF5;border-bottom-width:6px;background:#c0caf50b;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background}.input-group:focus-within{outline:2px solid #E0AF68;outline-offset:3px;border-color:#7aa2f7;background:transparent}.input-group .input-group-addon,.input-group .input-group-action{display:inline-flex;align-items:center;justify-content:center;min-width:54px;padding:0 12px;color:#a9b1d6;background:#c0caf50b;border:0;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;text-transform:uppercase}.input-group .input-group-action{color:#c0caf5;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}@media(hover:hover)and (pointer:fine){.input-group .input-group-action:hover{color:#16161e;background:#e0af68}}@media(hover:none)and (pointer:coarse){.input-group .input-group-action:active{color:#16161e;background:#e0af68}}.input-group .input-group-input{flex:1 1 auto;min-width:0;border:0;padding:12px 15px;color:#c0caf5;background:transparent;font-family:IBM Plex Mono,monospace;font-size:15px;font-weight:500;letter-spacing:.04em}.input-group .input-group-input:focus{outline:none}.input-group .input-group-input::placeholder{color:#787c99}.input-group .input-group-input::-webkit-search-cancel-button,.input-group .input-group-input::-webkit-search-decoration,.input-group .input-group-input::-webkit-search-results-button,.input-group .input-group-input::-webkit-search-results-decoration{display:none;-webkit-appearance:none}.input-group .ph,.input-group .ph-bold{font-size:22px}.input-group.input-group-compact{min-height:46px}.input-group.input-group-compact .input-group-addon,.input-group.input-group-compact .input-group-action{min-width:46px}.input-group.input-group-compact .input-group-input{padding:8px 12px;font-size:13px}.search-field{max-width:420px}.list{display:flex;flex-direction:column;gap:5px;list-style-type:none;padding-left:0}.list .list-item{display:flex;flex-direction:row;align-items:center;gap:8px;margin-left:0}.list.list-ordered{list-style-type:decimal;display:list-item;margin-left:30px}.list.list-ordered .list-item{display:list-item}.list.list-definition{width:100%;max-width:620px;gap:0;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.list.list-definition .list-row{display:grid;grid-template-columns:minmax(120px,.32fr) minmax(0,1fr);gap:15px;align-items:start;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color}.list.list-definition .list-row .list-term{display:inline-flex;width:max-content;max-width:100%;margin:0;padding:5px 8px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:background,transform}.list.list-definition .list-row .list-desc{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6;transition-duration:.2s;transition-timing-function:ease;transition-property:color,transform}.list.list-definition .list-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.list.list-definition .list-row:hover{background:#c0caf516}.list.list-definition .list-row:hover .list-term{background:#7aa2f7;transform:translate(5px)}.list.list-definition .list-row:hover .list-desc{color:#c0caf5;transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.list.list-definition .list-row:active{background:#c0caf516}.list.list-definition .list-row:active .list-term{background:#7aa2f7;transform:translate(5px)}.list.list-definition .list-row:active .list-desc{color:#c0caf5;transform:translate(5px)}}.list.list-nav{max-width:420px;width:100%;gap:0}.list.list-nav .list-item{display:flex;flex-direction:column;align-items:flex-start;height:50px;margin:0}.list.list-nav .list-item .list-action{display:flex;justify-content:space-between;align-items:center;width:100%;height:100%;padding:8px 12px;border:2px solid transparent;font-size:15px;background:#1f2335;color:inherit;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:background,border-color,color}.list.list-nav .list-item .list-action:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.list.list-nav .list-item .list-action:hover{background:#7aa2f7;color:#16161e}}@media(hover:none)and (pointer:coarse){.list.list-nav .list-item .list-action:active{background:#7aa2f7;color:#16161e}}.list.list-nav .list-item .list-action .list-label{display:flex;flex-direction:row;gap:8px;align-items:center;letter-spacing:0;font-weight:400}.list.list-nav .list-item .list-action .list-meta{padding:8px;background:#9ece6a;color:#16161e;display:flex}.list.list-nav .list-item.list-item-active .list-action{background:#7aa2f7;color:#16161e;border-color:#7aa2f7}.list.list-actions{width:100%;max-width:420px;gap:22px}.list.list-actions .list-item{justify-content:space-between;align-items:flex-start;padding:12px 0;border-bottom:2px solid rgba(192,202,245,.08)}.list.list-actions .list-item .list-content{display:flex;flex-direction:column;gap:8px}.list.list-actions .list-item .list-content .list-title{font-size:16px;line-height:1}.list.list-actions .list-item .list-content .list-subtitle{color:#787c99}@media(hover:hover)and (pointer:fine){.list.list-actions .list-item:hover .list-title{color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.list.list-actions .list-item:active .list-title{color:#7aa2f7}}@media(max-width:479px){.list.list-definition .list-row{grid-template-columns:1fr;gap:8px}}.badge{position:relative;overflow:hidden;background:#c0caf5;color:#16161e;padding:5px 8px;font-size:13px;font-weight:600;line-height:1;letter-spacing:.04em;text-transform:uppercase;display:inline-flex;align-items:center;min-height:24px;transition-duration:.2s;transition-timing-function:ease;transition-property:filter,transform,border-color,color,background}.badge:after{content:"";position:absolute;inset:0 auto 0 0;width:40%;background:linear-gradient(90deg,transparent,rgba(22,22,30,.16),transparent);opacity:0;pointer-events:none;transform:translate(-120%)}@media(hover:hover)and (pointer:fine){.badge:hover{filter:saturate(1.12);transform:translateY(-1px)}.badge:hover:after{opacity:1;animation:terminal_scan_x .7s ease}}@media(hover:none)and (pointer:coarse){.badge:active{filter:saturate(1.12);transform:translateY(-1px)}.badge:active:after{opacity:1;animation:terminal_scan_x .7s ease}}.badge.badge-success{background:#9ece6a}.badge.badge-warning{background:#e0af68}.badge.badge-error,.badge.badge-danger{background:#f7768e}.badge.badge-info{background:#bb9af7;color:#16161e}.badge.badge-secondary{background:#7aa2f7;color:#16161e}.badge.badge-primary-outline{color:#c0caf5;border:2px solid #C0CAF5;background:transparent;padding:3px 8px}.chip-group{display:flex;flex-wrap:wrap;gap:8px;align-items:center}.chip{display:inline-flex;align-items:center;gap:8px;min-height:30px;padding:5px 12px;border:2px solid rgba(192,202,245,.24);color:#a9b1d6;background:#c0caf50b;font-family:IBM Plex Mono,monospace;font-size:12px;font-weight:600;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color,opacity}.chip .ph,.chip .ph-bold{font-size:18px}.chip:before{content:"";display:inline-block;width:7px;height:7px;flex:0 0 auto;background:#787c99;transition-duration:.2s;transition-timing-function:ease;transition-property:background,box-shadow,transform}.chip:has(.ph):before,.chip:has(.ph-bold):before{display:none}.chip .chip-remove{display:inline-flex;align-items:center;justify-content:center;width:18px;height:18px;margin-right:-5px;border:0;color:inherit;background:transparent;font:inherit;cursor:pointer}.chip .chip-remove:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}.chip.chip-primary{color:#c0caf5;background:#c0caf514;border-color:#c0caf5}.chip.chip-primary:before{background:#c0caf5}.chip.chip-secondary{color:#7aa2f7;background:#7aa2f714;border-color:#7aa2f7}.chip.chip-secondary:before{background:#7aa2f7}.chip.chip-success{color:#9ece6a;background:#9ece6a14;border-color:#9ece6a}.chip.chip-success:before{background:#9ece6a}.chip.chip-warning{color:#e0af68;background:#e0af6814;border-color:#e0af68}.chip.chip-warning:before{background:#e0af68}.chip.chip-danger,.chip.chip-error{color:#f7768e;background:#f7768e14;border-color:#f7768e}.chip.chip-danger:before,.chip.chip-error:before{background:#f7768e}.chip.chip-selected,.chip[aria-pressed=true],.chip[aria-selected=true]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.chip.chip-selected:before,.chip[aria-pressed=true]:before,.chip[aria-selected=true]:before{background:#16161e}.chip.chip-selected.chip-secondary,.chip.chip-secondary[aria-pressed=true],.chip.chip-secondary[aria-selected=true]{background:#7aa2f7;border-color:#7aa2f7}.chip.chip-disabled,.chip:disabled{color:#787c99;background:#1f2335;border-color:#c0caf53d;cursor:not-allowed;opacity:.7}.chip.chip-disabled:before,.chip:disabled:before{background:#414868}button.chip,a.chip{cursor:pointer}button.chip:focus-visible,a.chip:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){button.chip:hover,a.chip:hover{color:#c0caf5;background:#c0caf516;border-color:#7aa2f7}button.chip:hover:before,a.chip:hover:before{background:#7aa2f7;animation:terminal_pulse .7s ease;transform:scale(1.12)}}@media(hover:none)and (pointer:coarse){button.chip:active,a.chip:active{color:#c0caf5;background:#c0caf516;border-color:#7aa2f7}button.chip:active:before,a.chip:active:before{background:#7aa2f7;animation:terminal_pulse .7s ease;transform:scale(1.12)}}.avatar{position:relative;display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;flex:0 0 auto;overflow:hidden;border:2px solid rgba(192,202,245,.24);color:#16161e;background:#c0caf5;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase}.avatar img{width:100%;height:100%;object-fit:cover}.avatar .ph,.avatar .ph-bold{font-size:22px}.avatar .avatar-status{position:absolute;right:-2px;bottom:-2px;width:13px;height:13px;border:2px solid #16161E;background:#787c99;transition-duration:.2s;transition-timing-function:ease;transition-property:background,box-shadow}.avatar.avatar-sm{width:38px;height:38px;font-size:12px}.avatar.avatar-sm .ph,.avatar.avatar-sm .ph-bold{font-size:18px}.avatar.avatar-lg{width:54px;height:54px;font-size:14px}.avatar.avatar-lg .ph,.avatar.avatar-lg .ph-bold{font-size:26px}.avatar.avatar-secondary{background:#7aa2f7}.avatar.avatar-success{background:#9ece6a}.avatar.avatar-warning{background:#e0af68}.avatar.avatar-danger,.avatar.avatar-error{background:#f7768e}.avatar.avatar-outline{color:#c0caf5;background:#c0caf50b;border-color:#c0caf5}.avatar.is-online .avatar-status{background:#9ece6a;animation:terminal_pulse 1.8s ease infinite}.avatar.is-busy .avatar-status{background:#e0af68}.avatar.is-offline .avatar-status{background:#787c99}.identity{display:inline-flex;align-items:center;gap:12px;min-width:0}.identity-content{display:flex;flex-direction:column;gap:5px;min-width:0}.identity-title{color:#c0caf5;font-size:15px;font-weight:600;line-height:1}.identity-meta{color:#787c99;font-size:13px;line-height:1.4}.avatar-stack{display:inline-flex;align-items:center}.avatar-stack .avatar{margin-right:-8px;border-color:#16161e}.avatar-stack .avatar-stack-count{display:inline-flex;align-items:center;justify-content:center;min-width:46px;height:46px;padding:0 8px;border:2px solid #16161E;color:#16161e;background:#e0af68;font-size:13px;font-weight:700}.table{width:100%;text-align:left;border:2px solid rgba(192,202,245,.24);border-collapse:collapse;background:#c0caf50b}.table .table-caption{text-align:left;font-size:16px;background:#c0caf5;width:max-content;color:#16161e;padding:5px 12px;margin-bottom:0;font-weight:700;text-transform:uppercase}.table.table-empty{width:100%}.table.table-empty .is-empty{width:100%;padding:15px;font-size:13px;color:#787c99;text-align:left}.table .table-row th,.table .table-row td{padding:12px 18px;font-size:13px;vertical-align:middle;border-bottom:2px solid rgba(192,202,245,.08)}.table .table-row th{color:#c0caf5;background:#c0caf50a;text-transform:uppercase;letter-spacing:.04em}.table .table-head{border-bottom:2px solid #C0CAF5}.table .table-body .table-row{transition-duration:.2s;transition-timing-function:ease;transition-property:background,color}.table .table-body .table-row td{transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}@media(hover:hover)and (pointer:fine){.table .table-body .table-row:hover{background:#7aa2f714}.table .table-body .table-row:hover td:first-child{color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.table .table-body .table-row:active{background:#7aa2f714}.table .table-body .table-row:active td:first-child{color:#7aa2f7}}.table .table-foot th,.table .table-foot td{padding-top:15px}.table.table-compact .table-caption{font-size:14px}.table.table-compact .table-row th,.table.table-compact .table-row td{padding:8px 12px;font-size:12px}.table.table-compact .table-cell-mono{color:#a9b1d6;font-family:IBM Plex Mono,monospace;letter-spacing:0}.table.table-compact .table-cell-actions{width:1%;white-space:nowrap}.table-wrapper{width:100%;overflow-x:auto}.toolbar{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:12px;width:100%;padding:12px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.toolbar .toolbar-group{display:flex;flex-wrap:wrap;align-items:center;gap:8px;min-width:0}.toolbar .toolbar-title{margin:0;font-size:16px;font-weight:700;line-height:1;text-transform:uppercase}.toolbar .toolbar-meta{color:#787c99;font-size:13px}.pagination{display:flex;flex-wrap:wrap;align-items:center;gap:8px}.pagination .pagination-item{display:inline-flex;align-items:center;justify-content:center;min-width:38px;height:38px;padding:0 12px;border:2px solid rgba(192,202,245,.24);color:#a9b1d6;background:#c0caf50b;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;line-height:1;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color,opacity}.pagination .pagination-item:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.pagination .pagination-item:hover{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.pagination .pagination-item:active{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}.pagination .pagination-item.pagination-item-active,.pagination .pagination-item[aria-current=page]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.pagination .pagination-item:disabled,.pagination .pagination-item.pagination-item-disabled{color:#787c99;background:#1f2335;border-color:#c0caf53d;cursor:not-allowed;opacity:.72}.pagination .pagination-ellipsis{color:#787c99;padding:0 5px}.empty-state{max-width:560px;padding:22px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.empty-state .empty-state-icon{display:inline-flex;align-items:center;justify-content:center;width:54px;height:54px;margin-bottom:15px;color:#16161e;background:#c0caf5;font-size:26px}.empty-state .empty-state-title{margin:0 0 8px;font-size:20px;font-weight:700;text-transform:uppercase}.empty-state .empty-state-text{max-width:440px;margin:0 0 18px;color:#a9b1d6;line-height:1.6}.empty-state .empty-state-actions{display:flex;flex-wrap:wrap;gap:8px}.empty-state.empty-state-error{border-color:#f7768e}.empty-state.empty-state-error .empty-state-icon{background:#f7768e}.skeleton{display:block;position:relative;overflow:hidden;background:#c0caf516}.skeleton:after{content:"";position:absolute;top:0;right:0;bottom:0;left:0;transform:translate(-100%);background:linear-gradient(90deg,transparent,rgba(192,202,245,.12),transparent);animation:skeleton_shimmer 1.6s infinite}.skeleton.skeleton-line{width:100%;height:14px}.skeleton.skeleton-title{width:60%;height:22px}.skeleton.skeleton-block{width:100%;height:120px}.skeleton.skeleton-square{width:54px;height:54px}.skeleton-stack{display:flex;flex-direction:column;gap:12px;max-width:520px;padding:15px;border:2px solid rgba(192,202,245,.24);background:#c0caf50b}@keyframes skeleton_shimmer{to{transform:translate(100%)}}.page-header{position:relative;display:flex;flex-wrap:wrap;align-items:flex-end;justify-content:space-between;gap:18px;width:100%;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b;overflow:hidden;animation:panel_boot .28s ease both}.page-header:after{content:"";position:absolute;top:0;left:0;width:34%;height:2px;background:linear-gradient(90deg,transparent,#7AA2F7,transparent);opacity:.72;pointer-events:none;transform:translate(-120%)}@media(hover:hover)and (pointer:fine){.page-header:hover:after{animation:terminal_scan_x .9s ease}}@media(hover:none)and (pointer:coarse){.page-header:active:after{animation:terminal_scan_x .9s ease}}.page-header .page-header-content{display:flex;flex-direction:column;gap:8px;min-width:min(100%,320px)}.page-header .page-header-kicker{color:#7aa2f7;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color}.page-header .page-header-title{margin:0;color:#c0caf5;font-size:26px;font-weight:700;line-height:1.15}.page-header .page-header-subtitle{max-width:720px;margin:0;color:#a9b1d6;font-size:15px;line-height:1.6}.page-header .page-header-meta{display:flex;flex-wrap:wrap;align-items:center;gap:8px;color:#787c99;font-size:13px}.page-header .page-header-actions{display:flex;flex-wrap:wrap;align-items:center;justify-content:flex-end;gap:8px}.page-header.page-header-compact{align-items:center;padding:15px}.page-header.page-header-compact .page-header-title{font-size:20px}.page-header.page-header-accent{border-color:#7aa2f7;background:#7aa2f70e}.description-list{display:grid;width:100%;max-width:760px;margin:0;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.description-list .description-list-row{display:grid;grid-template-columns:minmax(140px,.36fr) minmax(0,1fr);gap:15px;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background}.description-list .description-list-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.description-list .description-list-row:hover{background:#c0caf516}.description-list .description-list-row:hover .description-list-term{color:#7aa2f7}.description-list .description-list-row:hover .description-list-value{transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.description-list .description-list-row:active{background:#c0caf516}.description-list .description-list-row:active .description-list-term{color:#7aa2f7}.description-list .description-list-row:active .description-list-value{transform:translate(5px)}}.description-list .description-list-term{margin:0;color:#787c99;font-size:13px;font-weight:600;line-height:1.4;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color}.description-list .description-list-value{display:flex;flex-wrap:wrap;align-items:center;gap:8px;min-width:0;margin:0;color:#c0caf5;font-size:15px;line-height:1.4;transition-duration:.2s;transition-timing-function:ease;transition-property:transform}.description-list .description-list-value-muted{color:#a9b1d6}.description-list.description-list-compact{max-width:520px}.description-list.description-list-compact .description-list-row{grid-template-columns:minmax(112px,.42fr) minmax(0,1fr);gap:12px;padding:8px 12px}.description-list.description-list-compact .description-list-term,.description-list.description-list-compact .description-list-value{font-size:13px}@media(max-width:479px){.description-list .description-list-row{grid-template-columns:1fr;gap:5px}}.steps{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;width:100%;max-width:900px;margin:0;padding:0;list-style:none}.steps .step{position:relative;display:flex;flex-direction:column;gap:8px;min-height:120px;padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.steps .step-marker{display:inline-flex;align-items:center;justify-content:center;width:38px;height:38px;color:#c0caf5;border:2px solid rgba(192,202,245,.24);font-size:13px;font-weight:700;line-height:1}.steps .step-title{margin:0;font-size:14px;font-weight:700;line-height:1.25;text-transform:uppercase}.steps .step-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.steps .step-complete{border-color:#9ece6a}.steps .step-complete .step-marker{color:#16161e;background:#9ece6a;border-color:#9ece6a}.steps .step-current{border-color:#7aa2f7}.steps .step-current .step-marker{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}.steps .step-disabled{opacity:.62}.steps.steps-vertical{grid-template-columns:1fr;max-width:520px;gap:0}.steps.steps-vertical .step{min-height:auto;border-bottom-width:0}.steps.steps-vertical .step:last-child{border-bottom-width:2px}@media(max-width:1023px){.steps{grid-template-columns:repeat(2,minmax(0,1fr))}}@media(max-width:479px){.steps{grid-template-columns:1fr}}.timeline{display:grid;gap:0;width:100%;max-width:760px;margin:0;padding:0;list-style:none}.timeline .timeline-item{position:relative;display:grid;grid-template-columns:46px minmax(0,1fr);gap:12px;min-height:88px}.timeline .timeline-item:before{content:"";position:absolute;top:46px;bottom:0;left:22px;width:2px;background:#c0caf53d}.timeline .timeline-item:last-child:before{display:none}.timeline .timeline-marker{position:relative;z-index:1;display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;border:2px solid rgba(192,202,245,.24);color:#a9b1d6;background:#16161e;font-size:18px;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background,color,box-shadow,transform}.timeline .timeline-content{min-width:0;padding:0 0 18px}.timeline .timeline-card{padding:15px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background,transform}.timeline .timeline-header{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px;margin-bottom:8px}.timeline .timeline-title{margin:0;font-size:14px;font-weight:700;line-height:1.25;text-transform:uppercase}.timeline .timeline-time{color:#787c99;font-size:12px;font-family:IBM Plex Mono,monospace;line-height:1.4}.timeline .timeline-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.4}.timeline .timeline-meta{display:flex;flex-wrap:wrap;gap:8px;margin-top:12px}.timeline .timeline-item-success .timeline-marker,.timeline .timeline-item-success .timeline-card{border-color:#9ece6a}.timeline .timeline-item-success .timeline-marker{color:#16161e;background:#9ece6a}.timeline .timeline-item-warning .timeline-marker,.timeline .timeline-item-warning .timeline-card{border-color:#e0af68}.timeline .timeline-item-warning .timeline-marker{color:#16161e;background:#e0af68}.timeline .timeline-item-danger .timeline-marker,.timeline .timeline-item-danger .timeline-card,.timeline .timeline-item-error .timeline-marker,.timeline .timeline-item-error .timeline-card{border-color:#f7768e}.timeline .timeline-item-danger .timeline-marker,.timeline .timeline-item-error .timeline-marker{color:#16161e;background:#f7768e}@media(hover:hover)and (pointer:fine){.timeline .timeline-item:hover .timeline-marker{box-shadow:0 0 0 4px #7aa2f724;transform:scale(1.04)}.timeline .timeline-item:hover .timeline-card{background:#c0caf516;transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.timeline .timeline-item:active .timeline-marker{box-shadow:0 0 0 4px #7aa2f724;transform:scale(1.04)}.timeline .timeline-item:active .timeline-card{background:#c0caf516;transform:translate(5px)}}.activity-log{display:grid;width:100%;max-width:720px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.activity-log .activity-log-row{display:grid;grid-template-columns:minmax(120px,.24fr) minmax(0,1fr) auto;gap:12px;align-items:center;padding:12px 15px;border-bottom:2px solid rgba(192,202,245,.08);transition-duration:.2s;transition-timing-function:ease;transition-property:background}.activity-log .activity-log-row:last-child{border-bottom:0}@media(hover:hover)and (pointer:fine){.activity-log .activity-log-row:hover{background:#c0caf516}}@media(hover:none)and (pointer:coarse){.activity-log .activity-log-row:active{background:#c0caf516}}.activity-log .activity-log-time{color:#787c99;font-family:IBM Plex Mono,monospace;font-size:12px}.activity-log .activity-log-title{color:#c0caf5;font-size:13px;font-weight:600;line-height:1.4}@media(max-width:479px){.activity-log .activity-log-row{grid-template-columns:1fr;gap:8px}}.accordion{display:grid;width:100%;max-width:760px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.accordion-item{border-bottom:2px solid rgba(192,202,245,.08);overflow:hidden}.accordion-item:last-child{border-bottom:0}.accordion-item[open] .accordion-summary{color:#16161e;background:#c0caf5}.accordion-item[open] .accordion-icon{transform:rotate(180deg)}.accordion-summary{display:flex;align-items:center;justify-content:space-between;gap:12px;min-height:46px;padding:12px 15px;color:#c0caf5;cursor:pointer;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.accordion-summary::-webkit-details-marker{display:none}.accordion-summary::marker{content:""}.accordion-summary:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.accordion-summary:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.accordion-summary:active{color:#16161e;background:#7aa2f7}}.accordion-summary-content{display:flex;align-items:center;gap:8px;min-width:0}.accordion-icon{flex:0 0 auto;font-size:18px;transition-duration:.2s;transition-property:transform}.accordion-panel{overflow:hidden;padding:15px;color:#a9b1d6;font-size:13px;line-height:1.6;transition-duration:.28s;transition-timing-function:ease;transition-property:height,opacity,transform}.accordion-panel p{margin-top:0}.accordion-panel p:last-child{margin-bottom:0}.disclosure{max-width:520px;border:2px solid rgba(192,202,245,.24);background:#c0caf50b}.disclosure .accordion-summary{min-height:38px;padding:8px 12px}.disclosure .accordion-panel{padding:12px}.tabs{display:grid;gap:15px;width:100%;max-width:900px}.tabs-list{display:flex;align-items:stretch;gap:0;max-width:100%;overflow-x:auto;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b;scrollbar-width:thin}.tab{position:relative;display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:46px;padding:12px 15px;border:0;border-right:2px solid rgba(192,202,245,.08);border-radius:0;color:#a9b1d6;background:transparent;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;line-height:1;text-transform:uppercase;white-space:nowrap;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,opacity}.tab .ph,.tab .ph-bold{font-size:18px}.tab:focus-visible{outline:2px solid #E0AF68;outline-offset:3px;z-index:1}@media(hover:hover)and (pointer:fine){.tab:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.tab:active{color:#16161e;background:#7aa2f7}}.tab:disabled,.tab[aria-disabled=true]{color:#787c99;cursor:not-allowed;opacity:.62}@media(hover:hover)and (pointer:fine){.tab:disabled:hover,.tab[aria-disabled=true]:hover{color:#787c99;background:transparent}}@media(hover:none)and (pointer:coarse){.tab:disabled:active,.tab[aria-disabled=true]:active{color:#787c99;background:transparent}}.tab-active,.tab[aria-selected=true]{color:#16161e;background:#c0caf5}.tabs-panels{border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.tab-panel{display:none;padding:15px;color:#a9b1d6;font-size:13px;line-height:1.6}.tab-panel p{margin-top:0}.tab-panel p:last-child{margin-bottom:0}.tab-panel-active{display:block}.tabs-compact{max-width:620px}.tabs-compact .tabs-list{border-left-width:2px}.tabs-compact .tab{min-height:38px;padding:8px 12px}.tabs-compact .tabs-panels{border-left-width:2px}.tabs-compact .tab-panel{padding:12px}.tabs-vertical{grid-template-columns:minmax(180px,240px) minmax(0,1fr);align-items:start}.tabs-vertical .tabs-list{flex-direction:column;overflow-x:visible}.tabs-vertical .tab{justify-content:flex-start;border-right:0;border-bottom:2px solid rgba(192,202,245,.08);text-align:left}@media(max-width:767px){.tabs-vertical{grid-template-columns:1fr}.tabs-vertical .tabs-list{flex-direction:row;overflow-x:auto}.tabs-vertical .tab{justify-content:center;border-right:2px solid rgba(192,202,245,.08);border-bottom:0;text-align:center}}.drawer{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1000;display:flex;justify-content:flex-end;pointer-events:none}.drawer .drawer-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1010;background:#16161e;opacity:0;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity;pointer-events:auto}.drawer .drawer-panel{position:relative;z-index:1020;width:min(460px,100vw - 18px);min-height:100vh;display:flex;flex-direction:column;gap:15px;background:#16161e;border-left:2px solid #C0CAF5;box-shadow:-18px 0 42px #16161e61;opacity:0;transform:translate(100%);transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,transform;pointer-events:auto}.drawer .drawer-header{display:flex;align-items:center;justify-content:space-between;padding-right:15px;border-bottom:2px solid rgba(192,202,245,.24)}.drawer .drawer-title{margin:0;padding:12px 15px;background:#c0caf5;color:#16161e;text-transform:uppercase;letter-spacing:.04em}.drawer .drawer-body{flex:1;overflow-y:auto;padding:18px}.drawer .drawer-footer{padding:18px;border-top:2px solid rgba(192,202,245,.24)}.drawer .drawer-footer .actions{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:12px;width:100%}.drawer.drawer-left{justify-content:flex-start}.drawer.drawer-left .drawer-panel{border-left:0;border-right:2px solid #C0CAF5;box-shadow:18px 0 42px #16161e61;transform:translate(-100%)}.drawer.a-show .drawer-backdrop{opacity:.82}.drawer.a-show .drawer-panel{opacity:1;transform:translate(0)}.drawer.a-hide .drawer-backdrop{opacity:0}.drawer.a-hide .drawer-panel{opacity:0;transform:translate(100%)}.drawer.a-hide.drawer-left .drawer-panel{transform:translate(-100%)}.drawer-preview{display:grid;grid-template-columns:minmax(0,1fr) minmax(180px,280px);gap:18px;align-items:stretch;padding:18px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#c0caf50b}.drawer-preview .drawer-preview-content{display:flex;flex-direction:column;gap:12px}.drawer-preview .drawer-preview-panel{display:flex;flex-direction:column;gap:12px;padding:15px;border:2px solid #7AA2F7;background:#1f2335}.drawer-preview .drawer-preview-title{margin:0;color:#7aa2f7;font-size:14px;text-transform:uppercase}.drawer-preview .drawer-preview-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}@media(max-width:720px){.drawer-preview{grid-template-columns:1fr}}.nav-topbar{position:sticky;top:0;z-index:900;display:grid;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;min-height:58px;border-bottom:2px solid rgba(192,202,245,.24);background:#16161ef5;box-shadow:0 10px 28px #16161e42}.nav-topbar-toggle{display:inline-flex;align-items:center;align-self:stretch;gap:8px;min-width:150px;padding:0 15px;border:0;border-right:2px solid rgba(192,202,245,.24);color:#c0caf5;background:#1f2335;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:700;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.nav-topbar-toggle .ph{color:#7aa2f7;font-size:22px}.nav-topbar-toggle:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.nav-topbar-toggle:hover{color:#16161e;background:#7aa2f7}.nav-topbar-toggle:hover .ph{color:#16161e}}@media(hover:none)and (pointer:coarse){.nav-topbar-toggle:active{color:#16161e;background:#7aa2f7}.nav-topbar-toggle:active .ph{color:#16161e}}.nav-topbar-brand{display:inline-flex;align-items:center;gap:8px;min-width:0;padding:0 15px;color:#c0caf5;font-size:13px;font-weight:700;text-transform:uppercase}.nav-topbar-brand img{width:22px;height:22px}.nav-topbar-current{min-width:160px;margin-right:15px;padding:5px 8px;border:2px solid rgba(192,202,245,.24);color:#a9b1d6;background:#c0caf50b;font-size:12px;font-weight:700;text-align:center;text-transform:uppercase}.nav-drawer-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:910;background:#16161e;opacity:0;pointer-events:none;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity}.nav-drawer{position:fixed;inset:0 auto 0 0;z-index:920;display:flex;flex-direction:column;width:min(380px,100vw);max-height:100vh;border-right:2px solid #C0CAF5;background:#1f2335;box-shadow:18px 0 42px #16161e61;opacity:0;overflow:hidden;pointer-events:none;transform:translate(-100%);transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,transform}.nav-drawer.is-open{opacity:1;pointer-events:auto;transform:translate(0)}.nav-drawer-header{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px;border-bottom:2px solid rgba(192,202,245,.24)}.nav-drawer-title{display:inline-flex;padding:8px 12px;color:#16161e;background:#c0caf5;font-size:13px;font-weight:700;text-transform:uppercase}.nav-drawer-subtitle{margin-top:8px;color:#787c99;font-size:12px;font-weight:700;text-transform:uppercase}.nav-drawer-close{display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;padding:0;border:2px solid rgba(192,202,245,.24);color:#c0caf5;background:transparent;font-size:22px;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.nav-drawer-close:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.nav-drawer-close:hover{color:#16161e;background:#f7768e;border-color:#f7768e}}@media(hover:none)and (pointer:coarse){.nav-drawer-close:active{color:#16161e;background:#f7768e;border-color:#f7768e}}.nav-drawer-body{flex:1;overflow-y:auto;overscroll-behavior:contain;padding:12px;scrollbar-width:thin;scrollbar-color:#7AA2F7 #1F2335}.nav-drawer-body::-webkit-scrollbar{width:8px}.nav-drawer-body::-webkit-scrollbar-track{background:#1f2335}.nav-drawer-body::-webkit-scrollbar-thumb{background:#7aa2f7}.nav-drawer-body .list.list-nav{max-width:none}.nav-drawer-footer{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:12px;border-top:2px solid rgba(192,202,245,.24);color:#787c99;background:#c0caf50b;font-size:12px;font-weight:700;text-transform:uppercase}.nav-drawer-open{overflow:hidden}.nav-drawer-open .nav-drawer-backdrop{opacity:.82;pointer-events:auto}@media(max-width:767px){.nav-topbar-toggle{min-width:54px;padding:0 12px}.nav-topbar-brand{padding-right:12px;padding-left:12px}.nav-topbar-current{max-width:38vw;min-width:0;margin-right:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.nav-drawer{width:100vw;border-right:0}}.nav-shell-preview{width:100%;max-width:900px;overflow:hidden;border:2px solid rgba(192,202,245,.24);border-left-width:6px;background:#16161e}.nav-shell-preview-topbar{position:relative;z-index:0;min-height:52px;box-shadow:none}.nav-shell-preview-body{display:grid;grid-template-columns:280px minmax(0,1fr);min-height:320px}.nav-shell-preview-drawer{position:relative;z-index:0;inset:auto;width:auto;max-height:none;opacity:1;pointer-events:auto;transform:none;box-shadow:none}.nav-shell-preview-content{display:flex;flex-direction:column;justify-content:center;gap:12px;min-width:0;padding:18px;border-left:2px solid rgba(192,202,245,.24);background:#c0caf50b}.nav-shell-preview-content h3{margin:0;color:#c0caf5;font-size:20px;text-transform:uppercase}.nav-shell-preview-content p{max-width:360px;margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}@media(max-width:767px){.nav-shell-preview-body{grid-template-columns:1fr}.nav-shell-preview-content{min-height:180px;border-top:2px solid rgba(192,202,245,.24);border-left:0}}.toast{position:fixed;z-index:1100;bottom:-100px;right:15px;max-width:420px;background:#1f2335;border:2px solid #C0CAF5;border-left-width:6px;padding:0;opacity:0;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,top,bottom}.toast.a-show{bottom:15px;opacity:1}.toast.a-hide{bottom:115px;opacity:0}.toast .toast-content{display:flex;flex-direction:column;gap:0}.toast .toast-content .toast-title{min-height:38px;font-size:16px;display:flex;flex-direction:row;gap:8px;align-items:center;color:#16161e;background:#c0caf5;padding:8px 42px 8px 12px;text-transform:uppercase}.toast .toast-content .toast-text{font-size:13px;padding:22px 15px;margin:0}.toast .toast-close{position:absolute;top:0;right:0;color:#16161e;height:38px;width:38px;border-color:transparent}@media(hover:hover)and (pointer:fine){.toast .toast-close:hover{color:#16161e;background:#16161e1f;border-color:#16161e6b}}@media(hover:none)and (pointer:coarse){.toast .toast-close:active{color:#16161e;background:#16161e1f;border-color:#16161e6b}}.toast.toast-info{border-color:#bb9af7}.toast.toast-info .toast-title{background:#bb9af7}.toast.toast-success{border-color:#9ece6a}.toast.toast-success .toast-title{background:#9ece6a}.toast.toast-warning{border-color:#e0af68}.toast.toast-warning .toast-title{background:#e0af68}.toast.toast-danger{border-color:#f7768e}.toast.toast-danger .toast-title{background:#f7768e}.card{position:relative;max-width:340px;width:100%;overflow:hidden;background:#c0caf50b;border:2px solid #C0CAF5;transition-duration:.2s;transition-timing-function:ease;transition-property:border-color,background,box-shadow,transform}.card .card-title{color:#16161e;background:#c0caf5;padding:8px 12px;font-weight:700;text-transform:uppercase}.card .card-content{padding:15px;height:100%}.card .card-content .card-thumb{display:block;width:min(68%,190px);margin:18px auto 22px;transition-duration:.2s;transition-timing-function:ease;transition-property:transform,filter}.card .card-content p{margin-top:8px;margin-bottom:0}.card .card-footer{padding:8px 15px 15px}@media(hover:hover)and (pointer:fine){.card:hover{border-color:#7aa2f7;background:#c0caf516;box-shadow:0 14px 32px #16161e57;transform:translateY(-2px)}.card:hover .card-thumb{filter:saturate(1.12);transform:translateY(-2px)}}@media(hover:none)and (pointer:coarse){.card:active{border-color:#7aa2f7;background:#c0caf516;box-shadow:0 14px 32px #16161e57;transform:translateY(-2px)}.card:active .card-thumb{filter:saturate(1.12);transform:translateY(-2px)}}.card.status-card{max-width:220px;overflow:hidden;transition-duration:.2s;transition-property:border-color}.card.status-card .status-icon-container{position:relative}.card.status-card .status-icon-container .status-indicator{position:absolute;top:-15px;left:-5px;font-size:22px;color:#f7768e}.card.status-card .status-icon-container .status-indicator.status-online{color:#9ece6a}.card.status-card .status-icon-container .status-icon{display:flex;flex-direction:row;align-items:center;justify-content:center;font-size:56px;height:108px;width:100%;transition-duration:.2s;transition-property:color,transform}.card.status-card .card-title{display:flex;width:100%;font-size:14px;font-weight:700;align-items:center;flex-direction:row;flex-wrap:nowrap;justify-content:space-between;transition-duration:.2s;transition-property:background-color,color}.card.status-card .status-name{font-size:13px;line-height:1.4}@media(hover:hover)and (pointer:fine){.card.status-card:hover .status-icon{transform:translateY(-2px) scale(1.03)}}@media(hover:none)and (pointer:coarse){.card.status-card:active .status-icon{transform:translateY(-2px) scale(1.03)}}.card.status-card.card-success{border-color:#9ece6a}.card.status-card.card-success .card-title,.card.status-card.card-success .toast-title,.card.status-card.card-success .modal-title{color:#16161e;background:#9ece6a}.card.status-card.card-success .status-icon{color:#9ece6a}.card.status-card.card-warning{border-color:#e0af68}.card.status-card.card-warning .card-title,.card.status-card.card-warning .toast-title,.card.status-card.card-warning .modal-title{color:#16161e;background:#e0af68}.card.status-card.card-warning .status-icon{color:#e0af68}.card.status-card.card-info{border-color:#bb9af7}.card.status-card.card-info .card-title,.card.status-card.card-info .toast-title,.card.status-card.card-info .modal-title{color:#16161e;background:#bb9af7}.card.status-card.card-info .status-icon{color:#bb9af7}.card.status-card.card-secondary{border-color:#7aa2f7}.card.status-card.card-secondary .card-title,.card.status-card.card-secondary .toast-title,.card.status-card.card-secondary .modal-title{color:#16161e;background:#7aa2f7}.card.status-card.card-secondary .status-icon{color:#7aa2f7}.card.status-card.card-danger,.card.status-card.card-error{border-color:#f7768e}.card.status-card.card-danger .card-title,.card.status-card.card-danger .toast-title,.card.status-card.card-danger .modal-title,.card.status-card.card-error .card-title,.card.status-card.card-error .toast-title,.card.status-card.card-error .modal-title{color:#16161e;background:#f7768e}.card.status-card.card-danger .status-icon,.card.status-card.card-error .status-icon{color:#f7768e}.card.metric-card{max-width:320px;border-color:#c0caf53d}.card.metric-card .card-content{display:flex;flex-direction:column;gap:15px}.card.metric-card .metric-card-header{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.card.metric-card .metric-card-label{margin:0;color:#a9b1d6;font-size:13px;font-weight:600;text-transform:uppercase}.card.metric-card .metric-card-icon{display:inline-flex;align-items:center;justify-content:center;width:46px;height:46px;color:#16161e;background:#7aa2f7;font-size:22px;transition-duration:.2s;transition-timing-function:ease;transition-property:background,transform}.card.metric-card .metric-card-value{margin:0;color:#c0caf5;font-size:34px;font-weight:700;line-height:1.15}.card.metric-card .metric-card-meta{display:flex;flex-wrap:wrap;align-items:center;gap:8px;color:#787c99;font-size:13px}.card.metric-card .metric-card-delta{color:#9ece6a;font-weight:700}.card.metric-card .metric-card-delta.metric-card-delta-negative{color:#f7768e}@media(hover:hover)and (pointer:fine){.card.metric-card:hover .metric-card-icon{background:#c0caf5;transform:translateY(-2px)}}@media(hover:none)and (pointer:coarse){.card.metric-card:active .metric-card-icon{background:#c0caf5;transform:translateY(-2px)}}.card.action-card{max-width:360px;border-color:#7aa2f7}.card.action-card .card-content{display:flex;flex-direction:column;gap:15px}.card.action-card .action-card-kicker{display:inline-flex;width:max-content;padding:5px 8px;color:#16161e;background:#7aa2f7;font-size:12px;font-weight:700;line-height:1;text-transform:uppercase;transition-duration:.2s;transition-timing-function:ease;transition-property:background,transform}.card.action-card .action-card-title{margin:0;font-size:20px;font-weight:700;line-height:1.25;text-transform:uppercase}.card.action-card .action-card-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.card.action-card .action-card-actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}@media(hover:hover)and (pointer:fine){.card.action-card:hover .action-card-kicker{background:#c0caf5;transform:translate(5px)}}@media(hover:none)and (pointer:coarse){.card.action-card:active .action-card-kicker{background:#c0caf5;transform:translate(5px)}}.modal{position:fixed;top:0;bottom:0;left:0;right:0;z-index:1000;display:flex;flex-direction:column;align-items:center;justify-content:center}.modal .modal-backdrop{position:fixed;z-index:1010;top:0;bottom:0;left:0;right:0;background:#16161e;opacity:0;transition-duration:.25s;transition-property:opacity}.modal .modal-dialog{position:relative;z-index:1020;width:100%;max-width:960px;margin:200px 18px 18px;height:auto;max-height:calc(100vh - 48px);padding:0;display:flex;flex-direction:column;gap:0;opacity:0;transition-duration:.28s;transition-timing-function:ease;transition-property:opacity,margin-top}.modal .modal-dialog .modal-header{display:flex;flex-direction:row;justify-content:space-between;align-items:center;gap:15px}.modal .modal-dialog .modal-header .modal-title{padding:12px 15px;background:#c0caf5;color:#16161e;text-transform:uppercase;letter-spacing:.04em}.modal .modal-dialog .modal-header .modal-close{flex:0 0 auto;color:#c0caf5;border-color:#c0caf53d;background:#16161e}.modal .modal-dialog .modal-panel{min-height:200px;display:flex;flex-direction:column;gap:15px;overflow:hidden;background:#16161e;border:2px solid #C0CAF5;border-left-width:6px}.modal .modal-dialog .modal-body{max-height:700px;overflow-y:auto;padding:18px}.modal .modal-dialog .modal-footer{padding:18px}.modal .modal-dialog .modal-footer .actions{display:flex;flex-direction:row;justify-content:flex-end;gap:15px;width:100%}.modal.a-show .modal-backdrop{opacity:1}.modal.a-show .modal-dialog{opacity:1;margin-top:0}.modal.a-hide .modal-backdrop{opacity:0}.modal.a-hide .modal-dialog{opacity:0;margin-top:-200px}.alert{position:relative;overflow:hidden;margin-bottom:12px;padding:12px 15px;border:2px solid transparent;border-left-style:solid;border-left-width:6px;background:#c0caf50b;color:#c0caf5;font-weight:500;line-height:1.4;transition-duration:.2s;transition-timing-function:ease;transition-property:background,color,border-color}.alert:after{content:"";position:absolute;inset:0 auto 0 0;width:36%;background:linear-gradient(90deg,transparent,rgba(192,202,245,.12),transparent);opacity:0;pointer-events:none;transform:translate(-120%)}@media(hover:hover)and (pointer:fine){.alert:hover:after{opacity:1;animation:terminal_scan_x .8s ease}}@media(hover:none)and (pointer:coarse){.alert:active:after{opacity:1;animation:terminal_scan_x .8s ease}}.alert.alert-primary{border-color:#c0caf5;background:#c0caf51a;color:#c0caf5}.alert.alert-success{border-color:#9ece6a;background:#9ece6a1a;color:#9ece6a}.alert.alert-secondary{border-color:#7aa2f7;background:#7aa2f71a;color:#7aa2f7}.alert.alert-info{border-color:#bb9af7;background:#bb9af71a;color:#c0caf5}.alert.alert-warning{border-color:#e0af68;background:#e0af681a;color:#e0af68}.alert.alert-error,.alert.alert-danger{border-color:#f7768e;background:#f7768e1a;color:#f7768e}.advanced-select-container{position:relative;height:0}.advanced-select{position:absolute;z-index:100;top:6px;width:100%;height:auto;max-height:200px;overflow-y:auto;background:#16161e;border:2px solid #C0CAF5;border-left-width:6px;margin-top:20px;opacity:0;visibility:hidden;transition-property:opacity,margin-top,visibility;transition-duration:.2s;transition-timing-function:ease}.advanced-select.a-show{opacity:1;margin-top:0;visibility:visible}.advanced-select .popup-options-container .not-found{width:100%;padding:15px;text-align:center;display:none}.advanced-select .popup-options-container .not-found.show{display:block}.advanced-select .popup-options-container .options{width:100%;display:none}.advanced-select .popup-options-container .options.show{display:block}.advanced-select .popup-options-container .options .option{padding:8px 15px;transition-property:color,background;transition-duration:.15s}.advanced-select .popup-options-container .options .option.hide{display:none}.advanced-select .popup-options-container .options .option:hover,.advanced-select .popup-options-container .options .option.focus{color:#16161e;background:#e0af68}.component.editable-string-component .editable-string-content{display:flex;flex-direction:row;align-items:center;gap:8px;font-size:inherit}.component.editable-string-component .editable-string-content .editable-string{font-size:inherit;border-bottom:2px solid rgba(192,202,245,.24)}@media(hover:hover)and (pointer:fine){.component.editable-string-component .edit-text-btn:hover,.component.editable-string-component .apply-changes-btn:hover,.component.editable-string-component .cancel-changes-btn:hover{color:#16161e;background:#e0af68}}@media(hover:none)and (pointer:coarse){.component.editable-string-component .edit-text-btn:active,.component.editable-string-component .apply-changes-btn:active,.component.editable-string-component .cancel-changes-btn:active{color:#16161e;background:#e0af68}}.component.editable-string-component .apply-changes-btn{color:#e0af68}.component.editable-string-component .editable-string-form{display:flex;flex-direction:row;align-items:center;gap:8px}.component.editable-string-component .editable-string-form .form-group{max-width:260px;margin:0}.component.editable-string-component .editable-string-form .form-group .input{padding:8px 15px}.tabs{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin-bottom:15px}.tabs .tab{display:inline-flex;align-items:center;min-height:38px;padding:8px 12px;border:2px solid rgba(192,202,245,.24);border-left-width:6px;color:#a9b1d6;background:#c0caf50b;font-family:IBM Plex Mono,monospace;font-size:13px;font-weight:600;line-height:1;text-transform:uppercase;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background,border-color}.tabs .tab:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.tabs .tab:hover{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}@media(hover:none)and (pointer:coarse){.tabs .tab:active{color:#16161e;background:#7aa2f7;border-color:#7aa2f7}}.tabs .tab.tab-active,.tabs .tab[aria-selected=true]{color:#16161e;background:#c0caf5;border-color:#c0caf5}.dropdown,.popover{position:relative;display:inline-flex}.dropdown-menu,.popover-panel,.tooltip-panel{z-index:40;background:#1f2335;border:2px solid rgba(192,202,245,.24);border-left-width:6px;box-shadow:0 14px 36px #16161e5c}.dropdown-menu,.popover-panel{position:absolute;top:calc(100% + 8px);left:0;min-width:220px;display:none;transform-origin:top left}.dropdown.is-open .dropdown-menu,.popover.is-open .popover-panel{display:block;animation:overlay_reveal .2s ease both}.dropdown-menu{padding:5px}.dropdown-menu .dropdown-item{display:flex;align-items:center;gap:8px;width:100%;min-height:38px;padding:8px 12px;border:0;color:#c0caf5;background:transparent;font-family:IBM Plex Mono,monospace;font-size:13px;text-align:left;cursor:pointer;transition-duration:.2s;transition-timing-function:ease;transition-property:color,background}.dropdown-menu .dropdown-item .ph,.dropdown-menu .dropdown-item .ph-bold{font-size:18px}.dropdown-menu .dropdown-item:focus-visible{outline:2px solid #E0AF68;outline-offset:3px}@media(hover:hover)and (pointer:fine){.dropdown-menu .dropdown-item:hover{color:#16161e;background:#7aa2f7}}@media(hover:none)and (pointer:coarse){.dropdown-menu .dropdown-item:active{color:#16161e;background:#7aa2f7}}.dropdown-menu .dropdown-item.dropdown-item-danger{color:#f7768e}@media(hover:hover)and (pointer:fine){.dropdown-menu .dropdown-item.dropdown-item-danger:hover{color:#16161e;background:#f7768e}}@media(hover:none)and (pointer:coarse){.dropdown-menu .dropdown-item.dropdown-item-danger:active{color:#16161e;background:#f7768e}}.popover-panel{width:min(320px,100vw - 22px);padding:15px}.popover-panel .popover-title{margin:0 0 8px;font-size:14px;font-weight:700;text-transform:uppercase}.popover-panel .popover-text{margin:0;color:#a9b1d6;font-size:13px;line-height:1.6}.tooltip{position:relative;display:inline-flex}.tooltip-panel{position:absolute;left:50%;bottom:calc(100% + 8px);width:max-content;max-width:260px;padding:8px 12px;color:#c0caf5;font-size:12px;line-height:1.4;transform:translate(-50%);opacity:0;visibility:hidden;pointer-events:none;transition-duration:.15s;transition-timing-function:ease;transition-property:opacity,visibility}.tooltip:hover .tooltip-panel,.tooltip:focus-within .tooltip-panel,.tooltip.is-open .tooltip-panel{opacity:1;visibility:visible;animation:tooltip_reveal .15s ease both}.m-0{margin:0!important}.mt-0{margin-top:0!important}.mr-0{margin-right:0!important}.mb-0{margin-bottom:0!important}.ml-0{margin-left:0!important}.mx-0{margin-left:0!important;margin-right:0!important}.my-0{margin-top:0!important;margin-bottom:0!important}.p-0{padding:0!important}.pt-0{padding-top:0!important}.pr-0{padding-right:0!important}.pb-0{padding-bottom:0!important}.pl-0{padding-left:0!important}.px-0{padding-left:0!important;padding-right:0!important}.py-0{padding-top:0!important;padding-bottom:0!important}.g-0{gap:0!important}.gx-0{column-gap:0!important}.gy-0{row-gap:0!important}.m-1{margin:5px!important}.mt-1{margin-top:5px!important}.mr-1{margin-right:5px!important}.mb-1{margin-bottom:5px!important}.ml-1{margin-left:5px!important}.mx-1{margin-left:5px!important;margin-right:5px!important}.my-1{margin-top:5px!important;margin-bottom:5px!important}.p-1{padding:5px!important}.pt-1{padding-top:5px!important}.pr-1{padding-right:5px!important}.pb-1{padding-bottom:5px!important}.pl-1{padding-left:5px!important}.px-1{padding-left:5px!important;padding-right:5px!important}.py-1{padding-top:5px!important;padding-bottom:5px!important}.g-1{gap:5px!important}.gx-1{column-gap:5px!important}.gy-1{row-gap:5px!important}.m-2{margin:8px!important}.mt-2{margin-top:8px!important}.mr-2{margin-right:8px!important}.mb-2{margin-bottom:8px!important}.ml-2{margin-left:8px!important}.mx-2{margin-left:8px!important;margin-right:8px!important}.my-2{margin-top:8px!important;margin-bottom:8px!important}.p-2{padding:8px!important}.pt-2{padding-top:8px!important}.pr-2{padding-right:8px!important}.pb-2{padding-bottom:8px!important}.pl-2{padding-left:8px!important}.px-2{padding-left:8px!important;padding-right:8px!important}.py-2{padding-top:8px!important;padding-bottom:8px!important}.g-2{gap:8px!important}.gx-2{column-gap:8px!important}.gy-2{row-gap:8px!important}.m-3{margin:12px!important}.mt-3{margin-top:12px!important}.mr-3{margin-right:12px!important}.mb-3{margin-bottom:12px!important}.ml-3{margin-left:12px!important}.mx-3{margin-left:12px!important;margin-right:12px!important}.my-3{margin-top:12px!important;margin-bottom:12px!important}.p-3{padding:12px!important}.pt-3{padding-top:12px!important}.pr-3{padding-right:12px!important}.pb-3{padding-bottom:12px!important}.pl-3{padding-left:12px!important}.px-3{padding-left:12px!important;padding-right:12px!important}.py-3{padding-top:12px!important;padding-bottom:12px!important}.g-3{gap:12px!important}.gx-3{column-gap:12px!important}.gy-3{row-gap:12px!important}.m-4{margin:15px!important}.mt-4{margin-top:15px!important}.mr-4{margin-right:15px!important}.mb-4{margin-bottom:15px!important}.ml-4{margin-left:15px!important}.mx-4{margin-left:15px!important;margin-right:15px!important}.my-4{margin-top:15px!important;margin-bottom:15px!important}.p-4{padding:15px!important}.pt-4{padding-top:15px!important}.pr-4{padding-right:15px!important}.pb-4{padding-bottom:15px!important}.pl-4{padding-left:15px!important}.px-4{padding-left:15px!important;padding-right:15px!important}.py-4{padding-top:15px!important;padding-bottom:15px!important}.g-4{gap:15px!important}.gx-4{column-gap:15px!important}.gy-4{row-gap:15px!important}.m-5{margin:18px!important}.mt-5{margin-top:18px!important}.mr-5{margin-right:18px!important}.mb-5{margin-bottom:18px!important}.ml-5{margin-left:18px!important}.mx-5{margin-left:18px!important;margin-right:18px!important}.my-5{margin-top:18px!important;margin-bottom:18px!important}.p-5{padding:18px!important}.pt-5{padding-top:18px!important}.pr-5{padding-right:18px!important}.pb-5{padding-bottom:18px!important}.pl-5{padding-left:18px!important}.px-5{padding-left:18px!important;padding-right:18px!important}.py-5{padding-top:18px!important;padding-bottom:18px!important}.g-5{gap:18px!important}.gx-5{column-gap:18px!important}.gy-5{row-gap:18px!important}.m-6{margin:22px!important}.mt-6{margin-top:22px!important}.mr-6{margin-right:22px!important}.mb-6{margin-bottom:22px!important}.ml-6{margin-left:22px!important}.mx-6{margin-left:22px!important;margin-right:22px!important}.my-6{margin-top:22px!important;margin-bottom:22px!important}.p-6{padding:22px!important}.pt-6{padding-top:22px!important}.pr-6{padding-right:22px!important}.pb-6{padding-bottom:22px!important}.pl-6{padding-left:22px!important}.px-6{padding-left:22px!important;padding-right:22px!important}.py-6{padding-top:22px!important;padding-bottom:22px!important}.g-6{gap:22px!important}.gx-6{column-gap:22px!important}.gy-6{row-gap:22px!important}.m-7{margin:26px!important}.mt-7{margin-top:26px!important}.mr-7{margin-right:26px!important}.mb-7{margin-bottom:26px!important}.ml-7{margin-left:26px!important}.mx-7{margin-left:26px!important;margin-right:26px!important}.my-7{margin-top:26px!important;margin-bottom:26px!important}.p-7{padding:26px!important}.pt-7{padding-top:26px!important}.pr-7{padding-right:26px!important}.pb-7{padding-bottom:26px!important}.pl-7{padding-left:26px!important}.px-7{padding-left:26px!important;padding-right:26px!important}.py-7{padding-top:26px!important;padding-bottom:26px!important}.g-7{gap:26px!important}.gx-7{column-gap:26px!important}.gy-7{row-gap:26px!important}.m-8{margin:34px!important}.mt-8{margin-top:34px!important}.mr-8{margin-right:34px!important}.mb-8{margin-bottom:34px!important}.ml-8{margin-left:34px!important}.mx-8{margin-left:34px!important;margin-right:34px!important}.my-8{margin-top:34px!important;margin-bottom:34px!important}.p-8{padding:34px!important}.pt-8{padding-top:34px!important}.pr-8{padding-right:34px!important}.pb-8{padding-bottom:34px!important}.pl-8{padding-left:34px!important}.px-8{padding-left:34px!important;padding-right:34px!important}.py-8{padding-top:34px!important;padding-bottom:34px!important}.g-8{gap:34px!important}.gx-8{column-gap:34px!important}.gy-8{row-gap:34px!important}.m-9{margin:42px!important}.mt-9{margin-top:42px!important}.mr-9{margin-right:42px!important}.mb-9{margin-bottom:42px!important}.ml-9{margin-left:42px!important}.mx-9{margin-left:42px!important;margin-right:42px!important}.my-9{margin-top:42px!important;margin-bottom:42px!important}.p-9{padding:42px!important}.pt-9{padding-top:42px!important}.pr-9{padding-right:42px!important}.pb-9{padding-bottom:42px!important}.pl-9{padding-left:42px!important}.px-9{padding-left:42px!important;padding-right:42px!important}.py-9{padding-top:42px!important;padding-bottom:42px!important}.g-9{gap:42px!important}.gx-9{column-gap:42px!important}.gy-9{row-gap:42px!important}.m-10{margin:48px!important}.mt-10{margin-top:48px!important}.mr-10{margin-right:48px!important}.mb-10{margin-bottom:48px!important}.ml-10{margin-left:48px!important}.mx-10{margin-left:48px!important;margin-right:48px!important}.my-10{margin-top:48px!important;margin-bottom:48px!important}.p-10{padding:48px!important}.pt-10{padding-top:48px!important}.pr-10{padding-right:48px!important}.pb-10{padding-bottom:48px!important}.pl-10{padding-left:48px!important}.px-10{padding-left:48px!important;padding-right:48px!important}.py-10{padding-top:48px!important;padding-bottom:48px!important}.g-10{gap:48px!important}.gx-10{column-gap:48px!important}.gy-10{row-gap:48px!important}.m-11{margin:64px!important}.mt-11{margin-top:64px!important}.mr-11{margin-right:64px!important}.mb-11{margin-bottom:64px!important}.ml-11{margin-left:64px!important}.mx-11{margin-left:64px!important;margin-right:64px!important}.my-11{margin-top:64px!important;margin-bottom:64px!important}.p-11{padding:64px!important}.pt-11{padding-top:64px!important}.pr-11{padding-right:64px!important}.pb-11{padding-bottom:64px!important}.pl-11{padding-left:64px!important}.px-11{padding-left:64px!important;padding-right:64px!important}.py-11{padding-top:64px!important;padding-bottom:64px!important}.g-11{gap:64px!important}.gx-11{column-gap:64px!important}.gy-11{row-gap:64px!important}.m-12{margin:80px!important}.mt-12{margin-top:80px!important}.mr-12{margin-right:80px!important}.mb-12{margin-bottom:80px!important}.ml-12{margin-left:80px!important}.mx-12{margin-left:80px!important;margin-right:80px!important}.my-12{margin-top:80px!important;margin-bottom:80px!important}.p-12{padding:80px!important}.pt-12{padding-top:80px!important}.pr-12{padding-right:80px!important}.pb-12{padding-bottom:80px!important}.pl-12{padding-left:80px!important}.px-12{padding-left:80px!important;padding-right:80px!important}.py-12{padding-top:80px!important;padding-bottom:80px!important}.g-12{gap:80px!important}.gx-12{column-gap:80px!important}.gy-12{row-gap:80px!important}.row{display:flex;flex-direction:row}@media(max-width:1279px){.row.adaptive{flex-direction:column}}.column{display:flex;flex-direction:column}.f-grid{display:flex;flex-direction:row;flex-wrap:wrap}.grid{display:grid}.grid-2{display:grid;grid-template-columns:repeat(2,minmax(0,1fr))}.grid-3{display:grid;grid-template-columns:repeat(3,minmax(0,1fr))}.items-start{align-items:flex-start!important}.items-center{align-items:center!important}.items-end{align-items:flex-end!important}.justify-start{justify-content:flex-start!important}.justify-center{justify-content:center!important}.justify-between{justify-content:space-between!important}.justify-end{justify-content:flex-end!important}.w-100{width:100%}.w-auto{width:auto!important}.w-fit{width:fit-content!important}.w-200{width:200%}.h-100{height:100%}.min-w-0{min-width:0!important}.overflow-hidden{overflow:hidden!important}.overflow-auto{overflow:auto!important}.fs-xs{font-size:12px}.fs-sm{font-size:13px}.fs-md{font-size:14px}.fs-base{font-size:15px}.fs-lg{font-size:16px}.fs-xl{font-size:20px}.text-left{text-align:left!important}.text-center{text-align:center!important}.text-right{text-align:right!important}.text-uppercase{text-transform:uppercase!important}.text-nowrap{white-space:nowrap!important}.d-none{display:none!important}.d-block{display:block!important}.d-inline-flex{display:inline-flex!important}.d-flex{display:flex!important}.d-grid{display:grid!important}@media(max-width:767px){.grid-2,.grid-3{grid-template-columns:1fr}}*{box-sizing:border-box}html,body{padding:0;margin:0}body{background-color:#16161e;color:#c0caf5}*::-webkit-scrollbar-corner{background:transparent;height:1px}.ph.normalize{position:relative;top:.15em}html,body{height:100%}*::-webkit-scrollbar{width:10px}*::-webkit-scrollbar-track{width:10px;background:#16161e;cursor:pointer}*::-webkit-scrollbar-thumb{width:10px;background:#414868;cursor:default}*::-webkit-scrollbar-corner{background:transparent}*::-webkit-scrollbar-button{display:none}#app{display:flex;height:100vh;height:100dvh;overflow:hidden}.app-main{flex:1 1 0;min-width:0;min-height:0;display:flex;flex-direction:column;overflow:hidden;background:#16161e}.app-sidebar{width:380px;min-width:380px;max-width:380px;display:flex;flex-direction:column;background:#1f2335;border-right:2px solid rgba(192,202,245,.24);overflow:hidden;flex-shrink:0;transition:width .22s ease,min-width .22s ease,max-width .22s ease,border-color .22s ease,transform .28s ease}.app-sidebar.is-hidden-by-artifacts{width:0;min-width:0;max-width:0;border-right-color:transparent}@media(max-width:1280px){.app-sidebar{position:fixed;top:0;right:0;bottom:0;left:0;z-index:100;width:min(380px,92vw)!important;min-width:min(380px,92vw)!important;transform:translate(-100%);transition:transform .28s ease}.app-sidebar.is-mobile-open{transform:translate(0)}.app-sidebar.is-hidden-by-artifacts{width:min(380px,92vw)!important;min-width:min(380px,92vw)!important;max-width:min(380px,92vw)!important;border-right-color:#c0caf53d}}@media(max-width:980px){.app-sidebar,.app-sidebar.is-hidden-by-artifacts{width:100vw!important;min-width:100vw!important;max-width:100vw!important}}.sidebar-header{padding:15px;border-bottom:2px solid rgba(192,202,245,.24);display:flex;flex-direction:column;gap:8px}.sidebar-controls-row{display:flex;align-items:center;gap:8px}.sidebar-controls-row .sidebar-profile-select{flex:1;min-width:0}.sidebar-logo{display:flex;align-items:center;gap:8px;text-decoration:none}.sidebar-logo img{width:28px;height:28px}.sidebar-logo span{font-size:18px;font-weight:700;color:#c0caf5;letter-spacing:-.3px}.sidebar-sessions{flex:1;overflow:hidden;display:flex;flex-direction:column}.sessions-header{display:flex;align-items:center;justify-content:space-between;padding:8px 15px;gap:8px}.sessions-label{font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:#787c99}.sessions-refresh-btn{font-size:14px;color:#787c99;transition:color .15s,transform .15s}.sessions-refresh-btn:hover{color:#c0caf5}.sessions-refresh-btn.is-spinning i{animation:spin .8s linear infinite}.sidebar-profile-select{position:relative}.sidebar-profile-select select{width:100%;-moz-appearance:none;appearance:none;-webkit-appearance:none;min-height:46px;font-family:inherit;font-size:13px;font-weight:500;padding:5px 34px 5px 15px;border:2px solid rgba(192,202,245,.24);border-bottom-width:6px;border-bottom-color:#c0caf5;color:#c0caf5;background-color:#c0caf50b;cursor:pointer;transition:border-color .2s ease,background-color .2s ease;outline:none}.sidebar-profile-select select:hover{border-bottom-color:#787c99}.sidebar-profile-select select:focus{outline:2px solid #E0AF68;outline-offset:3px;border-color:#7aa2f7;background-color:transparent}.sidebar-profile-select select option{background:#1f2335;color:#c0caf5}.sidebar-profile-select:after{content:"";position:absolute;right:15px;top:50%;transform:translateY(-50%);width:0;height:0;border-left:4px solid transparent;border-right:4px solid transparent;border-top:5px solid #A9B1D6;pointer-events:none}.session-item{display:flex;align-items:flex-start;gap:8px;padding:8px 15px;cursor:pointer;border-radius:0;transition:background .15s ease;position:relative}.session-item:hover{background:#c0caf50b}.session-item:hover .session-actions{opacity:1}@media(hover:none){.session-item .session-actions{opacity:1}}.session-item.is-active{background:#c0caf516;border-left:6px solid #7AA2F7;padding-left:9px}.session-item.is-pinned{background:#e0af6812}.session-item.is-pinned .session-name{color:#e0af68}.session-item.has-recall .session-actions{opacity:1}.session-icons{display:flex;flex-direction:column;align-items:center;gap:2px;flex-shrink:0;margin-top:2px;width:14px}.session-icons .session-pin-icon,.session-icons .session-recall-icon{color:#787c99;font-size:14px;opacity:0;transition:opacity .15s ease}.session-icons .session-pin-icon{color:#e0af68}.session-icons .session-recall-icon{color:var(--color-accent, #7aa2f7)}.is-pinned .session-icons .session-pin-icon,.has-recall .session-icons .session-recall-icon{opacity:1}.session-info{flex:1;overflow:hidden}.session-name{font-size:13px;color:#a9b1d6;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;line-height:1.4}.session-time{font-size:11px;color:#787c99;line-height:1.4;margin-top:2px}.session-preview{font-size:12px;color:#c0caf5;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;line-height:1.4;margin-top:3px}.session-actions{display:flex;gap:2px;opacity:0;transition:opacity .15s ease;flex-shrink:0;align-self:flex-start;margin-top:1px}.session-actions .btn-icon{width:26px;height:26px;font-size:14px}.chat-area{flex:1 1 0;min-height:0;min-width:0;display:flex;flex-direction:column;overflow:hidden;background:#16161e}.chat-header{display:flex;align-items:center;gap:8px;padding:8px 15px;border-bottom:2px solid rgba(192,202,245,.24);background:#1f2335;flex-shrink:0;min-height:54px}.chat-header-info{flex:1;display:flex;align-items:center;gap:8px;overflow:hidden;min-width:0}@media(max-width:768px){.chat-header-info{flex-direction:column;align-items:flex-start;gap:2px}}.chat-header-title{font-size:14px;font-weight:600;color:#c0caf5;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex-shrink:1;min-width:0}.profile-badge{display:inline-flex;align-items:center;gap:6px;flex-shrink:0}.profile-badge .profile-badge-name{font-size:12px;color:#787c99;white-space:nowrap}.btn-sidebar-toggle{display:none}@media(max-width:1280px){.btn-sidebar-toggle{display:flex}}.context-bar{display:flex;align-items:center;flex-shrink:0;cursor:default}.profile-badge{display:inline-flex;align-items:center;gap:5px;padding:2px 8px;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);font-size:12px;color:#a9b1d6;white-space:nowrap}.message-list{flex:1;overflow-y:auto;overflow-x:hidden;padding:22px 15px;display:flex;flex-direction:column;gap:15px;min-height:0}@media(max-width:768px){.message-list{padding-left:10px;padding-right:10px}}.message-list .vue-recycle-scroller{flex:1}.message-list-inner{display:flex;flex-direction:column;gap:34px;width:100%;max-width:920px;margin:0 auto;padding:34px 22px;transition:opacity .2s ease}@media(max-width:768px){.message-list-inner{padding-left:0;padding-right:0}}.message-list-inner.is-hidden{opacity:0;pointer-events:none}.msg-user{display:flex;justify-content:flex-end;gap:8px}.msg-user-bubble{background:#7aa2f7;color:#16161e;padding:8px 15px;font-size:14px;line-height:1.6;word-wrap:break-word;width:100%}.msg-user-bubble .msg-user-quote{margin:0 0 5px;padding:2px 0 2px 8px;border-left:3px solid rgba(22,22,30,.35);opacity:.7;font-size:13px}.msg-user--recall .msg-user-bubble{background:#7aa2f71f;border:1px solid rgba(122,162,247,.25)}.msg-user--recall .msg-user-bubble .msg-user-text{color:#c0caf5}.msg-recall-badge{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:#7aa2f7;margin-bottom:4px;opacity:.85}.msg-user-attachments{display:flex;flex-wrap:wrap;gap:5px;margin-top:5px}.msg-user-image{width:80px;height:80px;object-fit:cover;cursor:pointer;transition:opacity .15s}.msg-user-image:hover{opacity:.75}.msg-user-file-pill{display:inline-flex;align-items:center;gap:5px;padding:2px 8px;background:#16161e4d;font-size:12px}.msg-time{font-size:11px;color:#787c99;line-height:1;margin-top:4px}.msg-meta-row{display:flex;align-items:center;gap:8px;margin-top:2px;min-width:0}.msg-meta-item{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:#787c99;white-space:nowrap}.msg-meta-item i{font-size:12px;opacity:.7}.msg-user-wrap{display:flex;flex-direction:column;align-items:flex-end;max-width:70%}@media(max-width:768px){.msg-user-wrap{max-width:90%}}.msg-user-footer{display:flex;align-items:center;gap:5px;align-self:flex-end}.msg-copy-btn{width:22px;height:22px;min-width:22px;padding:0;font-size:12px;opacity:.5;transition:opacity .15s}.msg-copy-btn:hover{opacity:1}.msg-meta-row>.msg-copy-btn{margin-left:auto}.msg-meta-row .msg-rate-btn{width:22px;height:22px;min-width:22px;padding:0;font-size:13px}.msg-assistant{display:flex;flex-direction:column;gap:8px;max-width:100%}.planning-indicator{display:flex;align-items:center;gap:8px;font-size:13px;font-style:italic;color:#787c99;padding:5px 0}.planning-indicator.is-executing{color:#a9b1d6;font-style:normal}.planning-label{opacity:.75;transition:opacity .2s}.msg-assistant-avatar{width:28px;height:28px;border-radius:50%;flex-shrink:0}.msg-assistant-content{font-size:14px;line-height:1.7;color:#c0caf5;display:flex;flex-wrap:wrap;gap:8px}.msg-assistant-content>p,.msg-assistant-content>ul,.msg-assistant-content>ol,.msg-assistant-content>blockquote,.msg-assistant-content>pre,.msg-assistant-content>.table-wrap,.msg-assistant-content>.code-block,.msg-assistant-content>h1,.msg-assistant-content>h2,.msg-assistant-content>h3,.msg-assistant-content>h4,.msg-assistant-content>hr{flex:1 1 100%;margin:0}.msg-assistant-content>p:has(>.msg-md-image-link:only-child){flex:0 0 calc((100% - 16px) / 3)}.msg-assistant-content h1,.msg-assistant-content h2,.msg-assistant-content h3,.msg-assistant-content h4{color:#c0caf5}.msg-assistant-content ul,.msg-assistant-content ol{padding-left:22px}.msg-assistant-content li{margin-bottom:8px}.msg-assistant-content blockquote{padding-left:15px;border-left:6px solid #7AA2F7;color:#a9b1d6}.msg-assistant-content a{color:#7aa2f7}.msg-assistant-content strong{color:#c0caf5}.msg-assistant-content hr{border:none;border-top:1px solid rgba(192,202,245,.24)}.msg-assistant-content .msg-md-image-link{display:block;width:100%;text-decoration:none;border:2px solid rgba(192,202,245,.12);border-radius:4px;overflow:hidden;transition:border-color .2s ease;cursor:zoom-in}.msg-assistant-content .msg-md-image-link:hover{border-color:#7aa2f7}.msg-assistant-content .msg-md-image{display:block;width:100%;aspect-ratio:1/1;object-fit:cover;border-radius:2px}.msg-assistant-content .msg-md-image-link.is-broken{cursor:default;border-color:#f7768e66;background:#f7768e0f;display:flex;align-items:center;justify-content:center;aspect-ratio:1/1}.msg-assistant-content .msg-md-image-link.is-broken:before{content:"🖼️";font-size:32px;opacity:.4}.msg-assistant-content .msg-md-image-link.is-broken:hover{border-color:#f7768e66}.msg-assistant-content .msg-md-image-link.is-broken .msg-md-image{display:none}.msg-assistant-content .table-wrap{overflow-x:auto;-webkit-overflow-scrolling:touch;margin:15px 0}.msg-assistant-content .table{margin:15px 0}.msg-assistant-content .table thead{border-bottom:2px solid #C0CAF5}.msg-assistant-content .table tbody tr{transition:background .2s ease}.msg-assistant-content .table tbody tr:hover{background:#7aa2f714}.msg-assistant-content .table tbody tr:hover td:first-child{color:#7aa2f7}.msg-assistant-content .table tr th,.msg-assistant-content .table tr td{padding:8px 15px;font-size:13px;vertical-align:middle;border-bottom:2px solid rgba(192,202,245,.08)}.msg-assistant-content .table tr th{color:#c0caf5;background:#c0caf50a;text-transform:uppercase;letter-spacing:.06em}.msg-assistant-content :not(pre)>code{font-family:IBM Plex Mono,monospace;font-size:13px;background:#c0caf516;padding:1px 5px;color:#7dcfff}.msg-assistant-content .code-block{margin:15px 0;background:#1f2335;border:2px solid rgba(192,202,245,.24);overflow:hidden}.msg-assistant-content .code-block .code-header{display:flex;align-items:center;justify-content:space-between;padding:5px 15px;background:#c0caf516;border-bottom:2px solid rgba(192,202,245,.24);font-size:12px;color:#787c99;font-family:IBM Plex Mono,monospace}.msg-assistant-content .code-block pre{margin:0;background:#1f2335!important}.msg-assistant-content .code-block pre code{font-family:IBM Plex Mono,monospace;font-size:13px;display:block;padding:15px;overflow-x:auto}.thinking-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;color:#787c99;font-size:12px;font-style:italic;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);transition:background .15s ease;-webkit-user-select:none;user-select:none}.thinking-card summary::-webkit-details-marker{display:none}.thinking-card summary:hover{background:#c0caf516}.thinking-card[open] summary{border-bottom-color:transparent}.thinking-card .thinking-chevron{margin-left:auto;font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.thinking-card[open] .thinking-chevron{transform:rotate(180deg)}.thinking-card .thinking-body{padding:8px 15px;font-size:12px;font-style:italic;color:#a9b1d6;line-height:1.5;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);border-top:none;white-space:pre-wrap;word-break:break-word}.plan-card{border:2px solid #7AA2F7;border-left-width:6px;border-left-color:#7aa2f7;overflow:hidden;font-size:12px;margin-bottom:8px}.plan-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#7aa2f714;color:#7aa2f7;font-size:12px;-webkit-user-select:none;user-select:none}.plan-card summary::-webkit-details-marker{display:none}.plan-card summary:hover{background:#7aa2f724}.plan-card summary .plan-chevron{margin-left:auto;font-size:18px;color:#7aa2f799;transition:transform .15s ease;flex-shrink:0}.plan-card[open] .plan-chevron{transform:rotate(180deg)}.plan-card .plan-body{padding:8px 15px;font-size:12px;color:#a9b1d6;line-height:1.5;background:#7aa2f70a;border-top:2px solid rgba(122,162,247,.3)}.plan-card .plan-body p{margin:0 0 8px}.plan-card .plan-body p:last-child{margin-bottom:0}.plan-card .plan-body ul,.plan-card .plan-body ol{padding-left:22px;margin-bottom:8px}.plan-card .plan-body li{margin-bottom:5px}.plan-card .plan-body strong{color:#c0caf5}.tool-card{border:2px solid rgba(192,202,245,.24);border-left-width:6px;margin-bottom:8px;border-left-color:#7aa2f7;overflow:hidden;font-size:13px}.tool-card.is-success{border-left-color:#9ece6a}.tool-card.is-error{border-left-color:#f7768e}.tool-card>summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#c0caf50b;color:#a9b1d6;-webkit-user-select:none;user-select:none}.tool-card>summary::-webkit-details-marker{display:none}.tool-card>summary:hover{background:#c0caf516}.tool-card>summary .tool-chevron{font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.tool-card[open]>summary .tool-chevron{transform:rotate(180deg)}.tool-card .tool-name{flex:1;font-family:IBM Plex Mono,monospace;font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tool-card .tool-running-time{font-family:IBM Plex Mono,monospace;font-size:11px;color:#787c99;white-space:nowrap}.tool-card .tool-status-icon{display:flex;align-items:center;justify-content:center;width:18px;height:18px;font-size:18px;flex-shrink:0}.tool-card-body{background:#c0caf50b;border-top:2px solid rgba(192,202,245,.24)}.tool-running-banner{display:flex;align-items:center;gap:8px;padding:8px 15px;color:#a9b1d6;background:#7aa2f714;border-bottom:1px solid rgba(192,202,245,.24);font-size:12px}.tool-section{padding:8px 15px}.tool-section+.tool-section{border-top:1px solid rgba(192,202,245,.24)}.tool-section-label{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:#787c99;margin-bottom:5px}.tool-code{font-family:IBM Plex Mono,monospace;font-size:12px;color:#a9b1d6;white-space:pre-wrap;word-break:break-word}.tool-args summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;-webkit-user-select:none;user-select:none;font-size:12px;color:#a9b1d6;background:#c0caf50b}.tool-args summary::-webkit-details-marker{display:none}.tool-args summary:hover{background:#c0caf516}.tool-args summary .tool-chevron{margin-left:auto;font-size:18px;color:#787c99;transition:transform .15s ease}.tool-args[open]>summary .tool-chevron{transform:rotate(180deg)}.tool-cards-summary{display:inline-flex;align-items:center;gap:8px;padding:5px 0}.tool-fade-item{transition:none}.tool-fade-enter-active,.tool-fade-leave-active{transition:opacity .2s ease,transform .2s ease}.tool-fade-enter-from{opacity:0;transform:translateY(-4px)}.tool-fade-leave-to{opacity:0}@supports (interpolate-size: allow-keywords){details{interpolate-size:allow-keywords}details::details-content{block-size:0;overflow:clip;transition:block-size .25s ease,content-visibility .25s ease;transition-behavior:allow-discrete}details[open]::details-content{block-size:auto}}.tool-result{font-size:12px;line-height:1.5;color:#a9b1d6}.tool-result h1,.tool-result h2,.tool-result h3,.tool-result h4{color:#c0caf5;margin:8px 0}.tool-result p{margin:5px 0}.tool-result ul,.tool-result ol{padding-left:22px;margin:5px 0}.tool-result li{margin-bottom:2px}.tool-result blockquote{padding-left:8px;border-left:2px solid #7AA2F7;color:#a9b1d6;margin:5px 0}.tool-result code{font-family:IBM Plex Mono,monospace;background:#c0caf516;padding:1px 4px;color:#7dcfff;font-size:11px}.tool-result pre{margin:5px 0;background:#1f2335;border:2px solid rgba(192,202,245,.24);overflow:hidden}.tool-result pre code{display:block;padding:8px;overflow-x:auto}.result-line{font-family:IBM Plex Mono,monospace;padding:1px 0;white-space:pre-wrap;word-break:break-word}.result-line.diff-summary,.result-line.diff-hunk,.result-line.diff-add,.result-line.diff-del,.result-line.diff-ctx{padding:0;line-height:1.3}.result-line.diff-summary,.result-line.diff-hunk{color:#a9b1d6}.result-line.diff-add{color:#9ece6a}.result-line.diff-del{color:#f7768e}.result-line.diff-ctx{color:inherit}.diff-num-marker.diff-add{color:#9ece6a}.diff-num-marker.diff-del{color:#f7768e}.diff-num-marker.diff-ctx,.diff-content{color:inherit}.read-header-path{color:#ff9e64}.read-header-rest{color:#a9b1d6}.read-warning{color:#e0af68}.read-num{color:#ff9e64}.read-content{color:inherit}.json-object,.json-array{font-family:IBM Plex Mono,monospace;display:flex;flex-direction:column;gap:1px;padding:5px 0}.json-item{display:flex;align-items:baseline;gap:5px;padding:1px 0}.json-key{color:#c0caf5;font-weight:500;flex-shrink:0}.json-sep{color:#787c99}.json-value{color:#a9b1d6;word-break:break-word;white-space:pre-wrap}.json-string{color:#9ece6a}.json-number{color:#e0af68}.json-bool{color:#c0caf5}.json-null,.json-empty{color:#787c99;font-style:italic}.subagent-steps{display:flex;flex-direction:column;gap:5px;padding:5px 15px 15px;background:#c0caf50b}.subagent-planning-indicator{display:flex;align-items:center;gap:8px;padding:5px 15px;font-size:12px;font-style:italic;color:#787c99;background:#c0caf50b}.task-update-step{display:flex;align-items:baseline;gap:8px;padding:5px 15px;font-size:12px;color:#a9b1d6;background:#c0caf50b}.task-update-step i{font-size:14px;color:#e0af68;flex:none}.task-update-step .task-step-tool{color:#c0caf5;font-weight:500}.task-update-step .task-step-status{color:#787c99;font-style:italic}.task-update-step .task-step-preview{color:#a9b1d6;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.task-update-step.completed i{color:#9ece6a}.task-update-step.completed .task-step-status{color:#9ece6a;font-style:normal}.task-update-step.failed i,.task-update-step.cancelled i{color:#f7768e}.task-update-step.failed .task-step-status,.task-update-step.cancelled .task-step-status{color:#f7768e;font-style:normal}.subagent-step{border:2px solid rgba(192,202,245,.24);border-left-width:6px;border-left-color:#7aa2f7;overflow:hidden;margin-bottom:8px;font-size:12px}.subagent-step.is-success{border-left-color:#9ece6a}.subagent-step.is-error{border-left-color:#f7768e}.subagent-step summary{list-style:none;display:flex;align-items:center;gap:8px;padding:5px 15px;cursor:pointer;background:#c0caf50b;color:#a9b1d6;-webkit-user-select:none;user-select:none}.subagent-step summary::-webkit-details-marker{display:none}.subagent-step summary:hover{background:#c0caf516}.subagent-step .tool-name{flex:1;font-family:IBM Plex Mono,monospace;font-size:12px;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.subagent-step .tool-running-time{font-family:IBM Plex Mono,monospace;font-size:11px;color:#787c99;white-space:nowrap}.subagent-step .tool-status-icon{display:flex;align-items:center;justify-content:center;width:18px;height:18px;font-size:18px;flex-shrink:0}.subagent-step .tool-chevron{font-size:18px;color:#787c99;flex-shrink:0;transition:transform .15s ease}.subagent-step[open]>summary .tool-chevron{transform:rotate(180deg)}.summary-card{border:2px solid #BB9AF7;overflow:hidden;font-size:13px}.summary-card summary{list-style:none;display:flex;align-items:center;gap:8px;padding:8px 15px;cursor:pointer;background:#bb9af714;color:#bb9af7;-webkit-user-select:none;user-select:none}.summary-card summary::-webkit-details-marker{display:none}.compression-notice{font-size:12px}.compression-notice summary{list-style:none;text-align:center;padding:8px;color:#787c99;display:flex;align-items:center;justify-content:center;gap:8px;cursor:pointer;-webkit-user-select:none;user-select:none}.compression-notice summary::-webkit-details-marker{display:none}.compression-notice summary:before,.compression-notice summary:after{content:"";flex:1;height:1px;background:#c0caf53d}.compression-notice .compression-counts{opacity:.7}.compression-notice .compression-chevron{font-size:18px;transition:transform .15s ease}.compression-notice[open] .compression-chevron{transform:rotate(180deg)}.compression-notice .compression-body{padding:15px;font-size:13px;color:#a9b1d6;line-height:1.6;background:#c0caf50b;border:2px solid rgba(192,202,245,.24)}.input-bar{flex-shrink:0;padding:8px 15px;background:#16161e;border-top:2px solid rgba(192,202,245,.24)}.input-dropzone{position:relative}.input-dropzone.is-dragging:after{content:"Drop files here";position:absolute;top:0;right:0;bottom:0;left:0;display:flex;align-items:center;justify-content:center;background:#7aa2f71f;border:2px dashed #7AA2F7;font-size:14px;color:#7aa2f7;pointer-events:none;z-index:10}.file-preview-strip{display:flex;flex-wrap:wrap;gap:5px;margin-bottom:5px;max-width:920px;margin-left:auto;margin-right:auto}.file-preview-image{position:relative;width:60px;height:60px}.file-preview-image img{width:100%;height:100%;object-fit:cover;border:2px solid rgba(192,202,245,.24)}.file-preview-pill{display:inline-flex;align-items:center;gap:5px;padding:5px 8px;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);font-size:12px;color:#a9b1d6;max-width:180px}.file-preview-pill span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.file-preview-remove{background:none;border:none;cursor:pointer;color:#787c99;padding:0;display:flex;align-items:center;font-size:14px;transition:color .15s ease;flex-shrink:0}.file-preview-remove:hover{color:#f7768e}.upload-progress{height:2px;background:#c0caf516;margin-bottom:5px;overflow:hidden}.upload-progress-fill{height:100%;background:#7aa2f7;transition:width .2s ease}.input-row{display:flex;align-items:center;gap:8px;background:#1f2335;border:2px solid rgba(192,202,245,.24);padding:8px;transition:border-color .15s ease;max-width:920px;margin:0 auto}.input-row:focus-within{border-color:#7aa2f7}.input-textarea{flex:1;background:none;border:none;outline:none;resize:none;color:#c0caf5;font-size:14px;line-height:1.5;font-family:inherit;min-height:24px;max-height:144px;overflow-y:auto;padding:2px 0}.input-textarea::placeholder{color:#787c99}.welcome-screen{flex:1;position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:34px;gap:34px;text-align:center}@media(max-width:768px){.welcome-screen{padding:52px 15px 15px;gap:15px;justify-content:flex-start}}.welcome-logo{display:flex;flex-direction:column;align-items:center;gap:8px}.welcome-logo img{width:64px;height:64px}.welcome-logo h1{font-size:32px;font-weight:700;letter-spacing:-.5px;color:#c0caf5;margin:0}.welcome-logo p{font-size:15px;color:#a9b1d6;margin:0}@media(max-width:768px){.welcome-logo{flex-direction:row;flex-wrap:wrap;justify-content:center;gap:8px}.welcome-logo img{width:36px;height:36px}.welcome-logo h1{font-size:22px}.welcome-logo p{font-size:13px;flex-basis:100%}}.welcome-profiles{display:flex;gap:15px;flex-wrap:wrap;justify-content:center;max-width:600px}@media(max-width:768px){.welcome-profiles{display:grid;grid-template-columns:repeat(2,1fr);gap:10px;width:100%;max-width:100%}}.welcome-profile-card{display:flex;flex-direction:column;align-items:center;gap:8px;padding:15px;background:#c0caf50b;border:2px solid rgba(192,202,245,.24);cursor:pointer;transition:border-color .15s ease,background .15s ease;width:160px;text-align:center}.welcome-profile-card:hover,.welcome-profile-card.is-selected{border-color:#7aa2f7;background:#c0caf516}.welcome-profile-card.is-selected{border-color:#7aa2f7}.welcome-profile-card .profile-icon{font-size:32px;color:#7aa2f7}.welcome-profile-card .profile-name{font-size:14px;font-weight:600;color:#c0caf5}.welcome-profile-card .profile-desc{font-size:12px;color:#787c99;line-height:1.4}@media(max-width:768px){.welcome-profile-card{width:auto;padding:10px;gap:6px}.welcome-profile-card .profile-icon{font-size:22px}.welcome-profile-card .profile-name{font-size:13px}.welcome-profile-card .profile-desc{font-size:11px;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}}.empty-chat{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:15px;color:#787c99;padding:34px}.empty-chat .empty-icon{font-size:56px;opacity:.4}.empty-chat p{font-size:15px;margin:0}.spinner{display:inline-block;width:14px;height:14px;border:2px solid rgba(192,202,245,.24);border-top-color:#7aa2f7;border-radius:50%;animation:spin .6s linear infinite;flex-shrink:0}@keyframes spin{to{transform:rotate(360deg)}}.fade-enter-active,.fade-leave-active{transition:opacity .15s ease}.fade-enter-from,.fade-leave-to{opacity:0}.msg-enter{animation:msgEnter .2s ease both}@keyframes msgEnter{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.slide-left-enter-active,.slide-left-leave-active{transition:transform .28s ease,opacity .28s ease}.slide-left-enter-from,.slide-left-leave-to{transform:translate(-100%);opacity:0}.modal-enter-active,.modal-leave-active{transition:opacity .28s ease}.modal-enter-active .modal-panel,.modal-leave-active .modal-panel{transition:opacity .28s ease,margin-top .28s ease}.modal-enter-from,.modal-leave-to{opacity:0}.modal-enter-from .modal-panel,.modal-leave-to .modal-panel{opacity:0;margin-top:200px}.btn-icon:not(.with-rotate) .ph{transform:none!important;transition:none!important}.tool-card[open]>summary .tool-chevron,.thinking-card[open]>summary .tool-chevron{transform:rotate(180deg)!important}.msg-flash{animation:msgFlash 2.5s ease-out}@keyframes msgFlash{0%{filter:brightness(1)}15%{filter:brightness(1.4);background-color:#7aa2f71f}40%{filter:brightness(1.4);background-color:#7aa2f71f}to{filter:brightness(1)}} diff --git a/webclient/dist/assets/index-Dp40tuNy.js b/webclient/dist/assets/index-Dp40tuNy.js new file mode 100644 index 0000000..a38ecf0 --- /dev/null +++ b/webclient/dist/assets/index-Dp40tuNy.js @@ -0,0 +1,118 @@ +var zS=Object.defineProperty;var WS=(t,e,n)=>e in t?zS(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n;var At=(t,e,n)=>WS(t,typeof e!="symbol"?e+"":e,n);(function(){const e=document.createElement("link").relList;if(e&&e.supports&&e.supports("modulepreload"))return;for(const r of document.querySelectorAll('link[rel="modulepreload"]'))a(r);new MutationObserver(r=>{for(const i of r)if(i.type==="childList")for(const s of i.addedNodes)s.tagName==="LINK"&&s.rel==="modulepreload"&&a(s)}).observe(document,{childList:!0,subtree:!0});function n(r){const i={};return r.integrity&&(i.integrity=r.integrity),r.referrerPolicy&&(i.referrerPolicy=r.referrerPolicy),r.crossOrigin==="use-credentials"?i.credentials="include":r.crossOrigin==="anonymous"?i.credentials="omit":i.credentials="same-origin",i}function a(r){if(r.ep)return;r.ep=!0;const i=n(r);fetch(r.href,i)}})();/** +* @vue/shared v3.5.32 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/function Uu(t){const e=Object.create(null);for(const n of t.split(","))e[n]=1;return n=>n in e}const It={},gr=[],jn=()=>{},SE=()=>!1,$i=t=>t.charCodeAt(0)===111&&t.charCodeAt(1)===110&&(t.charCodeAt(2)>122||t.charCodeAt(2)<97),qi=t=>t.startsWith("onUpdate:"),zt=Object.assign,Fu=(t,e)=>{const n=t.indexOf(e);n>-1&&t.splice(n,1)},KS=Object.prototype.hasOwnProperty,Rt=(t,e)=>KS.call(t,e),Ye=Array.isArray,Er=t=>ii(t)==="[object Map]",Cr=t=>ii(t)==="[object Set]",fd=t=>ii(t)==="[object Date]",Ze=t=>typeof t=="function",Gt=t=>typeof t=="string",Ln=t=>typeof t=="symbol",Ct=t=>t!==null&&typeof t=="object",bE=t=>(Ct(t)||Ze(t))&&Ze(t.then)&&Ze(t.catch),TE=Object.prototype.toString,ii=t=>TE.call(t),QS=t=>ii(t).slice(8,-1),hE=t=>ii(t)==="[object Object]",Hi=t=>Gt(t)&&t!=="NaN"&&t[0]!=="-"&&""+parseInt(t,10)===t,Gr=Uu(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),Vi=t=>{const e=Object.create(null);return(n=>e[n]||(e[n]=t(n)))},XS=/-\w/g,fn=Vi(t=>t.replace(XS,e=>e.slice(1).toUpperCase())),ZS=/\B([A-Z])/g,Ma=Vi(t=>t.replace(ZS,"-$1").toLowerCase()),zi=Vi(t=>t.charAt(0).toUpperCase()+t.slice(1)),ps=Vi(t=>t?`on${zi(t)}`:""),Jn=(t,e)=>!Object.is(t,e),Ti=(t,...e)=>{for(let n=0;n{Object.defineProperty(t,e,{configurable:!0,enumerable:!1,writable:a,value:n})},Wi=t=>{const e=parseFloat(t);return isNaN(e)?t:e},JS=t=>{const e=Gt(t)?Number(t):NaN;return isNaN(e)?t:e};let Sd;const Ki=()=>Sd||(Sd=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{});function Da(t){if(Ye(t)){const e={};for(let n=0;n{if(n){const a=n.split(eb);a.length>1&&(e[a[0].trim()]=a[1].trim())}}),e}function Ge(t){let e="";if(Gt(t))e=t;else if(Ye(t))for(let n=0;nwa(n,e))}const CE=t=>!!(t&&t.__v_isRef===!0),X=t=>Gt(t)?t:t==null?"":Ye(t)||Ct(t)&&(t.toString===TE||!Ze(t.toString))?CE(t)?X(t.value):JSON.stringify(t,yE,2):String(t),yE=(t,e)=>CE(e)?yE(t,e.value):Er(e)?{[`Map(${e.size})`]:[...e.entries()].reduce((n,[a,r],i)=>(n[ms(a,i)+" =>"]=r,n),{})}:Cr(e)?{[`Set(${e.size})`]:[...e.values()].map(n=>ms(n))}:Ln(e)?ms(e):Ct(e)&&!Ye(e)&&!hE(e)?String(e):e,ms=(t,e="")=>{var n;return Ln(t)?`Symbol(${(n=t.description)!=null?n:e})`:t};/** +* @vue/reactivity v3.5.32 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/let nn;class NE{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this.__v_skip=!0,this.parent=nn,!e&&nn&&(this.index=(nn.scopes||(nn.scopes=[])).push(this)-1)}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,n;if(this.scopes)for(e=0,n=this.scopes.length;e0&&--this._on===0&&(nn=this.prevScope,this.prevScope=void 0)}stop(e){if(this._active){this._active=!1;let n,a;for(n=0,a=this.effects.length;n0)return;if($r){let e=$r;for($r=void 0;e;){const n=e.next;e.next=void 0,e.flags&=-9,e=n}}let t;for(;Yr;){let e=Yr;for(Yr=void 0;e;){const n=e.next;if(e.next=void 0,e.flags&=-9,e.flags&1)try{e.trigger()}catch(a){t||(t=a)}e=n}}if(t)throw t}function xE(t){for(let e=t.deps;e;e=e.nextDep)e.version=-1,e.prevActiveLink=e.dep.activeLink,e.dep.activeLink=e}function LE(t){let e,n=t.depsTail,a=n;for(;a;){const r=a.prevDep;a.version===-1?(a===n&&(n=r),$u(a),ob(a)):e=a,a.dep.activeLink=a.prevActiveLink,a.prevActiveLink=void 0,a=r}t.deps=e,t.depsTail=n}function pu(t){for(let e=t.deps;e;e=e.nextDep)if(e.dep.version!==e.version||e.dep.computed&&(ME(e.dep.computed)||e.dep.version!==e.version))return!0;return!!t._dirty}function ME(t){if(t.flags&4&&!(t.flags&16)||(t.flags&=-17,t.globalVersion===Xr)||(t.globalVersion=Xr,!t.isSSR&&t.flags&128&&(!t.deps&&!t._dirty||!pu(t))))return;t.flags|=2;const e=t.dep,n=xt,a=Fn;xt=t,Fn=!0;try{xE(t);const r=t.fn(t._value);(e.version===0||Jn(r,t._value))&&(t.flags|=128,t._value=r,e.version++)}catch(r){throw e.version++,r}finally{xt=n,Fn=a,LE(t),t.flags&=-3}}function $u(t,e=!1){const{dep:n,prevSub:a,nextSub:r}=t;if(a&&(a.nextSub=r,t.prevSub=void 0),r&&(r.prevSub=a,t.nextSub=void 0),n.subs===t&&(n.subs=a,!a&&n.computed)){n.computed.flags&=-5;for(let i=n.computed.deps;i;i=i.nextDep)$u(i,!0)}!e&&!--n.sc&&n.map&&n.map.delete(n.key)}function ob(t){const{prevDep:e,nextDep:n}=t;e&&(e.nextDep=n,t.prevDep=void 0),n&&(n.prevDep=e,t.nextDep=void 0)}let Fn=!0;const kE=[];function _a(){kE.push(Fn),Fn=!1}function pa(){const t=kE.pop();Fn=t===void 0?!0:t}function bd(t){const{cleanup:e}=t;if(t.cleanup=void 0,e){const n=xt;xt=void 0;try{e()}finally{xt=n}}}let Xr=0;class lb{constructor(e,n){this.sub=e,this.dep=n,this.version=n.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}}class qu{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!xt||!Fn||xt===this.computed)return;let n=this.activeLink;if(n===void 0||n.sub!==xt)n=this.activeLink=new lb(xt,this),xt.deps?(n.prevDep=xt.depsTail,xt.depsTail.nextDep=n,xt.depsTail=n):xt.deps=xt.depsTail=n,PE(n);else if(n.version===-1&&(n.version=this.version,n.nextDep)){const a=n.nextDep;a.prevDep=n.prevDep,n.prevDep&&(n.prevDep.nextDep=a),n.prevDep=xt.depsTail,n.nextDep=void 0,xt.depsTail.nextDep=n,xt.depsTail=n,xt.deps===n&&(xt.deps=a)}return n}trigger(e){this.version++,Xr++,this.notify(e)}notify(e){Gu();try{for(let n=this.subs;n;n=n.prevSub)n.sub.notify()&&n.sub.dep.notify()}finally{Yu()}}}function PE(t){if(t.dep.sc++,t.sub.flags&4){const e=t.dep.computed;if(e&&!t.dep.subs){e.flags|=20;for(let a=e.deps;a;a=a.nextDep)PE(a)}const n=t.dep.subs;n!==t&&(t.prevSub=n,n&&(n.nextSub=t)),t.dep.subs=t}}const yi=new WeakMap,Ja=Symbol(""),mu=Symbol(""),Zr=Symbol("");function an(t,e,n){if(Fn&&xt){let a=yi.get(t);a||yi.set(t,a=new Map);let r=a.get(n);r||(a.set(n,r=new qu),r.map=a,r.key=n),r.track()}}function sa(t,e,n,a,r,i){const s=yi.get(t);if(!s){Xr++;return}const o=c=>{c&&c.trigger()};if(Gu(),e==="clear")s.forEach(o);else{const c=Ye(t),l=c&&Hi(n);if(c&&n==="length"){const u=Number(a);s.forEach((d,_)=>{(_==="length"||_===Zr||!Ln(_)&&_>=u)&&o(d)})}else switch((n!==void 0||s.has(void 0))&&o(s.get(n)),l&&o(s.get(Zr)),e){case"add":c?l&&o(s.get("length")):(o(s.get(Ja)),Er(t)&&o(s.get(mu)));break;case"delete":c||(o(s.get(Ja)),Er(t)&&o(s.get(mu)));break;case"set":Er(t)&&o(s.get(Ja));break}}Yu()}function cb(t,e){const n=yi.get(t);return n&&n.get(e)}function ur(t){const e=gt(t);return e===t?e:(an(e,"iterate",Zr),On(t)?e:e.map(Bn))}function Qi(t){return an(t=gt(t),"iterate",Zr),t}function Xn(t,e){return ma(t)?br(da(t)?Bn(e):e):Bn(e)}const ub={__proto__:null,[Symbol.iterator](){return Es(this,Symbol.iterator,t=>Xn(this,t))},concat(...t){return ur(this).concat(...t.map(e=>Ye(e)?ur(e):e))},entries(){return Es(this,"entries",t=>(t[1]=Xn(this,t[1]),t))},every(t,e){return aa(this,"every",t,e,void 0,arguments)},filter(t,e){return aa(this,"filter",t,e,n=>n.map(a=>Xn(this,a)),arguments)},find(t,e){return aa(this,"find",t,e,n=>Xn(this,n),arguments)},findIndex(t,e){return aa(this,"findIndex",t,e,void 0,arguments)},findLast(t,e){return aa(this,"findLast",t,e,n=>Xn(this,n),arguments)},findLastIndex(t,e){return aa(this,"findLastIndex",t,e,void 0,arguments)},forEach(t,e){return aa(this,"forEach",t,e,void 0,arguments)},includes(...t){return fs(this,"includes",t)},indexOf(...t){return fs(this,"indexOf",t)},join(t){return ur(this).join(t)},lastIndexOf(...t){return fs(this,"lastIndexOf",t)},map(t,e){return aa(this,"map",t,e,void 0,arguments)},pop(){return Ir(this,"pop")},push(...t){return Ir(this,"push",t)},reduce(t,...e){return Td(this,"reduce",t,e)},reduceRight(t,...e){return Td(this,"reduceRight",t,e)},shift(){return Ir(this,"shift")},some(t,e){return aa(this,"some",t,e,void 0,arguments)},splice(...t){return Ir(this,"splice",t)},toReversed(){return ur(this).toReversed()},toSorted(t){return ur(this).toSorted(t)},toSpliced(...t){return ur(this).toSpliced(...t)},unshift(...t){return Ir(this,"unshift",t)},values(){return Es(this,"values",t=>Xn(this,t))}};function Es(t,e,n){const a=Qi(t),r=a[e]();return a!==t&&!On(t)&&(r._next=r.next,r.next=()=>{const i=r._next();return i.done||(i.value=n(i.value)),i}),r}const db=Array.prototype;function aa(t,e,n,a,r,i){const s=Qi(t),o=s!==t&&!On(t),c=s[e];if(c!==db[e]){const d=c.apply(t,i);return o?Bn(d):d}let l=n;s!==t&&(o?l=function(d,_){return n.call(this,Xn(t,d),_,t)}:n.length>2&&(l=function(d,_){return n.call(this,d,_,t)}));const u=c.call(s,l,a);return o&&r?r(u):u}function Td(t,e,n,a){const r=Qi(t),i=r!==t&&!On(t);let s=n,o=!1;r!==t&&(i?(o=a.length===0,s=function(l,u,d){return o&&(o=!1,l=Xn(t,l)),n.call(this,l,Xn(t,u),d,t)}):n.length>3&&(s=function(l,u,d){return n.call(this,l,u,d,t)}));const c=r[e](s,...a);return o?Xn(t,c):c}function fs(t,e,n){const a=gt(t);an(a,"iterate",Zr);const r=a[e](...n);return(r===-1||r===!1)&&Xi(n[0])?(n[0]=gt(n[0]),a[e](...n)):r}function Ir(t,e,n=[]){_a(),Gu();const a=gt(t)[e].apply(t,n);return Yu(),pa(),a}const _b=Uu("__proto__,__v_isRef,__isVue"),UE=new Set(Object.getOwnPropertyNames(Symbol).filter(t=>t!=="arguments"&&t!=="caller").map(t=>Symbol[t]).filter(Ln));function pb(t){Ln(t)||(t=String(t));const e=gt(this);return an(e,"has",t),e.hasOwnProperty(t)}class FE{constructor(e=!1,n=!1){this._isReadonly=e,this._isShallow=n}get(e,n,a){if(n==="__v_skip")return e.__v_skip;const r=this._isReadonly,i=this._isShallow;if(n==="__v_isReactive")return!r;if(n==="__v_isReadonly")return r;if(n==="__v_isShallow")return i;if(n==="__v_raw")return a===(r?i?Rb:$E:i?YE:GE).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(a)?e:void 0;const s=Ye(e);if(!r){let c;if(s&&(c=ub[n]))return c;if(n==="hasOwnProperty")return pb}const o=Reflect.get(e,n,Bt(e)?e:a);if((Ln(n)?UE.has(n):_b(n))||(r||an(e,"get",n),i))return o;if(Bt(o)){const c=s&&Hi(n)?o:o.value;return r&&Ct(c)?Eu(c):c}return Ct(o)?r?Eu(o):ar(o):o}}class BE extends FE{constructor(e=!1){super(!1,e)}set(e,n,a,r){let i=e[n];const s=Ye(e)&&Hi(n);if(!this._isShallow){const l=ma(i);if(!On(a)&&!ma(a)&&(i=gt(i),a=gt(a)),!s&&Bt(i)&&!Bt(a))return l||(i.value=a),!0}const o=s?Number(n)t,_i=t=>Reflect.getPrototypeOf(t);function Sb(t,e,n){return function(...a){const r=this.__v_raw,i=gt(r),s=Er(i),o=t==="entries"||t===Symbol.iterator&&s,c=t==="keys"&&s,l=r[t](...a),u=n?gu:e?br:Bn;return!e&&an(i,"iterate",c?mu:Ja),zt(Object.create(l),{next(){const{value:d,done:_}=l.next();return _?{value:d,done:_}:{value:o?[u(d[0]),u(d[1])]:u(d),done:_}}})}}function pi(t){return function(...e){return t==="delete"?!1:t==="clear"?void 0:this}}function bb(t,e){const n={get(r){const i=this.__v_raw,s=gt(i),o=gt(r);t||(Jn(r,o)&&an(s,"get",r),an(s,"get",o));const{has:c}=_i(s),l=e?gu:t?br:Bn;if(c.call(s,r))return l(i.get(r));if(c.call(s,o))return l(i.get(o));i!==s&&i.get(r)},get size(){const r=this.__v_raw;return!t&&an(gt(r),"iterate",Ja),r.size},has(r){const i=this.__v_raw,s=gt(i),o=gt(r);return t||(Jn(r,o)&&an(s,"has",r),an(s,"has",o)),r===o?i.has(r):i.has(r)||i.has(o)},forEach(r,i){const s=this,o=s.__v_raw,c=gt(o),l=e?gu:t?br:Bn;return!t&&an(c,"iterate",Ja),o.forEach((u,d)=>r.call(i,l(u),l(d),s))}};return zt(n,t?{add:pi("add"),set:pi("set"),delete:pi("delete"),clear:pi("clear")}:{add(r){const i=gt(this),s=_i(i),o=gt(r),c=!e&&!On(r)&&!ma(r)?o:r;return s.has.call(i,c)||Jn(r,c)&&s.has.call(i,r)||Jn(o,c)&&s.has.call(i,o)||(i.add(c),sa(i,"add",c,c)),this},set(r,i){!e&&!On(i)&&!ma(i)&&(i=gt(i));const s=gt(this),{has:o,get:c}=_i(s);let l=o.call(s,r);l||(r=gt(r),l=o.call(s,r));const u=c.call(s,r);return s.set(r,i),l?Jn(i,u)&&sa(s,"set",r,i):sa(s,"add",r,i),this},delete(r){const i=gt(this),{has:s,get:o}=_i(i);let c=s.call(i,r);c||(r=gt(r),c=s.call(i,r)),o&&o.call(i,r);const l=i.delete(r);return c&&sa(i,"delete",r,void 0),l},clear(){const r=gt(this),i=r.size!==0,s=r.clear();return i&&sa(r,"clear",void 0,void 0),s}}),["keys","values","entries",Symbol.iterator].forEach(r=>{n[r]=Sb(r,t,e)}),n}function Hu(t,e){const n=bb(t,e);return(a,r,i)=>r==="__v_isReactive"?!t:r==="__v_isReadonly"?t:r==="__v_raw"?a:Reflect.get(Rt(n,r)&&r in a?n:a,r,i)}const Tb={get:Hu(!1,!1)},hb={get:Hu(!1,!0)},vb={get:Hu(!0,!1)};const GE=new WeakMap,YE=new WeakMap,$E=new WeakMap,Rb=new WeakMap;function Cb(t){switch(t){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function yb(t){return t.__v_skip||!Object.isExtensible(t)?0:Cb(QS(t))}function ar(t){return ma(t)?t:Vu(t,!1,gb,Tb,GE)}function Nb(t){return Vu(t,!1,fb,hb,YE)}function Eu(t){return Vu(t,!0,Eb,vb,$E)}function Vu(t,e,n,a,r){if(!Ct(t)||t.__v_raw&&!(e&&t.__v_isReactive))return t;const i=yb(t);if(i===0)return t;const s=r.get(t);if(s)return s;const o=new Proxy(t,i===2?a:n);return r.set(t,o),o}function da(t){return ma(t)?da(t.__v_raw):!!(t&&t.__v_isReactive)}function ma(t){return!!(t&&t.__v_isReadonly)}function On(t){return!!(t&&t.__v_isShallow)}function Xi(t){return t?!!t.__v_raw:!1}function gt(t){const e=t&&t.__v_raw;return e?gt(e):t}function Jr(t){return!Rt(t,"__v_skip")&&Object.isExtensible(t)&&vE(t,"__v_skip",!0),t}const Bn=t=>Ct(t)?ar(t):t,br=t=>Ct(t)?Eu(t):t;function Bt(t){return t?t.__v_isRef===!0:!1}function Y(t){return HE(t,!1)}function qE(t){return HE(t,!0)}function HE(t,e){return Bt(t)?t:new Ob(t,e)}class Ob{constructor(e,n){this.dep=new qu,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=n?e:gt(e),this._value=n?e:Bn(e),this.__v_isShallow=n}get value(){return this.dep.track(),this._value}set value(e){const n=this._rawValue,a=this.__v_isShallow||On(e)||ma(e);e=a?e:gt(e),Jn(e,n)&&(this._rawValue=e,this._value=a?e:Bn(e),this.dep.trigger())}}function $(t){return Bt(t)?t.value:t}const Ab={get:(t,e,n)=>e==="__v_raw"?t:$(Reflect.get(t,e,n)),set:(t,e,n,a)=>{const r=t[e];return Bt(r)&&!Bt(n)?(r.value=n,!0):Reflect.set(t,e,n,a)}};function VE(t){return da(t)?t:new Proxy(t,Ab)}function Ib(t){const e=Ye(t)?new Array(t.length):{};for(const n in t)e[n]=wb(t,n);return e}class Db{constructor(e,n,a){this._object=e,this._defaultValue=a,this.__v_isRef=!0,this._value=void 0,this._key=Ln(n)?n:String(n),this._raw=gt(e);let r=!0,i=e;if(!Ye(e)||Ln(this._key)||!Hi(this._key))do r=!Xi(i)||On(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=$(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&Bt(this._raw[this._key])){const n=this._object[this._key];if(Bt(n)){n.value=e;return}}this._object[this._key]=e}get dep(){return cb(this._raw,this._key)}}function wb(t,e,n){return new Db(t,e,n)}class xb{constructor(e,n,a){this.fn=e,this.setter=n,this._value=void 0,this.dep=new qu(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=Xr-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!n,this.isSSR=a}notify(){if(this.flags|=16,!(this.flags&8)&&xt!==this)return wE(this,!0),!0}get value(){const e=this.dep.track();return ME(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}}function Lb(t,e,n=!1){let a,r;return Ze(t)?a=t:(a=t.get,r=t.set),new xb(a,r,n)}const mi={},Ni=new WeakMap;let za;function Mb(t,e=!1,n=za){if(n){let a=Ni.get(n);a||Ni.set(n,a=[]),a.push(t)}}function kb(t,e,n=It){const{immediate:a,deep:r,once:i,scheduler:s,augmentJob:o,call:c}=n,l=L=>r?L:On(L)||r===!1||r===0?oa(L,1):oa(L);let u,d,_,m,p=!1,E=!1;if(Bt(t)?(d=()=>t.value,p=On(t)):da(t)?(d=()=>l(t),p=!0):Ye(t)?(E=!0,p=t.some(L=>da(L)||On(L)),d=()=>t.map(L=>{if(Bt(L))return L.value;if(da(L))return l(L);if(Ze(L))return c?c(L,2):L()})):Ze(t)?e?d=c?()=>c(t,2):t:d=()=>{if(_){_a();try{_()}finally{pa()}}const L=za;za=u;try{return c?c(t,3,[m]):t(m)}finally{za=L}}:d=jn,e&&r){const L=d,U=r===!0?1/0:r;d=()=>oa(L(),U)}const b=AE(),I=()=>{u.stop(),b&&b.active&&Fu(b.effects,u)};if(i&&e){const L=e;e=(...U)=>{L(...U),I()}}let R=E?new Array(t.length).fill(mi):mi;const y=L=>{if(!(!(u.flags&1)||!u.dirty&&!L))if(e){const U=u.run();if(r||p||(E?U.some((h,N)=>Jn(h,R[N])):Jn(U,R))){_&&_();const h=za;za=u;try{const N=[U,R===mi?void 0:E&&R[0]===mi?[]:R,m];R=U,c?c(e,3,N):e(...N)}finally{za=h}}}else u.run()};return o&&o(y),u=new IE(d),u.scheduler=s?()=>s(y,!1):y,m=L=>Mb(L,!1,u),_=u.onStop=()=>{const L=Ni.get(u);if(L){if(c)c(L,4);else for(const U of L)U();Ni.delete(u)}},e?a?y(!0):R=u.run():s?s(y.bind(null,!0),!0):u.run(),I.pause=u.pause.bind(u),I.resume=u.resume.bind(u),I.stop=I,I}function oa(t,e=1/0,n){if(e<=0||!Ct(t)||t.__v_skip||(n=n||new Map,(n.get(t)||0)>=e))return t;if(n.set(t,e),e--,Bt(t))oa(t.value,e,n);else if(Ye(t))for(let a=0;a{oa(a,e,n)});else if(hE(t)){for(const a in t)oa(t[a],e,n);for(const a of Object.getOwnPropertySymbols(t))Object.prototype.propertyIsEnumerable.call(t,a)&&oa(t[a],e,n)}return t}/** +* @vue/runtime-core v3.5.32 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/function si(t,e,n,a){try{return a?t(...a):t()}catch(r){Zi(r,e,n)}}function Gn(t,e,n,a){if(Ze(t)){const r=si(t,e,n,a);return r&&bE(r)&&r.catch(i=>{Zi(i,e,n)}),r}if(Ye(t)){const r=[];for(let i=0;i>>1,r=mn[a],i=jr(r);i=jr(n)?mn.push(t):mn.splice(Ub(e),0,t),t.flags|=1,WE()}}function WE(){Oi||(Oi=zE.then(QE))}function Fb(t){Ye(t)?fr.push(...t):Ia&&t.id===-1?Ia.splice(_r+1,0,t):t.flags&1||(fr.push(t),t.flags|=1),WE()}function hd(t,e,n=Kn+1){for(;njr(n)-jr(a));if(fr.length=0,Ia){Ia.push(...e);return}for(Ia=e,_r=0;_rt.id==null?t.flags&2?-1:1/0:t.id;function QE(t){try{for(Kn=0;Kn{a._d&&wi(-1);const i=Ai(e);let s;try{s=t(...r)}finally{Ai(i),a._d&&wi(1)}return s};return a._n=!0,a._c=!0,a._d=!0,a}function Ka(t,e){if(yn===null)return t;const n=as(yn),a=t.dirs||(t.dirs=[]);for(let r=0;r1)return n&&Ze(e)?e.call(a&&a.proxy):e}}function Bb(){return!!(yr()||er)}const Gb=Symbol.for("v-scx"),Yb=()=>ja(Gb);function $b(t,e){return Wu(t,null,e)}function st(t,e,n){return Wu(t,e,n)}function Wu(t,e,n=It){const{immediate:a,deep:r,flush:i,once:s}=n,o=zt({},n),c=e&&a||!e&&i!=="post";let l;if(ni){if(i==="sync"){const m=Yb();l=m.__watcherHandles||(m.__watcherHandles=[])}else if(!c){const m=()=>{};return m.stop=jn,m.resume=jn,m.pause=jn,m}}const u=rn;o.call=(m,p,E)=>Gn(m,u,p,E);let d=!1;i==="post"?o.scheduler=m=>{pn(m,u&&u.suspense)}:i!=="sync"&&(d=!0,o.scheduler=(m,p)=>{p?m():zu(m)}),o.augmentJob=m=>{e&&(m.flags|=4),d&&(m.flags|=2,u&&(m.id=u.uid,m.i=u))};const _=kb(t,e,o);return ni&&(l?l.push(_):c&&_()),_}function qb(t,e,n){const a=this.proxy,r=Gt(t)?t.includes(".")?JE(a,t):()=>a[t]:t.bind(a,a);let i;Ze(e)?i=e:(i=e.handler,n=e);const s=oi(this),o=Wu(r,i.bind(a),n);return s(),o}function JE(t,e){const n=e.split(".");return()=>{let a=t;for(let r=0;rt.__isTeleport,Qa=t=>t&&(t.disabled||t.disabled===""),Hb=t=>t&&(t.defer||t.defer===""),vd=t=>typeof SVGElement<"u"&&t instanceof SVGElement,Rd=t=>typeof MathMLElement=="function"&&t instanceof MathMLElement,fu=(t,e)=>{const n=t&&t.to;return Gt(n)?e?e(n):null:n},Vb={name:"Teleport",__isTeleport:!0,process(t,e,n,a,r,i,s,o,c,l){const{mc:u,pc:d,pbc:_,o:{insert:m,querySelector:p,createText:E,createComment:b}}=l,I=Qa(e.props);let{dynamicChildren:R}=e;const y=(h,N,C)=>{h.shapeFlag&16&&u(h.children,N,C,r,i,s,o,c)},L=(h=e)=>{const N=Qa(h.props),C=h.target=fu(h.props,p),f=Su(C,h,E,m);C&&(s!=="svg"&&vd(C)?s="svg":s!=="mathml"&&Rd(C)&&(s="mathml"),r&&r.isCE&&(r.ce._teleportTargets||(r.ce._teleportTargets=new Set)).add(C),N||(y(h,C,f),Ur(h,!1)))},U=h=>{const N=()=>{$a.get(h)===N&&($a.delete(h),Qa(h.props)&&(y(h,n,h.anchor),Ur(h,!0)),L(h))};$a.set(h,N),pn(N,i)};if(t==null){const h=e.el=E(""),N=e.anchor=E("");if(m(h,n,a),m(N,n,a),Hb(e.props)||i&&i.pendingBranch){U(e);return}I&&(y(e,n,N),Ur(e,!0)),L()}else{e.el=t.el;const h=e.anchor=t.anchor,N=$a.get(t);if(N){N.flags|=8,$a.delete(t),U(e);return}e.targetStart=t.targetStart;const C=e.target=t.target,f=e.targetAnchor=t.targetAnchor,A=Qa(t.props),w=A?n:C,F=A?h:f;if(s==="svg"||vd(C)?s="svg":(s==="mathml"||Rd(C))&&(s="mathml"),R?(_(t.dynamicChildren,R,w,r,i,s,o),Zu(t,e,!0)):c||d(t,e,w,F,r,i,s,o,!1),I)A?e.props&&t.props&&e.props.to!==t.props.to&&(e.props.to=t.props.to):gi(e,n,h,l,1);else if((e.props&&e.props.to)!==(t.props&&t.props.to)){const j=e.target=fu(e.props,p);j&&gi(e,j,null,l,0)}else A&&gi(e,C,f,l,1);Ur(e,I)}},remove(t,e,n,{um:a,o:{remove:r}},i){const{shapeFlag:s,children:o,anchor:c,targetStart:l,targetAnchor:u,target:d,props:_}=t;let m=i||!Qa(_);const p=$a.get(t);if(p&&(p.flags|=8,$a.delete(t),m=!1),d&&(r(l),r(u)),i&&r(c),s&16)for(let E=0;E{t.isMounted=!0}),Yn(()=>{t.isUnmounting=!0}),t}const Dn=[Function,Array],nf={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Dn,onEnter:Dn,onAfterEnter:Dn,onEnterCancelled:Dn,onBeforeLeave:Dn,onLeave:Dn,onAfterLeave:Dn,onLeaveCancelled:Dn,onBeforeAppear:Dn,onAppear:Dn,onAfterAppear:Dn,onAppearCancelled:Dn},af=t=>{const e=t.subTree;return e.component?af(e.component):e},Wb={name:"BaseTransition",props:nf,setup(t,{slots:e}){const n=yr(),a=tf();return()=>{const r=e.default&&Ku(e.default(),!0);if(!r||!r.length)return;const i=rf(r),s=gt(t),{mode:o}=s;if(a.isLeaving)return Ss(i);const c=Cd(i);if(!c)return Ss(i);let l=ei(c,s,a,n,d=>l=d);c.type!==gn&&rr(c,l);let u=n.subTree&&Cd(n.subTree);if(u&&u.type!==gn&&!Xa(u,c)&&af(n).type!==gn){let d=ei(u,s,a,n);if(rr(u,d),o==="out-in"&&c.type!==gn)return a.isLeaving=!0,d.afterLeave=()=>{a.isLeaving=!1,n.job.flags&8||n.update(),delete d.afterLeave,u=void 0},Ss(i);o==="in-out"&&c.type!==gn?d.delayLeave=(_,m,p)=>{const E=sf(a,u);E[String(u.key)]=u,_[Qn]=()=>{m(),_[Qn]=void 0,delete l.delayedLeave,u=void 0},l.delayedLeave=()=>{p(),delete l.delayedLeave,u=void 0}}:u=void 0}else u&&(u=void 0);return i}}};function rf(t){let e=t[0];if(t.length>1){for(const n of t)if(n.type!==gn){e=n;break}}return e}const Kb=Wb;function sf(t,e){const{leavingVNodes:n}=t;let a=n.get(e.type);return a||(a=Object.create(null),n.set(e.type,a)),a}function ei(t,e,n,a,r){const{appear:i,mode:s,persisted:o=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:_,onLeave:m,onAfterLeave:p,onLeaveCancelled:E,onBeforeAppear:b,onAppear:I,onAfterAppear:R,onAppearCancelled:y}=e,L=String(t.key),U=sf(n,t),h=(f,A)=>{f&&Gn(f,a,9,A)},N=(f,A)=>{const w=A[1];h(f,A),Ye(f)?f.every(F=>F.length<=1)&&w():f.length<=1&&w()},C={mode:s,persisted:o,beforeEnter(f){let A=c;if(!n.isMounted)if(i)A=b||c;else return;f[Qn]&&f[Qn](!0);const w=U[L];w&&Xa(t,w)&&w.el[Qn]&&w.el[Qn](),h(A,[f])},enter(f){if(U[L]===t)return;let A=l,w=u,F=d;if(!n.isMounted)if(i)A=I||l,w=R||u,F=y||d;else return;let j=!1;f[Dr]=be=>{j||(j=!0,be?h(F,[f]):h(w,[f]),C.delayedLeave&&C.delayedLeave(),f[Dr]=void 0)};const _e=f[Dr].bind(null,!1);A?N(A,[f,_e]):_e()},leave(f,A){const w=String(t.key);if(f[Dr]&&f[Dr](!0),n.isUnmounting)return A();h(_,[f]);let F=!1;f[Qn]=_e=>{F||(F=!0,A(),_e?h(E,[f]):h(p,[f]),f[Qn]=void 0,U[w]===t&&delete U[w])};const j=f[Qn].bind(null,!1);U[w]=t,m?N(m,[f,j]):j()},clone(f){const A=ei(f,e,n,a,r);return r&&r(A),A}};return C}function Ss(t){if(ji(t))return t=xa(t),t.children=null,t}function Cd(t){if(!ji(t))return ef(t.type)&&t.children?rf(t.children):t;if(t.component)return t.component.subTree;const{shapeFlag:e,children:n}=t;if(n){if(e&16)return n[0];if(e&32&&Ze(n.default))return n.default()}}function rr(t,e){t.shapeFlag&6&&t.component?(t.transition=e,rr(t.component.subTree,e)):t.shapeFlag&128?(t.ssContent.transition=e.clone(t.ssContent),t.ssFallback.transition=e.clone(t.ssFallback)):t.transition=e}function Ku(t,e=!1,n){let a=[],r=0;for(let i=0;i1)for(let i=0;iqr(E,e&&(Ye(e)?e[b]:e),n,a,r));return}if(Hr(a)&&!r){a.shapeFlag&512&&a.type.__asyncResolved&&a.component.subTree.component&&qr(t,e,n,a.component.subTree);return}const i=a.shapeFlag&4?as(a.component):a.el,s=r?null:i,{i:o,r:c}=t,l=e&&e.r,u=o.refs===It?o.refs={}:o.refs,d=o.setupState,_=gt(d),m=d===It?SE:E=>yd(u,E)?!1:Rt(_,E),p=(E,b)=>!(b&&yd(u,b));if(l!=null&&l!==c){if(Nd(e),Gt(l))u[l]=null,m(l)&&(d[l]=null);else if(Bt(l)){const E=e;p(l,E.k)&&(l.value=null),E.k&&(u[E.k]=null)}}if(Ze(c))si(c,o,12,[s,u]);else{const E=Gt(c),b=Bt(c);if(E||b){const I=()=>{if(t.f){const R=E?m(c)?d[c]:u[c]:p()||!t.k?c.value:u[t.k];if(r)Ye(R)&&Fu(R,i);else if(Ye(R))R.includes(i)||R.push(i);else if(E)u[c]=[i],m(c)&&(d[c]=u[c]);else{const y=[i];p(c,t.k)&&(c.value=y),t.k&&(u[t.k]=y)}}else E?(u[c]=s,m(c)&&(d[c]=s)):b&&(p(c,t.k)&&(c.value=s),t.k&&(u[t.k]=s))};if(s){const R=()=>{I(),Ii.delete(t)};R.id=-1,Ii.set(t,R),pn(R,n)}else Nd(t),I()}}}function Nd(t){const e=Ii.get(t);e&&(e.flags|=8,Ii.delete(t))}Ki().requestIdleCallback;Ki().cancelIdleCallback;const Hr=t=>!!t.type.__asyncLoader,ji=t=>t.type.__isKeepAlive;function Qb(t,e){lf(t,"a",e)}function Xb(t,e){lf(t,"da",e)}function lf(t,e,n=rn){const a=t.__wdc||(t.__wdc=()=>{let r=n;for(;r;){if(r.isDeactivated)return;r=r.parent}return t()});if(es(e,a,n),n){let r=n.parent;for(;r&&r.parent;)ji(r.parent.vnode)&&Zb(a,e,n,r),r=r.parent}}function Zb(t,e,n,a){const r=es(e,t,a,!0);fa(()=>{Fu(a[e],r)},n)}function es(t,e,n=rn,a=!1){if(n){const r=n[t]||(n[t]=[]),i=e.__weh||(e.__weh=(...s)=>{_a();const o=oi(n),c=Gn(e,n,t,s);return o(),pa(),c});return a?r.unshift(i):r.push(i),i}}const Ea=t=>(e,n=rn)=>{(!ni||t==="sp")&&es(t,(...a)=>e(...a),n)},Jb=Ea("bm"),Sn=Ea("m"),jb=Ea("bu"),cf=Ea("u"),Yn=Ea("bum"),fa=Ea("um"),eT=Ea("sp"),tT=Ea("rtg"),nT=Ea("rtc");function aT(t,e=rn){es("ec",t,e)}const uf="components";function tt(t,e){return pf(uf,t,!0,e)||t}const df=Symbol.for("v-ndc");function _f(t){return Gt(t)?pf(uf,t,!1)||t:t||df}function pf(t,e,n=!0,a=!1){const r=yn||rn;if(r){const i=r.type;{const o=$T(i,!1);if(o&&(o===e||o===fn(e)||o===zi(fn(e))))return i}const s=Od(r[t]||i[t],e)||Od(r.appContext[t],e);return!s&&a?i:s}}function Od(t,e){return t&&(t[e]||t[fn(e)]||t[zi(fn(e))])}function Dt(t,e,n,a){let r;const i=n,s=Ye(t);if(s||Gt(t)){const o=s&&da(t);let c=!1,l=!1;o&&(c=!On(t),l=ma(t),t=Qi(t)),r=new Array(t.length);for(let u=0,d=t.length;ue(o,c,void 0,i));else{const o=Object.keys(t);r=new Array(o.length);for(let c=0,l=o.length;ct?xf(t)?as(t):bu(t.parent):null,Vr=zt(Object.create(null),{$:t=>t,$el:t=>t.vnode.el,$data:t=>t.data,$props:t=>t.props,$attrs:t=>t.attrs,$slots:t=>t.slots,$refs:t=>t.refs,$parent:t=>bu(t.parent),$root:t=>bu(t.root),$host:t=>t.ce,$emit:t=>t.emit,$options:t=>gf(t),$forceUpdate:t=>t.f||(t.f=()=>{zu(t.update)}),$nextTick:t=>t.n||(t.n=Ht.bind(t.proxy)),$watch:t=>qb.bind(t)}),bs=(t,e)=>t!==It&&!t.__isScriptSetup&&Rt(t,e),rT={get({_:t},e){if(e==="__v_skip")return!0;const{ctx:n,setupState:a,data:r,props:i,accessCache:s,type:o,appContext:c}=t;if(e[0]!=="$"){const _=s[e];if(_!==void 0)switch(_){case 1:return a[e];case 2:return r[e];case 4:return n[e];case 3:return i[e]}else{if(bs(a,e))return s[e]=1,a[e];if(r!==It&&Rt(r,e))return s[e]=2,r[e];if(Rt(i,e))return s[e]=3,i[e];if(n!==It&&Rt(n,e))return s[e]=4,n[e];Tu&&(s[e]=0)}}const l=Vr[e];let u,d;if(l)return e==="$attrs"&&an(t.attrs,"get",""),l(t);if((u=o.__cssModules)&&(u=u[e]))return u;if(n!==It&&Rt(n,e))return s[e]=4,n[e];if(d=c.config.globalProperties,Rt(d,e))return d[e]},set({_:t},e,n){const{data:a,setupState:r,ctx:i}=t;return bs(r,e)?(r[e]=n,!0):a!==It&&Rt(a,e)?(a[e]=n,!0):Rt(t.props,e)||e[0]==="$"&&e.slice(1)in t?!1:(i[e]=n,!0)},has({_:{data:t,setupState:e,accessCache:n,ctx:a,appContext:r,props:i,type:s}},o){let c;return!!(n[o]||t!==It&&o[0]!=="$"&&Rt(t,o)||bs(e,o)||Rt(i,o)||Rt(a,o)||Rt(Vr,o)||Rt(r.config.globalProperties,o)||(c=s.__cssModules)&&c[o])},defineProperty(t,e,n){return n.get!=null?t._.accessCache[e]=0:Rt(n,"value")&&this.set(t,e,n.value,null),Reflect.defineProperty(t,e,n)}};function Ad(t){return Ye(t)?t.reduce((e,n)=>(e[n]=null,e),{}):t}let Tu=!0;function iT(t){const e=gf(t),n=t.proxy,a=t.ctx;Tu=!1,e.beforeCreate&&Id(e.beforeCreate,t,"bc");const{data:r,computed:i,methods:s,watch:o,provide:c,inject:l,created:u,beforeMount:d,mounted:_,beforeUpdate:m,updated:p,activated:E,deactivated:b,beforeDestroy:I,beforeUnmount:R,destroyed:y,unmounted:L,render:U,renderTracked:h,renderTriggered:N,errorCaptured:C,serverPrefetch:f,expose:A,inheritAttrs:w,components:F,directives:j,filters:_e}=e;if(l&&sT(l,a,null),s)for(const pe in s){const Ce=s[pe];Ze(Ce)&&(a[pe]=Ce.bind(n))}if(r){const pe=r.call(n,n);Ct(pe)&&(t.data=ar(pe))}if(Tu=!0,i)for(const pe in i){const Ce=i[pe],ot=Ze(Ce)?Ce.bind(n,n):Ze(Ce.get)?Ce.get.bind(n,n):jn,lt=!Ze(Ce)&&Ze(Ce.set)?Ce.set.bind(n):jn,at=ue({get:ot,set:lt});Object.defineProperty(a,pe,{enumerable:!0,configurable:!0,get:()=>at.value,set:We=>at.value=We})}if(o)for(const pe in o)mf(o[pe],a,n,pe);if(c){const pe=Ze(c)?c.call(n):c;Reflect.ownKeys(pe).forEach(Ce=>{ZE(Ce,pe[Ce])})}u&&Id(u,t,"c");function oe(pe,Ce){Ye(Ce)?Ce.forEach(ot=>pe(ot.bind(n))):Ce&&pe(Ce.bind(n))}if(oe(Jb,d),oe(Sn,_),oe(jb,m),oe(cf,p),oe(Qb,E),oe(Xb,b),oe(aT,C),oe(nT,h),oe(tT,N),oe(Yn,R),oe(fa,L),oe(eT,f),Ye(A))if(A.length){const pe=t.exposed||(t.exposed={});A.forEach(Ce=>{Object.defineProperty(pe,Ce,{get:()=>n[Ce],set:ot=>n[Ce]=ot,enumerable:!0})})}else t.exposed||(t.exposed={});U&&t.render===jn&&(t.render=U),w!=null&&(t.inheritAttrs=w),F&&(t.components=F),j&&(t.directives=j),f&&of(t)}function sT(t,e,n=jn){Ye(t)&&(t=hu(t));for(const a in t){const r=t[a];let i;Ct(r)?"default"in r?i=ja(r.from||a,r.default,!0):i=ja(r.from||a):i=ja(r),Bt(i)?Object.defineProperty(e,a,{enumerable:!0,configurable:!0,get:()=>i.value,set:s=>i.value=s}):e[a]=i}}function Id(t,e,n){Gn(Ye(t)?t.map(a=>a.bind(e.proxy)):t.bind(e.proxy),e,n)}function mf(t,e,n,a){let r=a.includes(".")?JE(n,a):()=>n[a];if(Gt(t)){const i=e[t];Ze(i)&&st(r,i)}else if(Ze(t))st(r,t.bind(n));else if(Ct(t))if(Ye(t))t.forEach(i=>mf(i,e,n,a));else{const i=Ze(t.handler)?t.handler.bind(n):e[t.handler];Ze(i)&&st(r,i,t)}}function gf(t){const e=t.type,{mixins:n,extends:a}=e,{mixins:r,optionsCache:i,config:{optionMergeStrategies:s}}=t.appContext,o=i.get(e);let c;return o?c=o:!r.length&&!n&&!a?c=e:(c={},r.length&&r.forEach(l=>Di(c,l,s,!0)),Di(c,e,s)),Ct(e)&&i.set(e,c),c}function Di(t,e,n,a=!1){const{mixins:r,extends:i}=e;i&&Di(t,i,n,!0),r&&r.forEach(s=>Di(t,s,n,!0));for(const s in e)if(!(a&&s==="expose")){const o=oT[s]||n&&n[s];t[s]=o?o(t[s],e[s]):e[s]}return t}const oT={data:Dd,props:wd,emits:wd,methods:Fr,computed:Fr,beforeCreate:_n,created:_n,beforeMount:_n,mounted:_n,beforeUpdate:_n,updated:_n,beforeDestroy:_n,beforeUnmount:_n,destroyed:_n,unmounted:_n,activated:_n,deactivated:_n,errorCaptured:_n,serverPrefetch:_n,components:Fr,directives:Fr,watch:cT,provide:Dd,inject:lT};function Dd(t,e){return e?t?function(){return zt(Ze(t)?t.call(this,this):t,Ze(e)?e.call(this,this):e)}:e:t}function lT(t,e){return Fr(hu(t),hu(e))}function hu(t){if(Ye(t)){const e={};for(let n=0;ne==="modelValue"||e==="model-value"?t.modelModifiers:t[`${e}Modifiers`]||t[`${fn(e)}Modifiers`]||t[`${Ma(e)}Modifiers`];function pT(t,e,...n){if(t.isUnmounted)return;const a=t.vnode.props||It;let r=n;const i=e.startsWith("update:"),s=i&&_T(a,e.slice(7));s&&(s.trim&&(r=n.map(u=>Gt(u)?u.trim():u)),s.number&&(r=n.map(Wi)));let o,c=a[o=ps(e)]||a[o=ps(fn(e))];!c&&i&&(c=a[o=ps(Ma(e))]),c&&Gn(c,t,6,r);const l=a[o+"Once"];if(l){if(!t.emitted)t.emitted={};else if(t.emitted[o])return;t.emitted[o]=!0,Gn(l,t,6,r)}}const mT=new WeakMap;function ff(t,e,n=!1){const a=n?mT:e.emitsCache,r=a.get(t);if(r!==void 0)return r;const i=t.emits;let s={},o=!1;if(!Ze(t)){const c=l=>{const u=ff(l,e,!0);u&&(o=!0,zt(s,u))};!n&&e.mixins.length&&e.mixins.forEach(c),t.extends&&c(t.extends),t.mixins&&t.mixins.forEach(c)}return!i&&!o?(Ct(t)&&a.set(t,null),null):(Ye(i)?i.forEach(c=>s[c]=null):zt(s,i),Ct(t)&&a.set(t,s),s)}function ts(t,e){return!t||!$i(e)?!1:(e=e.slice(2).replace(/Once$/,""),Rt(t,e[0].toLowerCase()+e.slice(1))||Rt(t,Ma(e))||Rt(t,e))}function xd(t){const{type:e,vnode:n,proxy:a,withProxy:r,propsOptions:[i],slots:s,attrs:o,emit:c,render:l,renderCache:u,props:d,data:_,setupState:m,ctx:p,inheritAttrs:E}=t,b=Ai(t);let I,R;try{if(n.shapeFlag&4){const L=r||a,U=L;I=Zn(l.call(U,L,u,d,m,_,p)),R=o}else{const L=e;I=Zn(L.length>1?L(d,{attrs:o,slots:s,emit:c}):L(d,null)),R=e.props?o:gT(o)}}catch(L){zr.length=0,Zi(L,t,1),I=ne(gn)}let y=I;if(R&&E!==!1){const L=Object.keys(R),{shapeFlag:U}=y;L.length&&U&7&&(i&&L.some(qi)&&(R=ET(R,i)),y=xa(y,R,!1,!0))}return n.dirs&&(y=xa(y,null,!1,!0),y.dirs=y.dirs?y.dirs.concat(n.dirs):n.dirs),n.transition&&rr(y,n.transition),I=y,Ai(b),I}const gT=t=>{let e;for(const n in t)(n==="class"||n==="style"||$i(n))&&((e||(e={}))[n]=t[n]);return e},ET=(t,e)=>{const n={};for(const a in t)(!qi(a)||!(a.slice(9)in e))&&(n[a]=t[a]);return n};function fT(t,e,n){const{props:a,children:r,component:i}=t,{props:s,children:o,patchFlag:c}=e,l=i.emitsOptions;if(e.dirs||e.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return a?Ld(a,s,l):!!s;if(c&8){const u=e.dynamicProps;for(let d=0;dObject.create(bf),hf=t=>Object.getPrototypeOf(t)===bf;function bT(t,e,n,a=!1){const r={},i=Tf();t.propsDefaults=Object.create(null),vf(t,e,r,i);for(const s in t.propsOptions[0])s in r||(r[s]=void 0);n?t.props=a?r:Nb(r):t.type.props?t.props=r:t.props=i,t.attrs=i}function TT(t,e,n,a){const{props:r,attrs:i,vnode:{patchFlag:s}}=t,o=gt(r),[c]=t.propsOptions;let l=!1;if((a||s>0)&&!(s&16)){if(s&8){const u=t.vnode.dynamicProps;for(let d=0;d{c=!0;const[_,m]=Rf(d,e,!0);zt(s,_),m&&o.push(...m)};!n&&e.mixins.length&&e.mixins.forEach(u),t.extends&&u(t.extends),t.mixins&&t.mixins.forEach(u)}if(!i&&!c)return Ct(t)&&a.set(t,gr),gr;if(Ye(i))for(let u=0;ut==="_"||t==="_ctx"||t==="$stable",Xu=t=>Ye(t)?t.map(Zn):[Zn(t)],vT=(t,e,n)=>{if(e._n)return e;const a=Be((...r)=>Xu(e(...r)),n);return a._c=!1,a},Cf=(t,e,n)=>{const a=t._ctx;for(const r in t){if(Qu(r))continue;const i=t[r];if(Ze(i))e[r]=vT(r,i,a);else if(i!=null){const s=Xu(i);e[r]=()=>s}}},yf=(t,e)=>{const n=Xu(e);t.slots.default=()=>n},Nf=(t,e,n)=>{for(const a in e)(n||!Qu(a))&&(t[a]=e[a])},RT=(t,e,n)=>{const a=t.slots=Tf();if(t.vnode.shapeFlag&32){const r=e._;r?(Nf(a,e,n),n&&vE(a,"_",r,!0)):Cf(e,a)}else e&&yf(t,e)},CT=(t,e,n)=>{const{vnode:a,slots:r}=t;let i=!0,s=It;if(a.shapeFlag&32){const o=e._;o?n&&o===1?i=!1:Nf(r,e,n):(i=!e.$stable,Cf(e,r)),s=e}else e&&(yf(t,e),s={default:1});if(i)for(const o in r)!Qu(o)&&s[o]==null&&delete r[o]},pn=IT;function yT(t){return NT(t)}function NT(t,e){const n=Ki();n.__VUE__=!0;const{insert:a,remove:r,patchProp:i,createElement:s,createText:o,createComment:c,setText:l,setElementText:u,parentNode:d,nextSibling:_,setScopeId:m=jn,insertStaticContent:p}=t,E=(D,P,z,K=null,Z=null,W=null,de=void 0,ae=null,re=!!P.dynamicChildren)=>{if(D===P)return;D&&!Xa(D,P)&&(K=je(D),We(D,Z,W,!0),D=null),P.patchFlag===-2&&(re=!1,P.dynamicChildren=null);const{type:ee,ref:Ne,shapeFlag:ce}=P;switch(ee){case ns:b(D,P,z,K);break;case gn:I(D,P,z,K);break;case hi:D==null&&R(P,z,K,de);break;case Ue:F(D,P,z,K,Z,W,de,ae,re);break;default:ce&1?U(D,P,z,K,Z,W,de,ae,re):ce&6?j(D,P,z,K,Z,W,de,ae,re):(ce&64||ce&128)&&ee.process(D,P,z,K,Z,W,de,ae,re,ut)}Ne!=null&&Z?qr(Ne,D&&D.ref,W,P||D,!P):Ne==null&&D&&D.ref!=null&&qr(D.ref,null,W,D,!0)},b=(D,P,z,K)=>{if(D==null)a(P.el=o(P.children),z,K);else{const Z=P.el=D.el;P.children!==D.children&&l(Z,P.children)}},I=(D,P,z,K)=>{D==null?a(P.el=c(P.children||""),z,K):P.el=D.el},R=(D,P,z,K)=>{[D.el,D.anchor]=p(D.children,P,z,K,D.el,D.anchor)},y=({el:D,anchor:P},z,K)=>{let Z;for(;D&&D!==P;)Z=_(D),a(D,z,K),D=Z;a(P,z,K)},L=({el:D,anchor:P})=>{let z;for(;D&&D!==P;)z=_(D),r(D),D=z;r(P)},U=(D,P,z,K,Z,W,de,ae,re)=>{if(P.type==="svg"?de="svg":P.type==="math"&&(de="mathml"),D==null)h(P,z,K,Z,W,de,ae,re);else{const ee=D.el&&D.el._isVueCE?D.el:null;try{ee&&ee._beginPatch(),f(D,P,Z,W,de,ae,re)}finally{ee&&ee._endPatch()}}},h=(D,P,z,K,Z,W,de,ae)=>{let re,ee;const{props:Ne,shapeFlag:ce,transition:Re,dirs:ye}=D;if(re=D.el=s(D.type,W,Ne&&Ne.is,Ne),ce&8?u(re,D.children):ce&16&&C(D.children,re,null,K,Z,Ts(D,W),de,ae),ye&&Ya(D,null,K,"created"),N(re,D,D.scopeId,de,K),Ne){for(const qe in Ne)qe!=="value"&&!Gr(qe)&&i(re,qe,null,Ne[qe],W,K);"value"in Ne&&i(re,"value",null,Ne.value,W),(ee=Ne.onVnodeBeforeMount)&&Vn(ee,K,D)}ye&&Ya(D,null,K,"beforeMount");const Fe=OT(Z,Re);Fe&&Re.beforeEnter(re),a(re,P,z),((ee=Ne&&Ne.onVnodeMounted)||Fe||ye)&&pn(()=>{try{ee&&Vn(ee,K,D),Fe&&Re.enter(re),ye&&Ya(D,null,K,"mounted")}finally{}},Z)},N=(D,P,z,K,Z)=>{if(z&&m(D,z),K)for(let W=0;W{for(let ee=re;ee{const ae=P.el=D.el;let{patchFlag:re,dynamicChildren:ee,dirs:Ne}=P;re|=D.patchFlag&16;const ce=D.props||It,Re=P.props||It;let ye;if(z&&qa(z,!1),(ye=Re.onVnodeBeforeUpdate)&&Vn(ye,z,P,D),Ne&&Ya(P,D,z,"beforeUpdate"),z&&qa(z,!0),(ce.innerHTML&&Re.innerHTML==null||ce.textContent&&Re.textContent==null)&&u(ae,""),ee?A(D.dynamicChildren,ee,ae,z,K,Ts(P,Z),W):de||Ce(D,P,ae,null,z,K,Ts(P,Z),W,!1),re>0){if(re&16)w(ae,ce,Re,z,Z);else if(re&2&&ce.class!==Re.class&&i(ae,"class",null,Re.class,Z),re&4&&i(ae,"style",ce.style,Re.style,Z),re&8){const Fe=P.dynamicProps;for(let qe=0;qe{ye&&Vn(ye,z,P,D),Ne&&Ya(P,D,z,"updated")},K)},A=(D,P,z,K,Z,W,de)=>{for(let ae=0;ae{if(P!==z){if(P!==It)for(const W in P)!Gr(W)&&!(W in z)&&i(D,W,P[W],null,Z,K);for(const W in z){if(Gr(W))continue;const de=z[W],ae=P[W];de!==ae&&W!=="value"&&i(D,W,ae,de,Z,K)}"value"in z&&i(D,"value",P.value,z.value,Z)}},F=(D,P,z,K,Z,W,de,ae,re)=>{const ee=P.el=D?D.el:o(""),Ne=P.anchor=D?D.anchor:o("");let{patchFlag:ce,dynamicChildren:Re,slotScopeIds:ye}=P;ye&&(ae=ae?ae.concat(ye):ye),D==null?(a(ee,z,K),a(Ne,z,K),C(P.children||[],z,Ne,Z,W,de,ae,re)):ce>0&&ce&64&&Re&&D.dynamicChildren&&D.dynamicChildren.length===Re.length?(A(D.dynamicChildren,Re,z,Z,W,de,ae),(P.key!=null||Z&&P===Z.subTree)&&Zu(D,P,!0)):Ce(D,P,z,Ne,Z,W,de,ae,re)},j=(D,P,z,K,Z,W,de,ae,re)=>{P.slotScopeIds=ae,D==null?P.shapeFlag&512?Z.ctx.activate(P,z,K,de,re):_e(P,z,K,Z,W,de,re):be(D,P,re)},_e=(D,P,z,K,Z,W,de)=>{const ae=D.component=UT(D,K,Z);if(ji(D)&&(ae.ctx.renderer=ut),FT(ae,!1,de),ae.asyncDep){if(Z&&Z.registerDep(ae,oe,de),!D.el){const re=ae.subTree=ne(gn);I(null,re,P,z),D.placeholder=re.el}}else oe(ae,D,P,z,Z,W,de)},be=(D,P,z)=>{const K=P.component=D.component;if(fT(D,P,z))if(K.asyncDep&&!K.asyncResolved){pe(K,P,z);return}else K.next=P,K.update();else P.el=D.el,K.vnode=P},oe=(D,P,z,K,Z,W,de)=>{const ae=()=>{if(D.isMounted){let{next:ce,bu:Re,u:ye,parent:Fe,vnode:qe}=D;{const Mt=Of(D);if(Mt){ce&&(ce.el=qe.el,pe(D,ce,de)),Mt.asyncDep.then(()=>{pn(()=>{D.isUnmounted||ee()},Z)});return}}let Qe=ce,et;qa(D,!1),ce?(ce.el=qe.el,pe(D,ce,de)):ce=qe,Re&&Ti(Re),(et=ce.props&&ce.props.onVnodeBeforeUpdate)&&Vn(et,Fe,ce,qe),qa(D,!0);const dt=xd(D),Lt=D.subTree;D.subTree=dt,E(Lt,dt,d(Lt.el),je(Lt),D,Z,W),ce.el=dt.el,Qe===null&&ST(D,dt.el),ye&&pn(ye,Z),(et=ce.props&&ce.props.onVnodeUpdated)&&pn(()=>Vn(et,Fe,ce,qe),Z)}else{let ce;const{el:Re,props:ye}=P,{bm:Fe,m:qe,parent:Qe,root:et,type:dt}=D,Lt=Hr(P);qa(D,!1),Fe&&Ti(Fe),!Lt&&(ce=ye&&ye.onVnodeBeforeMount)&&Vn(ce,Qe,P),qa(D,!0);{et.ce&&et.ce._hasShadowRoot()&&et.ce._injectChildStyle(dt,D.parent?D.parent.type:void 0);const Mt=D.subTree=xd(D);E(null,Mt,z,K,D,Z,W),P.el=Mt.el}if(qe&&pn(qe,Z),!Lt&&(ce=ye&&ye.onVnodeMounted)){const Mt=P;pn(()=>Vn(ce,Qe,Mt),Z)}(P.shapeFlag&256||Qe&&Hr(Qe.vnode)&&Qe.vnode.shapeFlag&256)&&D.a&&pn(D.a,Z),D.isMounted=!0,P=z=K=null}};D.scope.on();const re=D.effect=new IE(ae);D.scope.off();const ee=D.update=re.run.bind(re),Ne=D.job=re.runIfDirty.bind(re);Ne.i=D,Ne.id=D.uid,re.scheduler=()=>zu(Ne),qa(D,!0),ee()},pe=(D,P,z)=>{P.component=D;const K=D.vnode.props;D.vnode=P,D.next=null,TT(D,P.props,K,z),CT(D,P.children,z),_a(),hd(D),pa()},Ce=(D,P,z,K,Z,W,de,ae,re=!1)=>{const ee=D&&D.children,Ne=D?D.shapeFlag:0,ce=P.children,{patchFlag:Re,shapeFlag:ye}=P;if(Re>0){if(Re&128){lt(ee,ce,z,K,Z,W,de,ae,re);return}else if(Re&256){ot(ee,ce,z,K,Z,W,de,ae,re);return}}ye&8?(Ne&16&&rt(ee,Z,W),ce!==ee&&u(z,ce)):Ne&16?ye&16?lt(ee,ce,z,K,Z,W,de,ae,re):rt(ee,Z,W,!0):(Ne&8&&u(z,""),ye&16&&C(ce,z,K,Z,W,de,ae,re))},ot=(D,P,z,K,Z,W,de,ae,re)=>{D=D||gr,P=P||gr;const ee=D.length,Ne=P.length,ce=Math.min(ee,Ne);let Re;for(Re=0;ReNe?rt(D,Z,W,!0,!1,ce):C(P,z,K,Z,W,de,ae,re,ce)},lt=(D,P,z,K,Z,W,de,ae,re)=>{let ee=0;const Ne=P.length;let ce=D.length-1,Re=Ne-1;for(;ee<=ce&&ee<=Re;){const ye=D[ee],Fe=P[ee]=re?ia(P[ee]):Zn(P[ee]);if(Xa(ye,Fe))E(ye,Fe,z,null,Z,W,de,ae,re);else break;ee++}for(;ee<=ce&&ee<=Re;){const ye=D[ce],Fe=P[Re]=re?ia(P[Re]):Zn(P[Re]);if(Xa(ye,Fe))E(ye,Fe,z,null,Z,W,de,ae,re);else break;ce--,Re--}if(ee>ce){if(ee<=Re){const ye=Re+1,Fe=yeRe)for(;ee<=ce;)We(D[ee],Z,W,!0),ee++;else{const ye=ee,Fe=ee,qe=new Map;for(ee=Fe;ee<=Re;ee++){const vt=P[ee]=re?ia(P[ee]):Zn(P[ee]);vt.key!=null&&qe.set(vt.key,ee)}let Qe,et=0;const dt=Re-Fe+1;let Lt=!1,Mt=0;const Vt=new Array(dt);for(ee=0;ee=dt){We(vt,Z,W,!0);continue}let O;if(vt.key!=null)O=qe.get(vt.key);else for(Qe=Fe;Qe<=Re;Qe++)if(Vt[Qe-Fe]===0&&Xa(vt,P[Qe])){O=Qe;break}O===void 0?We(vt,Z,W,!0):(Vt[O-Fe]=ee+1,O>=Mt?Mt=O:Lt=!0,E(vt,P[O],z,null,Z,W,de,ae,re),et++)}const Ut=Lt?AT(Vt):gr;for(Qe=Ut.length-1,ee=dt-1;ee>=0;ee--){const vt=Fe+ee,O=P[vt],G=P[vt+1],Q=vt+1{const{el:W,type:de,transition:ae,children:re,shapeFlag:ee}=D;if(ee&6){at(D.component.subTree,P,z,K);return}if(ee&128){D.suspense.move(P,z,K);return}if(ee&64){de.move(D,P,z,ut);return}if(de===Ue){a(W,P,z);for(let ce=0;ceae.enter(W),Z);else{const{leave:ce,delayLeave:Re,afterLeave:ye}=ae,Fe=()=>{D.ctx.isUnmounted?r(W):a(W,P,z)},qe=()=>{W._isLeaving&&W[Qn](!0),ce(W,()=>{Fe(),ye&&ye()})};Re?Re(W,Fe,qe):qe()}else a(W,P,z)},We=(D,P,z,K=!1,Z=!1)=>{const{type:W,props:de,ref:ae,children:re,dynamicChildren:ee,shapeFlag:Ne,patchFlag:ce,dirs:Re,cacheIndex:ye,memo:Fe}=D;if(ce===-2&&(Z=!1),ae!=null&&(_a(),qr(ae,null,z,D,!0),pa()),ye!=null&&(P.renderCache[ye]=void 0),Ne&256){P.ctx.deactivate(D);return}const qe=Ne&1&&Re,Qe=!Hr(D);let et;if(Qe&&(et=de&&de.onVnodeBeforeUnmount)&&Vn(et,P,D),Ne&6)ke(D.component,z,K);else{if(Ne&128){D.suspense.unmount(z,K);return}qe&&Ya(D,null,P,"beforeUnmount"),Ne&64?D.type.remove(D,P,z,ut,K):ee&&!ee.hasOnce&&(W!==Ue||ce>0&&ce&64)?rt(ee,P,z,!1,!0):(W===Ue&&ce&384||!Z&&Ne&16)&&rt(re,P,z),K&&Ae(D)}const dt=Fe!=null&&ye==null;(Qe&&(et=de&&de.onVnodeUnmounted)||qe||dt)&&pn(()=>{et&&Vn(et,P,D),qe&&Ya(D,null,P,"unmounted"),dt&&(D.el=null)},z)},Ae=D=>{const{type:P,el:z,anchor:K,transition:Z}=D;if(P===Ue){He(z,K);return}if(P===hi){L(D);return}const W=()=>{r(z),Z&&!Z.persisted&&Z.afterLeave&&Z.afterLeave()};if(D.shapeFlag&1&&Z&&!Z.persisted){const{leave:de,delayLeave:ae}=Z,re=()=>de(z,W);ae?ae(D.el,W,re):re()}else W()},He=(D,P)=>{let z;for(;D!==P;)z=_(D),r(D),D=z;r(P)},ke=(D,P,z)=>{const{bum:K,scope:Z,job:W,subTree:de,um:ae,m:re,a:ee}=D;kd(re),kd(ee),K&&Ti(K),Z.stop(),W&&(W.flags|=8,We(de,D,P,z)),ae&&pn(ae,P),pn(()=>{D.isUnmounted=!0},P)},rt=(D,P,z,K=!1,Z=!1,W=0)=>{for(let de=W;de{if(D.shapeFlag&6)return je(D.component.subTree);if(D.shapeFlag&128)return D.suspense.next();const P=_(D.anchor||D.el),z=P&&P[jE];return z?_(z):P};let Ke=!1;const Et=(D,P,z)=>{let K;D==null?P._vnode&&(We(P._vnode,null,null,!0),K=P._vnode.component):E(P._vnode||null,D,P,null,null,null,z),P._vnode=D,Ke||(Ke=!0,hd(K),KE(),Ke=!1)},ut={p:E,um:We,m:at,r:Ae,mt:_e,mc:C,pc:Ce,pbc:A,n:je,o:t};return{render:Et,hydrate:void 0,createApp:dT(Et)}}function Ts({type:t,props:e},n){return n==="svg"&&t==="foreignObject"||n==="mathml"&&t==="annotation-xml"&&e&&e.encoding&&e.encoding.includes("html")?void 0:n}function qa({effect:t,job:e},n){n?(t.flags|=32,e.flags|=4):(t.flags&=-33,e.flags&=-5)}function OT(t,e){return(!t||t&&!t.pendingBranch)&&e&&!e.persisted}function Zu(t,e,n=!1){const a=t.children,r=e.children;if(Ye(a)&&Ye(r))for(let i=0;i>1,t[n[o]]0&&(e[a]=n[i-1]),n[i]=a)}}for(i=n.length,s=n[i-1];i-- >0;)n[i]=s,s=e[s];return n}function Of(t){const e=t.subTree.component;if(e)return e.asyncDep&&!e.asyncResolved?e:Of(e)}function kd(t){if(t)for(let e=0;et.__isSuspense;function IT(t,e){e&&e.pendingBranch?Ye(t)?e.effects.push(...t):e.effects.push(t):Fb(t)}const Ue=Symbol.for("v-fgt"),ns=Symbol.for("v-txt"),gn=Symbol.for("v-cmt"),hi=Symbol.for("v-stc"),zr=[];let Nn=null;function v(t=!1){zr.push(Nn=t?null:[])}function DT(){zr.pop(),Nn=zr[zr.length-1]||null}let ti=1;function wi(t,e=!1){ti+=t,t<0&&Nn&&e&&(Nn.hasOnce=!0)}function Df(t){return t.dynamicChildren=ti>0?Nn||gr:null,DT(),ti>0&&Nn&&Nn.push(t),t}function x(t,e,n,a,r,i){return Df(g(t,e,n,a,r,i,!0))}function ze(t,e,n,a,r){return Df(ne(t,e,n,a,r,!0))}function xi(t){return t?t.__v_isVNode===!0:!1}function Xa(t,e){return t.type===e.type&&t.key===e.key}const wf=({key:t})=>t??null,vi=({ref:t,ref_key:e,ref_for:n})=>(typeof t=="number"&&(t=""+t),t!=null?Gt(t)||Bt(t)||Ze(t)?{i:yn,r:t,k:e,f:!!n}:t:null);function g(t,e=null,n=null,a=0,r=null,i=t===Ue?0:1,s=!1,o=!1){const c={__v_isVNode:!0,__v_skip:!0,type:t,props:e,key:e&&wf(e),ref:e&&vi(e),scopeId:XE,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:i,patchFlag:a,dynamicProps:r,dynamicChildren:null,appContext:null,ctx:yn};return o?(Ju(c,n),i&128&&t.normalize(c)):n&&(c.shapeFlag|=Gt(n)?8:16),ti>0&&!s&&Nn&&(c.patchFlag>0||i&6)&&c.patchFlag!==32&&Nn.push(c),c}const ne=wT;function wT(t,e=null,n=null,a=0,r=null,i=!1){if((!t||t===df)&&(t=gn),xi(t)){const o=xa(t,e,!0);return n&&Ju(o,n),ti>0&&!i&&Nn&&(o.shapeFlag&6?Nn[Nn.indexOf(t)]=o:Nn.push(o)),o.patchFlag=-2,o}if(qT(t)&&(t=t.__vccOpts),e){e=xT(e);let{class:o,style:c}=e;o&&!Gt(o)&&(e.class=Ge(o)),Ct(c)&&(Xi(c)&&!Ye(c)&&(c=zt({},c)),e.style=Da(c))}const s=Gt(t)?1:If(t)?128:ef(t)?64:Ct(t)?4:Ze(t)?2:0;return g(t,e,n,a,r,s,i,!0)}function xT(t){return t?Xi(t)||hf(t)?zt({},t):t:null}function xa(t,e,n=!1,a=!1){const{props:r,ref:i,patchFlag:s,children:o,transition:c}=t,l=e?MT(r||{},e):r,u={__v_isVNode:!0,__v_skip:!0,type:t.type,props:l,key:l&&wf(l),ref:e&&e.ref?n&&i?Ye(i)?i.concat(vi(e)):[i,vi(e)]:vi(e):i,scopeId:t.scopeId,slotScopeIds:t.slotScopeIds,children:o,target:t.target,targetStart:t.targetStart,targetAnchor:t.targetAnchor,staticCount:t.staticCount,shapeFlag:t.shapeFlag,patchFlag:e&&t.type!==Ue?s===-1?16:s|16:s,dynamicProps:t.dynamicProps,dynamicChildren:t.dynamicChildren,appContext:t.appContext,dirs:t.dirs,transition:c,component:t.component,suspense:t.suspense,ssContent:t.ssContent&&xa(t.ssContent),ssFallback:t.ssFallback&&xa(t.ssFallback),placeholder:t.placeholder,el:t.el,anchor:t.anchor,ctx:t.ctx,ce:t.ce};return c&&a&&rr(u,c.clone(u)),u}function $e(t=" ",e=0){return ne(ns,null,t,e)}function LT(t,e){const n=ne(hi,null,t);return n.staticCount=e,n}function J(t="",e=!1){return e?(v(),ze(gn,null,t)):ne(gn,null,t)}function Zn(t){return t==null||typeof t=="boolean"?ne(gn):Ye(t)?ne(Ue,null,t.slice()):xi(t)?ia(t):ne(ns,null,String(t))}function ia(t){return t.el===null&&t.patchFlag!==-1||t.memo?t:xa(t)}function Ju(t,e){let n=0;const{shapeFlag:a}=t;if(e==null)e=null;else if(Ye(e))n=16;else if(typeof e=="object")if(a&65){const r=e.default;r&&(r._c&&(r._d=!1),Ju(t,r()),r._c&&(r._d=!0));return}else{n=32;const r=e._;!r&&!hf(e)?e._ctx=yn:r===3&&yn&&(yn.slots._===1?e._=1:(e._=2,t.patchFlag|=1024))}else Ze(e)?(e={default:e,_ctx:yn},n=32):(e=String(e),a&64?(n=16,e=[$e(e)]):n=8);t.children=e,t.shapeFlag|=n}function MT(...t){const e={};for(let n=0;nrn||yn;let Li,Ru;{const t=Ki(),e=(n,a)=>{let r;return(r=t[n])||(r=t[n]=[]),r.push(a),i=>{r.length>1?r.forEach(s=>s(i)):r[0](i)}};Li=e("__VUE_INSTANCE_SETTERS__",n=>rn=n),Ru=e("__VUE_SSR_SETTERS__",n=>ni=n)}const oi=t=>{const e=rn;return Li(t),t.scope.on(),()=>{t.scope.off(),Li(e)}},Pd=()=>{rn&&rn.scope.off(),Li(null)};function xf(t){return t.vnode.shapeFlag&4}let ni=!1;function FT(t,e=!1,n=!1){e&&Ru(e);const{props:a,children:r}=t.vnode,i=xf(t);bT(t,a,i,e),RT(t,r,n||e);const s=i?BT(t,e):void 0;return e&&Ru(!1),s}function BT(t,e){const n=t.type;t.accessCache=Object.create(null),t.proxy=new Proxy(t.ctx,rT);const{setup:a}=n;if(a){_a();const r=t.setupContext=a.length>1?YT(t):null,i=oi(t),s=si(a,t,0,[t.props,r]),o=bE(s);if(pa(),i(),(o||t.sp)&&!Hr(t)&&of(t),o){if(s.then(Pd,Pd),e)return s.then(c=>{Ud(t,c)}).catch(c=>{Zi(c,t,0)});t.asyncDep=s}else Ud(t,s)}else Lf(t)}function Ud(t,e,n){Ze(e)?t.type.__ssrInlineRender?t.ssrRender=e:t.render=e:Ct(e)&&(t.setupState=VE(e)),Lf(t)}function Lf(t,e,n){const a=t.type;t.render||(t.render=a.render||jn);{const r=oi(t);_a();try{iT(t)}finally{pa(),r()}}}const GT={get(t,e){return an(t,"get",""),t[e]}};function YT(t){const e=n=>{t.exposed=n||{}};return{attrs:new Proxy(t.attrs,GT),slots:t.slots,emit:t.emit,expose:e}}function as(t){return t.exposed?t.exposeProxy||(t.exposeProxy=new Proxy(VE(Jr(t.exposed)),{get(e,n){if(n in e)return e[n];if(n in Vr)return Vr[n](t)},has(e,n){return n in e||n in Vr}})):t.proxy}function $T(t,e=!0){return Ze(t)?t.displayName||t.name:t.name||e&&t.__name}function qT(t){return Ze(t)&&"__vccOpts"in t}const ue=(t,e)=>Lb(t,e,ni);function T(t,e,n){try{wi(-1);const a=arguments.length;return a===2?Ct(e)&&!Ye(e)?xi(e)?ne(t,null,[e]):ne(t,e):ne(t,null,e):(a>3?n=Array.prototype.slice.call(arguments,2):a===3&&xi(n)&&(n=[n]),ne(t,e,n))}finally{wi(1)}}const HT="3.5.32";/** +* @vue/runtime-dom v3.5.32 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/let Cu;const Fd=typeof window<"u"&&window.trustedTypes;if(Fd)try{Cu=Fd.createPolicy("vue",{createHTML:t=>t})}catch{}const Mf=Cu?t=>Cu.createHTML(t):t=>t,VT="http://www.w3.org/2000/svg",zT="http://www.w3.org/1998/Math/MathML",ra=typeof document<"u"?document:null,Bd=ra&&ra.createElement("template"),WT={insert:(t,e,n)=>{e.insertBefore(t,n||null)},remove:t=>{const e=t.parentNode;e&&e.removeChild(t)},createElement:(t,e,n,a)=>{const r=e==="svg"?ra.createElementNS(VT,t):e==="mathml"?ra.createElementNS(zT,t):n?ra.createElement(t,{is:n}):ra.createElement(t);return t==="select"&&a&&a.multiple!=null&&r.setAttribute("multiple",a.multiple),r},createText:t=>ra.createTextNode(t),createComment:t=>ra.createComment(t),setText:(t,e)=>{t.nodeValue=e},setElementText:(t,e)=>{t.textContent=e},parentNode:t=>t.parentNode,nextSibling:t=>t.nextSibling,querySelector:t=>ra.querySelector(t),setScopeId(t,e){t.setAttribute(e,"")},insertStaticContent(t,e,n,a,r,i){const s=n?n.previousSibling:e.lastChild;if(r&&(r===i||r.nextSibling))for(;e.insertBefore(r.cloneNode(!0),n),!(r===i||!(r=r.nextSibling)););else{Bd.innerHTML=Mf(a==="svg"?`${t}`:a==="mathml"?`${t}`:t);const o=Bd.content;if(a==="svg"||a==="mathml"){const c=o.firstChild;for(;c.firstChild;)o.appendChild(c.firstChild);o.removeChild(c)}e.insertBefore(o,n)}return[s?s.nextSibling:e.firstChild,n?n.previousSibling:e.lastChild]}},Ca="transition",wr="animation",Tr=Symbol("_vtc"),kf={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Pf=zt({},nf,kf),KT=t=>(t.displayName="Transition",t.props=Pf,t),hr=KT((t,{slots:e})=>T(Kb,Uf(t),e)),Ha=(t,e=[])=>{Ye(t)?t.forEach(n=>n(...e)):t&&t(...e)},Gd=t=>t?Ye(t)?t.some(e=>e.length>1):t.length>1:!1;function Uf(t){const e={};for(const F in t)F in kf||(e[F]=t[F]);if(t.css===!1)return e;const{name:n="v",type:a,duration:r,enterFromClass:i=`${n}-enter-from`,enterActiveClass:s=`${n}-enter-active`,enterToClass:o=`${n}-enter-to`,appearFromClass:c=i,appearActiveClass:l=s,appearToClass:u=o,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:_=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=t,p=QT(r),E=p&&p[0],b=p&&p[1],{onBeforeEnter:I,onEnter:R,onEnterCancelled:y,onLeave:L,onLeaveCancelled:U,onBeforeAppear:h=I,onAppear:N=R,onAppearCancelled:C=y}=e,f=(F,j,_e,be)=>{F._enterCancelled=be,Oa(F,j?u:o),Oa(F,j?l:s),_e&&_e()},A=(F,j)=>{F._isLeaving=!1,Oa(F,d),Oa(F,m),Oa(F,_),j&&j()},w=F=>(j,_e)=>{const be=F?N:R,oe=()=>f(j,F,_e);Ha(be,[j,oe]),Yd(()=>{Oa(j,F?c:i),zn(j,F?u:o),Gd(be)||$d(j,a,E,oe)})};return zt(e,{onBeforeEnter(F){Ha(I,[F]),zn(F,i),zn(F,s)},onBeforeAppear(F){Ha(h,[F]),zn(F,c),zn(F,l)},onEnter:w(!1),onAppear:w(!0),onLeave(F,j){F._isLeaving=!0;const _e=()=>A(F,j);zn(F,d),F._enterCancelled?(zn(F,_),yu(F)):(yu(F),zn(F,_)),Yd(()=>{F._isLeaving&&(Oa(F,d),zn(F,m),Gd(L)||$d(F,a,b,_e))}),Ha(L,[F,_e])},onEnterCancelled(F){f(F,!1,void 0,!0),Ha(y,[F])},onAppearCancelled(F){f(F,!0,void 0,!0),Ha(C,[F])},onLeaveCancelled(F){A(F),Ha(U,[F])}})}function QT(t){if(t==null)return null;if(Ct(t))return[hs(t.enter),hs(t.leave)];{const e=hs(t);return[e,e]}}function hs(t){return JS(t)}function zn(t,e){e.split(/\s+/).forEach(n=>n&&t.classList.add(n)),(t[Tr]||(t[Tr]=new Set)).add(e)}function Oa(t,e){e.split(/\s+/).forEach(a=>a&&t.classList.remove(a));const n=t[Tr];n&&(n.delete(e),n.size||(t[Tr]=void 0))}function Yd(t){requestAnimationFrame(()=>{requestAnimationFrame(t)})}let XT=0;function $d(t,e,n,a){const r=t._endId=++XT,i=()=>{r===t._endId&&a()};if(n!=null)return setTimeout(i,n);const{type:s,timeout:o,propCount:c}=Ff(t,e);if(!s)return a();const l=s+"end";let u=0;const d=()=>{t.removeEventListener(l,_),i()},_=m=>{m.target===t&&++u>=c&&d()};setTimeout(()=>{u(n[p]||"").split(", "),r=a(`${Ca}Delay`),i=a(`${Ca}Duration`),s=qd(r,i),o=a(`${wr}Delay`),c=a(`${wr}Duration`),l=qd(o,c);let u=null,d=0,_=0;e===Ca?s>0&&(u=Ca,d=s,_=i.length):e===wr?l>0&&(u=wr,d=l,_=c.length):(d=Math.max(s,l),u=d>0?s>l?Ca:wr:null,_=u?u===Ca?i.length:c.length:0);const m=u===Ca&&/\b(?:transform|all)(?:,|$)/.test(a(`${Ca}Property`).toString());return{type:u,timeout:d,propCount:_,hasTransform:m}}function qd(t,e){for(;t.lengthHd(n)+Hd(t[a])))}function Hd(t){return t==="auto"?0:Number(t.slice(0,-1).replace(",","."))*1e3}function yu(t){return(t?t.ownerDocument:document).body.offsetHeight}function ZT(t,e,n){const a=t[Tr];a&&(e=(e?[e,...a]:[...a]).join(" ")),e==null?t.removeAttribute("class"):n?t.setAttribute("class",e):t.className=e}const Vd=Symbol("_vod"),JT=Symbol("_vsh"),jT=Symbol(""),eh=/(?:^|;)\s*display\s*:/;function th(t,e,n){const a=t.style,r=Gt(n);let i=!1;if(n&&!r){if(e)if(Gt(e))for(const s of e.split(";")){const o=s.slice(0,s.indexOf(":")).trim();n[o]==null&&Ri(a,o,"")}else for(const s in e)n[s]==null&&Ri(a,s,"");for(const s in n)s==="display"&&(i=!0),Ri(a,s,n[s])}else if(r){if(e!==n){const s=a[jT];s&&(n+=";"+s),a.cssText=n,i=eh.test(n)}}else e&&t.removeAttribute("style");Vd in t&&(t[Vd]=i?a.display:"",t[JT]&&(a.display="none"))}const zd=/\s*!important$/;function Ri(t,e,n){if(Ye(n))n.forEach(a=>Ri(t,e,a));else if(n==null&&(n=""),e.startsWith("--"))t.setProperty(e,n);else{const a=nh(t,e);zd.test(n)?t.setProperty(Ma(a),n.replace(zd,""),"important"):t[a]=n}}const Wd=["Webkit","Moz","ms"],vs={};function nh(t,e){const n=vs[e];if(n)return n;let a=fn(e);if(a!=="filter"&&a in t)return vs[e]=a;a=zi(a);for(let r=0;rRs||(sh.then(()=>Rs=0),Rs=Date.now());function lh(t,e){const n=a=>{if(!a._vts)a._vts=Date.now();else if(a._vts<=n.attached)return;Gn(ch(a,n.value),e,5,[a])};return n.value=t,n.attached=oh(),n}function ch(t,e){if(Ye(e)){const n=t.stopImmediatePropagation;return t.stopImmediatePropagation=()=>{n.call(t),t._stopped=!0},e.map(a=>r=>!r._stopped&&a&&a(r))}else return e}const jd=t=>t.charCodeAt(0)===111&&t.charCodeAt(1)===110&&t.charCodeAt(2)>96&&t.charCodeAt(2)<123,uh=(t,e,n,a,r,i)=>{const s=r==="svg";e==="class"?ZT(t,a,s):e==="style"?th(t,n,a):$i(e)?qi(e)||rh(t,e,n,a,i):(e[0]==="."?(e=e.slice(1),!0):e[0]==="^"?(e=e.slice(1),!1):dh(t,e,a,s))?(Xd(t,e,a),!t.tagName.includes("-")&&(e==="value"||e==="checked"||e==="selected")&&Qd(t,e,a,s,i,e!=="value")):t._isVueCE&&(_h(t,e)||t._def.__asyncLoader&&(/[A-Z]/.test(e)||!Gt(a)))?Xd(t,fn(e),a,i,e):(e==="true-value"?t._trueValue=a:e==="false-value"&&(t._falseValue=a),Qd(t,e,a,s))};function dh(t,e,n,a){if(a)return!!(e==="innerHTML"||e==="textContent"||e in t&&jd(e)&&Ze(n));if(e==="spellcheck"||e==="draggable"||e==="translate"||e==="autocorrect"||e==="sandbox"&&t.tagName==="IFRAME"||e==="form"||e==="list"&&t.tagName==="INPUT"||e==="type"&&t.tagName==="TEXTAREA")return!1;if(e==="width"||e==="height"){const r=t.tagName;if(r==="IMG"||r==="VIDEO"||r==="CANVAS"||r==="SOURCE")return!1}return jd(e)&&Gt(n)?!1:e in t}function _h(t,e){const n=t._def.props;if(!n)return!1;const a=fn(e);return Array.isArray(n)?n.some(r=>fn(r)===a):Object.keys(n).some(r=>fn(r)===a)}const Bf=new WeakMap,Gf=new WeakMap,Mi=Symbol("_moveCb"),e_=Symbol("_enterCb"),ph=t=>(delete t.props.mode,t),mh=ph({name:"TransitionGroup",props:zt({},Pf,{tag:String,moveClass:String}),setup(t,{slots:e}){const n=yr(),a=tf();let r,i;return cf(()=>{if(!r.length)return;const s=t.moveClass||`${t.name||"v"}-move`;if(!bh(r[0].el,n.vnode.el,s)){r=[];return}r.forEach(Eh),r.forEach(fh);const o=r.filter(Sh);yu(n.vnode.el),o.forEach(c=>{const l=c.el,u=l.style;zn(l,s),u.transform=u.webkitTransform=u.transitionDuration="";const d=l[Mi]=_=>{_&&_.target!==l||(!_||_.propertyName.endsWith("transform"))&&(l.removeEventListener("transitionend",d),l[Mi]=null,Oa(l,s))};l.addEventListener("transitionend",d)}),r=[]}),()=>{const s=gt(t),o=Uf(s);let c=s.tag||Ue;if(r=[],i)for(let l=0;l{o.split(/\s+/).forEach(c=>c&&a.classList.remove(c))}),n.split(/\s+/).forEach(o=>o&&a.classList.add(o)),a.style.display="none";const i=e.nodeType===1?e:e.parentNode;i.appendChild(a);const{hasTransform:s}=Ff(a);return i.removeChild(a),s}const La=t=>{const e=t.props["onUpdate:modelValue"]||!1;return Ye(e)?n=>Ti(e,n):e};function Th(t){t.target.composing=!0}function t_(t){const e=t.target;e.composing&&(e.composing=!1,e.dispatchEvent(new Event("input")))}const xn=Symbol("_assign");function n_(t,e,n){return e&&(t=t.trim()),n&&(t=Wi(t)),t}const ai={created(t,{modifiers:{lazy:e,trim:n,number:a}},r){t[xn]=La(r);const i=a||r.props&&r.props.type==="number";la(t,e?"change":"input",s=>{s.target.composing||t[xn](n_(t.value,n,i))}),(n||i)&&la(t,"change",()=>{t.value=n_(t.value,n,i)}),e||(la(t,"compositionstart",Th),la(t,"compositionend",t_),la(t,"change",t_))},mounted(t,{value:e}){t.value=e??""},beforeUpdate(t,{value:e,oldValue:n,modifiers:{lazy:a,trim:r,number:i}},s){if(t[xn]=La(s),t.composing)return;const o=(i||t.type==="number")&&!/^0\d/.test(t.value)?Wi(t.value):t.value,c=e??"";if(o===c)return;const l=t.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===t&&t.type!=="range"&&(a&&e===n||r&&t.value.trim()===c)||(t.value=c)}},$f={deep:!0,created(t,e,n){t[xn]=La(n),la(t,"change",()=>{const a=t._modelValue,r=vr(t),i=t.checked,s=t[xn];if(Ye(a)){const o=Bu(a,r),c=o!==-1;if(i&&!c)s(a.concat(r));else if(!i&&c){const l=[...a];l.splice(o,1),s(l)}}else if(Cr(a)){const o=new Set(a);i?o.add(r):o.delete(r),s(o)}else s(qf(t,i))})},mounted:a_,beforeUpdate(t,e,n){t[xn]=La(n),a_(t,e,n)}};function a_(t,{value:e,oldValue:n},a){t._modelValue=e;let r;if(Ye(e))r=Bu(e,a.props.value)>-1;else if(Cr(e))r=e.has(a.props.value);else{if(e===n)return;r=wa(e,qf(t,!0))}t.checked!==r&&(t.checked=r)}const hh={created(t,{value:e},n){t.checked=wa(e,n.props.value),t[xn]=La(n),la(t,"change",()=>{t[xn](vr(t))})},beforeUpdate(t,{value:e,oldValue:n},a){t[xn]=La(a),e!==n&&(t.checked=wa(e,a.props.value))}},Nu={deep:!0,created(t,{value:e,modifiers:{number:n}},a){const r=Cr(e);la(t,"change",()=>{const i=Array.prototype.filter.call(t.options,s=>s.selected).map(s=>n?Wi(vr(s)):vr(s));t[xn](t.multiple?r?new Set(i):i:i[0]),t._assigning=!0,Ht(()=>{t._assigning=!1})}),t[xn]=La(a)},mounted(t,{value:e}){r_(t,e)},beforeUpdate(t,e,n){t[xn]=La(n)},updated(t,{value:e}){t._assigning||r_(t,e)}};function r_(t,e){const n=t.multiple,a=Ye(e);if(!(n&&!a&&!Cr(e))){for(let r=0,i=t.options.length;rString(l)===String(o)):s.selected=Bu(e,o)>-1}else s.selected=e.has(o);else if(wa(vr(s),e)){t.selectedIndex!==r&&(t.selectedIndex=r);return}}!n&&t.selectedIndex!==-1&&(t.selectedIndex=-1)}}function vr(t){return"_value"in t?t._value:t.value}function qf(t,e){const n=e?"_trueValue":"_falseValue";return n in t?t[n]:e}const vh={created(t,e,n){Ei(t,e,n,null,"created")},mounted(t,e,n){Ei(t,e,n,null,"mounted")},beforeUpdate(t,e,n,a){Ei(t,e,n,a,"beforeUpdate")},updated(t,e,n,a){Ei(t,e,n,a,"updated")}};function Rh(t,e){switch(t){case"SELECT":return Nu;case"TEXTAREA":return ai;default:switch(e){case"checkbox":return $f;case"radio":return hh;default:return ai}}}function Ei(t,e,n,a,r){const s=Rh(t.tagName,n.props&&n.props.type)[r];s&&s(t,e,n,a)}const Ch=["ctrl","shift","alt","meta"],yh={stop:t=>t.stopPropagation(),prevent:t=>t.preventDefault(),self:t=>t.target!==t.currentTarget,ctrl:t=>!t.ctrlKey,shift:t=>!t.shiftKey,alt:t=>!t.altKey,meta:t=>!t.metaKey,left:t=>"button"in t&&t.button!==0,middle:t=>"button"in t&&t.button!==1,right:t=>"button"in t&&t.button!==2,exact:(t,e)=>Ch.some(n=>t[`${n}Key`]&&!e.includes(n))},ga=(t,e)=>{if(!t)return t;const n=t._withMods||(t._withMods={}),a=e.join(".");return n[a]||(n[a]=((r,...i)=>{for(let s=0;s{const n=t._withKeys||(t._withKeys={}),a=e.join(".");return n[a]||(n[a]=(r=>{if(!("key"in r))return;const i=Ma(r.key);if(e.some(s=>s===i||Nh[s]===i))return t(r)}))},Oh=zt({patchProp:uh},WT);let i_;function Ah(){return i_||(i_=yT(Oh))}const Ih=((...t)=>{const e=Ah().createApp(...t),{mount:n}=e;return e.mount=a=>{const r=wh(a);if(!r)return;const i=e._component;!Ze(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent="");const s=n(r,!1,Dh(r));return r instanceof Element&&(r.removeAttribute("v-cloak"),r.setAttribute("data-v-app","")),s},e});function Dh(t){if(t instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&t instanceof MathMLElement)return"mathml"}function wh(t){return Gt(t)?document.querySelector(t):t}/*! + * pinia v3.0.4 + * (c) 2025 Eduardo San Martin Morote + * @license MIT + */let Hf;const rs=t=>Hf=t,Vf=Symbol();function Ou(t){return t&&typeof t=="object"&&Object.prototype.toString.call(t)==="[object Object]"&&typeof t.toJSON!="function"}var Wr;(function(t){t.direct="direct",t.patchObject="patch object",t.patchFunction="patch function"})(Wr||(Wr={}));function xh(){const t=OE(!0),e=t.run(()=>Y({}));let n=[],a=[];const r=Jr({install(i){rs(r),r._a=i,i.provide(Vf,r),i.config.globalProperties.$pinia=r,a.forEach(s=>n.push(s)),a=[]},use(i){return this._a?n.push(i):a.push(i),this},_p:n,_a:null,_e:t,_s:new Map,state:e});return r}const zf=()=>{};function s_(t,e,n,a=zf){t.add(e);const r=()=>{t.delete(e)&&a()};return!n&&AE()&&sb(r),r}function dr(t,...e){t.forEach(n=>{n(...e)})}const Lh=t=>t(),o_=Symbol(),Cs=Symbol();function Au(t,e){t instanceof Map&&e instanceof Map?e.forEach((n,a)=>t.set(a,n)):t instanceof Set&&e instanceof Set&&e.forEach(t.add,t);for(const n in e){if(!e.hasOwnProperty(n))continue;const a=e[n],r=t[n];Ou(r)&&Ou(a)&&t.hasOwnProperty(n)&&!Bt(a)&&!da(a)?t[n]=Au(r,a):t[n]=a}return t}const Mh=Symbol();function kh(t){return!Ou(t)||!Object.prototype.hasOwnProperty.call(t,Mh)}const{assign:Aa}=Object;function Ph(t){return!!(Bt(t)&&t.effect)}function Uh(t,e,n,a){const{state:r,actions:i,getters:s}=e,o=n.state.value[t];let c;function l(){o||(n.state.value[t]=r?r():{});const u=Ib(n.state.value[t]);return Aa(u,i,Object.keys(s||{}).reduce((d,_)=>(d[_]=Jr(ue(()=>{rs(n);const m=n._s.get(t);return s[_].call(m,m)})),d),{}))}return c=Wf(t,l,e,n,a,!0),c}function Wf(t,e,n={},a,r,i){let s;const o=Aa({actions:{}},n),c={deep:!0};let l,u,d=new Set,_=new Set,m;const p=a.state.value[t];!i&&!p&&(a.state.value[t]={});let E;function b(C){let f;l=u=!1,typeof C=="function"?(C(a.state.value[t]),f={type:Wr.patchFunction,storeId:t,events:m}):(Au(a.state.value[t],C),f={type:Wr.patchObject,payload:C,storeId:t,events:m});const A=E=Symbol();Ht().then(()=>{E===A&&(l=!0)}),u=!0,dr(d,f,a.state.value[t])}const I=i?function(){const{state:f}=n,A=f?f():{};this.$patch(w=>{Aa(w,A)})}:zf;function R(){s.stop(),d.clear(),_.clear(),a._s.delete(t)}const y=(C,f="")=>{if(o_ in C)return C[Cs]=f,C;const A=function(){rs(a);const w=Array.from(arguments),F=new Set,j=new Set;function _e(pe){F.add(pe)}function be(pe){j.add(pe)}dr(_,{args:w,name:A[Cs],store:U,after:_e,onError:be});let oe;try{oe=C.apply(this&&this.$id===t?this:U,w)}catch(pe){throw dr(j,pe),pe}return oe instanceof Promise?oe.then(pe=>(dr(F,pe),pe)).catch(pe=>(dr(j,pe),Promise.reject(pe))):(dr(F,oe),oe)};return A[o_]=!0,A[Cs]=f,A},L={_p:a,$id:t,$onAction:s_.bind(null,_),$patch:b,$reset:I,$subscribe(C,f={}){const A=s_(d,C,f.detached,()=>w()),w=s.run(()=>st(()=>a.state.value[t],F=>{(f.flush==="sync"?u:l)&&C({storeId:t,type:Wr.direct,events:m},F)},Aa({},c,f)));return A},$dispose:R},U=ar(L);a._s.set(t,U);const N=(a._a&&a._a.runWithContext||Lh)(()=>a._e.run(()=>(s=OE()).run(()=>e({action:y}))));for(const C in N){const f=N[C];if(Bt(f)&&!Ph(f)||da(f))i||(p&&kh(f)&&(Bt(f)?f.value=p[C]:Au(f,p[C])),a.state.value[t][C]=f);else if(typeof f=="function"){const A=y(f,C);N[C]=A,o.actions[C]=f}}return Aa(U,N),Aa(gt(U),N),Object.defineProperty(U,"$state",{get:()=>a.state.value[t],set:C=>{b(f=>{Aa(f,C)})}}),a._p.forEach(C=>{Aa(U,s.run(()=>C({store:U,app:a._a,pinia:a,options:o})))}),p&&i&&n.hydrate&&n.hydrate(U.$state,p),l=!0,u=!0,U}/*! #__NO_SIDE_EFFECTS__ */function ka(t,e,n){let a;const r=typeof e=="function";a=r?n:e;function i(s,o){const c=Bb();return s=s||(c?ja(Vf,null):null),s&&rs(s),s=Hf,s._s.has(t)||(r?Wf(t,e,a,s):Uh(t,a,s)),s._s.get(t)}return i.$id=t,i}const Fh="modulepreload",Bh=function(t){return"/"+t},l_={},Gh=function(e,n,a){let r=Promise.resolve();if(n&&n.length>0){let s=function(l){return Promise.all(l.map(u=>Promise.resolve(u).then(d=>({status:"fulfilled",value:d}),d=>({status:"rejected",reason:d}))))};document.getElementsByTagName("link");const o=document.querySelector("meta[property=csp-nonce]"),c=(o==null?void 0:o.nonce)||(o==null?void 0:o.getAttribute("nonce"));r=s(n.map(l=>{if(l=Bh(l),l in l_)return;l_[l]=!0;const u=l.endsWith(".css"),d=u?'[rel="stylesheet"]':"";if(document.querySelector(`link[href="${l}"]${d}`))return;const _=document.createElement("link");if(_.rel=u?"stylesheet":Fh,u||(_.as="script"),_.crossOrigin="",_.href=l,c&&_.setAttribute("nonce",c),document.head.appendChild(_),u)return new Promise((m,p)=>{_.addEventListener("load",m),_.addEventListener("error",()=>p(new Error(`Unable to preload CSS for ${l}`)))})}))}function i(s){const o=new Event("vite:preloadError",{cancelable:!0});if(o.payload=s,window.dispatchEvent(o),!o.defaultPrevented)throw s}return r.then(s=>{for(const o of s||[])o.status==="rejected"&&i(o.reason);return e().catch(i)})},Kf="";window.addEventListener("unhandledrejection",t=>{console.error("[API] Unhandled rejection:",t.reason)});async function pt(t,e,n){const a={method:t,headers:{},credentials:"include"};n!==void 0&&(a.headers["Content-Type"]="application/json",a.body=JSON.stringify(n));const r=await fetch(`${Kf}${e}`,a);if(r.status===401){try{const{useAuthStore:s}=await Gh(async()=>{const{useAuthStore:c}=await Promise.resolve().then(()=>bv);return{useAuthStore:c}},void 0),o=s();o.user=null}catch{}const i=await r.text().catch(()=>"");throw new Error(`${t} ${e} → 401: ${i}`)}if(!r.ok){const i=await r.text().catch(()=>"");throw new Error(`${t} ${e} → ${r.status}: ${i}`)}return r.status===204?null:r.json()}function Yh(){return pt("GET","/auth/me")}function $h(){return pt("POST","/auth/logout")}function qh(){return pt("GET","/agents/profiles")}function c_({limit:t=30,offset:e=0,profileId:n=null,search:a=null,special:r=null}={}){const i=new URLSearchParams({limit:String(t),offset:String(e)});return n&&i.set("profile_id",n),a&&i.set("search",a),r!=null&&i.set("special",String(r)),pt("GET",`/sessions?${i.toString()}`)}function u_(t){return pt("GET",`/sessions/${t}/meta`)}function ys(t,e=null,n=200){const a=new URLSearchParams({limit:String(n)});return e!=null&&a.set("before_seq",String(e)),pt("GET",`/sessions/${t}/messages/history?${a.toString()}`)}function Hh(t){return pt("POST","/sessions",{profile_id:t})}function Vh(t){return pt("DELETE",`/sessions/${t}`)}function zh(t,e){return pt("PATCH",`/sessions/${t}/pin`,{pinned:e})}function Wh(t,e){return pt("PATCH",`/sessions/${t}/name`,{name:e})}function Kh(t){return pt("POST",`/sessions/${t}/stop`)}function Qh(t){return pt("POST",`/sessions/${t}/generate-name`)}function Xh(t){return pt("GET",`/sessions/${t}/content`)}function Zh(t){return pt("GET",`/sessions/${t}/tasks`)}function Jh(t){return pt("GET",`/eval/feedback/${t}`)}function jh(t,e,n){return pt("POST","/eval/feedback",{session_id:t,message_index:e,rating:n})}function ev(t){return pt("GET",`/sessions/${t}/files`)}async function tv(t,e){const n=new FormData;n.append("file",e);const a=await fetch(`${Kf}/sessions/${t}/files`,{method:"POST",credentials:"include",body:n});if(!a.ok){const r=await a.text().catch(()=>"");throw new Error(`Upload failed: ${a.status}: ${r}`)}return a.json()}function nv(t){return pt("GET",`/sessions/${t}/recall`)}function Qf(t){return pt("DELETE",`/sessions/${t}/recall`)}function Xf(t){return pt("POST",`/sessions/${t}/recall/skip`)}function av(){return pt("GET","/api-tokens")}function rv(t){return pt("POST","/api-tokens",{name:t})}function iv(t){return pt("DELETE",`/api-tokens/${t}`)}function sv(){return pt("GET","/synapse-targets")}function ov(t,e){return pt("POST","/synapse-targets",{token_ref:t,secret:e})}function lv(t){return pt("DELETE",`/synapse-targets/${t}`)}function cv(){return pt("GET","/synapse-settings")}function uv(t){return pt("PUT","/synapse-settings",t)}function dv(t=20){return pt("GET",`/synapse-settings/versions?limit=${t}`)}function _v(){return pt("GET","/mcp-keys")}function pv(t,e){return pt("PUT",`/mcp-keys/${t}`,{key:e})}function mv(t){return pt("DELETE",`/mcp-keys/${t}`)}function gv(){return pt("GET","/push/vapid-key")}function Ev(t){return pt("POST","/push/subscribe",t)}function fv(t){return pt("DELETE","/push/subscribe",{endpoint:t})}const Un=ka("sessions",()=>{const e=Y([]),n=Y(!1),a=Y(!1),r=Y(!0),i=Y(0),s=Y(null),o=Y(""),c=Y(!1),l=Y(null),u=Y(!1),d=Y(!1),_=Y({});function m(F,j){F==null||!j||_.value[F]!==j&&(_.value[F]=j)}function p(F){for(const j of F)m(j.session_id,j.name)}async function E(F=null){s.value=F,n.value=!0;try{const j=await c_({limit:30,offset:0,profileId:c.value?null:F,search:c.value?o.value:null,special:!!d.value}),_e=Array.isArray(j)?j:j.items,be=new Map(e.value.map(oe=>[oe.session_id,oe]));e.value=_e.map(oe=>{const pe=be.get(oe.session_id);return pe?(Object.assign(pe,oe),pe):oe}),p(e.value),r.value=Array.isArray(j)?!1:j.has_more,i.value=Array.isArray(j)?_e.length:j.next_offset,c.value&&(l.value={query:o.value,items:[..._e],hasMore:r.value,nextOffset:i.value})}finally{n.value=!1}}async function b(){if(!(n.value||a.value||!r.value)){a.value=!0;try{const F=await c_({limit:30,offset:i.value,profileId:c.value?null:s.value,search:c.value?o.value:null,special:!!d.value}),j=Array.isArray(F)?F:F.items,_e=new Set(e.value.map(be=>be.session_id));e.value=[...e.value,...j.filter(be=>!_e.has(be.session_id))],p(e.value),r.value=Array.isArray(F)?!1:F.has_more,i.value=Array.isArray(F)?e.value.length:F.next_offset,c.value&&(l.value={query:o.value,items:[...e.value],hasMore:r.value,nextOffset:i.value})}finally{a.value=!1}}}function I(F){o.value=F,c.value=F.length>0}function R(){o.value&&(c.value=!0,l.value&&l.value.query===o.value?(e.value=l.value.items,r.value=l.value.hasMore,i.value=l.value.nextOffset):E())}function y(){o.value="",c.value=!1,l.value=null}function L(){c.value=!1}async function U(F){const j=await Hh(F),_e=e.value.findIndex(oe=>!oe.pinned),be=_e===-1?e.value.length:_e;return e.value.splice(be,0,{session_id:j.session_id,profile_id:j.profile_id,created_at:j.created_at,last_active:j.created_at,message_count:0,preview:"",pinned:!1}),i.value+=1,j}async function h(F){await Vh(F),e.value=e.value.filter(j=>j.session_id!==F),i.value=Math.max(0,i.value-1)}async function N(F,j){await zh(F,j);const _e=e.value.find(be=>be.session_id===F);_e&&(_e.pinned=j),e.value.sort((be,oe)=>(oe.pinned?1:0)-(be.pinned?1:0))}function C(F,j){const _e=e.value.find(be=>be.session_id===F);_e&&(_e.has_pending_recall=j)}function f(F,j){const _e=e.value.find(be=>be.session_id===F);_e&&(_e.preview=j)}function A(F,j){m(F,j);const _e=e.value.find(be=>be.session_id===F);_e&&(_e.name=j)}const w=ue(()=>u.value?e.value.filter(F=>F.has_pending_recall):e.value);return{nameById:_,sessions:e,filteredSessions:w,loading:n,loadingMore:a,hasMore:r,currentProfileId:s,searchQuery:o,searchActive:c,hasPendingRecallFilter:u,showSpecial:d,fetchSessions:E,fetchMoreSessions:b,rememberName:m,createSession:U,deleteSession:h,pinSession:N,updatePreview:f,updateName:A,updateRecallStatus:C,setSearch:I,restoreSearch:R,clearSearch:y,exitSearch:L,searchCache:l}}),li=ka("profiles",()=>{const t=Y([]),e=Y(null),n=Y(!1);async function a(){n.value=!0;try{t.value=await qh(),t.value.length&&!e.value&&(e.value=t.value[0].id)}finally{n.value=!1}}function r(i){return t.value.find(s=>s.id===i)??null}return{profiles:t,selectedProfileId:e,loading:n,fetchProfiles:a,getProfile:r}});let d_=null;async function Sv(t){try{const e=Un(),n=e.sessions.find(r=>r.session_id===t);if(n!=null&&n.name)return;const{name:a}=await Qh(t);a&&e.updateName(t,a)}catch{}}const sn=ka("chat",()=>{const t=Un(),e=Y(null),n=Y(null),a=Y([]),r=Y(!1),i=Y([]),s=Y([]),o=Y([]),c=Y([]),l=Y(0),u=Y(0),d=Y(!1),_=Y(0),m=Y(!1),p=qE(null),E=Y(!1),b=Y(null),I=Y(null),R=Y({}),y=Y({}),L=Y({count:0,max:5}),U=new Map,h=Y([]),N=new Set,C=new Set,f=Y(!1),A=Y(!1),w=Y(null);async function F(O,G=null){if(!(e.value===O&&G==null)){d_=O,h.value=[],N.clear(),d.value=!0,a.value=[],o.value=[],c.value=[],r.value=!1,m.value=!1,p.value=null,l.value=0,u.value=0,R.value={},y.value={},C.clear(),L.value={count:0,max:5},U.clear(),b.value=G;try{const[Q,fe]=await Promise.all([u_(O),ys(O,null,200)]);if(d_!==O)return;if(n.value=Q.profile_id??null,t.rememberName(O,Q.name),a.value=vt(fe.items??[]),f.value=!1,A.value=fe.has_more??!1,w.value=fe.next_before_seq??null,Q.context_token_count&&(l.value=Q.context_token_count),Q.max_context_tokens&&(u.value=Q.max_context_tokens),G!=null){let he=0;for(;!a.value.some(we=>{var Pe;return(Pe=we.rawIndices)==null?void 0:Pe.includes(G)})&&A.value&&he<20;)await dt(),he++}await Promise.all([be(O),oe(O),pe(O)]),e.value=O,location.hash=O,Ce(O)}catch(Q){console.error("[chat] loadSession failed",Q)}finally{d.value=!1}}}function j(){e.value=null,n.value=null,a.value=[],h.value=[],N.clear(),o.value=[],c.value=[],r.value=!1,m.value=!1,p.value=null,l.value=0,u.value=0,R.value={},y.value={},C.clear(),L.value={count:0,max:5},U.clear(),location.hash=""}async function _e(O){if(O&&!r.value)try{const[G,Q]=await Promise.all([u_(O),ys(O,null,200)]);if(r.value)return;n.value=G.profile_id??null;const fe=vt(Q.items??[]);a.value=fe,A.value=Q.has_more??!1,w.value=Q.next_before_seq??null,await Promise.all([be(O),oe(O),pe(O),Ce(O)]),G.context_token_count&&(l.value=G.context_token_count),G.max_context_tokens&&(u.value=G.max_context_tokens),p.value=null,r.value=!1,m.value=!1}catch{}}async function be(O){var G,Q;try{const{feedback:fe=[]}=await Jh(O);if(!fe.length)return;const he=new Map(fe.map(we=>[we.message_index,we.rating]));for(const we of a.value){if(we.role!=="assistant")continue;const Pe=(Q=(G=we.id)==null?void 0:G.startsWith)!=null&&Q.call(G,"h_")?Number(we.id.slice(2)):NaN;Number.isInteger(Pe)&&he.has(Pe)&&(we.rating=he.get(Pe))}}catch{}}async function oe(O=e.value){if(!O){o.value=[];return}try{const{content:G=[]}=await Xh(O);o.value=G}catch{o.value=[]}}async function pe(O=e.value){if(!O){c.value=[];return}try{const{files:G=[]}=await ev(O);c.value=G}catch{c.value=[]}}async function Ce(O=e.value){if(!O){y.value={};return}let G=[];try{G=(await Zh(O)).tasks??[]}catch{return}if(e.value!==O)return;const Q={};for(const fe of G)Q[fe.task_id]={taskId:fe.task_id,tool:fe.tool,status:fe.status,startedAt:fe.started_at??null,finishedAt:fe.finished_at??null,argsSummary:fe.args_summary??"",preview:fe.result_preview??"",subagentTokens:fe.subagent_tokens??null},fe.status!=="running"&&C.add(fe.task_id);for(const fe of Object.values(y.value))Q[fe.taskId]=fe;y.value=Q}function ot(O){if(!(O!=null&&O.filename))return;const G=O.id||O.filename,Q=o.value.findIndex(he=>(he.id||he.filename)===G),fe={...O};Q===-1?o.value.unshift(fe):o.value.splice(Q,1,{...o.value[Q],...fe})}async function lt(O,G){var we,Pe;if(!e.value||!O)return;const Q=(Pe=(we=O.id)==null?void 0:we.startsWith)!=null&&Pe.call(we,"h_")?Number(O.id.slice(2)):NaN;if(!Number.isInteger(Q))return;const fe=O.rating===G?0:G,he=O.rating??0;O.rating=fe;try{await jh(e.value,Q,fe)}catch(Je){throw O.rating=he,Je}}function at(O){e.value&&(O?localStorage.setItem(`draft:${e.value}`,O):localStorage.removeItem(`draft:${e.value}`))}function We(O){return localStorage.getItem(`draft:${O}`)??""}function Ae(){if(p.value){const G=a.value.indexOf(p.value);G!==-1&&a.value.splice(G,1),p.value=null}r.value=!0,m.value=!1,L.value={count:0,max:L.value.max},U.clear();const O={id:`stream_${Date.now()}`,role:"assistant",type:"stream",thinking:null,tools:[],text:"",done:!1,time:new Date().toISOString(),animate:!E.value,statusLabel:null};a.value.push(O),p.value=a.value[a.value.length-1]}function He(){E.value=!0}function ke(){E.value=!1,p.value&&(p.value.animate=!0)}function rt(O){const G=p.value;G&&(G.thinking||(G.thinking={text:"",done:!1}),G.thinking.text+=O)}function je(){const O=p.value;O!=null&&O.thinking&&(O.thinking.done=!0)}function Ke(O){for(let G=O.tools.length-1;G>=0;G--){const Q=O.tools[G];if(Q.kind==="tool"&&Q.name==="spawn_agent")return Q}}function Et(O){const G=p.value;if(!G)return;const Q={kind:"turn_thinking",isSubagent:O.is_subagent??!1,thinking:{text:O.thinking??"",done:!0}};if(O.is_subagent){const fe=Ke(G);if(fe){fe.steps.push(Q);return}}G.tools.push(Q)}function ut(O){const G=p.value;if(G){if(O.is_subagent){const Q=Ke(G);Q&&(Q.planningLabel=O.label??"");return}G.statusLabel=O.label??""}}function bt(O){const G=p.value;if(G){if(O.is_subagent){const Q=Ke(G);Q&&(Q.planningLabel=null,Q.steps.push({kind:"plan",text:O.plan??""}));return}G.statusLabel=null,G.tools.push({kind:"plan",text:O.plan??""})}}function D(O){var fe,he;const G=p.value;if(!G)return;const Q={kind:"tool",id:`tool_${Date.now()}`,toolCallId:O.tool_call_id??null,name:O.tool,args:O.args,result:null,success:null,pending:!0,startedAt:Date.now(),isSubagent:O.is_subagent??!1,steps:[],terminalName:O.tool==="terminal"&&((fe=O.args)==null?void 0:fe.terminal_name)||null};if(Q.toolCallId&&U.set(Q.toolCallId,Q),Q.parentMsg=G,O.is_subagent){const we=Ke(G);if(we){we.steps.push(Q);return}}if(G.tools.push(Q),O.tool==="terminal"&&((he=O.args)==null?void 0:he.action)==="open"){const we=O.args.terminal_name;if(we){const Pe=R.value[we]||{};R.value={...R.value,[we]:{...Pe,name:we,description:O.args.description||"",command:O.args.command||"",background:O.args.background||!1,output:Pe.output||"",closed:!1}}}}}function P(O){var Q,fe;if((Q=O.metadata)!=null&&Q.is_image&&((fe=O.metadata)!=null&&fe.base64)&&Ut([O.metadata.data_url??`data:image/jpeg;base64,${O.metadata.base64}`]),O.is_subagent&&!O.tool_call_id){const he=p.value??K(),we=he?Ke(he):null;if(we)for(let Pe=we.steps.length-1;Pe>=0;Pe--){const Je=we.steps[Pe];if(Je.kind==="tool"&&Je.name===O.tool&&Je.pending){z(Je,O);return}}}let G=O.tool_call_id?U.get(O.tool_call_id)??null:null;if(!G&&!O.tool_call_id){const he=p.value;if(he)for(let we=he.tools.length-1;we>=0;we--){const Pe=he.tools[we];if(Pe.kind==="tool"&&Pe.name===O.tool&&Pe.pending){G=Pe;break}}}G||(G=Z(O)),G&&z(G,O)}function z(O,G){var Q,fe,he,we,Pe;{if(O.result=G.result,O.success=G.success!==!1,O.pending=!1,G.metadata&&(O.metadata=G.metadata),G.tool==="mcp__navi_ui__render_component"&&O.success&&((Q=G.metadata)!=null&&Q.ui_component)){const Je=O.parentMsg??p.value??K();Je&&!O.isSubagent&&Je.tools.push({kind:"ui_component",component:G.metadata.ui_component.component??"",payload:G.metadata.ui_component.payload??{}})}if(G.tool==="content_publish"&&O.success&&G.metadata&&ot(G.metadata),G.tool==="filesystem"&&O.success&&e.value){const Je=typeof O.args=="object"?(fe=O.args)==null?void 0:fe.action:null;["write","edit","append","mkdir","rm","cp","mv"].includes(Je)&&pe(e.value),["write","edit"].includes(Je)&&oe(e.value)}if((G.tool==="terminal"||G.tool==="code_exec")&&O.success&&e.value&&pe(e.value),G.tool==="terminal"&&O.success&&e.value){const Je=typeof O.args=="object"?(he=O.args)==null?void 0:he.action:null,k=(we=O.args)==null?void 0:we.terminal_name;if(G.metadata){if(Je==="open"||Je==="status"){if(k){const V=R.value[k]||{};R.value={...R.value,[k]:{...V,...G.metadata,name:k,closed:!1}}}}else if(Je==="list"&&Array.isArray(G.metadata.terminals))for(const V of G.metadata.terminals){if(!V.name)continue;const se=R.value[V.name]||{};R.value={...R.value,[V.name]:{...se,...V,closed:!1}}}else if(Je==="close"&&k){const V=R.value[k]||{};R.value={...R.value,[k]:{...V,closed:!0,closeReason:"explicit"}}}}}if(G.tool==="schedule_recall"&&O.success&&e.value&&(et(e.value),Un().updateRecallStatus(e.value,!0)),G.tool==="manage_recall"&&O.success&&e.value){const Je=(Pe=O.args)==null?void 0:Pe.action;Je==="cancel"?(I.value=null,Un().updateRecallStatus(e.value,!1)):Je==="skip"&&et(e.value)}}}function K(){for(let O=a.value.length-1;O>=0;O--){const G=a.value[O];if(G.role==="assistant"&&Array.isArray(G.tools))return G}return null}function Z(O){const G=p.value??K();if(!G)return null;const Q={kind:"tool",id:`tool_${Date.now()}`,toolCallId:O.tool_call_id??null,name:O.tool,args:null,result:null,success:null,pending:!1,isSubagent:O.is_subagent??!1,steps:[]};if(Q.parentMsg=G,Q.toolCallId&&U.set(Q.toolCallId,Q),O.is_subagent){const fe=Ke(G);if(fe)return fe.steps.push(Q),Q}return G.tools.push(Q),Q}function W(O){const G=O.task_id;if(G&&!(O.session_id&&e.value&&O.session_id!==e.value)){if(O.parent_tool_call_id){const Q=U.get(O.parent_tool_call_id);if(Q){const fe=Q.steps[Q.steps.length-1];(fe==null?void 0:fe.kind)==="task_update"&&fe.status===O.status&&fe.preview===(O.result_preview??"")||Q.steps.push({kind:"task_update",taskId:G,tool:O.tool,status:O.status,preview:O.result_preview??""}),O.subagent_tokens!=null&&(Q.subagentTokens=O.subagent_tokens)}}if(O.status!=="running"){C.add(G);const Q=y.value[G];Q&&(y.value={...y.value,[G]:{...Q,status:O.status,preview:O.result_preview??Q.preview,finishedAt:O.finished_at??Q.finishedAt??null,subagentTokens:O.subagent_tokens??Q.subagentTokens??null}})}else!C.has(G)&&!y.value[G]&&(y.value={...y.value,[G]:{taskId:G,tool:O.tool,status:O.status,startedAt:O.started_at??null,finishedAt:null,argsSummary:O.args_summary??"",preview:"",subagentTokens:null}})}}function de(O){L.value={count:O.queue_len??1,max:O.max??5},m.value=!1}function ae(O){const G=O.terminal_name;if(!G)return;const Q=R.value[G]||{};R.value={...R.value,[G]:{...Q,name:G,closed:!1}}}function re(O){const G=O.terminal_name;if(!G)return;const Q=R.value[G]||{output:""},fe={...Q,output:(Q.output||"")+(O.delta||"")};R.value={...R.value,[G]:fe};const he=p.value;if(he)for(let we=he.tools.length-1;we>=0;we--){const Pe=he.tools[we];if(Pe.kind==="tool"&&Pe.name==="terminal"&&Pe.terminalName===G){Pe.terminalOutput=fe.output;break}}}function ee(O){const G=O.terminal_name;if(!G)return;const fe={...R.value[G]||{},closed:!0,closeReason:O.reason||"unknown"};R.value={...R.value,[G]:fe};const he=p.value;if(he)for(let we=he.tools.length-1;we>=0;we--){const Pe=he.tools[we];if(Pe.kind==="tool"&&Pe.name==="terminal"&&Pe.terminalName===G&&Pe.pending){Pe.pending=!1,Pe.success=O.reason!=="error";break}}}function Ne(O){const G=p.value;G&&(G.statusLabel&&(G.statusLabel=null),G.text+=O)}function ce(O){const G=p.value;if(G){G.done=!0,G.elapsed_seconds=(O==null?void 0:O.elapsed_seconds)??null,G.tool_call_count=(O==null?void 0:O.tool_call_count)??null,G.token_count=(O==null?void 0:O.token_count)??null;const Q=a.value.filter(fe=>fe.role==="assistant").length-1;G.id=`h_${Q}`,p.value=null,!G.thinking&&!G.tools.length&&!G.text&&(a.value=a.value.filter(fe=>fe!==G))}r.value=!1,m.value=!1,(O==null?void 0:O.context_tokens)!=null&&(l.value=O.context_tokens),(O==null?void 0:O.max_context_tokens)!=null&&(u.value=O.max_context_tokens),e.value&&(G!=null&&G.text)&&Un().updatePreview(e.value,G.text.slice(0,80)),e.value&&Sv(e.value)}function Re(){const O=p.value;if(O){O.done=!0;const G=a.value.filter(Q=>Q.role==="assistant").length-1;O.id=`h_${G}`,p.value=null,!O.thinking&&!O.tools.length&&!O.text&&(a.value=a.value.filter(Q=>Q!==O))}r.value=!1,m.value=!1}function ye(O){n.value=O.profile_id}function Fe(O){(O==null?void 0:O.context_tokens)!=null&&(l.value=O.context_tokens),(O==null?void 0:O.max_context_tokens)!=null&&(u.value=O.max_context_tokens),a.value.push({id:`compress_pending_${Date.now()}`,role:"system",type:"compression_pending",text:"Compressing context…"})}function qe(O){(O==null?void 0:O.context_tokens)!=null&&(l.value=O.context_tokens),(O==null?void 0:O.max_context_tokens)!=null&&(u.value=O.max_context_tokens),a.value=a.value.filter(G=>G.type!=="compression_pending"),a.value.push({id:`compress_${Date.now()}`,role:"system",type:"compression_notice",before:O.messages_before,after:O.messages_after,summary:O.summary??""})}function Qe(O){r.value=!1,m.value=!1,p.value=null,a.value.push({id:`err_${Date.now()}`,role:"system",type:"error",text:O.message??"An error occurred"})}async function et(O=e.value){if(!O){I.value=null;return}try{const G=await nv(O);G&&G.id?I.value=G:I.value=null}catch{I.value=null}}async function dt(){if(!(!e.value||f.value||!A.value)){f.value=!0;try{const O=await ys(e.value,w.value),G=vt(O.items??[]);a.value=[...G,...a.value],A.value=O.has_more??!1,w.value=O.next_before_seq??null}catch(O){console.error("[chat] loadArchivedMessages failed",O)}finally{f.value=!1}}}function Lt(O=!1,G=null){A.value=O,w.value=G}function Mt(O){if(!O.session_id)return;const G=Un(),Q=O.status==="pending";G.updateRecallStatus(O.session_id,Q),O.session_id===e.value&&(Q?et(O.session_id):I.value=null)}function Vt(O,G,Q){a.value.push({id:`user_${Date.now()}`,role:"user",text:O,images:[...G],files:[...Q],time:new Date().toISOString(),animate:!0})}function Ut(O){for(const G of O)!G||N.has(G)||(N.add(G),h.value.push(G))}function vt(O){var he,we,Pe,Je,k;const G=[];let Q=0;const fe=V=>{var Ie;const se=O[V];return((Ie=se==null?void 0:se.metadata)==null?void 0:Ie.display_index)??V};for(;Qtypeof mt=="string"&&mt.startsWith("data:")?mt:`data:image/jpeg;base64,${String(mt??"")}`);if((we=(he=V.content)==null?void 0:he.startsWith)!=null&&we.call(he,"[Image loaded via")&&Ie.length){Ut(Ie),Q++;continue}G.push({id:`h_${se}`,role:"user",text:V.content??"",images:Ie,files:V.files??[],time:V.created_at??null,rawIndices:[se],isRecall:V.is_recall??!1}),Q++;continue}if(V.role==="assistant"){const Ie=Q,mt=se,_t=[];let ve=null,me="",De=null;for(;Q=O.length||O[Q].role!=="assistant")break}}if(ve||_t.length||me){const it=`h_${mt}`;let ct=null,Ft=null,kt=null;for(let on=Ie;onfe(Ie+Qt))})}continue}Q++}return G}return{currentId:e,currentProfileId:n,messages:a,streaming:r,pendingImages:i,pendingFiles:s,artifacts:o,files:c,viewedImages:h,contextTokens:l,maxContextTokens:u,loading:d,imagesProcessing:_,awaitingStream:m,streamingMsg:p,scrollToMessageIndex:b,recall:I,terminals:R,backgroundTasks:y,queuedMessages:L,archiveLoading:f,archiveHasMore:A,archiveNextBefore:w,loadSession:F,clearSession:j,reloadSession:_e,fetchArtifacts:oe,fetchFiles:pe,fetchTasks:Ce,rateMessage:lt,saveDraft:at,loadDraft:We,appendUserMessage:Vt,buildMessageList:vt,onStreamStart:Ae,onReplayStart:He,onReplayEnd:ke,onThinkingDelta:rt,onThinkingEnd:je,onTurnThinking:Et,onPlanningStatus:ut,onPlanReady:bt,onToolStarted:D,onToolCall:P,onTerminalOutput:re,onTerminalClosed:ee,onTerminalOpened:ae,onTaskUpdate:W,onMessageQueued:de,onStreamDelta:Ne,onStreamEnd:ce,onStreamStopped:Re,onProfileSwitched:ye,onCompressionStarted:Fe,onContextCompressed:qe,onError:Qe,loadRecall:et,onRecallUpdate:Mt,loadArchivedMessages:dt,initArchiveState:Lt}}),is=ka("auth",()=>{const t=Y(null),e=Y(!1),n=Y(!1),a=ue(()=>t.value!==null),r=ue(()=>{var _;return((_=t.value)==null?void 0:_.role)==="admin"});function i(_){return t.value?t.value.role==="admin"?!0:(t.value.permissions||[]).includes(_):!1}async function s(){var _;console.log("[auth] fetchMe start"),e.value=!0;try{t.value=await Yh(),console.log("[auth] fetchMe success",t.value)}catch(m){console.log("[auth] fetchMe error",m.message),(_=m.message)!=null&&_.includes("401")&&(t.value=null)}finally{e.value=!1,console.log("[auth] fetchMe loading=false")}}const o=Y(!0);async function c(){console.log("[auth] fetchStatus start");try{const _=await fetch("/auth/status");if(console.log("[auth] fetchStatus response",_.status,_.ok),_.ok){const m=await _.json();console.log("[auth] fetchStatus data",m),o.value=m.enabled!==!1,n.value=!!m.configured,console.log("[auth] fetchStatus authEnabled set to",o.value),console.log("[auth] fetchStatus authConfigured set to",n.value)}else console.log("[auth] fetchStatus not ok"),o.value=!0,n.value=!1}catch(_){console.log("[auth] fetchStatus error",_),o.value=!0,n.value=!1}}function l(){const _=navigator.userAgent.includes("NaviAndroid"),m=new URLSearchParams;_&&m.set("platform","android");const p=m.toString();window.location.href="/auth/login"+(p?"?"+p:"")}async function u(){try{await $h()}catch{}t.value=null,window.location.reload()}const d=ue(()=>!o.value);return{user:t,loading:e,authConfigured:n,authEnabled:o,isAuthenticated:a,isAdmin:r,isNoAuthMode:d,hasPermission:i,fetchMe:s,fetchStatus:c,login:l,logout:u}}),bv=Object.freeze(Object.defineProperty({__proto__:null,useAuthStore:is},Symbol.toStringTag,{value:"Module"})),ju="/images/logo.svg";function __(t){if(!t)return"";const e=new Date(t);if(isNaN(e))return"";const n=Date.now()-e;return n<6e4?"just now":n<36e5?`${Math.floor(n/6e4)}m ago`:n<864e5?e.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"}):e.toLocaleDateString()}function ed(t){const e=Y(__(t.value));let n=null;function a(){e.value=__(t.value)}return Sn(()=>{a(),n=setInterval(a,3e4)}),fa(()=>{n&&clearInterval(n)}),e}const ki=Y(!1),Zf=qE(""),Iu=[];function Tv(){return{visible:ki,message:Zf}}function ss(){return function(e){return Zf.value=e,ki.value=!0,new Promise(n=>{Iu.push(n)})}}function p_(t){ki.value=!1;const e=Iu.shift();e==null||e(t),Iu.length===0&&(ki.value=!1)}const ht=(t,e)=>{const n=t.__vccOpts||t;for(const[a,r]of e)n[a]=r;return n},hv={key:0,class:"session-icons"},vv={key:0,class:"ph ph-push-pin session-pin-icon",title:"Pinned"},Rv={key:1,class:"ph ph-clock session-recall-icon",title:"Scheduled recall pending"},Cv={key:2,class:"ph ph-robot session-special-icon",title:"Service session (Synapse reaction)"},yv={class:"session-info"},Nv={class:"session-name-row"},Ov=["innerHTML"],Av=["innerHTML"],Iv={key:1,class:"session-time"},Dv=["title"],wv={__name:"SessionItem",props:{session:{type:Object,required:!0},active:{type:Boolean,default:!1},searchQuery:{type:String,default:""}},emits:["select","delete","pin","cancel-recall","skip-recall"],setup(t,{emit:e}){const n=t,a=e,r=ss(),i=ue(()=>{const p=n.session.session_id??"";return n.session.name||p.slice(0,8)}),s=ue(()=>n.searchQuery&&n.session.match_preview?n.session.match_preview:n.session.preview),o=ue(()=>n.session.last_active),c=ed(o);function l(p){return typeof p!="string"?String(p??""):p.replace(/&/g,"&").replace(//g,">")}function u(p,E){if(!E||!p)return l(p);const b=E.toLowerCase(),I=p.toLowerCase(),R=[];let y=0;for(;;){const L=I.indexOf(b,y);if(L===-1)break;L>y&&R.push(l(p.slice(y,L))),R.push(`${l(p.slice(L,L+E.length))}`),y=L+E.length}return yu(i.value,n.searchQuery)),_=ue(()=>u(s.value,n.searchQuery));async function m(){await r("Delete this conversation?")&&a("delete")}return(p,E)=>(v(),x("div",{class:Ge(["session-item",{"is-active":t.active,"is-pinned":t.session.pinned,"has-recall":t.session.has_pending_recall,"is-special":t.session.special}]),onClick:E[4]||(E[4]=b=>a("select"))},[t.session.pinned||t.session.has_pending_recall||t.session.special?(v(),x("div",hv,[t.session.pinned?(v(),x("i",vv)):J("",!0),t.session.has_pending_recall?(v(),x("i",Rv)):J("",!0),t.session.special?(v(),x("i",Cv)):J("",!0)])):J("",!0),g("div",yv,[g("div",Nv,[g("span",{class:"session-name",innerHTML:d.value},null,8,Ov)]),s.value?(v(),x("div",{key:0,class:"session-preview",innerHTML:_.value},null,8,Av)):J("",!0),$(c)?(v(),x("div",Iv,X($(c)),1)):J("",!0)]),g("div",{class:"session-actions",onClick:E[3]||(E[3]=ga(()=>{},["stop"]))},[t.session.has_pending_recall?(v(),x("button",{key:0,class:"btn-icon",title:"Cancel recall",onClick:E[0]||(E[0]=b=>a("cancel-recall"))},[...E[5]||(E[5]=[g("i",{class:"ph ph-clock-slash"},null,-1)])])):J("",!0),t.session.has_pending_recall?(v(),x("button",{key:1,class:"btn-icon",title:"Skip next",onClick:E[1]||(E[1]=b=>a("skip-recall"))},[...E[6]||(E[6]=[g("i",{class:"ph ph-skip-forward"},null,-1)])])):J("",!0),g("button",{class:"btn-icon",title:t.session.pinned?"Unpin":"Pin",onClick:E[2]||(E[2]=b=>a("pin"))},[g("i",{class:Ge(t.session.pinned?"ph ph-push-pin-slash":"ph ph-push-pin")},null,2)],8,Dv),g("button",{class:"btn-icon",title:"Delete",onClick:m},[...E[7]||(E[7]=[g("i",{class:"ph ph-trash"},null,-1)])])])],2))}},xv=ht(wv,[["__scopeId","data-v-308a2eeb"]]),Lv={class:"ptr-label"},Mv={key:0,class:"sessions-loading"},kv={key:1,class:"empty-sessions"},Pv={key:2,class:"empty-sessions"},Uv={key:4,class:"sessions-loading sessions-loading-more"},m_=80,Fv=120,Bv={__name:"SessionList",emits:["select"],setup(t,{emit:e}){const n=e,a=Un(),r=sn(),i=li();st(()=>i.selectedProfileId,N=>{N&&N!==a.currentProfileId&&a.fetchSessions(N)});function s(N){n("select",N)}async function o(N){const C=N.session_id===r.currentId;await a.deleteSession(N.session_id),C&&r.clearSession()}async function c(N){await a.pinSession(N.session_id,!N.pinned)}async function l(N){try{await Qf(N.session_id),a.updateRecallStatus(N.session_id,!1)}catch(C){console.error("cancel recall failed",C)}}async function u(N){try{await Xf(N.session_id)}catch(C){console.error("skip recall failed",C)}}function d(N){const C=N.target;C.scrollHeight-C.scrollTop-C.clientHeight<160&&a.fetchMoreSessions()}const _=Y(!1),m=Y(0),p=Y(!1),E=Y(null),b=ue(()=>({transform:`translateY(${Math.min(m.value,Fv)}px)`,opacity:_.value?Math.min(m.value/m_,1):0})),I=ue(()=>a.loading?"Refreshing...":p.value?"Release to refresh":"Pull to refresh");let R=0,y=0;function L(N){var f;const C=E.value;C&&(y=C.scrollTop||0,!(y>2)&&(R=((f=N.touches[0])==null?void 0:f.clientY)??0,_.value=!1,m.value=0,p.value=!1))}function U(N){var A;if(y>2||!R)return;const f=(((A=N.touches[0])==null?void 0:A.clientY)??0)-R;if(f<=0){_.value=!1;return}f>4&&N.preventDefault(),_.value=!0,m.value=f,p.value=f>=m_}function h(){p.value&&!a.loading&&a.fetchSessions(i.selectedProfileId),_.value=!1,m.value=0,p.value=!1,R=0,y=0}return(N,C)=>(v(),x("div",{class:"session-list-wrap",onTouchstart:L,onTouchmove:U,onTouchend:h},[g("div",{class:Ge(["ptr-indicator",{"ptr-active":_.value&&!$(a).loading}]),style:Da(b.value)},[g("span",{class:Ge(["ptr-spinner",{"ptr-spinning":p.value}])},null,2),g("span",Lv,X(I.value),1)],6),$(a).loading&&!$(a).sessions.length?(v(),x("div",Mv,[...C[0]||(C[0]=[g("span",{class:"sessions-spinner"},null,-1),g("p",null,"Loading conversations...",-1)])])):$(a).sessions.length?$(a).filteredSessions.length?J("",!0):(v(),x("div",Pv,[...C[2]||(C[2]=[g("i",{class:"ph ph-faders"},null,-1),g("p",null,"No conversations match the current filter",-1)])])):(v(),x("div",kv,[...C[1]||(C[1]=[g("i",{class:"ph ph-chat-dots"},null,-1),g("p",null,"No conversations yet",-1)])])),$(a).filteredSessions.length?(v(),x("div",{key:3,ref_key:"scrollerRef",ref:E,class:Ge(["session-scroller",{"ptr-pulled":_.value}]),onScrollPassive:d},[(v(!0),x(Ue,null,Dt($(a).filteredSessions,(f,A)=>(v(),ze(xv,{key:f.session_id,session:f,active:f.session_id===$(r).currentId,"search-query":$(a).searchActive?$(a).searchQuery:"",onSelect:w=>s(f),onDelete:w=>o(f),onPin:w=>c(f),onCancelRecall:w=>l(f),onSkipRecall:w=>u(f)},null,8,["session","active","search-query","onSelect","onDelete","onPin","onCancelRecall","onSkipRecall"]))),128))],34)):J("",!0),$(a).loadingMore?(v(),x("div",Uv,[...C[3]||(C[3]=[g("span",{class:"sessions-spinner"},null,-1)])])):J("",!0)],32))}},Gv=ht(Bv,[["__scopeId","data-v-306ab182"]]),Yv={class:"sidebar-header"},$v={class:"sidebar-logo-row"},qv={class:"sidebar-sessions"},Hv={class:"sessions-header"},Vv={class:"sessions-label"},zv={class:"sessions-header-actions"},Wv={class:"sidebar-footer"},Kv={class:"user-info",title:"Authorization is disabled"},Qv={class:"sidebar-footer-actions"},Xv=["href"],Zv={class:"user-name"},Jv={class:"sidebar-footer-actions"},jv={key:0,href:"/admin",target:"_blank",rel:"noopener noreferrer",class:"btn-icon admin-link",title:"Admin"},eR={__name:"AppSidebar",props:{mobileOpen:Boolean},emits:["close"],setup(t,{emit:e}){const n=t,a=e,r=li(),i=Un(),s=sn(),o=is(),c=Y(!1),l=Y(""),u=Y(null);let d=null;st(()=>s.currentProfileId,C=>{C&&(r.selectedProfileId=C)}),st(()=>r.selectedProfileId,C=>{C&&(c.value&&(c.value=!1,i.exitSearch()),i.fetchSessions(C),Ht(()=>{var f,A;(A=(f=_.value)==null?void 0:f.querySelector(".chip-selected"))==null||A.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})}))},{immediate:!0});const _=Y(null);function m(C){const f=_.value;f&&(f.scrollLeft+=Math.abs(C.deltaX)>Math.abs(C.deltaY)?C.deltaX:C.deltaY)}function p(C,f){var A;r.selectedProfileId=C,(A=f==null?void 0:f.currentTarget)==null||A.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})}function E(){i.showSpecial=!i.showSpecial,i.showSpecial&&c.value&&(c.value=!1,l.value="",i.clearSearch(),i.exitSearch()),i.fetchSessions(r.selectedProfileId)}function b(){var A;const C=((A=u.value)==null?void 0:A.$el)??u.value;if(!C)return;const f=C.querySelector("input");f==null||f.focus()}st(()=>s.currentProfileId,C=>{C&&(r.selectedProfileId=C)});function I(){c.value=!c.value,c.value&&(setTimeout(b,50),i.searchQuery&&(l.value=i.searchQuery,i.restoreSearch()))}function R(){c.value&&(c.value=!1,i.exitSearch(),i.fetchSessions(r.selectedProfileId))}function y(){c.value=!1,l.value="",i.clearSearch(),i.exitSearch(),i.fetchSessions(r.selectedProfileId)}st(l,C=>{if(d&&clearTimeout(d),!C){i.clearSearch(),i.fetchSessions(r.selectedProfileId);return}d=setTimeout(()=>{i.setSearch(C),i.fetchSessions()},300)});function L(){s.clearSession(),a("close")}async function U(C){var A;const f=i.searchActive;f&&C.profile_id&&(r.selectedProfileId=C.profile_id),await s.loadSession(C.session_id,f?(A=C.match_indices)==null?void 0:A[0]:null),f&&(c.value=!1,i.exitSearch(),i.fetchSessions(r.selectedProfileId)),a("close")}function h(){location.hash="#settings",a("close")}function N(C){(C.ctrlKey||C.metaKey)&&C.key==="k"&&(C.preventDefault(),I())}return Sn(()=>window.addEventListener("keydown",N)),Yn(()=>window.removeEventListener("keydown",N)),(C,f)=>{var be,oe,pe,Ce,ot,lt,at;const A=tt("GnButton"),w=tt("GnIconButton"),F=tt("GnSearchField"),j=tt("GnChip"),_e=tt("GnAvatar");return v(),x("aside",{class:Ge(["app-sidebar",{"is-mobile-open":n.mobileOpen}])},[g("div",Yv,[g("div",$v,[f[5]||(f[5]=g("div",{class:"sidebar-logo"},[g("img",{src:ju,alt:"Navi"}),g("span",null,"Navi")],-1)),ne(A,{variant:"primary",icon:"ph ph-plus",onClick:L},{default:Be(()=>[...f[4]||(f[4]=[$e(" New Chat ",-1)])]),_:1}),ne(w,{icon:"ph ph-x",label:"Close",class:"sidebar-close-btn",onClick:f[0]||(f[0]=We=>a("close"))})])]),g("div",{class:Ge(["sidebar-search",{"is-open":c.value}])},[g("div",{class:Ge(["sidebar-search-inner",{"is-loading":$(i).loading&&$(i).searchActive}])},[ne(F,{ref_key:"searchFieldEl",ref:u,modelValue:l.value,"onUpdate:modelValue":f[1]||(f[1]=We=>l.value=We),placeholder:"Search conversations...",compact:"",clearable:"",onClear:y,onKeydown:ea(R,["esc"])},null,8,["modelValue"])],2)],2),g("div",qv,[g("div",{ref_key:"profilesEl",ref:_,class:"sessions-profiles",onWheel:ga(m,["prevent"])},[(v(!0),x(Ue,null,Dt($(r).profiles,We=>(v(),ze(j,{key:We.id,clickable:"",selected:$(r).selectedProfileId===We.id,onClick:Ae=>p(We.id,Ae)},{default:Be(()=>[$e(X(We.name),1)]),_:2},1032,["selected","onClick"]))),128))],544),g("div",Hv,[g("div",Vv,[$(i).searchActive?(v(),x(Ue,{key:0},[$e(X($(i).sessions.length)+" result"+X($(i).sessions.length===1?"":"s"),1)],64)):(v(),x(Ue,{key:1},[$e(X($(i).showSpecial?"Service sessions":"Conversations"),1)],64))]),g("div",zv,[ne(w,{icon:"ph ph-clock",label:"Pending recalls only",class:Ge(["recall-filter-btn",{active:$(i).hasPendingRecallFilter}]),onClick:f[2]||(f[2]=We=>$(i).hasPendingRecallFilter=!$(i).hasPendingRecallFilter)},null,8,["class"]),ne(w,{icon:"ph ph-robot",label:"Service (Synapse) sessions",class:Ge(["special-filter-btn",{active:$(i).showSpecial}]),onClick:E},null,8,["class"]),ne(w,{icon:"ph ph-magnifying-glass",label:"Search",class:Ge(["search-toggle-btn",{active:c.value||$(i).searchActive}]),onClick:I},null,8,["class"]),ne(w,{icon:"ph ph-arrow-clockwise",label:"Refresh",class:Ge(["sessions-refresh-btn",{"is-spinning":$(i).loading}]),onClick:f[3]||(f[3]=We=>$(i).fetchSessions($(r).selectedProfileId))},null,8,["class"])])]),ne(Gv,{onSelect:U})]),g("div",Wv,[$(o).isNoAuthMode?(v(),x(Ue,{key:0},[g("div",Kv,[ne(_e,{size:"sm",src:"",alt:"local",initials:"L"}),f[6]||(f[6]=g("span",{class:"user-name"},"Local mode",-1))]),g("div",Qv,[ne(w,{icon:"ph ph-gear",label:"Settings",onClick:h}),f[7]||(f[7]=g("a",{href:"/admin",target:"_blank",rel:"noopener noreferrer",class:"btn-icon admin-link",title:"Admin"},[g("i",{class:"ph ph-shield-check"})],-1))])],64)):$(o).isAuthenticated?(v(),x(Ue,{key:1},[g("a",{class:"user-info",href:(be=$(o).user)==null?void 0:be.profile_url,target:"_blank",rel:"noopener noreferrer",title:"Open profile in gnexus-auth"},[ne(_e,{size:"sm",src:((oe=$(o).user)==null?void 0:oe.avatar_url)||"",alt:((pe=$(o).user)==null?void 0:pe.display_name)||"avatar",initials:(((Ce=$(o).user)==null?void 0:Ce.display_name)||((ot=$(o).user)==null?void 0:ot.email)||"?").charAt(0).toUpperCase()},null,8,["src","alt","initials"]),g("span",Zv,X(((lt=$(o).user)==null?void 0:lt.display_name)||((at=$(o).user)==null?void 0:at.email)),1)],8,Xv),g("div",Jv,[ne(w,{icon:"ph ph-gear",label:"Settings",onClick:h}),$(o).isAdmin?(v(),x("a",jv,[...f[8]||(f[8]=[g("i",{class:"ph ph-shield-check"},null,-1)])])):J("",!0),ne(w,{icon:"ph ph-sign-out",label:"Logout",onClick:$(o).logout},null,8,["onClick"])])],64)):(v(),ze(A,{key:2,variant:"primary",icon:"ph ph-sign-in",onClick:$(o).login},{default:Be(()=>[...f[9]||(f[9]=[$e(" Login ",-1)])]),_:1},8,["onClick"]))])],2)}}},tR=ht(eR,[["__scopeId","data-v-7de86c3c"]]),Jf={__name:"ConfirmDialog",setup(t){const{visible:e,message:n}=Tv();function a(){p_(!0)}function r(){p_(!1)}return(i,s)=>{const o=tt("GnConfirmDialog");return v(),ze(o,{open:$(e),"onUpdate:open":s[0]||(s[0]=c=>Bt(e)?e.value=c:null),message:$(n),title:"Requires confirmation","cancel-text":"No","confirm-text":"Yes","confirm-variant":"warning",onConfirm:a,onCancel:r},null,8,["open","message"])}}},nR=Object.freeze(Object.defineProperty({__proto__:null,default:Jf},Symbol.toStringTag,{value:"Module"})),mr=Y(null);function aR(){mr.value&&(mr.value=null)}typeof window<"u"&&window.addEventListener("popstate",aR);function ci(){function t(n){var a;(a=history.state)!=null&&a.lightbox||history.pushState({lightbox:!0},""),mr.value=n}function e(){var n;mr.value&&(mr.value=null,(n=history.state)!=null&&n.lightbox&&history.back())}return{src:mr,open:t,close:e}}const rR={key:0,class:"modal a-show","aria-hidden":"false"},iR={class:"modal-dialog lightbox-dialog",role:"dialog","aria-modal":"true",tabindex:"-1"},sR={class:"modal-header"},oR={class:"modal-panel lightbox-panel"},lR={class:"modal-body"},cR=["src"],uR={key:1,class:"lightbox-error"},jf={__name:"ImageLightbox",setup(t){const{src:e,close:n}=ci(),a=Y(!1);return st(e,r=>{document.body.style.overflow=r?"hidden":"",a.value=!1}),(r,i)=>(v(),ze(Ji,{to:"body"},[$(e)?(v(),x("div",rR,[g("div",{class:"modal-backdrop",onClick:i[0]||(i[0]=(...s)=>$(n)&&$(n)(...s))}),g("div",iR,[g("header",sR,[i[3]||(i[3]=g("h4",{class:"modal-title"},"Photo",-1)),g("button",{class:"btn-icon modal-close",type:"button","aria-label":"Close",onClick:i[1]||(i[1]=(...s)=>$(n)&&$(n)(...s))},"✕")]),g("div",oR,[g("div",lR,[a.value?(v(),x("div",uR,[...i[4]||(i[4]=[g("i",{class:"ph ph-image-broken"},null,-1),g("span",null,"Failed to load image",-1)])])):(v(),x("img",{key:0,src:$(e),class:"lightbox-img",onError:i[2]||(i[2]=s=>a.value=!0)},null,40,cR))])])])])):J("",!0)]))}},dR=Object.freeze(Object.defineProperty({__proto__:null,default:jf},Symbol.toStringTag,{value:"Module"})),fi=Y("");function eS(){function t(n){fi.value=n}function e(){const n=fi.value;return fi.value="",n}return{pendingQuote:fi,requestQuote:t,consumeQuote:e}}const _R={__name:"SelectionToolbar",setup(t){const{requestQuote:e}=eS(),n=Y(!1),a=Y({x:0,y:0});let r="";function i(){const u=window.getSelection();if(!u||u.isCollapsed||!u.toString().trim())return null;const d=u.getRangeAt(0),_=d.commonAncestorContainer;return(_.nodeType===Node.TEXT_NODE?_.parentElement:_).closest(".msg-assistant-content")?{text:u.toString().trim(),range:d}:null}function s(){const u=window.getSelection();if(!u||u.isCollapsed||!u.rangeCount){n.value=!1;return}const _=u.getRangeAt(0).getBoundingClientRect();if(!_.width&&!_.height){n.value=!1;return}a.value={x:Math.round(_.left+_.width/2),y:Math.round(_.top-44)}}function o(){setTimeout(()=>{const u=i();if(!u){n.value=!1;return}r=u.text,s(),n.value=!0},10)}function c(){const u=window.getSelection();(!u||u.isCollapsed)&&(n.value=!1)}function l(){var u;r&&(e(r),(u=window.getSelection())==null||u.removeAllRanges(),n.value=!1)}return Sn(()=>{document.addEventListener("mouseup",o),document.addEventListener("selectionchange",c),document.addEventListener("scroll",s,!0)}),fa(()=>{document.removeEventListener("mouseup",o),document.removeEventListener("selectionchange",c),document.removeEventListener("scroll",s,!0)}),(u,d)=>{const _=tt("GnButton");return v(),ze(Ji,{to:"body"},[n.value?(v(),x("div",{key:0,class:"selection-toolbar",style:Da({top:a.value.y+"px",left:a.value.x+"px"}),onMousedown:d[0]||(d[0]=ga(()=>{},["prevent"]))},[ne(_,{variant:"warning",size:"sm",icon:"ph ph-quotes",style:{color:"var(--gn-color-black)"},title:"Reply to selection",onClick:l},{default:Be(()=>[...d[1]||(d[1]=[$e(" Reply ",-1)])]),_:1})],36)):J("",!0)])}}},tS=ht(_R,[["__scopeId","data-v-b94aaefd"]]),pR=Object.freeze(Object.defineProperty({__proto__:null,default:tS},Symbol.toStringTag,{value:"Module"}));function tr(t){if(!t)return"";let e;try{e=new URL(t,window.location.origin)}catch{return t}return e.origin===window.location.origin?`${e.pathname}${e.search}${e.hash}`:e.href}function Pi(t){return t?new URL(t,window.location.origin).href:""}function mR(t,e){const n=tr(t);return!n||!e?n:`${n}${n.includes("?")?"&":"?"}v=${encodeURIComponent(e)}`}function nS(t,e){const n=new URL(`/content-viewers/${t}.html`,window.location.origin);return n.searchParams.set("url",e),n.href}function gR(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}var Ns,g_;function ER(){if(g_)return Ns;g_=1;function t(k){return k instanceof Map?k.clear=k.delete=k.set=function(){throw new Error("map is read-only")}:k instanceof Set&&(k.add=k.clear=k.delete=function(){throw new Error("set is read-only")}),Object.freeze(k),Object.getOwnPropertyNames(k).forEach(V=>{const se=k[V],Ie=typeof se;(Ie==="object"||Ie==="function")&&!Object.isFrozen(se)&&t(se)}),k}class e{constructor(V){V.data===void 0&&(V.data={}),this.data=V.data,this.isMatchIgnored=!1}ignoreMatch(){this.isMatchIgnored=!0}}function n(k){return k.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function a(k,...V){const se=Object.create(null);for(const Ie in k)se[Ie]=k[Ie];return V.forEach(function(Ie){for(const mt in Ie)se[mt]=Ie[mt]}),se}const r="    ",i=k=>!!k.scope,s=(k,{prefix:V})=>{if(k.startsWith("language:"))return k.replace("language:","language-");if(k.includes(".")){const se=k.split(".");return[`${V}${se.shift()}`,...se.map((Ie,mt)=>`${Ie}${"_".repeat(mt+1)}`)].join(" ")}return`${V}${k}`};class o{constructor(V,se){this.buffer="",this.classPrefix=se.classPrefix,V.walk(this)}addText(V){this.buffer+=n(V)}openNode(V){if(!i(V))return;const se=s(V.scope,{prefix:this.classPrefix});this.span(se)}closeNode(V){i(V)&&(this.buffer+=r)}value(){return this.buffer}span(V){this.buffer+=``}}const c=(k={})=>{const V={children:[]};return Object.assign(V,k),V};class l{constructor(){this.rootNode=c(),this.stack=[this.rootNode]}get top(){return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(V){this.top.children.push(V)}openNode(V){const se=c({scope:V});this.add(se),this.stack.push(se)}closeNode(){if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}walk(V){return this.constructor._walk(V,this.rootNode)}static _walk(V,se){return typeof se=="string"?V.addText(se):se.children&&(V.openNode(se),se.children.forEach(Ie=>this._walk(V,Ie)),V.closeNode(se)),V}static _collapse(V){typeof V!="string"&&V.children&&(V.children.every(se=>typeof se=="string")?V.children=[V.children.join("")]:V.children.forEach(se=>{l._collapse(se)}))}}class u extends l{constructor(V){super(),this.options=V}addText(V){V!==""&&this.add(V)}startScope(V){this.openNode(V)}endScope(){this.closeNode()}__addSublanguage(V,se){const Ie=V.root;se&&(Ie.scope=`language:${se}`),this.add(Ie)}toHTML(){return new o(this,this.options).value()}finalize(){return this.closeAllNodes(),!0}}function d(k){return k?typeof k=="string"?k:k.source:null}function _(k){return E("(?=",k,")")}function m(k){return E("(?:",k,")*")}function p(k){return E("(?:",k,")?")}function E(...k){return k.map(se=>d(se)).join("")}function b(k){const V=k[k.length-1];return typeof V=="object"&&V.constructor===Object?(k.splice(k.length-1,1),V):{}}function I(...k){return"("+(b(k).capture?"":"?:")+k.map(Ie=>d(Ie)).join("|")+")"}function R(k){return new RegExp(k.toString()+"|").exec("").length-1}function y(k,V){const se=k&&k.exec(V);return se&&se.index===0}const L=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;function U(k,{joinWith:V}){let se=0;return k.map(Ie=>{se+=1;const mt=se;let _t=d(Ie),ve="";for(;_t.length>0;){const me=L.exec(_t);if(!me){ve+=_t;break}ve+=_t.substring(0,me.index),_t=_t.substring(me.index+me[0].length),me[0][0]==="\\"&&me[1]?ve+="\\"+String(Number(me[1])+mt):(ve+=me[0],me[0]==="("&&se++)}return ve}).map(Ie=>`(${Ie})`).join(V)}const h=/\b\B/,N="[a-zA-Z]\\w*",C="[a-zA-Z_]\\w*",f="\\b\\d+(\\.\\d+)?",A="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",w="\\b(0b[01]+)",F="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",j=(k={})=>{const V=/^#![ ]*\//;return k.binary&&(k.begin=E(V,/.*\b/,k.binary,/\b.*/)),a({scope:"meta",begin:V,end:/$/,relevance:0,"on:begin":(se,Ie)=>{se.index!==0&&Ie.ignoreMatch()}},k)},_e={begin:"\\\\[\\s\\S]",relevance:0},be={scope:"string",begin:"'",end:"'",illegal:"\\n",contains:[_e]},oe={scope:"string",begin:'"',end:'"',illegal:"\\n",contains:[_e]},pe={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/},Ce=function(k,V,se={}){const Ie=a({scope:"comment",begin:k,end:V,contains:[]},se);Ie.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 mt=I("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 Ie.contains.push({begin:E(/[ ]+/,"(",mt,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),Ie},ot=Ce("//","$"),lt=Ce("/\\*","\\*/"),at=Ce("#","$"),We={scope:"number",begin:f,relevance:0},Ae={scope:"number",begin:A,relevance:0},He={scope:"number",begin:w,relevance:0},ke={scope:"regexp",begin:/\/(?=[^/\n]*\/)/,end:/\/[gimuy]*/,contains:[_e,{begin:/\[/,end:/\]/,relevance:0,contains:[_e]}]},rt={scope:"title",begin:N,relevance:0},je={scope:"title",begin:C,relevance:0},Ke={begin:"\\.\\s*"+C,relevance:0};var ut=Object.freeze({__proto__:null,APOS_STRING_MODE:be,BACKSLASH_ESCAPE:_e,BINARY_NUMBER_MODE:He,BINARY_NUMBER_RE:w,COMMENT:Ce,C_BLOCK_COMMENT_MODE:lt,C_LINE_COMMENT_MODE:ot,C_NUMBER_MODE:Ae,C_NUMBER_RE:A,END_SAME_AS_BEGIN:function(k){return Object.assign(k,{"on:begin":(V,se)=>{se.data._beginMatch=V[1]},"on:end":(V,se)=>{se.data._beginMatch!==V[1]&&se.ignoreMatch()}})},HASH_COMMENT_MODE:at,IDENT_RE:N,MATCH_NOTHING_RE:h,METHOD_GUARD:Ke,NUMBER_MODE:We,NUMBER_RE:f,PHRASAL_WORDS_MODE:pe,QUOTE_STRING_MODE:oe,REGEXP_MODE:ke,RE_STARTERS_RE:F,SHEBANG:j,TITLE_MODE:rt,UNDERSCORE_IDENT_RE:C,UNDERSCORE_TITLE_MODE:je});function bt(k,V){k.input[k.index-1]==="."&&V.ignoreMatch()}function D(k,V){k.className!==void 0&&(k.scope=k.className,delete k.className)}function P(k,V){V&&k.beginKeywords&&(k.begin="\\b("+k.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",k.__beforeBegin=bt,k.keywords=k.keywords||k.beginKeywords,delete k.beginKeywords,k.relevance===void 0&&(k.relevance=0))}function z(k,V){Array.isArray(k.illegal)&&(k.illegal=I(...k.illegal))}function K(k,V){if(k.match){if(k.begin||k.end)throw new Error("begin & end are not supported with match");k.begin=k.match,delete k.match}}function Z(k,V){k.relevance===void 0&&(k.relevance=1)}const W=(k,V)=>{if(!k.beforeMatch)return;if(k.starts)throw new Error("beforeMatch cannot be used with starts");const se=Object.assign({},k);Object.keys(k).forEach(Ie=>{delete k[Ie]}),k.keywords=se.keywords,k.begin=E(se.beforeMatch,_(se.begin)),k.starts={relevance:0,contains:[Object.assign(se,{endsParent:!0})]},k.relevance=0,delete se.beforeMatch},de=["of","and","for","in","not","or","if","then","parent","list","value"],ae="keyword";function re(k,V,se=ae){const Ie=Object.create(null);return typeof k=="string"?mt(se,k.split(" ")):Array.isArray(k)?mt(se,k):Object.keys(k).forEach(function(_t){Object.assign(Ie,re(k[_t],V,_t))}),Ie;function mt(_t,ve){V&&(ve=ve.map(me=>me.toLowerCase())),ve.forEach(function(me){const De=me.split("|");Ie[De[0]]=[_t,ee(De[0],De[1])]})}}function ee(k,V){return V?Number(V):Ne(k)?0:1}function Ne(k){return de.includes(k.toLowerCase())}const ce={},Re=k=>{console.error(k)},ye=(k,...V)=>{console.log(`WARN: ${k}`,...V)},Fe=(k,V)=>{ce[`${k}/${V}`]||(console.log(`Deprecated as of ${k}. ${V}`),ce[`${k}/${V}`]=!0)},qe=new Error;function Qe(k,V,{key:se}){let Ie=0;const mt=k[se],_t={},ve={};for(let me=1;me<=V.length;me++)ve[me+Ie]=mt[me],_t[me+Ie]=!0,Ie+=R(V[me-1]);k[se]=ve,k[se]._emit=_t,k[se]._multi=!0}function et(k){if(Array.isArray(k.begin)){if(k.skip||k.excludeBegin||k.returnBegin)throw Re("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),qe;if(typeof k.beginScope!="object"||k.beginScope===null)throw Re("beginScope must be object"),qe;Qe(k,k.begin,{key:"beginScope"}),k.begin=U(k.begin,{joinWith:""})}}function dt(k){if(Array.isArray(k.end)){if(k.skip||k.excludeEnd||k.returnEnd)throw Re("skip, excludeEnd, returnEnd not compatible with endScope: {}"),qe;if(typeof k.endScope!="object"||k.endScope===null)throw Re("endScope must be object"),qe;Qe(k,k.end,{key:"endScope"}),k.end=U(k.end,{joinWith:""})}}function Lt(k){k.scope&&typeof k.scope=="object"&&k.scope!==null&&(k.beginScope=k.scope,delete k.scope)}function Mt(k){Lt(k),typeof k.beginScope=="string"&&(k.beginScope={_wrap:k.beginScope}),typeof k.endScope=="string"&&(k.endScope={_wrap:k.endScope}),et(k),dt(k)}function Vt(k){function V(ve,me){return new RegExp(d(ve),"m"+(k.case_insensitive?"i":"")+(k.unicodeRegex?"u":"")+(me?"g":""))}class se{constructor(){this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}addRule(me,De){De.position=this.position++,this.matchIndexes[this.matchAt]=De,this.regexes.push([De,me]),this.matchAt+=R(me)+1}compile(){this.regexes.length===0&&(this.exec=()=>null);const me=this.regexes.map(De=>De[1]);this.matcherRe=V(U(me,{joinWith:"|"}),!0),this.lastIndex=0}exec(me){this.matcherRe.lastIndex=this.lastIndex;const De=this.matcherRe.exec(me);if(!De)return null;const it=De.findIndex((Ft,kt)=>kt>0&&Ft!==void 0),ct=this.matchIndexes[it];return De.splice(0,it),Object.assign(De,ct)}}class Ie{constructor(){this.rules=[],this.multiRegexes=[],this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(me){if(this.multiRegexes[me])return this.multiRegexes[me];const De=new se;return this.rules.slice(me).forEach(([it,ct])=>De.addRule(it,ct)),De.compile(),this.multiRegexes[me]=De,De}resumingScanAtSamePosition(){return this.regexIndex!==0}considerAll(){this.regexIndex=0}addRule(me,De){this.rules.push([me,De]),De.type==="begin"&&this.count++}exec(me){const De=this.getMatcher(this.regexIndex);De.lastIndex=this.lastIndex;let it=De.exec(me);if(this.resumingScanAtSamePosition()&&!(it&&it.index===this.lastIndex)){const ct=this.getMatcher(0);ct.lastIndex=this.lastIndex+1,it=ct.exec(me)}return it&&(this.regexIndex+=it.position+1,this.regexIndex===this.count&&this.considerAll()),it}}function mt(ve){const me=new Ie;return ve.contains.forEach(De=>me.addRule(De.begin,{rule:De,type:"begin"})),ve.terminatorEnd&&me.addRule(ve.terminatorEnd,{type:"end"}),ve.illegal&&me.addRule(ve.illegal,{type:"illegal"}),me}function _t(ve,me){const De=ve;if(ve.isCompiled)return De;[D,K,Mt,W].forEach(ct=>ct(ve,me)),k.compilerExtensions.forEach(ct=>ct(ve,me)),ve.__beforeBegin=null,[P,z,Z].forEach(ct=>ct(ve,me)),ve.isCompiled=!0;let it=null;return typeof ve.keywords=="object"&&ve.keywords.$pattern&&(ve.keywords=Object.assign({},ve.keywords),it=ve.keywords.$pattern,delete ve.keywords.$pattern),it=it||/\w+/,ve.keywords&&(ve.keywords=re(ve.keywords,k.case_insensitive)),De.keywordPatternRe=V(it,!0),me&&(ve.begin||(ve.begin=/\B|\b/),De.beginRe=V(De.begin),!ve.end&&!ve.endsWithParent&&(ve.end=/\B|\b/),ve.end&&(De.endRe=V(De.end)),De.terminatorEnd=d(De.end)||"",ve.endsWithParent&&me.terminatorEnd&&(De.terminatorEnd+=(ve.end?"|":"")+me.terminatorEnd)),ve.illegal&&(De.illegalRe=V(ve.illegal)),ve.contains||(ve.contains=[]),ve.contains=[].concat(...ve.contains.map(function(ct){return vt(ct==="self"?ve:ct)})),ve.contains.forEach(function(ct){_t(ct,De)}),ve.starts&&_t(ve.starts,me),De.matcher=mt(De),De}if(k.compilerExtensions||(k.compilerExtensions=[]),k.contains&&k.contains.includes("self"))throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");return k.classNameAliases=a(k.classNameAliases||{}),_t(k)}function Ut(k){return k?k.endsWithParent||Ut(k.starts):!1}function vt(k){return k.variants&&!k.cachedVariants&&(k.cachedVariants=k.variants.map(function(V){return a(k,{variants:null},V)})),k.cachedVariants?k.cachedVariants:Ut(k)?a(k,{starts:k.starts?a(k.starts):null}):Object.isFrozen(k)?a(k):k}var O="11.11.1";class G extends Error{constructor(V,se){super(V),this.name="HTMLInjectionError",this.html=se}}const Q=n,fe=a,he=Symbol("nomatch"),we=7,Pe=function(k){const V=Object.create(null),se=Object.create(null),Ie=[];let mt=!0;const _t="Could not find the language '{}', did you forget to load/include a language module?",ve={disableAutodetect:!0,name:"Plain text",contains:[]};let me={ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",cssSelector:"pre code",languages:null,__emitter:u};function De(le){return me.noHighlightRe.test(le)}function it(le){let xe=le.className+" ";xe+=le.parentNode?le.parentNode.className:"";const Xe=me.languageDetectRe.exec(xe);if(Xe){const Nt=Zt(Xe[1]);return Nt||(ye(_t.replace("{}",Xe[1])),ye("Falling back to no-highlight mode for this block.",le)),Nt?Xe[1]:"no-highlight"}return xe.split(/\s+/).find(Nt=>De(Nt)||Zt(Nt))}function ct(le,xe,Xe){let Nt="",Pt="";typeof xe=="object"?(Nt=le,Xe=xe.ignoreIllegals,Pt=xe.language):(Fe("10.7.0","highlight(lang, code, ...args) has been deprecated."),Fe("10.7.0",`Please use highlight(code, options) instead. +https://github.com/highlightjs/highlight.js/issues/2277`),Pt=le,Nt=xe),Xe===void 0&&(Xe=!0);const ln={code:Nt,language:Pt};$n("before:highlight",ln);const Pn=ln.result?ln.result:Ft(ln.language,ln.code,Xe);return Pn.code=ln.code,$n("after:highlight",Pn),Pn}function Ft(le,xe,Xe,Nt){const Pt=Object.create(null);function ln(S,M){return S.keywords[M]}function Pn(){if(!Ve.keywords){qt.addText(Tt);return}let S=0;Ve.keywordPatternRe.lastIndex=0;let M=Ve.keywordPatternRe.exec(Tt),H="";for(;M;){H+=Tt.substring(S,M.index);const te=cn.case_insensitive?M[0].toLowerCase():M[0],Ee=ln(Ve,te);if(Ee){const[Le,Ot]=Ee;if(qt.addText(H),H="",Pt[te]=(Pt[te]||0)+1,Pt[te]<=we&&(Hn+=Ot),Le.startsWith("_"))H+=M[0];else{const wt=cn.classNameAliases[Le]||Le;en(M[0],wt)}}else H+=M[0];S=Ve.keywordPatternRe.lastIndex,M=Ve.keywordPatternRe.exec(Tt)}H+=Tt.substring(S),qt.addText(H)}function Ta(){if(Tt==="")return;let S=null;if(typeof Ve.subLanguage=="string"){if(!V[Ve.subLanguage]){qt.addText(Tt);return}S=Ft(Ve.subLanguage,Tt,!0,Ga[Ve.subLanguage]),Ga[Ve.subLanguage]=S._top}else S=on(Tt,Ve.subLanguage.length?Ve.subLanguage:null);Ve.relevance>0&&(Hn+=S.relevance),qt.__addSublanguage(S._emitter,S.language)}function Jt(){Ve.subLanguage!=null?Ta():Pn(),Tt=""}function en(S,M){S!==""&&(qt.startScope(M),qt.addText(S),qt.endScope())}function Pa(S,M){let H=1;const te=M.length-1;for(;H<=te;){if(!S._emit[H]){H++;continue}const Ee=cn.classNameAliases[S[H]]||S[H],Le=M[H];Ee?en(Le,Ee):(Tt=Le,Pn(),Tt=""),H++}}function ha(S,M){return S.scope&&typeof S.scope=="string"&&qt.openNode(cn.classNameAliases[S.scope]||S.scope),S.beginScope&&(S.beginScope._wrap?(en(Tt,cn.classNameAliases[S.beginScope._wrap]||S.beginScope._wrap),Tt=""):S.beginScope._multi&&(Pa(S.beginScope,M),Tt="")),Ve=Object.create(S,{parent:{value:Ve}}),Ve}function qn(S,M,H){let te=y(S.endRe,H);if(te){if(S["on:end"]){const Ee=new e(S);S["on:end"](M,Ee),Ee.isMatchIgnored&&(te=!1)}if(te){for(;S.endsParent&&S.parent;)S=S.parent;return S}}if(S.endsWithParent)return qn(S.parent,M,H)}function va(S){return Ve.matcher.regexIndex===0?(Tt+=S[0],1):(ie=!0,0)}function vn(S){const M=S[0],H=S.rule,te=new e(H),Ee=[H.__beforeBegin,H["on:begin"]];for(const Le of Ee)if(Le&&(Le(S,te),te.isMatchIgnored))return va(M);return H.skip?Tt+=M:(H.excludeBegin&&(Tt+=M),Jt(),!H.returnBegin&&!H.excludeBegin&&(Tt=M)),ha(H,S),H.returnBegin?0:M.length}function di(S){const M=S[0],H=xe.substring(S.index),te=qn(Ve,S,H);if(!te)return he;const Ee=Ve;Ve.endScope&&Ve.endScope._wrap?(Jt(),en(M,Ve.endScope._wrap)):Ve.endScope&&Ve.endScope._multi?(Jt(),Pa(Ve.endScope,S)):Ee.skip?Tt+=M:(Ee.returnEnd||Ee.excludeEnd||(Tt+=M),Jt(),Ee.excludeEnd&&(Tt=M));do Ve.scope&&qt.closeNode(),!Ve.skip&&!Ve.subLanguage&&(Hn+=Ve.relevance),Ve=Ve.parent;while(Ve!==te.parent);return te.starts&&ha(te.starts,S),Ee.returnEnd?0:M.length}function Ua(){const S=[];for(let M=Ve;M!==cn;M=M.parent)M.scope&&S.unshift(M.scope);S.forEach(M=>qt.openNode(M))}let Fa={};function Ba(S,M){const H=M&&M[0];if(Tt+=S,H==null)return Jt(),0;if(Fa.type==="begin"&&M.type==="end"&&Fa.index===M.index&&H===""){if(Tt+=xe.slice(M.index,M.index+1),!mt){const te=new Error(`0 width match regex (${le})`);throw te.languageName=le,te.badRule=Fa.rule,te}return 1}if(Fa=M,M.type==="begin")return vn(M);if(M.type==="illegal"&&!Xe){const te=new Error('Illegal lexeme "'+H+'" for mode "'+(Ve.scope||"")+'"');throw te.mode=Ve,te}else if(M.type==="end"){const te=di(M);if(te!==he)return te}if(M.type==="illegal"&&H==="")return Tt+=` +`,1;if(na>1e5&&na>M.index*3)throw new Error("potential infinite loop, way more iterations than matches");return Tt+=H,H.length}const cn=Zt(le);if(!cn)throw Re(_t.replace("{}",le)),new Error('Unknown language: "'+le+'"');const cr=Vt(cn);let Ra="",Ve=Nt||cr;const Ga={},qt=new me.__emitter(me);Ua();let Tt="",Hn=0,un=0,na=0,ie=!1;try{if(cn.__emitTokens)cn.__emitTokens(xe,qt);else{for(Ve.matcher.considerAll();;){na++,ie?ie=!1:Ve.matcher.considerAll(),Ve.matcher.lastIndex=un;const S=Ve.matcher.exec(xe);if(!S)break;const M=xe.substring(un,S.index),H=Ba(M,S);un=S.index+H}Ba(xe.substring(un))}return qt.finalize(),Ra=qt.toHTML(),{language:le,value:Ra,relevance:Hn,illegal:!1,_emitter:qt,_top:Ve}}catch(S){if(S.message&&S.message.includes("Illegal"))return{language:le,value:Q(xe),illegal:!0,relevance:0,_illegalBy:{message:S.message,index:un,context:xe.slice(un-100,un+100),mode:S.mode,resultSoFar:Ra},_emitter:qt};if(mt)return{language:le,value:Q(xe),illegal:!1,relevance:0,errorRaised:S,_emitter:qt,_top:Ve};throw S}}function kt(le){const xe={value:Q(le),illegal:!1,relevance:0,_top:ve,_emitter:new me.__emitter(me)};return xe._emitter.addText(le),xe}function on(le,xe){xe=xe||me.languages||Object.keys(V);const Xe=kt(le),Nt=xe.filter(Zt).filter(In).map(Jt=>Ft(Jt,le,!1));Nt.unshift(Xe);const Pt=Nt.sort((Jt,en)=>{if(Jt.relevance!==en.relevance)return en.relevance-Jt.relevance;if(Jt.language&&en.language){if(Zt(Jt.language).supersetOf===en.language)return 1;if(Zt(en.language).supersetOf===Jt.language)return-1}return 0}),[ln,Pn]=Pt,Ta=ln;return Ta.secondBest=Pn,Ta}function Qt(le,xe,Xe){const Nt=xe&&se[xe]||Xe;le.classList.add("hljs"),le.classList.add(`language-${Nt}`)}function Mn(le){let xe=null;const Xe=it(le);if(De(Xe))return;if($n("before:highlightElement",{el:le,language:Xe}),le.dataset.highlighted){console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",le);return}if(le.children.length>0&&(me.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(le)),me.throwUnescapedHTML))throw new G("One of your code blocks includes unescaped HTML.",le.innerHTML);xe=le;const Nt=xe.textContent,Pt=Xe?ct(Nt,{language:Xe,ignoreIllegals:!0}):on(Nt);le.innerHTML=Pt.value,le.dataset.highlighted="yes",Qt(le,Xe,Pt.language),le.result={language:Pt.language,re:Pt.relevance,relevance:Pt.relevance},Pt.secondBest&&(le.secondBest={language:Pt.secondBest.language,relevance:Pt.secondBest.relevance}),$n("after:highlightElement",{el:le,result:Pt,text:Nt})}function lr(le){me=fe(me,le)}const B=()=>{Te(),Fe("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")};function q(){Te(),Fe("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")}let Oe=!1;function Te(){function le(){Te()}if(document.readyState==="loading"){Oe||window.addEventListener("DOMContentLoaded",le,!1),Oe=!0;return}document.querySelectorAll(me.cssSelector).forEach(Mn)}function Se(le,xe){let Xe=null;try{Xe=xe(k)}catch(Nt){if(Re("Language definition for '{}' could not be registered.".replace("{}",le)),mt)Re(Nt);else throw Nt;Xe=ve}Xe.name||(Xe.name=le),V[le]=Xe,Xe.rawDefinition=xe.bind(null,k),Xe.aliases&&jt(Xe.aliases,{languageName:le})}function $t(le){delete V[le];for(const xe of Object.keys(se))se[xe]===le&&delete se[xe]}function Yt(){return Object.keys(V)}function Zt(le){return le=(le||"").toLowerCase(),V[le]||V[se[le]]}function jt(le,{languageName:xe}){typeof le=="string"&&(le=[le]),le.forEach(Xe=>{se[Xe.toLowerCase()]=xe})}function In(le){const xe=Zt(le);return xe&&!xe.disableAutodetect}function ba(le){le["before:highlightBlock"]&&!le["before:highlightElement"]&&(le["before:highlightElement"]=xe=>{le["before:highlightBlock"](Object.assign({block:xe.el},xe))}),le["after:highlightBlock"]&&!le["after:highlightElement"]&&(le["after:highlightElement"]=xe=>{le["after:highlightBlock"](Object.assign({block:xe.el},xe))})}function ta(le){ba(le),Ie.push(le)}function Ar(le){const xe=Ie.indexOf(le);xe!==-1&&Ie.splice(xe,1)}function $n(le,xe){const Xe=le;Ie.forEach(function(Nt){Nt[Xe]&&Nt[Xe](xe)})}function kn(le){return Fe("10.7.0","highlightBlock will be removed entirely in v12.0"),Fe("10.7.0","Please use highlightElement now."),Mn(le)}Object.assign(k,{highlight:ct,highlightAuto:on,highlightAll:Te,highlightElement:Mn,highlightBlock:kn,configure:lr,initHighlighting:B,initHighlightingOnLoad:q,registerLanguage:Se,unregisterLanguage:$t,listLanguages:Yt,getLanguage:Zt,registerAliases:jt,autoDetection:In,inherit:fe,addPlugin:ta,removePlugin:Ar}),k.debugMode=function(){mt=!1},k.safeMode=function(){mt=!0},k.versionString=O,k.regex={concat:E,lookahead:_,either:I,optional:p,anyNumberOfTimes:m};for(const le in ut)typeof ut[le]=="object"&&t(ut[le]);return Object.assign(k,ut),k},Je=Pe({});return Je.newInstance=()=>Pe({}),Ns=Je,Je.HighlightJS=Je,Je.default=Je,Ns}var Os,E_;function fR(){if(E_)return Os;E_=1;function t(e){const n="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]+",i="далее "+"возврат вызватьисключение выполнить для если и из или иначе иначеесли исключение каждого конецесли конецпопытки конеццикла не новый перейти перем по пока попытка прервать продолжить тогда цикл экспорт ",c="загрузитьизфайла "+"вебклиент вместо внешнеесоединение клиент конецобласти мобильноеприложениеклиент мобильноеприложениесервер наклиенте наклиентенасервере наклиентенасерверебезконтекста насервере насерверебезконтекста область перед после сервер толстыйклиентобычноеприложение толстыйклиентуправляемоеприложение тонкийклиент ",m="разделительстраниц разделительстрок символтабуляции "+"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 файловыепотоки фоновыезадания хранилищанастроек хранилищевариантовотчетов хранилищенастроекданныхформ хранилищеобщихнастроек хранилищепользовательскихнастроекдинамическихсписков хранилищепользовательскихнастроекотчетов хранилищесистемныхнастроек ",lt="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 типэлементаинформацииовыполненииобновленияконфигурациибазыданных уровеньизоляциитранзакций хешфункция частидаты",Ae="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 деревозначений массив соответствие списокзначений структура таблицазначений фиксированнаяструктура фиксированноесоответствие фиксированныймассив ",He="null истина ложь неопределено",ke=e.inherit(e.NUMBER_MODE),rt={className:"string",begin:'"|\\|',end:'"|$',contains:[{begin:'""'}]},je={begin:"'",end:"'",excludeBegin:!0,excludeEnd:!0,contains:[{className:"number",begin:"\\d{4}([\\.\\\\/:-]?\\d{2}){0,5}"}]},Ke={match:/[;()+\-:=,]/,className:"punctuation",relevance:0},Et=e.inherit(e.C_LINE_COMMENT_MODE),ut={className:"meta",begin:"#|&",end:"$",keywords:{$pattern:n,keyword:i+c},contains:[Et]},bt={className:"symbol",begin:"~",end:";|:",excludeEnd:!0},D={className:"function",variants:[{begin:"процедура|функция",end:"\\)",keywords:"процедура функция"},{begin:"конецпроцедуры|конецфункции",keywords:"конецпроцедуры конецфункции"}],contains:[{begin:"\\(",end:"\\)",endsParent:!0,contains:[{className:"params",begin:n,end:",",excludeEnd:!0,endsWithParent:!0,keywords:{$pattern:n,keyword:"знач",literal:He},contains:[ke,rt,je]},Et]},e.inherit(e.TITLE_MODE,{begin:n})]};return{name:"1C:Enterprise",case_insensitive:!0,keywords:{$pattern:n,keyword:i,built_in:m,class:lt,type:Ae,literal:He},contains:[ut,D,Et,bt,ke,rt,je,Ke]}}return Os=t,Os}var As,f_;function SR(){if(f_)return As;f_=1;function t(e){const n=e.regex,a=/^[a-zA-Z][a-zA-Z0-9-]*/,r=["ALPHA","BIT","CHAR","CR","CRLF","CTL","DIGIT","DQUOTE","HEXDIG","HTAB","LF","LWSP","OCTET","SP","VCHAR","WSP"],i=e.COMMENT(/;/,/$/),s={scope:"symbol",match:/%b[0-1]+(-[0-1]+|(\.[0-1]+)+)?/},o={scope:"symbol",match:/%d[0-9]+(-[0-9]+|(\.[0-9]+)+)?/},c={scope:"symbol",match:/%x[0-9A-F]+(-[0-9A-F]+|(\.[0-9A-F]+)+)?/},l={scope:"symbol",match:/%[si](?=".*")/},u={scope:"attribute",match:n.concat(a,/(?=\s*=)/)};return{name:"Augmented Backus-Naur Form",illegal:/[!@#$^&',?+~`|:]/,keywords:r,contains:[{scope:"operator",match:/=\/?/},u,i,s,o,c,l,e.QUOTE_STRING_MODE,e.NUMBER_MODE]}}return As=t,As}var Is,S_;function bR(){if(S_)return Is;S_=1;function t(e){const n=e.regex,a=["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:n.concat(/"/,n.either(...a)),end:/"/,keywords:a,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 Is=t,Is}var Ds,b_;function TR(){if(b_)return Ds;b_=1;function t(e){const n=e.regex,a=/[a-zA-Z_$][a-zA-Z0-9_$]*/,r=n.concat(a,n.concat("(\\.",a,")*")),i=/([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/,s={className:"rest_arg",begin:/[.]{3}/,end:a,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+/,r],className:{1:"keyword",3:"title.class"}},{match:[/\b(?:class|interface|extends|implements)/,/\s+/,a],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:n.concat(/:\s*/,i)}]},e.METHOD_GUARD],illegal:/#/}}return Ds=t,Ds}var ws,T_;function hR(){if(T_)return ws;T_=1;function t(e){const n="\\d(_|\\d)*",a="[eE][-+]?"+n,r=n+"(\\."+n+")?("+a+")?",i="\\w+",o="\\b("+(n+"#"+i+"(\\."+i+")?#("+a+")?")+"|"+r+")",c="[A-Za-z](_?[A-Za-z0-9.])*",l=`[]\\{\\}%#'"`,u=e.COMMENT("--","$"),d={begin:"\\s+:\\s+",end:"\\s*(:=|;|\\)|=>|$)",illegal:l,contains:[{beginKeywords:"loop for declare others",endsParent:!0},{className:"keyword",beginKeywords:"not null constant access function procedure in out aliased exception"},{className:"type",begin:c,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:[u,{className:"string",begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{className:"string",begin:/'.'/},{className:"number",begin:o,relevance:0},{className:"symbol",begin:"'"+c},{className:"title",begin:"(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?",end:"(is|$)",keywords:"package body",excludeBegin:!0,excludeEnd:!0,illegal:l},{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:[u,{className:"title",begin:"(\\bwith\\s+)?\\b(function|procedure)\\s+",end:"(\\(|\\s+|$)",excludeBegin:!0,excludeEnd:!0,illegal:l},d,{className:"type",begin:"\\breturn\\s+",end:"(\\s+|;|$)",keywords:"return",excludeBegin:!0,excludeEnd:!0,endsParent:!0,illegal:l}]},{className:"type",begin:"\\b(sub)?type\\s+",end:"\\s+",keywords:"type",excludeBegin:!0,illegal:l},d]}}return ws=t,ws}var xs,h_;function vR(){if(h_)return xs;h_=1;function t(e){const n={className:"built_in",begin:"\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)"},a={className:"symbol",begin:"[a-zA-Z0-9_]+@"},r={className:"keyword",begin:"<",end:">",contains:[n,a]};return n.contains=[r],a.contains=[r],{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_]+"}]}]}]},n,a,{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 xs=t,xs}var Ls,v_;function RR(){if(v_)return Ls;v_=1;function t(e){const n={className:"number",begin:/[$%]\d+/},a={className:"number",begin:/\b\d+/},r={className:"number",begin:/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?/},i={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:[r,i,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",n]},r,a,e.QUOTE_STRING_MODE]}}],illegal:/\S/}}return Ls=t,Ls}var Ms,R_;function CR(){if(R_)return Ms;R_=1;function t(e){const n=e.regex,a=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),r={className:"params",begin:/\(/,end:/\)/,contains:["self",e.C_NUMBER_MODE,a]},i=e.COMMENT(/--/,/$/),s=e.COMMENT(/\(\*/,/\*\)/,{contains:["self",i]}),o=[i,s,e.HASH_COMMENT_MODE],c=[/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/],l=[/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:[a,e.C_NUMBER_MODE,{className:"built_in",begin:n.concat(/\b/,n.either(...l),/\b/)},{className:"built_in",begin:/^\s*return\b/},{className:"literal",begin:/\b(text item delimiters|current application|missing value)\b/},{className:"keyword",begin:n.concat(/\b/,n.either(...c),/\b/)},{beginKeywords:"on",illegal:/[${=;\n]/,contains:[e.UNDERSCORE_TITLE_MODE,r]},...o],illegal:/\/\/|->|=>|\[\[/}}return Ms=t,Ms}var ks,C_;function yR(){if(C_)return ks;C_=1;function t(e){const n=e.regex,a="[A-Za-z_][0-9A-Za-z_]*",r={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"]},i=["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:"\\$"+n.either(...i)},o={className:"number",variants:[{begin:"\\b(0[bB][01]+)"},{begin:"\\b(0[oO][0-7]+)"},{begin:e.C_NUMBER_RE}],relevance:0},c={className:"subst",begin:"\\$\\{",end:"\\}",keywords:r,contains:[]},l={className:"string",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE,c]};c.contains=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,l,o,e.REGEXP_MODE];const u=c.contains.concat([e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE]);return{name:"ArcGIS Arcade",case_insensitive:!0,keywords:r,contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,l,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,s,o,{begin:/[{,]\s*/,relevance:0,contains:[{begin:a+"\\s*:",returnBegin:!0,relevance:0,contains:[{className:"attr",begin:a,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:"(\\(.*?\\)|"+a+")\\s*=>",returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:a},{begin:/\(\s*\)/},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:r,contains:u}]}]}],relevance:0},{beginKeywords:"function",end:/\{/,excludeEnd:!0,contains:[e.inherit(e.TITLE_MODE,{className:"title.function",begin:a}),{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:u}],illegal:/\[|%/},{begin:/\$[(.]/}],illegal:/#(?!!)/}}return ks=t,ks}var Ps,y_;function NR(){if(y_)return Ps;y_=1;function t(n){const a=n.regex,r=n.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",s="[a-zA-Z_]\\w*::",c="(?!struct)("+i+"|"+a.optional(s)+"[a-zA-Z_]\\w*"+a.optional("<[^<>]+>")+")",l={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},d={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[n.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:"."},n.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},_={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},m={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},n.inherit(d,{className:"string"}),{className:"string",begin:/<.*?>/},r,n.C_BLOCK_COMMENT_MODE]},p={className:"title",begin:a.optional(s)+n.IDENT_RE,relevance:0},E=a.optional(s)+n.IDENT_RE+"\\s*\\(",b=["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"],I=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],R=["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"],h={type:I,keyword:b,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:R},N={className:"function.dispatch",relevance:0,keywords:{_hint:y},begin:a.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,n.IDENT_RE,a.lookahead(/(<[^<>]+>|)\s*\(/))},C=[N,m,l,r,n.C_BLOCK_COMMENT_MODE,_,d],f={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:h,contains:C.concat([{begin:/\(/,end:/\)/,keywords:h,contains:C.concat(["self"]),relevance:0}]),relevance:0},A={className:"function",begin:"("+c+"[\\*&\\s]+)+"+E,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:h,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:i,keywords:h,relevance:0},{begin:E,returnBegin:!0,contains:[p],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[d,_]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:h,relevance:0,contains:[r,n.C_BLOCK_COMMENT_MODE,d,_,l,{begin:/\(/,end:/\)/,keywords:h,relevance:0,contains:["self",r,n.C_BLOCK_COMMENT_MODE,d,_,l]}]},l,r,n.C_BLOCK_COMMENT_MODE,m]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:h,illegal:"",keywords:h,contains:["self",l]},{begin:n.IDENT_RE+"::",keywords:h},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}function e(n){const a={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"]},r=t(n),i=r.keywords;return i.type=[...i.type,...a.type],i.literal=[...i.literal,...a.literal],i.built_in=[...i.built_in,...a.built_in],i._hints=a._hints,r.name="Arduino",r.aliases=["ino"],r.supersetOf="cpp",r}return Ps=e,Ps}var Us,N_;function OR(){if(N_)return Us;N_=1;function t(e){const n={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)"},n,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 Us=t,Us}var Fs,O_;function AR(){if(O_)return Fs;O_=1;function t(e){const n=e.regex,a=n.concat(/[\p{L}_]/u,n.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),r=/[\p{L}0-9._:-]+/u,i={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:/\)/}),c=e.inherit(e.APOS_STRING_MODE,{className:"string"}),l=e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),u={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,l,c,o,{begin:/\[/,end:/\]/,contains:[{className:"meta",begin://,contains:[s,o,l,c]}]}]},e.COMMENT(//,{relevance:10}),{begin://,relevance:10},i,{className:"meta",end:/\?>/,variants:[{begin:/<\?xml/,relevance:10,contains:[l]},{begin:/<\?[a-z][a-z0-9]+/}]},{className:"tag",begin:/)/,end:/>/,keywords:{name:"style"},contains:[u],starts:{end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",begin:/)/,end:/>/,keywords:{name:"script"},contains:[u],starts:{end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{className:"tag",begin:/<>|<\/>/},{className:"tag",begin:n.concat(//,/>/,/\s/)))),end:/\/?>/,contains:[{className:"name",begin:a,relevance:0,starts:u}]},{className:"tag",begin:n.concat(/<\//,n.lookahead(n.concat(a,/>/))),contains:[{className:"name",begin:a,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}}return Fs=t,Fs}var Bs,A_;function IR(){if(A_)return Bs;A_=1;function t(e){const n=e.regex,a={begin:"^'{3,}[ \\t]*$",relevance:10},r=[{begin:/\\[*_`]/},{begin:/\\\\\*{2}[^\n]*?\*{2}/},{begin:/\\\\_{2}[^\n]*_{2}/},{begin:/\\\\`{2}[^\n]*`{2}/},{begin:/[:;}][*_`](?![*_`])/}],i=[{className:"strong",begin:/\*{2}([^\n]+?)\*{2}/},{className:"strong",begin:n.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:n.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},c={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},c,o,...r,...i,...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},a,{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 Bs=t,Bs}var Gs,I_;function DR(){if(I_)return Gs;I_=1;function t(e){const n=e.regex,a=["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"],r=["get","set","args","call"];return{name:"AspectJ",keywords:a,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:a.concat(r),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:n.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,contains:[e.UNDERSCORE_TITLE_MODE]}]},{begin:/[:]/,returnBegin:!0,end:/[{;]/,relevance:0,excludeEnd:!1,keywords:a,illegal:/["\[\]]/,contains:[{begin:n.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),keywords:a.concat(r),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:a,excludeEnd:!0,contains:[{begin:n.concat(e.UNDERSCORE_IDENT_RE,/\s*\(/),returnBegin:!0,relevance:0,contains:[e.UNDERSCORE_TITLE_MODE]},{className:"params",begin:/\(/,end:/\)/,relevance:0,keywords:a,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 Gs=t,Gs}var Ys,D_;function wR(){if(D_)return Ys;D_=1;function t(e){const n={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:[n,e.inherit(e.QUOTE_STRING_MODE,{contains:[n]}),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 Ys=t,Ys}var $s,w_;function xR(){if(w_)return $s;w_=1;function t(e){const n="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",a=["EndRegion","forcedef","forceref","ignorefunc","include","include-once","NoTrayIcon","OnAutoItStartRegister","pragma","Region","RequireAdmin","Tidy_Off","Tidy_On","Tidy_Parameters"],r="True False And Null Not Or Default",i="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_]+"},c={className:"string",variants:[{begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]}]},l={variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]},u={className:"meta",begin:"#",end:"$",keywords:{keyword:a},contains:[{begin:/\\\n/,relevance:0},{beginKeywords:"include",keywords:{keyword:"include"},end:"$",contains:[c,{className:"string",variants:[{begin:"<",end:">"},{begin:/"/,end:/"/,contains:[{begin:/""/,relevance:0}]},{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]}]}]},c,s]},d={className:"symbol",begin:"@[A-z0-9_]+"},_={beginKeywords:"Func",end:"$",illegal:"\\$|\\[|%",contains:[e.inherit(e.UNDERSCORE_TITLE_MODE,{className:"title.function"}),{className:"params",begin:"\\(",end:"\\)",contains:[o,c,l]}]};return{name:"AutoIt",case_insensitive:!0,illegal:/\/\*/,keywords:{keyword:n,built_in:i,literal:r},contains:[s,o,c,l,u,d,_]}}return $s=t,$s}var qs,x_;function LR(){if(x_)return qs;x_=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 qs=t,qs}var Hs,L_;function MR(){if(L_)return Hs;L_=1;function t(e){const n={className:"variable",variants:[{begin:/\$[\w\d#@][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},a="BEGIN END if else while do for in break continue delete next nextfile function func exit|10",r={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:a},contains:[n,r,e.REGEXP_MODE,e.HASH_COMMENT_MODE,e.NUMBER_MODE]}}return Hs=t,Hs}var Vs,M_;function kR(){if(M_)return Vs;M_=1;function t(e){const n=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+/,n,/\s+(extends|implements)\s+/,n]},{match:[/class\s+/,n]}],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 Vs=t,Vs}var zs,k_;function PR(){if(k_)return zs;k_=1;function t(e){const n=e.regex,a={},r={begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[a]}]};Object.assign(a,{className:"variable",variants:[{begin:n.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},r]});const i={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"})]}},c={className:"string",begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,a,i]};i.contains.push(c);const l={match:/\\"/},u={className:"string",begin:/'/,end:/'/},d={match:/\\'/},_={begin:/\$?\(\(/,end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},e.NUMBER_MODE,a]},m=["fish","bash","zsh","sh","csh","ksh","tcsh","dash","scsh"],p=e.SHEBANG({binary:`(${m.join("|")})`,relevance:10}),E={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,contains:[e.inherit(e.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0},b=["if","then","else","elif","fi","time","for","while","until","in","do","done","case","esac","coproc","function","select"],I=["true","false"],R={match:/(\/[a-z._-]+)+/},y=["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset"],L=["alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","sudo","type","typeset","ulimit","unalias"],U=["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"],h=["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:b,literal:I,built_in:[...y,...L,"set","shopt",...U,...h]},contains:[p,e.SHEBANG(),E,_,s,o,R,c,l,u,d,a]}}return zs=t,zs}var Ws,P_;function UR(){if(P_)return Ws;P_=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 Ws=t,Ws}var Ks,U_;function FR(){if(U_)return Ks;U_=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 Ks=t,Ks}var Qs,F_;function BR(){if(F_)return Qs;F_=1;function t(e){const n={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:[n]},n]}}return Qs=t,Qs}var Xs,B_;function GR(){if(B_)return Xs;B_=1;function t(e){const n=e.regex,a=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),r="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",o="("+r+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",c={className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{match:/\batomic_[a-z]{3,6}\b/}]},u={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})"/})]},d={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},_={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(u,{className:"string"}),{className:"string",begin:/<.*?>/},a,e.C_BLOCK_COMMENT_MODE]},m={className:"title",begin:n.optional(i)+e.IDENT_RE,relevance:0},p=n.optional(i)+e.IDENT_RE+"\\s*\\(",I={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"},R=[_,c,a,e.C_BLOCK_COMMENT_MODE,d,u],y={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:I,contains:R.concat([{begin:/\(/,end:/\)/,keywords:I,contains:R.concat(["self"]),relevance:0}]),relevance:0},L={begin:"("+o+"[\\*&\\s]+)+"+p,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:I,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:r,keywords:I,relevance:0},{begin:p,returnBegin:!0,contains:[e.inherit(m,{className:"title.function"})],relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:I,relevance:0,contains:[a,e.C_BLOCK_COMMENT_MODE,u,d,c,{begin:/\(/,end:/\)/,keywords:I,relevance:0,contains:["self",a,e.C_BLOCK_COMMENT_MODE,u,d,c]}]},c,a,e.C_BLOCK_COMMENT_MODE,_]};return{name:"C",aliases:["h"],keywords:I,disableAutodetect:!0,illegal:"=]/,contains:[{beginKeywords:"final class struct"},e.TITLE_MODE]}]),exports:{preprocessor:_,strings:u,keywords:I}}}return Xs=t,Xs}var Zs,G_;function YR(){if(G_)return Zs;G_=1;function t(e){const n=e.regex,a=["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"],r="false true",i=[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+)+/},c={className:"number",begin:"\\b\\d+(\\.\\d+)?(DT|D|T)",relevance:0},l={className:"string",begin:'"',end:'"'},u={match:[/procedure/,/\s+/,/[a-zA-Z_][\w@]*/,/\s*/],scope:{1:"keyword",3:"title.function"},contains:[{className:"params",begin:/\(/,end:/\)/,keywords:a,contains:[s,o,e.NUMBER_MODE]},...i]},d=["Table","Form","Report","Dataport","Codeunit","XMLport","MenuSuite","Page","Query"],_={match:[/OBJECT/,/\s+/,n.either(...d),/\s+/,/\d+/,/\s+(?=[^\s])/,/.*/,/$/],relevance:3,scope:{1:"keyword",3:"type",5:"number",7:"title"}};return{name:"C/AL",case_insensitive:!0,keywords:{keyword:a,literal:r},illegal:/\/\*/,contains:[{match:/[\w]+(?=\=)/,scope:"attribute",relevance:0},s,o,c,l,e.NUMBER_MODE,_,u]}}return Zs=t,Zs}var Js,Y_;function $R(){if(Y_)return Js;Y_=1;function t(e){const n=["struct","enum","interface","union","group","import","using","const","annotation","extends","in","of","on","as","with","from","fixed"],a=["Void","Bool","Int8","Int16","Int32","Int64","UInt8","UInt16","UInt32","UInt64","Float32","Float64","Text","Data","AnyPointer","AnyStruct","Capability","List"],r=["true","false"],i={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:n,type:a,literal:r},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/},i]}}return Js=t,Js}var js,$_;function qR(){if($_)return js;$_=1;function t(e){const n=["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"],a=["shared","abstract","formal","default","actual","variable","late","native","deprecated","final","sealed","annotation","suppressWarnings","small"],r=["doc","by","license","see","throws","tagged"],i={className:"subst",excludeBegin:!0,excludeEnd:!0,begin:/``/,end:/``/,keywords:n,relevance:10},s=[{className:"string",begin:'"""',end:'"""',relevance:10},{className:"string",begin:'"',end:'"',contains:[i]},{className:"string",begin:"'",end:"'"},{className:"number",begin:"#[0-9a-fA-F_]+|\\$[01_]+|[0-9_]+(?:\\.[0-9_](?:[eE][+-]?\\d+)?)?[kMGTPmunpf]?",relevance:0}];return i.contains=s,{name:"Ceylon",keywords:{keyword:n.concat(a),meta:r},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 js=t,js}var eo,q_;function HR(){if(q_)return eo;q_=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 eo=t,eo}var to,H_;function VR(){if(H_)return to;H_=1;function t(e){const n="a-zA-Z_\\-!.?+*=<>&'",a="[#]?["+n+"]["+n+"0-9/;:$#]*",r="def defonce defprotocol defstruct defmulti defmethod defn- defn defmacro deftype defrecord",i={$pattern:a,built_in:r+" 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:a,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?/}]},c={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}]},l={scope:"regex",begin:/#"/,end:/"/,contains:[e.BACKSLASH_ESCAPE]},u=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),d={scope:"punctuation",match:/,/,relevance:0},_=e.COMMENT(";","$",{relevance:0}),m={className:"literal",begin:/\b(true|false|nil)\b/},p={begin:"\\[|(#::?"+a+")?\\{",end:"[\\]\\}]",relevance:0},E={className:"symbol",begin:"[:]{1,2}"+a},b={begin:"\\(",end:"\\)"},I={endsWithParent:!0,relevance:0},R={keywords:i,className:"name",begin:a,relevance:0,starts:I},y=[d,b,c,l,u,_,E,p,o,m,s],L={beginKeywords:r,keywords:{$pattern:a,keyword:r},end:'(\\[|#|\\d|"|:|\\{|\\)|\\(|$)',contains:[{className:"title",begin:a,relevance:0,excludeEnd:!0,endsParent:!0}].concat(y)};return b.contains=[L,R,I],I.contains=y,p.contains=y,{name:"Clojure",aliases:["clj","edn"],illegal:/\S/,contains:[d,b,c,l,u,_,E,p,o,m]}}return to=t,to}var no,V_;function zR(){if(V_)return no;V_=1;function t(e){return{name:"Clojure REPL",contains:[{className:"meta.prompt",begin:/^([\w.-]+|\s*#_)?=>/,starts:{end:/$/,subLanguage:"clojure"}}]}}return no=t,no}var ao,z_;function WR(){if(z_)return ao;z_=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 ao=t,ao}var ro,W_;function KR(){if(W_)return ro;W_=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"],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"],a=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],r=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],i=[].concat(r,n,a);function s(o){const c=["npm","print"],l=["yes","no","on","off"],u=["then","unless","until","loop","by","when","and","or","is","isnt","not"],d=["var","const","let","function","static"],_=U=>h=>!U.includes(h),m={keyword:t.concat(u).filter(_(d)),literal:e.concat(l),built_in:i.concat(c)},p="[A-Za-z$_][0-9A-Za-z$_]*",E={className:"subst",begin:/#\{/,end:/\}/,keywords:m},b=[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,E]},{begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE,E]}]},{className:"regexp",variants:[{begin:"///",end:"///",contains:[E,o.HASH_COMMENT_MODE]},{begin:"//[gim]{0,3}(?=\\W)",relevance:0},{begin:/\/(?![ *]).*?(?![\\]).\/[gim]{0,3}(?=\W)/}]},{begin:"@"+p},{subLanguage:"javascript",excludeBegin:!0,excludeEnd:!0,variants:[{begin:"```",end:"```"},{begin:"`",end:"`"}]}];E.contains=b;const I=o.inherit(o.TITLE_MODE,{begin:p}),R="(\\(.*\\)\\s*)?\\B[-=]>",y={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:m,contains:["self"].concat(b)}]},L={variants:[{match:[/class\s+/,p,/\s+extends\s+/,p]},{match:[/class\s+/,p]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:m};return{name:"CoffeeScript",aliases:["coffee","cson","iced"],keywords:m,illegal:/\/\*/,contains:[...b,o.COMMENT("###","###"),o.HASH_COMMENT_MODE,{className:"function",begin:"^\\s*"+p+"\\s*=\\s*"+R,end:"[-=]>",returnBegin:!0,contains:[I,y]},{begin:/[:\(,=]\s*/,relevance:0,contains:[{className:"function",begin:R,end:"[-=]>",returnBegin:!0,contains:[y]}]},L,{begin:p+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}]}}return ro=s,ro}var io,K_;function QR(){if(K_)return io;K_=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 io=t,io}var so,Q_;function XR(){if(Q_)return so;Q_=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 so=t,so}var oo,X_;function ZR(){if(X_)return oo;X_=1;function t(e){const n=e.regex,a=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),r="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",o="(?!struct)("+r+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",c={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},u={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})"/})]},d={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},_={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(u,{className:"string"}),{className:"string",begin:/<.*?>/},a,e.C_BLOCK_COMMENT_MODE]},m={className:"title",begin:n.optional(i)+e.IDENT_RE,relevance:0},p=n.optional(i)+e.IDENT_RE+"\\s*\\(",E=["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"],b=["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],I=["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"],R=["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"],U={type:b,keyword:E,literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:I},h={className:"function.dispatch",relevance:0,keywords:{_hint:R},begin:n.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,e.IDENT_RE,n.lookahead(/(<[^<>]+>|)\s*\(/))},N=[h,_,c,a,e.C_BLOCK_COMMENT_MODE,d,u],C={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:U,contains:N.concat([{begin:/\(/,end:/\)/,keywords:U,contains:N.concat(["self"]),relevance:0}]),relevance:0},f={className:"function",begin:"("+o+"[\\*&\\s]+)+"+p,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:U,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:r,keywords:U,relevance:0},{begin:p,returnBegin:!0,contains:[m],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[u,d]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:U,relevance:0,contains:[a,e.C_BLOCK_COMMENT_MODE,u,d,c,{begin:/\(/,end:/\)/,keywords:U,relevance:0,contains:["self",a,e.C_BLOCK_COMMENT_MODE,u,d,c]}]},c,a,e.C_BLOCK_COMMENT_MODE,_]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:U,illegal:"",keywords:U,contains:["self",c]},{begin:e.IDENT_RE+"::",keywords:U},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}return oo=t,oo}var lo,Z_;function JR(){if(Z_)return lo;Z_=1;function t(e){const n="primitive rsc_template",a="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:n,starts:{className:"title",end:"\\s*[\\$\\w_][\\w_-]*",starts:{end:"\\s*@?[\\w_][\\w_\\.:-]*"}}},{begin:"\\b("+a.split(" ").join("|")+")\\s+",keywords:a,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 lo=t,lo}var co,J_;function jR(){if(J_)return co;J_=1;function t(e){const n="(_?[ui](8|16|32|64|128))?",a="(_?f(32|64))?",r="[a-zA-Z_]\\w*[!?=]?",i="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?",s="[A-Za-z_]\\w*(::\\w+)*(\\?|!)?",o={$pattern:r,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"},c={className:"subst",begin:/#\{/,end:/\}/,keywords:o},l={className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},u={className:"template-variable",variants:[{begin:"\\{\\{",end:"\\}\\}"},{begin:"\\{%",end:"%\\}"}],keywords:o};function d(R,y){const L=[{begin:R,end:y}];return L[0].contains=L,L}const _={className:"string",contains:[e.BACKSLASH_ESCAPE,c],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:"%[Qwi]?\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%[Qwi]?\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%[Qwi]?\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%[Qwi]?<",end:">",contains:d("<",">")},{begin:"%[Qwi]?\\|",end:"\\|"},{begin:/<<-\w+$/,end:/^\s*\w+$/}],relevance:0},m={className:"string",variants:[{begin:"%q\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%q\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%q\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%q<",end:">",contains:d("<",">")},{begin:"%q\\|",end:"\\|"},{begin:/<<-'\w+'$/,end:/^\s*\w+$/}],relevance:0},p={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,c],variants:[{begin:"//[a-z]*",relevance:0},{begin:"/(?!\\/)",end:"/[a-z]*"}]}],relevance:0},E={className:"regexp",contains:[e.BACKSLASH_ESCAPE,c],variants:[{begin:"%r\\(",end:"\\)",contains:d("\\(","\\)")},{begin:"%r\\[",end:"\\]",contains:d("\\[","\\]")},{begin:"%r\\{",end:/\}/,contains:d(/\{/,/\}/)},{begin:"%r<",end:">",contains:d("<",">")},{begin:"%r\\|",end:"\\|"}],relevance:0},b={className:"meta",begin:"@\\[",end:"\\]",contains:[e.inherit(e.QUOTE_STRING_MODE,{className:"string"})]},I=[u,_,m,E,p,b,l,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:i,endsParent:!0})]},{className:"function",beginKeywords:"fun macro",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:i,endsParent:!0})],relevance:2},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":",contains:[_,{begin:i}],relevance:0},{className:"number",variants:[{begin:"\\b0b([01_]+)"+n},{begin:"\\b0o([0-7_]+)"+n},{begin:"\\b0x([A-Fa-f0-9_]+)"+n},{begin:"\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?"+a+"(?!_)"},{begin:"\\b([1-9][0-9_]*|0)"+n}],relevance:0}];return c.contains=I,u.contains=I.slice(1),{name:"Crystal",aliases:["cr"],keywords:o,contains:I}}return co=t,co}var uo,j_;function eC(){if(j_)return uo;j_=1;function t(e){const n=["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],a=["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"],r=["default","false","null","true"],i=["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:i.concat(s),built_in:n,literal:r},c=e.inherit(e.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),l={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},u={className:"string",begin:/"""("*)(?!")(.|\n)*?"""\1/,relevance:1},d={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},_=e.inherit(d,{illegal:/\n/}),m={className:"subst",begin:/\{/,end:/\}/,keywords:o},p=e.inherit(m,{illegal:/\n/}),E={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},e.BACKSLASH_ESCAPE,p]},b={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},m]},I=e.inherit(b,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},p]});m.contains=[b,E,d,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,l,e.C_BLOCK_COMMENT_MODE],p.contains=[I,E,_,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,l,e.inherit(e.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const R={variants:[u,b,E,d,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},y={begin:"<",end:">",contains:[{beginKeywords:"in out"},c]},L=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",U={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"}},R,l,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},c,y,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[c,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[c,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:"("+L+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:o,contains:[{beginKeywords:a.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:[R,l,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},U]}}return uo=t,uo}var _o,ep;function tC(){if(ep)return _o;ep=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 _o=t,_o}var po,tp;function nC(){if(tp)return po;tp=1;const t=l=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:l.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:[l.APOS_STRING_MODE,l.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:l.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"],n=["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"],a=[...e,...n],r=["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(),i=["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 c(l){const u=l.regex,d=t(l),_={begin:/-(webkit|moz|ms|o)-(?=[a-z])/},m="and or not only",p=/@-?\w[\w]*(-\w+)*/,E="[a-zA-Z-][a-zA-Z0-9_-]*",b=[l.APOS_STRING_MODE,l.QUOTE_STRING_MODE];return{name:"CSS",case_insensitive:!0,illegal:/[=|'\$]/,keywords:{keyframePosition:"from to"},classNameAliases:{keyframePosition:"selector-tag"},contains:[d.BLOCK_COMMENT,_,d.CSS_NUMBER_MODE,{className:"selector-id",begin:/#[A-Za-z0-9_-]+/,relevance:0},{className:"selector-class",begin:"\\."+E,relevance:0},d.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",variants:[{begin:":("+i.join("|")+")"},{begin:":(:)?("+s.join("|")+")"}]},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b"},{begin:/:/,end:/[;}{]/,contains:[d.BLOCK_COMMENT,d.HEXCOLOR,d.IMPORTANT,d.CSS_NUMBER_MODE,...b,{begin:/(url|data-uri)\(/,end:/\)/,relevance:0,keywords:{built_in:"url data-uri"},contains:[...b,{className:"string",begin:/[^)]/,endsWithParent:!0,excludeEnd:!0}]},d.FUNCTION_DISPATCH]},{begin:u.lookahead(/@/),end:"[{;]",relevance:0,illegal:/:/,contains:[{className:"keyword",begin:p},{begin:/\s/,endsWithParent:!0,excludeEnd:!0,relevance:0,keywords:{$pattern:/[a-z-]+/,keyword:m,attribute:r.join(" ")},contains:[{begin:/[a-z-]+(?=:)/,className:"attribute"},...b,d.CSS_NUMBER_MODE]}]},{className:"selector-tag",begin:"\\b("+a.join("|")+")\\b"}]}}return po=c,po}var mo,np;function aC(){if(np)return mo;np=1;function t(e){const n={$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"},a="(0|[1-9][\\d_]*)",r="(0|[1-9][\\d_]*|\\d[\\d_]*|[\\d_]+?\\d)",i="0[bB][01_]+",s="([\\da-fA-F][\\da-fA-F_]*|_[\\da-fA-F][\\da-fA-F_]*)",o="0[xX]"+s,c="([eE][+-]?"+r+")",l="("+r+"(\\.\\d*|"+c+")|\\d+\\."+r+"|\\."+a+c+"?)",u="(0[xX]("+s+"\\."+s+"|\\.?"+s+")[pP][+-]?"+r+")",d="("+a+"|"+i+"|"+o+")",_="("+u+"|"+l+")",m=`\\\\(['"\\?\\\\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,};`,p={className:"number",begin:"\\b"+d+"(L|u|U|Lu|LU|uL|UL)?",relevance:0},E={className:"number",begin:"\\b("+_+"([fF]|L|i|[fF]i|Li)?|"+d+"(i|[fF]i|Li))",relevance:0},b={className:"string",begin:"'("+m+"|.)",end:"'",illegal:"."},R={className:"string",begin:'"',contains:[{begin:m,relevance:0}],end:'"[cwd]?'},y={className:"string",begin:'[rq]"',end:'"[cwd]?',relevance:5},L={className:"string",begin:"`",end:"`[cwd]?"},U={className:"string",begin:'x"[\\da-fA-F\\s\\n\\r]*"[cwd]?',relevance:10},h={className:"string",begin:'q"\\{',end:'\\}"'},N={className:"meta",begin:"^#!",end:"$",relevance:5},C={className:"meta",begin:"#(line)",end:"$",relevance:5},f={className:"keyword",begin:"@[a-zA-Z_][a-zA-Z_\\d]*"},A=e.COMMENT("\\/\\+","\\+\\/",{contains:["self"],relevance:10});return{name:"D",keywords:n,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,A,U,R,y,L,h,E,p,b,N,C,f]}}return mo=t,mo}var go,ap;function rC(){if(ap)return go;ap=1;function t(e){const n=e.regex,a={begin:/<\/?[A-Za-z_]/,end:">",subLanguage:"xml",relevance:0},r={begin:"^[-\\*]{3,}",end:"$"},i={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}]},c=/[A-Za-z][A-Za-z0-9+.-]*/,l={variants:[{begin:/\[.+?\]\[.*?\]/,relevance:0},{begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,relevance:2},{begin:n.concat(/\[.+?\]\(/,c,/:\/\/.*?\)/),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}]},u={className:"strong",contains:[],variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]},d={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{begin:/_(?![_\s])/,end:/_/,relevance:0}]},_=e.inherit(u,{contains:[]}),m=e.inherit(d,{contains:[]});u.contains.push(m),d.contains.push(_);let p=[a,l];return[u,d,_,m].forEach(R=>{R.contains=R.contains.concat(p)}),p=p.concat(u,d),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:p},{begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",contains:p}]}]},a,s,u,d,{className:"quote",begin:"^>\\s+",contains:p,end:"$"},i,r,l,o,{scope:"literal",match:/&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/}]}}return go=t,go}var Eo,rp;function iC(){if(rp)return Eo;rp=1;function t(e){const n={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"}]},a={className:"subst",variants:[{begin:/\$\{/,end:/\}/}],keywords:"true false null this is new super"},r={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/}]},i={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,n,a]},{begin:'"""',end:'"""',contains:[e.BACKSLASH_ESCAPE,n,a]},{begin:"'",end:"'",illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,n,a]},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,n,a]}]};a.contains=[r,i];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(u=>`${u}?`);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:[i,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]},r,{className:"meta",begin:"@[A-Za-z]+"},{begin:"=>"}]}}return Eo=t,Eo}var fo,ip;function sC(){if(ip)return fo;ip=1;function t(e){const n=["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"],a=[e.C_LINE_COMMENT_MODE,e.COMMENT(/\{/,/\}/,{relevance:0}),e.COMMENT(/\(\*/,/\*\)/,{relevance:10})],r={className:"meta",variants:[{begin:/\{\$/,end:/\}/},{begin:/\(\*\$/,end:/\*\)/}]},i={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_]*/}]},c={begin:e.IDENT_RE+"\\s*=\\s*class\\s*\\(",returnBegin:!0,contains:[e.TITLE_MODE]},l={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:n,contains:[i,o,r].concat(a)},r].concat(a)};return{name:"Delphi",aliases:["dpr","dfm","pas","pascal"],case_insensitive:!0,keywords:n,illegal:/"|\$[G-Zg-z]|\/\*|<\/|\|/,contains:[i,o,s,c,l,r].concat(a)}}return fo=t,fo}var So,sp;function oC(){if(sp)return So;sp=1;function t(e){const n=e.regex;return{name:"Diff",aliases:["patch"],contains:[{className:"meta",relevance:10,match:n.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,/^\*\*\* +\d+,\d+ +\*\*\*\*$/,/^--- +\d+,\d+ +----$/)},{className:"comment",variants:[{begin:n.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 So=t,So}var bo,op;function lC(){if(op)return bo;op=1;function t(e){const n={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:[n],relevance:0}}]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[n]}]}}return bo=t,bo}var To,lp;function cC(){if(lp)return To;lp=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 To=t,To}var ho,cp;function uC(){if(cp)return ho;cp=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"}]},n,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},i={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_]*:"},c={className:"params",relevance:0,begin:"<",end:">",contains:[a,i]},l={className:"title.class",begin:/[a-zA-Z_][a-zA-Z\d_@-]*(?=\s\{)/,relevance:.2},u={className:"title.class",begin:/^\/(?=\s*\{)/,relevance:10},d={match:/[a-z][a-z-,]+(?=;)/,relevance:0,scope:"attr"},_={relevance:0,match:[/[a-z][a-z-,]+/,/\s*/,/=/],scope:{1:"attr",3:"operator"}},m={scope:"punctuation",relevance:0,match:/\};|[;{}]/};return{name:"Device Tree",contains:[u,i,s,o,l,_,d,c,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,a,n,r,m,{begin:e.IDENT_RE+"::",keywords:""}]}}return Co=t,Co}var yo,pp;function mC(){if(pp)return yo;pp=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 yo=t,yo}var No,mp;function gC(){if(mp)return No;mp=1;function t(e){const n=e.COMMENT(/\(\*/,/\*\)/),a={className:"attribute",begin:/^[ ]*[a-zA-Z]+([\s_-]+[a-zA-Z]+)*/},i={begin:/=/,end:/[.;]/,contains:[n,{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:[n,a,i]}}return No=t,No}var Oo,gp;function EC(){if(gp)return Oo;gp=1;function t(e){const n=e.regex,a="[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?",r="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?",o={$pattern:a,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"]},c={className:"subst",begin:/#\{/,end:/\}/,keywords:o},l={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},d={match:/\\[\s\S]/,scope:"char.escape",relevance:0},_=`[/|([{<"']`,m=[{begin:/"/,end:/"/},{begin:/'/,end:/'/},{begin:/\//,end:/\//},{begin:/\|/,end:/\|/},{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/},{begin:/\{/,end:/\}/},{begin://}],p=h=>({scope:"char.escape",begin:n.concat(/\\/,h),relevance:0}),E={className:"string",begin:"~[a-z](?="+_+")",contains:m.map(h=>e.inherit(h,{contains:[p(h.end),d,c]}))},b={className:"string",begin:"~[A-Z](?="+_+")",contains:m.map(h=>e.inherit(h,{contains:[p(h.end)]}))},I={className:"regex",variants:[{begin:"~r(?="+_+")",contains:m.map(h=>e.inherit(h,{end:n.concat(h.end,/[uismxfU]{0,7}/),contains:[p(h.end),d,c]}))},{begin:"~R(?="+_+")",contains:m.map(h=>e.inherit(h,{end:n.concat(h.end,/[uismxfU]{0,7}/),contains:[p(h.end)]}))}]},R={className:"string",contains:[e.BACKSLASH_ESCAPE,c],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:a,endsParent:!0})]},L=e.inherit(y,{className:"class",beginKeywords:"defimpl defmodule defprotocol defrecord",end:/\bdo\b|$|;/}),U=[R,I,b,E,e.HASH_COMMENT_MODE,L,y,{begin:"::"},{className:"symbol",begin:":(?![\\s:])",contains:[R,{begin:r}],relevance:0},{className:"symbol",begin:a+":(?!:)",relevance:0},{className:"title.class",begin:/(\b[A-Z][a-zA-Z0-9_]+)/,relevance:0},l,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))"}];return c.contains=U,{name:"Elixir",aliases:["ex","exs"],keywords:o,contains:U}}return Oo=t,Oo}var Ao,Ep;function fC(){if(Ep)return Ao;Ep=1;function t(e){const n={variants:[e.COMMENT("--","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},a={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},r={begin:"\\(",end:"\\)",illegal:'"',contains:[{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},n]},i={begin:/\{/,end:/\}/,contains:r.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:[r,n],illegal:"\\W\\.|;"},{begin:"import",end:"$",keywords:"import as exposing",contains:[r,n],illegal:"\\W\\.|;"},{begin:"type",end:"$",keywords:"type alias",contains:[a,r,i,n]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,n]},{begin:"port",end:"$",keywords:"port",contains:[n]},s,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,a,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),n,{begin:"->|<-"}],illegal:/;/}}return Ao=t,Ao}var Io,fp;function SC(){if(fp)return Io;fp=1;function t(e){const n=e.regex,a="([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",r=n.either(/\b([A-Z]+[a-z0-9]+)+/,/\b([A-Z]+[a-z0-9]+)+[A-Z]+/),i=n.concat(r,/(::\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"]},c={className:"doctag",begin:"@[A-Za-z]+"},l={begin:"#<",end:">"},u=[e.COMMENT("#","$",{contains:[c]}),e.COMMENT("^=begin","^=end",{contains:[c],relevance:10}),e.COMMENT("^__END__",e.MATCH_NOTHING_RE)],d={className:"subst",begin:/#\{/,end:/\}/,keywords:o},_={className:"string",contains:[e.BACKSLASH_ESCAPE,d],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:n.concat(/<<[-~]?'?/,n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,contains:[e.BACKSLASH_ESCAPE,d]})]}]},m="[1-9](_?[0-9])*|0",p="[0-9](_?[0-9])*",E={className:"number",relevance:0,variants:[{begin:`\\b(${m})(\\.(${p}))?([eE][+-]?(${p})|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"}]},b={variants:[{match:/\(\)/},{className:"params",begin:/\(/,end:/(?=\))/,excludeBegin:!0,endsParent:!0,keywords:o}]},N=[_,{variants:[{match:[/class\s+/,i,/\s+<\s+/,i]},{match:[/\b(class|module)\s+/,i]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:o},{match:[/(include|extend)\s+/,i],scope:{2:"title.class"},keywords:o},{relevance:0,match:[i,/\.new[. (]/],scope:{1:"title.class"}},{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},{relevance:0,match:r,scope:"title.class"},{match:[/def/,/\s+/,a],scope:{1:"keyword",3:"title.function"},contains:[b]},{begin:e.IDENT_RE+"::"},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":(?!\\s)",contains:[_,{begin:a}],relevance:0},E,{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,d],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(l,u),relevance:0}].concat(l,u);d.contains=N,b.contains=N;const w=[{begin:/^\s*=>/,starts:{end:"$",contains:N}},{className:"meta.prompt",begin:"^("+"[>?]>"+"|"+"[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]"+"|"+"(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>"+")(?=[ ])",starts:{end:"$",keywords:o,contains:N}}];return u.unshift(l),{name:"Ruby",aliases:["rb","gemspec","podspec","thor","irb"],keywords:o,illegal:/\/\*/,contains:[e.SHEBANG({binary:"ruby"})].concat(w).concat(u).concat(N)}}return Io=t,Io}var Do,Sp;function bC(){if(Sp)return Do;Sp=1;function t(e){return{name:"ERB",subLanguage:"xml",contains:[e.COMMENT("<%#","%>"),{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0}]}}return Do=t,Do}var wo,bp;function TC(){if(bp)return wo;bp=1;function t(e){const n=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:n.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 wo=t,wo}var xo,Tp;function hC(){if(Tp)return xo;Tp=1;function t(e){const n="[a-z'][a-zA-Z0-9_']*",a="("+n+":"+n+"|"+n+")",r={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"},i=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+"+n+"/\\d+"},c={begin:a+"\\(",end:"\\)",returnBegin:!0,relevance:0,contains:[{begin:a,relevance:0},{begin:"\\(",end:"\\)",endsWithParent:!0,returnEnd:!0,relevance:0}]},l={begin:/\{/,end:/\}/,relevance:0},u={begin:"\\b_([A-Z][A-Za-z0-9_]*)?",relevance:0},d={begin:"[A-Z][a-zA-Z0-9_]*",relevance:0},_={begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0,returnBegin:!0,contains:[{begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0},{begin:/\{/,end:/\}/,relevance:0}]},m={scope:"string",match:/\$(\\([^0-9]|[0-9]{1,3}|)|.)/},p={scope:"string",match:/"""("*)(?!")[\s\S]*?"""\1/},E={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:/#/}]},b={beginKeywords:"fun receive if try case maybe",end:"end",keywords:r};b.contains=[i,o,e.inherit(e.APOS_STRING_MODE,{className:""}),b,c,E,p,e.QUOTE_STRING_MODE,s,l,u,d,_,m];const I=[i,o,b,c,E,p,e.QUOTE_STRING_MODE,s,l,u,d,_,m];c.contains[1].contains=I,l.contains=I,_.contains[1].contains=I;const R=["-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:I};return{name:"Erlang",aliases:["erl"],keywords:r,illegal:"(",returnBegin:!0,illegal:"\\(|#|//|/\\*|\\\\|:|;",contains:[y,e.inherit(e.TITLE_MODE,{begin:n})],starts:{end:";|\\.",keywords:r,contains:I}},i,{begin:"^-",end:"\\.",relevance:0,excludeEnd:!0,returnBegin:!0,keywords:{$pattern:"-"+e.IDENT_RE,keyword:R.map(L=>`${L}|1.5`).join(" ")},contains:[y,E,p,e.QUOTE_STRING_MODE]},s,E,p,e.QUOTE_STRING_MODE,_,u,d,l,m,{begin:/\.$/}]}}return xo=t,xo}var Lo,hp;function vC(){if(hp)return Lo;hp=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 Lo=t,Lo}var Mo,vp;function RC(){if(vp)return Mo;vp=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 Mo=t,Mo}var ko,Rp;function CC(){if(Rp)return ko;Rp=1;function t(e){const n={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},a={className:"string",variants:[{begin:'"',end:'"'}]},i={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,n,a,i,e.C_NUMBER_MODE]}}return ko=t,ko}var Po,Cp;function yC(){if(Cp)return Po;Cp=1;function t(e){const n=e.regex,a={className:"params",begin:"\\(",end:"\\)"},r={variants:[e.COMMENT("!","$",{relevance:0}),e.COMMENT("^C[ ]","$",{relevance:0}),e.COMMENT("^C$","$",{relevance:0})]},i=/(_[a-z_\d]+)?/,s=/([de][+-]?\d+)?/,o={className:"number",variants:[{begin:n.concat(/\b\d+/,/\.(\d*)/,s,i)},{begin:n.concat(/\b\d+/,s,i)},{begin:n.concat(/\.\d+/,s,i)}],relevance:0},c={className:"function",beginKeywords:"subroutine function program",illegal:"[${=\\n]",contains:[e.UNDERSCORE_TITLE_MODE,a]},l={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:[l,c,{begin:/^C\s*=(?!=)/,relevance:0},r,o]}}return Po=t,Po}var Uo,yp;function NC(){if(yp)return Uo;yp=1;function t(o){return new RegExp(o.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}function e(o){return o?typeof o=="string"?o:o.source:null}function n(o){return a("(?=",o,")")}function a(...o){return o.map(l=>e(l)).join("")}function r(o){const c=o[o.length-1];return typeof c=="object"&&c.constructor===Object?(o.splice(o.length-1,1),c):{}}function i(...o){return"("+(r(o).capture?"":"?:")+o.map(u=>e(u)).join("|")+")"}function s(o){const c=["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"],l={scope:"keyword",match:/\b(yield|return|let|do|match|use)!/},u=["if","else","endif","line","nowarn","light","r","i","I","load","time","help","quit"],d=["true","false","null","Some","None","Ok","Error","infinity","infinityf","nan","nanf"],_=["__LINE__","__SOURCE_DIRECTORY__","__SOURCE_FILE__"],m=["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"],E={keyword:c,literal:d,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":_},I={variants:[o.COMMENT(/\(\*(?!\))/,/\*\)/,{contains:["self"]}),o.C_LINE_COMMENT_MODE]},R=/[a-zA-Z_](\w|')*/,y={scope:"variable",begin:/``/,end:/``/},L=/\B('|\^)/,U={scope:"symbol",variants:[{match:a(L,/``.*?``/)},{match:a(L,o.UNDERSCORE_IDENT_RE)}],relevance:0},h=function({includeEqual:ke}){let rt;ke?rt="!%&*+-/<=>@^|~?":rt="!%&*+-/<>@^|~?";const je=Array.from(rt),Ke=a("[",...je.map(t),"]"),Et=i(Ke,/\./),ut=a(Et,n(Et)),bt=i(a(ut,Et,"*"),a(Ke,"+"));return{scope:"operator",match:i(bt,/:\?>/,/:\?/,/:>/,/:=/,/::?/,/\$/),relevance:0}},N=h({includeEqual:!0}),C=h({includeEqual:!1}),f=function(ke,rt){return{begin:a(ke,n(a(/\s*/,i(/\w/,/'/,/\^/,/#/,/``/,/\(/,/{\|/)))),beginScope:rt,end:n(i(/\n/,/=/)),relevance:0,keywords:o.inherit(E,{type:m}),contains:[I,U,o.inherit(y,{scope:null}),C]}},A=f(/:/,"operator"),w=f(/\bof\b/,"keyword"),F={begin:[/(^|\s+)/,/type/,/\s+/,R],beginScope:{2:"keyword",4:"title.class"},end:n(/\(|=|$/),keywords:E,contains:[I,o.inherit(y,{scope:null}),U,{scope:"operator",match:/<|>/},A]},j={scope:"computation-expression",match:/\b[_a-z]\w*(?=\s*\{)/},_e={begin:[/^\s*/,a(/#/,i(...u)),/\b/],beginScope:{2:"meta"},end:n(/\s|$/)},be={variants:[o.BINARY_NUMBER_MODE,o.C_NUMBER_MODE]},oe={scope:"string",begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE]},pe={scope:"string",begin:/@"/,end:/"/,contains:[{match:/""/},o.BACKSLASH_ESCAPE]},Ce={scope:"string",begin:/"""/,end:/"""/,relevance:2},ot={scope:"subst",begin:/\{/,end:/\}/,keywords:E},lt={scope:"string",begin:/\$"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},o.BACKSLASH_ESCAPE,ot]},at={scope:"string",begin:/(\$@|@\$)"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},{match:/""/},o.BACKSLASH_ESCAPE,ot]},We={scope:"string",begin:/\$"""/,end:/"""/,contains:[{match:/\{\{/},{match:/\}\}/},ot],relevance:2},Ae={scope:"string",match:a(/'/,i(/[^\\']/,/\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/),/'/)};return ot.contains=[at,lt,pe,oe,Ae,l,I,y,A,j,_e,be,U,N],{name:"F#",aliases:["fs","f#"],keywords:E,illegal:/\/\*/,classNameAliases:{"computation-expression":"keyword"},contains:[l,{variants:[We,at,lt,Ce,pe,oe,Ae]},I,y,F,{scope:"meta",begin:/\[\]/,relevance:2,contains:[y,Ce,pe,oe,Ae,be]},w,A,j,_e,be,U,N]}}return Uo=s,Uo}var Fo,Np;function OC(){if(Np)return Fo;Np=1;function t(e){const n=e.regex,a={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"},r={className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0},i={className:"symbol",variants:[{begin:/=[lgenxc]=/},{begin:/\$/}]},s={className:"comment",variants:[{begin:"'",end:"'"},{begin:'"',end:'"'}],illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},o={begin:"/",end:"/",keywords:a,contains:[s,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,e.C_NUMBER_MODE]},c=/[a-z0-9&#*=?@\\><:,()$[\]_.{}!+%^-]+/,l={begin:/[a-z][a-z0-9_]*(\([a-z0-9_, ]*\))?[ \t]+/,excludeBegin:!0,end:"$",endsWithParent:!0,contains:[s,o,{className:"comment",begin:n.concat(c,n.anyNumberOfTimes(n.concat(/[ ]+/,c))),relevance:0}]};return{name:"GAMS",aliases:["gms"],case_insensitive:!0,keywords:a,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,l]},{beginKeywords:"table",end:";",returnBegin:!0,contains:[{beginKeywords:"table",end:"$",contains:[l]},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_]+/},r,i]},e.C_NUMBER_MODE,i]}}return Fo=t,Fo}var Bo,Op;function AC(){if(Op)return Bo;Op=1;function t(e){const n={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"},a=e.COMMENT("@","@"),r={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,a]},i={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,a,i]}],o={className:"title",begin:e.UNDERSCORE_IDENT_RE,relevance:0},c=function(m,p,E){const b=e.inherit({className:"function",beginKeywords:m,end:p,excludeEnd:!0,contains:[].concat(s)},{});return b.contains.push(o),b.contains.push(e.C_NUMBER_MODE),b.contains.push(e.C_BLOCK_COMMENT_MODE),b.contains.push(a),b},l={className:"built_in",begin:"\\b("+n.built_in.split(" ").join("|")+")\\b"},u={className:"string",begin:'"',end:'"',contains:[e.BACKSLASH_ESCAPE],relevance:0},d={begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,keywords:n,relevance:0,contains:[{beginKeywords:n.keyword},l,{className:"built_in",begin:e.UNDERSCORE_IDENT_RE,relevance:0}]},_={begin:/\(/,end:/\)/,relevance:0,keywords:{built_in:n.built_in,literal:n.literal},contains:[e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,a,l,d,u,"self"]};return d.contains.push(_),{name:"GAUSS",aliases:["gss"],case_insensitive:!0,keywords:n,illegal:/(\{[%#]|[%#]\}| <- )/,contains:[e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,a,u,r,{className:"keyword",begin:/\bexternal (matrix|string|array|sparse matrix|struct|proc|keyword|fn)/},c("proc keyword",";"),c("fn","="),{beginKeywords:"for threadfor",end:/;/,relevance:0,contains:[e.C_BLOCK_COMMENT_MODE,a,_]},{variants:[{begin:e.UNDERSCORE_IDENT_RE+"\\."+e.UNDERSCORE_IDENT_RE},{begin:e.UNDERSCORE_IDENT_RE+"\\s*="}],relevance:0},d,i]}}return Bo=t,Bo}var Go,Ap;function IC(){if(Ap)return Go;Ap=1;function t(e){const n=e.regex,a={$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"]},r=/\b/;function i(p,E){if(p.index===0)return;const b=p.input[p.index-1];b>="0"&&b<="9"||b!=="_"&&E.ignoreMatch()}const s=/[+-]?((\.\d+)|(\d+)(\.\d*)?)/,o=/[GM]\s*\d+(\.\d+)?/,c=/T\s*\d+/,l=/O\s*\d+/,u=/O<.+>/,d=/[ABCUVWXYZ]\s*/,_=/[FHIJKPQRS]\s*/,m=[e.COMMENT(/\(/,/\)/),e.COMMENT(/;/,/$/),e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,{scope:"title.function",variants:[{match:n.concat(r,o)},{begin:o,"on:begin":i},{match:n.concat(r,c)},{begin:c,"on:begin":i}]},{scope:"symbol",variants:[{match:n.concat(r,l)},{begin:l,"on:begin":i},{match:n.concat(r,u)},{begin:u,"on:begin":i},{match:/\*\s*\d+\s*$/}]},{scope:"operator",match:/^N\s*\d+/},{scope:"variable",match:/-?#\s*\d+/},{scope:"property",variants:[{match:n.concat(r,d,s)},{begin:n.concat(d,s),"on:begin":i}]},{scope:"params",variants:[{match:n.concat(r,_,s)},{begin:n.concat(_,s),"on:begin":i}]}];return{name:"G-code (ISO 6983)",aliases:["nc"],case_insensitive:!0,disableAutodetect:!0,keywords:a,contains:m}}return Go=t,Go}var Yo,Ip;function DC(){if(Ip)return Yo;Ip=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 Yo=t,Yo}var $o,Dp;function wC(){if(Dp)return $o;Dp=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 $o=t,$o}var qo,wp;function xC(){if(wp)return qo;wp=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 qo=t,qo}var Ho,xp;function LC(){if(xp)return Ho;xp=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 Qo=t,Qo}var Xo,Fp;function BC(){if(Fp)return Xo;Fp=1;function t(e){const n=e.regex,a={$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"]},r={$pattern:/[\w.\/]+/,literal:["true","false","undefined","null"]},i=/""|"[^"]+"/,s=/''|'[^']+'/,o=/\[\]|\[[^\]]+\]/,c=/[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/,l=/(\.|\/)/,u=n.either(i,s,o,c),d=n.concat(n.optional(/\.|\.\/|\//),u,n.anyNumberOfTimes(n.concat(l,u))),_=n.concat("(",o,"|",c,")(?==)"),m={begin:d},p=e.inherit(m,{keywords:r}),E={begin:/\(/,end:/\)/},b={className:"attr",begin:_,relevance:0,starts:{begin:/=/,end:/=/,starts:{contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,p,E]}}},I={begin:/as\s+\|/,keywords:{keyword:"as"},end:/\|/,contains:[{begin:/\w+/}]},R={contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,I,b,p,E],returnEnd:!0},y=e.inherit(m,{className:"name",keywords:a,starts:e.inherit(R,{end:/\)/})});E.contains=[y];const L=e.inherit(m,{keywords:a,className:"name",starts:e.inherit(R,{end:/\}\}/})}),U=e.inherit(m,{keywords:a,className:"name"}),h=e.inherit(m,{className:"name",keywords:a,starts:e.inherit(R,{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:[L],starts:{end:/\{\{\{\{\//,returnEnd:!0,subLanguage:"xml"}},{className:"template-tag",begin:/\{\{\{\{\//,end:/\}\}\}\}/,contains:[U]},{className:"template-tag",begin:/\{\{#/,end:/\}\}/,contains:[L]},{className:"template-tag",begin:/\{\{(?=else\}\})/,end:/\}\}/,keywords:"else"},{className:"template-tag",begin:/\{\{(?=else if)/,end:/\}\}/,keywords:"else if"},{className:"template-tag",begin:/\{\{\//,end:/\}\}/,contains:[U]},{className:"template-variable",begin:/\{\{\{/,end:/\}\}\}/,contains:[h]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[h]}]}}return Xo=t,Xo}var Zo,Bp;function GC(){if(Bp)return Zo;Bp=1;function t(e){const n="([0-9]_*)+",a="([0-9a-fA-F]_*)+",r="([01]_*)+",i="([0-7]_*)+",l="([!#$%&*+.\\/<=>?@\\\\^~-]|(?!([(),;\\[\\]`|{}]|[_:\"']))(\\p{S}|\\p{P}))",u={variants:[e.COMMENT("--+","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},d={className:"meta",begin:/\{-#/,end:/#-\}/},_={className:"meta",begin:"^#",end:"$"},m={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},p={begin:"\\(",end:"\\)",illegal:'"',contains:[d,_,{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},e.inherit(e.TITLE_MODE,{begin:"[_a-z][\\w']*"}),u]},E={begin:/\{/,end:/\}/,contains:p.contains},b={className:"number",relevance:0,variants:[{match:`\\b(${n})(\\.(${n}))?([eE][+-]?(${n}))?\\b`},{match:`\\b0[xX]_*(${a})(\\.(${a}))?([pP][+-]?(${n}))?\\b`},{match:`\\b0[oO](${i})\\b`},{match:`\\b0[bB](${r})\\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:[p,u],illegal:"\\W\\.|;"},{begin:"\\bimport\\b",end:"$",keywords:"import qualified as hiding",contains:[p,u],illegal:"\\W\\.|;"},{className:"class",begin:"^(\\s*)?(class|instance)\\b",end:"where",keywords:"class family instance where",contains:[m,p,u]},{className:"class",begin:"\\b(data|(new)?type)\\b",end:"$",keywords:"data family type newtype deriving",contains:[d,m,p,E,u]},{beginKeywords:"default",end:"$",contains:[m,p,u]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,u]},{begin:"\\bforeign\\b",end:"$",keywords:"foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",contains:[m,e.QUOTE_STRING_MODE,u]},{className:"meta",begin:"#!\\/usr\\/bin\\/env runhaskell",end:"$"},d,_,{scope:"string",begin:/'(?=\\?.')/,end:/'/,contains:[{scope:"char.escape",match:/\\./}]},e.QUOTE_STRING_MODE,b,m,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),{begin:`(?!-)${l}--+|--+(?!-)${l}`},u,{begin:"->|<-"}]}}return Zo=t,Zo}var Jo,Gp;function YC(){if(Gp)return Jo;Gp=1;function t(e){const n="[a-zA-Z_$][a-zA-Z0-9_$]*",a=/(-?)(\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:a,relevance:0},{className:"variable",begin:"\\$"+n},{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 Jo=t,Jo}var jo,Yp;function $C(){if(Yp)return jo;Yp=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 jo=t,jo}var el,$p;function qC(){if($p)return el;$p=1;function t(e){const n=e.regex,a="HTTP/([32]|1\\.[01])",r=/[A-Za-z][A-Za-z0-9-]*/,i={className:"attribute",begin:n.concat("^",r,"(?=\\:\\s)"),starts:{contains:[{className:"punctuation",begin:/: /,relevance:0,starts:{end:"$",relevance:0}}]}},s=[i,{begin:"\\n\\n",starts:{subLanguage:[],endsWithParent:!0}}];return{name:"HTTP",aliases:["https"],illegal:/\S/,contains:[{begin:"^(?="+a+" \\d{3})",end:/$/,contains:[{className:"meta",begin:a},{className:"number",begin:"\\b\\d{3}\\b"}],starts:{end:/\b\B/,illegal:/\S/,contains:s}},{begin:"(?=^[A-Z]+ (.*?) "+a+"$)",end:/$/,contains:[{className:"string",begin:" ",end:" ",excludeBegin:!0,excludeEnd:!0},{className:"meta",begin:a},{className:"keyword",begin:"[A-Z]+"}],starts:{end:/\b\B/,illegal:/\S/,contains:s}},e.inherit(i,{relevance:0})]}}return el=t,el}var tl,qp;function HC(){if(qp)return tl;qp=1;function t(e){const n="a-zA-Z_\\-!.?+*=<>&#'",a="["+n+"]["+n+"0-9/;:]*",r={$pattern:a,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 | |= ~"},i="[-+]?\\d+(\\.\\d+)?",s={begin:a,relevance:0},o={className:"number",begin:i,relevance:0},c=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),l=e.COMMENT(";","$",{relevance:0}),u={className:"literal",begin:/\b([Tt]rue|[Ff]alse|nil|None)\b/},d={begin:"[\\[\\{]",end:"[\\]\\}]",relevance:0},_={className:"comment",begin:"\\^"+a},m=e.COMMENT("\\^\\{","\\}"),p={className:"symbol",begin:"[:]{1,2}"+a},E={begin:"\\(",end:"\\)"},b={endsWithParent:!0,relevance:0},I={className:"name",relevance:0,keywords:r,begin:a,starts:b},R=[E,c,_,m,l,p,d,o,u,s];return E.contains=[e.COMMENT("comment",""),I,b],b.contains=R,d.contains=R,{name:"Hy",aliases:["hylang"],illegal:/\S/,contains:[e.SHEBANG(),E,c,_,m,l,p,d,o,u]}}return tl=t,tl}var nl,Hp;function VC(){if(Hp)return nl;Hp=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 nl=t,nl}var al,Vp;function zC(){if(Vp)return al;Vp=1;function t(e){const n=e.regex,a={className:"number",relevance:0,variants:[{begin:/([+-]+)?[\d]+_[\d_]+/},{begin:e.NUMBER_RE}]},r=e.COMMENT();r.variants=[{begin:/;/,end:/$/},{begin:/#/,end:/$/}];const i={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:"'"}]},c={begin:/\[/,end:/\]/,contains:[r,s,i,o,a,"self"],relevance:0},l=/[A-Za-z0-9_-]+/,u=/"(\\"|[^"])*"/,d=/'[^']*'/,_=n.either(l,u,d),m=n.concat(_,"(\\s*\\.\\s*",_,")*",n.lookahead(/\s*=\s*[^#\s]/));return{name:"TOML, also INI",aliases:["toml"],case_insensitive:!0,illegal:/\S/,contains:[r,{className:"section",begin:/\[+/,end:/\]+/},{begin:m,className:"attr",starts:{end:/$/,contains:[r,c,s,i,o,a]}}]}}return al=t,al}var rl,zp;function WC(){if(zp)return rl;zp=1;function t(e){const n=e.regex,a={className:"params",begin:"\\(",end:"\\)"},r=/(_[a-z_\d]+)?/,i=/([de][+-]?\d+)?/,s={className:"number",variants:[{begin:n.concat(/\b\d+/,/\.(\d*)/,i,r)},{begin:n.concat(/\b\d+/,i,r)},{begin:n.concat(/\.\d+/,i,r)}],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,a]},e.COMMENT("!","$",{relevance:0}),e.COMMENT("begin_doc","end_doc",{relevance:10}),s]}}return rl=t,rl}var il,Wp;function KC(){if(Wp)return il;Wp=1;function t(e){const n="[A-Za-zА-Яа-яёЁ_!][A-Za-zА-Яа-яёЁ_0-9]*",a="[A-Za-zА-Яа-яёЁ_][A-Za-zА-Яа-яёЁ_0-9]*",r="and и else иначе endexcept endfinally endforeach конецвсе endif конецесли endwhile конецпока except exitfor finally foreach все if если in в not не or или try while пока ",ke="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 ",Ba="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 ",cn="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Дат ФмтДат ФмтСтр ФмтЧсл Формат ЦМассивЭлемент ЦНаборДанныхРеквизит ЦПодстр ",cr="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 ВызовСпособ ИмяОтчета РеквЗнач ",Ra="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 ",Ve=ke+Ba,Ga=cr,qt="null true false nil ",Tt={className:"number",begin:e.NUMBER_RE,relevance:0},Hn={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"}]},un={className:"doctag",begin:"\\b(?:TODO|DONE|BEGIN|END|STUB|CHG|FIXME|NOTE|BUG|XXX)\\b",relevance:0},na={className:"comment",begin:"//",end:"$",relevance:0,contains:[e.PHRASAL_WORDS_MODE,un]},ie={className:"comment",begin:"/\\*",end:"\\*/",relevance:0,contains:[e.PHRASAL_WORDS_MODE,un]},S={variants:[na,ie]},M={$pattern:n,keyword:r,built_in:Ve,class:Ga,literal:qt},H={begin:"\\.\\s*"+e.UNDERSCORE_IDENT_RE,keywords:M,relevance:0},te={className:"type",begin:":[ \\t]*("+Ra.trim().replace(/\s/g,"|")+")",end:"[ \\t]*=",excludeEnd:!0},Ee={className:"variable",keywords:M,begin:n,relevance:0,contains:[te,H]},Le=a+"\\(";return{name:"ISBL",case_insensitive:!0,keywords:M,illegal:"\\$|\\?|%|,|;$|~|#|@|r(s,o,c-1))}function i(s){const o=s.regex,c="[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*",l=c+r("(?:<"+c+"~~~(?:\\s*,\\s*"+c+"~~~)*>)?",/~~~/g,2),p={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"]},E={className:"meta",begin:"@"+c,contains:[{begin:/\(/,end:/\)/,contains:["self"]}]},b={className:"params",begin:/\(/,end:/\)/,keywords:p,relevance:0,contains:[s.C_BLOCK_COMMENT_MODE],endsParent:!0};return{name:"Java",aliases:["jsp"],keywords:p,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+/,c],className:{1:"keyword",3:"title.class"}},{match:/non-sealed/,scope:"keyword"},{begin:[o.concat(/(?!else)/,c),/\s+/,c,/\s+/,/=(?!=)/],className:{1:"type",3:"variable",5:"operator"}},{begin:[/record/,/\s+/,c],className:{1:"keyword",3:"title.class"},contains:[b,s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE]},{beginKeywords:"new throw return else",relevance:0},{begin:["(?:"+l+"\\s+)",s.UNDERSCORE_IDENT_RE,/\s*(?=\()/],className:{2:"title.function"},keywords:p,contains:[{className:"params",begin:/\(/,end:/\)/,keywords:p,relevance:0,contains:[E,s.APOS_STRING_MODE,s.QUOTE_STRING_MODE,a,s.C_BLOCK_COMMENT_MODE]},s.C_LINE_COMMENT_MODE,s.C_BLOCK_COMMENT_MODE]},a,E]}}return sl=i,sl}var ol,Qp;function XC(){if(Qp)return ol;Qp=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"],n=["true","false","null","undefined","NaN","Infinity"],a=["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"],r=["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"],s=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],o=[].concat(i,a,r);function c(l){const u=l.regex,d=(je,{after:Ke})=>{const Et="",end:""},p=/<[A-Za-z0-9\\._:-]+\s*\/>/,E={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(je,Ke)=>{const Et=je[0].length+je.index,ut=je.input[Et];if(ut==="<"||ut===","){Ke.ignoreMatch();return}ut===">"&&(d(je,{after:Et})||Ke.ignoreMatch());let bt;const D=je.input.substring(Et);if(bt=D.match(/^\s*=/)){Ke.ignoreMatch();return}if((bt=D.match(/^\s+extends\s+/))&&bt.index===0){Ke.ignoreMatch();return}}},b={$pattern:t,keyword:e,literal:n,built_in:o,"variable.language":s},I="[0-9](_?[0-9])*",R=`\\.(${I})`,y="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",L={className:"number",variants:[{begin:`(\\b(${y})((${R})|\\.)?|(${R}))[eE][+-]?(${I})\\b`},{begin:`\\b(${y})\\b((${R})\\b|\\.)?|(${R})\\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},U={className:"subst",begin:"\\$\\{",end:"\\}",keywords:b,contains:[]},h={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[l.BACKSLASH_ESCAPE,U],subLanguage:"xml"}},N={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[l.BACKSLASH_ESCAPE,U],subLanguage:"css"}},C={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[l.BACKSLASH_ESCAPE,U],subLanguage:"graphql"}},f={className:"string",begin:"`",end:"`",contains:[l.BACKSLASH_ESCAPE,U]},w={className:"comment",variants:[l.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:_+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),l.C_BLOCK_COMMENT_MODE,l.C_LINE_COMMENT_MODE]},F=[l.APOS_STRING_MODE,l.QUOTE_STRING_MODE,h,N,C,f,{match:/\$\d+/},L];U.contains=F.concat({begin:/\{/,end:/\}/,keywords:b,contains:["self"].concat(F)});const j=[].concat(w,U.contains),_e=j.concat([{begin:/(\s*)\(/,end:/\)/,keywords:b,contains:["self"].concat(j)}]),be={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:b,contains:_e},oe={variants:[{match:[/class/,/\s+/,_,/\s+/,/extends/,/\s+/,u.concat(_,"(",u.concat(/\./,_),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,_],scope:{1:"keyword",3:"title.class"}}]},pe={relevance:0,match:u.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:{_:[...a,...r]}},Ce={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},ot={variants:[{match:[/function/,/\s+/,_,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[be],illegal:/%/},lt={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function at(je){return u.concat("(?!",je.join("|"),")")}const We={match:u.concat(/\b/,at([...i,"super","import"].map(je=>`${je}\\s*\\(`)),_,u.lookahead(/\s*\(/)),className:"title.function",relevance:0},Ae={begin:u.concat(/\./,u.lookahead(u.concat(_,/(?![0-9A-Za-z$_(])/))),end:_,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},He={match:[/get|set/,/\s+/,_,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},be]},ke="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+l.UNDERSCORE_IDENT_RE+")\\s*=>",rt={match:[/const|var|let/,/\s+/,_,/\s*/,/=\s*/,/(async\s*)?/,u.lookahead(ke)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[be]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:b,exports:{PARAMS_CONTAINS:_e,CLASS_REFERENCE:pe},illegal:/#(?![$_A-z])/,contains:[l.SHEBANG({label:"shebang",binary:"node",relevance:5}),Ce,l.APOS_STRING_MODE,l.QUOTE_STRING_MODE,h,N,C,f,w,{match:/\$\d+/},L,pe,{scope:"attr",match:_+u.lookahead(":"),relevance:0},rt,{begin:"("+l.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[w,l.REGEXP_MODE,{className:"function",begin:ke,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:l.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:b,contains:_e}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:m.begin,end:m.end},{match:p},{begin:E.begin,"on:begin":E.isTrulyOpeningTag,end:E.end}],subLanguage:"xml",contains:[{begin:E.begin,end:E.end,skip:!0,contains:["self"]}]}]},ot,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+l.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[be,l.inherit(l.TITLE_MODE,{begin:_,className:"title.function"})]},{match:/\.\.\./,relevance:0},Ae,{match:"\\$"+_,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[be]},We,lt,oe,He,{match:/\$[(.]/}]}}return ol=c,ol}var ll,Xp;function ZC(){if(Xp)return ll;Xp=1;function t(e){const a={className:"params",begin:/\(/,end:/\)/,contains:[{begin:/[\w-]+ *=/,returnBegin:!0,relevance:0,contains:[{className:"attr",begin:/[\w-]+/}]}],relevance:0},r={className:"function",begin:/:[\w\-.]+/,relevance:0},i={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,r,i,a]}}return ll=t,ll}var cl,Zp;function JC(){if(Zp)return cl;Zp=1;function t(e){const n={className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/,relevance:1.01},a={match:/[{}[\],:]/,className:"punctuation",relevance:0},r=["true","false","null"],i={scope:"literal",beginKeywords:r.join(" ")};return{name:"JSON",aliases:["jsonc"],keywords:{literal:r},contains:[n,a,e.QUOTE_STRING_MODE,i,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE],illegal:"\\S"}}return cl=t,cl}var ul,Jp;function jC(){if(Jp)return ul;Jp=1;function t(e){const n="[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*",s={$pattern:n,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:/<\//},c={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},l={className:"string",begin:/'(.|\\[xXuU][a-zA-Z0-9]+)'/},u={className:"subst",begin:/\$\(/,end:/\)/,keywords:s},d={className:"variable",begin:"\\$"+n},_={className:"string",contains:[e.BACKSLASH_ESCAPE,u,d],variants:[{begin:/\w*"""/,end:/"""\w*/,relevance:10},{begin:/\w*"/,end:/"\w*/}]},m={className:"string",contains:[e.BACKSLASH_ESCAPE,u,d],begin:"`",end:"`"},p={className:"meta",begin:"@"+n},E={className:"comment",variants:[{begin:"#=",end:"=#",relevance:10},{begin:"#",end:"$"}]};return o.name="Julia",o.contains=[c,l,_,m,p,E,e.HASH_COMMENT_MODE,{className:"keyword",begin:"\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b"},{begin:/<:/}],u.contains=o.contains,o}return ul=t,ul}var dl,jp;function ey(){if(jp)return dl;jp=1;function t(e){return{name:"Julia REPL",contains:[{className:"meta.prompt",begin:/^julia>/,relevance:10,starts:{end:/^(?![ ]{6})/,subLanguage:"julia"}}],aliases:["jldoctest"]}}return dl=t,dl}var _l,em;function ty(){if(em)return _l;em=1;var t="[0-9](_*[0-9])*",e=`\\.(${t})`,n="[0-9a-fA-F](_*[0-9a-fA-F])*",a={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]((${n})\\.?|(${n})?\\.(${n}))[pP][+-]?(${t})[fFdD]?\\b`},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${n})[lL]?\\b`},{begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],relevance:0};function r(i){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+/}]}},c={className:"symbol",begin:i.UNDERSCORE_IDENT_RE+"@"},l={className:"subst",begin:/\$\{/,end:/\}/,contains:[i.C_NUMBER_MODE]},u={className:"variable",begin:"\\$"+i.UNDERSCORE_IDENT_RE},d={className:"string",variants:[{begin:'"""',end:'"""(?=[^"])',contains:[u,l]},{begin:"'",end:"'",illegal:/\n/,contains:[i.BACKSLASH_ESCAPE]},{begin:'"',end:'"',illegal:/\n/,contains:[i.BACKSLASH_ESCAPE,u,l]}]};l.contains.push(d);const _={className:"meta",begin:"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*"+i.UNDERSCORE_IDENT_RE+")?"},m={className:"meta",begin:"@"+i.UNDERSCORE_IDENT_RE,contains:[{begin:/\(/,end:/\)/,contains:[i.inherit(d,{className:"string"}),"self"]}]},p=a,E=i.COMMENT("/\\*","\\*/",{contains:[i.C_BLOCK_COMMENT_MODE]}),b={variants:[{className:"type",begin:i.UNDERSCORE_IDENT_RE},{begin:/\(/,end:/\)/,contains:[]}]},I=b;return I.variants[1].contains=[b],b.variants[1].contains=[I],{name:"Kotlin",aliases:["kt","kts"],keywords:s,contains:[i.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"}]}),i.C_LINE_COMMENT_MODE,E,o,c,_,m,{className:"function",beginKeywords:"fun",end:"[(]|$",returnBegin:!0,excludeEnd:!0,keywords:s,relevance:5,contains:[{begin:i.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,contains:[i.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:[b,i.C_LINE_COMMENT_MODE,E],relevance:0},i.C_LINE_COMMENT_MODE,E,_,m,d,i.C_NUMBER_MODE]},E]},{begin:[/class|interface|trait/,/\s+/,i.UNDERSCORE_IDENT_RE],beginScope:{3:"title.class"},keywords:"class interface trait",end:/[:\{(]|$/,excludeEnd:!0,illegal:"extends implements",contains:[{beginKeywords:"public protected internal private constructor"},i.UNDERSCORE_TITLE_MODE,{className:"type",begin://,excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:/[,:]\s*/,end:/[<\(,){\s]|$/,excludeBegin:!0,returnEnd:!0},_,m]},d,{className:"meta",begin:"^#!/usr/bin/env",end:"$",illegal:` +`},p]}}return _l=r,_l}var pl,tm;function ny(){if(tm)return pl;tm=1;function t(e){const n="[a-zA-Z_][\\w.]*",a="<\\?(lasso(script)?|=)",r="\\]|\\?>",i={$pattern:n+"|&[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]}},c={className:"meta",begin:"\\[/noprocess|"+a},l={className:"symbol",begin:"'"+n+"'"},u=[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:"[#$]"+n},{begin:"#",end:"\\d+",illegal:"\\W"}]},{className:"type",begin:"::\\s*",end:n,illegal:"\\W"},{className:"params",variants:[{begin:"-(?!infinity)"+n,relevance:0},{begin:"(\\.\\.\\.)"}]},{begin:/(->|\.)\s*/,relevance:0,contains:[l]},{className:"class",beginKeywords:"define",returnEnd:!0,end:"\\(|=>",contains:[e.inherit(e.TITLE_MODE,{begin:n+"(=(?!>))?|[-+*/%](?!>)"})]}];return{name:"Lasso",aliases:["ls","lassoscript"],case_insensitive:!0,keywords:i,contains:[{className:"meta",begin:r,relevance:0,starts:{end:"\\[|"+a,returnEnd:!0,relevance:0,contains:[s]}},o,c,{className:"meta",begin:"\\[no_square_brackets",starts:{end:"\\[/no_square_brackets\\]",keywords:i,contains:[{className:"meta",begin:r,relevance:0,starts:{end:"\\[noprocess\\]|"+a,returnEnd:!0,contains:[s]}},o,c].concat(u)}},{className:"meta",begin:"\\[",relevance:0},{className:"meta",begin:"^#!",end:"lasso9$",relevance:10}].concat(u)}}return pl=t,pl}var ml,nm;function ay(){if(nm)return ml;nm=1;function t(e){const a=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(w=>w+"(?![a-zA-Z@:_])")),r=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(w=>w+"(?![a-zA-Z:_])").join("|")),i=[{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:a},{endsParent:!0,begin:r},{endsParent:!0,variants:s},{endsParent:!0,relevance:0,variants:i}]},c={className:"params",relevance:0,begin:/#+\d?/},l={variants:s},u={className:"built_in",relevance:0,begin:/[$&^_]/},d={className:"meta",begin:/% ?!(T[eE]X|tex|BIB|bib)/,end:"$",relevance:10},_=e.COMMENT("%","$",{relevance:0}),m=[o,c,l,u,d,_],p={begin:/\{/,end:/\}/,relevance:0,contains:["self",...m]},E=e.inherit(p,{relevance:0,endsParent:!0,contains:[p,...m]}),b={begin:/\[/,end:/\]/,endsParent:!0,relevance:0,contains:[p,...m]},I={begin:/\s+/,relevance:0},R=[E],y=[b],L=function(w,F){return{contains:[I],starts:{relevance:0,contains:w,starts:F}}},U=function(w,F){return{begin:"\\\\"+w+"(?![a-zA-Z@:_])",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\"+w},relevance:0,contains:[I],starts:F}},h=function(w,F){return e.inherit({begin:"\\\\begin(?=[ ]*(\\r?\\n[ ]*)?\\{"+w+"\\})",keywords:{$pattern:/\\[a-zA-Z]+/,keyword:"\\begin"},relevance:0},L(R,F))},N=(w="string")=>e.END_SAME_AS_BEGIN({className:w,begin:/(.|\r?\n)/,end:/(.|\r?\n)/,excludeBegin:!0,excludeEnd:!0,endsParent:!0}),C=function(w){return{className:"string",end:"(?=\\\\end\\{"+w+"\\})"}},f=(w="string")=>({relevance:0,begin:/\{/,starts:{endsParent:!0,contains:[{className:w,end:/(?=\})/,endsParent:!0,contains:[{begin:/\{/,end:/\}/,relevance:0,contains:["self"]}]}]}}),A=[...["verb","lstinline"].map(w=>U(w,{contains:[N()]})),U("mint",L(R,{contains:[N()]})),U("mintinline",L(R,{contains:[f(),N()]})),U("url",{contains:[f("link"),f("link")]}),U("hyperref",{contains:[f("link")]}),U("href",L(y,{contains:[f("link")]})),...[].concat(...["","\\*"].map(w=>[h("verbatim"+w,C("verbatim"+w)),h("filecontents"+w,L(R,C("filecontents"+w))),...["","B","L"].map(F=>h(F+"Verbatim"+w,L(y,C(F+"Verbatim"+w))))])),h("minted",L(y,L(R,C("minted"))))];return{name:"LaTeX",aliases:["tex"],contains:[...A,...m]}}return ml=t,ml}var gl,am;function ry(){if(am)return gl;am=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 gl=t,gl}var El,rm;function iy(){if(rm)return El;rm=1;function t(e){const n=/([A-Za-z_][A-Za-z_0-9]*)?/,r={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:/\+|\-|\*|\/|\%|\=\=|\=|\!|\>|\<|\&\&|\|\|/}]},i={match:[n,/(?=\()/],scope:{1:"keyword"},contains:[r]};return r.contains.unshift(i),{name:"Leaf",contains:[{match:[/#+/,n,/(?=\()/],scope:{1:"punctuation",2:"keyword"},starts:{contains:[{match:/\:/,scope:"punctuation"}]},contains:[r]},{match:[/#+/,n,/:?/],scope:{1:"punctuation",2:"keyword",3:"punctuation"}}]}}return El=t,El}var fl,im;function sy(){if(im)return fl;im=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"],n=["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"],a=[...e,...n],r=["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(),i=["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(),c=i.concat(s).sort().reverse();function l(u){const d=t(u),_=c,m="and or not only",p="[\\w-]+",E="("+p+"|@\\{"+p+"\\})",b=[],I=[],R=function(j){return{className:"string",begin:"~?"+j+".*?"+j}},y=function(j,_e,be){return{className:j,begin:_e,relevance:be}},L={$pattern:/[a-z-]+/,keyword:m,attribute:r.join(" ")},U={begin:"\\(",end:"\\)",contains:I,keywords:L,relevance:0};I.push(u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,R("'"),R('"'),d.CSS_NUMBER_MODE,{begin:"(url|data-uri)\\(",starts:{className:"string",end:"[\\)\\n]",excludeEnd:!0}},d.HEXCOLOR,U,y("variable","@@?"+p,10),y("variable","@\\{"+p+"\\}"),y("built_in","~?`[^`]*?`"),{className:"attribute",begin:p+"\\s*:",end:":",returnBegin:!0,excludeEnd:!0},d.IMPORTANT,{beginKeywords:"and not"},d.FUNCTION_DISPATCH);const h=I.concat({begin:/\{/,end:/\}/,contains:b}),N={beginKeywords:"when",endsWithParent:!0,contains:[{beginKeywords:"and not"}].concat(I)},C={begin:E+"\\s*:",returnBegin:!0,end:/[;}]/,relevance:0,contains:[{begin:/-(webkit|moz|ms|o)-/},d.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b",end:/(?=:)/,starts:{endsWithParent:!0,illegal:"[<=$]",relevance:0,contains:I}}]},f={className:"keyword",begin:"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",starts:{end:"[;{}]",keywords:L,returnEnd:!0,contains:I,relevance:0}},A={className:"variable",variants:[{begin:"@"+p+"\\s*:",relevance:15},{begin:"@"+p}],starts:{end:"[;}]",returnEnd:!0,contains:h}},w={variants:[{begin:"[\\.#:&\\[>]",end:"[;{}]"},{begin:E,end:/\{/}],returnBegin:!0,returnEnd:!0,illegal:`[<='$"]`,relevance:0,contains:[u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,N,y("keyword","all\\b"),y("variable","@\\{"+p+"\\}"),{begin:"\\b("+a.join("|")+")\\b",className:"selector-tag"},d.CSS_NUMBER_MODE,y("selector-tag",E,0),y("selector-id","#"+E),y("selector-class","\\."+E,0),y("selector-tag","&",0),d.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",begin:":("+i.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+s.join("|")+")"},{begin:/\(/,end:/\)/,relevance:0,contains:h},{begin:"!important"},d.FUNCTION_DISPATCH]},F={begin:p+`:(:)?(${_.join("|")})`,returnBegin:!0,contains:[w]};return b.push(u.C_LINE_COMMENT_MODE,u.C_BLOCK_COMMENT_MODE,f,A,F,C,w,N,d.FUNCTION_DISPATCH),{name:"Less",case_insensitive:!0,illegal:`[=>'/<($"]`,contains:b}}return fl=l,fl}var Sl,sm;function oy(){if(sm)return Sl;sm=1;function t(e){const n="[a-zA-Z_\\-+\\*\\/<=>&#][a-zA-Z0-9_\\-+*\\/<=>&#!]*",a="\\|[^]*?\\|",r="(-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|-)?\\d+)?",i={className:"literal",begin:"\\b(t{1}|nil)\\b"},s={className:"number",variants:[{begin:r,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)\\("+r+" +"+r,end:"\\)"}]},o=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),c=e.COMMENT(";","$",{relevance:0}),l={begin:"\\*",end:"\\*"},u={className:"symbol",begin:"[:&]"+n},d={begin:n,relevance:0},_={begin:a},p={contains:[s,o,l,u,{begin:"\\(",end:"\\)",contains:["self",i,o,s,d]},d],variants:[{begin:"['`]\\(",end:"\\)"},{begin:"\\(quote ",end:"\\)",keywords:{name:"quote"}},{begin:"'"+a}]},E={variants:[{begin:"'"+n},{begin:"#'"+n+"(::"+n+")*"}]},b={begin:"\\(\\s*",end:"\\)"},I={endsWithParent:!0,relevance:0};return b.contains=[{className:"name",variants:[{begin:n,relevance:0},{begin:a}]},I],I.contains=[p,E,b,i,s,o,c,l,u,_,d],{name:"Lisp",illegal:/\S/,contains:[s,e.SHEBANG(),i,o,c,p,E,b,d]}}return Sl=t,Sl}var bl,om;function ly(){if(om)return bl;om=1;function t(e){const n={className:"variable",variants:[{begin:"\\b([gtps][A-Z]{1}[a-zA-Z0-9]*)(\\[.+\\])?(?:\\s*?)"},{begin:"\\$_[A-Z]+"}],relevance:0},a=[e.C_BLOCK_COMMENT_MODE,e.HASH_COMMENT_MODE,e.COMMENT("--","$"),e.COMMENT("[^:]//","$")],r=e.inherit(e.TITLE_MODE,{variants:[{begin:"\\b_*rig[A-Z][A-Za-z0-9_\\-]*"},{begin:"\\b_[a-z0-9\\-]+"}]}),i=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:[n,{className:"keyword",begin:"\\bend\\sif\\b"},{className:"function",beginKeywords:"function",end:"$",contains:[n,i,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE,r]},{className:"function",begin:"\\bend\\s+",end:"$",keywords:"end",contains:[i,r],relevance:0},{beginKeywords:"command on",end:"$",contains:[n,i,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE,r]},{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,r].concat(a),illegal:";$|^\\[|^=|&|\\{"}}return bl=t,bl}var Tl,lm;function cy(){if(lm)return Tl;lm=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"],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"],a=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],r=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],i=[].concat(r,n,a);function s(o){const c=["npm","print"],l=["yes","no","on","off","it","that","void"],u=["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"],d={keyword:t.concat(u),literal:e.concat(l),built_in:i.concat(c)},_="[A-Za-z$_](?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*",m=o.inherit(o.TITLE_MODE,{begin:_}),p={className:"subst",begin:/#\{/,end:/\}/,keywords:d},E={className:"subst",begin:/#[A-Za-z$_]/,end:/(?:-[0-9A-Za-z$_]|[0-9A-Za-z$_])*/,keywords:d},b=[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,p,E]},{begin:/"/,end:/"/,contains:[o.BACKSLASH_ESCAPE,p,E]},{begin:/\\/,end:/(\s|$)/,excludeEnd:!0}]},{className:"regexp",variants:[{begin:"//",end:"//[gim]*",contains:[p,o.HASH_COMMENT_MODE]},{begin:/\/(?![ *])(\\.|[^\\\n])*?\/[gim]*(?=\W)/}]},{begin:"@"+_},{begin:"``",end:"``",excludeBegin:!0,excludeEnd:!0,subLanguage:"javascript"}];p.contains=b;const I={className:"params",begin:"\\(",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:d,contains:["self"].concat(b)}]},R={begin:"(#=>|=>|\\|>>|-?->|!->)"},y={variants:[{match:[/class\s+/,_,/\s+extends\s+/,_]},{match:[/class\s+/,_]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:d};return{name:"LiveScript",aliases:["ls"],keywords:d,illegal:/\/\*/,contains:b.concat([o.COMMENT("\\/\\*","\\*\\/"),o.HASH_COMMENT_MODE,R,{className:"function",contains:[m,I],returnBegin:!0,variants:[{begin:"("+_+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B->\\*?",end:"->\\*?"},{begin:"("+_+"\\s*(?:=|:=)\\s*)?!?(\\(.*\\)\\s*)?\\B[-~]{1,2}>\\*?",end:"[-~]{1,2}>\\*?"},{begin:"("+_+"\\s*(?:=|:=)\\s*)?(\\(.*\\)\\s*)?\\B!?[-~]{1,2}>\\*?",end:"!?[-~]{1,2}>\\*?"}]},y,{begin:_+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return Tl=s,Tl}var hl,cm;function uy(){if(cm)return hl;cm=1;function t(e){const n=e.regex,a=/([-a-zA-Z$._][\w$.-]*)/,r={className:"type",begin:/\bi\d+(?=\s|\b)/},i={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},c={className:"symbol",variants:[{begin:/^\s*[a-z]+:/}],relevance:0},l={className:"variable",variants:[{begin:n.concat(/%/,a)},{begin:/%\d+/},{begin:/#\d+/}]},u={className:"title",variants:[{begin:n.concat(/@/,a)},{begin:/@\d+/},{begin:n.concat(/!/,a)},{begin:n.concat(/!\d+/,a)},{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:[r,e.COMMENT(/;\s*$/,null,{relevance:0}),e.COMMENT(/;/,/$/),{className:"string",begin:/"/,end:/"/,contains:[{className:"char.escape",match:/\\\d\d/}]},u,s,i,l,c,o]}}return hl=t,hl}var vl,um;function dy(){if(um)return vl;um=1;function t(e){const a={className:"string",begin:'"',end:'"',contains:[{className:"subst",begin:/\\[tn"\\]/}]},r={className:"number",relevance:0,begin:e.C_NUMBER_RE},i={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:[a,{className:"comment",variants:[e.COMMENT("//","$"),e.COMMENT("/\\*","\\*/")],relevance:0},r,{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,i,{className:"type",begin:"\\b(integer|float|string|key|vector|quaternion|rotation|list)\\b"}]}}return vl=t,vl}var Rl,dm;function _y(){if(dm)return Rl;dm=1;function t(e){const n="\\[=*\\[",a="\\]=*\\]",r={begin:n,end:a,contains:["self"]},i=[e.COMMENT("--(?!"+n+")","$"),e.COMMENT("--"+n,a,{contains:[r],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:i.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:i}].concat(i)},e.C_NUMBER_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:n,end:a,contains:[r],relevance:5}])}}return Rl=t,Rl}var Cl,_m;function py(){if(_m)return Cl;_m=1;function t(e){const n={className:"variable",variants:[{begin:"\\$\\("+e.UNDERSCORE_IDENT_RE+"\\)",contains:[e.BACKSLASH_ESCAPE]},{begin:/\$[@%{E.has(N[0])||C.ignoreMatch()}},{className:"symbol",relevance:0,begin:p}]},I={className:"named-character",begin:/\\\[[$a-zA-Z][$a-zA-Z0-9]+\]/},R={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$]*)?/},L={className:"slot",relevance:0,begin:/#[a-zA-Z$][a-zA-Z0-9$]*|#+[0-9]?/},U={className:"brace",relevance:0,begin:/[[\](){}]/},h={className:"message-name",relevance:0,begin:a.concat("::",p)};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:[n.COMMENT(/\(\*/,/\*\)/,{contains:["self"]}),y,L,h,b,I,n.QUOTE_STRING_MODE,m,R,U]}}return yl=e,yl}var Nl,mm;function gy(){if(mm)return Nl;mm=1;function t(e){const n="('|\\.')+",a={relevance:0,contains:[{begin:n}]};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:a},{begin:"[a-zA-Z][a-zA-Z_0-9]*"+n,relevance:0},{className:"number",begin:e.C_NUMBER_RE,relevance:0,starts:a},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{begin:/\]|\}|\)/,relevance:0,starts:a},{className:"string",begin:'"',end:'"',contains:[{begin:'""'}],starts:a},e.COMMENT("^\\s*%\\{\\s*$","^\\s*%\\}\\s*$"),e.COMMENT("%","$")]}}return Nl=t,Nl}var Ol,gm;function Ey(){if(gm)return Ol;gm=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 Ol=t,Ol}var Al,Em;function fy(){if(Em)return Al;Em=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}]},a,e.C_BLOCK_COMMENT_MODE,r,e.NUMBER_MODE,i,s,{begin:/:-/},{begin:/\.$/}]}}return Il=t,Il}var Dl,Sm;function by(){if(Sm)return Dl;Sm=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 Dl=t,Dl}var wl,bm;function Ty(){if(bm)return wl;bm=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 wl=t,wl}var xl,Tm;function hy(){if(Tm)return xl;Tm=1;function t(e){const n=e.regex,a=["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"],r=/[dualxmsipngr]{0,12}/,i={$pattern:/[\w.]+/,keyword:a.join(" ")},s={className:"subst",begin:"[$@]\\{",end:"\\}",keywords:i},o={begin:/->\{/,end:/\}/},c={scope:"attr",match:/\s+:\s*\w+(\s*\(.*?\))?/},l={scope:"variable",variants:[{begin:/\$\d/},{begin:n.concat(/[$%@](?!")(\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,"(?![A-Za-z])(?![@$%])")},{begin:/[$%@](?!")[^\s\w{=]|\$=/,relevance:0}],contains:[c]},u={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},d=[e.BACKSLASH_ESCAPE,s,l],_=[/!/,/\//,/\|/,/\?/,/'/,/"/,/#/],m=(b,I,R="\\1")=>{const y=R==="\\1"?R:n.concat(R,I);return n.concat(n.concat("(?:",b,")"),I,/(?:\\.|[^\\\/])*?/,y,/(?:\\.|[^\\\/])*?/,R,r)},p=(b,I,R)=>n.concat(n.concat("(?:",b,")"),I,/(?:\\.|[^\\\/])*?/,R,r),E=[l,e.HASH_COMMENT_MODE,e.COMMENT(/^=\w/,/=cut/,{endsWithParent:!0}),o,{className:"string",contains:d,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}]},u,{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:m("s|tr|y",n.either(..._,{capture:!0}))},{begin:m("s|tr|y","\\(","\\)")},{begin:m("s|tr|y","\\[","\\]")},{begin:m("s|tr|y","\\{","\\}")}],relevance:2},{className:"regexp",variants:[{begin:/(m|qr)\/\//,relevance:0},{begin:p("(?:m|qr)?",/\//,/\//)},{begin:p("m|qr",n.either(..._,{capture:!0}),/\1/)},{begin:p("m|qr",/\(/,/\)/)},{begin:p("m|qr",/\[/,/\]/)},{begin:p("m|qr",/\{/,/\}/)}]}]},{className:"function",beginKeywords:"sub method",end:"(\\s*\\(.*?\\))?[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE,c]},{className:"class",beginKeywords:"class",end:"[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE,c,u]},{begin:"-\\w\\b",relevance:0},{begin:"^__DATA__$",end:"^__END__$",subLanguage:"mojolicious",contains:[{begin:"^@@.*",end:"$",className:"comment"}]}];return s.contains=E,o.contains=E,{name:"Perl",aliases:["pl","pm"],keywords:i,contains:E}}return xl=t,xl}var Ll,hm;function vy(){if(hm)return Ll;hm=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 Ll=t,Ll}var Ml,vm;function Ry(){if(vm)return Ml;vm=1;function t(e){const n={className:"number",relevance:0,variants:[{begin:"[$][a-fA-F0-9]+"},e.NUMBER_MODE]},a={variants:[{match:[/(function|method)/,/\s+/,e.UNDERSCORE_IDENT_RE]}],scope:{1:"keyword",3:"title.function"}},r={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}),a,r,{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,n]}}return Ml=t,Ml}var kl,Rm;function Cy(){if(Rm)return kl;Rm=1;function t(e){const n={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"},a="[A-Za-z$_][0-9A-Za-z$_]*",r={className:"subst",begin:/#\{/,end:/\}/,keywords:n},i=[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,r]}]},{className:"built_in",begin:"@__"+e.IDENT_RE},{begin:"@"+e.IDENT_RE},{begin:e.IDENT_RE+"\\\\"+e.IDENT_RE}];r.contains=i;const s=e.inherit(e.TITLE_MODE,{begin:a}),o="(\\(.*\\)\\s*)?\\B[-=]>",c={className:"params",begin:"\\([^\\(]",returnBegin:!0,contains:[{begin:/\(/,end:/\)/,keywords:n,contains:["self"].concat(i)}]};return{name:"MoonScript",aliases:["moon"],keywords:n,illegal:/\/\*/,contains:i.concat([e.COMMENT("--","$"),{className:"function",begin:"^\\s*"+a+"\\s*=\\s*"+o,end:"[-=]>",returnBegin:!0,contains:[s,c]},{begin:/[\(,:=]\s*/,relevance:0,contains:[{className:"function",begin:o,end:"[-=]>",returnBegin:!0,contains:[c]}]},{className:"class",beginKeywords:"class",end:"$",illegal:/[:="\[\]]/,contains:[{beginKeywords:"extends",endsWithParent:!0,illegal:/[:="\[\]]/,contains:[s]},s]},{className:"name",begin:a+":",end:":",returnBegin:!0,returnEnd:!0,relevance:0}])}}return kl=t,kl}var Pl,Cm;function yy(){if(Cm)return Pl;Cm=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 Pl=t,Pl}var Ul,ym;function Ny(){if(ym)return Ul;ym=1;function t(e){const n={match:[/^\s*(?=\S)/,/[^:]+/,/:\s*/,/$/],className:{2:"attribute",3:"punctuation"}},a={match:[/^\s*(?=\S)/,/[^:]*[^: ]/,/[ ]*:/,/[ ]/,/.*$/],className:{2:"attribute",3:"punctuation",5:"string"}},r={match:[/^\s*/,/>/,/[ ]/,/.*$/],className:{2:"punctuation",4:"string"}},i={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}),i,r,n,a]}}return Ul=t,Ul}var Fl,Nm;function Oy(){if(Nm)return Fl;Nm=1;function t(e){const n=e.regex,a={className:"variable",variants:[{begin:/\$\d+/},{begin:/\$\{\w+\}/},{begin:n.concat(/[$@]/,e.UNDERSCORE_IDENT_RE)}]},i={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,a],variants:[{begin:/"/,end:/"/},{begin:/'/,end:/'/}]},{begin:"([a-z]+):/",end:"\\s",endsWithParent:!0,excludeEnd:!0,contains:[a]},{className:"regexp",contains:[e.BACKSLASH_ESCAPE,a],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},a]};return{name:"Nginx config",aliases:["nginxconf"],contains:[e.HASH_COMMENT_MODE,{beginKeywords:"upstream location",end:/;|\{/,contains:i.contains,keywords:{section:"upstream location"}},{className:"section",begin:n.concat(e.UNDERSCORE_IDENT_RE+n.lookahead(/\s+\{/)),relevance:0},{begin:n.lookahead(e.UNDERSCORE_IDENT_RE+"\\s"),end:";|\\{",contains:[{className:"attribute",begin:e.UNDERSCORE_IDENT_RE,starts:i}],relevance:0}],illegal:"[^\\s\\}\\{]"}}return Fl=t,Fl}var Bl,Om;function Ay(){if(Om)return Bl;Om=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 Bl=t,Bl}var Gl,Am;function Iy(){if(Am)return Gl;Am=1;function t(e){const n=e.regex,a={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"]},r={scope:"built_in",match:n.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(N=>`builtins\\.${N}`)),relevance:10},i="[A-Za-z_][A-Za-z0-9_'-]*",s={scope:"symbol",match:new RegExp(`<${i}(/${i})*>`)},o="[A-Za-z0-9_\\+\\.-]+",c={scope:"symbol",match:new RegExp(`(\\.\\.|\\.|~)?/(${o})?(/${o})*(?=[\\s;])`)},l=n.either("==","=","\\+\\+","\\+","<=","<\\|","<",">=",">","->","//","/","!=","!","\\|\\|","\\|>","\\?","\\*","&&"),u={scope:"operator",match:n.concat(l,/(?!-)/),relevance:0},d={scope:"number",match:new RegExp(`${e.NUMBER_RE}(?!-)`),relevance:0},_={variants:[{scope:"operator",beforeMatch:/\s/,begin:/-(?!>)/},{begin:[new RegExp(`${e.NUMBER_RE}`),/-/,/(?!>)/],beginScope:{1:"number",2:"operator"}},{begin:[l,/-/,/(?!>)/],beginScope:{1:"operator",2:"operator"}}],relevance:0},m={beforeMatch:/(^|\{|;)\s*/,begin:new RegExp(`${i}(\\.${i})*\\s*=(?!=)`),returnBegin:!0,relevance:0,contains:[{scope:"attr",match:new RegExp(`${i}(\\.${i})*(?=\\s*=)`),relevance:.2}]},p={scope:"char.escape",match:/\\\$/},E={scope:"char.escape",match:/''\$/},b={scope:"subst",begin:/\$\{/,end:/\}/,keywords:a},I={scope:"char.escape",match:/'''/},R={scope:"char.escape",match:/\\(?!\$)./},y={scope:"string",variants:[{begin:"''",end:"''",contains:[E,b,I,R]},{begin:'"',end:'"',contains:[p,b,R]}]},L={scope:"params",match:new RegExp(`${i}\\s*:(?=\\s)`)},U=[d,e.HASH_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),r,y,s,c,L,m,_,u];b.contains=U;const h=[{scope:"meta.prompt",match:/^nix-repl>(?=\s)/,relevance:10},{scope:"meta",beforeMatch:/\s+/,begin:/:([a-z]+|\?)/}];return{name:"Nix",aliases:["nixos"],keywords:a,contains:U.concat(h)}}return Gl=t,Gl}var Yl,Im;function Dy(){if(Im)return Yl;Im=1;function t(e){return{name:"Node REPL",contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"javascript"}},variants:[{begin:/^>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return Yl=t,Yl}var $l,Dm;function wy(){if(Dm)return $l;Dm=1;function t(e){const n=e.regex,a=["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"],r=["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"],i=["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:n.concat(/\$/,n.either(...a))},o={className:"variable",begin:/\$+\{[\!\w.:-]+\}/},c={className:"variable",begin:/\$+\w[\w\.]*/,illegal:/\(\)\{\}/},l={className:"variable",begin:/\$+\([\w^.:!-]+\)/},u={className:"params",begin:n.either(...r)},d={className:"keyword",begin:n.concat(/!/,n.either(...i))},_={className:"char.escape",begin:/\$(\\[nrt]|\$)/},m={className:"title.function",begin:/\w+::\w+/},p={className:"string",variants:[{begin:'"',end:'"'},{begin:"'",end:"'"},{begin:"`",end:"`"}],illegal:/\n/,contains:[_,s,o,c,l]},E=["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"],b=["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"],I={match:[/Function/,/\s+/,n.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:E,literal:b},contains:[e.HASH_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT(";","$",{relevance:0}),y,I,{beginKeywords:"Function PageEx Section SectionGroup FunctionEnd SectionEnd"},p,d,o,c,l,u,m,e.NUMBER_MODE]}}return $l=t,$l}var ql,wm;function xy(){if(wm)return ql;wm=1;function t(e){const n={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+"},a=/[a-zA-Z@][a-zA-Z0-9_]*/,c={"variable.language":["this","super"],$pattern:a,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"]},l={$pattern:a,keyword:["@interface","@class","@protocol","@implementation"]};return{name:"Objective-C",aliases:["mm","objc","obj-c","obj-c++","objective-c++"],keywords:c,illegal:"/,end:/$/,illegal:"\\n"},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"class",begin:"("+l.keyword.join("|")+")\\b",end:/(\{|$)/,excludeEnd:!0,keywords:l,contains:[e.UNDERSCORE_TITLE_MODE]},{begin:"\\."+e.UNDERSCORE_IDENT_RE,relevance:0}]}}return ql=t,ql}var Hl,xm;function Ly(){if(xm)return Hl;xm=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 Hl=t,Hl}var Vl,Lm;function My(){if(Lm)return Vl;Lm=1;function t(e){const n={className:"keyword",begin:"\\$(f[asn]|t|vp[rtd]|children)"},a={className:"literal",begin:"false|true|PI|undef"},r={className:"number",begin:"\\b\\d+(\\.\\d+)?(e-?\\d+)?",relevance:0},i=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",r,i,n,a]},c={begin:"[*!#%]",relevance:0},l={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,r,s,i,n,c,l]}}return Vl=t,Vl}var zl,Mm;function ky(){if(Mm)return zl;Mm=1;function t(e){const n={$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"},a=e.COMMENT(/\{/,/\}/,{relevance:0}),r=e.COMMENT("\\(\\*","\\*\\)",{relevance:10}),i={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:n,contains:[i,s]},a,r]},c={scope:"punctuation",match:/;/,relevance:0};return{name:"Oxygene",case_insensitive:!0,keywords:n,illegal:'("|\\$[G-Zg-z]|\\/\\*||->)',contains:[a,r,e.C_LINE_COMMENT_MODE,i,s,e.NUMBER_MODE,o,c]}}return zl=t,zl}var Wl,km;function Py(){if(km)return Wl;km=1;function t(e){const n=e.COMMENT(/\{/,/\}/,{contains:["self"]});return{name:"Parser3",subLanguage:"xml",relevance:0,contains:[e.COMMENT("^#","$"),e.COMMENT(/\^rem\{/,/\}/,{relevance:10,contains:[n]}),{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 Wl=t,Wl}var Kl,Pm;function Uy(){if(Pm)return Kl;Pm=1;function t(e){const n={className:"variable",begin:/\$[\w\d#@][\w\d_]*/,relevance:0},a={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,n,a]}}return Kl=t,Kl}var Ql,Um;function Fy(){if(Um)return Ql;Um=1;function t(e){const n=e.COMMENT("--","$"),a="[a-zA-Z_][a-zA-Z_0-9$]*",r="\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",i="<<\\s*"+a+"\\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 ",c="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 ",l="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 ",u=l.trim().split(" ").map(function(b){return b.split("|")[0]}).join("|"),d="CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURRENT_CATALOG|10 CURRENT_DATE LOCALTIME LOCALTIMESTAMP CURRENT_ROLE|10 CURRENT_SCHEMA|10 SESSION_USER PUBLIC ",_="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 ",m="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 ",E="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(b){return b.split("|")[0]}).join("|");return{name:"PostgreSQL",aliases:["postgres","postgresql"],supersetOf:"sql",case_insensitive:!0,keywords:{keyword:s+c+o,built_in:d+_+m},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("+E+")\\s*\\("},{begin:"\\.("+u+")\\b"},{begin:"\\b("+u+")\\s+PATH\\b",keywords:{keyword:"PATH",type:l.replace("PATH ","")}},{className:"type",begin:"\\b("+u+")\\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:r,end:r,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,n,{className:"meta",variants:[{begin:"%(ROW)?TYPE",relevance:10},{begin:"\\$\\d+"},{begin:"^#\\w",end:"$"}]},{className:"symbol",begin:i,relevance:10}]}}return Ql=t,Ql}var Xl,Fm;function By(){if(Fm)return Xl;Fm=1;function t(e){const n=e.regex,a=/(?![A-Za-z0-9])(?![$])/,r=n.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,a),i=n.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,a),s=n.concat(/[A-Z]+/,a),o={scope:"variable",match:"\\$+"+r},c={scope:"meta",variants:[{begin:/<\?php/,relevance:10},{begin:/<\?=/},{begin:/<\?/,relevance:.1},{begin:/\?>/}]},l={scope:"subst",variants:[{begin:/\$\w+/},{begin:/\{\$/,end:/\}/}]},u=e.inherit(e.APOS_STRING_MODE,{illegal:null}),d=e.inherit(e.QUOTE_STRING_MODE,{illegal:null,contains:e.QUOTE_STRING_MODE.contains.concat(l)}),_={begin:/<<<[ \t]*(?:(\w+)|"(\w+)")\n/,end:/[ \t]*(\w+)\b/,contains:e.QUOTE_STRING_MODE.contains.concat(l),"on:begin":(be,oe)=>{oe.data._beginMatch=be[1]||be[2]},"on:end":(be,oe)=>{oe.data._beginMatch!==be[1]&&oe.ignoreMatch()}},m=e.END_SAME_AS_BEGIN({begin:/<<<[ \t]*'(\w+)'\n/,end:/[ \t]*(\w+)\b/}),p=`[ +]`,E={scope:"string",variants:[d,u,_,m]},b={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},I=["false","null","true"],R=["__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"],U={keyword:R,literal:(be=>{const oe=[];return be.forEach(pe=>{oe.push(pe),pe.toLowerCase()===pe?oe.push(pe.toUpperCase()):oe.push(pe.toLowerCase())}),oe})(I),built_in:y},h=be=>be.map(oe=>oe.replace(/\|\d+$/,"")),N={variants:[{match:[/new/,n.concat(p,"+"),n.concat("(?!",h(y).join("\\b|"),"\\b)"),i],scope:{1:"keyword",4:"title.class"}}]},C=n.concat(r,"\\b(?!\\()"),f={variants:[{match:[n.concat(/::/,n.lookahead(/(?!class\b)/)),C],scope:{2:"variable.constant"}},{match:[/::/,/class/],scope:{2:"variable.language"}},{match:[i,n.concat(/::/,n.lookahead(/(?!class\b)/)),C],scope:{1:"title.class",3:"variable.constant"}},{match:[i,n.concat("::",n.lookahead(/(?!class\b)/))],scope:{1:"title.class"}},{match:[i,/::/,/class/],scope:{1:"title.class",3:"variable.language"}}]},A={scope:"attr",match:n.concat(r,n.lookahead(":"),n.lookahead(/(?!::)/))},w={relevance:0,begin:/\(/,end:/\)/,keywords:U,contains:[A,o,f,e.C_BLOCK_COMMENT_MODE,E,b,N]},F={relevance:0,match:[/\b/,n.concat("(?!fn\\b|function\\b|",h(R).join("\\b|"),"|",h(y).join("\\b|"),"\\b)"),r,n.concat(p,"*"),n.lookahead(/(?=\()/)],scope:{3:"title.function.invoke"},contains:[w]};w.contains.push(F);const j=[A,f,e.C_BLOCK_COMMENT_MODE,E,b,N],_e={begin:n.concat(/#\[\s*\\?/,n.either(i,s)),beginScope:"meta",end:/]/,endScope:"meta",keywords:{literal:I,keyword:["new","array"]},contains:[{begin:/\[/,end:/]/,keywords:{literal:I,keyword:["new","array"]},contains:["self",...j]},...j,{scope:"meta",variants:[{match:i},{match:s}]}]};return{case_insensitive:!1,keywords:U,contains:[_e,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}]}},c,{scope:"variable.language",match:/\$this\b/},o,F,f,{match:[/const/,/\s/,r],scope:{1:"keyword",3:"variable.constant"}},N,{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:U,contains:["self",_e,o,f,e.C_BLOCK_COMMENT_MODE,E,b]}]},{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]},E,b]}}return Xl=t,Xl}var Zl,Bm;function Gy(){if(Bm)return Zl;Bm=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 Zl=t,Zl}var Jl,Gm;function Yy(){if(Gm)return Jl;Gm=1;function t(e){return{name:"Plain text",aliases:["text","txt"],disableAutodetect:!0}}return Jl=t,Jl}var jl,Ym;function $y(){if(Ym)return jl;Ym=1;function t(e){const n={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"},a={className:"string",begin:'"""',end:'"""',relevance:10},r={className:"string",begin:'"',end:'"',contains:[e.BACKSLASH_ESCAPE]},i={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:n,contains:[s,a,r,i,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 jl=t,jl}var ec,$m;function qy(){if($m)return ec;$m=1;function t(e){const n=["string","char","byte","int","long","bool","decimal","single","double","DateTime","xml","array","hashtable","void"],a="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",r="-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",i={$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},c={className:"variable",variants:[{begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]},l={className:"literal",begin:/\$(null|true|false)\b/},u={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],contains:[o,c,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},d={className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]},_={className:"doctag",variants:[{begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/},{begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/}]},m=e.inherit(e.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,end:/#>/}],contains:[_]}),p={className:"built_in",variants:[{begin:"(".concat(a,")+(-)[\\w\\d]+")}]},E={className:"class",beginKeywords:"class enum",end:/\s*[{]/,excludeEnd:!0,relevance:0,contains:[e.TITLE_MODE]},b={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:[c]}]},I={begin:/using\s/,end:/$/,returnBegin:!0,contains:[u,d,{className:"keyword",begin:/(using|assembly|command|module|namespace|type)/}]},R={variants:[{className:"operator",begin:"(".concat(r,")\\b")},{className:"literal",begin:/(-){1,2}[\w\d-]+/,relevance:0}]},y={className:"selector-tag",begin:/@\B/,relevance:0},L={className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,relevance:0,contains:[{className:"keyword",begin:"(".concat(i.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,relevance:0},e.inherit(e.TITLE_MODE,{endsParent:!0})]},U=[L,m,o,e.NUMBER_MODE,u,d,p,c,l,y],h={begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",U,{begin:"("+n.join("|")+")",className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,relevance:0})};return L.contains.unshift(h),{name:"PowerShell",aliases:["pwsh","ps","ps1"],case_insensitive:!0,keywords:i,contains:U.concat(E,b,I,R,h)}}return ec=t,ec}var tc,qm;function Hy(){if(qm)return tc;qm=1;function t(e){const n=e.regex,a=["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"],r=e.IDENT_RE,i={variants:[{match:n.concat(n.either(...a),n.lookahead(/\s*\(/)),className:"built_in"},{relevance:0,match:n.concat(/\b(?!for|if|while)/,r,n.lookahead(/\s*\(/)),className:"title.function"}]},s={match:[/new\s+/,r],className:{1:"keyword",2:"class.title"}},o={relevance:0,match:[/\./,r],className:{2:"property"}},c={variants:[{match:[/class/,/\s+/,r,/\s+/,/extends/,/\s+/,r]},{match:[/class/,/\s+/,r]}],className:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},l=["boolean","byte","char","color","double","float","int","long","short"],u=["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:[...a,...u],type:l},contains:[c,s,i,o,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.C_NUMBER_MODE]}}return tc=t,tc}var nc,Hm;function Vy(){if(Hm)return nc;Hm=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 nc=t,nc}var ac,Vm;function zy(){if(Vm)return ac;Vm=1;function t(e){const n={begin:/[a-z][A-Za-z0-9_]*/,relevance:0},a={className:"symbol",variants:[{begin:/[A-Z][a-zA-Z0-9_]*/},{begin:/_[A-Za-z0-9_]*/}],relevance:0},r={begin:/\(/,end:/\)/,relevance:0},i={begin:/\[/,end:/\]/},s={className:"comment",begin:/%/,end:/$/,contains:[e.PHRASAL_WORDS_MODE]},o={className:"string",begin:/`/,end:/`/,contains:[e.BACKSLASH_ESCAPE]},c={className:"string",begin:/0'(\\'|.)/},l={className:"string",begin:/0'\\s/},d=[n,a,r,{begin:/:-/},i,s,e.C_BLOCK_COMMENT_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,o,c,l,e.C_NUMBER_MODE];return r.contains=d,i.contains=d,{name:"Prolog",contains:d.concat([{begin:/\.$/}])}}return ac=t,ac}var rc,zm;function Wy(){if(zm)return rc;zm=1;function t(e){const n="[ \\t\\f]*",a="[ \\t\\f]+",r=n+"[:=]"+n,i=a,s="("+r+"|"+i+")",o="([^\\\\:= \\t\\f\\n]|\\\\.)+",c={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+r},{begin:o+i}],contains:[{className:"attr",begin:o,endsParent:!0}],starts:c},{className:"attr",begin:o+n+"$"}]}}return rc=t,rc}var ic,Wm;function Ky(){if(Wm)return ic;Wm=1;function t(e){const n=["package","import","option","optional","required","repeated","group","oneof"],a=["double","float","int32","int64","uint32","uint64","sint32","sint64","fixed32","fixed64","sfixed32","sfixed64","bool","string","bytes"],r={match:[/(message|enum|service)\s+/,e.IDENT_RE],scope:{1:"keyword",2:"title.class"}};return{name:"Protocol Buffers",aliases:["proto"],keywords:{keyword:n,type:a,literal:["true","false"]},contains:[e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,r,{className:"function",beginKeywords:"rpc",end:/[{;]/,excludeEnd:!0,keywords:"rpc returns"},{begin:/^\s*[A-Z_]+(?=\s*=[^\n]+;$)/}]}}return ic=t,ic}var sc,Km;function Qy(){if(Km)return sc;Km=1;function t(e){const n={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"},a=e.COMMENT("#","$"),r="([A-Za-z_]|::)(\\w|::)*",i=e.inherit(e.TITLE_MODE,{begin:r}),s={className:"variable",begin:"\\$"+r},o={className:"string",contains:[e.BACKSLASH_ESCAPE,s],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]};return{name:"Puppet",aliases:["pp"],contains:[a,s,o,{beginKeywords:"class",end:"\\{|;",illegal:/=/,contains:[i,a]},{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:n,relevance:0,contains:[o,a,{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 sc=t,sc}var oc,Qm;function Xy(){if(Qm)return oc;Qm=1;function t(e){const n={className:"string",begin:'(~)?"',end:'"',illegal:"\\n"},a={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]},n,a]}}return oc=t,oc}var lc,Xm;function Zy(){if(Xm)return lc;Xm=1;function t(e){const n=e.regex,a=new RegExp("[\\p{XID_Start}_]\\p{XID_Continue}*","u"),r=["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"],c={$pattern:/[A-Za-z]\w+|__\w+__/,keyword:r,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"]},l={className:"meta",begin:/^(>>>|\.\.\.) /},u={className:"subst",begin:/\{/,end:/\}/,keywords:c,illegal:/#/},d={begin:/\{\{/,relevance:0},_={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,l],relevance:10},{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,l],relevance:10},{begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,l,d,u]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,l,d,u]},{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,d,u]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,d,u]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},m="[0-9](_?[0-9])*",p=`(\\b(${m}))?\\.(${m})|\\b(${m})\\.`,E=`\\b|${r.join("|")}`,b={className:"number",relevance:0,variants:[{begin:`(\\b(${m})|(${p}))[eE][+-]?(${m})[jJ]?(?=${E})`},{begin:`(${p})[jJ]?`},{begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${E})`},{begin:`\\b0[bB](_?[01])+[lL]?(?=${E})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${E})`},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${E})`},{begin:`\\b(${m})[jJ](?=${E})`}]},I={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:c,contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},R={className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:c,contains:["self",l,b,_,e.HASH_COMMENT_MODE]}]};return u.contains=[_,b,l],{name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:c,illegal:/(<\/|\?)|=>/,contains:[l,b,{scope:"variable.language",match:/\bself\b/},{beginKeywords:"if",relevance:0},{match:/\bor\b/,scope:"keyword"},_,I,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,a],scope:{1:"keyword",3:"title.function"},contains:[R]},{variants:[{match:[/\bclass/,/\s+/,a,/\s*/,/\(\s*/,a,/\s*\)/]},{match:[/\bclass/,/\s+/,a]}],scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[b,R,_]}]}}return lc=t,lc}var cc,Zm;function Jy(){if(Zm)return cc;Zm=1;function t(e){return{aliases:["pycon"],contains:[{className:"meta.prompt",starts:{end:/ |$/,starts:{end:"$",subLanguage:"python"}},variants:[{begin:/^>>>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}}return cc=t,cc}var uc,Jm;function jy(){if(Jm)return uc;Jm=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 uc=t,uc}var dc,jm;function eN(){if(jm)return dc;jm=1;function t(e){const n=e.regex,a={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"},r="[a-zA-Z_][a-zA-Z0-9\\._]*",i={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:r,returnEnd:!1}},c={begin:r+"\\s*:",returnBegin:!0,contains:[{className:"attribute",begin:r,end:"\\s*:",excludeEnd:!0,relevance:0}],relevance:0},l={begin:n.concat(r,/\s*\{/),end:/\{/,returnBegin:!0,relevance:0,contains:[e.inherit(e.TITLE_MODE,{begin:r})]};return{name:"QML",aliases:["qt"],case_insensitive:!1,keywords:a,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,i,{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,c,l],illegal:/#/}}return dc=t,dc}var _c,eg;function tN(){if(eg)return _c;eg=1;function t(e){const n=e.regex,a=/(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,r=n.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]?/),i=/[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/,s=n.either(/[()]/,/[{}]/,/\[\[/,/[[\]]/,/\\/,/,/);return{name:"R",keywords:{$pattern:a,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:n.lookahead(n.either(/\n^#'\s*(?=@[a-zA-Z]+)/,/\n^(?!#')/)),endsParent:!0}},{scope:"doctag",begin:"@param",end:/$/,contains:[{scope:"variable",variants:[{match:a},{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:[i,r]},{scope:{1:"operator",2:"number"},match:[/%[^%]*%/,r]},{scope:{1:"punctuation",2:"number"},match:[s,r]},{scope:{2:"number"},match:[/[^a-zA-Z0-9._]|^/,r]}]},{scope:{3:"operator"},match:[a,/\s+/,/<-/,/\s+/]},{scope:"operator",relevance:0,variants:[{match:i},{match:/%[^%]*%/}]},{scope:"punctuation",relevance:0,match:s},{begin:"`",end:"`",contains:[{begin:/\\./}]}]}}return _c=t,_c}var pc,tg;function nN(){if(tg)return pc;tg=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 pc=t,pc}var mc,ng;function aN(){if(ng)return mc;ng=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("^#","$"),c,l,o,{begin:/[\w-]+=([^\s{}[\]()>]+)/,relevance:0,returnBegin:!0,contains:[{className:"attribute",begin:/[^=]+/},{begin:/=/,endsWithParent:!0,relevance:0,contains:[c,l,o,{className:"literal",begin:"\\b("+i.split(" ").join("|")+")\\b"},{begin:/("[^"]*"|[^\s{}[\]]+)/}]}]},{className:"number",begin:/\*[0-9a-fA-F]+/},{begin:"\\b("+r.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 Ec=t,Ec}var fc,ig;function sN(){if(ig)return fc;ig=1;function t(e){const n=["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"],a=["matrix","float","color","point","normal","vector"],r=["while","for","if","do","return","else","break","extern","continue"],i={match:[/(surface|displacement|light|volume|imager)/,/\s+/,e.IDENT_RE],scope:{1:"keyword",3:"title.class"}};return{name:"RenderMan RSL",keywords:{keyword:r,built_in:n,type:a},illegal:""},s]}}return bc=t,bc}var Tc,lg;function cN(){if(lg)return Tc;lg=1;function t(e){const n=e.regex,a=["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"],r=["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"],i=["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:a},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:"%"+n.either(...i)},{className:"title.function",begin:/%[a-zA-Z_][a-zA-Z_0-9]*/},{className:"meta",begin:n.either(...r)+"(?=\\()"},{className:"string",variants:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},e.COMMENT("\\*",";"),e.C_BLOCK_COMMENT_MODE]}}return Tc=t,Tc}var hc,cg;function uN(){if(cg)return hc;cg=1;function t(e){const n=e.regex,a={className:"meta",begin:"@[A-Za-z]+"},r={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"},{begin:/\$\{/,end:/\}/}]},i={className:"string",variants:[{begin:'"""',end:'"""'},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:'[a-z]+"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,r]},{className:"string",begin:'[a-z]+"""',end:'"""',contains:[r],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},c={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]},l={className:"function",beginKeywords:"def",end:n.lookahead(/[:={\[(\n;]/),contains:[o]},u={begin:[/^\s*/,"extension",/\s+(?=[[(])/],beginScope:{2:"keyword"}},d={begin:[/^\s*/,/end/,/\s+/,/(extension\b)?/],beginScope:{2:"keyword",4:"keyword"}},_=[{match:/\.inline\b/},{begin:/\binline(?=\s)/,keywords:"inline"}],m={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,i,s,l,c,e.C_NUMBER_MODE,u,d,..._,m,a]}}return hc=t,hc}var vc,ug;function dN(){if(ug)return vc;ug=1;function t(e){const n="[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",a="(-|\\+)?\\d+([./]\\d+)?",r=a+"[+\\-]"+a+"i",i={$pattern:n,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|#\\\\"+n+"|#\\\\.)"},o={className:"number",variants:[{begin:a,relevance:0},{begin:r,relevance:0},{begin:"#b[0-1]+(/[0-1]+)?"},{begin:"#o[0-7]+(/[0-7]+)?"},{begin:"#x[0-9a-f]+(/[0-9a-f]+)?"}]},c=e.QUOTE_STRING_MODE,l=[e.COMMENT(";","$",{relevance:0}),e.COMMENT("#\\|","\\|#")],u={begin:n,relevance:0},d={className:"symbol",begin:"'"+n},_={endsWithParent:!0,relevance:0},m={variants:[{begin:/'/},{begin:"`"}],contains:[{begin:"\\(",end:"\\)",contains:["self",s,c,o,u,d]}]},p={className:"name",relevance:0,begin:n,keywords:i},b={variants:[{begin:"\\(",end:"\\)"},{begin:"\\[",end:"\\]"}],contains:[{begin:/lambda/,endsWithParent:!0,returnBegin:!0,contains:[p,{endsParent:!0,variants:[{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/}],contains:[u]}]},p,_]};return _.contains=[s,o,c,u,d,m,b].concat(l),{name:"Scheme",aliases:["scm"],illegal:/\S/,contains:[e.SHEBANG(),o,c,d,m,b].concat(l)}}return vc=t,vc}var Rc,dg;function _N(){if(dg)return Rc;dg=1;function t(e){const n=[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:n},e.COMMENT("//","$")].concat(n)}}return Rc=t,Rc}var Cc,_g;function pN(){if(_g)return Cc;_g=1;const t=l=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:l.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:[l.APOS_STRING_MODE,l.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:l.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"],n=["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"],a=[...e,...n],r=["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(),i=["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 c(l){const u=t(l),d=s,_=i,m="@[a-z-]+",p="and or not only",b={className:"variable",begin:"(\\$"+"[a-zA-Z-][a-zA-Z0-9_-]*"+")\\b",relevance:0};return{name:"SCSS",case_insensitive:!0,illegal:"[=/|']",contains:[l.C_LINE_COMMENT_MODE,l.C_BLOCK_COMMENT_MODE,u.CSS_NUMBER_MODE,{className:"selector-id",begin:"#[A-Za-z0-9_-]+",relevance:0},{className:"selector-class",begin:"\\.[A-Za-z0-9_-]+",relevance:0},u.ATTRIBUTE_SELECTOR_MODE,{className:"selector-tag",begin:"\\b("+a.join("|")+")\\b",relevance:0},{className:"selector-pseudo",begin:":("+_.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+d.join("|")+")"},b,{begin:/\(/,end:/\)/,contains:[u.CSS_NUMBER_MODE]},u.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:[u.BLOCK_COMMENT,b,u.HEXCOLOR,u.CSS_NUMBER_MODE,l.QUOTE_STRING_MODE,l.APOS_STRING_MODE,u.IMPORTANT,u.FUNCTION_DISPATCH]},{begin:"@(page|font-face)",keywords:{$pattern:m,keyword:"@page @font-face"}},{begin:"@",end:"[{;]",returnBegin:!0,keywords:{$pattern:/[a-z-]+/,keyword:p,attribute:r.join(" ")},contains:[{begin:m,className:"keyword"},{begin:/[a-z-]+(?=:)/,className:"attribute"},b,l.QUOTE_STRING_MODE,l.APOS_STRING_MODE,u.HEXCOLOR,u.CSS_NUMBER_MODE]},u.FUNCTION_DISPATCH]}}return Cc=c,Cc}var yc,pg;function mN(){if(pg)return yc;pg=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 yc=t,yc}var Nc,mg;function gN(){if(mg)return Nc;mg=1;function t(e){const n=["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"],a=["aget","aput","array","check","execute","fill","filled","goto/16","goto/32","iget","instance","invoke","iput","monitor","packed","sget","sparse"],r=["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("+r.join("|")+")"}]},{className:"built_in",variants:[{begin:"\\s("+n.join("|")+")\\s"},{begin:"\\s("+n.join("|")+")((-|/)[a-zA-Z0-9]+)+\\s",relevance:10},{begin:"\\s("+a.join("|")+")((-|/)[a-zA-Z0-9]+)*\\s",relevance:10}]},{className:"class",begin:`L[^(;: +]*;`,relevance:0},{begin:"[vp][0-9]+"}]}}return Nc=t,Nc}var Oc,gg;function EN(){if(gg)return Oc;gg=1;function t(e){const n="[a-z][a-zA-Z0-9_]*",a={className:"string",begin:"\\$.{1}"},r={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:n+":",relevance:0},e.C_NUMBER_MODE,r,a,{begin:"\\|[ ]*"+n+"([ ]+"+n+")*[ ]*\\|",returnBegin:!0,end:/\|/,illegal:/\S/,contains:[{begin:"(\\|[ ]*)?"+n}]},{begin:"#\\(",end:"\\)",contains:[e.APOS_STRING_MODE,a,e.C_NUMBER_MODE,r]}]}}return Oc=t,Oc}var Ac,Eg;function fN(){if(Eg)return Ac;Eg=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 Ac=t,Ac}var Ic,fg;function SN(){if(fg)return Ic;fg=1;function t(e){const n={className:"variable",begin:/\b_+[a-zA-Z]\w*/},a={className:"title",begin:/[a-zA-Z][a-zA-Z_0-9]*_fnc_[a-zA-Z_0-9]+/},r={className:"string",variants:[{begin:'"',end:'"',contains:[{begin:'""',relevance:0}]},{begin:"'",end:"'",contains:[{begin:"''",relevance:0}]}]},i=["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"],c={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:"define undef ifdef ifndef else endif include if",contains:[{begin:/\\\n/,relevance:0},e.inherit(r,{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:i,built_in:o,literal:s},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.NUMBER_MODE,n,a,r,c],illegal:[/\$[^a-fA-F0-9]/,/\w\$/,/\?/,/@/,/ \| /,/[a-zA-Z_]\./,/\:\=/,/\[\:/]}}return Ic=t,Ic}var Dc,Sg;function bN(){if(Sg)return Dc;Sg=1;function t(e){const n=e.regex,a=e.COMMENT("--","$"),r={scope:"string",variants:[{begin:/'/,end:/'/,contains:[{match:/''/}]}]},i={begin:/"/,end:/"/,contains:[{match:/""/}]},s=["true","false","unknown"],o=["double precision","large object","with timezone","without timezone"],c=["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"],l=["add","asc","collation","desc","final","first","last","view"],u=["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"],d=["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"],_=["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"],m=["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"],p=d,E=[...u,...l].filter(h=>!d.includes(h)),b={scope:"variable",match:/@[a-z0-9][a-z0-9_]*/},I={scope:"operator",match:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,relevance:0},R={match:n.concat(/\b/,n.either(...p),/\s*\(/),relevance:0,keywords:{built_in:p}};function y(h){return n.concat(/\b/,n.either(...h.map(N=>N.replace(/\s+/,"\\s+"))),/\b/)}const L={scope:"keyword",match:y(m),relevance:0};function U(h,{exceptions:N,when:C}={}){const f=C;return N=N||[],h.map(A=>A.match(/\|\d+$/)||N.includes(A)?A:f(A)?`${A}|0`:A)}return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{$pattern:/\b[\w\.]+/,keyword:U(E,{when:h=>h.length<3}),literal:s,type:c,built_in:_},contains:[{scope:"type",match:y(o)},L,R,b,r,i,e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,a,I]}}return Dc=t,Dc}var wc,bg;function TN(){if(bg)return wc;bg=1;function t(e){const n=e.regex,a=["functions","model","data","parameters","quantities","transformed","generated"],r=["for","in","if","else","while","break","continue","return"],i=["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"],c=e.COMMENT(/\/\*/,/\*\//,{relevance:0,contains:[{scope:"doctag",match:/@(return|param)/}]}),l={scope:"meta",begin:/#include\b/,end:/$/,contains:[{match:/[a-z][a-z-._]+/,scope:"string"},e.C_LINE_COMMENT_MODE]},u=["lower","upper","offset","multiplier"];return{name:"Stan",aliases:["stanfuncs"],keywords:{$pattern:e.IDENT_RE,title:a,type:i,keyword:r,built_in:s},contains:[e.C_LINE_COMMENT_MODE,l,e.HASH_COMMENT_MODE,c,{scope:"built_in",match:/\s(pi|e|sqrt2|log2|log10)(?=\()/,relevance:0},{match:n.concat(/[<,]\s*/,n.either(...u),/\s*=/),keywords:u},{scope:"keyword",match:/\btarget(?=\s*\+=)/},{match:[/~\s*/,n.either(...o),/(?:\(\))/,/\s*T(?=\s*\[)/],scope:{2:"built_in",4:"keyword"}},{scope:"built_in",keywords:o,begin:n.concat(/\w*/,n.either(...o),/(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/)},{begin:[/~/,/\s*/,n.concat(n.either(...o),/(?=\s*[\(.*\)])/)],scope:{3:"built_in"}},{begin:[/~/,/\s*\w+(?=\s*[\(.*\)])/,"(?!.*/\b("+n.either(...o)+")\b)"],scope:{2:"title.function"}},{scope:"title.function",begin:/\w*(_lpdf|_lupdf|_lpmf|_cdf|_lcdf|_lccdf|_qf)(?=\s*[\(.*\)])/},{scope:"number",match:n.concat(/(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)/,/(?:[eE][+-]?\d+(?:_\d+)*)?i?(?!\w)/),relevance:0},{scope:"string",begin:/"/,end:/"/}]}}return wc=t,wc}var xc,Tg;function hN(){if(Tg)return xc;Tg=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 xc=t,xc}var Lc,hg;function vN(){if(hg)return Lc;hg=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 Lc=t,Lc}var Mc,vg;function RN(){if(vg)return Mc;vg=1;const t=l=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:l.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:[l.APOS_STRING_MODE,l.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:l.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"],n=["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"],a=[...e,...n],r=["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(),i=["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 c(l){const u=t(l),d="and or not only",_={className:"variable",begin:"\\$"+l.IDENT_RE},m=["charset","css","debug","extend","font-face","for","import","include","keyframes","media","mixin","page","warn","while"],p="(?=[.\\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:[l.QUOTE_STRING_MODE,l.APOS_STRING_MODE,l.C_LINE_COMMENT_MODE,l.C_BLOCK_COMMENT_MODE,u.HEXCOLOR,{begin:"\\.[a-zA-Z][a-zA-Z0-9_-]*"+p,className:"selector-class"},{begin:"#[a-zA-Z][a-zA-Z0-9_-]*"+p,className:"selector-id"},{begin:"\\b("+a.join("|")+")"+p,className:"selector-tag"},{className:"selector-pseudo",begin:"&?:("+i.join("|")+")"+p},{className:"selector-pseudo",begin:"&?:(:)?("+s.join("|")+")"+p},u.ATTRIBUTE_SELECTOR_MODE,{className:"keyword",begin:/@media/,starts:{end:/[{;}]/,keywords:{$pattern:/[a-z-]+/,keyword:d,attribute:r.join(" ")},contains:[u.CSS_NUMBER_MODE]}},{className:"keyword",begin:"@((-(o|moz|ms|webkit)-)?("+m.join("|")+"))\\b"},_,u.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:[u.HEXCOLOR,_,l.APOS_STRING_MODE,u.CSS_NUMBER_MODE,l.QUOTE_STRING_MODE]}]},u.CSS_VARIABLE,{className:"attribute",begin:"\\b("+o.join("|")+")\\b",starts:{end:/;|$/,contains:[u.HEXCOLOR,_,l.APOS_STRING_MODE,l.QUOTE_STRING_MODE,u.CSS_NUMBER_MODE,l.C_BLOCK_COMMENT_MODE,u.IMPORTANT,u.FUNCTION_DISPATCH],illegal:/\./,relevance:0}},u.FUNCTION_DISPATCH]}}return Mc=c,Mc}var kc,Rg;function CN(){if(Rg)return kc;Rg=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 kc=t,kc}var Pc,Cg;function yN(){if(Cg)return Pc;Cg=1;function t(C){return C?typeof C=="string"?C:C.source:null}function e(C){return n("(?=",C,")")}function n(...C){return C.map(A=>t(A)).join("")}function a(C){const f=C[C.length-1];return typeof f=="object"&&f.constructor===Object?(C.splice(C.length-1,1),f):{}}function r(...C){return"("+(a(C).capture?"":"?:")+C.map(w=>t(w)).join("|")+")"}const i=C=>n(/\b/,C,/\w$/.test(C)?/\b/:/\B/),s=["Protocol","Type"].map(i),o=["init","self"].map(i),c=["Any","Self"],l=["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"],u=["false","nil","true"],d=["assignment","associativity","higherThan","left","lowerThan","none","right"],_=["#colorLiteral","#column","#dsohandle","#else","#elseif","#endif","#error","#file","#fileID","#fileLiteral","#filePath","#function","#if","#imageLiteral","#keyPath","#line","#selector","#sourceLocation","#warning"],m=["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"],p=r(/[/=\-+!*%<>&|^~?]/,/[\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]/),E=r(p,/[\u0300-\u036F]/,/[\u1DC0-\u1DFF]/,/[\u20D0-\u20FF]/,/[\uFE00-\uFE0F]/,/[\uFE20-\uFE2F]/),b=n(p,E,"*"),I=r(/[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]/),R=r(I,/\d/,/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),y=n(I,R,"*"),L=n(/[A-Z]/,R,"*"),U=["attached","autoclosure",n(/convention\(/,r("swift","block","c"),/\)/),"discardableResult","dynamicCallable","dynamicMemberLookup","escaping","freestanding","frozen","GKInspectable","IBAction","IBDesignable","IBInspectable","IBOutlet","IBSegueAction","inlinable","main","nonobjc","NSApplicationMain","NSCopying","NSManaged",n(/objc\(/,y,/\)/),"objc","objcMembers","propertyWrapper","requires_stored_property_inits","resultBuilder","Sendable","testable","UIApplicationMain","unchecked","unknown","usableFromInline","warn_unqualified_access"],h=["iOS","iOSApplicationExtension","macOS","macOSApplicationExtension","macCatalyst","macCatalystApplicationExtension","watchOS","watchOSApplicationExtension","tvOS","tvOSApplicationExtension","swift"];function N(C){const f={match:/\s+/,relevance:0},A=C.COMMENT("/\\*","\\*/",{contains:["self"]}),w=[C.C_LINE_COMMENT_MODE,A],F={match:[/\./,r(...s,...o)],className:{2:"keyword"}},j={match:n(/\./,r(...l)),relevance:0},_e=l.filter(he=>typeof he=="string").concat(["_|0"]),be=l.filter(he=>typeof he!="string").concat(c).map(i),oe={variants:[{className:"keyword",match:r(...be,...o)}]},pe={$pattern:r(/\b\w+/,/#\w+/),keyword:_e.concat(_),literal:u},Ce=[F,j,oe],ot={match:n(/\./,r(...m)),relevance:0},lt={className:"built_in",match:n(/\b/,r(...m),/(?=\()/)},at=[ot,lt],We={match:/->/,relevance:0},Ae={className:"operator",relevance:0,variants:[{match:b},{match:`\\.(\\.|${E})+`}]},He=[We,Ae],ke="([0-9]_*)+",rt="([0-9a-fA-F]_*)+",je={className:"number",relevance:0,variants:[{match:`\\b(${ke})(\\.(${ke}))?([eE][+-]?(${ke}))?\\b`},{match:`\\b0x(${rt})(\\.(${rt}))?([pP][+-]?(${ke}))?\\b`},{match:/\b0o([0-7]_*)+\b/},{match:/\b0b([01]_*)+\b/}]},Ke=(he="")=>({className:"subst",variants:[{match:n(/\\/,he,/[0\\tnr"']/)},{match:n(/\\/,he,/u\{[0-9a-fA-F]{1,8}\}/)}]}),Et=(he="")=>({className:"subst",match:n(/\\/,he,/[\t ]*(?:[\r\n]|\r\n)/)}),ut=(he="")=>({className:"subst",label:"interpol",begin:n(/\\/,he,/\(/),end:/\)/}),bt=(he="")=>({begin:n(he,/"""/),end:n(/"""/,he),contains:[Ke(he),Et(he),ut(he)]}),D=(he="")=>({begin:n(he,/"/),end:n(/"/,he),contains:[Ke(he),ut(he)]}),P={className:"string",variants:[bt(),bt("#"),bt("##"),bt("###"),D(),D("#"),D("##"),D("###")]},z=[C.BACKSLASH_ESCAPE,{begin:/\[/,end:/\]/,relevance:0,contains:[C.BACKSLASH_ESCAPE]}],K={begin:/\/[^\s](?=[^/\n]*\/)/,end:/\//,contains:z},Z=he=>{const we=n(he,/\//),Pe=n(/\//,he);return{begin:we,end:Pe,contains:[...z,{scope:"comment",begin:`#(?!.*${Pe})`,end:/$/}]}},W={scope:"regexp",variants:[Z("###"),Z("##"),Z("#"),K]},de={match:n(/`/,y,/`/)},ae={className:"variable",match:/\$\d+/},re={className:"variable",match:`\\$${R}+`},ee=[de,ae,re],Ne={match:/(@|#(un)?)available/,scope:"keyword",starts:{contains:[{begin:/\(/,end:/\)/,keywords:h,contains:[...He,je,P]}]}},ce={scope:"keyword",match:n(/@/,r(...U),e(r(/\(/,/\s+/)))},Re={scope:"meta",match:n(/@/,y)},ye=[Ne,ce,Re],Fe={match:e(/\b[A-Z]/),relevance:0,contains:[{className:"type",match:n(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,R,"+")},{className:"type",match:L,relevance:0},{match:/[?!]+/,relevance:0},{match:/\.\.\./,relevance:0},{match:n(/\s+&\s+/,e(L)),relevance:0}]},qe={begin://,keywords:pe,contains:[...w,...Ce,...ye,We,Fe]};Fe.contains.push(qe);const Qe={match:n(y,/\s*:/),keywords:"_|0",relevance:0},et={begin:/\(/,end:/\)/,relevance:0,keywords:pe,contains:["self",Qe,...w,W,...Ce,...at,...He,je,P,...ee,...ye,Fe]},dt={begin://,keywords:"repeat each",contains:[...w,Fe]},Lt={begin:r(e(n(y,/\s*:/)),e(n(y,/\s+/,y,/\s*:/))),end:/:/,relevance:0,contains:[{className:"keyword",match:/\b_\b/},{className:"params",match:y}]},Mt={begin:/\(/,end:/\)/,keywords:pe,contains:[Lt,...w,...Ce,...He,je,P,...ye,Fe,et],endsParent:!0,illegal:/["']/},Vt={match:[/(func|macro)/,/\s+/,r(de.match,y,b)],className:{1:"keyword",3:"title.function"},contains:[dt,Mt,f],illegal:[/\[/,/%/]},Ut={match:[/\b(?:subscript|init[?!]?)/,/\s*(?=[<(])/],className:{1:"keyword"},contains:[dt,Mt,f],illegal:/\[|%/},vt={match:[/operator/,/\s+/,b],className:{1:"keyword",3:"title"}},O={begin:[/precedencegroup/,/\s+/,L],className:{1:"keyword",3:"title"},contains:[Fe],keywords:[...d,...u],end:/}/},G={match:[/class\b/,/\s+/,/func\b/,/\s+/,/\b[A-Za-z_][A-Za-z0-9_]*\b/],scope:{1:"keyword",3:"keyword",5:"title.function"}},Q={match:[/class\b/,/\s+/,/var\b/],scope:{1:"keyword",3:"keyword"}},fe={begin:[/(struct|protocol|class|extension|enum|actor)/,/\s+/,y,/\s*/],beginScope:{1:"keyword",3:"title.class"},keywords:pe,contains:[dt,...Ce,{begin:/:/,end:/\{/,keywords:pe,contains:[{scope:"title.class.inherited",match:L},...Ce],relevance:0}]};for(const he of P.variants){const we=he.contains.find(Je=>Je.label==="interpol");we.keywords=pe;const Pe=[...Ce,...at,...He,je,P,...ee];we.contains=[...Pe,{begin:/\(/,end:/\)/,contains:["self",...Pe]}]}return{name:"Swift",keywords:pe,contains:[...w,Vt,Ut,G,Q,fe,vt,O,{beginKeywords:"import",end:/$/,contains:[...w],relevance:0},W,...Ce,...at,...He,je,P,...ee,...ye,Fe,et]}}return Pc=N,Pc}var Uc,yg;function NN(){if(yg)return Uc;yg=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 Uc=t,Uc}var Fc,Ng;function ON(){if(Ng)return Fc;Ng=1;function t(e){const n="true false yes no null",a="[\\w#;/?:@&=+$,.~*'()[\\]]+",r={className:"attr",variants:[{begin:/[\w*@][\w*@ :()\./-]*:(?=[ \t]|$)/},{begin:/"[\w*@][\w*@ :()\./-]*":(?=[ \t]|$)/},{begin:/'[\w*@][\w*@ :()\./-]*':(?=[ \t]|$)/}]},i={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,i]},c=e.inherit(o,{variants:[{begin:/'/,end:/'/,contains:[{begin:/''/,relevance:0}]},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),m={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"},p={end:",",endsWithParent:!0,excludeEnd:!0,keywords:n,relevance:0},E={begin:/\{/,end:/\}/,contains:[p],illegal:"\\n",relevance:0},b={begin:"\\[",end:"\\]",contains:[p],illegal:"\\n",relevance:0},I=[r,{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+!"+a},{className:"type",begin:"!<"+a+">"},{className:"type",begin:"!"+a},{className:"type",begin:"!!"+a},{className:"meta",begin:"&"+e.UNDERSCORE_IDENT_RE+"$"},{className:"meta",begin:"\\*"+e.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",relevance:0},e.HASH_COMMENT_MODE,{beginKeywords:n,keywords:{literal:n}},m,{className:"number",begin:e.C_NUMBER_RE+"\\b",relevance:0},E,b,s,o],R=[...I];return R.pop(),R.push(c),p.contains=R,{name:"YAML",case_insensitive:!0,aliases:["yml"],contains:I}}return Fc=t,Fc}var Bc,Og;function AN(){if(Og)return Bc;Og=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 Bc=t,Bc}var Gc,Ag;function IN(){if(Ag)return Gc;Ag=1;function t(e){const n=e.regex,a=/[a-zA-Z_][a-zA-Z0-9_]*/,r={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:n.concat(/\$/,n.optional(/::/),a,"(::",a,")*")},{begin:"\\$\\{(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",end:"\\}",contains:[r]}]},{className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[e.inherit(e.QUOTE_STRING_MODE,{illegal:null})]},r]}}return Gc=t,Gc}var Yc,Ig;function DN(){if(Ig)return Yc;Ig=1;function t(e){const n=["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:n,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:[...n,"set","list","map"]},end:">",contains:["self"]}]}}return Yc=t,Yc}var $c,Dg;function wN(){if(Dg)return $c;Dg=1;function t(e){const n={className:"number",begin:"[1-9][0-9]*",relevance:0},a={className:"symbol",begin:":[^\\]]+"},r={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",n,a]},i={className:"built_in",begin:"(AI|AO|DI|DO|F|RI|RO|UI|UO|GI|GO|SI|SO)\\[",end:"\\]",contains:["self",n,e.QUOTE_STRING_MODE,a]};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:[r,i,{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 $c=t,$c}var qc,wg;function xN(){if(wg)return qc;wg=1;function t(e){const n=e.regex,a=["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"],r=["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 i=["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"];i=i.concat(i.map(E=>`end${E}`));const s={scope:"string",variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/}]},o={scope:"number",match:/\d+/},c={begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,contains:[s,o]},l={beginKeywords:a.join(" "),keywords:{name:a},relevance:0,contains:[c]},u={match:/\|(?=[A-Za-z_]+:?)/,beginScope:"punctuation",relevance:0,contains:[{match:/[A-Za-z_]+:?/,keywords:r}]},d=(E,{relevance:b})=>({beginScope:{1:"template-tag",3:"name"},relevance:b||2,endScope:"template-tag",begin:[/\{%/,/\s*/,n.either(...E)],end:/%\}/,keywords:"in",contains:[u,l,s,o]}),_=/[a-z_]+/,m=d(i,{relevance:2}),p=d([_],{relevance:1});return{name:"Twig",aliases:["craftcms"],case_insensitive:!0,subLanguage:"xml",contains:[e.COMMENT(/\{#/,/#\}/),m,p,{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:["self",u,l,s,o]}]}}return qc=t,qc}var Hc,xg;function LN(){if(xg)return Hc;xg=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"],n=["true","false","null","undefined","NaN","Infinity"],a=["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"],r=["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"],s=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],o=[].concat(i,a,r);function c(u){const d=u.regex,_=(Ke,{after:Et})=>{const ut="",end:""},E=/<[A-Za-z0-9\\._:-]+\s*\/>/,b={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(Ke,Et)=>{const ut=Ke[0].length+Ke.index,bt=Ke.input[ut];if(bt==="<"||bt===","){Et.ignoreMatch();return}bt===">"&&(_(Ke,{after:ut})||Et.ignoreMatch());let D;const P=Ke.input.substring(ut);if(D=P.match(/^\s*=/)){Et.ignoreMatch();return}if((D=P.match(/^\s+extends\s+/))&&D.index===0){Et.ignoreMatch();return}}},I={$pattern:t,keyword:e,literal:n,built_in:o,"variable.language":s},R="[0-9](_?[0-9])*",y=`\\.(${R})`,L="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",U={className:"number",variants:[{begin:`(\\b(${L})((${y})|\\.)?|(${y}))[eE][+-]?(${R})\\b`},{begin:`\\b(${L})\\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},h={className:"subst",begin:"\\$\\{",end:"\\}",keywords:I,contains:[]},N={begin:".?html`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,h],subLanguage:"xml"}},C={begin:".?css`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,h],subLanguage:"css"}},f={begin:".?gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[u.BACKSLASH_ESCAPE,h],subLanguage:"graphql"}},A={className:"string",begin:"`",end:"`",contains:[u.BACKSLASH_ESCAPE,h]},F={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:m+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),u.C_BLOCK_COMMENT_MODE,u.C_LINE_COMMENT_MODE]},j=[u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,N,C,f,A,{match:/\$\d+/},U];h.contains=j.concat({begin:/\{/,end:/\}/,keywords:I,contains:["self"].concat(j)});const _e=[].concat(F,h.contains),be=_e.concat([{begin:/(\s*)\(/,end:/\)/,keywords:I,contains:["self"].concat(_e)}]),oe={className:"params",begin:/(\s*)\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:I,contains:be},pe={variants:[{match:[/class/,/\s+/,m,/\s+/,/extends/,/\s+/,d.concat(m,"(",d.concat(/\./,m),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,m],scope:{1:"keyword",3:"title.class"}}]},Ce={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:{_:[...a,...r]}},ot={label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},lt={variants:[{match:[/function/,/\s+/,m,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[oe],illegal:/%/},at={relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"};function We(Ke){return d.concat("(?!",Ke.join("|"),")")}const Ae={match:d.concat(/\b/,We([...i,"super","import"].map(Ke=>`${Ke}\\s*\\(`)),m,d.lookahead(/\s*\(/)),className:"title.function",relevance:0},He={begin:d.concat(/\./,d.lookahead(d.concat(m,/(?![0-9A-Za-z$_(])/))),end:m,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},ke={match:[/get|set/,/\s+/,m,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},oe]},rt="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+u.UNDERSCORE_IDENT_RE+")\\s*=>",je={match:[/const|var|let/,/\s+/,m,/\s*/,/=\s*/,/(async\s*)?/,d.lookahead(rt)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[oe]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:I,exports:{PARAMS_CONTAINS:be,CLASS_REFERENCE:Ce},illegal:/#(?![$_A-z])/,contains:[u.SHEBANG({label:"shebang",binary:"node",relevance:5}),ot,u.APOS_STRING_MODE,u.QUOTE_STRING_MODE,N,C,f,A,F,{match:/\$\d+/},U,Ce,{scope:"attr",match:m+d.lookahead(":"),relevance:0},je,{begin:"("+u.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[F,u.REGEXP_MODE,{className:"function",begin:rt,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:I,contains:be}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:p.begin,end:p.end},{match:E},{begin:b.begin,"on:begin":b.isTrulyOpeningTag,end:b.end}],subLanguage:"xml",contains:[{begin:b.begin,end:b.end,skip:!0,contains:["self"]}]}]},lt,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+u.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[oe,u.inherit(u.TITLE_MODE,{begin:m,className:"title.function"})]},{match:/\.\.\./,relevance:0},He,{match:"\\$"+m,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[oe]},Ae,at,pe,ke,{match:/\$[(.]/}]}}function l(u){const d=u.regex,_=c(u),m=t,p=["any","void","number","boolean","string","object","never","symbol","bigint","unknown"],E={begin:[/namespace/,/\s+/,u.IDENT_RE],beginScope:{1:"keyword",3:"title.class"}},b={beginKeywords:"interface",end:/\{/,excludeEnd:!0,keywords:{keyword:"interface extends",built_in:p},contains:[_.exports.CLASS_REFERENCE]},I={className:"meta",relevance:10,begin:/^\s*['"]use strict['"]/},R=["type","interface","public","private","protected","implements","declare","abstract","readonly","enum","override","satisfies"],y={$pattern:t,keyword:e.concat(R),literal:n,built_in:o.concat(p),"variable.language":s},L={className:"meta",begin:"@"+m},U=(f,A,w)=>{const F=f.contains.findIndex(j=>j.label===A);if(F===-1)throw new Error("can not find mode to replace");f.contains.splice(F,1,w)};Object.assign(_.keywords,y),_.exports.PARAMS_CONTAINS.push(L);const h=_.contains.find(f=>f.scope==="attr"),N=Object.assign({},h,{match:d.concat(m,d.lookahead(/\s*\?:/))});_.exports.PARAMS_CONTAINS.push([_.exports.CLASS_REFERENCE,h,N]),_.contains=_.contains.concat([L,E,b,N]),U(_,"shebang",u.SHEBANG()),U(_,"use_strict",I);const C=_.contains.find(f=>f.label==="func.def");return C.relevance=0,Object.assign(_,{name:"TypeScript",aliases:["ts","tsx","mts","cts"]}),_}return Hc=l,Hc}var Vc,Lg;function MN(){if(Lg)return Vc;Lg=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 Vc=t,Vc}var zc,Mg;function kN(){if(Mg)return zc;Mg=1;function t(e){const n=e.regex,a={className:"string",begin:/"(""|[^/n])"C\b/},r={className:"string",begin:/"/,end:/"/,illegal:/\n/,contains:[{begin:/""/}]},i=/\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)/,c=/\d{1,2}(:\d{1,2}){1,2}/,l={className:"literal",variants:[{begin:n.concat(/# */,n.either(s,i),/ *#/)},{begin:n.concat(/# */,c,/ *#/)},{begin:n.concat(/# */,o,/ *#/)},{begin:n.concat(/# */,n.either(s,i),/ +/,n.either(o,c),/ *#/)}]},u={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])|[%&])?/}]},d={className:"label",begin:/^\w+:/},_=e.COMMENT(/'''/,/$/,{contains:[{className:"doctag",begin:/<\/?/,end:/>/}]}),m=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:[a,r,l,u,d,_,m,{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:[m]}]}}return zc=t,zc}var Wc,kg;function PN(){if(kg)return Wc;kg=1;function t(e){const n=e.regex,a=["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"],r=["server","response","request","scriptengine","scriptenginebuildversion","scriptengineminorversion","scriptenginemajorversion"],i={begin:n.concat(n.either(...a),"\\s*\\("),relevance:0,keywords:{built_in:a}};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:r,literal:["true","false","null","nothing","empty"]},illegal:"//",contains:[i,e.inherit(e.QUOTE_STRING_MODE,{contains:[{begin:'""'}]}),e.COMMENT(/'/,/$/,{relevance:0}),e.C_NUMBER_MODE]}}return Wc=t,Wc}var Kc,Pg;function UN(){if(Pg)return Kc;Pg=1;function t(e){return{name:"VBScript in HTML",subLanguage:"xml",contains:[{begin:"<%",end:"%>",subLanguage:"vbscript"}]}}return Kc=t,Kc}var Qc,Ug;function FN(){if(Ug)return Qc;Ug=1;function t(e){const n=e.regex,a={$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"]},r=["__FILE__","__LINE__"],i=["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:a,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:n.concat(/`/,n.either(...r))},{scope:"meta",begin:n.concat(/`/,n.either(...i)),end:/$|\/\/|\/\*/,returnEnd:!0,keywords:i}]}}return Qc=t,Qc}var Xc,Fg;function BN(){if(Fg)return Xc;Fg=1;function t(e){const n="\\d(_|\\d)*",a="[eE][-+]?"+n,r=n+"(\\."+n+")?("+a+")?",i="\\w+",o="\\b("+(n+"#"+i+"(\\."+i+")?#("+a+")?")+"|"+r+")";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 Xc=t,Xc}var Zc,Bg;function GN(){if(Bg)return Zc;Bg=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 Zc=t,Zc}var Jc,Gg;function YN(){if(Gg)return Jc;Gg=1;function t(e){e.regex;const n=e.COMMENT(/\(;/,/;\)/);n.contains.push("self");const a=e.COMMENT(/;;/,/$/),r=["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"],i={begin:[/(?:func|call|call_indirect)/,/\s+/,/\$[^\s)]+/],className:{1:"keyword",3:"title.function"}},s={className:"variable",begin:/\$[\w_]+/},o={match:/(\((?!;)|\))+/,className:"punctuation",relevance:0},c={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/},l={match:/(i32|i64|f32|f64)(?!\.)/,className:"type"},u={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:r},contains:[a,n,{match:[/(?:offset|align)/,/\s*/,/=/],className:{1:"keyword",3:"operator"}},s,o,i,e.QUOTE_STRING_MODE,l,u,c]}}return Jc=t,Jc}var jc,Yg;function $N(){if(Yg)return jc;Yg=1;function t(e){const n=e.regex,a=/[a-zA-Z]\w*/,r=["as","break","class","construct","continue","else","for","foreign","if","import","in","is","return","static","var","while"],i=["true","false","null"],s=["this","super"],o=["Bool","Class","Fiber","Fn","List","Map","Null","Num","Object","Range","Sequence","String","System"],c=["-","~",/\*/,"%",/\.\.\./,/\.\./,/\+/,"<<",">>",">=","<=","<",">",/\^/,/!=/,/!/,/\bis\b/,"==","&&","&",/\|\|/,/\|/,/\?:/,"="],l={relevance:0,match:n.concat(/\b(?!(if|while|for|else|super)\b)/,a,/(?=\s*[({])/),className:"title.function"},u={match:n.concat(n.either(n.concat(/\b(?!(if|while|for|else|super)\b)/,a),n.either(...c)),/(?=\s*\([^)]+\)\s*\{)/),className:"title.function",starts:{contains:[{begin:/\(/,end:/\)/,contains:[{relevance:0,scope:"params",match:a}]}]}},d={variants:[{match:[/class\s+/,a,/\s+is\s+/,a]},{match:[/class\s+/,a]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:r},_={relevance:0,match:n.either(...c),className:"operator"},m={className:"string",begin:/"""/,end:/"""/},p={className:"property",begin:n.concat(/\./,n.lookahead(a)),end:a,excludeBegin:!0,relevance:0},E={relevance:0,match:n.concat(/\b_/,a),scope:"variable"},b={relevance:0,match:/\b[A-Z]+[a-z]+([A-Z]+[a-z]+)*/,scope:"title.class",keywords:{_:o}},I=e.C_NUMBER_MODE,R={match:[a,/\s*/,/=/,/\s*/,/\(/,a,/\)\s*\{/],scope:{1:"title.function",3:"operator",6:"params"}},y=e.COMMENT(/\/\*\*/,/\*\//,{contains:[{match:/@[a-z]+/,scope:"doctag"},"self"]}),L={scope:"subst",begin:/%\(/,end:/\)/,contains:[I,b,l,E,_]},U={scope:"string",begin:/"/,end:/"/,contains:[L,{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}/}]}]};L.contains.push(U);const h=[...r,...s,...i],N={relevance:0,match:n.concat("\\b(?!",h.join("|"),"\\b)",/[a-zA-Z_]\w*(?:[?!]|\b)/),className:"variable"};return{name:"Wren",keywords:{keyword:r,"variable.language":s,literal:i},contains:[{scope:"comment",variants:[{begin:[/#!?/,/[A-Za-z_]+(?=\()/],beginScope:{},keywords:{literal:i},contains:[],end:/\)/},{begin:[/#!?/,/[A-Za-z_]+/],beginScope:{},end:/$/}]},I,U,m,y,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,b,d,R,u,l,_,E,p,N]}}return jc=t,jc}var eu,$g;function qN(){if($g)return eu;$g=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 eu=t,eu}var tu,qg;function HN(){if(qg)return tu;qg=1;function t(e){const n=["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"],a=["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"],r=["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:n,literal:["true","false","nil"],built_in:a.concat(r)},o={className:"string",begin:'"',end:'"',illegal:"\\n"},c={className:"string",begin:"'",end:"'",illegal:"\\n"},l={className:"string",begin:"<<",end:">>"},u={className:"number",begin:"[0-9]+#[0-9A-Z_]+(\\.[0-9-A-Z_]+)?#?([Ee][+-]?[0-9]+)?"},d={beginKeywords:"import",end:"$",keywords:s,contains:[o]},_={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,c,l,_,d,u,e.NUMBER_MODE]}}return tu=t,tu}var nu,Hg;function VN(){if(Hg)return nu;Hg=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 nu=t,nu}var au,Vg;function zN(){if(Vg)return au;Vg=1;function t(e){const n={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[e.inherit(e.APOS_STRING_MODE,{illegal:null}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null})]},a=e.UNDERSCORE_TITLE_MODE,r={variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]},i="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:i,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:[a,{className:"params",begin:/\(/,end:/\)/,keywords:i,contains:["self",e.C_BLOCK_COMMENT_MODE,n,r]}]},{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,illegal:/[:($"]/,contains:[{beginKeywords:"extends implements"},a]},{beginKeywords:"namespace",end:/;/,illegal:/[.']/,contains:[a]},{beginKeywords:"use",end:/;/,contains:[a]},{begin:/=>/},n,r]}}return au=t,au}var ru,zg;function WN(){if(zg)return ru;zg=1;var t=ER();return t.registerLanguage("1c",fR()),t.registerLanguage("abnf",SR()),t.registerLanguage("accesslog",bR()),t.registerLanguage("actionscript",TR()),t.registerLanguage("ada",hR()),t.registerLanguage("angelscript",vR()),t.registerLanguage("apache",RR()),t.registerLanguage("applescript",CR()),t.registerLanguage("arcade",yR()),t.registerLanguage("arduino",NR()),t.registerLanguage("armasm",OR()),t.registerLanguage("xml",AR()),t.registerLanguage("asciidoc",IR()),t.registerLanguage("aspectj",DR()),t.registerLanguage("autohotkey",wR()),t.registerLanguage("autoit",xR()),t.registerLanguage("avrasm",LR()),t.registerLanguage("awk",MR()),t.registerLanguage("axapta",kR()),t.registerLanguage("bash",PR()),t.registerLanguage("basic",UR()),t.registerLanguage("bnf",FR()),t.registerLanguage("brainfuck",BR()),t.registerLanguage("c",GR()),t.registerLanguage("cal",YR()),t.registerLanguage("capnproto",$R()),t.registerLanguage("ceylon",qR()),t.registerLanguage("clean",HR()),t.registerLanguage("clojure",VR()),t.registerLanguage("clojure-repl",zR()),t.registerLanguage("cmake",WR()),t.registerLanguage("coffeescript",KR()),t.registerLanguage("coq",QR()),t.registerLanguage("cos",XR()),t.registerLanguage("cpp",ZR()),t.registerLanguage("crmsh",JR()),t.registerLanguage("crystal",jR()),t.registerLanguage("csharp",eC()),t.registerLanguage("csp",tC()),t.registerLanguage("css",nC()),t.registerLanguage("d",aC()),t.registerLanguage("markdown",rC()),t.registerLanguage("dart",iC()),t.registerLanguage("delphi",sC()),t.registerLanguage("diff",oC()),t.registerLanguage("django",lC()),t.registerLanguage("dns",cC()),t.registerLanguage("dockerfile",uC()),t.registerLanguage("dos",dC()),t.registerLanguage("dsconfig",_C()),t.registerLanguage("dts",pC()),t.registerLanguage("dust",mC()),t.registerLanguage("ebnf",gC()),t.registerLanguage("elixir",EC()),t.registerLanguage("elm",fC()),t.registerLanguage("ruby",SC()),t.registerLanguage("erb",bC()),t.registerLanguage("erlang-repl",TC()),t.registerLanguage("erlang",hC()),t.registerLanguage("excel",vC()),t.registerLanguage("fix",RC()),t.registerLanguage("flix",CC()),t.registerLanguage("fortran",yC()),t.registerLanguage("fsharp",NC()),t.registerLanguage("gams",OC()),t.registerLanguage("gauss",AC()),t.registerLanguage("gcode",IC()),t.registerLanguage("gherkin",DC()),t.registerLanguage("glsl",wC()),t.registerLanguage("gml",xC()),t.registerLanguage("go",LC()),t.registerLanguage("golo",MC()),t.registerLanguage("gradle",kC()),t.registerLanguage("graphql",PC()),t.registerLanguage("groovy",UC()),t.registerLanguage("haml",FC()),t.registerLanguage("handlebars",BC()),t.registerLanguage("haskell",GC()),t.registerLanguage("haxe",YC()),t.registerLanguage("hsp",$C()),t.registerLanguage("http",qC()),t.registerLanguage("hy",HC()),t.registerLanguage("inform7",VC()),t.registerLanguage("ini",zC()),t.registerLanguage("irpf90",WC()),t.registerLanguage("isbl",KC()),t.registerLanguage("java",QC()),t.registerLanguage("javascript",XC()),t.registerLanguage("jboss-cli",ZC()),t.registerLanguage("json",JC()),t.registerLanguage("julia",jC()),t.registerLanguage("julia-repl",ey()),t.registerLanguage("kotlin",ty()),t.registerLanguage("lasso",ny()),t.registerLanguage("latex",ay()),t.registerLanguage("ldif",ry()),t.registerLanguage("leaf",iy()),t.registerLanguage("less",sy()),t.registerLanguage("lisp",oy()),t.registerLanguage("livecodeserver",ly()),t.registerLanguage("livescript",cy()),t.registerLanguage("llvm",uy()),t.registerLanguage("lsl",dy()),t.registerLanguage("lua",_y()),t.registerLanguage("makefile",py()),t.registerLanguage("mathematica",my()),t.registerLanguage("matlab",gy()),t.registerLanguage("maxima",Ey()),t.registerLanguage("mel",fy()),t.registerLanguage("mercury",Sy()),t.registerLanguage("mipsasm",by()),t.registerLanguage("mizar",Ty()),t.registerLanguage("perl",hy()),t.registerLanguage("mojolicious",vy()),t.registerLanguage("monkey",Ry()),t.registerLanguage("moonscript",Cy()),t.registerLanguage("n1ql",yy()),t.registerLanguage("nestedtext",Ny()),t.registerLanguage("nginx",Oy()),t.registerLanguage("nim",Ay()),t.registerLanguage("nix",Iy()),t.registerLanguage("node-repl",Dy()),t.registerLanguage("nsis",wy()),t.registerLanguage("objectivec",xy()),t.registerLanguage("ocaml",Ly()),t.registerLanguage("openscad",My()),t.registerLanguage("oxygene",ky()),t.registerLanguage("parser3",Py()),t.registerLanguage("pf",Uy()),t.registerLanguage("pgsql",Fy()),t.registerLanguage("php",By()),t.registerLanguage("php-template",Gy()),t.registerLanguage("plaintext",Yy()),t.registerLanguage("pony",$y()),t.registerLanguage("powershell",qy()),t.registerLanguage("processing",Hy()),t.registerLanguage("profile",Vy()),t.registerLanguage("prolog",zy()),t.registerLanguage("properties",Wy()),t.registerLanguage("protobuf",Ky()),t.registerLanguage("puppet",Qy()),t.registerLanguage("purebasic",Xy()),t.registerLanguage("python",Zy()),t.registerLanguage("python-repl",Jy()),t.registerLanguage("q",jy()),t.registerLanguage("qml",eN()),t.registerLanguage("r",tN()),t.registerLanguage("reasonml",nN()),t.registerLanguage("rib",aN()),t.registerLanguage("roboconf",rN()),t.registerLanguage("routeros",iN()),t.registerLanguage("rsl",sN()),t.registerLanguage("ruleslanguage",oN()),t.registerLanguage("rust",lN()),t.registerLanguage("sas",cN()),t.registerLanguage("scala",uN()),t.registerLanguage("scheme",dN()),t.registerLanguage("scilab",_N()),t.registerLanguage("scss",pN()),t.registerLanguage("shell",mN()),t.registerLanguage("smali",gN()),t.registerLanguage("smalltalk",EN()),t.registerLanguage("sml",fN()),t.registerLanguage("sqf",SN()),t.registerLanguage("sql",bN()),t.registerLanguage("stan",TN()),t.registerLanguage("stata",hN()),t.registerLanguage("step21",vN()),t.registerLanguage("stylus",RN()),t.registerLanguage("subunit",CN()),t.registerLanguage("swift",yN()),t.registerLanguage("taggerscript",NN()),t.registerLanguage("yaml",ON()),t.registerLanguage("tap",AN()),t.registerLanguage("tcl",IN()),t.registerLanguage("thrift",DN()),t.registerLanguage("tp",wN()),t.registerLanguage("twig",xN()),t.registerLanguage("typescript",LN()),t.registerLanguage("vala",MN()),t.registerLanguage("vbnet",kN()),t.registerLanguage("vbscript",PN()),t.registerLanguage("vbscript-html",UN()),t.registerLanguage("verilog",FN()),t.registerLanguage("vhdl",BN()),t.registerLanguage("vim",GN()),t.registerLanguage("wasm",YN()),t.registerLanguage("wren",$N()),t.registerLanguage("x86asm",qN()),t.registerLanguage("xl",HN()),t.registerLanguage("xquery",VN()),t.registerLanguage("zephir",zN()),t.HighlightJS=t,t.default=t,ru=t,ru}var KN=WN();const Ui=gR(KN),QN={css:"css",htm:"xml",html:"xml",js:"javascript",json:"json",md:"markdown",scad:"openscad",svg:"xml",ts:"typescript",xml:"xml"},XN={html:"xml",svg:"xml",stl:"openscad"};function aS(t){return t&&Ui.getLanguage(t)?t:"plaintext"}function ZN(t){const e=String(t||"").split("?")[0].split("#")[0];return e.includes(".")?e.split(".").pop().toLowerCase():""}function rS(t={}){const e=t.source_filename||t.filename||t.url||"",n=QN[ZN(e)]||XN[t.content_type];return aS(n)}function iS(t,e){return Ui.highlight(t||"",{language:aS(e)}).value}const JN={class:"artifacts-header"},jN={class:"artifacts-tabs chip-group"},eO=["aria-pressed"],tO={class:"artifacts-tab-count"},nO=["aria-pressed"],aO={class:"artifacts-tab-count"},rO=["aria-pressed"],iO={class:"artifacts-tab-count"},sO=["aria-pressed"],oO={key:0,class:"viewed-images-group"},lO={class:"viewed-images-header"},cO={class:"artifacts-tab-count"},uO={class:"viewed-images-grid"},dO=["src","alt","onClick"],_O={key:1,class:"artifacts-empty"},pO={class:"artifacts-list"},mO=["onClick"],gO={class:"artifact-icon"},EO={class:"artifact-info"},fO={class:"artifact-title"},SO={class:"artifact-meta"},bO={key:0,class:"artifact-detail"},TO={class:"artifact-detail-header"},hO={class:"artifact-detail-title"},vO={class:"artifact-detail-filename"},RO={class:"artifact-actions"},CO=["href"],yO=["href"],NO=["href"],OO={class:"artifact-preview"},AO={key:0,class:"artifact-source"},IO={key:0,class:"artifact-source-state"},DO={key:1,class:"artifact-source-error"},wO={key:2,class:"artifact-source-code"},xO=["innerHTML"],LO=["src"],MO=["src","alt"],kO=["src"],PO={key:4,class:"artifact-no-preview"},UO={key:0,class:"artifacts-empty"},FO={class:"artifacts-list links-list"},BO=["href"],GO={class:"artifact-info"},YO={class:"artifact-title"},$O={class:"artifact-meta"},qO={class:"link-detail"},HO={class:"link-detail-header"},VO={class:"link-detail-count"},zO={class:"link-actions"},WO={class:"ptr-label"},KO={class:"files-toolbar"},QO={key:0,class:"artifacts-empty"},XO={class:"artifact-icon"},ZO={class:"artifact-info"},JO={class:"artifact-title"},jO={class:"artifact-meta"},eA={key:0,class:"file-row-actions"},tA=["href"],nA=["href"],aA={key:0,class:"artifacts-empty"},rA={class:"artifacts-list terminals-list"},iA=["onClick"],sA={class:"artifact-icon"},oA={class:"artifact-info"},lA={class:"artifact-title"},cA={class:"artifact-meta"},uA={key:0,class:"terminal-detail"},dA={class:"terminal-detail-header"},_A={class:"terminal-detail-title-wrap"},pA={class:"terminal-detail-title"},mA={class:"terminal-detail-meta"},gA={class:"terminal-detail-grid"},EA={class:"terminal-detail-row"},fA={class:"terminal-detail-value"},SA={class:"terminal-detail-row"},bA={class:"terminal-detail-row"},TA={class:"terminal-detail-value"},hA={key:0,class:"terminal-detail-row"},vA={class:"terminal-detail-value"},RA={key:1,class:"terminal-detail-row"},CA={class:"terminal-detail-value"},yA={key:0,class:"terminal-output-wrap"},NA={class:"terminal-output-header"},OA={class:"terminal-output"},AA={key:1,class:"terminal-detail"},IA={class:"terminal-detail-header"},DA={class:"terminal-detail-title"},wA={class:"terminal-detail-meta"},xA={class:"terminal-detail-grid"},LA={class:"terminal-detail-row"},MA={class:"terminal-detail-row"},kA={class:"terminal-detail-value"},PA={class:"terminal-detail-row"},UA={class:"terminal-detail-value terminal-detail-command"},FA={class:"terminal-detail-row"},BA={class:"terminal-detail-value"},GA={key:0,class:"terminal-detail-row"},YA={class:"terminal-detail-value"},$A={key:1,class:"terminal-detail-row"},qA={class:"terminal-detail-value"},HA={key:2,class:"terminal-detail-row"},VA={class:"terminal-detail-value"},zA={key:0,class:"terminal-output-wrap"},WA={class:"terminal-output"},Wg=80,KA=120,QA=980,XA=500,Kg="navi:artifacts-drawer-width",ZA={__name:"ArtifactsPanel",props:{open:{type:Boolean,default:!1}},emits:["close"],setup(t,{emit:e}){const n=e,a=sn(),{open:r}=ci();function i(B){r(B)}const s=Y(null),o=Y(null),c=Y(!1),l=Y(""),u=Y(!1),d=Y(""),_=Y(!1),m=Y(typeof window>"u"?0:window.innerWidth),p=Y("artifacts");function E(B){if(B<60)return`${Math.round(B)}s`;if(B<3600)return`${Math.floor(B/60)}m ${Math.round(B%60)}s`;const q=Math.floor(B/3600),Oe=Math.floor(B%3600/60);return`${q}h ${Oe}m`}const b=Y(null),I=ue(()=>{const B=Object.values(a.backgroundTasks).map(Te=>({kind:"task",key:Te.taskId,running:Te.status==="running",startedAt:Te.startedAt??"",task:Te})),q=Object.values(a.terminals).filter(Te=>!Te.closed||Te.output).map(Te=>({kind:"terminal",key:Te.name,running:Te.status==="busy"&&!Te.closed,startedAt:"",terminal:Te}));return[...B,...q].sort((Te,Se)=>Te.running!==Se.running?Te.running?-1:1:String(Se.startedAt??"").localeCompare(String(Te.startedAt??"")))}),R=ue(()=>I.value.filter(B=>B.running).length),y=ue(()=>{var B;return((B=b.value)==null?void 0:B.kind)==="task"&&a.backgroundTasks[b.value.key]||null}),L=ue(()=>{var B;return((B=b.value)==null?void 0:B.kind)==="terminal"&&a.terminals[b.value.key]||null});st(()=>[y.value,L.value],([B,q])=>{b.value&&!B&&!q&&(b.value=null)}),st(()=>a.currentId,()=>{b.value=null});function U(B){var Oe,Te;const q={kind:B.kind,key:B.key};b.value=((Oe=b.value)==null?void 0:Oe.kind)===q.kind&&((Te=b.value)==null?void 0:Te.key)===q.key?null:q}function h(B){return!!(b.value&&b.value.kind===B.kind&&b.value.key===B.key)}function N(B){return B.kind==="terminal"?"ph ph-terminal-window":F[B.task.tool]||"ph ph-arrows-out"}function C(B){return B.kind==="terminal"?B.terminal.name:B.task.argsSummary||B.task.tool}function f(B){return B.kind==="terminal"?B.terminal.description||B.terminal.command||"Terminal":`${B.task.tool} · ${j(B.task)} ago`}function A(B){return B.kind==="terminal"?B.terminal.closed?"badge-error":B.terminal.status==="busy"?"badge-success":"badge-secondary":be(B.task)}function w(B){return B.kind==="terminal"?B.terminal.closed?"Closed":B.terminal.status==="busy"?"Busy":"Idle":oe(B.task)}const F={terminal:"ph ph-terminal-window",ssh_exec:"ph ph-plugs-connected",spawn_agent:"ph ph-user-circle-gear",code_exec:"ph ph-code",peer:"ph ph-chats-circle"};function j(B){const q=B.finishedAt??B.startedAt;if(!q)return"";let Oe=(Date.now()-new Date(q).getTime())/1e3;return!Number.isFinite(Oe)||Oe<0?"just now":Oe<60?`${Math.round(Oe)}s`:Oe<3600?`${Math.floor(Oe/60)}m`:Oe<86400?`${Math.floor(Oe/3600)}h`:`${Math.floor(Oe/86400)}d`}function _e(B){return B.status==="running"?"status-busy":B.status==="completed"?"status-idle":"status-closed"}function be(B){return B.status==="running"?"badge-success":B.status==="completed"?"badge-secondary":"badge-error"}function oe(B){return{running:"Running",completed:"Done",failed:"Failed",cancelled:"Stopped"}[B.status]||B.status}function pe(B){if(!B)return"N/A";const q=new Date(B);return Number.isNaN(q.getTime())?B:q.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit",second:"2-digit"})}const Ce=Y(!1);async function ot(){if(!(Ce.value||!a.currentId)){Ce.value=!0;try{await a.fetchFiles(a.currentId)}finally{Ce.value=!1}}}const lt=Y(!1),at=Y(0),We=Y(!1),Ae=Y(null),He=ue(()=>({transform:`translateY(${Math.min(at.value,KA)}px)`,opacity:lt.value?Math.min(at.value/Wg,1):0})),ke=ue(()=>Ce.value?"Refreshing...":We.value?"Release to refresh":"Pull to refresh");let rt=0,je=0;function Ke(B){var Oe;const q=Ae.value;q&&(je=q.scrollTop||0,!(je>2)&&(rt=((Oe=B.touches[0])==null?void 0:Oe.clientY)??0,lt.value=!1,at.value=0,We.value=!1))}function Et(B){var Te;if(je>2||!rt)return;const Oe=(((Te=B.touches[0])==null?void 0:Te.clientY)??0)-rt;if(Oe<=0){lt.value=!1;return}Oe>4&&B.preventDefault(),lt.value=!0,at.value=Oe,We.value=Oe>=Wg}function ut(){We.value&&!Ce.value&&ot(),lt.value=!1,at.value=0,We.value=!1,rt=0,je=0}const bt=Y(vt()),D=ue(()=>a.artifacts),P=ue(()=>D.value.find(B=>ce(B)===s.value)||D.value[0]||null);function z(B){return B.replace(/[.,;:!?)\]}+]+$/,"")}function K(B){try{const q=z(B),Oe=new URL(q,window.location.origin),Te=Oe.hostname.toLowerCase().replace(/^www\./,"");let Se=Oe.pathname.toLowerCase();return Se=Se.replace(/\/$/,""),`${Te}${Se}`}catch{return z(B).toLowerCase()}}const Z=ue(()=>{const B=new Set,q=[],Oe=[];for(let Te=a.messages.length-1;Te>=0;Te--){const Se=a.messages[Te];if(Se.role!=="assistant")continue;const $t=Se.text||"";let Yt;const Zt=/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;for(;(Yt=Zt.exec($t))!==null;){let jt=Yt[2].trim();const In=K(jt);if(B.has(In))continue;B.add(In),q.push({url:jt,text:Yt[1].trim(),snippet:it($t,Yt.index),domain:De(jt)});const ba=Yt[0].lastIndexOf(Yt[2]),ta=Yt.index+ba;Oe.push({start:ta,end:ta+Yt[2].length})}}for(let Te=a.messages.length-1;Te>=0;Te--){const Se=a.messages[Te];if(Se.role!=="assistant")continue;const $t=Se.text||"";let Yt;const Zt=/https?:\/\/[^\s<>"{}|\\^`[\]]+/g;for(;(Yt=Zt.exec($t))!==null;){let jt=Yt[0].trim();jt=z(jt);const In=K(jt);if(B.has(In))continue;const ba=Yt.index,ta=Yt.index+Yt[0].length;Oe.some($n=>ba>=$n.start&&ta<=$n.end)||(B.add(In),q.push({url:jt,text:"",snippet:it($t,Yt.index),domain:De(jt)}))}}return q}),W=ue(()=>a.files),de=ue(()=>W.value.map(q=>{const Oe=q.path.split("/"),Te=Oe[Oe.length-1],Se=Oe.length-1;return{...q,name:Te,depth:Se}})),ae=ue(()=>P.value?rS(P.value):"plaintext"),re=ue(()=>iS(l.value,ae.value)),ee=ue(()=>m.value>QA),Ne=ue(()=>ee.value?{"--artifacts-width":`${dt()}px`}:{});st(D,B=>{if(!B.length){s.value=null;return}(!s.value||!B.some(q=>ce(q)===s.value))&&(s.value=ce(B[0]))},{immediate:!0});function ce(B){return B.id||B.filename}function Re(B){s.value=ce(B),c.value=!1,l.value="",d.value=""}function ye(B){return B.content_type||"unknown"}function Fe(B){return{stl:"ph ph-cube",html:"ph ph-browser",svg:"ph ph-bezier-curve",pdf:"ph ph-file-pdf",image:"ph ph-image",video:"ph ph-video"}[ye(B)]||"ph ph-paperclip"}function qe(){return Math.round(Math.min(600,m.value*.42))}function Qe(){return Math.max(qe(),m.value-XA)}function et(B){return Math.min(Math.max(Math.round(B),qe()),Qe())}function dt(){return et(bt.value??qe())}function Lt(){m.value=window.innerWidth,bt.value!==null&&(bt.value=dt())}function Mt(B){ee.value&&(B.preventDefault(),_.value=!0,document.body.style.cursor="col-resize",document.body.style.userSelect="none",window.addEventListener("pointermove",Vt),window.addEventListener("pointerup",Ut,{once:!0}))}function Vt(B){bt.value=et(m.value-B.clientX)}function Ut(){_.value=!1,O(),document.body.style.cursor="",document.body.style.userSelect="",window.removeEventListener("pointermove",Vt),window.removeEventListener("pointerup",Ut)}function vt(){if(typeof window>"u")return null;try{const B=Number(window.localStorage.getItem(Kg));return Number.isFinite(B)&&B>0?B:null}catch{return null}}function O(){if(!(typeof window>"u"||bt.value===null))try{window.localStorage.setItem(Kg,String(dt()))}catch{}}Sn(()=>{window.addEventListener("resize",Lt)}),Yn(()=>{window.removeEventListener("resize",Lt),window.removeEventListener("pointermove",Vt),window.removeEventListener("pointerup",Ut),_.value&&Ut()});function G(B){const q=ye(B).toUpperCase(),Oe=B.updated_at||B.created_at;return Oe?`${q} · ${Q(Oe)}`:q}function Q(B){const q=new Date(B);return Number.isNaN(q.getTime())?B:q.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"})}function fe(B){return mR(B.url,B.updated_at||B.created_at||"")}function he(B,q){return nS(q,fe(B))}function we(B){const q=ye(B);return["stl","html","svg","pdf"].includes(q)?he(B,q):Pi(fe(B))}function Pe(B){return tr(B.url)}function Je(B){const q=ye(B);return["html","svg"].includes(q)?Pe(B):q==="stl"&&B.source_url?tr(B.source_url):""}function k(B){return!!Je(B)}async function V(B){c.value=!c.value,c.value&&await se(B)}async function se(B){const q=Je(B);if(!(!q||l.value||u.value)){u.value=!0,d.value="";try{const Oe=await fetch(q);if(!Oe.ok)throw new Error(`HTTP ${Oe.status}`);l.value=await Oe.text()}catch(Oe){d.value=`Failed to load source: ${(Oe==null?void 0:Oe.message)||Oe}`}finally{u.value=!1}}}function Ie(B){return ye(B)==="stl"?we(B):Pi(fe(B))}function mt(B){const q=tr(B.download_url||B.url);return B.download_url||!q?q:`${q}${q.includes("?")?"&":"?"}download=1`}function _t(B){return["stl","html","svg","pdf"].includes(ye(B))}async function ve(B){try{await navigator.clipboard.writeText(Ie(B)),o.value=ce(B),setTimeout(()=>{o.value===ce(B)&&(o.value=null)},1500)}catch{}}function me(B){return o.value===ce(B)?"ph ph-check":"ph ph-copy"}function De(B){try{return new URL(B).hostname.replace(/^www\./,"")}catch{return B.split("/")[2]||B}}function it(B,q,Oe=60){const Te=Math.max(0,q-Oe),Se=Math.min(B.length,q+Oe);let $t=B.slice(Te,Se).replace(/\s+/g," ").trim();return Te>0&&($t="…"+$t),Seq.url);B.length&&navigator.clipboard.writeText(B.join(` +`)).catch(()=>{})}function Ft(){for(const B of Z.value.slice(0,8))window.open(B.url,"_blank","noopener,noreferrer")}function kt(B){var Te;if(B.is_dir)return"ph ph-folder";const q=((Te=B.name.split(".").pop())==null?void 0:Te.toLowerCase())||"";return{js:"ph ph-file-js",ts:"ph ph-file-ts",py:"ph ph-file-py",html:"ph ph-file-html",css:"ph ph-file-css",json:"ph ph-file-code",md:"ph ph-file-text",txt:"ph ph-file-text",jpg:"ph ph-file-image",jpeg:"ph ph-file-image",png:"ph ph-file-image",gif:"ph ph-file-image",svg:"ph ph-file-image",webp:"ph ph-file-image",mp4:"ph ph-file-video",webm:"ph ph-file-video",mov:"ph ph-file-video",mp3:"ph ph-file-audio",wav:"ph ph-file-audio",ogg:"ph ph-file-audio",pdf:"ph ph-file-pdf",zip:"ph ph-file-zip",tar:"ph ph-file-zip",gz:"ph ph-file-zip",rar:"ph ph-file-zip"}[q]||"ph ph-file"}function on(B){if(B.is_dir)return"Directory";const q=B.size;return q<1024?`${q} B`:q<1024*1024?`${(q/1024).toFixed(1)} KB`:`${(q/(1024*1024)).toFixed(1)} MB`}function Qt(B){return{paddingLeft:`${12+B.depth*16}px`}}function Mn(B){const q=a.currentId;return q?`/api/sessions/${q}/files/${encodeURIComponent(B)}?download=1`:"#"}function lr(B){var Te;const q=((Te=B.split(".").pop())==null?void 0:Te.toLowerCase())||"";return["jpg","jpeg","png","gif","svg","webp","html","txt","md","pdf"].includes(q)}return(B,q)=>{const Oe=tt("GnIconButton"),Te=tt("GnEmptyState");return v(),x("aside",{class:Ge(["artifacts-panel",{"is-open":t.open,"is-resizing":_.value}]),style:Da(Ne.value),"aria-label":"Session artifacts"},[g("div",{class:"artifacts-resize-handle",role:"separator","aria-orientation":"vertical",title:"Resize artifacts",onPointerdown:Mt},null,32),g("div",JN,[g("div",jN,[g("button",{class:"chip artifacts-tab","aria-pressed":p.value==="artifacts",onClick:q[0]||(q[0]=Se=>p.value="artifacts")},[q[9]||(q[9]=g("i",{class:"ph ph-files"},null,-1)),q[10]||(q[10]=g("span",null,"Artifacts",-1)),g("span",tO,X(D.value.length),1)],8,eO),g("button",{class:"chip artifacts-tab","aria-pressed":p.value==="links",onClick:q[1]||(q[1]=Se=>p.value="links")},[q[11]||(q[11]=g("i",{class:"ph ph-link"},null,-1)),q[12]||(q[12]=g("span",null,"Links",-1)),g("span",aO,X(Z.value.length),1)],8,nO),g("button",{class:"chip artifacts-tab","aria-pressed":p.value==="files",onClick:q[2]||(q[2]=Se=>p.value="files")},[q[13]||(q[13]=g("i",{class:"ph ph-folder"},null,-1)),q[14]||(q[14]=g("span",null,"Files",-1)),g("span",iO,X(W.value.length),1)],8,rO),g("button",{class:"chip artifacts-tab","aria-pressed":p.value==="backgrounds",onClick:q[3]||(q[3]=Se=>p.value="backgrounds")},[q[15]||(q[15]=g("i",{class:"ph ph-arrows-out"},null,-1)),q[16]||(q[16]=g("span",null,"Backgrounds",-1)),g("span",{class:Ge(["artifacts-tab-count",{"has-running":R.value>0}])},X(R.value),3)],8,sO)]),ne(Oe,{icon:"ph ph-x",label:"Close artifacts",class:"artifacts-close",onClick:q[4]||(q[4]=Se=>n("close"))})]),p.value==="artifacts"?(v(),x(Ue,{key:0},[$(a).viewedImages.length?(v(),x("div",oO,[g("div",lO,[q[17]||(q[17]=g("i",{class:"ph ph-eye"},null,-1)),q[18]||(q[18]=g("span",{class:"viewed-images-title"},"Viewed images",-1)),g("span",cO,X($(a).viewedImages.length),1)]),g("div",uO,[(v(!0),x(Ue,null,Dt($(a).viewedImages,(Se,$t)=>(v(),x("img",{key:$t,src:Se,class:"viewed-image-thumb",alt:`Image viewed by Navi ${$t+1}`,onClick:Yt=>i(Se)},null,8,dO))),128))])])):J("",!0),!D.value.length&&!$(a).viewedImages.length?(v(),x("div",_O,[ne(Te,{icon:"ph ph-files",title:"No published files"})])):(v(),x(Ue,{key:2},[g("div",pO,[(v(!0),x(Ue,null,Dt(D.value,Se=>(v(),x("button",{key:Se.id||Se.filename,class:Ge(["artifact-item",{"is-active":s.value===ce(Se)}]),onClick:$t=>Re(Se)},[g("span",gO,[g("i",{class:Ge(Fe(Se))},null,2)]),g("span",EO,[g("span",fO,X(Se.title||Se.filename),1),g("span",SO,X(G(Se)),1)])],10,mO))),128))]),P.value?(v(),x("div",bO,[g("div",TO,[g("div",hO,X(P.value.title||P.value.filename),1),g("div",vO,X(P.value.filename),1)]),g("div",RO,[g("a",{class:"btn-icon",href:we(P.value),target:"_blank",rel:"noopener noreferrer",title:"Open preview","aria-label":"Open preview"},[...q[19]||(q[19]=[g("i",{class:"ph ph-arrow-square-out"},null,-1)])],8,CO),g("a",{class:"btn-icon",href:Pe(P.value),target:"_blank",rel:"noopener noreferrer",title:"Open raw file","aria-label":"Open raw file"},[...q[20]||(q[20]=[g("i",{class:"ph ph-file"},null,-1)])],8,yO),g("a",{class:"btn-icon",href:mt(P.value),title:"Download","aria-label":"Download"},[...q[21]||(q[21]=[g("i",{class:"ph ph-download-simple"},null,-1)])],8,NO),k(P.value)?(v(),ze(Oe,{key:0,icon:c.value?"ph ph-eye":"ph ph-code",label:c.value?"Show preview":"Show source",onClick:q[5]||(q[5]=Se=>V(P.value))},null,8,["icon","label"])):J("",!0),ne(Oe,{icon:me(P.value),label:"Copy file link",onClick:q[6]||(q[6]=Se=>ve(P.value))},null,8,["icon"])]),g("div",OO,[c.value?(v(),x("div",AO,[u.value?(v(),x("div",IO,[...q[22]||(q[22]=[g("span",{class:"spinner"},null,-1),g("span",null,"Loading source...",-1)])])):d.value?(v(),x("pre",DO,X(d.value),1)):(v(),x("pre",wO,[g("code",{class:Ge(["hljs",`language-${ae.value}`]),innerHTML:re.value},null,10,xO)]))])):_t(P.value)?(v(),x("iframe",{key:1,src:we(P.value),class:"artifact-frame",sandbox:"allow-scripts allow-same-origin"},null,8,LO)):ye(P.value)==="image"?(v(),x("img",{key:2,src:fe(P.value),alt:P.value.title||P.value.filename,class:"artifact-image"},null,8,MO)):ye(P.value)==="video"?(v(),x("video",{key:3,src:fe(P.value),class:"artifact-video",controls:"",playsinline:""},null,8,kO)):(v(),x("div",PO,[...q[23]||(q[23]=[g("i",{class:"ph ph-file"},null,-1),g("span",null,"Preview unavailable",-1)])]))])])):J("",!0)],64))],64)):J("",!0),p.value==="links"?(v(),x(Ue,{key:1},[Z.value.length?(v(),x(Ue,{key:1},[g("div",FO,[(v(!0),x(Ue,null,Dt(Z.value,Se=>(v(),x("a",{key:Se.url,class:"artifact-item link-item",href:Se.url,target:"_blank",rel:"noopener noreferrer"},[q[24]||(q[24]=g("span",{class:"artifact-icon"},[g("i",{class:"ph ph-link"})],-1)),g("span",GO,[g("span",YO,X(Se.text||Se.url),1),g("span",$O,X(Se.domain)+" · "+X(Se.snippet),1)])],8,BO))),128))]),g("div",qO,[g("div",HO,[g("div",VO,X(Z.value.length)+" link"+X(Z.value.length===1?"":"s")+" in session",1)]),g("div",zO,[ne(Oe,{icon:"ph ph-copy",label:"Copy all links",onClick:ct}),ne(Oe,{icon:"ph ph-arrow-square-out",label:"Open all links",onClick:Ft})])])],64)):(v(),x("div",UO,[ne(Te,{icon:"ph ph-link",title:"No links found yet"})]))],64)):J("",!0),p.value==="files"?(v(),x("div",{key:2,class:"files-tab-wrap",onTouchstart:Ke,onTouchmove:Et,onTouchend:ut},[g("div",{class:Ge(["ptr-indicator files-ptr",{"ptr-active":lt.value&&!Ce.value}]),style:Da(He.value)},[g("span",{class:Ge(["ptr-spinner",{"ptr-spinning":We.value}])},null,2),g("span",WO,X(ke.value),1)],6),g("div",KO,[ne(Oe,{class:"files-refresh-btn",icon:"ph ph-arrows-clockwise",label:"Refresh files",disabled:Ce.value,onClick:ot},null,8,["disabled"])]),W.value.length?(v(),x("div",{key:1,ref_key:"filesListRef",ref:Ae,class:Ge(["artifacts-list files-list",{"ptr-pulled":lt.value}])},[(v(!0),x(Ue,null,Dt(de.value,Se=>(v(),x("div",{key:Se.path,class:Ge(["artifact-item file-item",{"is-dir":Se.is_dir}]),style:Da(Qt(Se))},[g("span",XO,[g("i",{class:Ge(kt(Se))},null,2)]),g("span",ZO,[g("span",JO,X(Se.name),1),g("span",jO,X(on(Se)),1)]),Se.is_dir?J("",!0):(v(),x("div",eA,[g("a",{class:"btn-icon file-row-action",href:Mn(Se.path),title:"Download","aria-label":"Download",target:"_blank",rel:"noopener noreferrer"},[...q[25]||(q[25]=[g("i",{class:"ph ph-download-simple"},null,-1)])],8,tA),lr(Se.path)?(v(),x("a",{key:0,class:"btn-icon file-row-action",href:Mn(Se.path),title:"Open inline","aria-label":"Open inline",target:"_blank",rel:"noopener noreferrer"},[...q[26]||(q[26]=[g("i",{class:"ph ph-eye"},null,-1)])],8,nA)):J("",!0)]))],6))),128))],2)):(v(),x("div",QO,[ne(Te,{icon:"ph ph-folder",title:"No files in session directory"})]))],32)):J("",!0),p.value==="backgrounds"?(v(),x(Ue,{key:3},[I.value.length?(v(),x(Ue,{key:1},[g("div",rA,[(v(!0),x(Ue,null,Dt(I.value,Se=>(v(),x("button",{key:`${Se.kind}:${Se.key}`,class:Ge(["artifact-item terminal-item",{"is-active":h(Se),"is-closed":!Se.running}]),onClick:$t=>U(Se)},[g("span",sA,[g("i",{class:Ge(N(Se))},null,2)]),g("span",oA,[g("span",lA,X(C(Se)),1),g("span",cA,X(f(Se)),1)]),g("span",{class:Ge(["badge",A(Se)])},X(w(Se)),3)],10,iA))),128))]),y.value?(v(),x("div",uA,[g("div",dA,[g("div",_A,[g("div",pA,X(y.value.taskId),1),g("div",mA,X(y.value.argsSummary||y.value.tool),1)]),ne(Oe,{class:"terminal-detail-close",icon:"ph ph-x",label:"Close details",onClick:q[7]||(q[7]=Se=>b.value=null)})]),g("div",gA,[g("div",EA,[q[27]||(q[27]=g("span",{class:"terminal-detail-label"},"Tool",-1)),g("span",fA,X(y.value.tool),1)]),g("div",SA,[q[28]||(q[28]=g("span",{class:"terminal-detail-label"},"Status",-1)),g("span",{class:Ge(["terminal-detail-value",_e(y.value)])},X(oe(y.value)),3)]),g("div",bA,[q[29]||(q[29]=g("span",{class:"terminal-detail-label"},"Started",-1)),g("span",TA,X(pe(y.value.startedAt)),1)]),y.value.finishedAt?(v(),x("div",hA,[q[30]||(q[30]=g("span",{class:"terminal-detail-label"},"Finished",-1)),g("span",vA,X(pe(y.value.finishedAt)),1)])):J("",!0),y.value.subagentTokens!=null?(v(),x("div",RA,[q[31]||(q[31]=g("span",{class:"terminal-detail-label"},"Sub-agent tokens",-1)),g("span",CA,X(y.value.subagentTokens),1)])):J("",!0)]),y.value.preview||y.value.status==="running"?(v(),x("div",yA,[g("div",NA,X(y.value.status==="running"?"Latest progress":"Result"),1),g("pre",OA,X(y.value.preview||"No output yet — it arrives as a note next turn."),1)])):J("",!0)])):J("",!0),L.value?(v(),x("div",AA,[g("div",IA,[g("div",null,[g("div",DA,X(L.value.name),1),g("div",wA,X(L.value.description||L.value.command||"Terminal"),1)]),ne(Oe,{class:"terminal-detail-close",icon:"ph ph-x",label:"Close details",onClick:q[8]||(q[8]=Se=>b.value=null)})]),g("div",xA,[g("div",LA,[q[32]||(q[32]=g("span",{class:"terminal-detail-label"},"Status",-1)),g("span",{class:Ge(["terminal-detail-value",L.value.status==="busy"?"status-busy":L.value.closed?"status-closed":"status-idle"])},X(L.value.closed?"Closed":L.value.status==="busy"?"Busy":"Idle"),3)]),g("div",MA,[q[33]||(q[33]=g("span",{class:"terminal-detail-label"},"PID",-1)),g("span",kA,X(L.value.pid||"N/A"),1)]),g("div",PA,[q[34]||(q[34]=g("span",{class:"terminal-detail-label"},"Command",-1)),g("span",UA,X(L.value.command||"N/A"),1)]),g("div",FA,[q[35]||(q[35]=g("span",{class:"terminal-detail-label"},"CWD",-1)),g("span",BA,X(L.value.cwd||"N/A"),1)]),L.value.uptime_seconds!=null?(v(),x("div",GA,[q[36]||(q[36]=g("span",{class:"terminal-detail-label"},"Uptime",-1)),g("span",YA,X(E(L.value.uptime_seconds)),1)])):J("",!0),L.value.background!=null?(v(),x("div",$A,[q[37]||(q[37]=g("span",{class:"terminal-detail-label"},"Background",-1)),g("span",qA,X(L.value.background?"Yes":"No"),1)])):J("",!0),L.value.closeReason?(v(),x("div",HA,[q[38]||(q[38]=g("span",{class:"terminal-detail-label"},"Reason",-1)),g("span",VA,X(L.value.closeReason),1)])):J("",!0)]),L.value.output?(v(),x("div",zA,[q[39]||(q[39]=g("div",{class:"terminal-output-header"},"Live output",-1)),g("pre",WA,X(L.value.output),1)])):J("",!0)])):J("",!0)],64)):(v(),x("div",aA,[ne(Te,{icon:"ph ph-arrows-out",title:"No background tasks or terminals"})]))],64)):J("",!0)],6)}}},JA=ht(ZA,[["__scopeId","data-v-07ae46cf"]]),jA={class:"login-overlay"},eI={class:"login-card"},tI={__name:"LoginScreen",setup(t){function e(){window.location.href="/auth/login"}return(n,a)=>{const r=tt("GnButton");return v(),x("div",jA,[g("div",eI,[a[1]||(a[1]=g("img",{src:ju,alt:"Navi",class:"login-logo"},null,-1)),a[2]||(a[2]=g("h1",{class:"login-title"},"Welcome to Navi",-1)),a[3]||(a[3]=g("p",{class:"login-subtitle"},"Your personal AI assistant",-1)),ne(r,{variant:"primary",class:"login-btn",icon:"ph ph-sign-in",onClick:e},{default:Be(()=>[...a[0]||(a[0]=[$e(" Login with GNEXUS ",-1)])]),_:1})])])}}},sS=ht(tI,[["__scopeId","data-v-07af6970"]]),nI=Object.freeze(Object.defineProperty({__proto__:null,default:sS},Symbol.toStringTag,{value:"Module"}));function aI(){const t=Y(navigator.onLine);function e(){t.value=!0}function n(){t.value=!1}return Sn(()=>{window.addEventListener("online",e),window.addEventListener("offline",n)}),fa(()=>{window.removeEventListener("online",e),window.removeEventListener("offline",n)}),{online:t}}const rI={key:0,class:"offline-banner"},iI={__name:"OfflineBanner",setup(t){const{online:e}=aI();return(n,a)=>(v(),ze(hr,{name:"offline-slide"},{default:Be(()=>[$(e)?J("",!0):(v(),x("div",rI,[...a[0]||(a[0]=[g("i",{class:"ph ph-wifi-slash"},null,-1),g("span",null,"Нет сети — интерфейс открыт из кэша, сообщения не отправляются",-1)])]))]),_:1}))}},oS=ht(iI,[["__scopeId","data-v-2f8cc0a8"]]),sI=Object.freeze(Object.defineProperty({__proto__:null,default:oS},Symbol.toStringTag,{value:"Module"})),oI={class:"welcome-screen"},lI={key:0,class:"welcome-profiles"},cI=["onClick"],uI={class:"profile-name"},dI={class:"profile-desc"},_I={__name:"WelcomeScreen",emits:["toggle-sidebar"],setup(t,{emit:e}){const n=e,a=li(),r=Un(),i=sn(),s=Y(!1),o=Y(null),c={secretary:"ph-briefcase",server_admin:"ph-terminal",developer:"ph-code",tool_developer:"ph-wrench",discuss:"ph-chats"};function l(d){return`ph ${c[d.id]??"ph-robot"}`}async function u(d){if(!s.value){s.value=!0,o.value=d;try{a.selectedProfileId=d;const _=await r.createSession(d);await i.loadSession(_.session_id)}catch(_){console.error("[welcome] start failed",_)}finally{s.value=!1,o.value=null}}}return(d,_)=>{const m=tt("GnIconButton"),p=tt("GnAvatar");return v(),x("div",oI,[ne(m,{icon:"ph ph-sidebar",label:"Menu",class:"welcome-sidebar-btn",onClick:_[0]||(_[0]=E=>n("toggle-sidebar"))}),_[1]||(_[1]=g("div",{class:"welcome-logo"},[g("img",{src:ju,alt:"Navi"}),g("h1",null,"Navi"),g("p",null,"Your personal AI assistant")],-1)),$(a).profiles.length?(v(),x("div",lI,[(v(!0),x(Ue,null,Dt($(a).profiles,E=>(v(),x("div",{key:E.id,class:Ge(["welcome-profile-card",{"is-creating":s.value&&o.value===E.id}]),onClick:b=>u(E.id)},[ne(p,{size:"md",variant:"secondary",icon:l(E)},null,8,["icon"]),g("div",uI,X(E.name),1),g("div",dI,X(E.description),1)],10,cI))),128))])):J("",!0)])}}},lS=ht(_I,[["__scopeId","data-v-0ba11e7d"]]),pI=Object.freeze(Object.defineProperty({__proto__:null,default:lS},Symbol.toStringTag,{value:"Module"}));var cS={},mI=new Set(["primary","secondary","accent","success","warning","danger","error","info"]);function ge(...t){return t.flatMap(e=>e?Array.isArray(e)?e:typeof e=="object"?Object.entries(e).filter(([,n])=>n).map(([n])=>n):[e]:[]).filter(Boolean).join(" ")}function Sa(t,e="primary"){return mI.has(t)?t:e}function nt(t,e=""){if(!t)return null;const n=t.includes("ph ")||t.startsWith("ph-");n||typeof process<"u"&&cS&&console.warn(`[gnexus-ui-kit] Icon "${t}" is missing the required "ph-" prefix. Use "ph-${t}" instead.`);const a=n?t:`ph-${t}`;return T("i",{class:ge("ph",a,e),"aria-hidden":"true"})}function Nr(t){const e=t.target;return e.type==="checkbox"?e.checked:e.value}var gI=["a[href]","button:not([disabled])","input:not([disabled])","select:not([disabled])","textarea:not([disabled])","[tabindex]:not([tabindex='-1'])"].join(",");function uS(t,e){if(t.key!=="Tab"||!e)return;const n=[...e.querySelectorAll(gI)].filter(i=>!i.hasAttribute("disabled")&&i.offsetParent!==null);if(!n.length){t.preventDefault(),e.focus();return}const a=n[0],r=n[n.length-1];t.shiftKey&&document.activeElement===a?(t.preventDefault(),r.focus()):!t.shiftKey&&document.activeElement===r&&(t.preventDefault(),a.focus())}var EI=Me({name:"GnAccordion",props:{items:{type:Array,required:!0},modelValue:{type:[String,Array],default:""},multiple:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(t,{emit:e,slots:n}){const a=Y(t.multiple?[]:""),r=()=>t.modelValue||a.value,i=o=>t.multiple?r().includes(o):r()===o,s=o=>{let c;if(t.multiple){const l=[...r()];c=l.includes(o)?l.filter(u=>u!==o):[...l,o]}else c=i(o)?"":o;a.value=c,e("update:modelValue",c)};return()=>T("div",{class:"accordion"},t.items.map(o=>{var c;const l=i(o.id);return T("section",{class:"accordion-item",open:l?"":void 0},[T("button",{class:"accordion-summary",type:"button","aria-expanded":l?"true":"false",onClick:()=>s(o.id)},[T("span",{class:"accordion-summary-content"},[nt(o.icon),o.label]),T("i",{class:ge("ph ph-caret-down accordion-icon",{"is-open":l}),"aria-hidden":"true"})]),l&&T("div",{class:"accordion-panel"},((c=n[o.id])==null?void 0:c.call(n,{item:o,open:l}))||o.content)])}))}}),fI=Me({name:"GnActionCard",props:{kicker:{type:String,default:""},title:{type:String,required:!0},text:{type:String,default:""}},setup(t,{slots:e}){return()=>{var n,a,r;return T("article",{class:"card action-card"},[T("div",{class:"card-content"},[(t.kicker||e.kicker)&&T("span",{class:"action-card-kicker"},((n=e.kicker)==null?void 0:n.call(e))||t.kicker),T("h3",{class:"action-card-title"},((a=e.title)==null?void 0:a.call(e))||t.title),(t.text||e.default)&&T("p",{class:"action-card-text"},((r=e.default)==null?void 0:r.call(e))||t.text),e.actions&&T("div",{class:"action-card-actions"},e.actions())])])}}}),SI=Me({name:"GnActionList",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]}},setup(t,{attrs:e,slots:n}){return()=>T("ul",{...e,class:ge("list list-actions",e.class)},t.items.map(a=>{var r,i;return T("li",{class:ge("list-item",a.muted&&"list-item-muted")},[T("div",{class:"list-content"},[T("div",{class:"list-title"},((r=n.title)==null?void 0:r.call(n,{item:a}))||a.title||a.label||""),(a.subtitle||n.subtitle)&&T("div",{class:"list-subtitle"},((i=n.subtitle)==null?void 0:i.call(n,{item:a}))||a.subtitle)]),n.controls&&T("div",{class:"list-controls"},n.controls({item:a}))])}))}}),bI=Me({name:"GnActivityLog",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]}},setup(t,{attrs:e,slots:n}){return()=>T("div",{...e,class:ge("activity-log",e.class)},t.items.map(a=>{var r;return T("div",{class:"activity-log-row"},[T("time",{class:"activity-log-time"},a.time),T("span",{class:"activity-log-title"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.title),n.actions&&T("span",{},n.actions({item:a}))])}))}}),td=Me({name:"GnAlert",inheritAttrs:!1,props:{variant:{type:String,default:"primary"},role:{type:String,default:"status"}},setup(t,{attrs:e,slots:n}){return()=>{var a;const r=Sa(t.variant);return T("div",{...e,role:t.role,class:ge("alert",`alert-${r}`,e.class)},(a=n.default)==null?void 0:a.call(n))}}}),os=Me({name:"GnAvatar",inheritAttrs:!1,props:{src:{type:String,default:""},alt:{type:String,default:""},initials:{type:String,default:""},icon:{type:String,default:""},size:{type:String,default:"md"},variant:{type:String,default:"primary"},outline:{type:Boolean,default:!1},status:{type:String,default:""}},setup(t,{attrs:e}){return()=>{const n=Sa(t.variant);return T("span",{...e,class:ge("avatar",`avatar-${n}`,{"avatar-sm":t.size==="sm","avatar-lg":t.size==="lg","avatar-outline":t.outline,"is-online":t.status==="online","is-busy":t.status==="busy","is-offline":t.status==="offline"},e.class)},[t.src?T("img",{src:t.src,alt:t.alt}):nt(t.icon)||t.initials,t.status&&T("span",{class:"avatar-status","aria-hidden":"true"})])}}}),TI=Me({name:"GnAvatarStack",props:{items:{type:Array,default:()=>[]},count:{type:[Number,String],default:""}},setup(t,{slots:e}){return()=>{var n;return T("span",{class:"avatar-stack"},[t.items.map(a=>T(os,{...a,size:a.size||"sm"})),(n=e.default)==null?void 0:n.call(e),t.count&&T("span",{class:"avatar-stack-count"},`+${t.count}`)])}}}),dS=Me({name:"GnBadge",inheritAttrs:!1,props:{variant:{type:String,default:"primary"},outline:{type:Boolean,default:!1}},setup(t,{attrs:e,slots:n}){return()=>{var a;const r=Sa(t.variant);return T("span",{...e,class:ge("badge",t.outline&&r==="primary"?"badge-primary-outline":`badge-${r}`,e.class)},(a=n.default)==null?void 0:a.call(n))}}}),An=Me({name:"GnButton",inheritAttrs:!1,props:{variant:{type:String,default:"primary"},size:{type:String,default:"md"},icon:{type:String,default:""},loading:{type:Boolean,default:!1},disabled:{type:Boolean,default:!1},type:{type:String,default:"button"}},setup(t,{attrs:e,slots:n}){return()=>{var a;const r=!!(t.icon||t.loading),i=Sa(t.variant);return T("button",{...e,type:t.type,disabled:t.disabled||t.loading,class:ge("btn",`btn-${i}`,{"btn-small":t.size==="sm","btn-large":t.size==="lg","with-icon":r,"loading-state":t.loading},e.class)},[t.loading?nt("ph-bold ph-spinner"):nt(t.icon),(a=n.default)==null?void 0:a.call(n)])}}}),hI=Me({name:"GnCard",inheritAttrs:!1,props:{title:{type:String,default:""},variant:{type:String,default:""}},setup(t,{attrs:e,slots:n}){return()=>{var a,r;return T("article",{...e,class:ge("card",t.variant&&`card-${t.variant}`,e.class)},[(t.title||n.title)&&T("header",{class:"card-title"},((a=n.title)==null?void 0:a.call(n))||t.title),T("div",{class:"card-content"},(r=n.default)==null?void 0:r.call(n)),n.footer&&T("footer",{class:"card-footer"},n.footer())])}}}),_S=Me({name:"GnCheckbox",inheritAttrs:!1,props:{modelValue:{type:Boolean,default:!1},label:{type:String,default:""},disabled:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n,slots:a}){return()=>{var r;return T("label",{class:ge("checkbox",e.class)},[T("input",{...e,type:"checkbox",checked:t.modelValue,disabled:t.disabled,onChange:i=>n("update:modelValue",i.target.checked)}),T("span",{class:"checkbox-control","aria-hidden":"true"}),T("span",{class:"checkbox-label"},((r=a.default)==null?void 0:r.call(a))||t.label)])}}}),vI=Me({name:"GnChip",inheritAttrs:!1,props:{variant:{type:String,default:""},icon:{type:String,default:""},selected:{type:Boolean,default:!1},disabled:{type:Boolean,default:!1},removable:{type:Boolean,default:!1},clickable:{type:Boolean,default:!1}},emits:["remove"],setup(t,{attrs:e,emit:n,slots:a}){return()=>{var r,i,s,o;const c=t.clickable?"button":"span",l=t.variant?Sa(t.variant):"",u=(s=(i=(r=a.default)==null?void 0:r.call(a))==null?void 0:i[0])==null?void 0:s.children;return T(c,{...e,type:c==="button"?"button":void 0,disabled:c==="button"?t.disabled:void 0,"aria-pressed":c==="button"?String(t.selected):void 0,class:ge("chip",l&&`chip-${l}`,{"chip-selected":t.selected,"chip-disabled":t.disabled},e.class)},[nt(t.icon),(o=a.default)==null?void 0:o.call(a),t.removable&&T("button",{class:"chip-remove",type:"button","aria-label":u?`Remove ${u}`:"Remove",onClick:d=>{d.stopPropagation(),n("remove")}},[nt("ph-x")])])}}}),RI=Me({name:"GnChipGroup",inheritAttrs:!1,setup(t,{attrs:e,slots:n}){return()=>{var a;return T("div",{...e,class:ge("chip-group",e.class)},(a=n.default)==null?void 0:a.call(n))}}}),CI=0,yI=Me({name:"GnCombobox",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},icon:{type:String,default:""},options:{type:Array,default:()=>[]},placeholder:{type:String,default:"Search"},notFoundText:{type:String,default:"Nothing found"},state:{type:String,default:""},help:{type:String,default:""}},emits:["update:modelValue","select"],setup(t,{attrs:e,emit:n}){const a=`gn-combobox-${++CI}`,r=`${a}-listbox`,i=Y(!1),s=Y(-1),o=Y(null),c=ue(()=>t.options.map(p=>typeof p=="object"?p:{value:p,label:p})),l=ue(()=>{var p;return String((p=t.modelValue)!=null?p:"").toLowerCase()}),u=ue(()=>c.value.filter(p=>String(p.label).toLowerCase().includes(l.value))),d=p=>{p&&(n("update:modelValue",p.label),n("select",p),i.value=!1,s.value=-1)},_=p=>{u.value.length&&(i.value=!0,s.value=(s.value+p+u.value.length)%u.value.length,Ht(()=>{var E,b,I;const R=(b=(E=o.value)==null?void 0:E.closest(".form-group"))==null?void 0:b.querySelector(".advanced-select");(I=R==null?void 0:R.querySelector(".option.focus"))==null||I.scrollIntoView({block:"nearest"})}))},m=p=>{p.key==="ArrowDown"?(p.preventDefault(),_(1)):p.key==="ArrowUp"?(p.preventDefault(),_(-1)):p.key==="Enter"?(p.preventDefault(),d(u.value[s.value])):p.key==="Escape"&&(i.value=!1,s.value=-1)};return()=>T("div",{class:"form-group"},[T("label",{class:ge("label",t.state)},[t.label,nt(t.icon),T("input",{...e,ref:o,id:a,type:"text",value:t.modelValue,placeholder:t.placeholder,autocomplete:"off",role:"combobox","aria-autocomplete":"list","aria-expanded":i.value?"true":"false","aria-controls":r,"aria-activedescendant":s.value>=0?`${a}-option-${s.value}`:void 0,class:ge("input",e.class),onFocus:()=>{i.value=!0},onBlur:()=>{setTimeout(()=>{i.value=!1},120)},onInput:p=>{s.value=-1,i.value=!0,n("update:modelValue",Nr(p))},onKeydown:m})]),T("div",{class:"advanced-select-container"},[T("div",{class:ge("advanced-select",{"a-show":i.value})},[T("div",{class:"popup-options-container"},[T("div",{class:ge("not-found",{show:!u.value.length})},t.notFoundText),T("div",{id:r,class:ge("options",{show:u.value.length}),role:"listbox"},u.value.map((p,E)=>T("div",{id:`${a}-option-${E}`,class:ge("option",{focus:E===s.value}),role:"option","aria-selected":p.label===t.modelValue?"true":"false","data-value":p.value,"data-display-value":p.label,onMousedown:b=>{b.preventDefault(),d(p)}},p.label)))])])]),t.help&&T("div",{class:ge("input-info",t.state==="error"&&"error")},t.help)])}});function pS({duration:t=300}={}){const e=Y(!1),n=Y(!1);let a=null;return{visible:e,closing:n,show:()=>{window.clearTimeout(a),n.value=!0,e.value=!0,Ht(()=>{requestAnimationFrame(()=>{n.value=!1})})},hide:()=>{n.value=!0,a=window.setTimeout(()=>{e.value=!1,n.value=!1},t)},cancel:()=>{window.clearTimeout(a)}}}var NI=0,nd=Me({name:"GnModal",props:{open:{type:Boolean,default:!1},title:{type:String,default:""},closeOnBackdrop:{type:Boolean,default:!0}},emits:["update:open","close"],setup(t,{emit:e,slots:n}){const a=`gn-modal-title-${++NI}`,r=Y(null),{visible:i,closing:s,show:o,hide:c,cancel:l}=pS();let u=null;const d=()=>{e("update:open",!1),e("close")},_=p=>{p.key==="Escape"?(p.preventDefault(),d()):uS(p,r.value)},m=()=>{Ht(()=>{var p;(p=r.value)==null||p.focus()})};return st(()=>t.open,p=>{var E;p?(o(),u=document.activeElement,document.addEventListener("keydown",_),m()):(c(),document.removeEventListener("keydown",_),(E=u==null?void 0:u.focus)==null||E.call(u),u=null)},{flush:"post",immediate:!0}),Yn(()=>{document.removeEventListener("keydown",_),l()}),()=>{var p,E,b;return i.value?T(Ji,{to:"body"},[T("div",{class:ge("modal",s.value?"a-hide":"a-show"),"aria-hidden":"false"},[T("div",{class:"modal-backdrop",onClick:()=>t.closeOnBackdrop&&d()}),T("div",{ref:r,class:"modal-dialog",role:"dialog","aria-modal":"true","aria-labelledby":a,tabindex:"-1"},[T("header",{class:"modal-header"},[T("h4",{class:"modal-title",id:a},((p=n.title)==null?void 0:p.call(n))||t.title),T("button",{class:"btn-icon modal-close",type:"button","aria-label":"Close",onClick:d},[nt("ph-x")])]),T("div",{class:"modal-panel"},[T("div",{class:"modal-body"},(E=n.default)==null?void 0:E.call(n)),(n.footer||n.actions)&&T("footer",{class:"modal-footer"},[(b=n.footer)==null?void 0:b.call(n),n.actions&&T("div",{class:"actions"},n.actions({close:d}))])])])])]):null}}}),OI=Me({name:"GnConfirmDialog",props:{open:{type:Boolean,default:!1},title:{type:String,default:"Requires confirmation"},message:{type:String,default:""},confirmText:{type:String,default:"YES"},cancelText:{type:String,default:"NO"},confirmVariant:{type:String,default:"warning"}},emits:["update:open","confirm","cancel"],setup(t,{emit:e,slots:n}){const a=()=>e("update:open",!1),r=()=>{e("cancel"),a()},i=()=>{e("confirm"),a()};return()=>T(nd,{open:t.open,title:t.title,"onUpdate:open":s=>e("update:open",s)},{default:()=>{var s;return((s=n.default)==null?void 0:s.call(n))||T("p",{},t.message)},actions:()=>[T(An,{variant:"primary",onClick:r},()=>t.cancelText),T(An,{variant:t.confirmVariant,onClick:i},()=>t.confirmText)]})}}),AI=Me({name:"GnCopyButton",props:{text:{type:String,required:!0},icon:{type:String,default:"ph-copy"},successIcon:{type:String,default:"ph-check"},duration:{type:Number,default:3e3},label:{type:String,default:"Copy"},size:{type:String,default:null}},emits:["copy"],setup(t,{emit:e}){const n=Y(!1);let a=null;const r=async()=>{try{await navigator.clipboard.writeText(t.text)}catch{const s=document.createElement("textarea");s.value=t.text,s.style.position="fixed",s.style.opacity="0",document.body.appendChild(s),s.select(),document.execCommand("copy"),document.body.removeChild(s)}n.value=!0,window.clearTimeout(a),a=window.setTimeout(()=>{n.value=!1},t.duration),e("copy",t.text)};return()=>T("button",{class:ge("btn-icon",{"btn-icon-sm":t.size==="sm"}),type:"button","aria-label":t.label,onClick:r},[nt(n.value?t.successIcon:t.icon)])}}),II=Me({name:"GnDescriptionList",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]},compact:{type:Boolean,default:!1}},setup(t,{attrs:e,slots:n}){return()=>T("dl",{...e,class:ge("description-list",{"description-list-compact":t.compact},e.class)},t.items.map(a=>{var r;return T("div",{class:"description-list-row"},[T("dt",{class:"description-list-term"},a.term||a.label),T("dd",{class:ge("description-list-value",a.muted&&"description-list-value-muted")},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.value)])}))}}),DI=Me({name:"GnDefinitionList",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]}},setup(t,{attrs:e,slots:n}){return()=>T("dl",{...e,class:ge("list list-definition",e.class)},t.items.map(a=>{var r;return T("div",{class:"list-row"},[T("dt",{class:"list-term"},a.term||a.label),T("dd",{class:"list-desc"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.description||a.value)])}))}}),wI=Me({name:"GnDropdown",props:{label:{type:String,default:"Actions"},icon:{type:String,default:"ph-dots-three-outline"},variant:{type:String,default:"secondary"},items:{type:Array,default:()=>[]}},emits:["select"],setup(t,{emit:e,slots:n}){const a=Y(!1),r=Y(null),i=()=>{a.value=!1,document.removeEventListener("click",s),document.removeEventListener("keydown",o)},s=u=>{r.value&&!r.value.contains(u.target)&&i()},o=u=>{u.key==="Escape"&&(u.preventDefault(),i())},c=()=>{a.value=!a.value,a.value?(setTimeout(()=>document.addEventListener("click",s),0),document.addEventListener("keydown",o)):i()},l=u=>{var d;u.disabled||((d=u.onSelect)==null||d.call(u,u),e("select",u),i())};return Yn(i),()=>{var u,d;return T("div",{ref:r,class:ge("dropdown",{"is-open":a.value})},[((u=n.trigger)==null?void 0:u.call(n,{open:a.value,toggle:c}))||T(An,{variant:t.variant,icon:t.icon,"aria-expanded":a.value?"true":"false",onClick:c},()=>t.label),T("div",{class:"dropdown-menu",role:"menu"},((d=n.default)==null?void 0:d.call(n,{close:i}))||t.items.map(_=>T("button",{class:ge("dropdown-item",_.danger&&"dropdown-item-danger"),type:"button",role:"menuitem",disabled:_.disabled,onClick:()=>l(_)},[nt(_.icon),_.label])))])}}}),xI=0,LI=Me({name:"GnDrawer",props:{open:{type:Boolean,default:!1},title:{type:String,default:""},position:{type:String,default:"right"}},emits:["update:open","close"],setup(t,{emit:e,slots:n}){const a=`gn-drawer-title-${++xI}`,r=Y(null),{visible:i,closing:s,show:o,hide:c,cancel:l}=pS();let u=null;const d=()=>{e("update:open",!1),e("close")},_=m=>{m.key==="Escape"?(m.preventDefault(),d()):uS(m,r.value)};return st(()=>t.open,m=>{var p;m?(o(),u=document.activeElement,document.addEventListener("keydown",_),Ht(()=>{var E;return(E=r.value)==null?void 0:E.focus()})):(c(),document.removeEventListener("keydown",_),(p=u==null?void 0:u.focus)==null||p.call(u),u=null)},{flush:"post"}),Yn(()=>{document.removeEventListener("keydown",_),l()}),()=>{var m,p;return i.value?T(Ji,{to:"body"},[T("div",{class:ge("drawer",s.value?"a-hide":"a-show",{"drawer-left":t.position==="left"}),"aria-hidden":"false"},[T("div",{class:"drawer-backdrop",onClick:d}),T("aside",{ref:r,class:"drawer-panel",role:"dialog","aria-modal":"true","aria-labelledby":a,tabindex:"-1"},[T("header",{class:"drawer-header"},[T("h4",{class:"drawer-title",id:a},((m=n.title)==null?void 0:m.call(n))||t.title),T("button",{class:"btn-icon drawer-close",type:"button","aria-label":"Close",onClick:d},[nt("ph-x")])]),T("div",{class:"drawer-body"},(p=n.default)==null?void 0:p.call(n)),n.footer&&T("footer",{class:"drawer-footer"},n.footer({close:d}))])])]):null}}}),MI=Me({name:"GnEmptyState",inheritAttrs:!1,props:{title:{type:String,required:!0},text:{type:String,default:""},icon:{type:String,default:"ph-package"},variant:{type:String,default:""}},setup(t,{attrs:e,slots:n}){return()=>{var a,r;return T("div",{...e,class:ge("empty-state",t.variant&&`empty-state-${t.variant}`,e.class)},[T("div",{class:"empty-state-icon"},[nt(t.icon)]),T("h3",{class:"empty-state-title"},((a=n.title)==null?void 0:a.call(n))||t.title),(t.text||n.default)&&T("p",{class:"empty-state-text"},((r=n.default)==null?void 0:r.call(n))||t.text),n.actions&&T("div",{class:"empty-state-actions"},n.actions())])}}});function Qg(t){const e=t.name.split(".").pop();return e?e.slice(0,6).toUpperCase():"FILE"}function kI(t){if(!t.size)return"0 B";const e=["B","KB","MB","GB"],n=Math.min(Math.floor(Math.log(t.size)/Math.log(1024)),e.length-1),a=t.size/Math.pow(1024,n);return`${a.toFixed(a>=10||n===0?0:1)} ${e[n]}`}var PI=Me({name:"GnFileUpload",props:{modelValue:{type:Array,default:()=>[]},title:{type:String,default:"Upload files"},description:{type:String,default:"Attach documents, archives or images."},primary:{type:String,default:"Choose files"},secondary:{type:String,default:"Images get thumbnails, other files show their type"},badge:{type:String,default:""},multiple:{type:Boolean,default:!0},accept:{type:String,default:""}},emits:["update:modelValue","change"],setup(t,{emit:e,slots:n}){const a=Y(new Map),r=l=>{const u=a.value.get(l);u&&(URL.revokeObjectURL(u),a.value.delete(l))},i=()=>{a.value.forEach(l=>URL.revokeObjectURL(l)),a.value.clear()},s=l=>{const u=Array.from(l||[]);e("update:modelValue",u),e("change",u)},o=l=>{r(t.modelValue[l]);const u=t.modelValue.filter((d,_)=>_!==l);e("update:modelValue",u),e("change",u)},c=l=>{var u;return(u=l.type)!=null&&u.startsWith("image/")?(a.value.has(l)||a.value.set(l,URL.createObjectURL(l)),a.value.get(l)):""};return st(()=>t.modelValue,l=>{const u=new Set(l);[...a.value.keys()].forEach(d=>{u.has(d)||r(d)})}),Yn(i),()=>{var l,u;return T("div",{class:"file-upload-panel"},[T("div",{class:"file-upload-form"},[T("div",{class:"file-upload-header"},[T("div",{class:"file-upload-heading"},[T("h3",{class:"file-upload-title"},((l=n.title)==null?void 0:l.call(n))||t.title),T("p",{class:"file-upload-description"},((u=n.description)==null?void 0:u.call(n))||t.description)]),t.badge&&T(dS,{variant:"info"},()=>t.badge)]),T("label",{class:"file-upload-dropzone"},[T("span",{class:"file-upload-icon","aria-hidden":"true"},[nt("ph-cloud-arrow-up")]),T("span",{class:"file-upload-body"},[T("span",{class:"file-upload-primary"},t.primary),T("span",{class:"file-upload-secondary"},t.secondary)]),T("input",{type:"file",multiple:t.multiple,accept:t.accept||void 0,onChange:d=>s(d.target.files)})]),T("div",{class:"file-upload-preview",hidden:!t.modelValue.length},t.modelValue.map((d,_)=>T("figure",{class:"file-upload-preview-item"},[T("button",{class:"file-upload-preview-remove",type:"button","aria-label":`Remove ${d.name}`,onClick:()=>o(_)},[nt("ph-x")]),T("div",{class:"file-upload-preview-visual"},c(d)?T("img",{src:c(d),alt:""}):T("span",{class:"file-upload-preview-type"},Qg(d))),T("figcaption",{},[T("span",{class:"file-upload-preview-name"},d.name),T("span",{class:"file-upload-preview-meta"},`${Qg(d)} / ${kI(d)}`)])]))),n.actions&&T("div",{class:"file-upload-actions"},n.actions()),!n.actions&&t.modelValue.length>0&&T("div",{class:"file-upload-actions"},[T(An,{variant:"secondary",size:"sm",onClick:()=>{i(),s([])}},()=>"Reset")])])])}}}),Za=Me({name:"GnIconButton",inheritAttrs:!1,props:{icon:{type:String,required:!0},label:{type:String,required:!0},type:{type:String,default:"button"},size:{type:String,default:null},withoutHover:{type:Boolean,default:!1}},setup(t,{attrs:e}){return()=>T("button",{...e,type:t.type,"aria-label":t.label,class:ge("btn-icon",{"btn-icon-sm":t.size==="sm","without-hover":t.withoutHover},e.class)},[nt(t.icon)])}}),UI=Me({name:"GnIdentity",props:{title:{type:String,required:!0},meta:{type:String,default:""},avatar:{type:Object,default:()=>({})}},setup(t,{slots:e}){return()=>{var n,a,r;return T("span",{class:"identity"},[((n=e.avatar)==null?void 0:n.call(e))||T(os,t.avatar),T("span",{class:"identity-content"},[T("span",{class:"identity-title"},((a=e.title)==null?void 0:a.call(e))||t.title),(t.meta||e.meta)&&T("span",{class:"identity-meta"},((r=e.meta)==null?void 0:r.call(e))||t.meta)])])}}}),Rr=Me({name:"GnInput",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},type:{type:String,default:"text"},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""},bare:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n}){return()=>{const a=T("input",{...e,type:t.type,value:t.modelValue,class:ge(t.bare?"":"input",e.class),onInput:r=>n("update:modelValue",Nr(r))});return t.bare?a:T("div",{class:"form-group"},[T("label",{class:ge("label",t.state)},[t.label,nt(t.icon),a]),t.help&&T("div",{class:ge("input-info",t.state==="error"&&"error")},t.help)])}}}),FI=Me({name:"GnInputGroup",inheritAttrs:!1,props:{compact:{type:Boolean,default:!1},addon:{type:String,default:""},icon:{type:String,default:""}},setup(t,{attrs:e,slots:n}){return()=>{var a,r;return T("div",{...e,class:ge("input-group",{"input-group-compact":t.compact},e.class)},[(t.addon||t.icon||n.addon)&&T("span",{class:"input-group-addon"},((a=n.addon)==null?void 0:a.call(n))||nt(t.icon)||t.addon),(r=n.default)==null?void 0:r.call(n),n.action&&T("span",{class:"input-group-action"},n.action())])}}}),BI=Me({name:"GnList",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]},ordered:{type:Boolean,default:!1},icons:{type:Boolean,default:!1}},setup(t,{attrs:e,slots:n}){const a=t.ordered?"ol":"ul";return()=>T(a,{...e,class:ge("list",{"list-ordered":t.ordered,"with-icons":t.icons},e.class)},t.items.map(r=>{var i;return T("li",{class:"list-item"},[nt(r.icon),((i=n.item)==null?void 0:i.call(n,{item:r}))||r.label||r])}))}}),ls=Me({name:"GnLoader",inheritAttrs:!1,props:{circle:{type:Boolean,default:!1},label:{type:String,default:"Loading"}},setup(t,{attrs:e}){return()=>t.circle?T("div",{...e,class:ge("circle-loader",e.class)},[nt("ph-bold ph-spinner normalize"),t.label]):T("div",{...e,class:ge("loader",e.class),role:"status","aria-label":t.label})}}),GI=Me({name:"GnLoginCard",props:{title:{type:String,default:"Sign in"},logoSrc:{type:String,default:""},logoIcon:{type:String,default:""},usernameLabel:{type:String,default:"Username"},usernameIcon:{type:String,default:"ph-user"},passwordLabel:{type:String,default:"Password"},passwordIcon:{type:String,default:"ph-lock-key"},rememberMe:{type:Boolean,default:!1},rememberLabel:{type:String,default:"Remember me"},submitText:{type:String,default:"Sign in"},submitVariant:{type:String,default:"secondary"},loading:{type:Boolean,default:!1},error:{type:String,default:""},forgotHref:{type:String,default:"#"},forgotText:{type:String,default:"Forgot password?"},signupHref:{type:String,default:"#"},signupText:{type:String,default:"Create account"}},emits:["submit"],setup(t,{emit:e}){const n=Y(""),a=Y(""),r=Y(!1),i=s=>{s.preventDefault(),e("submit",{username:n.value,password:a.value,remember:r.value})};return()=>T("article",{class:"card login-card"},[(t.title||t.logoSrc||t.logoIcon)&&T("header",{class:"card-title login-card-header"},[t.logoSrc&&T("img",{src:t.logoSrc,alt:"",class:"login-card-logo"}),t.logoIcon&&!t.logoSrc&&nt(t.logoIcon,"login-card-logo-icon"),t.title&&T("span",{class:"login-card-title"},t.title)]),T("div",{class:"card-content"},[t.error&&T(td,{variant:"danger",class:"login-card-error"},()=>t.error),T("form",{class:"login-card-form",onSubmit:i},[T(Rr,{modelValue:n.value,"onUpdate:modelValue":s=>{n.value=s},label:t.usernameLabel,icon:t.usernameIcon,type:"text",autocomplete:"username"}),T(Rr,{modelValue:a.value,"onUpdate:modelValue":s=>{a.value=s},label:t.passwordLabel,icon:t.passwordIcon,type:"password",autocomplete:"current-password"}),t.rememberMe&&T(_S,{modelValue:r.value,"onUpdate:modelValue":s=>{r.value=s}},()=>t.rememberLabel),T(An,{variant:t.submitVariant,loading:t.loading,disabled:t.loading,type:"submit",icon:"ph-sign-in",class:"login-card-submit"},()=>t.submitText),(t.forgotHref||t.signupHref)&&T("div",{class:"login-card-links"},[t.forgotHref&&T("a",{href:t.forgotHref,class:"login-card-link"},t.forgotText),t.signupHref&&T("a",{href:t.signupHref,class:"login-card-link"},t.signupText)])])])])}}),YI=Me({name:"GnMetricCard",inheritAttrs:!1,props:{label:{type:String,required:!0},value:{type:[String,Number],required:!0},icon:{type:String,default:"ph-chart-line-up"},delta:{type:String,default:""},negative:{type:Boolean,default:!1},meta:{type:String,default:""}},setup(t,{attrs:e,slots:n}){return()=>{var a,r,i;return T("article",{...e,class:ge("card metric-card",e.class)},[T("div",{class:"card-content"},[T("div",{class:"metric-card-header"},[T("p",{class:"metric-card-label"},((a=n.label)==null?void 0:a.call(n))||t.label),T("span",{class:"metric-card-icon"},[nt(t.icon)])]),T("p",{class:"metric-card-value"},((r=n.value)==null?void 0:r.call(n))||t.value),(t.delta||t.meta||n.meta)&&T("div",{class:"metric-card-meta"},[t.delta&&T("span",{class:ge("metric-card-delta",{"metric-card-delta-negative":t.negative})},t.delta),((i=n.meta)==null?void 0:i.call(n))||t.meta])])])}}});function mS(){var t;const e=yr();return((t=e==null?void 0:e.proxy)==null?void 0:t.$router)||null}function gS(){var t;const e=yr();return((t=e==null?void 0:e.proxy)==null?void 0:t.$route)||null}function ES(t,e,n="prefix"){if(!t)return!1;const a=t.value||t;return typeof e=="string"?n==="exact"?a.path===e:a.path===e||a.path.startsWith(e+"/"):e.path?n==="exact"?a.path===e.path:a.path===e.path||a.path.startsWith(e.path+"/"):e.name?a.name===e.name:!1}var fS=Me({name:"GnNavList",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]},activeMatch:{type:String,default:"prefix"}},emits:["select"],setup(t,{attrs:e,emit:n,slots:a}){const r=mS(),i=gS(),s=!!(r&&i),o=l=>{if(l){if(typeof l=="string")return l;if(l.path)return l.path}},c=ue(()=>t.items.map(l=>{const u=!!l.to,d=u?s?r.resolve(l.to).href:o(l.to):l.href,_=u&&s?ES(i,l.to,t.activeMatch):!!l.active;return{...l,resolvedHref:d,isActive:_,hasTo:u}}));return()=>T("ul",{...e,class:ge("list list-nav",e.class)},c.value.map(l=>{var u,d;return T("li",{class:ge("list-item",{"list-item-active":l.isActive})},[T(l.resolvedHref?"a":"button",{class:"list-action",href:l.resolvedHref,type:l.resolvedHref?void 0:"button",onClick:_=>{var m;l.hasTo&&s&&(_.preventDefault(),r.push(l.to)),(m=l.onSelect)==null||m.call(l,l,_),n("select",l)}},[T("span",{class:"list-label"},[nt(l.icon),((u=a.label)==null?void 0:u.call(a,{item:l}))||l.label]),(l.meta||a.meta)&&T("span",{class:"list-meta"},((d=a.meta)==null?void 0:d.call(a,{item:l}))||l.meta)])])}))}}),$I=0,qI=Me({name:"GnNavigationShell",props:{brand:{type:String,default:"GNexus UI Kit"},logoSrc:{type:String,default:"/assets/imgs/gnexus-mark.svg"},current:{type:String,default:""},title:{type:String,default:"Sections"},subtitle:{type:String,default:"Navigation"},footerLeft:{type:String,default:""},footerRight:{type:String,default:""},items:{type:Array,default:()=>[]},activeMatch:{type:String,default:"prefix"}},emits:["select"],setup(t,{emit:e,slots:n}){const a=Y(!1),r=`gn-nav-drawer-${++$I}`,i=Y(null);let s=null;const o=()=>{a.value=!1},c=()=>{a.value=!a.value},l=u=>{u.key==="Escape"&&(u.preventDefault(),o())};return st(a,u=>{var d;u?(s=document.activeElement,document.body.classList.add("nav-drawer-open"),document.addEventListener("keydown",l),Ht(()=>{var _;return(_=i.value)==null?void 0:_.focus()})):(document.body.classList.remove("nav-drawer-open"),document.removeEventListener("keydown",l),(d=s==null?void 0:s.focus)==null||d.call(s),s=null)}),Yn(()=>{document.body.classList.remove("nav-drawer-open"),document.removeEventListener("keydown",l)}),()=>{var u,d,_,m,p,E,b;return[T("header",{class:"nav-topbar"},[T("button",{class:"nav-topbar-toggle",type:"button","aria-controls":r,"aria-expanded":a.value?"true":"false",onClick:c},[nt("ph-sidebar-simple"),T("span",{},"Menu")]),T("div",{class:"nav-topbar-brand"},[t.logoSrc&&T("img",{src:t.logoSrc,alt:"","aria-hidden":"true"}),T("span",{},((u=n.brand)==null?void 0:u.call(n))||t.brand)]),T("div",{class:"nav-topbar-current"},((d=n.current)==null?void 0:d.call(n))||t.current)]),T("div",{class:"nav-drawer-backdrop",onClick:o}),T("aside",{ref:i,class:["nav-drawer",{"is-open":a.value}],id:r,"aria-label":"Navigation","aria-hidden":a.value?"false":"true",tabindex:"-1"},[T("header",{class:"nav-drawer-header"},[T("div",{},[T("div",{class:"nav-drawer-title"},((_=n.title)==null?void 0:_.call(n))||t.title),T("div",{class:"nav-drawer-subtitle"},((m=n.subtitle)==null?void 0:m.call(n))||t.subtitle)]),T("button",{class:"nav-drawer-close",type:"button","aria-label":"Close navigation",onClick:o},[nt("ph-x")])]),T("nav",{class:"nav-drawer-body"},[((p=n.default)==null?void 0:p.call(n,{close:o}))||T(fS,{items:t.items,activeMatch:t.activeMatch,onSelect:I=>{e("select",I),o()}})]),(n.footer||t.footerLeft||t.footerRight)&&T("footer",{class:"nav-drawer-footer"},((E=n.footer)==null?void 0:E.call(n))||[T("span",{},t.footerLeft),T("span",{},t.footerRight)])]),(b=n.content)==null?void 0:b.call(n)]}}}),HI=Me({name:"GnPageHeader",inheritAttrs:!1,props:{title:{type:String,required:!0},subtitle:{type:String,default:""},kicker:{type:String,default:""},compact:{type:Boolean,default:!1},accent:{type:Boolean,default:!1}},setup(t,{attrs:e,slots:n}){return()=>{var a,r,i;return T("header",{...e,class:ge("page-header",{"page-header-compact":t.compact,"page-header-accent":t.accent},e.class)},[T("div",{class:"page-header-content"},[(t.kicker||n.kicker)&&T("div",{class:"page-header-kicker"},((a=n.kicker)==null?void 0:a.call(n))||t.kicker),T("h1",{class:"page-header-title"},((r=n.title)==null?void 0:r.call(n))||t.title),(t.subtitle||n.subtitle)&&T("p",{class:"page-header-subtitle"},((i=n.subtitle)==null?void 0:i.call(n))||t.subtitle),n.meta&&T("div",{class:"page-header-meta"},n.meta())]),n.actions&&T("div",{class:"page-header-actions"},n.actions())])}}}),VI=Me({name:"GnHorizontalCard",inheritAttrs:!1,props:{image:{type:String,default:""},title:{type:String,default:""},titleHref:{type:String,default:""},icon:{type:String,default:""}},setup(t,{attrs:e,slots:n}){const a=()=>{var r;const i=[nt(t.icon),((r=n.title)==null?void 0:r.call(n))||t.title];return t.titleHref?T("a",{href:t.titleHref,class:"card-title-link"},i):i};return()=>{var r;return T("article",{...e,class:ge("card card-horizontal",e.class)},[t.image&&T("div",{class:"card-media"},[T("img",{src:t.image,alt:""})]),T("div",{class:"card-body"},[(t.title||t.icon||n.title)&&T("h3",{class:"card-title"},a()),T("div",{class:"card-content"},(r=n.default)==null?void 0:r.call(n)),n.footer&&T("footer",{class:"card-footer"},n.footer())])])}}}),zI=Me({name:"GnPagination",props:{page:{type:Number,required:!0},totalPages:{type:Number,required:!0},ariaLabel:{type:String,default:"Pagination"}},emits:["update:page"],setup(t,{emit:e}){const n=a=>{a>=1&&a<=t.totalPages&&a!==t.page&&e("update:page",a)};return()=>{const a=Array.from({length:t.totalPages},(r,i)=>i+1);return T("nav",{class:"pagination","aria-label":t.ariaLabel},[T("button",{class:"pagination-item",type:"button",disabled:t.page<=1,onClick:()=>n(t.page-1)},[nt("ph-arrow-left")]),a.map(r=>T("button",{class:ge("pagination-item",{"pagination-item-active":r===t.page}),type:"button","aria-current":r===t.page?"page":void 0,onClick:()=>n(r)},r)),T("button",{class:"pagination-item",type:"button",disabled:t.page>=t.totalPages,onClick:()=>n(t.page+1)},[nt("ph-arrow-right")])])}}}),WI=Me({name:"GnPopover",props:{label:{type:String,default:"Details"},title:{type:String,default:""},text:{type:String,default:""},icon:{type:String,default:"ph-info"},variant:{type:String,default:"accent"}},setup(t,{slots:e}){const n=Y(!1),a=Y(null),r=()=>{n.value=!1,document.removeEventListener("click",i),document.removeEventListener("keydown",s)},i=c=>{a.value&&!a.value.contains(c.target)&&r()},s=c=>{c.key==="Escape"&&(c.preventDefault(),r())},o=()=>{n.value=!n.value,n.value?(setTimeout(()=>document.addEventListener("click",i),0),document.addEventListener("keydown",s)):r()};return Yn(r),()=>{var c,l,u;return T("div",{ref:a,class:ge("popover",{"is-open":n.value})},[((c=e.trigger)==null?void 0:c.call(e,{open:n.value,toggle:o}))||T(An,{variant:t.variant,icon:t.icon,"aria-expanded":n.value?"true":"false",onClick:o},()=>t.label),T("div",{class:"popover-panel"},[(t.title||e.title)&&T("h3",{class:"popover-title"},((l=e.title)==null?void 0:l.call(e))||t.title),(t.text||e.default)&&T("p",{class:"popover-text"},((u=e.default)==null?void 0:u.call(e))||t.text)])])}}}),SS=Me({name:"GnProgress",inheritAttrs:!1,props:{value:{type:Number,required:!0},max:{type:Number,default:100},label:{type:String,default:""},variant:{type:String,default:"secondary"},striped:{type:Boolean,default:!1},animated:{type:Boolean,default:!1}},setup(t,{attrs:e,slots:n}){return()=>{var a;const r=Math.max(0,Math.min(100,Math.round(t.value/t.max*100))),i=Sa(t.variant,"secondary");return T("div",{...e,class:ge("progress",`progress-${i}`,{"progress-striped":t.striped,"progress-animated":t.animated},e.class),style:{"--progress-value":`${r}%`}},[(t.label||n.label)&&T("div",{class:"progress-header"},[T("span",{},((a=n.label)==null?void 0:a.call(n))||t.label),T("span",{class:"progress-value"},`${r}%`)]),T("div",{class:"progress-track"},[T("span",{class:"progress-bar",role:"progressbar","aria-valuenow":t.value,"aria-valuemin":0,"aria-valuemax":t.max})])])}}}),KI=Me({name:"GnProgressStages",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]}},setup(t,{attrs:e}){return()=>T("div",{...e,class:ge("progress-stages",e.class)},t.items.map(n=>T("div",{class:ge("progress-stage",{"progress-stage-complete":n.status==="complete","progress-stage-current":n.status==="current"})},n.label||n)))}}),bS=Me({name:"GnRadio",inheritAttrs:!1,props:{modelValue:{type:[String,Number,Boolean],default:""},value:{type:[String,Number,Boolean],required:!0},label:{type:String,default:""},name:{type:String,default:""},disabled:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n,slots:a}){return()=>{var r;return T("label",{class:ge("radio",e.class)},[T("input",{...e,type:"radio",name:t.name,value:t.value,checked:t.modelValue===t.value,disabled:t.disabled,onChange:()=>n("update:modelValue",t.value)}),T("span",{class:"radio-control","aria-hidden":"true"}),T("span",{class:"radio-label"},((r=a.default)==null?void 0:r.call(a))||t.label)])}}}),Du=Me({name:"GnRadioGroup",props:{modelValue:{type:[String,Number,Boolean],default:""},name:{type:String,default:"gn-radio-group"},label:{type:String,default:""},options:{type:Array,default:()=>[]}},emits:["update:modelValue"],setup(t,{emit:e,slots:n}){return()=>{var a;return T("div",{class:"form-group radio-group",role:"radiogroup","aria-label":t.label||void 0},[t.label&&T("div",{class:"label"},t.label),((a=n.default)==null?void 0:a.call(n))||t.options.map(r=>T(bS,{modelValue:t.modelValue,"onUpdate:modelValue":i=>e("update:modelValue",i),name:t.name,value:r.value,label:r.label,disabled:r.disabled}))])}}}),QI=Me({name:"GnRange",inheritAttrs:!1,props:{modelValue:{type:[Number,String],default:0},label:{type:String,default:""},min:{type:[Number,String],default:0},max:{type:[Number,String],default:100},step:{type:[Number,String],default:1}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n}){return()=>T("div",{class:"range"},[T("label",{class:"label"},[t.label,T("input",{...e,type:"range",value:t.modelValue,min:t.min,max:t.max,step:t.step,onInput:a=>n("update:modelValue",Nr(a))})])])}}),XI=0;function ZI(){return`repeater-item-${++XI}`}var JI=Me({name:"GnRepeater",inheritAttrs:!1,props:{modelValue:{type:Array,default:()=>[]},label:{type:String,default:"Items"},addLabel:{type:String,default:"Add"},addIcon:{type:String,default:"ph-plus"},removeLabel:{type:String,default:"Remove"},removeIcon:{type:String,default:"ph-trash"},minItems:{type:Number,default:1},maxItems:{type:Number,default:0},itemFactory:{type:Function,default:()=>()=>({id:ZI()})},disabled:{type:Boolean,default:!1}},emits:["update:modelValue","add","remove"],setup(t,{attrs:e,emit:n,slots:a}){const r=ue(()=>!(t.disabled||t.maxItems>0&&t.modelValue.length>=t.maxItems));function i(c){return!(t.disabled||t.modelValue.length<=t.minItems)}function s(){if(!r.value)return;const c=t.itemFactory(),l=[...t.modelValue,c];n("update:modelValue",l),n("add",c)}function o(c){if(!i())return;const l=t.modelValue[c],u=t.modelValue.filter((d,_)=>_!==c);n("update:modelValue",u),n("remove",l)}return()=>{var c;const u=((c=a.header)==null?void 0:c.call(a,{add:s,canAdd:r.value}))||T("div",{class:"repeater-header"},[T("span",{class:"repeater-title"},t.label),T("button",{type:"button",class:ge("btn","btn-secondary","btn-small","with-icon"),disabled:!r.value,onClick:s},[nt(t.addIcon),t.addLabel])]),d=t.modelValue.map((_,m)=>{var p,E,b,I;const R=(E=(p=_==null?void 0:_.id)!=null?p:_==null?void 0:_.key)!=null?E:m,y=i(),L={item:_,index:m,remove:()=>o(m),canRemove:y},U=(b=a.item)==null?void 0:b.call(a,L),h=(I=a.actions)==null?void 0:I.call(a,L),N=!a.actions&&T("button",{type:"button",class:ge("btn-icon","btn-icon-sm"),"aria-label":t.removeLabel,disabled:!y,onClick:C=>{C.stopPropagation(),o(m)}},[nt(t.removeIcon)]);return T("div",{class:"repeater-item",key:R},[T("div",{class:"repeater-item-body"},U),(h||N)&&T("div",{class:"repeater-item-actions"},h||[N])])});return T("div",{...e,class:ge("repeater",{"repeater-disabled":t.disabled},e.class)},[u,T("div",{class:"repeater-list"},d)])}}}),ad=Me({name:"GnTabs",props:{modelValue:{type:String,default:""},items:{type:Array,required:!0},compact:{type:Boolean,default:!1},vertical:{type:Boolean,default:!1},ariaLabel:{type:String,default:"Tabs"}},emits:["update:modelValue"],setup(t,{emit:e,slots:n}){const a=ue(()=>{var c,l;return t.modelValue||((c=t.items.find(u=>!u.disabled))==null?void 0:c.id)||((l=t.items[0])==null?void 0:l.id)}),r=c=>{c.disabled||e("update:modelValue",c.id)},i=()=>t.items.filter(c=>!c.disabled),s=(c,l)=>{const u=i(),d=u.findIndex(m=>m.id===c.id),_=u[(d+l+u.length)%u.length];r(_)},o=(c,l)=>{if(c.key==="ArrowRight"||c.key==="ArrowDown")c.preventDefault(),s(l,1);else if(c.key==="ArrowLeft"||c.key==="ArrowUp")c.preventDefault(),s(l,-1);else if(c.key==="Home")c.preventDefault(),r(i()[0]);else if(c.key==="End"){c.preventDefault();const u=i();r(u[u.length-1])}};return()=>T("div",{class:ge("tabs",{"tabs-compact":t.compact,"tabs-vertical":t.vertical})},[T("div",{class:"tabs-list",role:"tablist","aria-label":t.ariaLabel},t.items.map(c=>{const l=c.id===a.value,u=`${c.id}-panel`;return T("button",{class:ge("tab",{"tab-active":l}),type:"button",role:"tab","aria-selected":l?"true":"false","aria-controls":u,"aria-disabled":c.disabled?"true":void 0,tabindex:l?"0":"-1",onClick:()=>r(c),onKeydown:d=>o(d,c)},[nt(c.icon),c.label])})),T("div",{class:"tabs-panels"},t.items.map(c=>{var l,u;const d=c.id===a.value;return T("div",{id:`${c.id}-panel`,class:ge("tab-panel",{"tab-panel-active":d}),role:"tabpanel",hidden:!d},((l=n[c.id])==null?void 0:l.call(n,{item:c,active:d}))||d&&((u=n.default)==null?void 0:u.call(n,{item:c,active:d})))}))])}}),jI=Me({name:"GnRouterTabs",props:{items:{type:Array,required:!0},compact:{type:Boolean,default:!1},vertical:{type:Boolean,default:!1},ariaLabel:{type:String,default:"Tabs"},activeMatch:{type:String,default:"prefix"}},setup(t,{slots:e}){const n=mS(),a=gS(),r=!!(n&&a);!r&&typeof process<"u"&&cS&&console.warn("[gnexus-ui-kit] GnRouterTabs requires vue-router. Falling back to standard tabs.");const i=ue(()=>t.items.map(c=>({id:c.id,label:c.label,icon:c.icon,disabled:c.disabled,to:c.to}))),s=ue(()=>{var c,l;if(!r)return((c=i.value.find(d=>!d.disabled))==null?void 0:c.id)||"";const u=i.value.find(d=>d.disabled||!d.to?!1:ES(a,d.to,t.activeMatch));return(u==null?void 0:u.id)||((l=i.value.find(d=>!d.disabled))==null?void 0:l.id)||""}),o=c=>{if(!r)return;const l=i.value.find(u=>u.id===c);l&&l.to&&n.push(l.to)};return()=>T(ad,{modelValue:s.value,items:i.value,compact:t.compact,vertical:t.vertical,ariaLabel:t.ariaLabel,"onUpdate:modelValue":o},e)}}),eD=Me({name:"GnSearchField",inheritAttrs:!1,props:{modelValue:{type:String,default:""},placeholder:{type:String,default:"Search"},compact:{type:Boolean,default:!0},clearable:{type:Boolean,default:!0}},emits:["update:modelValue","clear"],setup(t,{attrs:e,emit:n}){const a=()=>{n("update:modelValue",""),n("clear")};return()=>T("div",{class:ge("input-group search-field",{"input-group-compact":t.compact})},[T("span",{class:"input-group-addon"},[nt("ph-magnifying-glass")]),T("input",{...e,type:"search",value:t.modelValue,placeholder:t.placeholder,class:ge("input-group-input",e.class),onInput:r=>n("update:modelValue",Nr(r))}),t.clearable&&T("button",{class:"input-group-action",type:"button","aria-label":"Clear search",onClick:a},[nt("ph-x")])])}}),tD=Me({name:"GnSelect",inheritAttrs:!1,props:{modelValue:{type:[String,Number],default:""},label:{type:String,default:""},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""},options:{type:Array,default:()=>[]}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n,slots:a}){const r=()=>t.options.map(i=>{const s=typeof i=="object"?i.value:i,o=typeof i=="object"?i.label:i;return T("option",{value:s},o)});return()=>{var i;return T("div",{class:"form-group"},[T("label",{class:ge("label",t.state)},[t.label,nt(t.icon),T("div",{class:"select-wrap"},[T("select",{...e,value:t.modelValue,class:ge("input select",e.class),onChange:s=>n("update:modelValue",Nr(s))},((i=a.default)==null?void 0:i.call(a))||r())])]),t.help&&T("div",{class:ge("input-info",t.state==="error"&&"error")},t.help)])}}}),nD=Me({name:"GnSkeleton",inheritAttrs:!1,props:{type:{type:String,default:"line"},stack:{type:Boolean,default:!1},count:{type:Number,default:1}},setup(t,{attrs:e}){const n=a=>T("span",{key:a,...e,class:ge("skeleton",`skeleton-${t.type}`,e.class)});return()=>t.stack?T("div",{class:"skeleton-stack"},Array.from({length:t.count},(a,r)=>n(r))):n(0)}}),aD=Me({name:"GnSteps",inheritAttrs:!1,props:{items:{type:Array,required:!0},vertical:{type:Boolean,default:!1}},setup(t,{attrs:e}){return()=>T("ol",{...e,class:ge("steps",{"steps-vertical":t.vertical},e.class)},t.items.map((n,a)=>T("li",{class:ge("step",{"step-complete":n.status==="complete","step-current":n.status==="current","step-disabled":n.disabled||n.status==="disabled"})},[T("span",{class:"step-marker"},n.marker||String(a+1)),T("h3",{class:"step-title"},n.title),n.text&&T("p",{class:"step-text"},n.text)])))}}),rD=Me({name:"GnStatusCard",inheritAttrs:!1,props:{title:{type:String,required:!0},text:{type:String,default:""},icon:{type:String,default:"ph-stack"},variant:{type:String,default:"primary"}},setup(t,{attrs:e,slots:n}){const a=Sa(t.variant);return()=>{var r,i,s;return T("article",{...e,class:ge("card status-card",`card-${a}`,e.class)},[T("span",{class:"card-title"},((r=n.title)==null?void 0:r.call(n))||t.title),T("div",{class:"card-content"},[T("div",{class:"status-icon-container"},[T("div",{class:"status-icon"},((i=n.icon)==null?void 0:i.call(n))||[nt(t.icon)])]),(t.text||n.default)&&T("p",{class:"status-name"},((s=n.default)==null?void 0:s.call(n))||t.text)])])}}}),TS=Me({name:"GnSwitch",inheritAttrs:!1,props:{modelValue:{type:Boolean,default:!1},label:{type:String,default:""},disabled:{type:Boolean,default:!1}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n,slots:a}){return()=>{var r;return T("label",{class:ge("switch",e.class)},[T("input",{...e,type:"checkbox",checked:t.modelValue,disabled:t.disabled,onChange:i=>n("update:modelValue",i.target.checked)}),T("span",{class:"switch-control","aria-hidden":"true"}),T("span",{class:"switch-label"},((r=a.default)==null?void 0:r.call(a))||t.label)])}}}),iD=Me({name:"GnTagInput",inheritAttrs:!1,props:{modelValue:{type:Array,default:()=>[]},label:{type:String,default:""},placeholder:{type:String,default:"Add item…"},help:{type:String,default:""},disabled:{type:Boolean,default:!1},separator:{type:String,default:","},unique:{type:Boolean,default:!0},maxItems:{type:Number,default:0}},emits:["update:modelValue","add","remove"],setup(t,{emit:e,attrs:n,slots:a}){const r=Y(null),i=Y(!1),s=Y(""),o=ue(()=>!(t.disabled||t.maxItems>0&&t.modelValue.length>=t.maxItems));function c(p){return p.trim().replace(/\s+/g," ")}function l(p){const E=c(p);if(!E||t.unique&&t.modelValue.includes(E)||t.maxItems>0&&t.modelValue.length>=t.maxItems)return;const b=[...t.modelValue,E];e("update:modelValue",b),e("add",E)}function u(p){const E=t.modelValue[p],b=t.modelValue.filter((I,R)=>R!==p);e("update:modelValue",b),e("remove",E)}function d(p){if(p.key==="Enter"){p.preventDefault(),s.value&&((t.separator?s.value.split(t.separator).map(b=>b.trim()).filter(Boolean):[s.value]).forEach(l),s.value="");return}if(p.key==="Backspace"&&!s.value&&t.modelValue.length>0){u(t.modelValue.length-1);return}}function _(p){const E=p.clipboardData.getData("text");if(!E||!t.separator)return;p.preventDefault();const b=E.split(t.separator).map(R=>R.trim()).filter(Boolean),I=[];for(const R of b){const y=c(R);if(y&&!(t.unique&&t.modelValue.includes(y))){if(t.maxItems>0&&t.modelValue.length+I.length>=t.maxItems)break;I.push(y)}}if(I.length){const R=[...t.modelValue,...I];e("update:modelValue",R),I.forEach(y=>e("add",y))}}function m(){var p;(p=r.value)==null||p.focus()}return()=>{var p;const E=t.label||a.label?T("label",{class:"label"},[((p=a.label)==null?void 0:p.call(a))||t.label,t.disabled&&T("span",{class:"label-disabled-hint"},"Disabled")]):null,b=t.modelValue.map((L,U)=>T("span",{class:ge("chip","chip-secondary"),key:`${L}-${U}`},[L,!t.disabled&&T("button",{class:"chip-remove",type:"button","aria-label":`Remove ${L}`,onClick:h=>{h.stopPropagation(),u(U)}},[T("i",{class:"ph ph-x"})])])),I=T("input",{ref:r,class:"tag-input-field",type:"text",placeholder:o.value?t.placeholder:"",value:s.value,disabled:t.disabled,onInput:L=>{s.value=L.target.value},onKeydown:d,onPaste:_,onFocus:()=>i.value=!0,onBlur:()=>i.value=!1}),R=T("div",{class:ge("tag-input-wrap"),onClick:m},[...b,I]),y=t.help?T("div",{class:"input-info"},[T("i",{class:"ph ph-info"})," "+t.help]):null;return T("div",{...n,class:ge("tag-input",{"tag-input-focused":i.value,"tag-input-disabled":t.disabled},n.class)},[E,R,y])}}}),hS=Me({name:"GnTable",props:{columns:{type:Array,required:!0},rows:{type:Array,default:()=>[]},caption:{type:String,default:""},emptyText:{type:String,default:"Empty"}},setup(t,{attrs:e,slots:n}){return()=>{var a;return T("div",{class:"table-wrapper"},[T("table",{class:ge("table data-list",{"table-empty":!t.rows.length},e.class)},[t.caption&&T("caption",{class:"table-caption"},t.caption),T("thead",{class:"table-head"},[T("tr",{class:"table-row"},t.columns.map(r=>T("th",{scope:"col"},r.label)))]),T("tbody",{class:"table-body"},t.rows.length?t.rows.map(r=>T("tr",{class:"table-row"},t.columns.map(i=>{var s;const o=`cell-${i.key}`;return T("td",{},((s=n[o])==null?void 0:s.call(n,{row:r,column:i,value:r[i.key]}))||r[i.key])}))):T("tr",{},[T("td",{class:"is-empty",colspan:t.columns.length},((a=n.empty)==null?void 0:a.call(n))||t.emptyText)]))])])}}}),vS=Me({name:"GnTextarea",inheritAttrs:!1,props:{modelValue:{type:String,default:""},label:{type:String,default:""},icon:{type:String,default:""},state:{type:String,default:""},help:{type:String,default:""}},emits:["update:modelValue"],setup(t,{attrs:e,emit:n}){return()=>T("div",{class:"form-group"},[T("label",{class:ge("label",t.state)},[t.label,nt(t.icon),T("textarea",{...e,value:t.modelValue,class:ge("input",e.class),onInput:a=>n("update:modelValue",Nr(a))})]),t.help&&T("div",{class:ge("input-info",t.state==="error"&&"error")},t.help)])}}),sD=Me({name:"GnTimeline",inheritAttrs:!1,props:{items:{type:Array,default:()=>[]}},setup(t,{attrs:e,slots:n}){return()=>T("ol",{...e,class:ge("timeline",e.class)},t.items.map(a=>{var r,i;const s=a.variant?Sa(a.variant):"";return T("li",{class:ge("timeline-item",s&&`timeline-item-${s}`)},[T("span",{class:"timeline-marker"},[nt(a.icon||"ph-circle")]),T("div",{class:"timeline-content"},[T("article",{class:"timeline-card"},[T("header",{class:"timeline-header"},[T("h3",{class:"timeline-title"},a.title),a.time&&T("time",{class:"timeline-time"},a.time)]),T("p",{class:"timeline-text"},((r=n[a.key])==null?void 0:r.call(n,{item:a}))||a.text),(a.meta||n.meta)&&T("div",{class:"timeline-meta"},((i=n.meta)==null?void 0:i.call(n,{item:a}))||a.meta)])])])}))}}),oD=Me({name:"GnTooltip",inheritAttrs:!1,props:{text:{type:String,default:""}},setup(t,{attrs:e,slots:n}){const a=Y(!1);return()=>{var r,i;return T("span",{...e,class:ge("tooltip",{"is-open":a.value},e.class),tabindex:"0",onFocusin:()=>{a.value=!0},onFocusout:()=>{a.value=!1}},[(r=n.default)==null?void 0:r.call(n),T("span",{class:"tooltip-panel",role:"tooltip"},((i=n.panel)==null?void 0:i.call(n))||t.text)])}}}),lD=Me({name:"GnToolbar",inheritAttrs:!1,props:{title:{type:String,default:""},meta:{type:String,default:""}},setup(t,{attrs:e,slots:n}){return()=>{var a,r,i,s;return T("div",{...e,class:ge("toolbar",e.class)},[T("div",{class:"toolbar-group"},[T("div",{},[(t.title||n.title)&&T("h3",{class:"toolbar-title"},((a=n.title)==null?void 0:a.call(n))||t.title),(t.meta||n.meta)&&T("span",{class:"toolbar-meta"},((r=n.meta)==null?void 0:r.call(n))||t.meta)])]),(n.default||n.actions)&&T("div",{class:"toolbar-group"},((i=n.actions)==null?void 0:i.call(n))||((s=n.default)==null?void 0:s.call(n)))])}}}),RS=Symbol("gnexus-ui-kit-toast"),Xg={info:"ph-info",success:"ph-check-circle",warning:"ph-warning",danger:"ph-warning-octagon",error:"ph-warning-octagon",primary:"ph-info",secondary:"ph-info"},cD=Me({name:"GnToastProvider",props:{lifetime:{type:Number,default:4e3}},setup(t,{slots:e,expose:n}){const a=Y(null),r=Y(!1),i=Y(!1);let s=null,o=null,c=null;const l=Y(100),u=()=>{window.clearTimeout(o),window.clearInterval(c),r.value=!0,i.value=!1,o=window.setTimeout(()=>{a.value=null,r.value=!1,l.value=100,window.clearTimeout(s),s=null},300)},d=()=>{window.clearTimeout(o),window.clearTimeout(s),window.clearInterval(c),r.value=!1,i.value=!1,l.value=100,a.value=null},_=E=>{window.clearTimeout(o),window.clearInterval(c),r.value=!1,i.value=!1,l.value=100;const b=Sa(E.variant||E.type||"info","info"),I=E.lifetime!==void 0?E.lifetime:t.lifetime;if(a.value={id:Date.now(),variant:b==="error"?"danger":b,title:E.title||"",text:E.text||E.message||"",icon:E.icon||Xg[b]||Xg.info,lifetime:I},window.clearTimeout(s),I!==0){const y=I/100;l.value=100,c=window.setInterval(()=>{l.value-=100/y,l.value<=0&&window.clearInterval(c)},100),s=window.setTimeout(u,I)}Ht(()=>{requestAnimationFrame(()=>{i.value=!0})})},m={show:_,close:d,info:E=>_({...E,variant:"info"}),success:E=>_({...E,variant:"success"}),warning:E=>_({...E,variant:"warning"}),danger:E=>_({...E,variant:"danger"}),error:E=>_({...E,variant:"danger"})};ZE(RS,m),n(m);const p=()=>r.value?"a-hide":i.value?"a-show":"";return()=>{var E;return[(E=e.default)==null?void 0:E.call(e),a.value&&T("div",{class:ge("toast",p(),`toast-${a.value.variant}`),role:"alert"},[T("div",{class:"toast-content"},[T("div",{class:"toast-header"},[nt(a.value.icon),a.value.title]),a.value.text&&T("p",{class:"toast-text"},a.value.text)]),T("button",{class:"btn-icon toast-close",type:"button","aria-label":"Close",onClick:u},[nt("ph-x")]),a.value.lifetime!==0&&T("div",{class:"toast-progress"},[T("div",{class:"toast-progress-bar",style:{transform:`scaleX(${Math.max(0,l.value/100)})`}})])])]}}}),uD=Me({name:"GnUsageMeter",props:{title:{type:String,required:!0},value:{type:Number,required:!0},max:{type:Number,default:100},meta:{type:String,default:""}},setup(t,{slots:e}){return()=>{var n,a;const r=Math.max(0,Math.min(100,Math.round(t.value/t.max*100)));return T("section",{class:"usage-meter"},[T("h3",{class:"usage-meter-title"},[((n=e.title)==null?void 0:n.call(e))||t.title,T("span",{class:"usage-meter-value"},`${r}%`)]),T(SS,{value:t.value,max:t.max}),(t.meta||e.meta)&&T("p",{class:"usage-meter-meta"},((a=e.meta)==null?void 0:a.call(e))||t.meta)])}}}),dD=Me({name:"GnUserCard",props:{name:{type:String,required:!0},email:{type:String,default:""},role:{type:String,default:""},avatar:{type:Object,default:()=>({})},href:{type:String,default:""},compact:{type:Boolean,default:!1},actions:{type:Array,default:()=>[]}},setup(t,{slots:e}){const n=()=>{var i;return((i=e.avatar)==null?void 0:i.call(e))||T(os,{...t.avatar,size:t.compact?"sm":"md"})},a=()=>T("span",{class:"identity"},[n(),T("span",{class:"identity-content"},[T("span",{class:"identity-title"},t.name),t.email&&T("span",{class:"identity-meta"},t.email)])]),r=()=>e.actions?e.actions():t.actions.length?T("div",{class:"user-card-actions"},t.actions.map(i=>{if(t.compact)return T("button",{class:"btn-icon",type:"button","aria-label":i.label,onClick:i.onClick},[nt(i.icon)]);const s=!!i.icon,o=ge("btn","btn-small",{[`btn-${i.variant}`]:i.variant,"btn-secondary":!i.variant,"with-icon":s});return T("button",{class:o,type:"button",onClick:i.onClick},[s&&nt(i.icon),i.label])})):null;return()=>{const i=ge("card","user-card",{"user-card-compact":t.compact}),s=[];t.href?s.push(T("a",{class:"profile-identity",href:t.href,target:"_blank",rel:"noopener noreferrer"},[a()])):s.push(a()),!t.compact&&t.role&&s.push(T("span",{class:"user-card-role"},t.role)),e.default&&!t.compact&&s.push(T("div",{class:"user-card-extra"},e.default()));const o=r();return o&&s.push(o),T("article",{class:i},[T("div",{class:"user-card-body"},s)])}}});function Or(){const t=ja(RS,null);if(t)return t;const e=()=>{throw new Error("GNexus UI Kit: useToast() requires near the app root.")};return{show:e,info:e,success:e,warning:e,danger:e,error:e,close:e}}var _D={GnAccordion:EI,GnActionCard:fI,GnActionList:SI,GnActivityLog:bI,GnAlert:td,GnAvatar:os,GnAvatarStack:TI,GnBadge:dS,GnButton:An,GnCard:hI,GnCheckbox:_S,GnChip:vI,GnChipGroup:RI,GnCopyButton:AI,GnCombobox:yI,GnConfirmDialog:OI,GnDescriptionList:II,GnDefinitionList:DI,GnDropdown:wI,GnDrawer:LI,GnEmptyState:MI,GnFileUpload:PI,GnIconButton:Za,GnIdentity:UI,GnInput:Rr,GnInputGroup:FI,GnList:BI,GnLoader:ls,GnLoginCard:GI,GnMetricCard:YI,GnModal:nd,GnNavList:fS,GnNavigationShell:qI,GnPageHeader:HI,GnHorizontalCard:VI,GnPagination:zI,GnPopover:WI,GnProgress:SS,GnProgressStages:KI,GnRadio:bS,GnRadioGroup:Du,GnRange:QI,GnRepeater:JI,GnRouterTabs:jI,GnSearchField:eD,GnSelect:tD,GnSkeleton:nD,GnSteps:aD,GnStatusCard:rD,GnSwitch:TS,GnTagInput:iD,GnTable:hS,GnTabs:ad,GnTextarea:vS,GnTimeline:sD,GnTooltip:oD,GnToolbar:lD,GnToastProvider:cD,GnUsageMeter:uD,GnUserCard:dD},pD={install(t){Object.entries(_D).forEach(([e,n])=>{t.component(e,n)})}};const mD=location.protocol==="https:"?"wss":"ws",gD=`${mD}://${location.host}`,ED=3,fD=1e3,SD=15e3,bD=20;function TD(t){const e=`${gD}/ws/sessions/${t}`,n=localStorage.getItem("navi_api_token");return n?`${e}?api_token=${encodeURIComponent(n)}`:e}function hD(){const t=sn(),e=Or(),n=Y(!1),a=Y(!1),r=Y(!1);let i=null,s=null,o=0,c=null,l=!1,u=!1,d=[];function _(y){l=!1,s=y,o=0,r.value=!1,d=[],E()}function m(){l=!0,clearTimeout(c),i==null||i.close(),i=null,d=[],n.value=!1,a.value=!1}function p(y){return(i==null?void 0:i.readyState)===WebSocket.OPEN?(i.send(JSON.stringify(y)),!0):(d.length>=bD&&d.shift(),d.push(y),a.value=!0,(!i||i.readyState===WebSocket.CLOSED||i.readyState===WebSocket.CLOSING)&&E(),!1)}function E(){l||u||(u=!0,i&&(i.onclose=null,i.close()),i=new WebSocket(TD(s)),i.onopen=()=>{u=!1,n.value=!0,a.value=!1,r.value=!1,o=0,b()},i.onmessage=y=>{let L;try{L=JSON.parse(y.data)}catch{return}R(L)},i.onclose=()=>{u=!1,n.value=!1,l||I()},i.onerror=()=>{})}function b(){if(!i||i.readyState!==WebSocket.OPEN||!d.length)return;const y=d;d=[];for(const L of y)i.send(JSON.stringify(L))}function I(){if(!l)if(a.value=!0,o++,o<=ED){const y=fD*Math.pow(2,o-1);c=setTimeout(E,y)}else r.value=!0,a.value=!1,c=setTimeout(()=>{l||(a.value=!0,E())},SD)}function R(y){switch(y.type){case"stream_start":t.onStreamStart();break;case"thinking_delta":t.onThinkingDelta(y.delta??"");break;case"thinking_end":t.onThinkingEnd();break;case"turn_thinking":t.onTurnThinking(y);break;case"planning_status":t.onPlanningStatus(y);break;case"plan_ready":t.onPlanReady(y);break;case"tool_started":t.onToolStarted(y);break;case"tool_call":t.onToolCall(y);break;case"terminal_output":t.onTerminalOutput(y);break;case"terminal_closed":t.onTerminalClosed(y);break;case"terminal_opened":t.onTerminalOpened(y);break;case"task_update":{const L=y.task_id,U=L?!!t.backgroundTasks[L]:!1;t.onTaskUpdate(y);const h=L?t.backgroundTasks[L]:null,N=`${y.tool??"task"} (${L})`;if(y.status==="running")!U&&h&&e.info({title:"Background task started",text:N});else if(U){const C={title:"Background task finished",text:`${N} — ${y.status}`};y.status==="completed"?e.success(C):e.error(C)}break}case"message_queued":t.onMessageQueued(y);break;case"stream_delta":t.onStreamDelta(y.delta??"");break;case"stream_end":t.onStreamEnd(y);break;case"stream_stopped":t.onStreamStopped();break;case"profile_switched":t.onProfileSwitched(y);break;case"compression_started":t.onCompressionStarted(y);break;case"context_compressed":t.onContextCompressed(y);break;case"error":t.onError(y);break;case"replay_start":t.onReplayStart();break;case"replay_end":t.onReplayEnd();break;case"heartbeat":break;case"recall_update":t.onRecallUpdate(y);break;case"session_sync":s&&!t.streaming&&t.reloadSession(s);break;case"mcp_status_update":y.status==="connected"?e.success({title:"MCP server connected",text:`${y.server_name} (${y.tool_count??"?"} tools)`}):e.error({title:"MCP server disconnected",text:y.server_name});break}}return fa(m),{connected:n,reconnecting:a,reconnectFailed:r,connect:_,disconnect:m,send:p}}const vD={key:0,class:"profile-badge"},CS={__name:"ProfileBadge",props:{profileId:{type:String,default:null},showAvatar:{type:Boolean,default:!0}},setup(t){const e=t,n=li(),a=ue(()=>e.profileId?n.getProfile(e.profileId):null),r={secretary:"secondary",server_admin:"warning",developer:"info"},i=ue(()=>r[e.profileId]||"secondary");function s(o){return o?o.split(/\s+/).map(c=>c[0]).join("").slice(0,2).toUpperCase():"?"}return(o,c)=>{const l=tt("GnAvatar"),u=tt("GnBadge");return a.value?(v(),x("div",vD,[t.showAvatar?(v(),ze(l,{key:0,size:"sm",initials:s(a.value.name)},null,8,["initials"])):J("",!0),ne(u,{variant:i.value},{default:Be(()=>[$e(X(a.value.name),1)]),_:1},8,["variant"])])):J("",!0)}}},RD=Object.freeze(Object.defineProperty({__proto__:null,default:CS},Symbol.toStringTag,{value:"Module"})),CD=["title"],yD={__name:"ContextBar",setup(t){const e=sn(),n=ue(()=>e.maxContextTokens?Math.min(100,Math.round(e.contextTokens/e.maxContextTokens*100)):0),a=ue(()=>n.value>=80?"is-crit":n.value>=60?"is-warn":"");function r(i){return i>=1e3?(i/1e3).toFixed(1).replace(".0","")+"k":String(i)}return(i,s)=>$(e).maxContextTokens>0?(v(),x("div",{key:0,class:"context-bar",title:`${r($(e).contextTokens)} / ${r($(e).maxContextTokens)} tokens`},[g("span",{class:Ge(["context-bar-pct",a.value])},X(n.value)+"%",3)],8,CD)):J("",!0)}},yS=ht(yD,[["__scopeId","data-v-6810168f"]]),ND=Object.freeze(Object.defineProperty({__proto__:null,default:yS},Symbol.toStringTag,{value:"Module"})),OD={class:"chat-header"},AD={class:"chat-header-info"},ID={key:0,class:"artifact-count"},DD={key:0,class:"recall-banner"},wD={class:"recall-text"},xD={__name:"ChatHeader",emits:["toggle-sidebar","toggle-artifacts"],setup(t,{emit:e}){const n=e,a=sn(),r=Un(),i=ue(()=>{var b;const E=r.sessions.find(I=>I.session_id===a.currentId);return(E==null?void 0:E.name)||(((b=a.currentId)==null?void 0:b.slice(0,8))??"Navi")}),s=ue(()=>a.artifacts.length),o=Y(!1),c=Y(""),l=Y(null);function u(){c.value=i.value,o.value=!0,Ht(()=>{var E,b;(E=l.value)==null||E.focus(),(b=l.value)==null||b.select()})}async function d(){if(!o.value)return;const E=a.currentId,b=c.value;if(o.value=!1,!E)return;const I=b===i.value?null:b.trim();try{const R=I===null?{name:i.value}:await Wh(E,I);R!=null&&R.name&&r.updateName(E,R.name)}catch(R){console.error("rename session failed",R)}}function _(E){return E?new Date(E).toLocaleString():""}st(()=>a.currentId,a.loadRecall,{immediate:!0});async function m(){if(a.currentId)try{await Qf(a.currentId),a.recall=null,r.updateRecallStatus(a.currentId,!1)}catch(E){console.error("cancel recall failed",E)}}async function p(){if(a.currentId)try{await Xf(a.currentId),await a.loadRecall()}catch(E){console.error("skip recall failed",E)}}return(E,b)=>{const I=tt("GnIconButton");return v(),x(Ue,null,[g("div",OD,[ne(I,{icon:"ph ph-sidebar",label:"Menu",class:"btn-sidebar-toggle",onClick:b[0]||(b[0]=R=>n("toggle-sidebar"))}),g("div",AD,[o.value?Ka((v(),x("input",{key:0,ref_key:"renameEl",ref:l,"onUpdate:modelValue":b[1]||(b[1]=R=>c.value=R),class:"chat-header-rename",type:"text",maxlength:"200",spellcheck:"false",onBlur:d,onKeydown:[b[2]||(b[2]=ea(ga(R=>o.value=!1,["prevent"]),["esc"])),b[3]||(b[3]=ea(ga(R=>{var y;return(y=l.value)==null?void 0:y.blur()},["prevent"]),["enter"]))]},null,544)),[[ai,c.value]]):(v(),x("span",{key:1,class:"chat-header-title",title:"Rename",onClick:u},X(i.value),1)),o.value?J("",!0):(v(),ze(CS,{key:2,"profile-id":$(a).currentProfileId,"show-avatar":!1},null,8,["profile-id"]))]),ne(yS),ne(I,{icon:"ph ph-files",label:"Artifacts",class:"btn-artifacts-toggle",onClick:b[4]||(b[4]=R=>n("toggle-artifacts"))},{default:Be(()=>[s.value?(v(),x("span",ID,X(s.value),1)):J("",!0)]),_:1})]),$(a).recall?(v(),x("div",DD,[b[7]||(b[7]=g("i",{class:"ph ph-clock"},null,-1)),g("span",wD," Scheduled "+X($(a).recall.call_type)+" recall at "+X(_($(a).recall.trigger_at)),1),g("button",{class:"recall-btn",title:"Cancel",onClick:m},[...b[5]||(b[5]=[g("i",{class:"ph ph-clock-slash"},null,-1)])]),$(a).recall.call_type==="recurring"?(v(),x("button",{key:0,class:"recall-btn",title:"Skip next",onClick:p},[...b[6]||(b[6]=[g("i",{class:"ph ph-skip-forward"},null,-1)])])):J("",!0)])):J("",!0)],64)}}},LD=ht(xD,[["__scopeId","data-v-47d78bd2"]]);function NS(){const t=Y(!1);async function e(n){var a;if(n){if((a=navigator.clipboard)!=null&&a.writeText)await navigator.clipboard.writeText(n);else{const r=document.createElement("textarea");r.value=n,r.style.cssText="position:fixed;opacity:0",document.body.appendChild(r),r.select();try{document.execCommand("copy")}finally{document.body.removeChild(r)}}t.value=!0,setTimeout(()=>{t.value=!1},1500)}}return{copied:t,copy:e}}const MD={class:"msg-user-wrap"},kD={key:0,class:"msg-recall-badge"},PD=["innerHTML"],UD={key:1,class:"msg-user-attachments"},FD=["src","onClick"],BD={class:"msg-user-footer"},GD={key:0,class:"msg-time msg-time--user"},YD={__name:"UserMessage",props:{msg:{type:Object,required:!0},isFlashing:{type:Boolean,default:!1}},setup(t){const e=t,n=ue(()=>e.msg.time),a=ed(n),{open:r}=ci(),{copied:i,copy:s}=NS();function o(l){return l.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function c(l){if(!l)return"";const u=l.split(` +`);let d=[],_=[];for(const E of u)E.startsWith("> ")?d.push(o(E.slice(2))):E.trim()&&_.push(o(E));const m=d.length?`
    ${d.join("
    ")}
    `:"",p=_.join(" ");return m+p}return(l,u)=>{var _,m;const d=tt("GnIconButton");return v(),x("div",{class:Ge(["msg-user",{"msg-user--recall":t.msg.isRecall}])},[g("div",MD,[g("div",{class:Ge(["msg-user-bubble",{"msg-flash":e.isFlashing}])},[t.msg.isRecall?(v(),x("div",kD,[...u[1]||(u[1]=[g("i",{class:"ph ph-clock"},null,-1),g("span",null,"Scheduled recall",-1)])])):J("",!0),g("div",{class:"msg-user-text",innerHTML:c(t.msg.text)},null,8,PD),(_=t.msg.images)!=null&&_.length||(m=t.msg.files)!=null&&m.length?(v(),x("div",UD,[(v(!0),x(Ue,null,Dt(t.msg.images,(p,E)=>(v(),x("img",{key:`img-${E}`,src:p,class:"msg-user-image",onClick:b=>$(r)(p)},null,8,FD))),128)),(v(!0),x(Ue,null,Dt(t.msg.files,(p,E)=>(v(),x("span",{key:`file-${E}`,class:"msg-user-file-pill"},[u[2]||(u[2]=g("i",{class:"ph ph-file"},null,-1)),$e(" "+X(p.name),1)]))),128))])):J("",!0)],2),g("div",BD,[$(a)?(v(),x("span",GD,X($(a)),1)):J("",!0),ne(d,{icon:$(i)?"ph ph-check":"ph ph-copy",label:$(i)?"Copied!":"Copy",class:"msg-copy-btn",onClick:u[0]||(u[0]=p=>$(s)(t.msg.text))},null,8,["icon","label"])])])],2)}}},$D={key:0,class:"spinner"},qD={class:"thinking-body"},wu={__name:"ThinkingCard",props:{msg:{type:Object,required:!0}},setup(t){const e=t,n=Y(null),a=ue(()=>{var i;return(((i=e.msg.thinking)==null?void 0:i.text)??"").replace(/^\s*/i,"").replace(/\s*<\/thought>\s*$/i,"").replace(/^thought\s*:?\s*\n+/i,"").trim()});return(r,i)=>(v(),x("details",{ref_key:"detailsEl",ref:n,class:"thinking-card"},[g("summary",null,[i[0]||(i[0]=g("i",{class:"ph ph-brain"},null,-1)),i[1]||(i[1]=$e(" Thinking ",-1)),t.msg.thinking.done?J("",!0):(v(),x("span",$D)),i[2]||(i[2]=g("i",{class:"ph ph-caret-down thinking-chevron"},null,-1))]),g("div",qD,X(a.value),1)],512))}};/*! @license DOMPurify 3.4.15 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.15/LICENSE */function Zg(t,e){(e==null||e>t.length)&&(e=t.length);for(var n=0,a=Array(e);n2?a-2:0),i=2;i1?n-1:0),r=1;r"u"?null:Wt(BigInt.prototype.toString),aE=typeof Symbol>"u"?null:Wt(Symbol.prototype.toString),hn=Wt(Object.prototype.hasOwnProperty),Mr=Wt(Object.prototype.toString),tn=Wt(RegExp.prototype.test),Va=aw(TypeError);function Wt(t){return function(e){e instanceof RegExp&&(e.lastIndex=0);for(var n=arguments.length,a=new Array(n>1?n-1:0),r=1;r2&&arguments[2]!==void 0?arguments[2]:Br;if(Jg&&Jg(t,null),!Sr(e))return t;let a=e.length;for(;a--;){let r=e[a];if(typeof r=="string"){const i=n(r);i!==r&&(QD(e)||(e[a]=i),r=i)}t[r]=!0}return t}function rw(t){for(let e=0;e/g),dw=Xt(/\${[\w\W]*/g),_w=Xt(/^data-[\-\w.\u00B7-\uFFFF]+$/),pw=Xt(/^aria-[\-\w]+$/),lE=Xt(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),mw=Xt(/^(?:\w+script|data):/i),gw=Xt(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),Ew=Xt(/^html$/i),fw=Xt(/^[a-z][.\w]*(-[.\w]+)+$/i),cE=Xt(/<[/\w!]/g),uE=Xt(/<[/\w]/g),Sw=Xt(/<\/no(script|embed|frames)/i),bw=Xt(/\/>/i),Rn={element:1,attribute:2,text:3,cdataSection:4,entityReference:5,entityNode:6,processingInstruction:7,comment:8,document:9,documentType:10,documentFragment:11,notation:12},IS=["style","script","xmp","iframe","noembed","noframes","plaintext","noscript"],Tw=Kt(ft({},IS)),hw=(function(){const t={};return Wa(IS,e=>{t[e]=Xt(new RegExp("])","i"))}),Kt(t)})(),vw=function(){return typeof window>"u"?null:window},Rw=function(e,n){if(typeof e!="object"||typeof e.createPolicy!="function")return null;let a=null;const r="data-tt-policy-suffix";n&&n.hasAttribute(r)&&(a=n.getAttribute(r));const i="dompurify"+(a?"#"+a:"");try{return e.createPolicy(i,{createHTML(s){return s},createScriptURL(s){return s}})}catch{return console.warn("TrustedTypes policy "+i+" could not be created."),null}},dE=function(){return{afterSanitizeAttributes:[],afterSanitizeElements:[],afterSanitizeShadowDOM:[],beforeSanitizeAttributes:[],beforeSanitizeElements:[],beforeSanitizeShadowDOM:[],uponSanitizeAttribute:[],uponSanitizeElement:[],uponSanitizeShadowNode:[]}},ya=function(e,n,a,r){return hn(e,n)&&Sr(e[n])?ft(r.base?Cn(r.base):{},e[n],r.transform):a},uu=function(e,n,a){const r=hn(e,n)?e[n]:void 0;return r&&typeof r=="object"?Cn(r):a()};function DS(){let t=arguments.length>0&&arguments[0]!==void 0?arguments[0]:vw();const e=ie=>DS(ie);if(e.version="3.4.15",e.removed=[],!t||!t.document||t.document.nodeType!==Rn.document||!t.Element)return e.isSupported=!1,e;let n=t.document;const a=n,r=a.currentScript;t.DocumentFragment;const i=t.HTMLTemplateElement,s=t.Node,o=t.Element,c=t.NodeFilter,l=t.NamedNodeMap;l===void 0&&(t.NamedNodeMap||t.MozNamedAttrMap),t.HTMLFormElement;const u=t.DOMParser,d=t.trustedTypes,_=o.prototype,m=wn(_,"cloneNode"),p=wn(_,"remove"),E=wn(_,"removeAttributeNode"),b=wn(_,"nextSibling"),I=wn(_,"childNodes"),R=wn(_,"parentNode"),y=wn(_,"shadowRoot"),L=wn(_,"attributes"),U=s&&s.prototype?wn(s.prototype,"nodeType"):null,h=s&&s.prototype?wn(s.prototype,"nodeName"):null,N=s&&s.prototype?wn(s.prototype,"ownerDocument"):null,C=function(S){return U?U(S):S.nodeType},f=function(S){return h?h(S):S.nodeName};if(typeof i=="function"){const ie=n.createElement("template");ie.content&&ie.content.ownerDocument&&(n=ie.content.ownerDocument)}let A,w="",F,j=!1,_e=0;const be=function(){if(_e>0)throw Va('A configured TRUSTED_TYPES_POLICY callback (createHTML or createScriptURL) must not call DOMPurify.sanitize, as that causes infinite recursion. Do not pass a policy whose callbacks wrap DOMPurify as TRUSTED_TYPES_POLICY; see the "DOMPurify and Trusted Types" section of the README.')},oe=function(S){be(),_e++;try{return A.createHTML(S)}finally{_e--}},pe=function(S){be(),_e++;try{return A.createScriptURL(S)}finally{_e--}},Ce=function(){return j||(F=Rw(d,r),j=!0),F},ot=n,lt=ot.implementation,at=ot.createNodeIterator,We=ot.createDocumentFragment,Ae=ot.getElementsByTagName,He=a.importNode;let ke=dE();e.isSupported=typeof OS=="function"&&typeof R=="function"&<&<.createHTMLDocument!==void 0;const rt=cw,je=uw,Ke=dw,Et=_w,ut=pw,bt=mw,D=gw,P=fw;let z=lE,K=null;const Z=ft({},[...rE,...su,...ou,...lu,...iE]);let W=null;const de=ft({},[...sE,...cu,...oE,...Si]);let ae=Object.seal(pr(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),re=null,ee=null;const Ne=Object.seal(pr(null,{tagCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeCheck:{writable:!0,configurable:!1,enumerable:!0,value:null}}));let ce=!0,Re=!0,ye=!1,Fe=!0,qe=!1,Qe=!0,et=!1,dt=!1,Lt=null,Mt=null,Vt=!1,Ut=!1,vt=!1,O=!1,G=!0,Q=!1;const fe="user-content-";let he=!0,we=!1,Pe={},Je=null;const k=ft({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","selectedcontent","style","svg","template","thead","title","video","xmp"]);let V=null;const se=ft({},["audio","video","img","source","image","track"]);let Ie=null;const mt=ft({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),_t="http://www.w3.org/1998/Math/MathML",ve="http://www.w3.org/2000/svg",me="http://www.w3.org/1999/xhtml";let De=me,it=!1,ct=null;const Ft=ft({},[_t,ve,me],iu),kt=Kt(["mi","mo","mn","ms","mtext"]);let on=ft({},kt);const Qt=Kt(["annotation-xml"]);let Mn=ft({},Qt);const lr=ft({},["title","style","font","a","script"]);let B=null;const q=["application/xhtml+xml","text/html"],Oe="text/html";let Te=null,Se=null;const $t=n.createElement("form"),Yt=function(S){return S instanceof RegExp||S instanceof Function},Zt=function(){let S=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};if(Se&&Se===S)return;(!S||typeof S!="object")&&(S={}),S=Cn(S),B=q.indexOf(S.PARSER_MEDIA_TYPE)===-1?Oe:S.PARSER_MEDIA_TYPE,Te=B==="application/xhtml+xml"?iu:Br,K=ya(S,"ALLOWED_TAGS",Z,{transform:Te}),W=ya(S,"ALLOWED_ATTR",de,{transform:Te}),ct=ya(S,"ALLOWED_NAMESPACES",Ft,{transform:iu}),Ie=ya(S,"ADD_URI_SAFE_ATTR",mt,{transform:Te,base:mt}),V=ya(S,"ADD_DATA_URI_TAGS",se,{transform:Te,base:se}),Je=ya(S,"FORBID_CONTENTS",k,{transform:Te}),re=ya(S,"FORBID_TAGS",Cn({}),{transform:Te}),ee=ya(S,"FORBID_ATTR",Cn({}),{transform:Te}),Pe=hn(S,"USE_PROFILES")?S.USE_PROFILES&&typeof S.USE_PROFILES=="object"?Cn(S.USE_PROFILES):S.USE_PROFILES:!1,ce=S.ALLOW_ARIA_ATTR!==!1,Re=S.ALLOW_DATA_ATTR!==!1,ye=S.ALLOW_UNKNOWN_PROTOCOLS||!1,Fe=S.ALLOW_SELF_CLOSE_IN_ATTR!==!1,qe=S.SAFE_FOR_TEMPLATES||!1,Qe=S.SAFE_FOR_XML!==!1,et=S.WHOLE_DOCUMENT||!1,Ut=S.RETURN_DOM||!1,vt=S.RETURN_DOM_FRAGMENT||!1,O=S.RETURN_TRUSTED_TYPE||!1,Vt=S.FORCE_BODY||!1,G=S.SANITIZE_DOM!==!1,Q=S.SANITIZE_NAMED_PROPS||!1,he=S.KEEP_CONTENT!==!1,we=S.IN_PLACE||!1,z=sw(S.ALLOWED_URI_REGEXP)?S.ALLOWED_URI_REGEXP:lE,De=typeof S.NAMESPACE=="string"?S.NAMESPACE:me,on=uu(S,"MATHML_TEXT_INTEGRATION_POINTS",()=>ft({},kt)),Mn=uu(S,"HTML_INTEGRATION_POINTS",()=>ft({},Qt));const M=uu(S,"CUSTOM_ELEMENT_HANDLING",()=>pr(null));if(ae=pr(null),hn(M,"tagNameCheck")&&Yt(M.tagNameCheck)&&(ae.tagNameCheck=M.tagNameCheck),hn(M,"attributeNameCheck")&&Yt(M.attributeNameCheck)&&(ae.attributeNameCheck=M.attributeNameCheck),hn(M,"allowCustomizedBuiltInElements")&&typeof M.allowCustomizedBuiltInElements=="boolean"&&(ae.allowCustomizedBuiltInElements=M.allowCustomizedBuiltInElements),Xt(ae),qe&&(Re=!1),vt&&(Ut=!0),Pe&&(K=ft({},iE),W=pr(null),Pe.html===!0&&(ft(K,rE),ft(W,sE)),Pe.svg===!0&&(ft(K,su),ft(W,cu),ft(W,Si)),Pe.svgFilters===!0&&(ft(K,ou),ft(W,cu),ft(W,Si)),Pe.mathMl===!0&&(ft(K,lu),ft(W,oE),ft(W,Si))),Ne.tagCheck=null,Ne.attributeCheck=null,hn(S,"ADD_TAGS")&&(typeof S.ADD_TAGS=="function"?Ne.tagCheck=S.ADD_TAGS:Sr(S.ADD_TAGS)&&(K===Z&&(K=Cn(K)),ft(K,S.ADD_TAGS,Te))),hn(S,"ADD_ATTR")&&(typeof S.ADD_ATTR=="function"?Ne.attributeCheck=S.ADD_ATTR:Sr(S.ADD_ATTR)&&(W===de&&(W=Cn(W)),ft(W,S.ADD_ATTR,Te))),hn(S,"ADD_FORBID_CONTENTS")&&Sr(S.ADD_FORBID_CONTENTS)&&(Je===k&&(Je=Cn(Je)),ft(Je,S.ADD_FORBID_CONTENTS,Te)),he&&(K["#text"]=!0),et&&ft(K,["html","head","body"]),K.table&&(ft(K,["tbody"]),delete re.tbody),S.TRUSTED_TYPES_POLICY){if(typeof S.TRUSTED_TYPES_POLICY.createHTML!="function")throw Va('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if(typeof S.TRUSTED_TYPES_POLICY.createScriptURL!="function")throw Va('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');const H=A;A=S.TRUSTED_TYPES_POLICY;try{w=oe("")}catch(te){throw A=H,te}}else S.TRUSTED_TYPES_POLICY===null?(A=void 0,w=""):(A===void 0&&(A=Ce()),A&&typeof w=="string"&&(w=oe("")));Kt&&Kt(S),Se=S},jt=ft({},[...su,...ou,...ow]),In=ft({},[...lu,...lw]),ba=function(S,M,H){return M.namespaceURI===me?S==="svg":M.namespaceURI===_t?S==="svg"&&(H==="annotation-xml"||on[H]):!!jt[S]},ta=function(S,M,H){return M.namespaceURI===me?S==="math":M.namespaceURI===ve?S==="math"&&Mn[H]:!!In[S]},Ar=function(S,M,H){return M.namespaceURI===ve&&!Mn[H]||M.namespaceURI===_t&&!on[H]?!1:!In[S]&&(lr[S]||!jt[S])},$n=function(S){let M=R(S);(!M||!M.tagName)&&(M={namespaceURI:De,tagName:"template"});const H=Br(S.tagName),te=Br(M.tagName);return ct[S.namespaceURI]?S.namespaceURI===ve?ba(H,M,te):S.namespaceURI===_t?ta(H,M,te):S.namespaceURI===me?Ar(H,M,te):!!(B==="application/xhtml+xml"&&ct[S.namespaceURI]):!1},kn=function(S){xr(e.removed,{element:S});try{R(S).removeChild(S)}catch{if(p(S),!R(S))throw Va("a node selected for removal could not be detached from its tree and cannot be safely returned; refusing to sanitize in place")}},le=function(S,M,H){try{E(S,M)}catch{try{S.removeAttribute(H)}catch{}}},xe=function(S){Pt(S);const M=I(S);if(M){const te=[];Wa(M,Ee=>{xr(te,Ee)}),Wa(te,Ee=>{try{p(Ee)}catch{}})}const H=L(S);if(H)for(let te=H.length-1;te>=0;--te){const Ee=H[te],Le=Ee&&Ee.name;typeof Le=="string"&&le(S,Ee,Le)}},Xe=function(S,M,H){if(!H)try{H=M.getAttributeNode(S)}catch{H=null}xr(e.removed,{attribute:H||null,from:M});try{H?E(M,H):M.removeAttribute(S)}catch{try{M.removeAttribute(S)}catch{}}if(S==="is")if(Ut||vt)try{kn(M)}catch{}else try{M.setAttribute(S,"")}catch{}},Nt=function(S){const M=L(S);if(M)for(let H=M.length-1;H>=0;--H){const te=M[H],Ee=te&&te.name;typeof Ee!="string"||W[Te(Ee)]||le(S,te,Ee)}},Pt=function(S){const M=[S];for(;M.length>0;){const H=M.pop();C(H)===Rn.element&&Nt(H);const Ee=I(H);if(Ee)for(let Le=Ee.length-1;Le>=0;--Le)M.push(Ee[Le])}},ln=function(S,M){return Qe?S==="patchsrc"?!0:S==="for"&&M!=="label"&&M!=="output":!1},Pn=function(S){if(!Qe)return;const M=[S];for(;M.length>0;){const H=M.pop(),te=C(H);if(te===Rn.processingInstruction||te===Rn.comment&&tn(uE,H.data)){try{p(H)}catch{}continue}if(te===Rn.element){const Le=H,Ot=Te(f(H));try{Le.hasAttribute&&Le.hasAttribute("patchsrc")&&Le.removeAttribute("patchsrc"),Le.hasAttribute&&Le.hasAttribute("for")&&ln("for",Ot)&&Le.removeAttribute("for")}catch{}}const Ee=I(H);if(Ee)for(let Le=Ee.length-1;Le>=0;--Le)M.push(Ee[Le])}},Ta=function(S){let M=null,H=null;if(Vt)S=""+S;else{const Le=eE(S,/^[\r\n\t ]+/);H=Le&&Le[0]}B==="application/xhtml+xml"&&De===me&&(S=''+S+"");const te=A?oe(S):S;if(De===me)try{M=new u().parseFromString(te,B)}catch{}if(!M||!M.documentElement){M=lt.createDocument(De,"template",null);try{M.documentElement.innerHTML=it?w:te}catch{}}const Ee=M.body||M.documentElement;return S&&H&&Ee.insertBefore(n.createTextNode(H),Ee.childNodes[0]||null),De===me?Ae.call(M,et?"html":"body")[0]:et?M.documentElement:Ee},Jt=function(S){const M=N?N(S):S.ownerDocument;return at.call(M||S,S,c.SHOW_ELEMENT|c.SHOW_COMMENT|c.SHOW_TEXT|c.SHOW_PROCESSING_INSTRUCTION|c.SHOW_CDATA_SECTION,null)},en=function(S){return S=Lr(S,rt," "),S=Lr(S,je," "),S=Lr(S,Ke," "),S},Pa=function(S){var M;S.normalize();const H=N?N(S):S.ownerDocument,te=at.call(H||S,S,c.SHOW_TEXT|c.SHOW_COMMENT|c.SHOW_CDATA_SECTION|c.SHOW_PROCESSING_INSTRUCTION,null);let Ee=te.nextNode();for(;Ee;)Ee.data=en(Ee.data),Ee=te.nextNode();const Le=(M=S.querySelectorAll)===null||M===void 0?void 0:M.call(S,"template");Le&&Wa(Le,Ot=>{qn(Ot.content)&&Pa(Ot.content)})},ha=function(S){const M=h?h(S):null;return typeof M!="string"||Te(M)!=="form"?!1:typeof S.nodeName!="string"||typeof S.textContent!="string"||typeof S.removeChild!="function"||S.attributes!==L(S)||typeof S.removeAttribute!="function"||typeof S.removeAttributeNode!="function"||typeof S.getAttributeNode!="function"||typeof S.setAttribute!="function"||typeof S.namespaceURI!="string"||typeof S.insertBefore!="function"||typeof S.hasChildNodes!="function"||S.nodeType!==U(S)||S.childNodes!==I(S)},qn=function(S){if(!U||typeof S!="object"||S===null)return!1;try{return U(S)===Rn.documentFragment}catch{return!1}},va=function(S){if(!U||typeof S!="object"||S===null)return!1;try{return typeof U(S)=="number"}catch{return!1}};function vn(ie,S,M){ie.length!==0&&Wa(ie,H=>{H.call(e,S,M,Se)})}const di=function(S,M){return!!(Qe&&S.hasChildNodes()&&!va(S.firstElementChild)&&tn(cE,S.textContent)&&tn(cE,S.innerHTML)||Qe&&S.namespaceURI===me&&Tw[M]&&(va(S.firstElementChild)||typeof S.textContent=="string"&&tn(hw[M],S.textContent))||S.nodeType===Rn.processingInstruction||Qe&&S.nodeType===Rn.comment&&tn(uE,S.data))},Ua=function(S,M){if(S instanceof RegExp)return tn(S,M);if(S instanceof Function){for(var H=arguments.length,te=new Array(H>2?H-2:0),Ee=2;Ee=0;--Ot){const wt=S===H?m(Ee[Ot],!0):Ee[Ot];te.insertBefore(wt,b(S))}}}return kn(S),!0},Ba=function(S,M,H,te){return S.length===0?M:M===H||M===te?Cn(M):M},cn=function(S,M){return S===M||R(S)!==null?!1:(we&&Pt(S),!0)},cr=function(S,M){if(vn(ke.beforeSanitizeElements,S,null),cn(S,M))return!0;if(ha(S))return kn(S),!0;const H=Te(f(S));if(K=Ba(ke.uponSanitizeElement,K,Z,Lt),vn(ke.uponSanitizeElement,S,{tagName:H,allowedTags:K}),cn(S,M))return!0;if(di(S,H))return kn(S),!0;if(re[H]||!(Ne.tagCheck instanceof Function&&Ne.tagCheck(H))&&!K[H]){const Ee=Fa(S,H,M);return Ee===!1&&vn(ke.afterSanitizeElements,S,null),Ee}if(C(S)===Rn.element&&!$n(S)||(H==="noscript"||H==="noembed"||H==="noframes")&&tn(Sw,S.innerHTML))return kn(S),!0;if(qe&&S.nodeType===Rn.text){const Ee=en(S.textContent);S.textContent!==Ee&&(xr(e.removed,{element:S.cloneNode()}),S.textContent=Ee)}return vn(ke.afterSanitizeElements,S,null),!1},Ra=function(S,M,H){if(ee[M]||ln(M,S)||G&&(M==="id"||M==="name")&&(H in n||H in $t))return!1;const te=W[M]||Ne.attributeCheck instanceof Function&&Ne.attributeCheck(M,S);return Re&&tn(Et,M)||ce&&tn(ut,M)?!0:te?Ie[M]||tn(z,Lr(H,D,""))||(M==="src"||M==="xlink:href"||M==="href")&&S!=="script"&&tE(H,"data:")===0&&V[S]||ye&&!tn(bt,Lr(H,D,""))?!0:!H:Ga(S)&&Ua(ae.tagNameCheck,S)&&Ua(ae.attributeNameCheck,M,S)||M==="is"&&ae.allowCustomizedBuiltInElements&&Ua(ae.tagNameCheck,H)},Ve=ft({},["annotation-xml","color-profile","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","missing-glyph"]),Ga=function(S){return!Ve[Br(S)]&&tn(P,S)},qt=function(S,M,H,te){if(A&&typeof d=="object"&&typeof d.getAttributeType=="function"&&!H)switch(d.getAttributeType(S,M)){case"TrustedHTML":return oe(te);case"TrustedScriptURL":return pe(te)}return te},Tt=function(S,M,H,te){try{return H?S.setAttributeNS(H,M,te):S.setAttribute(M,te),ha(S)?(kn(S),!1):!0}catch{return Xe(M,S),!1}},Hn=function(S){vn(ke.beforeSanitizeAttributes,S,null);const M=S.attributes;if(!M||ha(S))return;W=Ba(ke.uponSanitizeAttribute,W,de,Mt);const H={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:W,forceKeepAttr:void 0};let te=M.length;const Ee=Te(S.nodeName);for(;te--;){const Le=M[te],Ot=Le.name,wt=Le.namespaceURI,bn=Le.value,Tn=Te(Ot),_s=bn;let dn=Ot==="value"?_s:ew(_s),Ed=!1;if(H.attrName=Tn,H.attrValue=dn,H.keepAttr=!0,H.forceKeepAttr=void 0,vn(ke.uponSanitizeAttribute,S,H),dn=H.attrValue,Q&&(Tn==="id"||Tn==="name")&&tE(dn,fe)!==0&&(Xe(Ot,S,Le),dn=fe+dn,Ed=!0),Qe&&tn(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i,dn)){Xe(Ot,S,Le);continue}if(Tn==="attributename"&&eE(dn,"href")){Xe(Ot,S,Le);continue}if(!H.forceKeepAttr){if(!H.keepAttr){Xe(Ot,S,Le);continue}if(!Fe&&tn(bw,dn)){Xe(Ot,S,Le);continue}if(qe&&(dn=en(dn)),!Ra(Ee,Tn,dn)){Xe(Ot,S,Le);continue}dn=qt(Ee,Tn,wt,dn),dn!==_s&&Tt(S,Ot,wt,dn)&&Ed&&jg(e.removed)}}vn(ke.afterSanitizeAttributes,S,null)},un=function(S){let M=null;const H=Jt(S);for(vn(ke.beforeSanitizeShadowDOM,S,null);M=H.nextNode();)if(vn(ke.uponSanitizeShadowNode,M,null),cr(M,S),Hn(M),qn(M.content)&&un(M.content),C(M)===Rn.element){const te=y(M);qn(te)&&(na(te),un(te))}vn(ke.afterSanitizeShadowDOM,S,null)},na=function(S){const M=[{node:S,shadow:null}];for(;M.length>0;){const H=M.pop();if(H.shadow){un(H.shadow);continue}const te=H.node,Le=C(te)===Rn.element,Ot=I(te);if(Ot)for(let wt=Ot.length-1;wt>=0;--wt)M.push({node:Ot[wt],shadow:null});if(Le){const wt=h?h(te):null;if(typeof wt=="string"&&Te(wt)==="template"){const bn=te.content;qn(bn)&&M.push({node:bn,shadow:null})}}if(Le){const wt=y(te);qn(wt)&&M.push({node:null,shadow:wt},{node:wt,shadow:null})}}};return e.sanitize=function(ie){let S=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},M=null,H=null,te=null,Ee=null;if(it=!ie,it&&(ie=""),typeof ie!="string"&&!va(ie)&&(ie=iw(ie),typeof ie!="string"))throw Va("dirty is not a string, aborting");if(!e.isSupported)return ie;dt?(K=Lt,W=Mt):Zt(S),(ke.uponSanitizeElement.length>0||ke.uponSanitizeAttribute.length>0)&&(K=Cn(K)),ke.uponSanitizeAttribute.length>0&&(W=Cn(W)),e.removed=[];const Le=we&&typeof ie!="string"&&va(ie);if(Le){Pn(ie);const bn=f(ie);if(typeof bn=="string"){const Tn=Te(bn);if(!K[Tn]||re[Tn])throw xe(ie),Va("root node is forbidden and cannot be sanitized in-place")}if(ha(ie))throw xe(ie),Va("root node is clobbered and cannot be sanitized in-place");try{na(ie)}catch(Tn){throw xe(ie),Tn}}else if(va(ie))M=Ta(""),H=M.ownerDocument.importNode(ie,!0),H.nodeType===Rn.element&&H.nodeName==="BODY"||H.nodeName==="HTML"?M=H:M.appendChild(H),na(M);else{if(!Ut&&!qe&&!et&&ie.indexOf("<")===-1)return A&&O?oe(ie):ie;if(M=Ta(ie),!M)return Ut?null:O?w:""}M&&Vt&&kn(M.firstChild);const Ot=Le?ie:M;try{const bn=Jt(Ot);for(;te=bn.nextNode();)cr(te,Ot),Hn(te),qn(te.content)&&un(te.content)}catch(bn){throw Le&&(xe(ie),Wa(e.removed,Tn=>{Tn.element&&Pt(Tn.element)})),bn}if(Le)return Wa(e.removed,bn=>{bn.element&&Pt(bn.element)}),qe&&Pa(ie),ie;if(Ut){if(qe&&Pa(M),vt)for(Ee=We.call(M.ownerDocument);M.firstChild;)Ee.appendChild(M.firstChild);else Ee=M;return(W.shadowroot||W.shadowrootmode)&&(Ee=He.call(a,Ee,!0)),Ee}let wt=et?M.outerHTML:M.innerHTML;return et&&K["!doctype"]&&M.ownerDocument&&M.ownerDocument.doctype&&M.ownerDocument.doctype.name&&tn(Ew,M.ownerDocument.doctype.name)&&(wt=" +`+wt),qe&&(wt=en(wt)),A&&O?oe(wt):wt},e.setConfig=function(){let ie=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};Zt(ie),dt=!0,Lt=K,Mt=W},e.clearConfig=function(){Se=null,dt=!1,Lt=null,Mt=null,A=F,w=""},e.isValidAttribute=function(ie,S,M){Se||Zt({});const H=Te(ie),te=Te(S);return Ra(H,te,M)},e.addHook=function(ie,S){typeof S=="function"&&hn(ke,ie)&&xr(ke[ie],S)},e.removeHook=function(ie,S){if(hn(ke,ie)){if(S!==void 0){const M=JD(ke[ie],S);return M===-1?void 0:jD(ke[ie],M,1)[0]}return jg(ke[ie])}},e.removeHooks=function(ie){hn(ke,ie)&&(ke[ie]=[])},e.removeAllHooks=function(){ke=dE()},e}var Cw=DS();function rd(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var or=rd();function wS(t){or=t}var Kr={exec:()=>null};function yt(t,e=""){let n=typeof t=="string"?t:t.source;const a={replace:(r,i)=>{let s=typeof i=="string"?i:i.source;return s=s.replace(En.caret,"$1"),n=n.replace(r,s),a},getRegex:()=>new RegExp(n,e)};return a}var En={codeRemoveIndent:/^(?: {1,4}| {0,3}\t)/gm,outputLinkReplace:/\\([\[\]])/g,indentCodeCompensation:/^(\s+)(?:```)/,beginningSpace:/^\s+/,endingHash:/#$/,startingSpaceChar:/^ /,endingSpaceChar:/ $/,nonSpaceChar:/[^ ]/,newLineCharGlobal:/\n/g,tabCharGlobal:/\t/g,multipleSpaceGlobal:/\s+/g,blankLine:/^[ \t]*$/,doubleBlankLine:/\n[ \t]*\n[ \t]*$/,blockquoteStart:/^ {0,3}>/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceTabs:/^\t+/,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] /,listReplaceTask:/^\[[ xX]\] +/,anyLine:/\n.*\n/,hrefBrackets:/^<(.*)>$/,tableDelimiter:/[:|]/,tableAlignChars:/^\||\| *$/g,tableRowBlankLine:/\n[ \t]*$/,tableAlignRight:/^ *-+: *$/,tableAlignCenter:/^ *:-+: *$/,tableAlignLeft:/^ *:-+ *$/,startATag:/^/i,startPreScriptTag:/^<(pre|code|kbd|script)(\s|>)/i,endPreScriptTag:/^<\/(pre|code|kbd|script)(\s|>)/i,startAngleBracket:/^$/,pedanticHrefTitle:/^([^'"]*[^\s])\s+(['"])(.*)\2/,unicodeAlphaNumeric:/[\p{L}\p{N}]/u,escapeTest:/[&<>"']/,escapeReplace:/[&<>"']/g,escapeTestNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,escapeReplaceNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,unescapeTest:/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:t=>new RegExp(`^( {0,3}${t})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:t=>new RegExp(`^ {0,${Math.min(3,t-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`),hrRegex:t=>new RegExp(`^ {0,${Math.min(3,t-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),fencesBeginRegex:t=>new RegExp(`^ {0,${Math.min(3,t-1)}}(?:\`\`\`|~~~)`),headingBeginRegex:t=>new RegExp(`^ {0,${Math.min(3,t-1)}}#`),htmlBeginRegex:t=>new RegExp(`^ {0,${Math.min(3,t-1)}}<(?:[a-z].*>|!--)`,"i")},yw=/^(?:[ \t]*(?:\n|$))+/,Nw=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,Ow=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,ui=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,Aw=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,id=/(?:[*+-]|\d{1,9}[.)])/,xS=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,LS=yt(xS).replace(/bull/g,id).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/\|table/g,"").getRegex(),Iw=yt(xS).replace(/bull/g,id).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).replace(/table/g,/ {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(),sd=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,Dw=/^[^\n]+/,od=/(?!\s*\])(?:\\.|[^\[\]\\])+/,ww=yt(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",od).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),xw=yt(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g,id).getRegex(),cs="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",ld=/|$))/,Lw=yt("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$))","i").replace("comment",ld).replace("tag",cs).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),MS=yt(sd).replace("hr",ui).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("|table","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",cs).getRegex(),Mw=yt(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",MS).getRegex(),cd={blockquote:Mw,code:Nw,def:ww,fences:Ow,heading:Aw,hr:ui,html:Lw,lheading:LS,list:xw,newline:yw,paragraph:MS,table:Kr,text:Dw},_E=yt("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",ui).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("blockquote"," {0,3}>").replace("code","(?: {4}| {0,3} )[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",cs).getRegex(),kw={...cd,lheading:Iw,table:_E,paragraph:yt(sd).replace("hr",ui).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",_E).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",cs).getRegex()},Pw={...cd,html:yt(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment",ld).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:Kr,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:yt(sd).replace("hr",ui).replace("heading",` *#{1,6} *[^ +]`).replace("lheading",LS).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},Uw=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,Fw=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,kS=/^( {2,}|\\)\n(?!\s*$)/,Bw=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\]*?>/g,FS=/^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/,Hw=yt(FS,"u").replace(/punct/g,us).getRegex(),Vw=yt(FS,"u").replace(/punct/g,US).getRegex(),BS="^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)",zw=yt(BS,"gu").replace(/notPunctSpace/g,PS).replace(/punctSpace/g,ud).replace(/punct/g,us).getRegex(),Ww=yt(BS,"gu").replace(/notPunctSpace/g,$w).replace(/punctSpace/g,Yw).replace(/punct/g,US).getRegex(),Kw=yt("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,PS).replace(/punctSpace/g,ud).replace(/punct/g,us).getRegex(),Qw=yt(/\\(punct)/,"gu").replace(/punct/g,us).getRegex(),Xw=yt(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme",/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email",/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(),Zw=yt(ld).replace("(?:-->|$)","-->").getRegex(),Jw=yt("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment",Zw).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),Fi=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,jw=yt(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label",Fi).replace("href",/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),GS=yt(/^!?\[(label)\]\[(ref)\]/).replace("label",Fi).replace("ref",od).getRegex(),YS=yt(/^!?\[(ref)\](?:\[\])?/).replace("ref",od).getRegex(),ex=yt("reflink|nolink(?!\\()","g").replace("reflink",GS).replace("nolink",YS).getRegex(),dd={_backpedal:Kr,anyPunctuation:Qw,autolink:Xw,blockSkip:qw,br:kS,code:Fw,del:Kr,emStrongLDelim:Hw,emStrongRDelimAst:zw,emStrongRDelimUnd:Kw,escape:Uw,link:jw,nolink:YS,punctuation:Gw,reflink:GS,reflinkSearch:ex,tag:Jw,text:Bw,url:Kr},tx={...dd,link:yt(/^!?\[(label)\]\((.*?)\)/).replace("label",Fi).getRegex(),reflink:yt(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",Fi).getRegex()},Mu={...dd,emStrongRDelimAst:Ww,emStrongLDelim:Vw,url:yt(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,"i").replace("email",/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),_backpedal:/(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":">",'"':""","'":"'"},pE=t=>ax[t];function Wn(t,e){if(e){if(En.escapeTest.test(t))return t.replace(En.escapeReplace,pE)}else if(En.escapeTestNoEncode.test(t))return t.replace(En.escapeReplaceNoEncode,pE);return t}function mE(t){try{t=encodeURI(t).replace(En.percentDecode,"%")}catch{return null}return t}function gE(t,e){var i;const n=t.replace(En.findPipe,(s,o,c)=>{let l=!1,u=o;for(;--u>=0&&c[u]==="\\";)l=!l;return l?"|":" |"}),a=n.split(En.splitPipe);let r=0;if(a[0].trim()||a.shift(),a.length>0&&!((i=a.at(-1))!=null&&i.trim())&&a.pop(),e)if(a.length>e)a.splice(e);else for(;a.length0?-2:-1}function EE(t,e,n,a,r){const i=e.href,s=e.title||null,o=t[1].replace(r.other.outputLinkReplace,"$1");a.state.inLink=!0;const c={type:t[0].charAt(0)==="!"?"image":"link",raw:n,href:i,title:s,text:o,tokens:a.inlineTokens(o)};return a.state.inLink=!1,c}function ix(t,e,n){const a=t.match(n.other.indentCodeCompensation);if(a===null)return e;const r=a[1];return e.split(` +`).map(i=>{const s=i.match(n.other.beginningSpace);if(s===null)return i;const[o]=s;return o.length>=r.length?i.slice(r.length):i}).join(` +`)}var Bi=class{constructor(t){At(this,"options");At(this,"rules");At(this,"lexer");this.options=t||or}space(t){const e=this.rules.block.newline.exec(t);if(e&&e[0].length>0)return{type:"space",raw:e[0]}}code(t){const e=this.rules.block.code.exec(t);if(e){const n=e[0].replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:e[0],codeBlockStyle:"indented",text:this.options.pedantic?n:Pr(n,` +`)}}}fences(t){const e=this.rules.block.fences.exec(t);if(e){const n=e[0],a=ix(n,e[3]||"",this.rules);return{type:"code",raw:n,lang:e[2]?e[2].trim().replace(this.rules.inline.anyPunctuation,"$1"):e[2],text:a}}}heading(t){const e=this.rules.block.heading.exec(t);if(e){let n=e[2].trim();if(this.rules.other.endingHash.test(n)){const a=Pr(n,"#");(this.options.pedantic||!a||this.rules.other.endingSpaceChar.test(a))&&(n=a.trim())}return{type:"heading",raw:e[0],depth:e[1].length,text:n,tokens:this.lexer.inline(n)}}}hr(t){const e=this.rules.block.hr.exec(t);if(e)return{type:"hr",raw:Pr(e[0],` +`)}}blockquote(t){const e=this.rules.block.blockquote.exec(t);if(e){let n=Pr(e[0],` +`).split(` +`),a="",r="";const i=[];for(;n.length>0;){let s=!1;const o=[];let c;for(c=0;c1,r={type:"list",raw:"",ordered:a,start:a?+n.slice(0,-1):"",loose:!1,items:[]};n=a?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=a?n:"[*+-]");const i=this.rules.other.listItemRegex(n);let s=!1;for(;t;){let c=!1,l="",u="";if(!(e=i.exec(t))||this.rules.block.hr.test(t))break;l=e[0],t=t.substring(l.length);let d=e[2].split(` +`,1)[0].replace(this.rules.other.listReplaceTabs,I=>" ".repeat(3*I.length)),_=t.split(` +`,1)[0],m=!d.trim(),p=0;if(this.options.pedantic?(p=2,u=d.trimStart()):m?p=e[1].length+1:(p=e[2].search(this.rules.other.nonSpaceChar),p=p>4?1:p,u=d.slice(p),p+=e[1].length),m&&this.rules.other.blankLine.test(_)&&(l+=_+` +`,t=t.substring(_.length+1),c=!0),!c){const I=this.rules.other.nextBulletRegex(p),R=this.rules.other.hrRegex(p),y=this.rules.other.fencesBeginRegex(p),L=this.rules.other.headingBeginRegex(p),U=this.rules.other.htmlBeginRegex(p);for(;t;){const h=t.split(` +`,1)[0];let N;if(_=h,this.options.pedantic?(_=_.replace(this.rules.other.listReplaceNesting," "),N=_):N=_.replace(this.rules.other.tabCharGlobal," "),y.test(_)||L.test(_)||U.test(_)||I.test(_)||R.test(_))break;if(N.search(this.rules.other.nonSpaceChar)>=p||!_.trim())u+=` +`+N.slice(p);else{if(m||d.replace(this.rules.other.tabCharGlobal," ").search(this.rules.other.nonSpaceChar)>=4||y.test(d)||L.test(d)||R.test(d))break;u+=` +`+_}!m&&!_.trim()&&(m=!0),l+=h+` +`,t=t.substring(h.length+1),d=N.slice(p)}}r.loose||(s?r.loose=!0:this.rules.other.doubleBlankLine.test(l)&&(s=!0));let E=null,b;this.options.gfm&&(E=this.rules.other.listIsTask.exec(u),E&&(b=E[0]!=="[ ] ",u=u.replace(this.rules.other.listReplaceTask,""))),r.items.push({type:"list_item",raw:l,task:!!E,checked:b,loose:!1,text:u,tokens:[]}),r.raw+=l}const o=r.items.at(-1);if(o)o.raw=o.raw.trimEnd(),o.text=o.text.trimEnd();else return;r.raw=r.raw.trimEnd();for(let c=0;cd.type==="space"),u=l.length>0&&l.some(d=>this.rules.other.anyLine.test(d.raw));r.loose=u}if(r.loose)for(let c=0;c({text:c,tokens:this.lexer.inline(c),header:!1,align:i.align[l]})));return i}}lheading(t){const e=this.rules.block.lheading.exec(t);if(e)return{type:"heading",raw:e[0],depth:e[2].charAt(0)==="="?1:2,text:e[1],tokens:this.lexer.inline(e[1])}}paragraph(t){const e=this.rules.block.paragraph.exec(t);if(e){const n=e[1].charAt(e[1].length-1)===` +`?e[1].slice(0,-1):e[1];return{type:"paragraph",raw:e[0],text:n,tokens:this.lexer.inline(n)}}}text(t){const e=this.rules.block.text.exec(t);if(e)return{type:"text",raw:e[0],text:e[0],tokens:this.lexer.inline(e[0])}}escape(t){const e=this.rules.inline.escape.exec(t);if(e)return{type:"escape",raw:e[0],text:e[1]}}tag(t){const e=this.rules.inline.tag.exec(t);if(e)return!this.lexer.state.inLink&&this.rules.other.startATag.test(e[0])?this.lexer.state.inLink=!0:this.lexer.state.inLink&&this.rules.other.endATag.test(e[0])&&(this.lexer.state.inLink=!1),!this.lexer.state.inRawBlock&&this.rules.other.startPreScriptTag.test(e[0])?this.lexer.state.inRawBlock=!0:this.lexer.state.inRawBlock&&this.rules.other.endPreScriptTag.test(e[0])&&(this.lexer.state.inRawBlock=!1),{type:"html",raw:e[0],inLink:this.lexer.state.inLink,inRawBlock:this.lexer.state.inRawBlock,block:!1,text:e[0]}}link(t){const e=this.rules.inline.link.exec(t);if(e){const n=e[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(n)){if(!this.rules.other.endAngleBracket.test(n))return;const i=Pr(n.slice(0,-1),"\\");if((n.length-i.length)%2===0)return}else{const i=rx(e[2],"()");if(i===-2)return;if(i>-1){const o=(e[0].indexOf("!")===0?5:4)+e[1].length+i;e[2]=e[2].substring(0,i),e[0]=e[0].substring(0,o).trim(),e[3]=""}}let a=e[2],r="";if(this.options.pedantic){const i=this.rules.other.pedanticHrefTitle.exec(a);i&&(a=i[1],r=i[3])}else r=e[3]?e[3].slice(1,-1):"";return a=a.trim(),this.rules.other.startAngleBracket.test(a)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(n)?a=a.slice(1):a=a.slice(1,-1)),EE(e,{href:a&&a.replace(this.rules.inline.anyPunctuation,"$1"),title:r&&r.replace(this.rules.inline.anyPunctuation,"$1")},e[0],this.lexer,this.rules)}}reflink(t,e){let n;if((n=this.rules.inline.reflink.exec(t))||(n=this.rules.inline.nolink.exec(t))){const a=(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal," "),r=e[a.toLowerCase()];if(!r){const i=n[0].charAt(0);return{type:"text",raw:i,text:i}}return EE(n,r,n[0],this.lexer,this.rules)}}emStrong(t,e,n=""){let a=this.rules.inline.emStrongLDelim.exec(t);if(!a||a[3]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(a[1]||a[2]||"")||!n||this.rules.inline.punctuation.exec(n)){const i=[...a[0]].length-1;let s,o,c=i,l=0;const u=a[0][0]==="*"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(u.lastIndex=0,e=e.slice(-1*t.length+i);(a=u.exec(e))!=null;){if(s=a[1]||a[2]||a[3]||a[4]||a[5]||a[6],!s)continue;if(o=[...s].length,a[3]||a[4]){c+=o;continue}else if((a[5]||a[6])&&i%3&&!((i+o)%3)){l+=o;continue}if(c-=o,c>0)continue;o=Math.min(o,o+c+l);const d=[...a[0]][0].length,_=t.slice(0,i+a.index+d+o);if(Math.min(i,o)%2){const p=_.slice(1,-1);return{type:"em",raw:_,text:p,tokens:this.lexer.inlineTokens(p)}}const m=_.slice(2,-2);return{type:"strong",raw:_,text:m,tokens:this.lexer.inlineTokens(m)}}}}codespan(t){const e=this.rules.inline.code.exec(t);if(e){let n=e[2].replace(this.rules.other.newLineCharGlobal," ");const a=this.rules.other.nonSpaceChar.test(n),r=this.rules.other.startingSpaceChar.test(n)&&this.rules.other.endingSpaceChar.test(n);return a&&r&&(n=n.substring(1,n.length-1)),{type:"codespan",raw:e[0],text:n}}}br(t){const e=this.rules.inline.br.exec(t);if(e)return{type:"br",raw:e[0]}}del(t){const e=this.rules.inline.del.exec(t);if(e)return{type:"del",raw:e[0],text:e[2],tokens:this.lexer.inlineTokens(e[2])}}autolink(t){const e=this.rules.inline.autolink.exec(t);if(e){let n,a;return e[2]==="@"?(n=e[1],a="mailto:"+n):(n=e[1],a=n),{type:"link",raw:e[0],text:n,href:a,tokens:[{type:"text",raw:n,text:n}]}}}url(t){var n;let e;if(e=this.rules.inline.url.exec(t)){let a,r;if(e[2]==="@")a=e[0],r="mailto:"+a;else{let i;do i=e[0],e[0]=((n=this.rules.inline._backpedal.exec(e[0]))==null?void 0:n[0])??"";while(i!==e[0]);a=e[0],e[1]==="www."?r="http://"+e[0]:r=e[0]}return{type:"link",raw:e[0],text:a,href:r,tokens:[{type:"text",raw:a,text:a}]}}}inlineText(t){const e=this.rules.inline.text.exec(t);if(e){const n=this.lexer.state.inRawBlock;return{type:"text",raw:e[0],text:e[0],escaped:n}}}},ca=class ku{constructor(e){At(this,"tokens");At(this,"options");At(this,"state");At(this,"tokenizer");At(this,"inlineQueue");this.tokens=[],this.tokens.links=Object.create(null),this.options=e||or,this.options.tokenizer=this.options.tokenizer||new Bi,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};const n={other:En,block:bi.normal,inline:kr.normal};this.options.pedantic?(n.block=bi.pedantic,n.inline=kr.pedantic):this.options.gfm&&(n.block=bi.gfm,this.options.breaks?n.inline=kr.breaks:n.inline=kr.gfm),this.tokenizer.rules=n}static get rules(){return{block:bi,inline:kr}}static lex(e,n){return new ku(n).lex(e)}static lexInline(e,n){return new ku(n).inlineTokens(e)}lex(e){e=e.replace(En.carriageReturn,` +`),this.blockTokens(e,this.tokens);for(let n=0;n(o=l.call({lexer:this},e,n))?(e=e.substring(o.raw.length),n.push(o),!0):!1))continue;if(o=this.tokenizer.space(e)){e=e.substring(o.raw.length);const l=n.at(-1);o.raw.length===1&&l!==void 0?l.raw+=` +`:n.push(o);continue}if(o=this.tokenizer.code(e)){e=e.substring(o.raw.length);const l=n.at(-1);(l==null?void 0:l.type)==="paragraph"||(l==null?void 0:l.type)==="text"?(l.raw+=` +`+o.raw,l.text+=` +`+o.text,this.inlineQueue.at(-1).src=l.text):n.push(o);continue}if(o=this.tokenizer.fences(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.heading(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.hr(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.blockquote(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.list(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.html(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.def(e)){e=e.substring(o.raw.length);const l=n.at(-1);(l==null?void 0:l.type)==="paragraph"||(l==null?void 0:l.type)==="text"?(l.raw+=` +`+o.raw,l.text+=` +`+o.raw,this.inlineQueue.at(-1).src=l.text):this.tokens.links[o.tag]||(this.tokens.links[o.tag]={href:o.href,title:o.title});continue}if(o=this.tokenizer.table(e)){e=e.substring(o.raw.length),n.push(o);continue}if(o=this.tokenizer.lheading(e)){e=e.substring(o.raw.length),n.push(o);continue}let c=e;if((s=this.options.extensions)!=null&&s.startBlock){let l=1/0;const u=e.slice(1);let d;this.options.extensions.startBlock.forEach(_=>{d=_.call({lexer:this},u),typeof d=="number"&&d>=0&&(l=Math.min(l,d))}),l<1/0&&l>=0&&(c=e.substring(0,l+1))}if(this.state.top&&(o=this.tokenizer.paragraph(c))){const l=n.at(-1);a&&(l==null?void 0:l.type)==="paragraph"?(l.raw+=` +`+o.raw,l.text+=` +`+o.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=l.text):n.push(o),a=c.length!==e.length,e=e.substring(o.raw.length);continue}if(o=this.tokenizer.text(e)){e=e.substring(o.raw.length);const l=n.at(-1);(l==null?void 0:l.type)==="text"?(l.raw+=` +`+o.raw,l.text+=` +`+o.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=l.text):n.push(o);continue}if(e){const l="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(l);break}else throw new Error(l)}}return this.state.top=!0,n}inline(e,n=[]){return this.inlineQueue.push({src:e,tokens:n}),n}inlineTokens(e,n=[]){var o,c,l;let a=e,r=null;if(this.tokens.links){const u=Object.keys(this.tokens.links);if(u.length>0)for(;(r=this.tokenizer.rules.inline.reflinkSearch.exec(a))!=null;)u.includes(r[0].slice(r[0].lastIndexOf("[")+1,-1))&&(a=a.slice(0,r.index)+"["+"a".repeat(r[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(r=this.tokenizer.rules.inline.anyPunctuation.exec(a))!=null;)a=a.slice(0,r.index)+"++"+a.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);for(;(r=this.tokenizer.rules.inline.blockSkip.exec(a))!=null;)a=a.slice(0,r.index)+"["+"a".repeat(r[0].length-2)+"]"+a.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);let i=!1,s="";for(;e;){i||(s=""),i=!1;let u;if((c=(o=this.options.extensions)==null?void 0:o.inline)!=null&&c.some(_=>(u=_.call({lexer:this},e,n))?(e=e.substring(u.raw.length),n.push(u),!0):!1))continue;if(u=this.tokenizer.escape(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.tag(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.link(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(u.raw.length);const _=n.at(-1);u.type==="text"&&(_==null?void 0:_.type)==="text"?(_.raw+=u.raw,_.text+=u.text):n.push(u);continue}if(u=this.tokenizer.emStrong(e,a,s)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.codespan(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.br(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.del(e)){e=e.substring(u.raw.length),n.push(u);continue}if(u=this.tokenizer.autolink(e)){e=e.substring(u.raw.length),n.push(u);continue}if(!this.state.inLink&&(u=this.tokenizer.url(e))){e=e.substring(u.raw.length),n.push(u);continue}let d=e;if((l=this.options.extensions)!=null&&l.startInline){let _=1/0;const m=e.slice(1);let p;this.options.extensions.startInline.forEach(E=>{p=E.call({lexer:this},m),typeof p=="number"&&p>=0&&(_=Math.min(_,p))}),_<1/0&&_>=0&&(d=e.substring(0,_+1))}if(u=this.tokenizer.inlineText(d)){e=e.substring(u.raw.length),u.raw.slice(-1)!=="_"&&(s=u.raw.slice(-1)),i=!0;const _=n.at(-1);(_==null?void 0:_.type)==="text"?(_.raw+=u.raw,_.text+=u.text):n.push(u);continue}if(e){const _="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(_);break}else throw new Error(_)}}return n}},Gi=class{constructor(t){At(this,"options");At(this,"parser");this.options=t||or}space(t){return""}code({text:t,lang:e,escaped:n}){var i;const a=(i=(e||"").match(En.notSpaceStart))==null?void 0:i[0],r=t.replace(En.endingNewline,"")+` +`;return a?'
    '+(n?r:Wn(r,!0))+`
    +`:"
    "+(n?r:Wn(r,!0))+`
    +`}blockquote({tokens:t}){return`
    +${this.parser.parse(t)}
    +`}html({text:t}){return t}heading({tokens:t,depth:e}){return`${this.parser.parseInline(t)} +`}hr(t){return`
    +`}list(t){const e=t.ordered,n=t.start;let a="";for(let s=0;s +`+a+" +`}listitem(t){var n;let e="";if(t.task){const a=this.checkbox({checked:!!t.checked});t.loose?((n=t.tokens[0])==null?void 0:n.type)==="paragraph"?(t.tokens[0].text=a+" "+t.tokens[0].text,t.tokens[0].tokens&&t.tokens[0].tokens.length>0&&t.tokens[0].tokens[0].type==="text"&&(t.tokens[0].tokens[0].text=a+" "+Wn(t.tokens[0].tokens[0].text),t.tokens[0].tokens[0].escaped=!0)):t.tokens.unshift({type:"text",raw:a+" ",text:a+" ",escaped:!0}):e+=a+" "}return e+=this.parser.parse(t.tokens,!!t.loose),`
  • ${e}
    • +`}checkbox({checked:t}){return"'}paragraph({tokens:t}){return`

    ${this.parser.parseInline(t)}

    +`}table(t){let e="",n="";for(let r=0;r${a}`),` + +`+e+` +`+a+`
    +`}tablerow({text:t}){return` +${t} +`}tablecell(t){const e=this.parser.parseInline(t.tokens),n=t.header?"th":"td";return(t.align?`<${n} align="${t.align}">`:`<${n}>`)+e+` +`}strong({tokens:t}){return`${this.parser.parseInline(t)}`}em({tokens:t}){return`${this.parser.parseInline(t)}`}codespan({text:t}){return`${Wn(t,!0)}`}br(t){return"
    "}del({tokens:t}){return`${this.parser.parseInline(t)}`}link({href:t,title:e,tokens:n}){const a=this.parser.parseInline(n),r=mE(t);if(r===null)return a;t=r;let i='    ",i}image({href:t,title:e,text:n,tokens:a}){a&&(n=this.parser.parseInline(a,this.parser.textRenderer));const r=mE(t);if(r===null)return Wn(n);t=r;let i=`${n}{const c=s[o].flat(1/0);n=n.concat(this.walkTokens(c,e))}):s.tokens&&(n=n.concat(this.walkTokens(s.tokens,e)))}}return n}use(...t){const e=this.defaults.extensions||{renderers:{},childTokens:{}};return t.forEach(n=>{const a={...n};if(a.async=this.defaults.async||a.async||!1,n.extensions&&(n.extensions.forEach(r=>{if(!r.name)throw new Error("extension name required");if("renderer"in r){const i=e.renderers[r.name];i?e.renderers[r.name]=function(...s){let o=r.renderer.apply(this,s);return o===!1&&(o=i.apply(this,s)),o}:e.renderers[r.name]=r.renderer}if("tokenizer"in r){if(!r.level||r.level!=="block"&&r.level!=="inline")throw new Error("extension level must be 'block' or 'inline'");const i=e[r.level];i?i.unshift(r.tokenizer):e[r.level]=[r.tokenizer],r.start&&(r.level==="block"?e.startBlock?e.startBlock.push(r.start):e.startBlock=[r.start]:r.level==="inline"&&(e.startInline?e.startInline.push(r.start):e.startInline=[r.start]))}"childTokens"in r&&r.childTokens&&(e.childTokens[r.name]=r.childTokens)}),a.extensions=e),n.renderer){const r=this.defaults.renderer||new Gi(this.defaults);for(const i in n.renderer){if(!(i in r))throw new Error(`renderer '${i}' does not exist`);if(["options","parser"].includes(i))continue;const s=i,o=n.renderer[s],c=r[s];r[s]=(...l)=>{let u=o.apply(r,l);return u===!1&&(u=c.apply(r,l)),u||""}}a.renderer=r}if(n.tokenizer){const r=this.defaults.tokenizer||new Bi(this.defaults);for(const i in n.tokenizer){if(!(i in r))throw new Error(`tokenizer '${i}' does not exist`);if(["options","rules","lexer"].includes(i))continue;const s=i,o=n.tokenizer[s],c=r[s];r[s]=(...l)=>{let u=o.apply(r,l);return u===!1&&(u=c.apply(r,l)),u}}a.tokenizer=r}if(n.hooks){const r=this.defaults.hooks||new Ci;for(const i in n.hooks){if(!(i in r))throw new Error(`hook '${i}' does not exist`);if(["options","block"].includes(i))continue;const s=i,o=n.hooks[s],c=r[s];Ci.passThroughHooks.has(i)?r[s]=l=>{if(this.defaults.async)return Promise.resolve(o.call(r,l)).then(d=>c.call(r,d));const u=o.call(r,l);return c.call(r,u)}:r[s]=(...l)=>{let u=o.apply(r,l);return u===!1&&(u=c.apply(r,l)),u}}a.hooks=r}if(n.walkTokens){const r=this.defaults.walkTokens,i=n.walkTokens;a.walkTokens=function(s){let o=[];return o.push(i.call(this,s)),r&&(o=o.concat(r.call(this,s))),o}}this.defaults={...this.defaults,...a}}),this}setOptions(t){return this.defaults={...this.defaults,...t},this}lexer(t,e){return ca.lex(t,e??this.defaults)}parser(t,e){return ua.parse(t,e??this.defaults)}parseMarkdown(t){return(n,a)=>{const r={...a},i={...this.defaults,...r},s=this.onError(!!i.silent,!!i.async);if(this.defaults.async===!0&&r.async===!1)return s(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));if(typeof n>"u"||n===null)return s(new Error("marked(): input parameter is undefined or null"));if(typeof n!="string")return s(new Error("marked(): input parameter is of type "+Object.prototype.toString.call(n)+", string expected"));i.hooks&&(i.hooks.options=i,i.hooks.block=t);const o=i.hooks?i.hooks.provideLexer():t?ca.lex:ca.lexInline,c=i.hooks?i.hooks.provideParser():t?ua.parse:ua.parseInline;if(i.async)return Promise.resolve(i.hooks?i.hooks.preprocess(n):n).then(l=>o(l,i)).then(l=>i.hooks?i.hooks.processAllTokens(l):l).then(l=>i.walkTokens?Promise.all(this.walkTokens(l,i.walkTokens)).then(()=>l):l).then(l=>c(l,i)).then(l=>i.hooks?i.hooks.postprocess(l):l).catch(s);try{i.hooks&&(n=i.hooks.preprocess(n));let l=o(n,i);i.hooks&&(l=i.hooks.processAllTokens(l)),i.walkTokens&&this.walkTokens(l,i.walkTokens);let u=c(l,i);return i.hooks&&(u=i.hooks.postprocess(u)),u}catch(l){return s(l)}}}onError(t,e){return n=>{if(n.message+=` +Please report this to https://github.com/markedjs/marked.`,t){const a="

    An error occurred:

    "+Wn(n.message+"",!0)+"
    ";return e?Promise.resolve(a):a}if(e)return Promise.reject(n);throw n}}},ir=new sx;function St(t,e){return ir.parse(t,e)}St.options=St.setOptions=function(t){return ir.setOptions(t),St.defaults=ir.defaults,wS(St.defaults),St};St.getDefaults=rd;St.defaults=or;St.use=function(...t){return ir.use(...t),St.defaults=ir.defaults,wS(St.defaults),St};St.walkTokens=function(t,e){return ir.walkTokens(t,e)};St.parseInline=ir.parseInline;St.Parser=ua;St.parser=ua.parse;St.Renderer=Gi;St.TextRenderer=_d;St.Lexer=ca;St.lexer=ca.lex;St.Tokenizer=Bi;St.Hooks=Ci;St.parse=St;St.options;St.setOptions;St.use;St.walkTokens;St.parseInline;ua.parse;ca.lex;St.setOptions({breaks:!0,gfm:!0});const pd=new St.Renderer;pd.code=function({text:t,lang:e}){const n=e&&Ui.getLanguage(e)?e:"plaintext",a=Ui.highlight(t,{language:n}).value;return`
    ${n}
    ${a}
    `};function ox(t){const e=String(t??"").trim();return/^data:image\//i.test(e)||/^https?:\/\//i.test(e)||e.startsWith("/")&&!e.startsWith("//")?e:""}pd.image=function({href:t,title:e,text:n}){const a=ox(t),r=String(n??"").replace(/"/g,""");return a?`    ${r}`:``};St.use({renderer:pd});function lx(t){const e=t.split(` +`),n=[],a=o=>o.trim().startsWith("|")&&o.includes("|",1),r=o=>/^:?-+:?$/.test(o.trim()),i=o=>o.split("|").slice(1,-1).length;let s=!1;for(let o=0;o!r(m));if(d){s||(s=!0,n.push(c));continue}a(l)&&(s||(_?o+1]*)?>/g,'
    ').replace(/<\/table>/g,"
    "),i=Cw.sanitize(r);if(e.length>=_x){Na.set(e,i);let s=e.length+i.length;for(;Na.size>1&&s>dx;){const o=Na.keys().next().value;s-=o.length+Na.get(o).length,Na.delete(o)}}return i}function px(t){t==null||t.querySelectorAll(".copy-btn").forEach(e=>{e.onclick=()=>{var r;const n=decodeURIComponent(e.dataset.code??""),a=()=>{e.innerHTML='',setTimeout(()=>{e.innerHTML=''},1500)};if((r=navigator.clipboard)!=null&&r.writeText)navigator.clipboard.writeText(n).then(a);else{const i=document.createElement("textarea");i.value=n,i.style.cssText="position:fixed;opacity:0",document.body.appendChild(i),i.select(),document.execCommand("copy"),document.body.removeChild(i),a()}}})}const{open:mx}=ci();function gx(t){t==null||t.querySelectorAll("img.msg-md-image").forEach(e=>{e.addEventListener("error",()=>{var n;e.classList.add("is-broken"),(n=e.closest(".msg-md-image-link"))==null||n.classList.add("is-broken")})}),t==null||t.querySelectorAll("a.msg-md-image-link").forEach(e=>{e.addEventListener("click",n=>{if(e.classList.contains("is-broken"))return;n.preventDefault();const a=e.dataset.lightbox||e.getAttribute("href");a&&mx(a)})})}const Ex={class:"tool-status-icon"},fx={key:0,class:"spinner"},Sx={key:1,class:"ph ph-check-circle"},bx={key:2,class:"ph ph-x-circle"},Tx={class:"tool-name"},hx={key:0,class:"tool-running-time"},vx={class:"tool-card-body"},Rx={key:0,class:"tool-args"},Cx={class:"tool-section"},yx=["innerHTML"],Nx={key:1,class:"tool-section tool-result-section"},Ox=["innerHTML"],Ax={__name:"SubagentStep",props:{tool:{type:Object,required:!0}},setup(t){function e(l){return typeof l!="string"?!1:[/#{1,6} /,/\*\*|__/,/`[^`]+`/,/```/,/^\s*[-*+]\s/m,/^\s*\d+\.\s/m,/\[[^\]]+\]\([^)]+\)/,/\|.*\|/,/^\s*>\s/m].some(d=>d.test(l))}const n=t,a=Y(null);st(()=>n.tool.pending,(l,u)=>{a.value&&(l?a.value.setAttribute("open",""):u!==void 0&&a.value.removeAttribute("open"))},{immediate:!0});function r(l){return s(l)}function i(l){if(typeof l=="string"){try{const u=JSON.parse(l);return s(u)}catch{}return e(l)?sr(l):c(l).split(` +`).map((u,d)=>`
    ${u||" "}
    `).join("")}return s(l)}function s(l){if(typeof l=="string")try{l=JSON.parse(l)}catch{return c(l)}if(l===null||typeof l!="object")return c(String(l));if(Array.isArray(l))return l.length===0?'[]':`
    ${l.map((m,p)=>`
    + ${p} + : + ${o(m)} +
    `).join("")}
    `;const u=Object.entries(l);return u.length===0?'{}':`
    ${u.map(([_,m])=>`
    + ${c(_)} + : + ${o(m)} +
    `).join("")}
    `}function o(l){if(l===null)return'null';if(typeof l=="boolean")return`${l}`;if(typeof l=="number")return`${l}`;if(typeof l=="string"){const d=c(l);return d.length<=200?`${d}`:`${d.slice(0,200)}…`}return Array.isArray(l)?`[${l.length} items]`:`{${Object.keys(l).length} keys}`}function c(l){return typeof l!="string"?String(l??""):l.replace(/&/g,"&").replace(//g,">")}return(l,u)=>(v(),x("details",{ref_key:"detailsEl",ref:a,class:Ge(["subagent-step",{"is-success":!t.tool.pending&&t.tool.success,"is-error":!t.tool.pending&&!t.tool.success}])},[g("summary",null,[g("span",Ex,[t.tool.pending?(v(),x("span",fx)):t.tool.success?(v(),x("i",Sx)):(v(),x("i",bx))]),g("span",Tx,X(t.tool.name),1),t.tool.pending?(v(),x("span",hx,"running")):J("",!0),u[0]||(u[0]=g("i",{class:"ph ph-caret-down tool-chevron"},null,-1))]),g("div",vx,[t.tool.args?(v(),x("details",Rx,[u[1]||(u[1]=g("summary",null,[g("span",{class:"tool-section-label"},"Arguments"),g("i",{class:"ph ph-caret-down tool-chevron"})],-1)),g("div",Cx,[g("pre",{class:"tool-code",innerHTML:r(t.tool.args)},null,8,yx)])])):J("",!0),t.tool.result!=null?(v(),x("div",Nx,[u[2]||(u[2]=g("div",{class:"tool-section-label"},"Result",-1)),g("div",{class:"tool-result",innerHTML:i(t.tool.result)},null,8,Ox)])):J("",!0)])],2))}},Ix={class:"tool-status-icon"},Dx={key:0,class:"spinner"},wx={key:1,class:"ph ph-check-circle"},xx={key:2,class:"ph ph-x-circle"},Lx={class:"tool-name"},Mx={key:0,class:"tool-running-time"},kx={class:"tool-card-body"},Px={key:0,class:"tool-running-banner"},Ux={key:1,class:"tool-args"},Fx={class:"tool-section"},Bx=["innerHTML"],Gx={key:2,class:"tool-section tool-result-section"},Yx=["innerHTML"],$x={key:3,class:"tool-section terminal-output-section"},qx={class:"terminal-output"},Hx={key:4,class:"subagent-planning-indicator"},Vx={class:"planning-label"},zx={key:5,class:"subagent-steps"},Wx={key:1,class:"plan-card",open:""},Kx=["innerHTML"],Qx={class:"task-step-tool"},Xx={class:"task-step-status"},Zx={key:0,class:"task-step-preview"},Jx={__name:"ToolCard",props:{tool:{type:Object,required:!0}},setup(t){function e(h){return typeof h!="string"?!1:[/#{1,6} /,/\*\*|__/,/`[^`]+`/,/```/,/^\s*[-*+]\s/m,/^\s*\d+\.\s/m,/\[[^\]]+\]\([^)]+\)/,/\|.*\|/,/^\s*>\s/m].some(C=>C.test(h))}const n=t;function a(h){return h==="running"?"ph ph-circle-notch task-spin":h==="completed"?"ph ph-check-circle":h==="cancelled"?"ph ph-prohibit":"ph ph-x-circle"}const r=Y(null),i=Y(Date.now());let s=null;st(()=>n.tool.pending,(h,N)=>{r.value&&(h?r.value.setAttribute("open",""):N!==void 0&&r.value.removeAttribute("open"))},{immediate:!0}),st(()=>n.tool.pending,h=>{h?l():u()},{immediate:!0}),Yn(u);const o=ue(()=>{var h;return n.tool.name==="filesystem"&&((h=n.tool.args)!=null&&h.action)?`Running filesystem ${n.tool.args.action}...`:`Running ${n.tool.name}...`}),c=ue(()=>{if(!n.tool.startedAt)return"";const h=Math.max(0,Math.floor((i.value-n.tool.startedAt)/1e3));return h<1?"starting":`${h}s`});function l(){s||(i.value=Date.now(),s=setInterval(()=>{i.value=Date.now()},1e3))}function u(){s&&(clearInterval(s),s=null)}function d(h){return y(h)}function _(h,N){var C,f;if(typeof h=="string"){try{const A=JSON.parse(h);return y(A)}catch{}return e(h)?sr(h):N&&N.name==="filesystem"&&["diff","edit_lines","smart_edit"].includes((C=N.args)==null?void 0:C.action)?m(h):N&&N.name==="filesystem"&&((f=N.args)==null?void 0:f.action)==="read"?R(h):U(h).split(` +`).map((A,w)=>`
    ${A||" "}
    `).join("")}return y(h)}function m(h){let N="",C=h;const f=h.indexOf(` + +`);if(f!==-1){const w=h.slice(f+2);(w.includes("@@")||/^[ +\-]/m.test(w))&&(N=h.slice(0,f),C=w)}const A=[];N&&A.push(`
    ${U(N)||" "}
    `);for(const w of C.split(` +`))A.push(E(w));return A.join("")}const p=/^([ +\-])( +)(\d+)│ ?(.*)$/;function E(h){const N=p.exec(h);if(N){const f=N[1],A=f==="+"?"diff-add":f==="-"?"diff-del":"diff-ctx",w=`${N[2]}${N[3]} ${f} `,F=N[4];return`
    ${U(w)}${U(F)||" "}
    `}return`
    ${U(h)||" "}
    `}function b(h){return h.startsWith("@@")?"diff-hunk":h.startsWith("+")?"diff-add":h.startsWith("-")?"diff-del":"diff-ctx"}const I=/^(\s*)(\d+): (.*)$/;function R(h){const N=h.split(` +`),C=[];let f=0;if(N.length&&N[0].startsWith("[")){const A=N[0],w=A.replace(/^\[/,"").replace(/\]$/,""),F=w.indexOf(" | ");if(F!==-1){const j=w.slice(0,F),_e=w.slice(F+5);C.push(`
    ${U(j)} | ${U(_e)}
    `)}else C.push(`
    ${U(A)||" "}
    `);f=1}for(f${U(N[f])||" "}`),f+=1);f ');continue}const w=I.exec(A);w?C.push(`
    ${U(w[1]+w[2])}: ${U(w[3])}
    `):C.push(`
    ${U(A)}
    `)}return C.join("")}function y(h){if(typeof h=="string")try{h=JSON.parse(h)}catch{return U(h)}if(h===null||typeof h!="object")return U(String(h));if(Array.isArray(h))return h.length===0?'[]':`
    ${h.map((A,w)=>`
    + ${w} + : + ${L(A)} +
    `).join("")}
    `;const N=Object.entries(h);return N.length===0?'{}':`
    ${N.map(([f,A])=>`
    + ${U(f)} + : + ${L(A)} +
    `).join("")}
    `}function L(h){if(h===null)return'null';if(typeof h=="boolean")return`${h}`;if(typeof h=="number")return`${h}`;if(typeof h=="string"){const C=U(h);return C.length<=200?`${C}`:`${C.slice(0,200)}…`}return Array.isArray(h)?`[${h.length} items]`:`{${Object.keys(h).length} keys}`}function U(h){return typeof h!="string"?String(h??""):h.replace(/&/g,"&").replace(//g,">")}return(h,N)=>{var C;return v(),x("details",{ref_key:"detailsEl",ref:r,class:Ge(["tool-card",{"is-success":!t.tool.pending&&t.tool.success,"is-error":!t.tool.pending&&!t.tool.success}])},[g("summary",null,[g("span",Ix,[t.tool.pending?(v(),x("span",Dx)):t.tool.success?(v(),x("i",wx)):(v(),x("i",xx))]),g("span",Lx,X(t.tool.name),1),t.tool.pending?(v(),x("span",Mx,X(c.value),1)):J("",!0),N[0]||(N[0]=g("i",{class:"ph ph-caret-down tool-chevron"},null,-1))]),g("div",kx,[t.tool.pending&&t.tool.name!=="spawn_agent"?(v(),x("div",Px,[N[1]||(N[1]=g("span",{class:"spinner"},null,-1)),g("span",null,X(o.value),1)])):J("",!0),t.tool.args?(v(),x("details",Ux,[N[2]||(N[2]=g("summary",null,[g("span",{class:"tool-section-label"},"Arguments"),g("i",{class:"ph ph-caret-down tool-chevron"})],-1)),g("div",Fx,[g("pre",{class:"tool-code",innerHTML:d(t.tool.args)},null,8,Bx)])])):J("",!0),t.tool.result!=null?(v(),x("div",Gx,[N[3]||(N[3]=g("div",{class:"tool-section-label"},"Result",-1)),g("div",{class:"tool-result",innerHTML:_(t.tool.result,t.tool)},null,8,Yx)])):J("",!0),t.tool.name==="terminal"&&t.tool.terminalOutput?(v(),x("div",$x,[N[4]||(N[4]=g("div",{class:"tool-section-label"},"Live output",-1)),g("pre",qx,X(t.tool.terminalOutput),1)])):J("",!0),t.tool.planningLabel!=null?(v(),x("div",Hx,[g("span",Vx,X(t.tool.planningLabel),1)])):J("",!0),(C=t.tool.steps)!=null&&C.length?(v(),x("div",zx,[(v(!0),x(Ue,null,Dt(t.tool.steps,(f,A)=>(v(),x(Ue,{key:A},[f.kind==="turn_thinking"?(v(),ze(wu,{key:0,msg:f},null,8,["msg"])):f.kind==="plan"?(v(),x("details",Wx,[N[5]||(N[5]=g("summary",null,[g("i",{class:"ph ph-map-trifold"}),$e(" Plan "),g("i",{class:"ph ph-caret-down plan-chevron"})],-1)),g("div",{class:"plan-body",innerHTML:$(sr)(f.text)},null,8,Kx)])):f.kind==="task_update"?(v(),x("div",{key:2,class:Ge(["task-update-step",f.status])},[g("i",{class:Ge(a(f.status))},null,2),g("span",Qx,X(f.tool),1),g("span",Xx,X(f.status),1),f.preview?(v(),x("span",Zx,X(f.preview),1)):J("",!0)],2)):(v(),ze(Ax,{key:3,tool:f},null,8,["tool"]))],64))),128))])):J("",!0)])],2)}}},jx=["open"],eL={class:"content-title"},tL=["href"],nL=["href"],aL=["title"],rL={key:0,class:"content-body"},iL={key:0,class:"content-source"},sL={key:0,class:"content-source-state"},oL={key:1,class:"content-source-error"},lL={key:2,class:"content-source-code"},cL=["innerHTML"],uL=["src"],dL=["src"],_L=["src"],pL=["src"],mL={key:5,class:"content-image-wrap"},gL=["src","alt"],EL={key:0,class:"content-image-skeleton"},fL=["src"],SL={key:7,class:"content-unknown"},bL={class:"unknown-name"},TL=["href"],hL=["open"],vL={class:"tool-card-body"},RL={class:"tool-section"},CL={class:"tool-code"},yL={class:"tool-section"},NL={class:"tool-code"},OL={__name:"ContentCard",props:{tool:{type:Object,required:!0},defaultOpen:{type:Boolean,default:!1},collapseToken:{type:String,default:""}},setup(t){const e=t,n=Y(null),a=Y(e.defaultOpen),r=Y(e.defaultOpen),i=Y(!1),s=Y(!1),o=Y(""),c=Y(!1),l=Y(""),u=Y(!1),{open:d}=ci();st(()=>[e.defaultOpen,e.collapseToken],([Ae])=>{a.value=Ae,Ae&&(r.value=!0)});const _=ue(()=>e.tool.success===!1?!0:!e.tool.metadata||!e.tool.metadata.url?!String(e.tool.result??"").match(/URL: (.+)/):!1),m=ue(()=>{if(e.tool.metadata)return e.tool.metadata;const Ae=String(e.tool.result??""),He=Ae.match(/URL: (.+)/);if(He){const ke=Ae.match(/Published: .+ \(([^)]+)\)/),rt=Ae.match(/Published: (.+) \(/);return{url:He[1].trim(),content_type:ke?ke[1].trim():"unknown",title:rt?rt[1].trim():"Content"}}return{}}),p=ue(()=>m.value.url||""),E=ue(()=>tr(p.value));st(()=>E.value,()=>{u.value=!1});const b=ue(()=>m.value.content_type||"unknown"),I=ue(()=>m.value.title||m.value.filename||"Content"),R=ue(()=>{var ke;if(b.value!=="unknown")return b.value;const Ae=(ke=p.value.split(".").pop())==null?void 0:ke.toLowerCase();return{svg:"svg",html:"html",htm:"html",pdf:"pdf",stl:"stl",png:"image",jpg:"image",jpeg:"image",gif:"image",webp:"image",bmp:"image",mp4:"video",webm:"video",mov:"video",mkv:"video"}[Ae]||"unknown"}),y={stl:"ph ph-cube",html:"ph ph-globe",svg:"ph ph-paint-brush",pdf:"ph ph-file-pdf",image:"ph ph-image",video:"ph ph-film-strip",unknown:"ph ph-paperclip"},L=ue(()=>y[b.value]||y.unknown),U={stl:"info",html:"secondary",svg:"success",pdf:"primary",image:"primary",video:"danger",unknown:"primary"},h=ue(()=>U[R.value]||"primary"),N=ue(()=>`is-${R.value}`),C=ue(()=>{const Ae=R.value;return["stl","html","svg","pdf"].includes(Ae)?oe(Ae):Pi(E.value)}),f=ue(()=>R.value==="stl"?C.value:Pi(E.value)),A=ue(()=>["html","svg"].includes(R.value)?E.value:R.value==="stl"&&m.value.source_url?tr(m.value.source_url):""),w=ue(()=>!!A.value),F=ue(()=>rS({...m.value,content_type:R.value,filename:m.value.source_filename||m.value.filename||p.value})),j=ue(()=>iS(o.value,F.value)),_e=ue(()=>i.value?"ph ph-check":"ph ph-copy"),be=ue(()=>{const Ae=tr(m.value.download_url||p.value);return m.value.download_url||!Ae?Ae:`${Ae}${Ae.includes("?")?"&":"?"}download=1`});function oe(Ae){return nS(Ae,E.value)}function pe(){b.value==="image"&&d(E.value)}function Ce(Ae){a.value=Ae.currentTarget.open,a.value&&(r.value=!0)}async function ot(){s.value=!s.value,s.value&&await lt()}async function lt(){if(!(!A.value||o.value||c.value)){c.value=!0,l.value="";try{const Ae=await fetch(A.value);if(!Ae.ok)throw new Error(`HTTP ${Ae.status}`);o.value=await Ae.text()}catch(Ae){l.value=`Failed to load source: ${(Ae==null?void 0:Ae.message)||Ae}`}finally{c.value=!1}}}async function at(){try{await navigator.clipboard.writeText(f.value),i.value=!0,setTimeout(()=>{i.value=!1},1500)}catch{}}function We(Ae){if(typeof Ae=="string")try{return JSON.stringify(JSON.parse(Ae),null,2)}catch{return Ae}return JSON.stringify(Ae,null,2)}return(Ae,He)=>{const ke=tt("GnBadge");return _.value?(v(),x("details",{key:1,ref_key:"detailsEl",ref:n,class:"tool-card is-error",open:a.value,onToggle:Ce},[He[9]||(He[9]=LT('📎content_publish',1)),g("div",vL,[g("div",RL,[He[7]||(He[7]=g("div",{class:"tool-section-label"},"Arguments",-1)),g("pre",CL,X(We(t.tool.args)),1)]),g("div",yL,[He[8]||(He[8]=g("div",{class:"tool-section-label"},"Result",-1)),g("pre",NL,X(t.tool.result),1)])])],40,hL)):(v(),x("details",{key:0,ref_key:"detailsEl",ref:n,class:Ge(["content-card",N.value]),open:a.value,onToggle:Ce},[g("summary",null,[g("i",{class:Ge(["content-icon",L.value])},null,2),g("span",eL,X(I.value),1),ne(ke,{variant:h.value},{default:Be(()=>[$e(X(b.value),1)]),_:1},8,["variant"]),g("span",{class:"content-actions",onClick:He[0]||(He[0]=ga(()=>{},["stop"]))},[g("a",{href:C.value,target:"_blank",rel:"noopener noreferrer",title:"Open preview",class:"btn-icon btn-icon-sm"},[...He[2]||(He[2]=[g("i",{class:"ph ph-arrow-square-out"},null,-1)])],8,tL),g("a",{href:be.value,title:"Download",class:"btn-icon btn-icon-sm"},[...He[3]||(He[3]=[g("i",{class:"ph ph-download-simple"},null,-1)])],8,nL),w.value?(v(),x("button",{key:0,type:"button",class:"btn-icon btn-icon-sm",title:s.value?"Show preview":"Show source",onClick:ot},[g("i",{class:Ge(s.value?"ph ph-eye":"ph ph-code")},null,2)],8,aL)):J("",!0),g("button",{type:"button",title:"Copy file link",class:"btn-icon btn-icon-sm",onClick:at},[g("i",{class:Ge(_e.value)},null,2)])]),He[4]||(He[4]=g("i",{class:"ph ph-caret-down content-chevron"},null,-1))]),r.value?(v(),x("div",rL,[s.value?(v(),x("div",iL,[c.value?(v(),x("div",sL,[...He[5]||(He[5]=[g("span",{class:"spinner"},null,-1),g("span",null,"Loading source...",-1)])])):l.value?(v(),x("pre",oL,X(l.value),1)):(v(),x("pre",lL,[g("code",{class:Ge(["hljs",`language-${F.value}`]),innerHTML:j.value},null,10,cL)]))])):R.value==="stl"?(v(),x("iframe",{key:1,src:oe("stl"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,uL)):R.value==="html"?(v(),x("iframe",{key:2,src:oe("html"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,dL)):R.value==="svg"?(v(),x("iframe",{key:3,src:oe("svg"),class:"content-iframe",sandbox:"allow-scripts allow-same-origin",loading:"lazy"},null,8,_L)):R.value==="pdf"?(v(),x("iframe",{key:4,src:oe("pdf"),class:"content-iframe",loading:"lazy"},null,8,pL)):R.value==="image"?(v(),x("div",mL,[g("img",{src:E.value,class:"content-image",alt:I.value,loading:"lazy",onLoad:He[1]||(He[1]=rt=>u.value=!0),onClick:pe},null,40,gL),u.value?J("",!0):(v(),x("div",EL,[...He[6]||(He[6]=[g("i",{class:"ph ph-spinner ph-spin content-image-spinner"},null,-1)])]))])):R.value==="video"?(v(),x("video",{key:6,src:E.value,class:"content-video",controls:"",playsinline:""},null,8,fL)):(v(),x("div",SL,[g("i",{class:Ge(["unknown-icon",L.value])},null,2),g("div",bL,X(I.value),1),g("a",{href:E.value,target:"_blank",rel:"noopener noreferrer",class:"btn btn-small btn-secondary unknown-open"}," Open file ",8,TL)]))])):J("",!0)],42,jx))}}},AL=ht(OL,[["__scopeId","data-v-65a497ff"]]),IL={class:"card-grid"},DL={key:0,class:"card-grid-title"},wL={class:"card-grid-items"},xL=["onClick","onKeydown"],LL=["src"],ML={key:1,class:"card-no-image"},kL={class:"card-content"},PL={class:"card-title"},UL={key:0,class:"card-subtitle"},FL={key:1,class:"card-meta"},BL={class:"card-meta-label"},GL={class:"card-meta-value"},YL={key:2,class:"card-description"},$L={key:1,class:"card-grid-more"},qL={class:"card-grid-more-text"},HL={class:"card-modal-title"},VL={key:0,class:"card-modal"},zL=["src"],WL={class:"card-modal-content"},KL={key:0,class:"card-modal-subtitle"},QL={key:1,class:"card-modal-section"},XL={class:"card-modal-meta-grid"},ZL={class:"card-modal-meta-label"},JL={class:"card-modal-meta-value"},jL={key:2,class:"card-modal-section"},eM={class:"card-modal-text"},tM={key:3,class:"card-modal-section"},nM={class:"card-modal-details"},aM={key:4,class:"card-modal-actions"},rM=["href"],du=4,iM={__name:"CardGrid",props:{data:{type:Object,default:()=>({})}},setup(t){const e=t,n=Y(null),a=ue(()=>Array.isArray(e.data.cards)?e.data.cards:[]),r=ue(()=>a.value.slice(0,du)),i=ue(()=>a.value.length>du),s=ue(()=>a.value.length-du);$b(()=>{var l;Array.isArray((l=e.data)==null?void 0:l.cards)||console.warn('[CardGrid] payload is missing a "cards" array',e.data)});function o(l){n.value=l}function c(){n.value=null}return(l,u)=>{const d=tt("GnModal");return v(),x("div",IL,[t.data.title?(v(),x("div",DL,X(t.data.title),1)):J("",!0),g("div",wL,[(v(!0),x(Ue,null,Dt(r.value,_=>{var m,p;return v(),x("div",{key:_.id,class:"card-grid-item",tabindex:"0",onClick:E=>o(_),onKeydown:ea(E=>o(_),["enter"])},[(m=_.image)!=null&&m.trim()?(v(),x("img",{key:0,src:_.image,class:"card-image",alt:"",loading:"lazy"},null,8,LL)):(v(),x("div",ML,[...u[0]||(u[0]=[g("i",{class:"ph ph-image"},null,-1)])])),g("div",kL,[g("div",PL,X(_.title),1),_.subtitle?(v(),x("div",UL,X(_.subtitle),1)):J("",!0),(p=_.meta)!=null&&p.length?(v(),x("div",FL,[(v(!0),x(Ue,null,Dt(_.meta,(E,b)=>(v(),x("span",{key:b,class:"card-meta-item"},[g("span",BL,X(E.label),1),g("span",GL,X(E.value),1)]))),128))])):J("",!0),_.description?(v(),x("div",YL,X(_.description),1)):J("",!0)])],40,xL)}),128))]),i.value?(v(),x("div",$L,[g("span",qL,"+"+X(s.value)+" more",1)])):J("",!0),ne(d,{open:!!n.value,"onUpdate:open":c},{title:Be(()=>{var _;return[g("h2",HL,X((_=n.value)==null?void 0:_.title),1)]}),default:Be(()=>{var _,m,p,E;return[n.value?(v(),x("div",VL,[(_=n.value.image)!=null&&_.trim()?(v(),x("img",{key:0,src:n.value.image,class:"card-modal-image",alt:""},null,8,zL)):J("",!0),g("div",WL,[n.value.subtitle?(v(),x("div",KL,X(n.value.subtitle),1)):J("",!0),(m=n.value.meta)!=null&&m.length?(v(),x("div",QL,[u[1]||(u[1]=g("div",{class:"card-modal-section-title"},"Overview",-1)),g("div",XL,[(v(!0),x(Ue,null,Dt(n.value.meta,(b,I)=>(v(),x("div",{key:I,class:"card-modal-meta-cell"},[g("div",ZL,X(b.label),1),g("div",JL,X(b.value),1)]))),128))])])):J("",!0),n.value.description?(v(),x("div",jL,[u[2]||(u[2]=g("div",{class:"card-modal-section-title"},"Description",-1)),g("p",eM,X(n.value.description),1)])):J("",!0),(p=n.value.details)!=null&&p.length?(v(),x("div",tM,[u[3]||(u[3]=g("div",{class:"card-modal-section-title"},"Details",-1)),g("dl",nM,[(v(!0),x(Ue,null,Dt(n.value.details,(b,I)=>(v(),x("div",{key:I,class:"card-modal-detail-row"},[g("dt",null,X(b.label),1),g("dd",null,X(b.value),1)]))),128))])])):J("",!0),(E=n.value.actions)!=null&&E.length?(v(),x("div",aM,[(v(!0),x(Ue,null,Dt(n.value.actions,(b,I)=>(v(),x("a",{key:I,href:b.url,target:"_blank",rel:"noopener noreferrer",class:"card-modal-action"},X(b.label),9,rM))),128))])):J("",!0)])])):J("",!0)]}),_:1},8,["open"])])}}},sM=ht(iM,[["__scopeId","data-v-9596a41c"]]),oM=Object.freeze(Object.defineProperty({__proto__:null,default:sM},Symbol.toStringTag,{value:"Module"})),lM={class:"ui-form"},cM={key:0,class:"ui-form-submitted"},uM={key:0,class:"ui-form-title"},dM={class:"ui-form-summary"},_M={key:1,class:"ui-form-body"},pM={key:0,class:"ui-form-title"},mM={key:1,class:"ui-form-description"},gM=["for"],EM={key:0,class:"ui-form-required"},fM={key:0,class:"ui-form-field-hint"},SM=["id","onUpdate:modelValue","placeholder","required","minlength","maxlength","onBlur","onInput"],bM=["id","onUpdate:modelValue","required","onBlur","onChange"],TM={key:0,value:""},hM=["value"],vM=["id","onUpdate:modelValue","required","onBlur","onChange"],RM=["value"],CM={key:4,class:"ui-form-checkbox"},yM=["id","onUpdate:modelValue","onChange"],NM=["id","onUpdate:modelValue","type","placeholder","required","min","max","minlength","maxlength","pattern","onBlur","onInput"],OM={key:6,class:"ui-form-error"},AM=["disabled"],IM={key:0,class:"ui-form-spinner"},DM={__name:"Form",props:{data:{type:Object,default:()=>({})}},setup(t){const e=t,n=sn(),a=ja("wsSend"),r=ar({}),i=Y(new Set),s=ar({}),o=Y(!1),c=Y(!1),l=ue(()=>{var f;return((f=e.data)==null?void 0:f.form_id)||""}),u=ue(()=>{var f;return Array.isArray((f=e.data)==null?void 0:f.fields)?e.data.fields:[]}),d=ue(()=>`navi_submitted_forms:${n.currentId||"unknown"}`);function _(f){return`form-${l.value}-${f}`}function m(f){return f==="email"||f==="url"||f==="date"||f==="number"?f:"text"}function p(f,A){var w;if(f==null||f==="")return"—";if(A.type==="checkbox")return f?"Yes":"No";if(A.type==="select"||A.type==="multiselect"){const F=Array.isArray(A.options)?A.options:[];return Array.isArray(f)?f.map(_e=>{var be;return((be=F.find(oe=>oe.value===_e))==null?void 0:be.label)||_e}).join(", ")||"—":((w=F.find(j=>j.value===f))==null?void 0:w.label)||f}return Array.isArray(f)?f.join(", "):String(f)}function E(f){return f==null||f===""||Array.isArray(f)&&f.length===0}function b(f){const A=f.name,w=r[A];if(delete s[A],f.required&&E(w)){s[A]=`${f.label} is required`;return}if(!E(w)){if(f.type==="email"&&(/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(w))||(s[A]="Enter a valid email address")),f.type==="url")try{const F=new URL(w);if(F.protocol!=="http:"&&F.protocol!=="https:")throw new Error("bad protocol")}catch{s[A]="Enter a valid http:// or https:// URL"}if(f.type==="number"){const F=Number(w);Number.isNaN(F)?s[A]="Must be a number":(f.min!==void 0&&f.min!==null&&Ff.max&&(s[A]=`Maximum value is ${f.max}`))}if(f.minLength!==void 0&&f.minLength!==null&&String(w).lengthf.maxLength&&(s[A]=`Maximum length is ${f.maxLength} characters`),f.pattern)try{new RegExp(f.pattern).test(String(w))||(s[A]="Invalid format")}catch{}}}function I(f){i.value.add(f);const A=u.value.find(w=>w.name===f);A&&b(A)}function R(){for(const f of u.value)b(f)}const y=ue(()=>(R(),u.value.every(f=>!s[f.name])));function L(f){return i.value.has(f)&&s[f]}function U(){if(l.value)try{if(JSON.parse(localStorage.getItem(d.value)||"[]").includes(l.value)){c.value=!0;const A=JSON.parse(localStorage.getItem(`${d.value}:${l.value}`)||"{}");Object.assign(r,A)}}catch{}}function h(){if(l.value)try{const f=d.value,A=JSON.parse(localStorage.getItem(f)||"[]");A.includes(l.value)||(A.push(l.value),localStorage.setItem(f,JSON.stringify(A))),localStorage.setItem(`${f}:${l.value}`,JSON.stringify({...r}))}catch{}}function N(){const f={};for(const A of u.value){const w=r[A.name];A.type==="number"?f[A.name]=w===""||w===void 0?null:Number(w):A.type==="checkbox"?f[A.name]=!!w:f[A.name]=w===void 0?null:w}return f}function C(){if(o.value||c.value||!y.value)return;o.value=!0,R();for(const A of u.value)i.value.add(A.name);if(!y.value){o.value=!1;return}const f={type:"form_submit",form_id:l.value,values:N()};typeof a=="function"?a(f):console.error("[Form] wsSend is not available"),h(),c.value=!0,o.value=!1}return Sn(()=>{for(const f of u.value)f.type==="checkbox"?r[f.name]=!!f.default:f.type==="multiselect"?r[f.name]=Array.isArray(f.default)?[...f.default]:[]:r[f.name]=f.default??(f.type==="select"&&f.required,"");U()}),(f,A)=>(v(),x("div",lM,[c.value?(v(),x("div",cM,[t.data.title?(v(),x("div",uM,X(t.data.title),1)):J("",!0),A[0]||(A[0]=g("div",{class:"ui-form-submitted-note"},[g("i",{class:"ph ph-check-circle"}),$e(" Submitted ")],-1)),g("dl",dM,[(v(!0),x(Ue,null,Dt(u.value,w=>(v(),x("div",{key:w.name,class:"ui-form-summary-row"},[g("dt",null,X(w.label),1),g("dd",null,X(p(r[w.name],w)),1)]))),128))])])):(v(),x("div",_M,[t.data.title?(v(),x("div",pM,X(t.data.title),1)):J("",!0),t.data.description?(v(),x("div",mM,X(t.data.description),1)):J("",!0),g("form",{class:"ui-form-fields",onSubmit:ga(C,["prevent"])},[(v(!0),x(Ue,null,Dt(u.value,w=>(v(),x("div",{key:w.name,class:Ge(["ui-form-field",{"has-error":L(w.name)}])},[g("label",{class:"ui-form-label",for:_(w.name)},[$e(X(w.label)+" ",1),w.required?(v(),x("span",EM,"*")):J("",!0)],8,gM),w.description?(v(),x("div",fM,X(w.description),1)):J("",!0),w.type==="textarea"?Ka((v(),x("textarea",{key:1,id:_(w.name),"onUpdate:modelValue":F=>r[w.name]=F,class:"ui-form-input",placeholder:w.placeholder||"",required:w.required,minlength:w.minLength,maxlength:w.maxLength,rows:"3",onBlur:F=>I(w.name),onInput:F=>I(w.name)},null,40,SM)),[[ai,r[w.name]]]):w.type==="select"?Ka((v(),x("select",{key:2,id:_(w.name),"onUpdate:modelValue":F=>r[w.name]=F,class:"ui-form-input",required:w.required,onBlur:F=>I(w.name),onChange:F=>I(w.name)},[w.required?J("",!0):(v(),x("option",TM,"—")),(v(!0),x(Ue,null,Dt(w.options,F=>(v(),x("option",{key:F.value,value:F.value},X(F.label),9,hM))),128))],40,bM)),[[Nu,r[w.name]]]):w.type==="multiselect"?Ka((v(),x("select",{key:3,id:_(w.name),"onUpdate:modelValue":F=>r[w.name]=F,class:"ui-form-input",multiple:"",required:w.required,onBlur:F=>I(w.name),onChange:F=>I(w.name)},[(v(!0),x(Ue,null,Dt(w.options,F=>(v(),x("option",{key:F.value,value:F.value},X(F.label),9,RM))),128))],40,vM)),[[Nu,r[w.name]]]):w.type==="checkbox"?(v(),x("label",CM,[Ka(g("input",{id:_(w.name),"onUpdate:modelValue":F=>r[w.name]=F,type:"checkbox",onChange:F=>I(w.name)},null,40,yM),[[$f,r[w.name]]]),g("span",null,X(w.label),1)])):Ka((v(),x("input",{key:5,id:_(w.name),"onUpdate:modelValue":F=>r[w.name]=F,class:"ui-form-input",type:m(w.type),placeholder:w.placeholder||"",required:w.required,min:w.min,max:w.max,minlength:w.minLength,maxlength:w.maxLength,pattern:w.pattern,onBlur:F=>I(w.name),onInput:F=>I(w.name)},null,40,NM)),[[vh,r[w.name]]]),L(w.name)?(v(),x("div",OM,X(s[w.name]),1)):J("",!0)],2))),128)),g("button",{type:"submit",class:"ui-form-submit",disabled:!y.value||o.value||c.value},[o.value?(v(),x("span",IM)):J("",!0),g("span",null,X(t.data.submit_label||"Submit"),1)],8,AM)],32)]))]))}},wM=ht(DM,[["__scopeId","data-v-4d9c6b33"]]),xM=Object.freeze(Object.defineProperty({__proto__:null,default:wM},Symbol.toStringTag,{value:"Module"})),fE=Object.assign({"./CardGrid.vue":oM,"./ConfirmDialog.vue":nR,"./ContextBar.vue":ND,"./Form.vue":xM,"./ImageLightbox.vue":dR,"./LoginScreen.vue":nI,"./OfflineBanner.vue":sI,"./ProfileBadge.vue":RD,"./SelectionToolbar.vue":pR,"./WelcomeScreen.vue":pI});function LM(t){return t.split("_").map(e=>e.charAt(0).toUpperCase()+e.slice(1)).join("")}const Qr=new Map;for(const t in fE){const e=t.replace(/^.*\//,"").replace(/\.vue$/,""),n=fE[t].default;if(!n)continue;Qr.set(e,Jr(n));const a=e.replace(/([a-z0-9])([A-Z])/g,"$1_$2").toLowerCase();Qr.set(a,Jr(n))}function MM(t){if(!t||typeof t!="string")return null;if(Qr.has(t))return Qr.get(t);const e=LM(t);return Qr.get(e)||null}const kM={class:"ui-component-card"},PM={class:"ui-component-header"},UM={class:"ui-component-name"},FM={class:"ui-component-body"},BM={key:1,class:"ui-component-fallback"},GM={class:"ui-component-fallback-title"},YM={class:"ui-component-fallback-json"},$M={__name:"UiComponentCard",props:{component:{type:Object,required:!0}},setup(t){const e=t,n=ue(()=>{const a=e.component.component??"";return MM(a)});return(a,r)=>(v(),x("div",kM,[g("div",PM,[r[0]||(r[0]=g("span",{class:"ui-component-icon"},"🧩",-1)),g("span",UM,X(e.component.component),1),r[1]||(r[1]=g("span",{class:"ui-component-badge"},"UI",-1))]),g("div",FM,[n.value?(v(),ze(_f(n.value),{key:0,data:e.component.payload},null,8,["data"])):(v(),x("div",BM,[g("div",GM," Unknown UI component: "+X(e.component.component??"?"),1),g("pre",YM,X(JSON.stringify(e.component.payload,null,2)),1)]))])]))}},qM=ht($M,[["__scopeId","data-v-5c9908d7"]]),HM={key:0,class:"msg-assistant"},VM={key:0,class:"tool-cards-summary"},zM={key:4,class:"plan-card"},WM=["innerHTML"],KM=["innerHTML"],QM={class:"planning-label"},XM={key:3,class:"stream-cursor"},ZM={key:4,class:"msg-meta-row"},JM={key:0,class:"msg-meta-item"},jM={key:1,class:"msg-meta-item"},ek={key:2,class:"msg-meta-item"},tk={key:3,class:"msg-meta-item msg-meta-time"},nk={__name:"AssistantMessage",props:{msg:{type:Object,required:!0},isFlashing:{type:Boolean,default:!1}},setup(t){const e=t,n=Y(null),a=sn(),r=Y(!1),i=ue(()=>sr(e.msg.text)),s=ue(()=>e.msg.done?e.msg.time:null),o=ed(s),c=ue(()=>{var N;let h=null;for(const C of a.messages)(N=C==null?void 0:C.tools)!=null&&N.length&&C.tools.forEach((f,A)=>{f.kind==="tool"&&f.name==="content_publish"&&(h=b(C,A))});return h}),l=ue(()=>{const h=I(e.msg.tools||[]);return h?`Running ${y(h)}...`:""}),u=ue(()=>e.msg.done?"":e.msg.statusLabel?e.msg.statusLabel:l.value?l.value:e.msg.text?"":R(e.msg.tools||[])?"Preparing next action...":"Thinking..."),d=ue(()=>typeof e.msg.id=="string"&&e.msg.id.startsWith("h_")),{copied:_,copy:m}=NS();async function p(h){try{await a.rateMessage(e.msg,h)}catch(N){console.error("rate failed",N)}}function E(h){return h?h>=1e3?(h/1e3).toFixed(1).replace(".0","")+"k":String(h):""}function b(h,N){return`${h.id}:content:${N}`}function I(h){var N;for(let C=h.length-1;C>=0;C--){const f=h[C];if(f.kind==="tool"&&f.pending)return f;if((N=f.steps)!=null&&N.length){const A=I(f.steps);if(A)return A}}return null}function R(h){return h.some(N=>{var C;return N.kind==="tool"||N.kind==="plan"||N.kind==="turn_thinking"?!0:(C=N.steps)!=null&&C.length?R(N.steps):!1})}function y(h){var N;return h.name==="filesystem"&&((N=h.args)!=null&&N.action)?`filesystem ${h.args.action}`:h.name}function L(h){return h.kind==="ui_component"?!1:h.kind==="tool"&&h.name!=="content_publish"}const U=ue(()=>{const h=e.msg.tools||[],N=h.map((w,F)=>({item:w,i:F})).filter(({item:w})=>L(w));if(N.length===0||N.length<4)return h.map((w,F)=>({type:"item",item:w,i:F,key:F}));const C=r.value,f=new Set(C?N.map(({i:w})=>w):N.slice(-3).map(({i:w})=>w)),A=[];for(let w=0;we.msg.done,h=>{h&&Ht(()=>{px(n.value),gx(n.value)})},{immediate:!0}),(h,N)=>{var f;const C=tt("GnBadge");return t.msg.thinking||(f=t.msg.tools)!=null&&f.length||t.msg.text||t.msg.type==="ui_component"||!t.msg.done?(v(),x("div",HM,[t.msg.thinking?(v(),ze(wu,{key:0,msg:t.msg},null,8,["msg"])):J("",!0),ne(gh,{name:"tool-fade",tag:"div"},{default:Be(()=>[(v(!0),x(Ue,null,Dt(U.value,A=>(v(),x("div",{key:A.key,class:"tool-fade-item"},[A.type==="summary"?(v(),x("div",VM,[ne(C,{variant:"secondary"},{default:Be(()=>[$e(X(A.total)+" tools",1)]),_:2},1024),ne($(Za),{size:"sm",icon:r.value?"ph ph-caret-up":"ph ph-caret-down",label:r.value?"Hide older tools":"Show all tools",onClick:N[0]||(N[0]=w=>r.value=!r.value)},null,8,["icon","label"])])):A.item.kind==="turn_thinking"?(v(),ze(wu,{key:1,msg:A.item},null,8,["msg"])):A.item.kind==="tool"&&A.item.name==="content_publish"?(v(),ze(AL,{key:2,tool:A.item,"default-open":b(t.msg,A.i)===c.value,"collapse-token":c.value},null,8,["tool","default-open","collapse-token"])):A.item.kind==="ui_component"?(v(),ze(qM,{key:3,component:A.item},null,8,["component"])):A.item.kind==="plan"?(v(),x("details",zM,[N[4]||(N[4]=g("summary",null,[g("i",{class:"ph ph-map-trifold"}),$e(" Plan "),g("i",{class:"ph ph-caret-down plan-chevron"})],-1)),g("div",{class:"plan-body",innerHTML:$(sr)(A.item.text)},null,8,WM)])):(v(),ze(Jx,{key:5,tool:A.item},null,8,["tool"]))]))),128))]),_:1}),t.msg.text?(v(),x("div",{key:1,ref_key:"contentEl",ref:n,class:Ge(["msg-assistant-content",{"msg-flash":e.isFlashing}]),innerHTML:i.value},null,10,KM)):J("",!0),u.value?(v(),x("div",{key:2,class:Ge(["planning-indicator",{"is-executing":l.value}])},[N[5]||(N[5]=g("span",{class:"spinner"},null,-1)),g("span",QM,X(u.value),1)],2)):!t.msg.done&&t.msg.text?(v(),x("span",XM)):J("",!0),t.msg.done?(v(),x("div",ZM,[t.msg.elapsed_seconds!=null?(v(),x("span",JM,[N[6]||(N[6]=g("i",{class:"ph ph-timer"},null,-1)),$e(X(t.msg.elapsed_seconds)+"s ",1)])):J("",!0),t.msg.tool_call_count?(v(),x("span",jM,[N[7]||(N[7]=g("i",{class:"ph ph-wrench"},null,-1)),$e(X(t.msg.tool_call_count),1)])):J("",!0),t.msg.token_count?(v(),x("span",ek,[N[8]||(N[8]=g("i",{class:"ph ph-coins"},null,-1)),$e(X(E(t.msg.token_count)),1)])):J("",!0),$(o)?(v(),x("span",tk,X($(o)),1)):J("",!0),t.msg.text?(v(),ze($(Za),{key:4,icon:$(_)?"ph ph-check":"ph ph-copy",label:$(_)?"Copied!":"Copy",class:"msg-copy-btn",onClick:N[1]||(N[1]=A=>$(m)(t.msg.text))},null,8,["icon","label"])):J("",!0),d.value?(v(),ze($(Za),{key:5,icon:"ph ph-thumbs-up",label:"Useful",class:Ge(["msg-rate-btn",{active:t.msg.rating===1}]),onClick:N[2]||(N[2]=A=>p(1))},null,8,["class"])):J("",!0),d.value?(v(),ze($(Za),{key:6,icon:"ph ph-thumbs-down",label:"Not useful",class:Ge(["msg-rate-btn",{active:t.msg.rating===-1}]),onClick:N[3]||(N[3]=A=>p(-1))},null,8,["class"])):J("",!0)])):J("",!0)])):J("",!0)}}},ak=ht(nk,[["__scopeId","data-v-413d0a09"]]),rk={class:"summary-card"},ik=["innerHTML"],sk={__name:"SummaryCard",props:{msg:{type:Object,required:!0}},setup(t){return(e,n)=>(v(),x("details",rk,[n[0]||(n[0]=g("summary",null,[g("i",{class:"ph ph-article"}),$e(" Context summary ")],-1)),g("div",{class:"thinking-body",innerHTML:$(sr)(t.msg.text)},null,8,ik)]))}},ok={key:0,class:"compression-notice compression-pending"},lk=["open"],ck={key:0,class:"compression-counts"},uk={key:1,class:"ph ph-caret-down compression-chevron"},dk=["innerHTML"],_k={__name:"CompressionNotice",props:{msg:{type:Object,required:!0}},setup(t){return(e,n)=>t.msg.type==="compression_pending"?(v(),x("div",ok,[n[0]||(n[0]=g("i",{class:"ph ph-spinner ph-spin"},null,-1)),g("span",null,X(t.msg.text||"Compressing context…"),1)])):(v(),x("details",{key:1,class:"compression-notice",open:!t.msg.summary},[g("summary",null,[n[1]||(n[1]=g("i",{class:"ph ph-arrows-in"},null,-1)),n[2]||(n[2]=$e(" Context compressed ",-1)),t.msg.before!=null&&t.msg.after!=null?(v(),x("span",ck," ("+X(t.msg.before)+" → "+X(t.msg.after)+" messages) ",1)):J("",!0),t.msg.summary?(v(),x("i",uk)):J("",!0)]),t.msg.summary?(v(),x("div",{key:0,class:"compression-body",innerHTML:$(sr)(t.msg.summary)},null,8,dk)):J("",!0)],8,lk))}},pk=ht(_k,[["__scopeId","data-v-cecede62"]]),mk={__name:"ErrorMessage",props:{msg:{type:Object,required:!0}},setup(t){return(e,n)=>{const a=tt("GnAlert");return v(),ze(a,{variant:"danger",role:"alert"},{default:Be(()=>[n[0]||(n[0]=g("i",{class:"ph ph-warning-octagon"},null,-1)),$e(" "+X(t.msg.text),1)]),_:1})}}},gk={class:"message-list-wrap"},Ek={key:0,class:"session-loading"},fk={key:1,class:"archive-loading"},Sk=["data-msg-index"],bk={__name:"MessageList",setup(t){const e=sn(),n=Y(null),a=Y(!1),r=Y(!1),i=Y(null);let s=!1,o=null,c=null,l=null,u=0,d=0;function _(){return n.value??null}function m(){d=performance.now()}function p(U){const h=e.messages.findIndex(f=>{var A;return(A=f.rawIndices)==null?void 0:A.includes(U)});if(h===-1)return;const N=_(),C=N==null?void 0:N.querySelector(`[data-msg-index="${h}"]`);C?C.scrollIntoView({block:"center",behavior:"smooth"}):N==null||N.scrollTo({top:0,behavior:"smooth"}),i.value=h,l&&clearTimeout(l),l=setTimeout(()=>{i.value=null,l=null},3e3)}function E(U){return U.role==="user"?YD:U.type==="summary"?sk:U.type==="compression_notice"||U.type==="compression_pending"?pk:U.type==="error"?mk:ak}function b(U=!1){if(U){const h=_();h&&h.scrollTo({top:h.scrollHeight,behavior:"smooth"});return}I()}function I(){const U=++u,h=_();if(!h||performance.now()-d<250)return;h.scrollTop=h.scrollHeight;const N=performance.now()+2500;(async()=>{for(;performance.now()1&&(h.scrollTop=h.scrollHeight),await new Promise(A=>requestAnimationFrame(A)),U!==u))return})()}function R(){const U=_();U&&(U.scrollTop=U.scrollHeight,requestAnimationFrame(()=>{U.scrollHeight-U.scrollTop-U.clientHeight>1&&(U.scrollTop=U.scrollHeight)}))}function y(U){const h=U.target;if(!h)return;const N=h.scrollHeight-h.scrollTop-h.clientHeight;if(s=N>100,r.value=N>200,h.scrollTop<80&&e.archiveHasMore&&!e.archiveLoading){const C=Math.floor(h.scrollTop+h.clientHeight/2),f=h.querySelectorAll("[data-msg-index]");for(const A of f)if(A.offsetTop+A.offsetHeight>=C){o=Number(A.dataset.msgIndex),c=Math.round(A.getBoundingClientRect().top);break}e.loadArchivedMessages()}}st(()=>e.messages.length,()=>{!s&&!e.loading&&!e.archiveLoading&&Ht(()=>b())}),st(()=>e.streamingMsg,()=>{s||Ht(()=>R())},{deep:!0}),st(()=>e.archiveLoading,U=>{!U&&o!=null&&Ht(()=>{const h=_(),N=h==null?void 0:h.querySelector(`[data-msg-index="${o}"]`);if(h&&N&&c!=null){const C=Math.round(N.getBoundingClientRect().top)-c;C&&(h.scrollTop+=C)}o=null,c=null})}),st(()=>e.currentId,()=>{u++,s=!1,r.value=!1,a.value=!1,o=null,c=null}),st(()=>e.loading,U=>{U||(e.scrollToMessageIndex!=null?(a.value=!0,L(()=>{p(e.scrollToMessageIndex),e.scrollToMessageIndex=null})):(a.value=!1,L(()=>{b(),a.value=!0})))});function L(U){Ht(()=>requestAnimationFrame(()=>requestAnimationFrame(U)))}return Sn(()=>{!e.loading&&e.messages.length?L(()=>{b(),a.value=!0}):e.loading||(a.value=!0)}),fa(()=>{l&&clearTimeout(l)}),(U,h)=>(v(),x("div",gk,[$(e).loading?(v(),x("div",Ek,[...h[1]||(h[1]=[g("i",{class:"ph ph-spinner animate-spin"},null,-1)])])):J("",!0),$(e).archiveLoading?(v(),x("div",fk,[...h[2]||(h[2]=[g("i",{class:"ph ph-spinner animate-spin"},null,-1),g("span",null,"Loading older messages…",-1)])])):J("",!0),$(e).messages.length?(v(),x("div",{key:2,ref_key:"listRef",ref:n,class:Ge(["message-scroller",{"is-hidden":!a.value}]),onWheelPassive:m,onPointerdownPassive:m,onTouchstartPassive:m,onScrollPassive:y},[(v(!0),x(Ue,null,Dt($(e).messages,(N,C)=>(v(),x("div",{key:N.id??C,class:Ge(["message-row",{"msg-enter":N.animate}]),"data-msg-index":C},[(v(),ze(_f(E(N)),{msg:N,"is-flashing":i.value===C},null,8,["msg","is-flashing"]))],10,Sk))),128))],34)):J("",!0),ne(hr,{name:"scroll-btn"},{default:Be(()=>[r.value?(v(),x("button",{key:0,class:"scroll-to-bottom-btn",title:"Scroll to bottom",onClick:h[0]||(h[0]=N=>b(!0))},[...h[3]||(h[3]=[g("i",{class:"ph ph-arrow-down"},null,-1)])])):J("",!0)]),_:1})]))}},Tk=ht(bk,[["__scopeId","data-v-5c05d9cd"]]);function $S(){const t=sn(),e=Y(!1),n=Y(0),a=Y(!1);function r(R){return t.imagesProcessing++,new Promise((y,L)=>{const U=new FileReader;U.onload=async h=>{try{const N=await i(h.target.result,1024,.9);t.pendingImages.push(N),y()}catch(N){L(N)}finally{t.imagesProcessing--}},U.onerror=()=>{t.imagesProcessing--,L(U.error??new Error("Failed to read file"))},U.readAsDataURL(R)})}function i(R,y=1024,L=.9){return new Promise((U,h)=>{const N=new Image;N.onload=()=>{let C=N.width,f=N.height;if(C>y||f>y){const F=y/Math.max(C,f);C=Math.round(C*F),f=Math.round(f*F)}const A=document.createElement("canvas");A.width=C,A.height=f,A.getContext("2d").drawImage(N,0,0,C,f),A.toBlob(F=>{if(!F){h(new Error("Canvas toBlob failed"));return}const j=new FileReader;j.onload=_e=>U(_e.target.result),j.onerror=h,j.readAsDataURL(F)},"image/jpeg",L)},N.onerror=h,N.src=R})}function s(R){t.pendingImages.splice(R,1)}async function o(R){if(t.currentId){a.value=!0,n.value=0;try{const y=await tv(t.currentId,R);t.pendingFiles.push(y),t.fetchFiles(t.currentId)}finally{a.value=!1,n.value=0}}}function c(R){t.pendingFiles.splice(R,1)}async function l(R){const y=Array.from(R.target.files??[]);R.target.value="",await E(y)}async function u(R){var U;const L=Array.from(((U=R.clipboardData)==null?void 0:U.items)??[]).filter(h=>h.type.startsWith("image/"));if(L.length){R.preventDefault();for(const h of L){const N=h.getAsFile();N&&await r(N)}}}function d(R){R.preventDefault(),I(R)&&(e.value=!0)}function _(R){R.preventDefault()}function m(R){R.currentTarget.contains(R.relatedTarget)||(e.value=!1)}async function p(R){var L;R.preventDefault(),e.value=!1;const y=Array.from(((L=R.dataTransfer)==null?void 0:L.files)??[]);await E(y)}async function E(R){for(const y of R)y.type.startsWith("image/")?await r(y):await o(y)}function b(){t.pendingImages=[],t.pendingFiles=[]}function I(R){var y;return Array.from(((y=R.dataTransfer)==null?void 0:y.types)??[]).includes("Files")}return{isDragging:e,uploading:a,uploadProgress:n,handleFileInput:l,handlePaste:u,handleDragEnter:d,handleDragOver:_,handleDragLeave:m,handleDrop:p,removeImage:s,removeFile:c,clearPending:b}}const hk={class:"file-preview-strip"},vk=["src"],Rk=["onClick"],Ck={class:"file-preview-name"},yk={__name:"FilePreviewStrip",setup(t){const e=sn(),{removeImage:n,removeFile:a}=$S();return(r,i)=>{const s=tt("GnChip");return v(),x("div",hk,[(v(!0),x(Ue,null,Dt($(e).imagesProcessing,o=>(v(),x("div",{key:`img-processing-${o}`,class:"file-preview-image is-processing"},[...i[0]||(i[0]=[g("i",{class:"ph ph-spinner ph-spin"},null,-1)])]))),128)),(v(!0),x(Ue,null,Dt($(e).pendingImages,(o,c)=>(v(),x("div",{key:`img-${c}`,class:"file-preview-image"},[g("img",{src:o,alt:"attachment"},null,8,vk),g("button",{class:"file-preview-remove",onClick:l=>$(n)(c),title:"Remove"},[...i[1]||(i[1]=[g("i",{class:"ph ph-x"},null,-1)])],8,Rk)]))),128)),(v(!0),x(Ue,null,Dt($(e).pendingFiles,(o,c)=>(v(),ze(s,{key:`file-${c}`,class:"file-preview-pill",icon:"ph ph-file",removable:"",title:o.name,onRemove:l=>$(a)(c)},{default:Be(()=>[g("span",Ck,X(o.name),1)]),_:2},1032,["title","onRemove"]))),128))])}}},Nk=ht(yk,[["__scopeId","data-v-f0b09655"]]),Ok={key:1,class:"upload-progress is-indeterminate"},Ak={key:2,class:"sending-notice"},Ik={class:"input-row"},Dk=["disabled"],wk=["disabled","onKeydown"],xk=["disabled"],Lk={__name:"InputBar",props:{ws:{type:Object,required:!0}},setup(t){const e=t,n=sn(),{isDragging:a,uploading:r,handleFileInput:i,handlePaste:s,handleDragEnter:o,handleDragOver:c,handleDragLeave:l,handleDrop:u,clearPending:d}=$S(),_=Y(""),m=Y(null),p=Y(null),E=Y(!1),b=ue(()=>!!n.currentId&&!n.streaming&&!E.value&&(_.value.trim()||n.pendingImages.length||n.pendingFiles.length));st(()=>n.currentId,C=>{_.value=C?n.loadDraft(C):"",Ht(L)},{immediate:!0});let I=null;st(_,C=>{I&&clearTimeout(I),I=setTimeout(()=>n.saveDraft(C),300)});const{pendingQuote:R,consumeQuote:y}=eS();st(R,C=>{if(!C)return;const f=C.split(` +`).map(A=>`> ${A}`).join(` +`);_.value=f+` + +`+_.value,y(),Ht(()=>{var w;L(),(w=m.value)==null||w.focus();const A=m.value;A&&(A.selectionStart=A.selectionEnd=A.value.length)})});function L(){const C=m.value;C&&(C.style.height="auto",C.style.height=Math.min(C.scrollHeight,144)+"px")}function U(){if(!(!b.value||E.value)){E.value=!0;try{const C=_.value.trim(),f=[...n.pendingImages],A=[...n.pendingFiles];n.appendUserMessage(C,f,A),d(),_.value="",Ht(L);const w=f.map(j=>j.split(",",2)[1]).filter(Boolean),F={type:"message",content:C||" "};w.length&&(F.images=w),A.length&&(F.files=A),e.ws.send(F),n.streaming||(n.awaitingStream=!0)}finally{E.value=!1}}}function h(){const C=m.value;if(!C)return;const f=C.selectionStart,A=C.selectionEnd;_.value=_.value.slice(0,f)+` +`+_.value.slice(A),Ht(()=>{C.selectionStart=C.selectionEnd=f+1,L()})}async function N(){n.currentId&&await Kh(n.currentId)}return(C,f)=>(v(),x("div",{class:Ge(["input-bar input-dropzone",{"is-dragging":$(a)}]),onDragenter:f[4]||(f[4]=(...A)=>$(o)&&$(o)(...A)),onDragover:f[5]||(f[5]=(...A)=>$(c)&&$(c)(...A)),onDragleave:f[6]||(f[6]=(...A)=>$(l)&&$(l)(...A)),onDrop:f[7]||(f[7]=(...A)=>$(u)&&$(u)(...A))},[$(n).pendingImages.length||$(n).pendingFiles.length?(v(),ze(Nk,{key:0})):J("",!0),$(r)?(v(),x("div",Ok,[...f[8]||(f[8]=[g("div",{class:"upload-progress-fill"},null,-1)])])):J("",!0),$(n).awaitingStream&&!$(n).streaming?(v(),x("div",Ak,[...f[9]||(f[9]=[g("i",{class:"ph ph-spinner ph-spin"},null,-1),$e(" Sending… ",-1)])])):J("",!0),g("div",Ik,[g("input",{ref_key:"fileInputEl",ref:p,type:"file",multiple:"",style:{display:"none"},onChange:f[0]||(f[0]=(...A)=>$(i)&&$(i)(...A))},null,544),g("button",{class:"btn-icon",title:"Attach files",disabled:!$(n).currentId,onClick:f[1]||(f[1]=A=>p.value.click())},[...f[10]||(f[10]=[g("i",{class:"ph ph-paperclip"},null,-1)])],8,Dk),Ka(g("textarea",{ref_key:"textareaEl",ref:m,"onUpdate:modelValue":f[2]||(f[2]=A=>_.value=A),class:"input-textarea",placeholder:"Message Navi…",rows:"1",disabled:!$(n).currentId,onKeydown:[ea(ga(U,["exact","prevent"]),["enter"]),ea(ga(h,["ctrl","prevent"]),["enter"])],onInput:L,onPaste:f[3]||(f[3]=(...A)=>$(s)&&$(s)(...A))},null,40,wk),[[ai,_.value]]),$(n).streaming?(v(),x("button",{key:0,class:"btn-icon",title:"Stop generation",onClick:N},[...f[11]||(f[11]=[g("i",{class:"ph ph-stop-circle"},null,-1)])])):(v(),x("button",{key:1,class:"btn-icon",title:"Send (Enter)",disabled:!b.value,onClick:U},[...f[12]||(f[12]=[g("i",{class:"ph ph-paper-plane-tilt"},null,-1)])],8,xk))])],34))}},Mk=ht(Lk,[["__scopeId","data-v-c90111b2"]]),kk={key:0,class:"task-chips"},Pk={__name:"QueuedMessagesChip",setup(t){const e=sn(),n=ue(()=>"Queued while the current turn is running — they execute next");return(a,r)=>{const i=tt("GnChip");return v(),ze(hr,{name:"fade"},{default:Be(()=>[$(e).queuedMessages.count?(v(),x("div",kk,[ne(i,{icon:"ph ph-inbox",title:n.value},{default:Be(()=>[$e(X($(e).queuedMessages.count)+" message"+X($(e).queuedMessages.count===1?"":"s")+" queued ",1)]),_:1},8,["title"])])):J("",!0)]),_:1})}}},Uk=ht(Pk,[["__scopeId","data-v-af03bea1"]]),Fk={class:"chat-area"},Bk={key:1,class:"empty-chat"},Gk={__name:"ChatArea",emits:["toggle-sidebar","toggle-artifacts"],setup(t,{emit:e}){const n=e,a=sn(),r=hD();st(()=>a.currentId,s=>{s?r.connect(s):r.disconnect()},{immediate:!0});function i(){a.currentId&&r.connect(a.currentId)}return fa(()=>r.disconnect()),(s,o)=>{const c=tt("GnIconButton"),l=tt("GnAlert"),u=tt("GnEmptyState");return v(),x("div",Fk,[ne(LD,{onToggleSidebar:o[0]||(o[0]=d=>n("toggle-sidebar")),onToggleArtifacts:o[1]||(o[1]=d=>n("toggle-artifacts"))}),ne(hr,{name:"fade"},{default:Be(()=>[$(r).reconnectFailed.value?(v(),ze(l,{key:0,variant:"warning",class:"reconnect-banner"},{default:Be(()=>[o[2]||(o[2]=g("i",{class:"ph ph-wifi-slash"},null,-1)),o[3]||(o[3]=$e(" Connection lost. Retrying in background… ",-1)),ne(c,{icon:"ph ph-arrows-clockwise",label:"Retry",onClick:i})]),_:1})):J("",!0)]),_:1}),$(a).currentId?(v(),x(Ue,{key:0},[ne(Tk),ne(Uk),ne(Mk,{ws:$(r)},null,8,["ws"])],64)):(v(),x("div",Bk,[ne(u,{icon:"ph ph-chat-dots",title:"Nothing open",text:"Select a conversation or start a new one"})]))])}}},Yk=ht(Gk,[["__scopeId","data-v-afc23956"]]),$k=ka("apiTokens",()=>{const t=Y([]),e=Y(!1),n=Y(!1);async function a(){e.value=!0;try{const s=await av();t.value=s.items||[]}finally{e.value=!1}}async function r(s){n.value=!0;try{const o=await rv(s);return t.value.unshift({id:o.id,name:o.name,token_prefix:o.token_prefix,created_at:o.created_at,last_used_at:null}),o}finally{n.value=!1}}async function i(s){await iv(s),t.value=t.value.filter(o=>o.id!==s)}return{tokens:t,loading:e,creating:n,fetchTokens:a,createToken:r,revokeToken:i}}),qk={class:"create-key-body"},Hk={__name:"CreateKeyModal",props:{open:Boolean,creating:Boolean},emits:["close","submit"],setup(t,{emit:e}){const n=t,a=e,r=Y("");st(()=>n.open,s=>{s&&(r.value="")});function i(){const s=r.value.trim();s&&a("submit",s)}return(s,o)=>{const c=tt("GnInput"),l=tt("GnButton"),u=tt("GnModal");return v(),ze(u,{open:n.open,title:"Create API Key","onUpdate:open":o[2]||(o[2]=d=>a("close"))},{actions:Be(()=>[ne(l,{variant:"secondary",onClick:o[1]||(o[1]=d=>a("close")),disabled:n.creating},{default:Be(()=>[...o[3]||(o[3]=[$e(" Cancel ",-1)])]),_:1},8,["disabled"]),ne(l,{variant:"primary",loading:n.creating,onClick:i},{default:Be(()=>[...o[4]||(o[4]=[$e(" Create ",-1)])]),_:1},8,["loading"])]),default:Be(()=>[g("div",qk,[ne(c,{modelValue:r.value,"onUpdate:modelValue":o[0]||(o[0]=d=>r.value=d),label:"Name",placeholder:"e.g. Smart Watch, Automation Script",disabled:n.creating,onKeydown:ea(i,["enter"])},null,8,["modelValue","disabled"])])]),_:1},8,["open"])}}},Vk=ht(Hk,[["__scopeId","data-v-db609bf3"]]),zk={class:"show-token-body"},Wk={class:"show-token-value"},Kk={__name:"ShowTokenModal",props:{open:Boolean,token:String},emits:["close"],setup(t,{emit:e}){const n=t,a=e;return(r,i)=>{const s=tt("GnCopyButton"),o=tt("GnInputGroup"),c=tt("GnButton"),l=tt("GnModal");return v(),ze(l,{open:n.open,title:"API Key Created","onUpdate:open":i[1]||(i[1]=u=>a("close"))},{actions:Be(()=>[ne(c,{variant:"primary",onClick:i[0]||(i[0]=u=>a("close"))},{default:Be(()=>[...i[3]||(i[3]=[$e(" Done ",-1)])]),_:1})]),default:Be(()=>[g("div",zk,[i[2]||(i[2]=g("p",{class:"show-token-warning"},[g("i",{class:"ph ph-warning-circle"}),$e(" Copy this token now — it will "),g("strong",null,"never be shown again"),$e(". ")],-1)),ne(o,null,{action:Be(()=>[ne(s,{text:n.token,label:"Copy to clipboard"},null,8,["text"])]),default:Be(()=>[g("code",Wk,X(n.token),1)]),_:1})])]),_:1},8,["open"])}}},Qk=ht(Kk,[["__scopeId","data-v-1b3695e8"]]),Xk={class:"api-keys-panel"},Zk={class:"api-keys-header"},Jk={key:1,class:"api-keys-loading"},jk={__name:"ApiKeysPanel",setup(t){const e=$k(),n=is(),a=ss(),r=Or(),i=Y(!1),s=Y(!1),o=Y(""),c=[{key:"name",label:"Name"},{key:"token_prefix",label:"Key"},{key:"created_at",label:"Created"},{key:"last_used_at",label:"Last used"},{key:"actions",label:""}];Sn(()=>{e.fetchTokens()});function l(){i.value=!0}async function u(m){try{const p=await e.createToken(m);i.value=!1,o.value=p.token,s.value=!0}catch(p){r.error({title:"Failed to create key",text:p.message})}}async function d(m,p){if(await a(`Revoke API key "${p}"? This cannot be undone.`))try{await e.revokeToken(m),r.success({title:"API key revoked"})}catch(b){r.error({title:"Failed to revoke key",text:b.message})}}function _(m){return m?new Date(m).toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"}):null}return(m,p)=>{const E=tt("GnButton"),b=tt("GnAlert"),I=tt("GnLoader"),R=tt("GnIconButton"),y=tt("GnTable");return v(),x("div",Xk,[g("div",Zk,[p[3]||(p[3]=g("h2",{class:"api-keys-title"},"API Keys",-1)),ne(E,{variant:"primary",icon:"ph ph-plus",onClick:l},{default:Be(()=>[...p[2]||(p[2]=[$e(" New Key ",-1)])]),_:1})]),p[5]||(p[5]=g("p",{class:"api-keys-description"}," API keys allow headless clients (scripts, voice assistants, IoT devices) to authenticate without browser-based OAuth. ",-1)),$(n).isNoAuthMode?(v(),ze(b,{key:0,variant:"warning",class:"api-keys-warning"},{default:Be(()=>[...p[4]||(p[4]=[g("i",{class:"ph ph-warning-circle"},null,-1),$e(" Authorization is currently disabled. Any keys created here are tied to the local anonymous user and grant full access to this Navi instance. ",-1)])]),_:1})):J("",!0),$(e).loading?(v(),x("div",Jk,[ne(I,{circle:"",label:"Loading API keys"})])):(v(),ze(y,{key:2,columns:c,rows:$(e).tokens,"empty-text":"No API keys yet. Create one to get started."},{"cell-token_prefix":Be(({row:L})=>[g("code",null,X(L.token_prefix),1)]),"cell-created_at":Be(({row:L})=>[$e(X(_(L.created_at)),1)]),"cell-last_used_at":Be(({row:L})=>[$e(X(_(L.last_used_at)||"Never"),1)]),"cell-actions":Be(({row:L})=>[ne(R,{icon:"ph ph-trash",label:"Revoke",onClick:U=>d(L.id,L.name)},null,8,["onClick"])]),_:1},8,["rows"])),ne(Vk,{open:i.value,creating:$(e).creating,onClose:p[0]||(p[0]=L=>i.value=!1),onSubmit:u},null,8,["open","creating"]),ne(Qk,{open:s.value,token:o.value,onClose:p[1]||(p[1]=L=>s.value=!1)},null,8,["open","token"])])}}},eP=ht(jk,[["__scopeId","data-v-2cf539c2"]]);function tP(t){const e="=".repeat((4-t.length%4)%4),n=(t+e).replace(/-/g,"+").replace(/_/g,"/"),a=atob(n),r=new Uint8Array(a.length);for(let i=0;ids()&&qS()),Yi=Y(qS()?Notification.permission:"denied"),ri=Y(!1),nr=Y(!1);async function VS(){if(!md()||!ds())return null;const t=await navigator.serviceWorker.getRegistration();return t?t.pushManager.getSubscription():null}async function nP(){if(!(!md()||!ds()))try{const t=await VS();ri.value=!!t,Yi.value=notificationsSupported?Notification.permission:"denied"}catch{ri.value=!1}}async function aP(){if(!(!HS.value||nr.value)){nr.value=!0;try{if(Yi.value=await Notification.requestPermission(),Yi.value!=="granted")return!1;const{public_key:t}=await gv();if(!t)return!1;const e=await navigator.serviceWorker.ready;let n=await e.pushManager.getSubscription();n||(n=await e.pushManager.subscribe({userVisibleOnly:!0,applicationServerKey:tP(t)}));const a=n.toJSON();return await Ev({endpoint:a.endpoint,keys:a.keys,user_agent:navigator.userAgent}),ri.value=!0,!0}finally{nr.value=!1}}}async function rP(){if(!(!md()||!ds()||nr.value)){nr.value=!0;try{const t=await VS();if(t){try{await fv(t.endpoint)}catch{}await t.unsubscribe()}ri.value=!1}finally{nr.value=!1}}}function iP(){return{supported:HS,permission:Yi,subscribed:ri,busy:nr,enable:aP,disable:rP,syncState:nP}}const sP={class:"notifications-panel"},oP={key:1,class:"notifications-row"},lP={class:"notifications-row-text"},cP={class:"notifications-row-status"},uP={__name:"NotificationSettingsPanel",setup(t){const{supported:e,permission:n,subscribed:a,busy:r,enable:i,disable:s,syncState:o}=iP(),c=Or();Sn(()=>{o()});async function l(u){try{if(u){const d=await i();d===!1&&n.value==="denied"?c.error({title:"Permission denied",text:"Allow notifications in the browser site settings."}):d===!1&&c.error({title:"Push unavailable",text:"The server does not accept push subscriptions right now."})}else await s()}catch(d){c.error({title:"Push error",text:d.message})}}return(u,d)=>{const _=tt("GnAlert"),m=tt("GnSwitch");return v(),x("div",sP,[d[2]||(d[2]=g("h2",{class:"notifications-title"},"Notifications",-1)),d[3]||(d[3]=g("p",{class:"notifications-description"}," Push notifications let Navi ping you when a reply is ready — even when the tab is closed. You get one notification per finished reply, but only when no Navi window is open on that session. ",-1)),$(e)?(v(),x("div",oP,[g("div",lP,[d[1]||(d[1]=g("div",{class:"notifications-row-title"},"Push notifications",-1)),g("div",cP,[$(a)?(v(),x(Ue,{key:0},[$e("Enabled — this device is subscribed.")],64)):$(n)==="denied"?(v(),x(Ue,{key:1},[$e("Blocked in browser site settings.")],64)):(v(),x(Ue,{key:2},[$e("Disabled.")],64))])]),ne(m,{"model-value":$(a),disabled:$(r)||$(n)==="denied","onUpdate:modelValue":l},null,8,["model-value","disabled"])])):(v(),ze(_,{key:0,variant:"info",class:"notifications-unsupported"},{default:Be(()=>[...d[0]||(d[0]=[g("i",{class:"ph ph-info"},null,-1),g("span",null," This browser does not support web push (needs HTTPS, a service worker and the Push API). Try Chrome or a recent Firefox. ",-1)])]),_:1}))])}}},dP=ht(uP,[["__scopeId","data-v-aef788e9"]]),_P=ka("synapseReactions",()=>{const t=Y(null),e=Y([]),n=Y(!1),a=Y(!1);async function r(){n.value=!0;try{t.value=await cv()}finally{n.value=!1}}async function i(o=20){const c=await dv(o);e.value=c.items||[]}async function s(o){a.value=!0;try{t.value=await uv({...t.value||{},...o})}finally{a.value=!1}}return{settings:t,versions:e,loading:n,saving:a,fetchSettings:r,fetchVersions:i,save:s}}),pP={class:"reactions-panel"},mP={key:1,class:"reactions-loading"},gP={class:"reactions-row"},EP={class:"reactions-row-text"},fP={class:"reactions-row-status"},SP={class:"reactions-row"},bP={class:"reactions-row-text"},TP={class:"reactions-row-status"},hP={class:"reactions-row"},vP={class:"reactions-instructions"},RP={class:"reactions-instructions-actions"},CP={key:0,class:"reactions-history"},yP={class:"reactions-history-meta"},NP={class:"reactions-history-text"},OP='e.g. "Todo events from gntodo go to the developer profile; junk mail goes nowhere."',AP={__name:"SynapseReactionsPanel",setup(t){const e=[{value:"always",label:"Always"},{value:"important",label:"Only failures"},{value:"never",label:"Never"}],n=ue(()=>{var m,p;return[{value:"app",label:"App only"},{value:"app_synapse",label:"App + Synapse",disabled:!((m=s.value)!=null&&m.source_ready)},{value:"synapse",label:"Synapse only",disabled:!((p=s.value)!=null&&p.source_ready)}]}),a={always:"Push on every finished run.",important:"Push only when a run ended with errors.",never:"No completion push."},r=_P(),i=Or(),s=ue(()=>r.settings),o=Y(!1),c=Y(""),l=ue(()=>s.value!==null&&c.value!==s.value.instructions);st(s,m=>{m&&c.value!==m.instructions&&(c.value=m.instructions)},{immediate:!0}),Sn(async()=>{o.value=!0;try{await r.fetchSettings(),await r.fetchVersions()}catch(m){i.error({title:"Failed to load reaction settings",text:m.message})}});async function u(m){try{await r.save(m)}catch(p){i.error({title:"Failed to save",text:p.message})}}async function d(){try{await r.save({instructions:c.value}),await r.fetchVersions(),i.success({title:"Instructions saved"})}catch(m){i.error({title:"Failed to save instructions",text:m.message})}}function _(m){const p=new Date(m);return p.toLocaleDateString(void 0,{month:"short",day:"numeric"})+" "+p.toLocaleTimeString(void 0,{hour:"2-digit",minute:"2-digit"})}return(m,p)=>{var E;return v(),x("div",pP,[p[12]||(p[12]=g("h2",{class:"reactions-title"},"Synapse reactions",-1)),p[13]||(p[13]=g("p",{class:"reactions-description"},' When a GNEXUS Synapse event is delivered, Navi can react to it on its own: a dispatcher picks a profile by your reaction instructions, the work runs in a hidden service session, and you can browse that session later via the sidebar "Service sessions" toggle. ',-1)),o.value&&!((E=s.value)!=null&&E.source_ready)?(v(),ze($(td),{key:0,variant:"info",class:"reactions-alert"},{default:Be(()=>[...p[4]||(p[4]=[g("i",{class:"ph ph-info"},null,-1),g("span",null," Synapse integration is not configured on this navi: options that send events to Synapse are disabled. App-only delivery keeps working. ",-1)])]),_:1})):J("",!0),$(r).loading&&!s.value?(v(),x("div",mP,[ne($(ls),{circle:"",label:"Loading reaction settings"})])):s.value?(v(),x(Ue,{key:2},[g("div",gP,[g("div",EP,[p[5]||(p[5]=g("div",{class:"reactions-row-title"},"Enable reactions",-1)),g("div",fP,X(s.value.reactions_enabled?"Delivered events start a background reaction run.":"Events are accepted and logged, but Navi does nothing."),1)]),ne($(TS),{"model-value":s.value.reactions_enabled,disabled:$(r).saving,"onUpdate:modelValue":p[0]||(p[0]=b=>u({reactions_enabled:b}))},null,8,["model-value","disabled"])]),g("div",SP,[g("div",bP,[p[6]||(p[6]=g("div",{class:"reactions-row-title"},"Notify me about finished reactions",-1)),g("div",TP,X(a[s.value.completion_notify]),1)]),ne($(Du),{"model-value":s.value.completion_notify,name:"completion-notify",options:e,"onUpdate:modelValue":p[1]||(p[1]=b=>u({completion_notify:b}))},null,8,["model-value"])]),g("div",hP,[p[7]||(p[7]=g("div",{class:"reactions-row-text"},[g("div",{class:"reactions-row-title"},"Where notifications go"),g("div",{class:"reactions-row-status"}," Applies to Navi's notify tool and to reaction-completion pushes. ")],-1)),ne($(Du),{"model-value":s.value.push_target,name:"push-target",options:n.value,"onUpdate:modelValue":p[2]||(p[2]=b=>u({push_target:b}))},null,8,["model-value","options"])]),g("div",vP,[p[10]||(p[10]=g("div",{class:"reactions-row-title"},"Reaction instructions",-1)),p[11]||(p[11]=g("div",{class:"reactions-row-status"}," Guidance the dispatcher uses to pick a profile and to shape the task. Both you and Navi can edit it; every change is recorded in the history below. ",-1)),ne($(vS),{modelValue:c.value,"onUpdate:modelValue":p[3]||(p[3]=b=>c.value=b),rows:6,placeholder:OP,class:"reactions-instructions-textarea"},null,8,["modelValue"]),g("div",RP,[ne($(An),{variant:"primary",disabled:!l.value||$(r).saving,onClick:d},{default:Be(()=>[...p[8]||(p[8]=[$e(" Save instructions ",-1)])]),_:1},8,["disabled"])]),$(r).versions.length?(v(),x("div",CP,[p[9]||(p[9]=g("div",{class:"reactions-history-title"},"Edit history",-1)),(v(!0),x(Ue,null,Dt($(r).versions,b=>(v(),x("div",{key:b.created_at+":"+b.content.slice(0,24),class:"reactions-history-item"},[g("span",yP,[g("i",{class:Ge(["ph",b.edited_by==="navi"?"ph-robot":"ph-user"])},null,2),$e(" "+X(b.edited_by==="navi"?"Navi":"You")+" · "+X(_(b.created_at))+" ",1),b.reason?(v(),x(Ue,{key:0},[$e(" · "+X(b.reason),1)],64)):J("",!0)]),g("div",NP,X(b.content),1)]))),128))])):J("",!0)])],64)):J("",!0)])}}},IP=ht(AP,[["__scopeId","data-v-0a24e5f3"]]),DP=ka("synapseTargets",()=>{const t=Y([]),e=Y(!1),n=Y(!1);async function a(){e.value=!0;try{const s=await sv();t.value=s.items||[]}finally{e.value=!1}}async function r(s,o){n.value=!0;try{const c=await ov(s,o);return t.value.unshift({id:c.id,token_ref:c.token_ref,created_at:c.created_at}),c}finally{n.value=!1}}async function i(s){await lv(s),t.value=t.value.filter(o=>o.id!==s)}return{targets:t,loading:e,creating:n,fetchTargets:a,createTarget:r,revokeTarget:i}}),wP={class:"create-target-body"},xP={__name:"CreateTargetModal",props:{open:Boolean,creating:Boolean},emits:["close","submit"],setup(t,{emit:e}){const n=t,a=e,r=Y(""),i=Y("");st(()=>n.open,o=>{o&&(r.value="",i.value="")});function s(){const o=r.value.trim(),c=i.value.trim();!o||c.length<16||a("submit",o,c)}return(o,c)=>(v(),ze($(nd),{open:n.open,title:"Add Synapse Target","onUpdate:open":c[3]||(c[3]=l=>a("close"))},{actions:Be(()=>[ne($(An),{variant:"secondary",onClick:c[2]||(c[2]=l=>a("close")),disabled:n.creating},{default:Be(()=>[...c[5]||(c[5]=[$e(" Cancel ",-1)])]),_:1},8,["disabled"]),ne($(An),{variant:"primary",loading:n.creating,onClick:s},{default:Be(()=>[...c[6]||(c[6]=[$e(" Add ",-1)])]),_:1},8,["loading"])]),default:Be(()=>[g("div",wP,[ne($(Rr),{modelValue:r.value,"onUpdate:modelValue":c[0]||(c[0]=l=>r.value=l),label:"Token ref",placeholder:"e.g. navi-main (as in the Synapse admin panel)",disabled:n.creating,onKeydown:ea(s,["enter"])},null,8,["modelValue","disabled"]),ne($(Rr),{modelValue:i.value,"onUpdate:modelValue":c[1]||(c[1]=l=>i.value=l),label:"Delivery secret",placeholder:"s2s secret of the Synapse target",disabled:n.creating,onKeydown:ea(s,["enter"])},null,8,["modelValue","disabled"]),c[4]||(c[4]=g("p",{class:"create-target-hint"},[$e(" In the Synapse admin panel create a target pointing at "),g("code",null,"POST /webhooks/synapse"),$e(" of this Navi and paste its secret here. Navi uses it to verify that deliveries really came from Synapse. ")],-1))])]),_:1},8,["open"]))}},LP=ht(xP,[["__scopeId","data-v-f6ec4fb5"]]),MP={class:"synapse-panel"},kP={class:"synapse-header"},PP={key:0,class:"synapse-loading"},UP={__name:"SynapseTargetsPanel",setup(t){const e=DP(),n=ss(),a=Or(),r=Y(!1),i=[{key:"token_ref",label:"Token ref"},{key:"created_at",label:"Created"},{key:"actions",label:""}];Sn(()=>{e.fetchTargets()});async function s(l,u){try{await e.createTarget(l,u),r.value=!1,a.success({title:"Target added"})}catch(d){a.error({title:"Failed to add target",text:d.message})}}async function o(l,u){if(await n(`Revoke Synapse target "${u}"? This cannot be undone.`))try{await e.revokeTarget(l),a.success({title:"Target revoked"})}catch(_){a.error({title:"Failed to revoke target",text:_.message})}}function c(l){return l?new Date(l).toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"}):null}return(l,u)=>(v(),x("div",MP,[g("div",kP,[u[3]||(u[3]=g("h2",{class:"synapse-title"},"Synapse deliveries",-1)),ne($(An),{variant:"primary",icon:"ph ph-plus",onClick:u[0]||(u[0]=d=>r.value=!0)},{default:Be(()=>[...u[2]||(u[2]=[$e(" Add Target ",-1)])]),_:1})]),u[4]||(u[4]=g("p",{class:"synapse-description"}," Deliveries from the GNEXUS Synapse notification hub arrive at this Navi's webhook and are verified against a per-user target secret. Create the target in the Synapse admin panel, then register it here to let Navi accept its deliveries. ",-1)),$(e).loading?(v(),x("div",PP,[ne($(ls),{circle:"",label:"Loading targets"})])):(v(),ze($(hS),{key:1,columns:i,rows:$(e).targets,"empty-text":"No Synapse targets registered. Add one to start receiving deliveries."},{"cell-created_at":Be(({row:d})=>[$e(X(c(d.created_at)),1)]),"cell-actions":Be(({row:d})=>[ne($(Za),{icon:"ph ph-trash",label:"Revoke",onClick:_=>o(d.id,d.token_ref)},null,8,["onClick"])]),_:1},8,["rows"])),ne(LP,{open:r.value,creating:$(e).creating,onClose:u[1]||(u[1]=d=>r.value=!1),onSubmit:s},null,8,["open","creating"])]))}},FP=ht(UP,[["__scopeId","data-v-6049b504"]]),BP=ka("mcpKeys",()=>{const t=Y([]),e=Y(!1),n=Y(null);async function a(){e.value=!0;try{const s=await _v();t.value=s.items||[]}finally{e.value=!1}}async function r(s,o){n.value=s;try{const c=await pv(s,o),l=t.value.find(u=>u.server_name===s);l&&(l.has_key=!0,l.updated_at=c.updated_at)}finally{n.value=null}}async function i(s){n.value=s;try{await mv(s);const o=t.value.find(c=>c.server_name===s);o&&(o.has_key=!1,o.updated_at=null)}finally{n.value=null}}return{servers:t,loading:e,savingServer:n,fetchServers:a,saveKey:r,resetKey:i}}),GP={class:"mcp-keys-panel"},YP={key:0,class:"mcp-keys-loading"},$P={key:1,class:"mcp-keys-empty"},qP={key:2,class:"mcp-keys-rows"},HP={class:"mcp-keys-info"},VP={class:"mcp-keys-server"},zP={class:"mcp-keys-where"},WP={key:0,class:"mcp-keys-updated"},KP={class:"mcp-keys-actions"},QP={__name:"McpKeysPanel",setup(t){const e=BP(),n=ss(),a=Or(),r=ar({});Sn(()=>{e.fetchServers()});function i(l){return l.key_type==="header"?`${l.key_location} header${l.prefix?` (${l.prefix}…)`:""}`:`${l.key_location} env`}async function s(l){const u=(r[l.server_name]||"").trim();if(u)try{await e.saveKey(l.server_name,u),r[l.server_name]="",a.success({title:`Key saved for ${l.server_name}`})}catch(d){a.error({title:"Failed to save key",text:d.message})}}async function o(l){if(await n(`Reset the key for "${l.server_name}" to the shared default?`))try{await e.resetKey(l.server_name),r[l.server_name]="",a.success({title:`Key reset for ${l.server_name}`})}catch(d){a.error({title:"Failed to reset key",text:d.message})}}function c(l){return new Date(l).toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"})}return(l,u)=>(v(),x("div",GP,[u[3]||(u[3]=g("div",{class:"mcp-keys-header"},[g("h2",{class:"mcp-keys-title"},"MCP Keys")],-1)),u[4]||(u[4]=g("p",{class:"mcp-keys-description"},' Some connected MCP servers accept a personal key ("one key per user"). Save your own key to make the server work on it; without a key it falls back to the shared default configured on this Navi. ',-1)),$(e).loading?(v(),x("div",YP,[ne($(ls),{circle:"",label:"Loading MCP servers"})])):$(e).servers.length?(v(),x("div",qP,[(v(!0),x(Ue,null,Dt($(e).servers,d=>(v(),x("div",{key:d.server_name,class:"mcp-keys-row"},[g("div",HP,[g("div",VP,X(d.server_name),1),g("div",zP,X(i(d)),1),d.updated_at?(v(),x("div",WP," Personal key set "+X(c(d.updated_at)),1)):J("",!0)]),ne($(Rr),{modelValue:r[d.server_name],"onUpdate:modelValue":_=>r[d.server_name]=_,type:"password",placeholder:d.has_key?"••• saved — enter a new key to replace":"Paste your key",class:"mcp-keys-input",onKeyup:ea(_=>s(d),["enter"])},null,8,["modelValue","onUpdate:modelValue","placeholder","onKeyup"]),g("div",KP,[ne($(An),{variant:"primary",size:"sm",disabled:!r[d.server_name]||$(e).savingServer===d.server_name,onClick:_=>s(d)},{default:Be(()=>[...u[1]||(u[1]=[$e(" Save ",-1)])]),_:1},8,["disabled","onClick"]),d.has_key?(v(),ze($(An),{key:0,variant:"ghost",size:"sm",disabled:$(e).savingServer===d.server_name,onClick:_=>o(d)},{default:Be(()=>[...u[2]||(u[2]=[$e(" Reset to default ",-1)])]),_:1},8,["disabled","onClick"])):J("",!0)])]))),128))])):(v(),x("div",$P,[...u[0]||(u[0]=[g("i",{class:"ph ph-plugs-connected empty-icon","aria-hidden":"true"},null,-1),g("p",null,[$e(" No MCP servers accept a personal key here. A server appears in this list once its config declares a "),g("code",null,"user_key"),$e(" slot — until then it runs on the shared default configured on this Navi. ")],-1)])]))]))}},XP=ht(QP,[["__scopeId","data-v-09b3eec4"]]),ZP={class:"settings-view"},JP={class:"chat-header"},jP={__name:"SettingsView",emits:["toggle-sidebar"],setup(t,{emit:e}){const n=e,a=[{id:"account",label:"Account",icon:"ph ph-user-circle"},{id:"notifications",label:"Notifications",icon:"ph ph-bell"},{id:"synapse",label:"Synapse",icon:"ph ph-network"},{id:"mcp",label:"MCP",icon:"ph ph-plugs-connected"}],r=Y("account"),i=Y(null);return st(r,()=>{Ht(()=>{var c,l;const s=(c=i.value)==null?void 0:c.$el,o=(l=s==null?void 0:s.querySelector)==null?void 0:l.call(s,'[role="tab"][aria-selected="true"]');o==null||o.scrollIntoView({behavior:"smooth",block:"nearest",inline:"nearest"})})}),(s,o)=>(v(),x("div",ZP,[g("div",JP,[ne($(Za),{icon:"ph ph-sidebar",label:"Menu",class:"btn-sidebar-toggle",onClick:o[0]||(o[0]=c=>n("toggle-sidebar"))}),o[2]||(o[2]=g("div",{class:"chat-header-info"},[g("span",{class:"chat-header-title"},"Settings")],-1))]),ne($(ad),{ref_key:"tabsRoot",ref:i,modelValue:r.value,"onUpdate:modelValue":o[1]||(o[1]=c=>r.value=c),items:a,class:"settings-tabs",ariaLabel:"Settings sections"},{account:Be(()=>[r.value==="account"?(v(),ze(eP,{key:0})):J("",!0)]),notifications:Be(()=>[r.value==="notifications"?(v(),ze(dP,{key:0})):J("",!0)]),synapse:Be(()=>[r.value==="synapse"?(v(),ze(IP,{key:0})):J("",!0),r.value==="synapse"?(v(),ze(FP,{key:1})):J("",!0)]),mcp:Be(()=>[r.value==="mcp"?(v(),ze(XP,{key:0})):J("",!0)]),_:1},8,["modelValue"])]))}},eU=ht(jP,[["__scopeId","data-v-7cd70059"]]),tU={class:"app-shell"},nU={class:"app-main"},aU={__name:"App",setup(t){const e=Un(),n=li(),a=sn(),r=is(),i=Y(!1),s=Y(!1);function o(){return location.hash==="#settings"?"settings":"chat"}const c=Y(o()),l=ue(()=>c.value==="chat"&&!a.currentId&&!a.loading),u=ue(()=>{var I;if(c.value==="settings")return"Navi — Settings";if(!a.currentId)return"Navi";const b=a.currentId;return e.nameById[b]||((I=e.sessions.find(R=>R.session_id===b))==null?void 0:I.name)||b.slice(0,8)});st(u,b=>{document.title=b},{immediate:!0});function d(){i.value=!1}function _(){s.value=!1}function m(){const b=!i.value;b&&(s.value=!1),i.value=b}function p(){const b=!s.value;b&&(i.value=!1),s.value=b}function E(){c.value=o();const b=location.hash;if(b==="#settings")return;const I=b.slice(1);I&&I!==a.currentId&&a.loadSession(I)}return Sn(async()=>{if(window.addEventListener("hashchange",E),await r.fetchStatus(),r.authConfigured)try{await r.fetchMe()}catch{}if(!r.authConfigured||r.isAuthenticated)try{await n.fetchProfiles(),await e.fetchSessions(n.selectedProfileId)}catch{}if(location.hash&&location.hash!=="#settings"){const b=location.hash.slice(1);b&&a.loadSession(b)}}),fa(()=>{window.removeEventListener("hashchange",E)}),(b,I)=>{const R=tt("GnToastProvider");return v(),ze(R,null,{default:Be(()=>[g("div",tU,[i.value?(v(),x("div",{key:0,class:"sidebar-backdrop",onClick:d})):J("",!0),ne(hr,{name:"backdrop-fade"},{default:Be(()=>[s.value?(v(),x("div",{key:0,class:"artifacts-backdrop",onClick:_})):J("",!0)]),_:1}),ne(tR,{"mobile-open":i.value,class:Ge({"is-hidden-by-artifacts":s.value}),onClose:d},null,8,["mobile-open","class"]),ne(Jf),ne(jf),ne(tS),ne(oS),g("div",nU,[ne(hr,{name:"fade",mode:"out-in"},{default:Be(()=>[l.value?(v(),ze(lS,{key:"welcome",onToggleSidebar:m})):c.value==="settings"?(v(),ze(eU,{key:"settings",onToggleSidebar:m})):(v(),ze(Yk,{key:"chat",onToggleSidebar:m,onToggleArtifacts:p}))]),_:1})]),ne(JA,{open:s.value,onClose:_},null,8,["open"]),$(r).authConfigured&&!$(r).isAuthenticated&&!$(r).loading?(v(),ze(sS,{key:1})):J("",!0)])]),_:1})}}},rU=ht(aU,[["__scopeId","data-v-40fd87a2"]]),gd=Ih(rU);gd.use(xh());gd.use(pD);gd.mount("#app");"serviceWorker"in navigator&&navigator.serviceWorker.register("/sw.js").catch(()=>{}); diff --git a/webclient/dist/images/apple-splash/splash-1125x2436-landscape.png b/webclient/dist/images/apple-splash/splash-1125x2436-landscape.png new file mode 100644 index 0000000..636b8ac --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1125x2436-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1125x2436-portrait.png b/webclient/dist/images/apple-splash/splash-1125x2436-portrait.png new file mode 100644 index 0000000..838fff9 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1125x2436-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1170x2532-landscape.png b/webclient/dist/images/apple-splash/splash-1170x2532-landscape.png new file mode 100644 index 0000000..fb9b115 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1170x2532-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1170x2532-portrait.png b/webclient/dist/images/apple-splash/splash-1170x2532-portrait.png new file mode 100644 index 0000000..39effbe --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1170x2532-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1179x2556-landscape.png b/webclient/dist/images/apple-splash/splash-1179x2556-landscape.png new file mode 100644 index 0000000..b5254ab --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1179x2556-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1179x2556-portrait.png b/webclient/dist/images/apple-splash/splash-1179x2556-portrait.png new file mode 100644 index 0000000..18a8f36 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1179x2556-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1242x2208-landscape.png b/webclient/dist/images/apple-splash/splash-1242x2208-landscape.png new file mode 100644 index 0000000..845a78a --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1242x2208-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1242x2208-portrait.png b/webclient/dist/images/apple-splash/splash-1242x2208-portrait.png new file mode 100644 index 0000000..30d8181 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1242x2208-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1242x2688-landscape.png b/webclient/dist/images/apple-splash/splash-1242x2688-landscape.png new file mode 100644 index 0000000..324d997 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1242x2688-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1242x2688-portrait.png b/webclient/dist/images/apple-splash/splash-1242x2688-portrait.png new file mode 100644 index 0000000..8ee9019 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1242x2688-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1284x2778-landscape.png b/webclient/dist/images/apple-splash/splash-1284x2778-landscape.png new file mode 100644 index 0000000..3cc9bfe --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1284x2778-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1284x2778-portrait.png b/webclient/dist/images/apple-splash/splash-1284x2778-portrait.png new file mode 100644 index 0000000..6199f6d --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1284x2778-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1290x2796-landscape.png b/webclient/dist/images/apple-splash/splash-1290x2796-landscape.png new file mode 100644 index 0000000..60d29e3 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1290x2796-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1290x2796-portrait.png b/webclient/dist/images/apple-splash/splash-1290x2796-portrait.png new file mode 100644 index 0000000..3ffbb9d --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1290x2796-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1320x2868-landscape.png b/webclient/dist/images/apple-splash/splash-1320x2868-landscape.png new file mode 100644 index 0000000..7e8a57b --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1320x2868-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1320x2868-portrait.png b/webclient/dist/images/apple-splash/splash-1320x2868-portrait.png new file mode 100644 index 0000000..a32474c --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1320x2868-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1488x2266-landscape.png b/webclient/dist/images/apple-splash/splash-1488x2266-landscape.png new file mode 100644 index 0000000..5078f9d --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1488x2266-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1488x2266-portrait.png b/webclient/dist/images/apple-splash/splash-1488x2266-portrait.png new file mode 100644 index 0000000..65cac2e --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1488x2266-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1500x2668-landscape.png b/webclient/dist/images/apple-splash/splash-1500x2668-landscape.png new file mode 100644 index 0000000..e6a39ec --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1500x2668-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1500x2668-portrait.png b/webclient/dist/images/apple-splash/splash-1500x2668-portrait.png new file mode 100644 index 0000000..d0a9b79 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1500x2668-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1536x2048-landscape.png b/webclient/dist/images/apple-splash/splash-1536x2048-landscape.png new file mode 100644 index 0000000..a5b4caa --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1536x2048-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1536x2048-portrait.png b/webclient/dist/images/apple-splash/splash-1536x2048-portrait.png new file mode 100644 index 0000000..f6cc0dc --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1536x2048-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1620x2160-landscape.png b/webclient/dist/images/apple-splash/splash-1620x2160-landscape.png new file mode 100644 index 0000000..c1dae41 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1620x2160-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1620x2160-portrait.png b/webclient/dist/images/apple-splash/splash-1620x2160-portrait.png new file mode 100644 index 0000000..1aba92a --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1620x2160-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1640x2160-landscape.png b/webclient/dist/images/apple-splash/splash-1640x2160-landscape.png new file mode 100644 index 0000000..95105ef --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1640x2160-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1640x2160-portrait.png b/webclient/dist/images/apple-splash/splash-1640x2160-portrait.png new file mode 100644 index 0000000..2b180c8 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1640x2160-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1668x2224-landscape.png b/webclient/dist/images/apple-splash/splash-1668x2224-landscape.png new file mode 100644 index 0000000..c246335 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1668x2224-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1668x2224-portrait.png b/webclient/dist/images/apple-splash/splash-1668x2224-portrait.png new file mode 100644 index 0000000..531c02b --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1668x2224-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1668x2388-landscape.png b/webclient/dist/images/apple-splash/splash-1668x2388-landscape.png new file mode 100644 index 0000000..0eea906 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1668x2388-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-1668x2388-portrait.png b/webclient/dist/images/apple-splash/splash-1668x2388-portrait.png new file mode 100644 index 0000000..a8c6a80 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-1668x2388-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2048x2732-landscape.png b/webclient/dist/images/apple-splash/splash-2048x2732-landscape.png new file mode 100644 index 0000000..a2825b0 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2048x2732-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2048x2732-portrait.png b/webclient/dist/images/apple-splash/splash-2048x2732-portrait.png new file mode 100644 index 0000000..d1da8a7 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2048x2732-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2064x2752-landscape.png b/webclient/dist/images/apple-splash/splash-2064x2752-landscape.png new file mode 100644 index 0000000..3c4d26b --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2064x2752-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2064x2752-portrait.png b/webclient/dist/images/apple-splash/splash-2064x2752-portrait.png new file mode 100644 index 0000000..63ca3e8 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2064x2752-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2560x3600-landscape.png b/webclient/dist/images/apple-splash/splash-2560x3600-landscape.png new file mode 100644 index 0000000..e185dcf --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2560x3600-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-2560x3600-portrait.png b/webclient/dist/images/apple-splash/splash-2560x3600-portrait.png new file mode 100644 index 0000000..d5e47dd --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-2560x3600-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-320x480-landscape.png b/webclient/dist/images/apple-splash/splash-320x480-landscape.png new file mode 100644 index 0000000..568f2fb --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-320x480-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-320x480-portrait.png b/webclient/dist/images/apple-splash/splash-320x480-portrait.png new file mode 100644 index 0000000..caaaf43 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-320x480-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-640x1136-landscape.png b/webclient/dist/images/apple-splash/splash-640x1136-landscape.png new file mode 100644 index 0000000..697f31c --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-640x1136-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-640x1136-portrait.png b/webclient/dist/images/apple-splash/splash-640x1136-portrait.png new file mode 100644 index 0000000..53e052b --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-640x1136-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-750x1334-landscape.png b/webclient/dist/images/apple-splash/splash-750x1334-landscape.png new file mode 100644 index 0000000..01b3e2a --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-750x1334-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-750x1334-portrait.png b/webclient/dist/images/apple-splash/splash-750x1334-portrait.png new file mode 100644 index 0000000..ba05101 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-750x1334-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-750x1624-landscape.png b/webclient/dist/images/apple-splash/splash-750x1624-landscape.png new file mode 100644 index 0000000..0d5f179 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-750x1624-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-750x1624-portrait.png b/webclient/dist/images/apple-splash/splash-750x1624-portrait.png new file mode 100644 index 0000000..30ae302 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-750x1624-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-828x1620-landscape.png b/webclient/dist/images/apple-splash/splash-828x1620-landscape.png new file mode 100644 index 0000000..d83ef5f --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-828x1620-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-828x1620-portrait.png b/webclient/dist/images/apple-splash/splash-828x1620-portrait.png new file mode 100644 index 0000000..3a757bc --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-828x1620-portrait.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-828x1792-landscape.png b/webclient/dist/images/apple-splash/splash-828x1792-landscape.png new file mode 100644 index 0000000..e5b13a5 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-828x1792-landscape.png Binary files differ diff --git a/webclient/dist/images/apple-splash/splash-828x1792-portrait.png b/webclient/dist/images/apple-splash/splash-828x1792-portrait.png new file mode 100644 index 0000000..85081f0 --- /dev/null +++ b/webclient/dist/images/apple-splash/splash-828x1792-portrait.png Binary files differ diff --git a/webclient/dist/images/icon-180.png b/webclient/dist/images/icon-180.png new file mode 100644 index 0000000..4d77545 --- /dev/null +++ b/webclient/dist/images/icon-180.png Binary files differ diff --git a/webclient/dist/images/icon-maskable-192.png b/webclient/dist/images/icon-maskable-192.png index 6b512db..4677643 100644 --- a/webclient/dist/images/icon-maskable-192.png +++ b/webclient/dist/images/icon-maskable-192.png Binary files differ diff --git a/webclient/dist/images/icon-maskable-512.png b/webclient/dist/images/icon-maskable-512.png index 5706349..84866b1 100644 --- a/webclient/dist/images/icon-maskable-512.png +++ b/webclient/dist/images/icon-maskable-512.png Binary files differ diff --git a/webclient/dist/index.html b/webclient/dist/index.html index ac799c0..cc4ddc3 100644 --- a/webclient/dist/index.html +++ b/webclient/dist/index.html @@ -2,17 +2,69 @@ - + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Navi - - + +
    diff --git a/webclient/dist/manifest.webmanifest b/webclient/dist/manifest.webmanifest index 7b28205..b2bbd44 100644 --- a/webclient/dist/manifest.webmanifest +++ b/webclient/dist/manifest.webmanifest @@ -5,6 +5,7 @@ "start_url": "/", "scope": "/", "display": "standalone", + "display_override": ["standalone"], "theme_color": "#16161E", "background_color": "#16161E", "description": "Navi — personal AI assistant", diff --git a/webclient/dist/sw.js b/webclient/dist/sw.js index 2186bc9..8627898 100644 --- a/webclient/dist/sw.js +++ b/webclient/dist/sw.js @@ -8,13 +8,13 @@ * - /images/*: cache-first, capped; * - everything dynamic (/api, /ws, /auth, /push, /content, ...): pass-through. * - * 1000e5ceefb06dcd is stamped at build time (vite.config.js closeBundle) + * 0fc9a6b7d4ac0601 is stamped at build time (vite.config.js closeBundle) * with a digest of index.html + the hashed asset filenames — so sw.js bytes * change on every build, the browser picks the new SW up (served no-store), * and activation evicts caches from previous builds. */ -const VERSION = '1000e5ceefb06dcd'; +const VERSION = '0fc9a6b7d4ac0601'; const SHELL_CACHE = `navi-shell-${VERSION}`; const ASSETS_CACHE = `navi-assets-${VERSION}`; const IMAGES_CACHE = 'navi-images'; diff --git a/webclient/index.html b/webclient/index.html index 9a46951..c73010e 100644 --- a/webclient/index.html +++ b/webclient/index.html @@ -2,13 +2,65 @@ - + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Navi diff --git a/webclient/package-lock.json b/webclient/package-lock.json index c7f44fb..04ec406 100644 --- a/webclient/package-lock.json +++ b/webclient/package-lock.json @@ -8,13 +8,13 @@ "name": "navi-webclient", "version": "0.1.0", "dependencies": { + "@phosphor-icons/web": "^2.1.2", "@tanstack/vue-virtual": "^3.13.6", "dompurify": "^3.4.15", "highlight.js": "^11.11.1", "marked": "^15.0.12", "pinia": "^3.0.2", - "vue": "^3.5.13", - "vue-virtual-scroller": "^2.0.0-beta.8" + "vue": "^3.5.13" }, "devDependencies": { "@pinia/testing": "^0.1.7", @@ -1080,6 +1080,12 @@ "url": "https://opencollective.com/parcel" } }, + "node_modules/@phosphor-icons/web": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@phosphor-icons/web/-/web-2.1.2.tgz", + "integrity": "sha512-rPAR9o/bEcp4Cw4DEeZHXf+nlGCMNGkNDRizYHM47NLxz9vvEHp/Tt6FMK1NcWadzw/pFDPnRBGi/ofRya958A==", + "license": "MIT" + }, "node_modules/@pinia/testing": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/@pinia/testing/-/testing-0.1.7.tgz", @@ -3530,24 +3536,6 @@ "dev": true, "license": "MIT" }, - "node_modules/vue-virtual-scroller": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/vue-virtual-scroller/-/vue-virtual-scroller-2.0.1.tgz", - "integrity": "sha512-3Drq8C61C4B3reSaZJr5nXBf/B7Beq1+h5/kYZB25MLYljTy97ISeUufRX9z6ZSZlFDXyafAOLK9XwajOWJY1A==", - "license": "MIT", - "dependencies": { - "mitt": "^2.1.0" - }, - "peerDependencies": { - "vue": "^3.3.0" - } - }, - "node_modules/vue-virtual-scroller/node_modules/mitt": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/mitt/-/mitt-2.1.0.tgz", - "integrity": "sha512-ILj2TpLiysu2wkBbWjAmww7TkZb65aiQO+DkVdUTBpBXq+MHYiETENkKFMtsJZX1Lf4pe4QOrTSjIfUwN5lRdg==", - "license": "MIT" - }, "node_modules/w3c-xmlserializer": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz", diff --git a/webclient/package.json b/webclient/package.json index 9cc617f..98ee477 100644 --- a/webclient/package.json +++ b/webclient/package.json @@ -10,13 +10,13 @@ "test": "vitest run" }, "dependencies": { + "@phosphor-icons/web": "^2.1.2", "@tanstack/vue-virtual": "^3.13.6", "dompurify": "^3.4.15", "highlight.js": "^11.11.1", "marked": "^15.0.12", "pinia": "^3.0.2", - "vue": "^3.5.13", - "vue-virtual-scroller": "^2.0.0-beta.8" + "vue": "^3.5.13" }, "devDependencies": { "@pinia/testing": "^0.1.7", diff --git a/webclient/public/assets/fonts/phosphor-icons/LICENSE b/webclient/public/assets/fonts/phosphor-icons/LICENSE deleted file mode 100644 index c04a19d..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2020-2021 Phosphor Icons - -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/webclient/public/assets/fonts/phosphor-icons/README.md b/webclient/public/assets/fonts/phosphor-icons/README.md deleted file mode 100644 index 5dfcfcc..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/README.md +++ /dev/null @@ -1,138 +0,0 @@ - - -# phosphor-icons - -Phosphor is a flexible icon family for interfaces, diagrams, presentations — whatever, really. Explore all our icons at [phosphoricons.com](https://phosphoricons.com). - -[![NPM](https://img.shields.io/npm/v/phosphor-icons.svg?style=flat-square)](https://www.npmjs.com/package/phosphor-icons) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com) [![Travis](https://img.shields.io/travis/com/rektdeckard/phosphor-icons.svg?style=flat-square)](https://travis-ci.com/github/rektdeckard/phosphor-icons) - -[![GitHub stars](https://img.shields.io/github/stars/phosphor-icons/phosphor-icons?style=flat-square&label=Star)](https://github.com/phosphor-icons/phosphor-icons) -[![GitHub forks](https://img.shields.io/github/forks/phosphor-icons/phosphor-icons?style=flat-square&label=Fork)](https://github.com/phosphor-icons/phosphor-icons/fork) -[![GitHub watchers](https://img.shields.io/github/watchers/phosphor-icons/phosphor-icons?style=flat-square&label=Watch)](https://github.com/phosphor-icons/phosphor-icons) -[![Follow on GitHub](https://img.shields.io/github/followers/rektdeckard?style=flat-square&label=Follow)](https://github.com/rektdeckard) - -## Usage - -### Getting Started - -We use a similar approach as many other icon sets out there, providing icons as a webfont that uses Unicode's Private Use Area character codes to map normally non-rendering characters to icons. But you don't need to know that. All you need to do is add the script to the document ``, and drop in icons with an `` tag and the appropriate class: - -```html - - - - - - - - - - - -``` - -> **Note:** For stability, you may choose to source a specific version of Phosphor by adding the version to the script URL, for example: `https://unpkg.com/phosphor-icons@1.3.2`. The CDN supports version ranges. - -### Styling - -Since the icons are just text under the hood, they can be colored and styled with CSS like any other font, including `font-size`, `color`, etc. We include several helper classes to provide easy sizing if you need it: - -```css -.ph-xxs { - font-size: 0.5em; -} -.ph-xs { - font-size: 0.75em; -} -.ph-sm { - font-size: 0.875em; -} -.ph-lg { - font-size: 1.3333em; - line-height: 0.75em; - vertical-align: -0.0667em; -} -.ph-xl { - font-size: 1.5em; - line-height: 0.6666em; - vertical-align: -0.075em; -} -.ph-1x { - font-size: 1em; -} -.ph-2x { - font-size: 2em; -} -.ph-3x { - font-size: 3em; -} -.ph-4x { - font-size: 4em; -} -.ph-5x { - font-size: 5em; -} -.ph-6x { - font-size: 6em; -} -.ph-7x { - font-size: 7em; -} -.ph-8x { - font-size: 8em; -} -.ph-9x { - font-size: 9em; -} -.ph-10x { - font-size: 10em; -} -.ph-fw { - text-align: center; - width: 1.25em; -} -``` - -> **Note:** Overriding the `font-family`, `font-style`, `font-weight`, `font-variant`, or `text-transform` may break the icons and render unprintable characters. Don't do it. - -> **Note:** The `duotone` weight is not yet available for this implementation, as fonts do not support baked-in alpha/opacity. In future we plan to move to an SVG-based approach with full support for all icon weights. - -### Ligatures - -The icon font now supports ligatures, meaning that in any text using `font-family: "Phosphor"`, writing the name of an icon (without the `ph-` prefix) will convert to the corresponding icon. The largest possible string will be matched, meaning you can use any available weight, and print multiple icons without separating with spaces or other characters if you choose. - -```html - - - - - - - -

    sword-fill shield

    - - -``` - -## Our Related Projects - -- [phosphor-home](https://github.com/phosphor-icons/phosphor-home) ▲ Phosphor homepage and general info -- [phosphor-react](https://github.com/phosphor-icons/phosphor-react) ▲ Phosphor icon component library for React -- [phosphor-vue](https://github.com/phosphor-icons/phosphor-vue) ▲ Phosphor icon component library for Vue -- [phosphor-flutter](https://github.com/phosphor-icons/phosphor-flutter) ▲ Phosphor IconData library for Flutter -- [phosphor-webcomponents](https://github.com/phosphor-icons/phosphor-webcomponents) ▲ Phosphor icons as Web Components -- [phosphor-figma](https://github.com/phosphor-icons/phosphor-figma) ▲ Phosphor icons Figma plugin -- [phosphor-sketch](https://github.com/phosphor-icons/phosphor-sketch) ▲ Phosphor icons Sketch plugin - -## Community Projects - -- [phosphor-react-native](https://github.com/duongdev/phosphor-react-native) ▲ Phosphor icon component library for React Native -- [phosphor-svelte](https://github.com/haruaki07/phosphor-svelte) ▲ Phosphor icons for Svelte apps -- [phosphor-r](https://github.com/dreamRs/phosphoricons) ▲ Phosphor icon wrapper for R documents and applications -- [blade-phosphor-icons](https://github.com/codeat3/blade-phosphor-icons) ▲ Phosphor icons in your Laravel Blade views - -If you've made a port of Phosphor and you want to see it here, just open a PR [here](https://github.com/phosphor-icons/phosphor-home)! - -## License - -MIT © [Phosphor Icons](https://github.com/phosphor-icons) diff --git a/webclient/public/assets/fonts/phosphor-icons/package.json b/webclient/public/assets/fonts/phosphor-icons/package.json deleted file mode 100644 index c341b84..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/package.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "name": "phosphor-icons", - "version": "1.4.2", - "description": "A clean and friendly icon family for web", - "main": "src/index.js", - "files": [ - "src" - ], - "scripts": { - "test": "http-server -o /test", - "collate": "node ./bin/collate.js", - "icomoon": "node ./bin/icomoon.js" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/phosphor-icons/phosphor-icons.git" - }, - "keywords": [ - "icons", - "icon-pack", - "web", - "html", - "css", - "svg", - "svg-icons", - "icon-font" - ], - "author": "rektdeckard", - "license": "MIT", - "bugs": { - "url": "https://github.com/phosphor-icons/phosphor-icons/issues" - }, - "homepage": "https://phosphoricons.com", - "devDependencies": { - "chalk": "^4.1.0", - "svgson": "^5.2.1" - } -} diff --git a/webclient/public/assets/fonts/phosphor-icons/src/css/icons.css b/webclient/public/assets/fonts/phosphor-icons/src/css/icons.css deleted file mode 100644 index ba57b05..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/css/icons.css +++ /dev/null @@ -1,21038 +0,0 @@ -/*-------------------------------- - -Phosphor Web Font -Generated using nucleoapp.com - --------------------------------- */ -@font-face { - font-family: "Phosphor"; - src: url(data:font/opentype;charset=utf-8;base64,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); - src: url(data:font/x-font-woff;charset=utf-8;base64,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) - format("woff"), - url(data:font/truetype;charset=utf-8;base64,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) - format("truetype"); - font-weight: normal; - font-style: normal; -} -/*------------------------ - base class definition --------------------------*/ -[class^="ph-"], -[class*=" ph-"] { - display: inline-flex; -} - -[class^="ph-"]:before, -[class*=" ph-"]:before { - font: normal normal normal 1em/1 "Phosphor"; - color: inherit; - flex-shrink: 0; - speak: none; - text-transform: none; - text-decoration: inherit; - text-align: center; - /* Better Font Rendering */ - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; -} -/*------------------------ - change icon size --------------------------*/ -/* relative units */ -.ph-xxs { - font-size: 0.5em; -} -.ph-xs { - font-size: 0.75em; -} -.ph-sm { - font-size: 0.875em; -} -.ph-lg { - font-size: 1.3333em; - line-height: 0.75em; - vertical-align: -0.0667em; -} -.ph-xl { - font-size: 1.5em; - line-height: 0.6666em; - vertical-align: -0.075em; -} -.ph-1x { - font-size: 1em; -} -.ph-2x { - font-size: 2em; -} -.ph-3x { - font-size: 3em; -} -.ph-4x { - font-size: 4em; -} -.ph-5x { - font-size: 5em; -} -.ph-6x { - font-size: 6em; -} -.ph-7x { - font-size: 7em; -} -.ph-8x { - font-size: 8em; -} -.ph-9x { - font-size: 9em; -} -.ph-10x { - font-size: 10em; -} -.ph-fw { - text-align: center; - width: 1.25em; -} - -/*------------------------ - icons --------------------------*/ - -.ph-activity-thin::before { - content: "\ea02"; -} - -.ph-address-book-thin::before { - content: "\ea03"; -} - -.ph-airplane-in-flight-thin::before { - content: "\ea04"; -} - -.ph-airplane-landing-thin::before { - content: "\ea05"; -} - -.ph-airplane-takeoff-thin::before { - content: "\ea06"; -} - -.ph-airplane-thin::before { - content: "\ea07"; -} - -.ph-airplane-tilt-thin::before { - content: "\ea08"; -} - -.ph-airplay-thin::before { - content: "\ea09"; -} - -.ph-alarm-thin::before { - content: "\ea0a"; -} - -.ph-alien-thin::before { - content: "\ea0b"; -} - -.ph-align-bottom-simple-thin::before { - content: "\ea0c"; -} - -.ph-align-bottom-thin::before { - content: "\ea0d"; -} - -.ph-align-center-horizontal-simple-thin::before { - content: "\ea0e"; -} - -.ph-align-center-horizontal-thin::before { - content: "\ea0f"; -} - -.ph-align-center-vertical-simple-thin::before { - content: "\ea10"; -} - -.ph-align-center-vertical-thin::before { - content: "\ea11"; -} - -.ph-align-left-simple-thin::before { - content: "\ea12"; -} - -.ph-align-left-thin::before { - content: "\ea13"; -} - -.ph-align-right-simple-thin::before { - content: "\ea14"; -} - -.ph-align-right-thin::before { - content: "\ea15"; -} - -.ph-align-top-simple-thin::before { - content: "\ea16"; -} - -.ph-align-top-thin::before { - content: "\ea17"; -} - -.ph-anchor-simple-thin::before { - content: "\ea18"; -} - -.ph-anchor-thin::before { - content: "\ea19"; -} - -.ph-android-logo-thin::before { - content: "\ea1a"; -} - -.ph-angular-logo-thin::before { - content: "\ea1b"; -} - -.ph-aperture-thin::before { - content: "\ea1c"; -} - -.ph-app-store-logo-thin::before { - content: "\ea1d"; -} - -.ph-app-window-thin::before { - content: "\ea1e"; -} - -.ph-apple-logo-thin::before { - content: "\ea1f"; -} - -.ph-apple-podcasts-logo-thin::before { - content: "\ea20"; -} - -.ph-archive-box-thin::before { - content: "\ea21"; -} - -.ph-archive-thin::before { - content: "\ea22"; -} - -.ph-archive-tray-thin::before { - content: "\ea23"; -} - -.ph-armchair-thin::before { - content: "\ea24"; -} - -.ph-arrow-arc-left-thin::before { - content: "\ea25"; -} - -.ph-arrow-arc-right-thin::before { - content: "\ea26"; -} - -.ph-arrow-bend-double-up-left-thin::before { - content: "\ea27"; -} - -.ph-arrow-bend-double-up-right-thin::before { - content: "\ea28"; -} - -.ph-arrow-bend-down-left-thin::before { - content: "\ea29"; -} - -.ph-arrow-bend-down-right-thin::before { - content: "\ea2a"; -} - -.ph-arrow-bend-left-down-thin::before { - content: "\ea2b"; -} - -.ph-arrow-bend-left-up-thin::before { - content: "\ea2c"; -} - -.ph-arrow-bend-right-down-thin::before { - content: "\ea2d"; -} - -.ph-arrow-bend-right-up-thin::before { - content: "\ea2e"; -} - -.ph-arrow-bend-up-left-thin::before { - content: "\ea2f"; -} - -.ph-arrow-bend-up-right-thin::before { - content: "\ea30"; -} - -.ph-arrow-circle-down-left-thin::before { - content: "\ea31"; -} - -.ph-arrow-circle-down-right-thin::before { - content: "\ea32"; -} - -.ph-arrow-circle-down-thin::before { - content: "\ea33"; -} - -.ph-arrow-circle-left-thin::before { - content: "\ea34"; -} - -.ph-arrow-circle-right-thin::before { - content: "\ea35"; -} - -.ph-arrow-circle-up-left-thin::before { - content: "\ea36"; -} - -.ph-arrow-circle-up-right-thin::before { - content: "\ea37"; -} - -.ph-arrow-circle-up-thin::before { - content: "\ea38"; -} - -.ph-arrow-clockwise-thin::before { - content: "\ea39"; -} - -.ph-arrow-counter-clockwise-thin::before { - content: "\ea3a"; -} - -.ph-arrow-down-left-thin::before { - content: "\ea3b"; -} - -.ph-arrow-down-right-thin::before { - content: "\ea3c"; -} - -.ph-arrow-down-thin::before { - content: "\ea3d"; -} - -.ph-arrow-elbow-down-left-thin::before { - content: "\ea3e"; -} - -.ph-arrow-elbow-down-right-thin::before { - content: "\ea3f"; -} - -.ph-arrow-elbow-left-down-thin::before { - content: "\ea40"; -} - -.ph-arrow-elbow-left-thin::before { - content: "\ea41"; -} - -.ph-arrow-elbow-left-up-thin::before { - content: "\ea42"; -} - -.ph-arrow-elbow-right-down-thin::before { - content: "\ea43"; -} - -.ph-arrow-elbow-right-thin::before { - content: "\ea44"; -} - -.ph-arrow-elbow-right-up-thin::before { - content: "\ea45"; -} - -.ph-arrow-elbow-up-left-thin::before { - content: "\ea46"; -} - -.ph-arrow-elbow-up-right-thin::before { - content: "\ea47"; -} - -.ph-arrow-fat-down-thin::before { - content: "\ea48"; -} - -.ph-arrow-fat-left-thin::before { - content: "\ea49"; -} - -.ph-arrow-fat-line-down-thin::before { - content: "\ea4a"; -} - -.ph-arrow-fat-line-left-thin::before { - content: "\ea4b"; -} - -.ph-arrow-fat-line-right-thin::before { - content: "\ea4c"; -} - -.ph-arrow-fat-line-up-thin::before { - content: "\ea4d"; -} - -.ph-arrow-fat-lines-down-thin::before { - content: "\ea4e"; -} - -.ph-arrow-fat-lines-left-thin::before { - content: "\ea4f"; -} - -.ph-arrow-fat-lines-right-thin::before { - content: "\ea50"; -} - -.ph-arrow-fat-lines-up-thin::before { - content: "\ea51"; -} - -.ph-arrow-fat-right-thin::before { - content: "\ea52"; -} - -.ph-arrow-fat-up-thin::before { - content: "\ea53"; -} - -.ph-arrow-left-thin::before { - content: "\ea54"; -} - -.ph-arrow-line-down-left-thin::before { - content: "\ea55"; -} - -.ph-arrow-line-down-right-thin::before { - content: "\ea56"; -} - -.ph-arrow-line-down-thin::before { - content: "\ea57"; -} - -.ph-arrow-line-left-thin::before { - content: "\ea58"; -} - -.ph-arrow-line-right-thin::before { - content: "\ea59"; -} - -.ph-arrow-line-up-left-thin::before { - content: "\ea5a"; -} - -.ph-arrow-line-up-right-thin::before { - content: "\ea5b"; -} - -.ph-arrow-line-up-thin::before { - content: "\ea5c"; -} - -.ph-arrow-right-thin::before { - content: "\ea5d"; -} - -.ph-arrow-square-down-left-thin::before { - content: "\ea5e"; -} - -.ph-arrow-square-down-right-thin::before { - content: "\ea5f"; -} - -.ph-arrow-square-down-thin::before { - content: "\ea60"; -} - -.ph-arrow-square-in-thin::before { - content: "\ea61"; -} - -.ph-arrow-square-left-thin::before { - content: "\ea62"; -} - -.ph-arrow-square-out-thin::before { - content: "\ea63"; -} - -.ph-arrow-square-right-thin::before { - content: "\ea64"; -} - -.ph-arrow-square-up-left-thin::before { - content: "\ea65"; -} - -.ph-arrow-square-up-right-thin::before { - content: "\ea66"; -} - -.ph-arrow-square-up-thin::before { - content: "\ea67"; -} - -.ph-arrow-u-down-left-thin::before { - content: "\ea68"; -} - -.ph-arrow-u-down-right-thin::before { - content: "\ea69"; -} - -.ph-arrow-u-left-down-thin::before { - content: "\ea6a"; -} - -.ph-arrow-u-left-up-thin::before { - content: "\ea6b"; -} - -.ph-arrow-u-right-down-thin::before { - content: "\ea6c"; -} - -.ph-arrow-u-right-up-thin::before { - content: "\ea6d"; -} - -.ph-arrow-u-up-left-thin::before { - content: "\ea6e"; -} - -.ph-arrow-u-up-right-thin::before { - content: "\ea6f"; -} - -.ph-arrow-up-left-thin::before { - content: "\ea70"; -} - -.ph-arrow-up-right-thin::before { - content: "\ea71"; -} - -.ph-arrow-up-thin::before { - content: "\ea72"; -} - -.ph-arrows-clockwise-thin::before { - content: "\ea73"; -} - -.ph-arrows-counter-clockwise-thin::before { - content: "\ea74"; -} - -.ph-arrows-down-up-thin::before { - content: "\ea75"; -} - -.ph-arrows-horizontal-thin::before { - content: "\ea76"; -} - -.ph-arrows-in-cardinal-thin::before { - content: "\ea77"; -} - -.ph-arrows-in-line-horizontal-thin::before { - content: "\ea78"; -} - -.ph-arrows-in-line-vertical-thin::before { - content: "\ea79"; -} - -.ph-arrows-in-simple-thin::before { - content: "\ea7a"; -} - -.ph-arrows-in-thin::before { - content: "\ea7b"; -} - -.ph-arrows-left-right-thin::before { - content: "\ea7c"; -} - -.ph-arrows-out-cardinal-thin::before { - content: "\ea7d"; -} - -.ph-arrows-out-line-horizontal-thin::before { - content: "\ea7e"; -} - -.ph-arrows-out-line-vertical-thin::before { - content: "\ea7f"; -} - -.ph-arrows-out-simple-thin::before { - content: "\ea80"; -} - -.ph-arrows-out-thin::before { - content: "\ea81"; -} - -.ph-arrows-vertical-thin::before { - content: "\ea82"; -} - -.ph-article-medium-thin::before { - content: "\ea83"; -} - -.ph-article-ny-times-thin::before { - content: "\ea84"; -} - -.ph-article-thin::before { - content: "\ea85"; -} - -.ph-asterisk-simple-thin::before { - content: "\ea86"; -} - -.ph-asterisk-thin::before { - content: "\ea87"; -} - -.ph-at-thin::before { - content: "\ea88"; -} - -.ph-atom-thin::before { - content: "\ea89"; -} - -.ph-baby-thin::before { - content: "\ea8a"; -} - -.ph-backpack-thin::before { - content: "\ea8b"; -} - -.ph-backspace-thin::before { - content: "\ea8c"; -} - -.ph-bag-simple-thin::before { - content: "\ea8d"; -} - -.ph-bag-thin::before { - content: "\ea8e"; -} - -.ph-balloon-thin::before { - content: "\ea8f"; -} - -.ph-bandaids-thin::before { - content: "\ea90"; -} - -.ph-bank-thin::before { - content: "\ea91"; -} - -.ph-barbell-thin::before { - content: "\ea92"; -} - -.ph-barcode-thin::before { - content: "\ea93"; -} - -.ph-barricade-thin::before { - content: "\ea94"; -} - -.ph-baseball-thin::before { - content: "\ea95"; -} - -.ph-basketball-thin::before { - content: "\ea96"; -} - -.ph-bathtub-thin::before { - content: "\ea97"; -} - -.ph-battery-charging-thin::before { - content: "\ea98"; -} - -.ph-battery-charging-vertical-thin::before { - content: "\ea99"; -} - -.ph-battery-empty-thin::before { - content: "\ea9a"; -} - -.ph-battery-full-thin::before { - content: "\ea9b"; -} - -.ph-battery-high-thin::before { - content: "\ea9c"; -} - -.ph-battery-low-thin::before { - content: "\ea9d"; -} - -.ph-battery-medium-thin::before { - content: "\ea9e"; -} - -.ph-battery-plus-thin::before { - content: "\ea9f"; -} - -.ph-battery-warning-thin::before { - content: "\eaa0"; -} - -.ph-battery-warning-vertical-thin::before { - content: "\eaa1"; -} - -.ph-bed-thin::before { - content: "\eaa2"; -} - -.ph-beer-bottle-thin::before { - content: "\eaa3"; -} - -.ph-behance-logo-thin::before { - content: "\eaa4"; -} - -.ph-bell-ringing-thin::before { - content: "\eaa5"; -} - -.ph-bell-simple-ringing-thin::before { - content: "\eaa6"; -} - -.ph-bell-simple-slash-thin::before { - content: "\eaa7"; -} - -.ph-bell-simple-thin::before { - content: "\eaa8"; -} - -.ph-bell-simple-z-thin::before { - content: "\eaa9"; -} - -.ph-bell-slash-thin::before { - content: "\eaaa"; -} - -.ph-bell-thin::before { - content: "\eaab"; -} - -.ph-bell-z-thin::before { - content: "\eaac"; -} - -.ph-bezier-curve-thin::before { - content: "\eaad"; -} - -.ph-bicycle-thin::before { - content: "\eaae"; -} - -.ph-binoculars-thin::before { - content: "\eaaf"; -} - -.ph-bird-thin::before { - content: "\eab0"; -} - -.ph-bluetooth-connected-thin::before { - content: "\eab1"; -} - -.ph-bluetooth-slash-thin::before { - content: "\eab2"; -} - -.ph-bluetooth-thin::before { - content: "\eab3"; -} - -.ph-bluetooth-x-thin::before { - content: "\eab4"; -} - -.ph-boat-thin::before { - content: "\eab5"; -} - -.ph-book-bookmark-thin::before { - content: "\eab6"; -} - -.ph-book-open-thin::before { - content: "\eab7"; -} - -.ph-book-thin::before { - content: "\eab8"; -} - -.ph-bookmark-simple-thin::before { - content: "\eab9"; -} - -.ph-bookmark-thin::before { - content: "\eaba"; -} - -.ph-bookmarks-simple-thin::before { - content: "\eabb"; -} - -.ph-bookmarks-thin::before { - content: "\eabc"; -} - -.ph-books-thin::before { - content: "\eabd"; -} - -.ph-bounding-box-thin::before { - content: "\eabe"; -} - -.ph-brackets-angle-thin::before { - content: "\eabf"; -} - -.ph-brackets-curly-thin::before { - content: "\eac0"; -} - -.ph-brackets-round-thin::before { - content: "\eac1"; -} - -.ph-brackets-square-thin::before { - content: "\eac2"; -} - -.ph-brain-thin::before { - content: "\eac3"; -} - -.ph-brandy-thin::before { - content: "\eac4"; -} - -.ph-briefcase-metal-thin::before { - content: "\eac5"; -} - -.ph-briefcase-thin::before { - content: "\eac6"; -} - -.ph-broadcast-thin::before { - content: "\eac7"; -} - -.ph-browser-thin::before { - content: "\eac8"; -} - -.ph-browsers-thin::before { - content: "\eac9"; -} - -.ph-bug-beetle-thin::before { - content: "\eaca"; -} - -.ph-bug-droid-thin::before { - content: "\eacb"; -} - -.ph-bug-thin::before { - content: "\eacc"; -} - -.ph-buildings-thin::before { - content: "\eacd"; -} - -.ph-bus-thin::before { - content: "\eace"; -} - -.ph-butterfly-thin::before { - content: "\eacf"; -} - -.ph-cactus-thin::before { - content: "\ead0"; -} - -.ph-cake-thin::before { - content: "\ead1"; -} - -.ph-calculator-thin::before { - content: "\ead2"; -} - -.ph-calendar-blank-thin::before { - content: "\ead3"; -} - -.ph-calendar-check-thin::before { - content: "\ead4"; -} - -.ph-calendar-plus-thin::before { - content: "\ead5"; -} - -.ph-calendar-thin::before { - content: "\ead6"; -} - -.ph-calendar-x-thin::before { - content: "\ead7"; -} - -.ph-camera-rotate-thin::before { - content: "\ead8"; -} - -.ph-camera-slash-thin::before { - content: "\ead9"; -} - -.ph-camera-thin::before { - content: "\eada"; -} - -.ph-campfire-thin::before { - content: "\eadb"; -} - -.ph-car-simple-thin::before { - content: "\eadc"; -} - -.ph-car-thin::before { - content: "\eadd"; -} - -.ph-cardholder-thin::before { - content: "\eade"; -} - -.ph-cards-thin::before { - content: "\eadf"; -} - -.ph-caret-circle-double-down-thin::before { - content: "\eae0"; -} - -.ph-caret-circle-double-left-thin::before { - content: "\eae1"; -} - -.ph-caret-circle-double-right-thin::before { - content: "\eae2"; -} - -.ph-caret-circle-double-up-thin::before { - content: "\eae3"; -} - -.ph-caret-circle-down-thin::before { - content: "\eae4"; -} - -.ph-caret-circle-left-thin::before { - content: "\eae5"; -} - -.ph-caret-circle-right-thin::before { - content: "\eae6"; -} - -.ph-caret-circle-up-thin::before { - content: "\eae7"; -} - -.ph-caret-double-down-thin::before { - content: "\eae8"; -} - -.ph-caret-double-left-thin::before { - content: "\eae9"; -} - -.ph-caret-double-right-thin::before { - content: "\eaea"; -} - -.ph-caret-double-up-thin::before { - content: "\eaeb"; -} - -.ph-caret-down-thin::before { - content: "\eaec"; -} - -.ph-caret-left-thin::before { - content: "\eaed"; -} - -.ph-caret-right-thin::before { - content: "\eaee"; -} - -.ph-caret-up-thin::before { - content: "\eaef"; -} - -.ph-cat-thin::before { - content: "\eaf0"; -} - -.ph-cell-signal-full-thin::before { - content: "\eaf1"; -} - -.ph-cell-signal-high-thin::before { - content: "\eaf2"; -} - -.ph-cell-signal-low-thin::before { - content: "\eaf3"; -} - -.ph-cell-signal-medium-thin::before { - content: "\eaf4"; -} - -.ph-cell-signal-none-thin::before { - content: "\eaf5"; -} - -.ph-cell-signal-slash-thin::before { - content: "\eaf6"; -} - -.ph-cell-signal-x-thin::before { - content: "\eaf7"; -} - -.ph-chalkboard-simple-thin::before { - content: "\eaf8"; -} - -.ph-chalkboard-teacher-thin::before { - content: "\eaf9"; -} - -.ph-chalkboard-thin::before { - content: "\eafa"; -} - -.ph-chart-bar-horizontal-thin::before { - content: "\eafb"; -} - -.ph-chart-bar-thin::before { - content: "\eafc"; -} - -.ph-chart-line-thin::before { - content: "\eafd"; -} - -.ph-chart-line-up-thin::before { - content: "\eafe"; -} - -.ph-chart-pie-slice-thin::before { - content: "\eaff"; -} - -.ph-chart-pie-thin::before { - content: "\eb00"; -} - -.ph-chat-centered-dots-thin::before { - content: "\eb01"; -} - -.ph-chat-centered-text-thin::before { - content: "\eb02"; -} - -.ph-chat-centered-thin::before { - content: "\eb03"; -} - -.ph-chat-circle-dots-thin::before { - content: "\eb04"; -} - -.ph-chat-circle-text-thin::before { - content: "\eb05"; -} - -.ph-chat-circle-thin::before { - content: "\eb06"; -} - -.ph-chat-dots-thin::before { - content: "\eb07"; -} - -.ph-chat-teardrop-dots-thin::before { - content: "\eb08"; -} - -.ph-chat-teardrop-text-thin::before { - content: "\eb09"; -} - -.ph-chat-teardrop-thin::before { - content: "\eb0a"; -} - -.ph-chat-text-thin::before { - content: "\eb0b"; -} - -.ph-chat-thin::before { - content: "\eb0c"; -} - -.ph-chats-circle-thin::before { - content: "\eb0d"; -} - -.ph-chats-teardrop-thin::before { - content: "\eb0e"; -} - -.ph-chats-thin::before { - content: "\eb0f"; -} - -.ph-check-circle-thin::before { - content: "\eb10"; -} - -.ph-check-square-offset-thin::before { - content: "\eb11"; -} - -.ph-check-square-thin::before { - content: "\eb12"; -} - -.ph-check-thin::before { - content: "\eb13"; -} - -.ph-checks-thin::before { - content: "\eb14"; -} - -.ph-circle-dashed-thin::before { - content: "\eb15"; -} - -.ph-circle-half-thin::before { - content: "\eb16"; -} - -.ph-circle-half-tilt-thin::before { - content: "\eb17"; -} - -.ph-circle-notch-thin::before { - content: "\eb18"; -} - -.ph-circle-thin::before { - content: "\eb19"; -} - -.ph-circle-wavy-check-thin::before { - content: "\eb1a"; -} - -.ph-circle-wavy-question-thin::before { - content: "\eb1b"; -} - -.ph-circle-wavy-thin::before { - content: "\eb1c"; -} - -.ph-circle-wavy-warning-thin::before { - content: "\eb1d"; -} - -.ph-circles-four-thin::before { - content: "\eb1e"; -} - -.ph-circles-three-plus-thin::before { - content: "\eb1f"; -} - -.ph-circles-three-thin::before { - content: "\eb20"; -} - -.ph-clipboard-text-thin::before { - content: "\eb21"; -} - -.ph-clipboard-thin::before { - content: "\eb22"; -} - -.ph-clock-afternoon-thin::before { - content: "\eb23"; -} - -.ph-clock-clockwise-thin::before { - content: "\eb24"; -} - -.ph-clock-counter-clockwise-thin::before { - content: "\eb25"; -} - -.ph-clock-thin::before { - content: "\eb26"; -} - -.ph-closed-captioning-thin::before { - content: "\eb27"; -} - -.ph-cloud-arrow-down-thin::before { - content: "\eb28"; -} - -.ph-cloud-arrow-up-thin::before { - content: "\eb29"; -} - -.ph-cloud-check-thin::before { - content: "\eb2a"; -} - -.ph-cloud-fog-thin::before { - content: "\eb2b"; -} - -.ph-cloud-lightning-thin::before { - content: "\eb2c"; -} - -.ph-cloud-moon-thin::before { - content: "\eb2d"; -} - -.ph-cloud-rain-thin::before { - content: "\eb2e"; -} - -.ph-cloud-slash-thin::before { - content: "\eb2f"; -} - -.ph-cloud-snow-thin::before { - content: "\eb30"; -} - -.ph-cloud-sun-thin::before { - content: "\eb31"; -} - -.ph-cloud-thin::before { - content: "\eb32"; -} - -.ph-club-thin::before { - content: "\eb33"; -} - -.ph-coat-hanger-thin::before { - content: "\eb34"; -} - -.ph-code-simple-thin::before { - content: "\eb35"; -} - -.ph-code-thin::before { - content: "\eb36"; -} - -.ph-codepen-logo-thin::before { - content: "\eb37"; -} - -.ph-codesandbox-logo-thin::before { - content: "\eb38"; -} - -.ph-coffee-thin::before { - content: "\eb39"; -} - -.ph-coin-thin::before { - content: "\eb3a"; -} - -.ph-coin-vertical-thin::before { - content: "\eb3b"; -} - -.ph-coins-thin::before { - content: "\eb3c"; -} - -.ph-columns-thin::before { - content: "\eb3d"; -} - -.ph-command-thin::before { - content: "\eb3e"; -} - -.ph-compass-thin::before { - content: "\eb3f"; -} - -.ph-computer-tower-thin::before { - content: "\eb40"; -} - -.ph-confetti-thin::before { - content: "\eb41"; -} - -.ph-cookie-thin::before { - content: "\eb42"; -} - -.ph-cooking-pot-thin::before { - content: "\eb43"; -} - -.ph-copy-simple-thin::before { - content: "\eb44"; -} - -.ph-copy-thin::before { - content: "\eb45"; -} - -.ph-copyleft-thin::before { - content: "\eb46"; -} - -.ph-copyright-thin::before { - content: "\eb47"; -} - -.ph-corners-in-thin::before { - content: "\eb48"; -} - -.ph-corners-out-thin::before { - content: "\eb49"; -} - -.ph-cpu-thin::before { - content: "\eb4a"; -} - -.ph-credit-card-thin::before { - content: "\eb4b"; -} - -.ph-crop-thin::before { - content: "\eb4c"; -} - -.ph-crosshair-simple-thin::before { - content: "\eb4d"; -} - -.ph-crosshair-thin::before { - content: "\eb4e"; -} - -.ph-crown-simple-thin::before { - content: "\eb4f"; -} - -.ph-crown-thin::before { - content: "\eb50"; -} - -.ph-cube-thin::before { - content: "\eb51"; -} - -.ph-currency-btc-thin::before { - content: "\eb52"; -} - -.ph-currency-circle-dollar-thin::before { - content: "\eb53"; -} - -.ph-currency-cny-thin::before { - content: "\eb54"; -} - -.ph-currency-dollar-simple-thin::before { - content: "\eb55"; -} - -.ph-currency-dollar-thin::before { - content: "\eb56"; -} - -.ph-currency-eth-thin::before { - content: "\eb57"; -} - -.ph-currency-eur-thin::before { - content: "\eb58"; -} - -.ph-currency-gbp-thin::before { - content: "\eb59"; -} - -.ph-currency-inr-thin::before { - content: "\eb5a"; -} - -.ph-currency-jpy-thin::before { - content: "\eb5b"; -} - -.ph-currency-krw-thin::before { - content: "\eb5c"; -} - -.ph-currency-kzt-thin::before { - content: "\eb5d"; -} - -.ph-currency-ngn-thin::before { - content: "\eb5e"; -} - -.ph-currency-rub-thin::before { - content: "\eb5f"; -} - -.ph-cursor-text-thin::before { - content: "\eb60"; -} - -.ph-cursor-thin::before { - content: "\eb61"; -} - -.ph-cylinder-thin::before { - content: "\eb62"; -} - -.ph-database-thin::before { - content: "\eb63"; -} - -.ph-desktop-thin::before { - content: "\eb64"; -} - -.ph-desktop-tower-thin::before { - content: "\eb65"; -} - -.ph-detective-thin::before { - content: "\eb66"; -} - -.ph-device-mobile-camera-thin::before { - content: "\eb67"; -} - -.ph-device-mobile-speaker-thin::before { - content: "\eb68"; -} - -.ph-device-mobile-thin::before { - content: "\eb69"; -} - -.ph-device-tablet-camera-thin::before { - content: "\eb6a"; -} - -.ph-device-tablet-speaker-thin::before { - content: "\eb6b"; -} - -.ph-device-tablet-thin::before { - content: "\eb6c"; -} - -.ph-diamond-thin::before { - content: "\eb6d"; -} - -.ph-diamonds-four-thin::before { - content: "\eb6e"; -} - -.ph-dice-five-thin::before { - content: "\eb6f"; -} - -.ph-dice-four-thin::before { - content: "\eb70"; -} - -.ph-dice-one-thin::before { - content: "\eb71"; -} - -.ph-dice-six-thin::before { - content: "\eb72"; -} - -.ph-dice-three-thin::before { - content: "\eb73"; -} - -.ph-dice-two-thin::before { - content: "\eb74"; -} - -.ph-disc-thin::before { - content: "\eb75"; -} - -.ph-discord-logo-thin::before { - content: "\eb76"; -} - -.ph-divide-thin::before { - content: "\eb77"; -} - -.ph-dog-thin::before { - content: "\eb78"; -} - -.ph-door-thin::before { - content: "\eb79"; -} - -.ph-dots-nine-thin::before { - content: "\eb7a"; -} - -.ph-dots-six-thin::before { - content: "\eb7b"; -} - -.ph-dots-six-vertical-thin::before { - content: "\eb7c"; -} - -.ph-dots-three-circle-thin::before { - content: "\eb7d"; -} - -.ph-dots-three-circle-vertical-thin::before { - content: "\eb7e"; -} - -.ph-dots-three-outline-thin::before { - content: "\eb7f"; -} - -.ph-dots-three-outline-vertical-thin::before { - content: "\eb80"; -} - -.ph-dots-three-thin::before { - content: "\eb81"; -} - -.ph-dots-three-vertical-thin::before { - content: "\eb82"; -} - -.ph-download-simple-thin::before { - content: "\eb83"; -} - -.ph-download-thin::before { - content: "\eb84"; -} - -.ph-dribbble-logo-thin::before { - content: "\eb85"; -} - -.ph-drop-half-bottom-thin::before { - content: "\eb86"; -} - -.ph-drop-half-thin::before { - content: "\eb87"; -} - -.ph-drop-thin::before { - content: "\eb88"; -} - -.ph-ear-slash-thin::before { - content: "\eb89"; -} - -.ph-ear-thin::before { - content: "\eb8a"; -} - -.ph-egg-crack-thin::before { - content: "\eb8b"; -} - -.ph-egg-thin::before { - content: "\eb8c"; -} - -.ph-eject-simple-thin::before { - content: "\eb8d"; -} - -.ph-eject-thin::before { - content: "\eb8e"; -} - -.ph-envelope-open-thin::before { - content: "\eb8f"; -} - -.ph-envelope-simple-open-thin::before { - content: "\eb90"; -} - -.ph-envelope-simple-thin::before { - content: "\eb91"; -} - -.ph-envelope-thin::before { - content: "\eb92"; -} - -.ph-equalizer-thin::before { - content: "\eb93"; -} - -.ph-equals-thin::before { - content: "\eb94"; -} - -.ph-eraser-thin::before { - content: "\eb95"; -} - -.ph-exam-thin::before { - content: "\eb96"; -} - -.ph-export-thin::before { - content: "\eb97"; -} - -.ph-eye-closed-thin::before { - content: "\eb98"; -} - -.ph-eye-slash-thin::before { - content: "\eb99"; -} - -.ph-eye-thin::before { - content: "\eb9a"; -} - -.ph-eyedropper-sample-thin::before { - content: "\eb9b"; -} - -.ph-eyedropper-thin::before { - content: "\eb9c"; -} - -.ph-eyeglasses-thin::before { - content: "\eb9d"; -} - -.ph-face-mask-thin::before { - content: "\eb9e"; -} - -.ph-facebook-logo-thin::before { - content: "\eb9f"; -} - -.ph-factory-thin::before { - content: "\eba0"; -} - -.ph-faders-horizontal-thin::before { - content: "\eba1"; -} - -.ph-faders-thin::before { - content: "\eba2"; -} - -.ph-fast-forward-circle-thin::before { - content: "\eba3"; -} - -.ph-fast-forward-thin::before { - content: "\eba4"; -} - -.ph-figma-logo-thin::before { - content: "\eba5"; -} - -.ph-file-arrow-down-thin::before { - content: "\eba6"; -} - -.ph-file-arrow-up-thin::before { - content: "\eba7"; -} - -.ph-file-audio-thin::before { - content: "\eba8"; -} - -.ph-file-cloud-thin::before { - content: "\eba9"; -} - -.ph-file-code-thin::before { - content: "\ebaa"; -} - -.ph-file-css-thin::before { - content: "\ebab"; -} - -.ph-file-csv-thin::before { - content: "\ebac"; -} - -.ph-file-doc-thin::before { - content: "\ebad"; -} - -.ph-file-dotted-thin::before { - content: "\ebae"; -} - -.ph-file-html-thin::before { - content: "\ebaf"; -} - -.ph-file-image-thin::before { - content: "\ebb0"; -} - -.ph-file-jpg-thin::before { - content: "\ebb1"; -} - -.ph-file-js-thin::before { - content: "\ebb2"; -} - -.ph-file-jsx-thin::before { - content: "\ebb3"; -} - -.ph-file-lock-thin::before { - content: "\ebb4"; -} - -.ph-file-minus-thin::before { - content: "\ebb5"; -} - -.ph-file-pdf-thin::before { - content: "\ebb6"; -} - -.ph-file-plus-thin::before { - content: "\ebb7"; -} - -.ph-file-png-thin::before { - content: "\ebb8"; -} - -.ph-file-ppt-thin::before { - content: "\ebb9"; -} - -.ph-file-rs-thin::before { - content: "\ebba"; -} - -.ph-file-search-thin::before { - content: "\ebbb"; -} - -.ph-file-text-thin::before { - content: "\ebbc"; -} - -.ph-file-thin::before { - content: "\ebbd"; -} - -.ph-file-ts-thin::before { - content: "\ebbe"; -} - -.ph-file-tsx-thin::before { - content: "\ebbf"; -} - -.ph-file-video-thin::before { - content: "\ebc0"; -} - -.ph-file-vue-thin::before { - content: "\ebc1"; -} - -.ph-file-x-thin::before { - content: "\ebc2"; -} - -.ph-file-xls-thin::before { - content: "\ebc3"; -} - -.ph-file-zip-thin::before { - content: "\ebc4"; -} - -.ph-files-thin::before { - content: "\ebc5"; -} - -.ph-film-script-thin::before { - content: "\ebc6"; -} - -.ph-film-slate-thin::before { - content: "\ebc7"; -} - -.ph-film-strip-thin::before { - content: "\ebc8"; -} - -.ph-fingerprint-simple-thin::before { - content: "\ebc9"; -} - -.ph-fingerprint-thin::before { - content: "\ebca"; -} - -.ph-finn-the-human-thin::before { - content: "\ebcb"; -} - -.ph-fire-simple-thin::before { - content: "\ebcc"; -} - -.ph-fire-thin::before { - content: "\ebcd"; -} - -.ph-first-aid-kit-thin::before { - content: "\ebce"; -} - -.ph-first-aid-thin::before { - content: "\ebcf"; -} - -.ph-fish-simple-thin::before { - content: "\ebd0"; -} - -.ph-fish-thin::before { - content: "\ebd1"; -} - -.ph-flag-banner-thin::before { - content: "\ebd2"; -} - -.ph-flag-checkered-thin::before { - content: "\ebd3"; -} - -.ph-flag-thin::before { - content: "\ebd4"; -} - -.ph-flame-thin::before { - content: "\ebd5"; -} - -.ph-flashlight-thin::before { - content: "\ebd6"; -} - -.ph-flask-thin::before { - content: "\ebd7"; -} - -.ph-floppy-disk-back-thin::before { - content: "\ebd8"; -} - -.ph-floppy-disk-thin::before { - content: "\ebd9"; -} - -.ph-flow-arrow-thin::before { - content: "\ebda"; -} - -.ph-flower-lotus-thin::before { - content: "\ebdb"; -} - -.ph-flower-thin::before { - content: "\ebdc"; -} - -.ph-flying-saucer-thin::before { - content: "\ebdd"; -} - -.ph-folder-dotted-thin::before { - content: "\ebde"; -} - -.ph-folder-lock-thin::before { - content: "\ebdf"; -} - -.ph-folder-minus-thin::before { - content: "\ebe0"; -} - -.ph-folder-notch-minus-thin::before { - content: "\ebe1"; -} - -.ph-folder-notch-open-thin::before { - content: "\ebe2"; -} - -.ph-folder-notch-plus-thin::before { - content: "\ebe3"; -} - -.ph-folder-notch-thin::before { - content: "\ebe4"; -} - -.ph-folder-open-thin::before { - content: "\ebe5"; -} - -.ph-folder-plus-thin::before { - content: "\ebe6"; -} - -.ph-folder-simple-dotted-thin::before { - content: "\ebe7"; -} - -.ph-folder-simple-lock-thin::before { - content: "\ebe8"; -} - -.ph-folder-simple-minus-thin::before { - content: "\ebe9"; -} - -.ph-folder-simple-plus-thin::before { - content: "\ebea"; -} - -.ph-folder-simple-star-thin::before { - content: "\ebeb"; -} - -.ph-folder-simple-thin::before { - content: "\ebec"; -} - -.ph-folder-simple-user-thin::before { - content: "\ebed"; -} - -.ph-folder-star-thin::before { - content: "\ebee"; -} - -.ph-folder-thin::before { - content: "\ebef"; -} - -.ph-folder-user-thin::before { - content: "\ebf0"; -} - -.ph-folders-thin::before { - content: "\ebf1"; -} - -.ph-football-thin::before { - content: "\ebf2"; -} - -.ph-fork-knife-thin::before { - content: "\ebf3"; -} - -.ph-frame-corners-thin::before { - content: "\ebf4"; -} - -.ph-framer-logo-thin::before { - content: "\ebf5"; -} - -.ph-function-thin::before { - content: "\ebf6"; -} - -.ph-funnel-simple-thin::before { - content: "\ebf7"; -} - -.ph-funnel-thin::before { - content: "\ebf8"; -} - -.ph-game-controller-thin::before { - content: "\ebf9"; -} - -.ph-gas-pump-thin::before { - content: "\ebfa"; -} - -.ph-gauge-thin::before { - content: "\ebfb"; -} - -.ph-gear-six-thin::before { - content: "\ebfc"; -} - -.ph-gear-thin::before { - content: "\ebfd"; -} - -.ph-gender-female-thin::before { - content: "\ebfe"; -} - -.ph-gender-intersex-thin::before { - content: "\ebff"; -} - -.ph-gender-male-thin::before { - content: "\ec00"; -} - -.ph-gender-neuter-thin::before { - content: "\ec01"; -} - -.ph-gender-nonbinary-thin::before { - content: "\ec02"; -} - -.ph-gender-transgender-thin::before { - content: "\ec03"; -} - -.ph-ghost-thin::before { - content: "\ec04"; -} - -.ph-gif-thin::before { - content: "\ec05"; -} - -.ph-gift-thin::before { - content: "\ec06"; -} - -.ph-git-branch-thin::before { - content: "\ec07"; -} - -.ph-git-commit-thin::before { - content: "\ec08"; -} - -.ph-git-diff-thin::before { - content: "\ec09"; -} - -.ph-git-fork-thin::before { - content: "\ec0a"; -} - -.ph-git-merge-thin::before { - content: "\ec0b"; -} - -.ph-git-pull-request-thin::before { - content: "\ec0c"; -} - -.ph-github-logo-thin::before { - content: "\ec0d"; -} - -.ph-gitlab-logo-simple-thin::before { - content: "\ec0e"; -} - -.ph-gitlab-logo-thin::before { - content: "\ec0f"; -} - -.ph-globe-hemisphere-east-thin::before { - content: "\ec10"; -} - -.ph-globe-hemisphere-west-thin::before { - content: "\ec11"; -} - -.ph-globe-simple-thin::before { - content: "\ec12"; -} - -.ph-globe-stand-thin::before { - content: "\ec13"; -} - -.ph-globe-thin::before { - content: "\ec14"; -} - -.ph-google-chrome-logo-thin::before { - content: "\ec15"; -} - -.ph-google-logo-thin::before { - content: "\ec16"; -} - -.ph-google-photos-logo-thin::before { - content: "\ec17"; -} - -.ph-google-play-logo-thin::before { - content: "\ec18"; -} - -.ph-google-podcasts-logo-thin::before { - content: "\ec19"; -} - -.ph-gradient-thin::before { - content: "\ec1a"; -} - -.ph-graduation-cap-thin::before { - content: "\ec1b"; -} - -.ph-graph-thin::before { - content: "\ec1c"; -} - -.ph-grid-four-thin::before { - content: "\ec1d"; -} - -.ph-hamburger-thin::before { - content: "\ec1e"; -} - -.ph-hand-eye-thin::before { - content: "\ec1f"; -} - -.ph-hand-fist-thin::before { - content: "\ec20"; -} - -.ph-hand-grabbing-thin::before { - content: "\ec21"; -} - -.ph-hand-palm-thin::before { - content: "\ec22"; -} - -.ph-hand-pointing-thin::before { - content: "\ec23"; -} - -.ph-hand-soap-thin::before { - content: "\ec24"; -} - -.ph-hand-thin::before { - content: "\ec25"; -} - -.ph-hand-waving-thin::before { - content: "\ec26"; -} - -.ph-handbag-simple-thin::before { - content: "\ec27"; -} - -.ph-handbag-thin::before { - content: "\ec28"; -} - -.ph-hands-clapping-thin::before { - content: "\ec29"; -} - -.ph-handshake-thin::before { - content: "\ec2a"; -} - -.ph-hard-drive-thin::before { - content: "\ec2b"; -} - -.ph-hard-drives-thin::before { - content: "\ec2c"; -} - -.ph-hash-straight-thin::before { - content: "\ec2d"; -} - -.ph-hash-thin::before { - content: "\ec2e"; -} - -.ph-headlights-thin::before { - content: "\ec2f"; -} - -.ph-headphones-thin::before { - content: "\ec30"; -} - -.ph-headset-thin::before { - content: "\ec31"; -} - -.ph-heart-break-thin::before { - content: "\ec32"; -} - -.ph-heart-straight-break-thin::before { - content: "\ec33"; -} - -.ph-heart-straight-thin::before { - content: "\ec34"; -} - -.ph-heart-thin::before { - content: "\ec35"; -} - -.ph-heartbeat-thin::before { - content: "\ec36"; -} - -.ph-hexagon-thin::before { - content: "\ec37"; -} - -.ph-highlighter-circle-thin::before { - content: "\ec38"; -} - -.ph-horse-thin::before { - content: "\ec39"; -} - -.ph-hourglass-high-thin::before { - content: "\ec3a"; -} - -.ph-hourglass-low-thin::before { - content: "\ec3b"; -} - -.ph-hourglass-medium-thin::before { - content: "\ec3c"; -} - -.ph-hourglass-simple-high-thin::before { - content: "\ec3d"; -} - -.ph-hourglass-simple-low-thin::before { - content: "\ec3e"; -} - -.ph-hourglass-simple-medium-thin::before { - content: "\ec3f"; -} - -.ph-hourglass-simple-thin::before { - content: "\ec40"; -} - -.ph-hourglass-thin::before { - content: "\ec41"; -} - -.ph-house-line-thin::before { - content: "\ec42"; -} - -.ph-house-simple-thin::before { - content: "\ec43"; -} - -.ph-house-thin::before { - content: "\ec44"; -} - -.ph-identification-badge-thin::before { - content: "\ec45"; -} - -.ph-identification-card-thin::before { - content: "\ec46"; -} - -.ph-image-square-thin::before { - content: "\ec47"; -} - -.ph-image-thin::before { - content: "\ec48"; -} - -.ph-infinity-thin::before { - content: "\ec49"; -} - -.ph-info-thin::before { - content: "\ec4a"; -} - -.ph-instagram-logo-thin::before { - content: "\ec4b"; -} - -.ph-intersect-thin::before { - content: "\ec4c"; -} - -.ph-jeep-thin::before { - content: "\ec4d"; -} - -.ph-kanban-thin::before { - content: "\ec4e"; -} - -.ph-key-return-thin::before { - content: "\ec4f"; -} - -.ph-key-thin::before { - content: "\ec50"; -} - -.ph-keyboard-thin::before { - content: "\ec51"; -} - -.ph-keyhole-thin::before { - content: "\ec52"; -} - -.ph-knife-thin::before { - content: "\ec53"; -} - -.ph-ladder-simple-thin::before { - content: "\ec54"; -} - -.ph-ladder-thin::before { - content: "\ec55"; -} - -.ph-lamp-thin::before { - content: "\ec56"; -} - -.ph-laptop-thin::before { - content: "\ec57"; -} - -.ph-layout-thin::before { - content: "\ec58"; -} - -.ph-leaf-thin::before { - content: "\ec59"; -} - -.ph-lifebuoy-thin::before { - content: "\ec5a"; -} - -.ph-lightbulb-filament-thin::before { - content: "\ec5b"; -} - -.ph-lightbulb-thin::before { - content: "\ec5c"; -} - -.ph-lightning-slash-thin::before { - content: "\ec5d"; -} - -.ph-lightning-thin::before { - content: "\ec5e"; -} - -.ph-line-segment-thin::before { - content: "\ec5f"; -} - -.ph-line-segments-thin::before { - content: "\ec60"; -} - -.ph-link-break-thin::before { - content: "\ec61"; -} - -.ph-link-simple-break-thin::before { - content: "\ec62"; -} - -.ph-link-simple-horizontal-break-thin::before { - content: "\ec63"; -} - -.ph-link-simple-horizontal-thin::before { - content: "\ec64"; -} - -.ph-link-simple-thin::before { - content: "\ec65"; -} - -.ph-link-thin::before { - content: "\ec66"; -} - -.ph-linkedin-logo-thin::before { - content: "\ec67"; -} - -.ph-linux-logo-thin::before { - content: "\ec68"; -} - -.ph-list-bullets-thin::before { - content: "\ec69"; -} - -.ph-list-checks-thin::before { - content: "\ec6a"; -} - -.ph-list-dashes-thin::before { - content: "\ec6b"; -} - -.ph-list-numbers-thin::before { - content: "\ec6c"; -} - -.ph-list-plus-thin::before { - content: "\ec6d"; -} - -.ph-list-thin::before { - content: "\ec6e"; -} - -.ph-lock-key-open-thin::before { - content: "\ec6f"; -} - -.ph-lock-key-thin::before { - content: "\ec70"; -} - -.ph-lock-laminated-open-thin::before { - content: "\ec71"; -} - -.ph-lock-laminated-thin::before { - content: "\ec72"; -} - -.ph-lock-open-thin::before { - content: "\ec73"; -} - -.ph-lock-simple-open-thin::before { - content: "\ec74"; -} - -.ph-lock-simple-thin::before { - content: "\ec75"; -} - -.ph-lock-thin::before { - content: "\ec76"; -} - -.ph-magic-wand-thin::before { - content: "\ec77"; -} - -.ph-magnet-straight-thin::before { - content: "\ec78"; -} - -.ph-magnet-thin::before { - content: "\ec79"; -} - -.ph-magnifying-glass-minus-thin::before { - content: "\ec7a"; -} - -.ph-magnifying-glass-plus-thin::before { - content: "\ec7b"; -} - -.ph-magnifying-glass-thin::before { - content: "\ec7c"; -} - -.ph-map-pin-line-thin::before { - content: "\ec7d"; -} - -.ph-map-pin-thin::before { - content: "\ec7e"; -} - -.ph-map-trifold-thin::before { - content: "\ec7f"; -} - -.ph-marker-circle-thin::before { - content: "\ec80"; -} - -.ph-martini-thin::before { - content: "\ec81"; -} - -.ph-mask-happy-thin::before { - content: "\ec82"; -} - -.ph-mask-sad-thin::before { - content: "\ec83"; -} - -.ph-math-operations-thin::before { - content: "\ec84"; -} - -.ph-medal-thin::before { - content: "\ec85"; -} - -.ph-medium-logo-thin::before { - content: "\ec86"; -} - -.ph-megaphone-simple-thin::before { - content: "\ec87"; -} - -.ph-megaphone-thin::before { - content: "\ec88"; -} - -.ph-messenger-logo-thin::before { - content: "\ec89"; -} - -.ph-microphone-slash-thin::before { - content: "\ec8a"; -} - -.ph-microphone-stage-thin::before { - content: "\ec8b"; -} - -.ph-microphone-thin::before { - content: "\ec8c"; -} - -.ph-microsoft-excel-logo-thin::before { - content: "\ec8d"; -} - -.ph-microsoft-powerpoint-logo-thin::before { - content: "\ec8e"; -} - -.ph-microsoft-teams-logo-thin::before { - content: "\ec8f"; -} - -.ph-microsoft-word-logo-thin::before { - content: "\ec90"; -} - -.ph-minus-circle-thin::before { - content: "\ec91"; -} - -.ph-minus-thin::before { - content: "\ec92"; -} - -.ph-money-thin::before { - content: "\ec93"; -} - -.ph-monitor-play-thin::before { - content: "\ec94"; -} - -.ph-monitor-thin::before { - content: "\ec95"; -} - -.ph-moon-stars-thin::before { - content: "\ec96"; -} - -.ph-moon-thin::before { - content: "\ec97"; -} - -.ph-mountains-thin::before { - content: "\ec98"; -} - -.ph-mouse-simple-thin::before { - content: "\ec99"; -} - -.ph-mouse-thin::before { - content: "\ec9a"; -} - -.ph-music-note-simple-thin::before { - content: "\ec9b"; -} - -.ph-music-note-thin::before { - content: "\ec9c"; -} - -.ph-music-notes-plus-thin::before { - content: "\ec9d"; -} - -.ph-music-notes-simple-thin::before { - content: "\ec9e"; -} - -.ph-music-notes-thin::before { - content: "\ec9f"; -} - -.ph-navigation-arrow-thin::before { - content: "\eca0"; -} - -.ph-needle-thin::before { - content: "\eca1"; -} - -.ph-newspaper-clipping-thin::before { - content: "\eca2"; -} - -.ph-newspaper-thin::before { - content: "\eca3"; -} - -.ph-note-blank-thin::before { - content: "\eca4"; -} - -.ph-note-pencil-thin::before { - content: "\eca5"; -} - -.ph-note-thin::before { - content: "\eca6"; -} - -.ph-notebook-thin::before { - content: "\eca7"; -} - -.ph-notepad-thin::before { - content: "\eca8"; -} - -.ph-notification-thin::before { - content: "\eca9"; -} - -.ph-number-circle-eight-thin::before { - content: "\ecaa"; -} - -.ph-number-circle-five-thin::before { - content: "\ecab"; -} - -.ph-number-circle-four-thin::before { - content: "\ecac"; -} - -.ph-number-circle-nine-thin::before { - content: "\ecad"; -} - -.ph-number-circle-one-thin::before { - content: "\ecae"; -} - -.ph-number-circle-seven-thin::before { - content: "\ecaf"; -} - -.ph-number-circle-six-thin::before { - content: "\ecb0"; -} - -.ph-number-circle-three-thin::before { - content: "\ecb1"; -} - -.ph-number-circle-two-thin::before { - content: "\ecb2"; -} - -.ph-number-circle-zero-thin::before { - content: "\ecb3"; -} - -.ph-number-eight-thin::before { - content: "\ecb4"; -} - -.ph-number-five-thin::before { - content: "\ecb5"; -} - -.ph-number-four-thin::before { - content: "\ecb6"; -} - -.ph-number-nine-thin::before { - content: "\ecb7"; -} - -.ph-number-one-thin::before { - content: "\ecb8"; -} - -.ph-number-seven-thin::before { - content: "\ecb9"; -} - -.ph-number-six-thin::before { - content: "\ecba"; -} - -.ph-number-square-eight-thin::before { - content: "\ecbb"; -} - -.ph-number-square-five-thin::before { - content: "\ecbc"; -} - -.ph-number-square-four-thin::before { - content: "\ecbd"; -} - -.ph-number-square-nine-thin::before { - content: "\ecbe"; -} - -.ph-number-square-one-thin::before { - content: "\ecbf"; -} - -.ph-number-square-seven-thin::before { - content: "\ecc0"; -} - -.ph-number-square-six-thin::before { - content: "\ecc1"; -} - -.ph-number-square-three-thin::before { - content: "\ecc2"; -} - -.ph-number-square-two-thin::before { - content: "\ecc3"; -} - -.ph-number-square-zero-thin::before { - content: "\ecc4"; -} - -.ph-number-three-thin::before { - content: "\ecc5"; -} - -.ph-number-two-thin::before { - content: "\ecc6"; -} - -.ph-number-zero-thin::before { - content: "\ecc7"; -} - -.ph-nut-thin::before { - content: "\ecc8"; -} - -.ph-ny-times-logo-thin::before { - content: "\ecc9"; -} - -.ph-octagon-thin::before { - content: "\ecca"; -} - -.ph-option-thin::before { - content: "\eccb"; -} - -.ph-package-thin::before { - content: "\eccc"; -} - -.ph-paint-brush-broad-thin::before { - content: "\eccd"; -} - -.ph-paint-brush-household-thin::before { - content: "\ecce"; -} - -.ph-paint-brush-thin::before { - content: "\eccf"; -} - -.ph-paint-bucket-thin::before { - content: "\ecd0"; -} - -.ph-paint-roller-thin::before { - content: "\ecd1"; -} - -.ph-palette-thin::before { - content: "\ecd2"; -} - -.ph-paper-plane-right-thin::before { - content: "\ecd3"; -} - -.ph-paper-plane-thin::before { - content: "\ecd4"; -} - -.ph-paper-plane-tilt-thin::before { - content: "\ecd5"; -} - -.ph-paperclip-horizontal-thin::before { - content: "\ecd6"; -} - -.ph-paperclip-thin::before { - content: "\ecd7"; -} - -.ph-parachute-thin::before { - content: "\ecd8"; -} - -.ph-password-thin::before { - content: "\ecd9"; -} - -.ph-path-thin::before { - content: "\ecda"; -} - -.ph-pause-circle-thin::before { - content: "\ecdb"; -} - -.ph-pause-thin::before { - content: "\ecdc"; -} - -.ph-paw-print-thin::before { - content: "\ecdd"; -} - -.ph-peace-thin::before { - content: "\ecde"; -} - -.ph-pen-nib-straight-thin::before { - content: "\ecdf"; -} - -.ph-pen-nib-thin::before { - content: "\ece0"; -} - -.ph-pen-thin::before { - content: "\ece1"; -} - -.ph-pencil-circle-thin::before { - content: "\ece2"; -} - -.ph-pencil-line-thin::before { - content: "\ece3"; -} - -.ph-pencil-simple-line-thin::before { - content: "\ece4"; -} - -.ph-pencil-simple-thin::before { - content: "\ece5"; -} - -.ph-pencil-thin::before { - content: "\ece6"; -} - -.ph-percent-thin::before { - content: "\ece7"; -} - -.ph-person-simple-run-thin::before { - content: "\ece8"; -} - -.ph-person-simple-thin::before { - content: "\ece9"; -} - -.ph-person-simple-walk-thin::before { - content: "\ecea"; -} - -.ph-person-thin::before { - content: "\eceb"; -} - -.ph-perspective-thin::before { - content: "\ecec"; -} - -.ph-phone-call-thin::before { - content: "\eced"; -} - -.ph-phone-disconnect-thin::before { - content: "\ecee"; -} - -.ph-phone-incoming-thin::before { - content: "\ecef"; -} - -.ph-phone-outgoing-thin::before { - content: "\ecf0"; -} - -.ph-phone-slash-thin::before { - content: "\ecf1"; -} - -.ph-phone-thin::before { - content: "\ecf2"; -} - -.ph-phone-x-thin::before { - content: "\ecf3"; -} - -.ph-phosphor-logo-thin::before { - content: "\ecf4"; -} - -.ph-piano-keys-thin::before { - content: "\ecf5"; -} - -.ph-picture-in-picture-thin::before { - content: "\ecf6"; -} - -.ph-pill-thin::before { - content: "\ecf7"; -} - -.ph-pinterest-logo-thin::before { - content: "\ecf8"; -} - -.ph-pinwheel-thin::before { - content: "\ecf9"; -} - -.ph-pizza-thin::before { - content: "\ecfa"; -} - -.ph-placeholder-thin::before { - content: "\ecfb"; -} - -.ph-planet-thin::before { - content: "\ecfc"; -} - -.ph-play-circle-thin::before { - content: "\ecfd"; -} - -.ph-play-thin::before { - content: "\ecfe"; -} - -.ph-playlist-thin::before { - content: "\ecff"; -} - -.ph-plug-thin::before { - content: "\ed00"; -} - -.ph-plugs-connected-thin::before { - content: "\ed01"; -} - -.ph-plugs-thin::before { - content: "\ed02"; -} - -.ph-plus-circle-thin::before { - content: "\ed03"; -} - -.ph-plus-minus-thin::before { - content: "\ed04"; -} - -.ph-plus-thin::before { - content: "\ed05"; -} - -.ph-poker-chip-thin::before { - content: "\ed06"; -} - -.ph-police-car-thin::before { - content: "\ed07"; -} - -.ph-polygon-thin::before { - content: "\ed08"; -} - -.ph-popcorn-thin::before { - content: "\ed09"; -} - -.ph-power-thin::before { - content: "\ed0a"; -} - -.ph-prescription-thin::before { - content: "\ed0b"; -} - -.ph-presentation-chart-thin::before { - content: "\ed0c"; -} - -.ph-presentation-thin::before { - content: "\ed0d"; -} - -.ph-printer-thin::before { - content: "\ed0e"; -} - -.ph-prohibit-inset-thin::before { - content: "\ed0f"; -} - -.ph-prohibit-thin::before { - content: "\ed10"; -} - -.ph-projector-screen-chart-thin::before { - content: "\ed11"; -} - -.ph-projector-screen-thin::before { - content: "\ed12"; -} - -.ph-push-pin-simple-slash-thin::before { - content: "\ed13"; -} - -.ph-push-pin-simple-thin::before { - content: "\ed14"; -} - -.ph-push-pin-slash-thin::before { - content: "\ed15"; -} - -.ph-push-pin-thin::before { - content: "\ed16"; -} - -.ph-puzzle-piece-thin::before { - content: "\ed17"; -} - -.ph-qr-code-thin::before { - content: "\ed18"; -} - -.ph-question-thin::before { - content: "\ed19"; -} - -.ph-queue-thin::before { - content: "\ed1a"; -} - -.ph-quotes-thin::before { - content: "\ed1b"; -} - -.ph-radical-thin::before { - content: "\ed1c"; -} - -.ph-radio-button-thin::before { - content: "\ed1d"; -} - -.ph-radio-thin::before { - content: "\ed1e"; -} - -.ph-rainbow-cloud-thin::before { - content: "\ed1f"; -} - -.ph-rainbow-thin::before { - content: "\ed20"; -} - -.ph-receipt-thin::before { - content: "\ed21"; -} - -.ph-record-thin::before { - content: "\ed22"; -} - -.ph-rectangle-thin::before { - content: "\ed23"; -} - -.ph-recycle-thin::before { - content: "\ed24"; -} - -.ph-reddit-logo-thin::before { - content: "\ed25"; -} - -.ph-repeat-once-thin::before { - content: "\ed26"; -} - -.ph-repeat-thin::before { - content: "\ed27"; -} - -.ph-rewind-circle-thin::before { - content: "\ed28"; -} - -.ph-rewind-thin::before { - content: "\ed29"; -} - -.ph-robot-thin::before { - content: "\ed2a"; -} - -.ph-rocket-launch-thin::before { - content: "\ed2b"; -} - -.ph-rocket-thin::before { - content: "\ed2c"; -} - -.ph-rows-thin::before { - content: "\ed2d"; -} - -.ph-rss-simple-thin::before { - content: "\ed2e"; -} - -.ph-rss-thin::before { - content: "\ed2f"; -} - -.ph-rug-thin::before { - content: "\ed30"; -} - -.ph-ruler-thin::before { - content: "\ed31"; -} - -.ph-scales-thin::before { - content: "\ed32"; -} - -.ph-scan-thin::before { - content: "\ed33"; -} - -.ph-scissors-thin::before { - content: "\ed34"; -} - -.ph-screencast-thin::before { - content: "\ed35"; -} - -.ph-scribble-loop-thin::before { - content: "\ed36"; -} - -.ph-scroll-thin::before { - content: "\ed37"; -} - -.ph-selection-all-thin::before { - content: "\ed38"; -} - -.ph-selection-background-thin::before { - content: "\ed39"; -} - -.ph-selection-foreground-thin::before { - content: "\ed3a"; -} - -.ph-selection-inverse-thin::before { - content: "\ed3b"; -} - -.ph-selection-plus-thin::before { - content: "\ed3c"; -} - -.ph-selection-slash-thin::before { - content: "\ed3d"; -} - -.ph-selection-thin::before { - content: "\ed3e"; -} - -.ph-share-network-thin::before { - content: "\ed3f"; -} - -.ph-share-thin::before { - content: "\ed40"; -} - -.ph-shield-check-thin::before { - content: "\ed41"; -} - -.ph-shield-checkered-thin::before { - content: "\ed42"; -} - -.ph-shield-chevron-thin::before { - content: "\ed43"; -} - -.ph-shield-plus-thin::before { - content: "\ed44"; -} - -.ph-shield-slash-thin::before { - content: "\ed45"; -} - -.ph-shield-star-thin::before { - content: "\ed46"; -} - -.ph-shield-thin::before { - content: "\ed47"; -} - -.ph-shield-warning-thin::before { - content: "\ed48"; -} - -.ph-shopping-bag-open-thin::before { - content: "\ed49"; -} - -.ph-shopping-bag-thin::before { - content: "\ed4a"; -} - -.ph-shopping-cart-simple-thin::before { - content: "\ed4b"; -} - -.ph-shopping-cart-thin::before { - content: "\ed4c"; -} - -.ph-shower-thin::before { - content: "\ed4d"; -} - -.ph-shuffle-angular-thin::before { - content: "\ed4e"; -} - -.ph-shuffle-simple-thin::before { - content: "\ed4f"; -} - -.ph-shuffle-thin::before { - content: "\ed50"; -} - -.ph-sidebar-simple-thin::before { - content: "\ed51"; -} - -.ph-sidebar-thin::before { - content: "\ed52"; -} - -.ph-sign-in-thin::before { - content: "\ed53"; -} - -.ph-sign-out-thin::before { - content: "\ed54"; -} - -.ph-signpost-thin::before { - content: "\ed55"; -} - -.ph-sim-card-thin::before { - content: "\ed56"; -} - -.ph-sketch-logo-thin::before { - content: "\ed57"; -} - -.ph-skip-back-circle-thin::before { - content: "\ed58"; -} - -.ph-skip-back-thin::before { - content: "\ed59"; -} - -.ph-skip-forward-circle-thin::before { - content: "\ed5a"; -} - -.ph-skip-forward-thin::before { - content: "\ed5b"; -} - -.ph-skull-thin::before { - content: "\ed5c"; -} - -.ph-slack-logo-thin::before { - content: "\ed5d"; -} - -.ph-sliders-horizontal-thin::before { - content: "\ed5e"; -} - -.ph-sliders-thin::before { - content: "\ed5f"; -} - -.ph-smiley-blank-thin::before { - content: "\ed60"; -} - -.ph-smiley-meh-thin::before { - content: "\ed61"; -} - -.ph-smiley-nervous-thin::before { - content: "\ed62"; -} - -.ph-smiley-sad-thin::before { - content: "\ed63"; -} - -.ph-smiley-sticker-thin::before { - content: "\ed64"; -} - -.ph-smiley-thin::before { - content: "\ed65"; -} - -.ph-smiley-wink-thin::before { - content: "\ed66"; -} - -.ph-smiley-x-eyes-thin::before { - content: "\ed67"; -} - -.ph-snapchat-logo-thin::before { - content: "\ed68"; -} - -.ph-snowflake-thin::before { - content: "\ed69"; -} - -.ph-soccer-ball-thin::before { - content: "\ed6a"; -} - -.ph-sort-ascending-thin::before { - content: "\ed6b"; -} - -.ph-sort-descending-thin::before { - content: "\ed6c"; -} - -.ph-spade-thin::before { - content: "\ed6d"; -} - -.ph-sparkle-thin::before { - content: "\ed6e"; -} - -.ph-speaker-high-thin::before { - content: "\ed6f"; -} - -.ph-speaker-low-thin::before { - content: "\ed70"; -} - -.ph-speaker-none-thin::before { - content: "\ed71"; -} - -.ph-speaker-simple-high-thin::before { - content: "\ed72"; -} - -.ph-speaker-simple-low-thin::before { - content: "\ed73"; -} - -.ph-speaker-simple-none-thin::before { - content: "\ed74"; -} - -.ph-speaker-simple-slash-thin::before { - content: "\ed75"; -} - -.ph-speaker-simple-x-thin::before { - content: "\ed76"; -} - -.ph-speaker-slash-thin::before { - content: "\ed77"; -} - -.ph-speaker-x-thin::before { - content: "\ed78"; -} - -.ph-spinner-gap-thin::before { - content: "\ed79"; -} - -.ph-spinner-thin::before { - content: "\ed7a"; -} - -.ph-spiral-thin::before { - content: "\ed7b"; -} - -.ph-spotify-logo-thin::before { - content: "\ed7c"; -} - -.ph-square-half-bottom-thin::before { - content: "\ed7d"; -} - -.ph-square-half-thin::before { - content: "\ed7e"; -} - -.ph-square-logo-thin::before { - content: "\ed7f"; -} - -.ph-square-thin::before { - content: "\ed80"; -} - -.ph-squares-four-thin::before { - content: "\ed81"; -} - -.ph-stack-overflow-logo-thin::before { - content: "\ed82"; -} - -.ph-stack-simple-thin::before { - content: "\ed83"; -} - -.ph-stack-thin::before { - content: "\ed84"; -} - -.ph-stamp-thin::before { - content: "\ed85"; -} - -.ph-star-four-thin::before { - content: "\ed86"; -} - -.ph-star-half-thin::before { - content: "\ed87"; -} - -.ph-star-thin::before { - content: "\ed88"; -} - -.ph-sticker-thin::before { - content: "\ed89"; -} - -.ph-stop-circle-thin::before { - content: "\ed8a"; -} - -.ph-stop-thin::before { - content: "\ed8b"; -} - -.ph-storefront-thin::before { - content: "\ed8c"; -} - -.ph-strategy-thin::before { - content: "\ed8d"; -} - -.ph-stripe-logo-thin::before { - content: "\ed8e"; -} - -.ph-student-thin::before { - content: "\ed8f"; -} - -.ph-suitcase-simple-thin::before { - content: "\ed90"; -} - -.ph-suitcase-thin::before { - content: "\ed91"; -} - -.ph-sun-dim-thin::before { - content: "\ed92"; -} - -.ph-sun-horizon-thin::before { - content: "\ed93"; -} - -.ph-sun-thin::before { - content: "\ed94"; -} - -.ph-sunglasses-thin::before { - content: "\ed95"; -} - -.ph-swap-thin::before { - content: "\ed96"; -} - -.ph-swatches-thin::before { - content: "\ed97"; -} - -.ph-sword-thin::before { - content: "\ed98"; -} - -.ph-syringe-thin::before { - content: "\ed99"; -} - -.ph-t-shirt-thin::before { - content: "\ed9a"; -} - -.ph-table-thin::before { - content: "\ed9b"; -} - -.ph-tabs-thin::before { - content: "\ed9c"; -} - -.ph-tag-chevron-thin::before { - content: "\ed9d"; -} - -.ph-tag-simple-thin::before { - content: "\ed9e"; -} - -.ph-tag-thin::before { - content: "\ed9f"; -} - -.ph-target-thin::before { - content: "\eda0"; -} - -.ph-taxi-thin::before { - content: "\eda1"; -} - -.ph-telegram-logo-thin::before { - content: "\eda2"; -} - -.ph-television-simple-thin::before { - content: "\eda3"; -} - -.ph-television-thin::before { - content: "\eda4"; -} - -.ph-tennis-ball-thin::before { - content: "\eda5"; -} - -.ph-terminal-thin::before { - content: "\eda6"; -} - -.ph-terminal-window-thin::before { - content: "\eda7"; -} - -.ph-test-tube-thin::before { - content: "\eda8"; -} - -.ph-text-aa-thin::before { - content: "\eda9"; -} - -.ph-text-align-center-thin::before { - content: "\edaa"; -} - -.ph-text-align-justify-thin::before { - content: "\edab"; -} - -.ph-text-align-left-thin::before { - content: "\edac"; -} - -.ph-text-align-right-thin::before { - content: "\edad"; -} - -.ph-text-bolder-thin::before { - content: "\edae"; -} - -.ph-text-h-five-thin::before { - content: "\edaf"; -} - -.ph-text-h-four-thin::before { - content: "\edb0"; -} - -.ph-text-h-one-thin::before { - content: "\edb1"; -} - -.ph-text-h-six-thin::before { - content: "\edb2"; -} - -.ph-text-h-thin::before { - content: "\edb3"; -} - -.ph-text-h-three-thin::before { - content: "\edb4"; -} - -.ph-text-h-two-thin::before { - content: "\edb5"; -} - -.ph-text-indent-thin::before { - content: "\edb6"; -} - -.ph-text-italic-thin::before { - content: "\edb7"; -} - -.ph-text-outdent-thin::before { - content: "\edb8"; -} - -.ph-text-strikethrough-thin::before { - content: "\edb9"; -} - -.ph-text-t-thin::before { - content: "\edba"; -} - -.ph-text-underline-thin::before { - content: "\edbb"; -} - -.ph-textbox-thin::before { - content: "\edbc"; -} - -.ph-thermometer-cold-thin::before { - content: "\edbd"; -} - -.ph-thermometer-hot-thin::before { - content: "\edbe"; -} - -.ph-thermometer-simple-thin::before { - content: "\edbf"; -} - -.ph-thermometer-thin::before { - content: "\edc0"; -} - -.ph-thumbs-down-thin::before { - content: "\edc1"; -} - -.ph-thumbs-up-thin::before { - content: "\edc2"; -} - -.ph-ticket-thin::before { - content: "\edc3"; -} - -.ph-tiktok-logo-thin::before { - content: "\edc4"; -} - -.ph-timer-thin::before { - content: "\edc5"; -} - -.ph-toggle-left-thin::before { - content: "\edc6"; -} - -.ph-toggle-right-thin::before { - content: "\edc7"; -} - -.ph-toilet-paper-thin::before { - content: "\edc8"; -} - -.ph-toilet-thin::before { - content: "\edc9"; -} - -.ph-tote-simple-thin::before { - content: "\edca"; -} - -.ph-tote-thin::before { - content: "\edcb"; -} - -.ph-trademark-registered-thin::before { - content: "\edcc"; -} - -.ph-traffic-cone-thin::before { - content: "\edcd"; -} - -.ph-traffic-sign-thin::before { - content: "\edce"; -} - -.ph-traffic-signal-thin::before { - content: "\edcf"; -} - -.ph-train-regional-thin::before { - content: "\edd0"; -} - -.ph-train-simple-thin::before { - content: "\edd1"; -} - -.ph-train-thin::before { - content: "\edd2"; -} - -.ph-translate-thin::before { - content: "\edd3"; -} - -.ph-trash-simple-thin::before { - content: "\edd4"; -} - -.ph-trash-thin::before { - content: "\edd5"; -} - -.ph-tray-thin::before { - content: "\edd6"; -} - -.ph-tree-evergreen-thin::before { - content: "\edd7"; -} - -.ph-tree-structure-thin::before { - content: "\edd8"; -} - -.ph-tree-thin::before { - content: "\edd9"; -} - -.ph-trend-down-thin::before { - content: "\edda"; -} - -.ph-trend-up-thin::before { - content: "\eddb"; -} - -.ph-triangle-thin::before { - content: "\eddc"; -} - -.ph-trophy-thin::before { - content: "\eddd"; -} - -.ph-truck-thin::before { - content: "\edde"; -} - -.ph-twitch-logo-thin::before { - content: "\eddf"; -} - -.ph-twitter-logo-thin::before { - content: "\ede0"; -} - -.ph-umbrella-simple-thin::before { - content: "\ede1"; -} - -.ph-umbrella-thin::before { - content: "\ede2"; -} - -.ph-upload-simple-thin::before { - content: "\ede3"; -} - -.ph-upload-thin::before { - content: "\ede4"; -} - -.ph-user-circle-gear-thin::before { - content: "\ede5"; -} - -.ph-user-circle-minus-thin::before { - content: "\ede6"; -} - -.ph-user-circle-plus-thin::before { - content: "\ede7"; -} - -.ph-user-circle-thin::before { - content: "\ede8"; -} - -.ph-user-focus-thin::before { - content: "\ede9"; -} - -.ph-user-gear-thin::before { - content: "\edea"; -} - -.ph-user-list-thin::before { - content: "\edeb"; -} - -.ph-user-minus-thin::before { - content: "\edec"; -} - -.ph-user-plus-thin::before { - content: "\eded"; -} - -.ph-user-rectangle-thin::before { - content: "\edee"; -} - -.ph-user-square-thin::before { - content: "\edef"; -} - -.ph-user-switch-thin::before { - content: "\edf0"; -} - -.ph-user-thin::before { - content: "\edf1"; -} - -.ph-users-four-thin::before { - content: "\edf2"; -} - -.ph-users-thin::before { - content: "\edf3"; -} - -.ph-users-three-thin::before { - content: "\edf4"; -} - -.ph-vault-thin::before { - content: "\edf5"; -} - -.ph-vibrate-thin::before { - content: "\edf6"; -} - -.ph-video-camera-slash-thin::before { - content: "\edf7"; -} - -.ph-video-camera-thin::before { - content: "\edf8"; -} - -.ph-vignette-thin::before { - content: "\edf9"; -} - -.ph-voicemail-thin::before { - content: "\edfa"; -} - -.ph-volleyball-thin::before { - content: "\edfb"; -} - -.ph-wall-thin::before { - content: "\edfc"; -} - -.ph-wallet-thin::before { - content: "\edfd"; -} - -.ph-warning-circle-thin::before { - content: "\edfe"; -} - -.ph-warning-octagon-thin::before { - content: "\edff"; -} - -.ph-warning-thin::before { - content: "\ee00"; -} - -.ph-watch-thin::before { - content: "\ee01"; -} - -.ph-wave-sawtooth-thin::before { - content: "\ee02"; -} - -.ph-wave-sine-thin::before { - content: "\ee03"; -} - -.ph-wave-square-thin::before { - content: "\ee04"; -} - -.ph-wave-triangle-thin::before { - content: "\ee05"; -} - -.ph-waves-thin::before { - content: "\ee06"; -} - -.ph-webcam-thin::before { - content: "\ee07"; -} - -.ph-whatsapp-logo-thin::before { - content: "\ee08"; -} - -.ph-wheelchair-thin::before { - content: "\ee09"; -} - -.ph-wifi-high-thin::before { - content: "\ee0a"; -} - -.ph-wifi-low-thin::before { - content: "\ee0b"; -} - -.ph-wifi-medium-thin::before { - content: "\ee0c"; -} - -.ph-wifi-none-thin::before { - content: "\ee0d"; -} - -.ph-wifi-slash-thin::before { - content: "\ee0e"; -} - -.ph-wifi-x-thin::before { - content: "\ee0f"; -} - -.ph-wind-thin::before { - content: "\ee10"; -} - -.ph-windows-logo-thin::before { - content: "\ee11"; -} - -.ph-wine-thin::before { - content: "\ee12"; -} - -.ph-wrench-thin::before { - content: "\ee13"; -} - -.ph-x-circle-thin::before { - content: "\ee14"; -} - -.ph-x-square-thin::before { - content: "\ee15"; -} - -.ph-x-thin::before { - content: "\ee16"; -} - -.ph-yin-yang-thin::before { - content: "\ee17"; -} - -.ph-youtube-logo-thin::before { - content: "\ee18"; -} - -.ph-activity-light::before { - content: "\ee19"; -} - -.ph-address-book-light::before { - content: "\ee1a"; -} - -.ph-airplane-in-flight-light::before { - content: "\ee1b"; -} - -.ph-airplane-landing-light::before { - content: "\ee1c"; -} - -.ph-airplane-light::before { - content: "\ee1d"; -} - -.ph-airplane-takeoff-light::before { - content: "\ee1e"; -} - -.ph-airplane-tilt-light::before { - content: "\ee1f"; -} - -.ph-airplay-light::before { - content: "\ee20"; -} - -.ph-alarm-light::before { - content: "\ee21"; -} - -.ph-alien-light::before { - content: "\ee22"; -} - -.ph-align-bottom-light::before { - content: "\ee23"; -} - -.ph-align-bottom-simple-light::before { - content: "\ee24"; -} - -.ph-align-center-horizontal-light::before { - content: "\ee25"; -} - -.ph-align-center-horizontal-simple-light::before { - content: "\ee26"; -} - -.ph-align-center-vertical-light::before { - content: "\ee27"; -} - -.ph-align-center-vertical-simple-light::before { - content: "\ee28"; -} - -.ph-align-left-light::before { - content: "\ee29"; -} - -.ph-align-left-simple-light::before { - content: "\ee2a"; -} - -.ph-align-right-light::before { - content: "\ee2b"; -} - -.ph-align-right-simple-light::before { - content: "\ee2c"; -} - -.ph-align-top-light::before { - content: "\ee2d"; -} - -.ph-align-top-simple-light::before { - content: "\ee2e"; -} - -.ph-anchor-light::before { - content: "\ee2f"; -} - -.ph-anchor-simple-light::before { - content: "\ee30"; -} - -.ph-android-logo-light::before { - content: "\ee31"; -} - -.ph-angular-logo-light::before { - content: "\ee32"; -} - -.ph-aperture-light::before { - content: "\ee33"; -} - -.ph-app-store-logo-light::before { - content: "\ee34"; -} - -.ph-app-window-light::before { - content: "\ee35"; -} - -.ph-apple-logo-light::before { - content: "\ee36"; -} - -.ph-apple-podcasts-logo-light::before { - content: "\ee37"; -} - -.ph-archive-box-light::before { - content: "\ee38"; -} - -.ph-archive-light::before { - content: "\ee39"; -} - -.ph-archive-tray-light::before { - content: "\ee3a"; -} - -.ph-armchair-light::before { - content: "\ee3b"; -} - -.ph-arrow-arc-left-light::before { - content: "\ee3c"; -} - -.ph-arrow-arc-right-light::before { - content: "\ee3d"; -} - -.ph-arrow-bend-double-up-left-light::before { - content: "\ee3e"; -} - -.ph-arrow-bend-double-up-right-light::before { - content: "\ee3f"; -} - -.ph-arrow-bend-down-left-light::before { - content: "\ee40"; -} - -.ph-arrow-bend-down-right-light::before { - content: "\ee41"; -} - -.ph-arrow-bend-left-down-light::before { - content: "\ee42"; -} - -.ph-arrow-bend-left-up-light::before { - content: "\ee43"; -} - -.ph-arrow-bend-right-down-light::before { - content: "\ee44"; -} - -.ph-arrow-bend-right-up-light::before { - content: "\ee45"; -} - -.ph-arrow-bend-up-left-light::before { - content: "\ee46"; -} - -.ph-arrow-bend-up-right-light::before { - content: "\ee47"; -} - -.ph-arrow-circle-down-left-light::before { - content: "\ee48"; -} - -.ph-arrow-circle-down-light::before { - content: "\ee49"; -} - -.ph-arrow-circle-down-right-light::before { - content: "\ee4a"; -} - -.ph-arrow-circle-left-light::before { - content: "\ee4b"; -} - -.ph-arrow-circle-right-light::before { - content: "\ee4c"; -} - -.ph-arrow-circle-up-left-light::before { - content: "\ee4d"; -} - -.ph-arrow-circle-up-light::before { - content: "\ee4e"; -} - -.ph-arrow-circle-up-right-light::before { - content: "\ee4f"; -} - -.ph-arrow-clockwise-light::before { - content: "\ee50"; -} - -.ph-arrow-counter-clockwise-light::before { - content: "\ee51"; -} - -.ph-arrow-down-left-light::before { - content: "\ee52"; -} - -.ph-arrow-down-light::before { - content: "\ee53"; -} - -.ph-arrow-down-right-light::before { - content: "\ee54"; -} - -.ph-arrow-elbow-down-left-light::before { - content: "\ee55"; -} - -.ph-arrow-elbow-down-right-light::before { - content: "\ee56"; -} - -.ph-arrow-elbow-left-down-light::before { - content: "\ee57"; -} - -.ph-arrow-elbow-left-light::before { - content: "\ee58"; -} - -.ph-arrow-elbow-left-up-light::before { - content: "\ee59"; -} - -.ph-arrow-elbow-right-down-light::before { - content: "\ee5a"; -} - -.ph-arrow-elbow-right-light::before { - content: "\ee5b"; -} - -.ph-arrow-elbow-right-up-light::before { - content: "\ee5c"; -} - -.ph-arrow-elbow-up-left-light::before { - content: "\ee5d"; -} - -.ph-arrow-elbow-up-right-light::before { - content: "\ee5e"; -} - -.ph-arrow-fat-down-light::before { - content: "\ee5f"; -} - -.ph-arrow-fat-left-light::before { - content: "\ee60"; -} - -.ph-arrow-fat-line-down-light::before { - content: "\ee61"; -} - -.ph-arrow-fat-line-left-light::before { - content: "\ee62"; -} - -.ph-arrow-fat-line-right-light::before { - content: "\ee63"; -} - -.ph-arrow-fat-line-up-light::before { - content: "\ee64"; -} - -.ph-arrow-fat-lines-down-light::before { - content: "\ee65"; -} - -.ph-arrow-fat-lines-left-light::before { - content: "\ee66"; -} - -.ph-arrow-fat-lines-right-light::before { - content: "\ee67"; -} - -.ph-arrow-fat-lines-up-light::before { - content: "\ee68"; -} - -.ph-arrow-fat-right-light::before { - content: "\ee69"; -} - -.ph-arrow-fat-up-light::before { - content: "\ee6a"; -} - -.ph-arrow-left-light::before { - content: "\ee6b"; -} - -.ph-arrow-line-down-left-light::before { - content: "\ee6c"; -} - -.ph-arrow-line-down-light::before { - content: "\ee6d"; -} - -.ph-arrow-line-down-right-light::before { - content: "\ee6e"; -} - -.ph-arrow-line-left-light::before { - content: "\ee6f"; -} - -.ph-arrow-line-right-light::before { - content: "\ee70"; -} - -.ph-arrow-line-up-left-light::before { - content: "\ee71"; -} - -.ph-arrow-line-up-light::before { - content: "\ee72"; -} - -.ph-arrow-line-up-right-light::before { - content: "\ee73"; -} - -.ph-arrow-right-light::before { - content: "\ee74"; -} - -.ph-arrow-square-down-left-light::before { - content: "\ee75"; -} - -.ph-arrow-square-down-light::before { - content: "\ee76"; -} - -.ph-arrow-square-down-right-light::before { - content: "\ee77"; -} - -.ph-arrow-square-in-light::before { - content: "\ee78"; -} - -.ph-arrow-square-left-light::before { - content: "\ee79"; -} - -.ph-arrow-square-out-light::before { - content: "\ee7a"; -} - -.ph-arrow-square-right-light::before { - content: "\ee7b"; -} - -.ph-arrow-square-up-left-light::before { - content: "\ee7c"; -} - -.ph-arrow-square-up-light::before { - content: "\ee7d"; -} - -.ph-arrow-square-up-right-light::before { - content: "\ee7e"; -} - -.ph-arrow-u-down-left-light::before { - content: "\ee7f"; -} - -.ph-arrow-u-down-right-light::before { - content: "\ee80"; -} - -.ph-arrow-u-left-down-light::before { - content: "\ee81"; -} - -.ph-arrow-u-left-up-light::before { - content: "\ee82"; -} - -.ph-arrow-u-right-down-light::before { - content: "\ee83"; -} - -.ph-arrow-u-right-up-light::before { - content: "\ee84"; -} - -.ph-arrow-u-up-left-light::before { - content: "\ee85"; -} - -.ph-arrow-u-up-right-light::before { - content: "\ee86"; -} - -.ph-arrow-up-left-light::before { - content: "\ee87"; -} - -.ph-arrow-up-light::before { - content: "\ee88"; -} - -.ph-arrow-up-right-light::before { - content: "\ee89"; -} - -.ph-arrows-clockwise-light::before { - content: "\ee8a"; -} - -.ph-arrows-counter-clockwise-light::before { - content: "\ee8b"; -} - -.ph-arrows-down-up-light::before { - content: "\ee8c"; -} - -.ph-arrows-horizontal-light::before { - content: "\ee8d"; -} - -.ph-arrows-in-cardinal-light::before { - content: "\ee8e"; -} - -.ph-arrows-in-light::before { - content: "\ee8f"; -} - -.ph-arrows-in-line-horizontal-light::before { - content: "\ee90"; -} - -.ph-arrows-in-line-vertical-light::before { - content: "\ee91"; -} - -.ph-arrows-in-simple-light::before { - content: "\ee92"; -} - -.ph-arrows-left-right-light::before { - content: "\ee93"; -} - -.ph-arrows-out-cardinal-light::before { - content: "\ee94"; -} - -.ph-arrows-out-light::before { - content: "\ee95"; -} - -.ph-arrows-out-line-horizontal-light::before { - content: "\ee96"; -} - -.ph-arrows-out-line-vertical-light::before { - content: "\ee97"; -} - -.ph-arrows-out-simple-light::before { - content: "\ee98"; -} - -.ph-arrows-vertical-light::before { - content: "\ee99"; -} - -.ph-article-light::before { - content: "\ee9a"; -} - -.ph-article-medium-light::before { - content: "\ee9b"; -} - -.ph-article-ny-times-light::before { - content: "\ee9c"; -} - -.ph-asterisk-light::before { - content: "\ee9d"; -} - -.ph-asterisk-simple-light::before { - content: "\ee9e"; -} - -.ph-at-light::before { - content: "\ee9f"; -} - -.ph-atom-light::before { - content: "\eea0"; -} - -.ph-baby-light::before { - content: "\eea1"; -} - -.ph-backpack-light::before { - content: "\eea2"; -} - -.ph-backspace-light::before { - content: "\eea3"; -} - -.ph-bag-light::before { - content: "\eea4"; -} - -.ph-bag-simple-light::before { - content: "\eea5"; -} - -.ph-balloon-light::before { - content: "\eea6"; -} - -.ph-bandaids-light::before { - content: "\eea7"; -} - -.ph-bank-light::before { - content: "\eea8"; -} - -.ph-barbell-light::before { - content: "\eea9"; -} - -.ph-barcode-light::before { - content: "\eeaa"; -} - -.ph-barricade-light::before { - content: "\eeab"; -} - -.ph-baseball-light::before { - content: "\eeac"; -} - -.ph-basketball-light::before { - content: "\eead"; -} - -.ph-bathtub-light::before { - content: "\eeae"; -} - -.ph-battery-charging-light::before { - content: "\eeaf"; -} - -.ph-battery-charging-vertical-light::before { - content: "\eeb0"; -} - -.ph-battery-empty-light::before { - content: "\eeb1"; -} - -.ph-battery-full-light::before { - content: "\eeb2"; -} - -.ph-battery-high-light::before { - content: "\eeb3"; -} - -.ph-battery-low-light::before { - content: "\eeb4"; -} - -.ph-battery-medium-light::before { - content: "\eeb5"; -} - -.ph-battery-plus-light::before { - content: "\eeb6"; -} - -.ph-battery-warning-light::before { - content: "\eeb7"; -} - -.ph-battery-warning-vertical-light::before { - content: "\eeb8"; -} - -.ph-bed-light::before { - content: "\eeb9"; -} - -.ph-beer-bottle-light::before { - content: "\eeba"; -} - -.ph-behance-logo-light::before { - content: "\eebb"; -} - -.ph-bell-light::before { - content: "\eebc"; -} - -.ph-bell-ringing-light::before { - content: "\eebd"; -} - -.ph-bell-simple-light::before { - content: "\eebe"; -} - -.ph-bell-simple-ringing-light::before { - content: "\eebf"; -} - -.ph-bell-simple-slash-light::before { - content: "\eec0"; -} - -.ph-bell-simple-z-light::before { - content: "\eec1"; -} - -.ph-bell-slash-light::before { - content: "\eec2"; -} - -.ph-bell-z-light::before { - content: "\eec3"; -} - -.ph-bezier-curve-light::before { - content: "\eec4"; -} - -.ph-bicycle-light::before { - content: "\eec5"; -} - -.ph-binoculars-light::before { - content: "\eec6"; -} - -.ph-bird-light::before { - content: "\eec7"; -} - -.ph-bluetooth-connected-light::before { - content: "\eec8"; -} - -.ph-bluetooth-light::before { - content: "\eec9"; -} - -.ph-bluetooth-slash-light::before { - content: "\eeca"; -} - -.ph-bluetooth-x-light::before { - content: "\eecb"; -} - -.ph-boat-light::before { - content: "\eecc"; -} - -.ph-book-bookmark-light::before { - content: "\eecd"; -} - -.ph-book-light::before { - content: "\eece"; -} - -.ph-book-open-light::before { - content: "\eecf"; -} - -.ph-bookmark-light::before { - content: "\eed0"; -} - -.ph-bookmark-simple-light::before { - content: "\eed1"; -} - -.ph-bookmarks-light::before { - content: "\eed2"; -} - -.ph-bookmarks-simple-light::before { - content: "\eed3"; -} - -.ph-books-light::before { - content: "\eed4"; -} - -.ph-bounding-box-light::before { - content: "\eed5"; -} - -.ph-brackets-angle-light::before { - content: "\eed6"; -} - -.ph-brackets-curly-light::before { - content: "\eed7"; -} - -.ph-brackets-round-light::before { - content: "\eed8"; -} - -.ph-brackets-square-light::before { - content: "\eed9"; -} - -.ph-brain-light::before { - content: "\eeda"; -} - -.ph-brandy-light::before { - content: "\eedb"; -} - -.ph-briefcase-light::before { - content: "\eedc"; -} - -.ph-briefcase-metal-light::before { - content: "\eedd"; -} - -.ph-broadcast-light::before { - content: "\eede"; -} - -.ph-browser-light::before { - content: "\eedf"; -} - -.ph-browsers-light::before { - content: "\eee0"; -} - -.ph-bug-beetle-light::before { - content: "\eee1"; -} - -.ph-bug-droid-light::before { - content: "\eee2"; -} - -.ph-bug-light::before { - content: "\eee3"; -} - -.ph-buildings-light::before { - content: "\eee4"; -} - -.ph-bus-light::before { - content: "\eee5"; -} - -.ph-butterfly-light::before { - content: "\eee6"; -} - -.ph-cactus-light::before { - content: "\eee7"; -} - -.ph-cake-light::before { - content: "\eee8"; -} - -.ph-calculator-light::before { - content: "\eee9"; -} - -.ph-calendar-blank-light::before { - content: "\eeea"; -} - -.ph-calendar-check-light::before { - content: "\eeeb"; -} - -.ph-calendar-light::before { - content: "\eeec"; -} - -.ph-calendar-plus-light::before { - content: "\eeed"; -} - -.ph-calendar-x-light::before { - content: "\eeee"; -} - -.ph-camera-light::before { - content: "\eeef"; -} - -.ph-camera-rotate-light::before { - content: "\eef0"; -} - -.ph-camera-slash-light::before { - content: "\eef1"; -} - -.ph-campfire-light::before { - content: "\eef2"; -} - -.ph-car-light::before { - content: "\eef3"; -} - -.ph-car-simple-light::before { - content: "\eef4"; -} - -.ph-cardholder-light::before { - content: "\eef5"; -} - -.ph-cards-light::before { - content: "\eef6"; -} - -.ph-caret-circle-double-down-light::before { - content: "\eef7"; -} - -.ph-caret-circle-double-left-light::before { - content: "\eef8"; -} - -.ph-caret-circle-double-right-light::before { - content: "\eef9"; -} - -.ph-caret-circle-double-up-light::before { - content: "\eefa"; -} - -.ph-caret-circle-down-light::before { - content: "\eefb"; -} - -.ph-caret-circle-left-light::before { - content: "\eefc"; -} - -.ph-caret-circle-right-light::before { - content: "\eefd"; -} - -.ph-caret-circle-up-light::before { - content: "\eefe"; -} - -.ph-caret-double-down-light::before { - content: "\eeff"; -} - -.ph-caret-double-left-light::before { - content: "\ef00"; -} - -.ph-caret-double-right-light::before { - content: "\ef01"; -} - -.ph-caret-double-up-light::before { - content: "\ef02"; -} - -.ph-caret-down-light::before { - content: "\ef03"; -} - -.ph-caret-left-light::before { - content: "\ef04"; -} - -.ph-caret-right-light::before { - content: "\ef05"; -} - -.ph-caret-up-light::before { - content: "\ef06"; -} - -.ph-cat-light::before { - content: "\ef07"; -} - -.ph-cell-signal-full-light::before { - content: "\ef08"; -} - -.ph-cell-signal-high-light::before { - content: "\ef09"; -} - -.ph-cell-signal-low-light::before { - content: "\ef0a"; -} - -.ph-cell-signal-medium-light::before { - content: "\ef0b"; -} - -.ph-cell-signal-none-light::before { - content: "\ef0c"; -} - -.ph-cell-signal-slash-light::before { - content: "\ef0d"; -} - -.ph-cell-signal-x-light::before { - content: "\ef0e"; -} - -.ph-chalkboard-light::before { - content: "\ef0f"; -} - -.ph-chalkboard-simple-light::before { - content: "\ef10"; -} - -.ph-chalkboard-teacher-light::before { - content: "\ef11"; -} - -.ph-chart-bar-horizontal-light::before { - content: "\ef12"; -} - -.ph-chart-bar-light::before { - content: "\ef13"; -} - -.ph-chart-line-light::before { - content: "\ef14"; -} - -.ph-chart-line-up-light::before { - content: "\ef15"; -} - -.ph-chart-pie-light::before { - content: "\ef16"; -} - -.ph-chart-pie-slice-light::before { - content: "\ef17"; -} - -.ph-chat-centered-dots-light::before { - content: "\ef18"; -} - -.ph-chat-centered-light::before { - content: "\ef19"; -} - -.ph-chat-centered-text-light::before { - content: "\ef1a"; -} - -.ph-chat-circle-dots-light::before { - content: "\ef1b"; -} - -.ph-chat-circle-light::before { - content: "\ef1c"; -} - -.ph-chat-circle-text-light::before { - content: "\ef1d"; -} - -.ph-chat-dots-light::before { - content: "\ef1e"; -} - -.ph-chat-light::before { - content: "\ef1f"; -} - -.ph-chat-teardrop-dots-light::before { - content: "\ef20"; -} - -.ph-chat-teardrop-light::before { - content: "\ef21"; -} - -.ph-chat-teardrop-text-light::before { - content: "\ef22"; -} - -.ph-chat-text-light::before { - content: "\ef23"; -} - -.ph-chats-circle-light::before { - content: "\ef24"; -} - -.ph-chats-light::before { - content: "\ef25"; -} - -.ph-chats-teardrop-light::before { - content: "\ef26"; -} - -.ph-check-circle-light::before { - content: "\ef27"; -} - -.ph-check-light::before { - content: "\ef28"; -} - -.ph-check-square-light::before { - content: "\ef29"; -} - -.ph-check-square-offset-light::before { - content: "\ef2a"; -} - -.ph-checks-light::before { - content: "\ef2b"; -} - -.ph-circle-dashed-light::before { - content: "\ef2c"; -} - -.ph-circle-half-light::before { - content: "\ef2d"; -} - -.ph-circle-half-tilt-light::before { - content: "\ef2e"; -} - -.ph-circle-light::before { - content: "\ef2f"; -} - -.ph-circle-notch-light::before { - content: "\ef30"; -} - -.ph-circle-wavy-check-light::before { - content: "\ef31"; -} - -.ph-circle-wavy-light::before { - content: "\ef32"; -} - -.ph-circle-wavy-question-light::before { - content: "\ef33"; -} - -.ph-circle-wavy-warning-light::before { - content: "\ef34"; -} - -.ph-circles-four-light::before { - content: "\ef35"; -} - -.ph-circles-three-light::before { - content: "\ef36"; -} - -.ph-circles-three-plus-light::before { - content: "\ef37"; -} - -.ph-clipboard-light::before { - content: "\ef38"; -} - -.ph-clipboard-text-light::before { - content: "\ef39"; -} - -.ph-clock-afternoon-light::before { - content: "\ef3a"; -} - -.ph-clock-clockwise-light::before { - content: "\ef3b"; -} - -.ph-clock-counter-clockwise-light::before { - content: "\ef3c"; -} - -.ph-clock-light::before { - content: "\ef3d"; -} - -.ph-closed-captioning-light::before { - content: "\ef3e"; -} - -.ph-cloud-arrow-down-light::before { - content: "\ef3f"; -} - -.ph-cloud-arrow-up-light::before { - content: "\ef40"; -} - -.ph-cloud-check-light::before { - content: "\ef41"; -} - -.ph-cloud-fog-light::before { - content: "\ef42"; -} - -.ph-cloud-light::before { - content: "\ef43"; -} - -.ph-cloud-lightning-light::before { - content: "\ef44"; -} - -.ph-cloud-moon-light::before { - content: "\ef45"; -} - -.ph-cloud-rain-light::before { - content: "\ef46"; -} - -.ph-cloud-slash-light::before { - content: "\ef47"; -} - -.ph-cloud-snow-light::before { - content: "\ef48"; -} - -.ph-cloud-sun-light::before { - content: "\ef49"; -} - -.ph-club-light::before { - content: "\ef4a"; -} - -.ph-coat-hanger-light::before { - content: "\ef4b"; -} - -.ph-code-light::before { - content: "\ef4c"; -} - -.ph-code-simple-light::before { - content: "\ef4d"; -} - -.ph-codepen-logo-light::before { - content: "\ef4e"; -} - -.ph-codesandbox-logo-light::before { - content: "\ef4f"; -} - -.ph-coffee-light::before { - content: "\ef50"; -} - -.ph-coin-light::before { - content: "\ef51"; -} - -.ph-coin-vertical-light::before { - content: "\ef52"; -} - -.ph-coins-light::before { - content: "\ef53"; -} - -.ph-columns-light::before { - content: "\ef54"; -} - -.ph-command-light::before { - content: "\ef55"; -} - -.ph-compass-light::before { - content: "\ef56"; -} - -.ph-computer-tower-light::before { - content: "\ef57"; -} - -.ph-confetti-light::before { - content: "\ef58"; -} - -.ph-cookie-light::before { - content: "\ef59"; -} - -.ph-cooking-pot-light::before { - content: "\ef5a"; -} - -.ph-copy-light::before { - content: "\ef5b"; -} - -.ph-copy-simple-light::before { - content: "\ef5c"; -} - -.ph-copyleft-light::before { - content: "\ef5d"; -} - -.ph-copyright-light::before { - content: "\ef5e"; -} - -.ph-corners-in-light::before { - content: "\ef5f"; -} - -.ph-corners-out-light::before { - content: "\ef60"; -} - -.ph-cpu-light::before { - content: "\ef61"; -} - -.ph-credit-card-light::before { - content: "\ef62"; -} - -.ph-crop-light::before { - content: "\ef63"; -} - -.ph-crosshair-light::before { - content: "\ef64"; -} - -.ph-crosshair-simple-light::before { - content: "\ef65"; -} - -.ph-crown-light::before { - content: "\ef66"; -} - -.ph-crown-simple-light::before { - content: "\ef67"; -} - -.ph-cube-light::before { - content: "\ef68"; -} - -.ph-currency-btc-light::before { - content: "\ef69"; -} - -.ph-currency-circle-dollar-light::before { - content: "\ef6a"; -} - -.ph-currency-cny-light::before { - content: "\ef6b"; -} - -.ph-currency-dollar-light::before { - content: "\ef6c"; -} - -.ph-currency-dollar-simple-light::before { - content: "\ef6d"; -} - -.ph-currency-eth-light::before { - content: "\ef6e"; -} - -.ph-currency-eur-light::before { - content: "\ef6f"; -} - -.ph-currency-gbp-light::before { - content: "\ef70"; -} - -.ph-currency-inr-light::before { - content: "\ef71"; -} - -.ph-currency-jpy-light::before { - content: "\ef72"; -} - -.ph-currency-krw-light::before { - content: "\ef73"; -} - -.ph-currency-kzt-light::before { - content: "\ef74"; -} - -.ph-currency-ngn-light::before { - content: "\ef75"; -} - -.ph-currency-rub-light::before { - content: "\ef76"; -} - -.ph-cursor-light::before { - content: "\ef77"; -} - -.ph-cursor-text-light::before { - content: "\ef78"; -} - -.ph-cylinder-light::before { - content: "\ef79"; -} - -.ph-database-light::before { - content: "\ef7a"; -} - -.ph-desktop-light::before { - content: "\ef7b"; -} - -.ph-desktop-tower-light::before { - content: "\ef7c"; -} - -.ph-detective-light::before { - content: "\ef7d"; -} - -.ph-device-mobile-camera-light::before { - content: "\ef7e"; -} - -.ph-device-mobile-light::before { - content: "\ef7f"; -} - -.ph-device-mobile-speaker-light::before { - content: "\ef80"; -} - -.ph-device-tablet-camera-light::before { - content: "\ef81"; -} - -.ph-device-tablet-light::before { - content: "\ef82"; -} - -.ph-device-tablet-speaker-light::before { - content: "\ef83"; -} - -.ph-diamond-light::before { - content: "\ef84"; -} - -.ph-diamonds-four-light::before { - content: "\ef85"; -} - -.ph-dice-five-light::before { - content: "\ef86"; -} - -.ph-dice-four-light::before { - content: "\ef87"; -} - -.ph-dice-one-light::before { - content: "\ef88"; -} - -.ph-dice-six-light::before { - content: "\ef89"; -} - -.ph-dice-three-light::before { - content: "\ef8a"; -} - -.ph-dice-two-light::before { - content: "\ef8b"; -} - -.ph-disc-light::before { - content: "\ef8c"; -} - -.ph-discord-logo-light::before { - content: "\ef8d"; -} - -.ph-divide-light::before { - content: "\ef8e"; -} - -.ph-dog-light::before { - content: "\ef8f"; -} - -.ph-door-light::before { - content: "\ef90"; -} - -.ph-dots-nine-light::before { - content: "\ef91"; -} - -.ph-dots-six-light::before { - content: "\ef92"; -} - -.ph-dots-six-vertical-light::before { - content: "\ef93"; -} - -.ph-dots-three-circle-light::before { - content: "\ef94"; -} - -.ph-dots-three-circle-vertical-light::before { - content: "\ef95"; -} - -.ph-dots-three-light::before { - content: "\ef96"; -} - -.ph-dots-three-outline-light::before { - content: "\ef97"; -} - -.ph-dots-three-outline-vertical-light::before { - content: "\ef98"; -} - -.ph-dots-three-vertical-light::before { - content: "\ef99"; -} - -.ph-download-light::before { - content: "\ef9a"; -} - -.ph-download-simple-light::before { - content: "\ef9b"; -} - -.ph-dribbble-logo-light::before { - content: "\ef9c"; -} - -.ph-drop-half-bottom-light::before { - content: "\ef9d"; -} - -.ph-drop-half-light::before { - content: "\ef9e"; -} - -.ph-drop-light::before { - content: "\ef9f"; -} - -.ph-ear-light::before { - content: "\efa0"; -} - -.ph-ear-slash-light::before { - content: "\efa1"; -} - -.ph-egg-crack-light::before { - content: "\efa2"; -} - -.ph-egg-light::before { - content: "\efa3"; -} - -.ph-eject-light::before { - content: "\efa4"; -} - -.ph-eject-simple-light::before { - content: "\efa5"; -} - -.ph-envelope-light::before { - content: "\efa6"; -} - -.ph-envelope-open-light::before { - content: "\efa7"; -} - -.ph-envelope-simple-light::before { - content: "\efa8"; -} - -.ph-envelope-simple-open-light::before { - content: "\efa9"; -} - -.ph-equalizer-light::before { - content: "\efaa"; -} - -.ph-equals-light::before { - content: "\efab"; -} - -.ph-eraser-light::before { - content: "\efac"; -} - -.ph-exam-light::before { - content: "\efad"; -} - -.ph-export-light::before { - content: "\efae"; -} - -.ph-eye-closed-light::before { - content: "\efaf"; -} - -.ph-eye-light::before { - content: "\efb0"; -} - -.ph-eye-slash-light::before { - content: "\efb1"; -} - -.ph-eyedropper-light::before { - content: "\efb2"; -} - -.ph-eyedropper-sample-light::before { - content: "\efb3"; -} - -.ph-eyeglasses-light::before { - content: "\efb4"; -} - -.ph-face-mask-light::before { - content: "\efb5"; -} - -.ph-facebook-logo-light::before { - content: "\efb6"; -} - -.ph-factory-light::before { - content: "\efb7"; -} - -.ph-faders-horizontal-light::before { - content: "\efb8"; -} - -.ph-faders-light::before { - content: "\efb9"; -} - -.ph-fast-forward-circle-light::before { - content: "\efba"; -} - -.ph-fast-forward-light::before { - content: "\efbb"; -} - -.ph-figma-logo-light::before { - content: "\efbc"; -} - -.ph-file-arrow-down-light::before { - content: "\efbd"; -} - -.ph-file-arrow-up-light::before { - content: "\efbe"; -} - -.ph-file-audio-light::before { - content: "\efbf"; -} - -.ph-file-cloud-light::before { - content: "\efc0"; -} - -.ph-file-code-light::before { - content: "\efc1"; -} - -.ph-file-css-light::before { - content: "\efc2"; -} - -.ph-file-csv-light::before { - content: "\efc3"; -} - -.ph-file-doc-light::before { - content: "\efc4"; -} - -.ph-file-dotted-light::before { - content: "\efc5"; -} - -.ph-file-html-light::before { - content: "\efc6"; -} - -.ph-file-image-light::before { - content: "\efc7"; -} - -.ph-file-jpg-light::before { - content: "\efc8"; -} - -.ph-file-js-light::before { - content: "\efc9"; -} - -.ph-file-jsx-light::before { - content: "\efca"; -} - -.ph-file-light::before { - content: "\efcb"; -} - -.ph-file-lock-light::before { - content: "\efcc"; -} - -.ph-file-minus-light::before { - content: "\efcd"; -} - -.ph-file-pdf-light::before { - content: "\efce"; -} - -.ph-file-plus-light::before { - content: "\efcf"; -} - -.ph-file-png-light::before { - content: "\efd0"; -} - -.ph-file-ppt-light::before { - content: "\efd1"; -} - -.ph-file-rs-light::before { - content: "\efd2"; -} - -.ph-file-search-light::before { - content: "\efd3"; -} - -.ph-file-text-light::before { - content: "\efd4"; -} - -.ph-file-ts-light::before { - content: "\efd5"; -} - -.ph-file-tsx-light::before { - content: "\efd6"; -} - -.ph-file-video-light::before { - content: "\efd7"; -} - -.ph-file-vue-light::before { - content: "\efd8"; -} - -.ph-file-x-light::before { - content: "\efd9"; -} - -.ph-file-xls-light::before { - content: "\efda"; -} - -.ph-file-zip-light::before { - content: "\efdb"; -} - -.ph-files-light::before { - content: "\efdc"; -} - -.ph-film-script-light::before { - content: "\efdd"; -} - -.ph-film-slate-light::before { - content: "\efde"; -} - -.ph-film-strip-light::before { - content: "\efdf"; -} - -.ph-fingerprint-light::before { - content: "\efe0"; -} - -.ph-fingerprint-simple-light::before { - content: "\efe1"; -} - -.ph-finn-the-human-light::before { - content: "\efe2"; -} - -.ph-fire-light::before { - content: "\efe3"; -} - -.ph-fire-simple-light::before { - content: "\efe4"; -} - -.ph-first-aid-kit-light::before { - content: "\efe5"; -} - -.ph-first-aid-light::before { - content: "\efe6"; -} - -.ph-fish-light::before { - content: "\efe7"; -} - -.ph-fish-simple-light::before { - content: "\efe8"; -} - -.ph-flag-banner-light::before { - content: "\efe9"; -} - -.ph-flag-checkered-light::before { - content: "\efea"; -} - -.ph-flag-light::before { - content: "\efeb"; -} - -.ph-flame-light::before { - content: "\efec"; -} - -.ph-flashlight-light::before { - content: "\efed"; -} - -.ph-flask-light::before { - content: "\efee"; -} - -.ph-floppy-disk-back-light::before { - content: "\efef"; -} - -.ph-floppy-disk-light::before { - content: "\eff0"; -} - -.ph-flow-arrow-light::before { - content: "\eff1"; -} - -.ph-flower-light::before { - content: "\eff2"; -} - -.ph-flower-lotus-light::before { - content: "\eff3"; -} - -.ph-flying-saucer-light::before { - content: "\eff4"; -} - -.ph-folder-dotted-light::before { - content: "\eff5"; -} - -.ph-folder-light::before { - content: "\eff6"; -} - -.ph-folder-lock-light::before { - content: "\eff7"; -} - -.ph-folder-minus-light::before { - content: "\eff8"; -} - -.ph-folder-notch-light::before { - content: "\eff9"; -} - -.ph-folder-notch-minus-light::before { - content: "\effa"; -} - -.ph-folder-notch-open-light::before { - content: "\effb"; -} - -.ph-folder-notch-plus-light::before { - content: "\effc"; -} - -.ph-folder-open-light::before { - content: "\effd"; -} - -.ph-folder-plus-light::before { - content: "\effe"; -} - -.ph-folder-simple-dotted-light::before { - content: "\efff"; -} - -.ph-folder-simple-light::before { - content: "\f000"; -} - -.ph-folder-simple-lock-light::before { - content: "\f001"; -} - -.ph-folder-simple-minus-light::before { - content: "\f002"; -} - -.ph-folder-simple-plus-light::before { - content: "\f003"; -} - -.ph-folder-simple-star-light::before { - content: "\f004"; -} - -.ph-folder-simple-user-light::before { - content: "\f005"; -} - -.ph-folder-star-light::before { - content: "\f006"; -} - -.ph-folder-user-light::before { - content: "\f007"; -} - -.ph-folders-light::before { - content: "\f008"; -} - -.ph-football-light::before { - content: "\f009"; -} - -.ph-fork-knife-light::before { - content: "\f00a"; -} - -.ph-frame-corners-light::before { - content: "\f00b"; -} - -.ph-framer-logo-light::before { - content: "\f00c"; -} - -.ph-function-light::before { - content: "\f00d"; -} - -.ph-funnel-light::before { - content: "\f00e"; -} - -.ph-funnel-simple-light::before { - content: "\f00f"; -} - -.ph-game-controller-light::before { - content: "\f010"; -} - -.ph-gas-pump-light::before { - content: "\f011"; -} - -.ph-gauge-light::before { - content: "\f012"; -} - -.ph-gear-light::before { - content: "\f013"; -} - -.ph-gear-six-light::before { - content: "\f014"; -} - -.ph-gender-female-light::before { - content: "\f015"; -} - -.ph-gender-intersex-light::before { - content: "\f016"; -} - -.ph-gender-male-light::before { - content: "\f017"; -} - -.ph-gender-neuter-light::before { - content: "\f018"; -} - -.ph-gender-nonbinary-light::before { - content: "\f019"; -} - -.ph-gender-transgender-light::before { - content: "\f01a"; -} - -.ph-ghost-light::before { - content: "\f01b"; -} - -.ph-gif-light::before { - content: "\f01c"; -} - -.ph-gift-light::before { - content: "\f01d"; -} - -.ph-git-branch-light::before { - content: "\f01e"; -} - -.ph-git-commit-light::before { - content: "\f01f"; -} - -.ph-git-diff-light::before { - content: "\f020"; -} - -.ph-git-fork-light::before { - content: "\f021"; -} - -.ph-git-merge-light::before { - content: "\f022"; -} - -.ph-git-pull-request-light::before { - content: "\f023"; -} - -.ph-github-logo-light::before { - content: "\f024"; -} - -.ph-gitlab-logo-light::before { - content: "\f025"; -} - -.ph-gitlab-logo-simple-light::before { - content: "\f026"; -} - -.ph-globe-hemisphere-east-light::before { - content: "\f027"; -} - -.ph-globe-hemisphere-west-light::before { - content: "\f028"; -} - -.ph-globe-light::before { - content: "\f029"; -} - -.ph-globe-simple-light::before { - content: "\f02a"; -} - -.ph-globe-stand-light::before { - content: "\f02b"; -} - -.ph-google-chrome-logo-light::before { - content: "\f02c"; -} - -.ph-google-logo-light::before { - content: "\f02d"; -} - -.ph-google-photos-logo-light::before { - content: "\f02e"; -} - -.ph-google-play-logo-light::before { - content: "\f02f"; -} - -.ph-google-podcasts-logo-light::before { - content: "\f030"; -} - -.ph-gradient-light::before { - content: "\f031"; -} - -.ph-graduation-cap-light::before { - content: "\f032"; -} - -.ph-graph-light::before { - content: "\f033"; -} - -.ph-grid-four-light::before { - content: "\f034"; -} - -.ph-hamburger-light::before { - content: "\f035"; -} - -.ph-hand-eye-light::before { - content: "\f036"; -} - -.ph-hand-fist-light::before { - content: "\f037"; -} - -.ph-hand-grabbing-light::before { - content: "\f038"; -} - -.ph-hand-light::before { - content: "\f039"; -} - -.ph-hand-palm-light::before { - content: "\f03a"; -} - -.ph-hand-pointing-light::before { - content: "\f03b"; -} - -.ph-hand-soap-light::before { - content: "\f03c"; -} - -.ph-hand-waving-light::before { - content: "\f03d"; -} - -.ph-handbag-light::before { - content: "\f03e"; -} - -.ph-handbag-simple-light::before { - content: "\f03f"; -} - -.ph-hands-clapping-light::before { - content: "\f040"; -} - -.ph-handshake-light::before { - content: "\f041"; -} - -.ph-hard-drive-light::before { - content: "\f042"; -} - -.ph-hard-drives-light::before { - content: "\f043"; -} - -.ph-hash-light::before { - content: "\f044"; -} - -.ph-hash-straight-light::before { - content: "\f045"; -} - -.ph-headlights-light::before { - content: "\f046"; -} - -.ph-headphones-light::before { - content: "\f047"; -} - -.ph-headset-light::before { - content: "\f048"; -} - -.ph-heart-break-light::before { - content: "\f049"; -} - -.ph-heart-light::before { - content: "\f04a"; -} - -.ph-heart-straight-break-light::before { - content: "\f04b"; -} - -.ph-heart-straight-light::before { - content: "\f04c"; -} - -.ph-heartbeat-light::before { - content: "\f04d"; -} - -.ph-hexagon-light::before { - content: "\f04e"; -} - -.ph-highlighter-circle-light::before { - content: "\f04f"; -} - -.ph-horse-light::before { - content: "\f050"; -} - -.ph-hourglass-high-light::before { - content: "\f051"; -} - -.ph-hourglass-light::before { - content: "\f052"; -} - -.ph-hourglass-low-light::before { - content: "\f053"; -} - -.ph-hourglass-medium-light::before { - content: "\f054"; -} - -.ph-hourglass-simple-high-light::before { - content: "\f055"; -} - -.ph-hourglass-simple-light::before { - content: "\f056"; -} - -.ph-hourglass-simple-low-light::before { - content: "\f057"; -} - -.ph-hourglass-simple-medium-light::before { - content: "\f058"; -} - -.ph-house-light::before { - content: "\f059"; -} - -.ph-house-line-light::before { - content: "\f05a"; -} - -.ph-house-simple-light::before { - content: "\f05b"; -} - -.ph-identification-badge-light::before { - content: "\f05c"; -} - -.ph-identification-card-light::before { - content: "\f05d"; -} - -.ph-image-light::before { - content: "\f05e"; -} - -.ph-image-square-light::before { - content: "\f05f"; -} - -.ph-infinity-light::before { - content: "\f060"; -} - -.ph-info-light::before { - content: "\f061"; -} - -.ph-instagram-logo-light::before { - content: "\f062"; -} - -.ph-intersect-light::before { - content: "\f063"; -} - -.ph-jeep-light::before { - content: "\f064"; -} - -.ph-kanban-light::before { - content: "\f065"; -} - -.ph-key-light::before { - content: "\f066"; -} - -.ph-key-return-light::before { - content: "\f067"; -} - -.ph-keyboard-light::before { - content: "\f068"; -} - -.ph-keyhole-light::before { - content: "\f069"; -} - -.ph-knife-light::before { - content: "\f06a"; -} - -.ph-ladder-light::before { - content: "\f06b"; -} - -.ph-ladder-simple-light::before { - content: "\f06c"; -} - -.ph-lamp-light::before { - content: "\f06d"; -} - -.ph-laptop-light::before { - content: "\f06e"; -} - -.ph-layout-light::before { - content: "\f06f"; -} - -.ph-leaf-light::before { - content: "\f070"; -} - -.ph-lifebuoy-light::before { - content: "\f071"; -} - -.ph-lightbulb-filament-light::before { - content: "\f072"; -} - -.ph-lightbulb-light::before { - content: "\f073"; -} - -.ph-lightning-light::before { - content: "\f074"; -} - -.ph-lightning-slash-light::before { - content: "\f075"; -} - -.ph-line-segment-light::before { - content: "\f076"; -} - -.ph-line-segments-light::before { - content: "\f077"; -} - -.ph-link-break-light::before { - content: "\f078"; -} - -.ph-link-light::before { - content: "\f079"; -} - -.ph-link-simple-break-light::before { - content: "\f07a"; -} - -.ph-link-simple-horizontal-break-light::before { - content: "\f07b"; -} - -.ph-link-simple-horizontal-light::before { - content: "\f07c"; -} - -.ph-link-simple-light::before { - content: "\f07d"; -} - -.ph-linkedin-logo-light::before { - content: "\f07e"; -} - -.ph-linux-logo-light::before { - content: "\f07f"; -} - -.ph-list-bullets-light::before { - content: "\f080"; -} - -.ph-list-checks-light::before { - content: "\f081"; -} - -.ph-list-dashes-light::before { - content: "\f082"; -} - -.ph-list-light::before { - content: "\f083"; -} - -.ph-list-numbers-light::before { - content: "\f084"; -} - -.ph-list-plus-light::before { - content: "\f085"; -} - -.ph-lock-key-light::before { - content: "\f086"; -} - -.ph-lock-key-open-light::before { - content: "\f087"; -} - -.ph-lock-laminated-light::before { - content: "\f088"; -} - -.ph-lock-laminated-open-light::before { - content: "\f089"; -} - -.ph-lock-light::before { - content: "\f08a"; -} - -.ph-lock-open-light::before { - content: "\f08b"; -} - -.ph-lock-simple-light::before { - content: "\f08c"; -} - -.ph-lock-simple-open-light::before { - content: "\f08d"; -} - -.ph-magic-wand-light::before { - content: "\f08e"; -} - -.ph-magnet-light::before { - content: "\f08f"; -} - -.ph-magnet-straight-light::before { - content: "\f090"; -} - -.ph-magnifying-glass-light::before { - content: "\f091"; -} - -.ph-magnifying-glass-minus-light::before { - content: "\f092"; -} - -.ph-magnifying-glass-plus-light::before { - content: "\f093"; -} - -.ph-map-pin-light::before { - content: "\f094"; -} - -.ph-map-pin-line-light::before { - content: "\f095"; -} - -.ph-map-trifold-light::before { - content: "\f096"; -} - -.ph-marker-circle-light::before { - content: "\f097"; -} - -.ph-martini-light::before { - content: "\f098"; -} - -.ph-mask-happy-light::before { - content: "\f099"; -} - -.ph-mask-sad-light::before { - content: "\f09a"; -} - -.ph-math-operations-light::before { - content: "\f09b"; -} - -.ph-medal-light::before { - content: "\f09c"; -} - -.ph-medium-logo-light::before { - content: "\f09d"; -} - -.ph-megaphone-light::before { - content: "\f09e"; -} - -.ph-megaphone-simple-light::before { - content: "\f09f"; -} - -.ph-messenger-logo-light::before { - content: "\f0a0"; -} - -.ph-microphone-light::before { - content: "\f0a1"; -} - -.ph-microphone-slash-light::before { - content: "\f0a2"; -} - -.ph-microphone-stage-light::before { - content: "\f0a3"; -} - -.ph-microsoft-excel-logo-light::before { - content: "\f0a4"; -} - -.ph-microsoft-powerpoint-logo-light::before { - content: "\f0a5"; -} - -.ph-microsoft-teams-logo-light::before { - content: "\f0a6"; -} - -.ph-microsoft-word-logo-light::before { - content: "\f0a7"; -} - -.ph-minus-circle-light::before { - content: "\f0a8"; -} - -.ph-minus-light::before { - content: "\f0a9"; -} - -.ph-money-light::before { - content: "\f0aa"; -} - -.ph-monitor-light::before { - content: "\f0ab"; -} - -.ph-monitor-play-light::before { - content: "\f0ac"; -} - -.ph-moon-light::before { - content: "\f0ad"; -} - -.ph-moon-stars-light::before { - content: "\f0ae"; -} - -.ph-mountains-light::before { - content: "\f0af"; -} - -.ph-mouse-light::before { - content: "\f0b0"; -} - -.ph-mouse-simple-light::before { - content: "\f0b1"; -} - -.ph-music-note-light::before { - content: "\f0b2"; -} - -.ph-music-note-simple-light::before { - content: "\f0b3"; -} - -.ph-music-notes-light::before { - content: "\f0b4"; -} - -.ph-music-notes-plus-light::before { - content: "\f0b5"; -} - -.ph-music-notes-simple-light::before { - content: "\f0b6"; -} - -.ph-navigation-arrow-light::before { - content: "\f0b7"; -} - -.ph-needle-light::before { - content: "\f0b8"; -} - -.ph-newspaper-clipping-light::before { - content: "\f0b9"; -} - -.ph-newspaper-light::before { - content: "\f0ba"; -} - -.ph-note-blank-light::before { - content: "\f0bb"; -} - -.ph-note-light::before { - content: "\f0bc"; -} - -.ph-note-pencil-light::before { - content: "\f0bd"; -} - -.ph-notebook-light::before { - content: "\f0be"; -} - -.ph-notepad-light::before { - content: "\f0bf"; -} - -.ph-notification-light::before { - content: "\f0c0"; -} - -.ph-number-circle-eight-light::before { - content: "\f0c1"; -} - -.ph-number-circle-five-light::before { - content: "\f0c2"; -} - -.ph-number-circle-four-light::before { - content: "\f0c3"; -} - -.ph-number-circle-nine-light::before { - content: "\f0c4"; -} - -.ph-number-circle-one-light::before { - content: "\f0c5"; -} - -.ph-number-circle-seven-light::before { - content: "\f0c6"; -} - -.ph-number-circle-six-light::before { - content: "\f0c7"; -} - -.ph-number-circle-three-light::before { - content: "\f0c8"; -} - -.ph-number-circle-two-light::before { - content: "\f0c9"; -} - -.ph-number-circle-zero-light::before { - content: "\f0ca"; -} - -.ph-number-eight-light::before { - content: "\f0cb"; -} - -.ph-number-five-light::before { - content: "\f0cc"; -} - -.ph-number-four-light::before { - content: "\f0cd"; -} - -.ph-number-nine-light::before { - content: "\f0ce"; -} - -.ph-number-one-light::before { - content: "\f0cf"; -} - -.ph-number-seven-light::before { - content: "\f0d0"; -} - -.ph-number-six-light::before { - content: "\f0d1"; -} - -.ph-number-square-eight-light::before { - content: "\f0d2"; -} - -.ph-number-square-five-light::before { - content: "\f0d3"; -} - -.ph-number-square-four-light::before { - content: "\f0d4"; -} - -.ph-number-square-nine-light::before { - content: "\f0d5"; -} - -.ph-number-square-one-light::before { - content: "\f0d6"; -} - -.ph-number-square-seven-light::before { - content: "\f0d7"; -} - -.ph-number-square-six-light::before { - content: "\f0d8"; -} - -.ph-number-square-three-light::before { - content: "\f0d9"; -} - -.ph-number-square-two-light::before { - content: "\f0da"; -} - -.ph-number-square-zero-light::before { - content: "\f0db"; -} - -.ph-number-three-light::before { - content: "\f0dc"; -} - -.ph-number-two-light::before { - content: "\f0dd"; -} - -.ph-number-zero-light::before { - content: "\f0de"; -} - -.ph-nut-light::before { - content: "\f0df"; -} - -.ph-ny-times-logo-light::before { - content: "\f0e0"; -} - -.ph-octagon-light::before { - content: "\f0e1"; -} - -.ph-option-light::before { - content: "\f0e2"; -} - -.ph-package-light::before { - content: "\f0e3"; -} - -.ph-paint-brush-broad-light::before { - content: "\f0e4"; -} - -.ph-paint-brush-household-light::before { - content: "\f0e5"; -} - -.ph-paint-brush-light::before { - content: "\f0e6"; -} - -.ph-paint-bucket-light::before { - content: "\f0e7"; -} - -.ph-paint-roller-light::before { - content: "\f0e8"; -} - -.ph-palette-light::before { - content: "\f0e9"; -} - -.ph-paper-plane-light::before { - content: "\f0ea"; -} - -.ph-paper-plane-right-light::before { - content: "\f0eb"; -} - -.ph-paper-plane-tilt-light::before { - content: "\f0ec"; -} - -.ph-paperclip-horizontal-light::before { - content: "\f0ed"; -} - -.ph-paperclip-light::before { - content: "\f0ee"; -} - -.ph-parachute-light::before { - content: "\f0ef"; -} - -.ph-password-light::before { - content: "\f0f0"; -} - -.ph-path-light::before { - content: "\f0f1"; -} - -.ph-pause-circle-light::before { - content: "\f0f2"; -} - -.ph-pause-light::before { - content: "\f0f3"; -} - -.ph-paw-print-light::before { - content: "\f0f4"; -} - -.ph-peace-light::before { - content: "\f0f5"; -} - -.ph-pen-light::before { - content: "\f0f6"; -} - -.ph-pen-nib-light::before { - content: "\f0f7"; -} - -.ph-pen-nib-straight-light::before { - content: "\f0f8"; -} - -.ph-pencil-circle-light::before { - content: "\f0f9"; -} - -.ph-pencil-light::before { - content: "\f0fa"; -} - -.ph-pencil-line-light::before { - content: "\f0fb"; -} - -.ph-pencil-simple-light::before { - content: "\f0fc"; -} - -.ph-pencil-simple-line-light::before { - content: "\f0fd"; -} - -.ph-percent-light::before { - content: "\f0fe"; -} - -.ph-person-light::before { - content: "\f0ff"; -} - -.ph-person-simple-light::before { - content: "\f100"; -} - -.ph-person-simple-run-light::before { - content: "\f101"; -} - -.ph-person-simple-walk-light::before { - content: "\f102"; -} - -.ph-perspective-light::before { - content: "\f103"; -} - -.ph-phone-call-light::before { - content: "\f104"; -} - -.ph-phone-disconnect-light::before { - content: "\f105"; -} - -.ph-phone-incoming-light::before { - content: "\f106"; -} - -.ph-phone-light::before { - content: "\f107"; -} - -.ph-phone-outgoing-light::before { - content: "\f108"; -} - -.ph-phone-slash-light::before { - content: "\f109"; -} - -.ph-phone-x-light::before { - content: "\f10a"; -} - -.ph-phosphor-logo-light::before { - content: "\f10b"; -} - -.ph-piano-keys-light::before { - content: "\f10c"; -} - -.ph-picture-in-picture-light::before { - content: "\f10d"; -} - -.ph-pill-light::before { - content: "\f10e"; -} - -.ph-pinterest-logo-light::before { - content: "\f10f"; -} - -.ph-pinwheel-light::before { - content: "\f110"; -} - -.ph-pizza-light::before { - content: "\f111"; -} - -.ph-placeholder-light::before { - content: "\f112"; -} - -.ph-planet-light::before { - content: "\f113"; -} - -.ph-play-circle-light::before { - content: "\f114"; -} - -.ph-play-light::before { - content: "\f115"; -} - -.ph-playlist-light::before { - content: "\f116"; -} - -.ph-plug-light::before { - content: "\f117"; -} - -.ph-plugs-connected-light::before { - content: "\f118"; -} - -.ph-plugs-light::before { - content: "\f119"; -} - -.ph-plus-circle-light::before { - content: "\f11a"; -} - -.ph-plus-light::before { - content: "\f11b"; -} - -.ph-plus-minus-light::before { - content: "\f11c"; -} - -.ph-poker-chip-light::before { - content: "\f11d"; -} - -.ph-police-car-light::before { - content: "\f11e"; -} - -.ph-polygon-light::before { - content: "\f11f"; -} - -.ph-popcorn-light::before { - content: "\f120"; -} - -.ph-power-light::before { - content: "\f121"; -} - -.ph-prescription-light::before { - content: "\f122"; -} - -.ph-presentation-chart-light::before { - content: "\f123"; -} - -.ph-presentation-light::before { - content: "\f124"; -} - -.ph-printer-light::before { - content: "\f125"; -} - -.ph-prohibit-inset-light::before { - content: "\f126"; -} - -.ph-prohibit-light::before { - content: "\f127"; -} - -.ph-projector-screen-chart-light::before { - content: "\f128"; -} - -.ph-projector-screen-light::before { - content: "\f129"; -} - -.ph-push-pin-light::before { - content: "\f12a"; -} - -.ph-push-pin-simple-light::before { - content: "\f12b"; -} - -.ph-push-pin-simple-slash-light::before { - content: "\f12c"; -} - -.ph-push-pin-slash-light::before { - content: "\f12d"; -} - -.ph-puzzle-piece-light::before { - content: "\f12e"; -} - -.ph-qr-code-light::before { - content: "\f12f"; -} - -.ph-question-light::before { - content: "\f130"; -} - -.ph-queue-light::before { - content: "\f131"; -} - -.ph-quotes-light::before { - content: "\f132"; -} - -.ph-radical-light::before { - content: "\f133"; -} - -.ph-radio-button-light::before { - content: "\f134"; -} - -.ph-radio-light::before { - content: "\f135"; -} - -.ph-rainbow-cloud-light::before { - content: "\f136"; -} - -.ph-rainbow-light::before { - content: "\f137"; -} - -.ph-receipt-light::before { - content: "\f138"; -} - -.ph-record-light::before { - content: "\f139"; -} - -.ph-rectangle-light::before { - content: "\f13a"; -} - -.ph-recycle-light::before { - content: "\f13b"; -} - -.ph-reddit-logo-light::before { - content: "\f13c"; -} - -.ph-repeat-light::before { - content: "\f13d"; -} - -.ph-repeat-once-light::before { - content: "\f13e"; -} - -.ph-rewind-circle-light::before { - content: "\f13f"; -} - -.ph-rewind-light::before { - content: "\f140"; -} - -.ph-robot-light::before { - content: "\f141"; -} - -.ph-rocket-launch-light::before { - content: "\f142"; -} - -.ph-rocket-light::before { - content: "\f143"; -} - -.ph-rows-light::before { - content: "\f144"; -} - -.ph-rss-light::before { - content: "\f145"; -} - -.ph-rss-simple-light::before { - content: "\f146"; -} - -.ph-rug-light::before { - content: "\f147"; -} - -.ph-ruler-light::before { - content: "\f148"; -} - -.ph-scales-light::before { - content: "\f149"; -} - -.ph-scan-light::before { - content: "\f14a"; -} - -.ph-scissors-light::before { - content: "\f14b"; -} - -.ph-screencast-light::before { - content: "\f14c"; -} - -.ph-scribble-loop-light::before { - content: "\f14d"; -} - -.ph-scroll-light::before { - content: "\f14e"; -} - -.ph-selection-all-light::before { - content: "\f14f"; -} - -.ph-selection-background-light::before { - content: "\f150"; -} - -.ph-selection-foreground-light::before { - content: "\f151"; -} - -.ph-selection-inverse-light::before { - content: "\f152"; -} - -.ph-selection-light::before { - content: "\f153"; -} - -.ph-selection-plus-light::before { - content: "\f154"; -} - -.ph-selection-slash-light::before { - content: "\f155"; -} - -.ph-share-light::before { - content: "\f156"; -} - -.ph-share-network-light::before { - content: "\f157"; -} - -.ph-shield-check-light::before { - content: "\f158"; -} - -.ph-shield-checkered-light::before { - content: "\f159"; -} - -.ph-shield-chevron-light::before { - content: "\f15a"; -} - -.ph-shield-light::before { - content: "\f15b"; -} - -.ph-shield-plus-light::before { - content: "\f15c"; -} - -.ph-shield-slash-light::before { - content: "\f15d"; -} - -.ph-shield-star-light::before { - content: "\f15e"; -} - -.ph-shield-warning-light::before { - content: "\f15f"; -} - -.ph-shopping-bag-light::before { - content: "\f160"; -} - -.ph-shopping-bag-open-light::before { - content: "\f161"; -} - -.ph-shopping-cart-light::before { - content: "\f162"; -} - -.ph-shopping-cart-simple-light::before { - content: "\f163"; -} - -.ph-shower-light::before { - content: "\f164"; -} - -.ph-shuffle-angular-light::before { - content: "\f165"; -} - -.ph-shuffle-light::before { - content: "\f166"; -} - -.ph-shuffle-simple-light::before { - content: "\f167"; -} - -.ph-sidebar-light::before { - content: "\f168"; -} - -.ph-sidebar-simple-light::before { - content: "\f169"; -} - -.ph-sign-in-light::before { - content: "\f16a"; -} - -.ph-sign-out-light::before { - content: "\f16b"; -} - -.ph-signpost-light::before { - content: "\f16c"; -} - -.ph-sim-card-light::before { - content: "\f16d"; -} - -.ph-sketch-logo-light::before { - content: "\f16e"; -} - -.ph-skip-back-circle-light::before { - content: "\f16f"; -} - -.ph-skip-back-light::before { - content: "\f170"; -} - -.ph-skip-forward-circle-light::before { - content: "\f171"; -} - -.ph-skip-forward-light::before { - content: "\f172"; -} - -.ph-skull-light::before { - content: "\f173"; -} - -.ph-slack-logo-light::before { - content: "\f174"; -} - -.ph-sliders-horizontal-light::before { - content: "\f175"; -} - -.ph-sliders-light::before { - content: "\f176"; -} - -.ph-smiley-blank-light::before { - content: "\f177"; -} - -.ph-smiley-light::before { - content: "\f178"; -} - -.ph-smiley-meh-light::before { - content: "\f179"; -} - -.ph-smiley-nervous-light::before { - content: "\f17a"; -} - -.ph-smiley-sad-light::before { - content: "\f17b"; -} - -.ph-smiley-sticker-light::before { - content: "\f17c"; -} - -.ph-smiley-wink-light::before { - content: "\f17d"; -} - -.ph-smiley-x-eyes-light::before { - content: "\f17e"; -} - -.ph-snapchat-logo-light::before { - content: "\f17f"; -} - -.ph-snowflake-light::before { - content: "\f180"; -} - -.ph-soccer-ball-light::before { - content: "\f181"; -} - -.ph-sort-ascending-light::before { - content: "\f182"; -} - -.ph-sort-descending-light::before { - content: "\f183"; -} - -.ph-spade-light::before { - content: "\f184"; -} - -.ph-sparkle-light::before { - content: "\f185"; -} - -.ph-speaker-high-light::before { - content: "\f186"; -} - -.ph-speaker-low-light::before { - content: "\f187"; -} - -.ph-speaker-none-light::before { - content: "\f188"; -} - -.ph-speaker-simple-high-light::before { - content: "\f189"; -} - -.ph-speaker-simple-low-light::before { - content: "\f18a"; -} - -.ph-speaker-simple-none-light::before { - content: "\f18b"; -} - -.ph-speaker-simple-slash-light::before { - content: "\f18c"; -} - -.ph-speaker-simple-x-light::before { - content: "\f18d"; -} - -.ph-speaker-slash-light::before { - content: "\f18e"; -} - -.ph-speaker-x-light::before { - content: "\f18f"; -} - -.ph-spinner-gap-light::before { - content: "\f190"; -} - -.ph-spinner-light::before { - content: "\f191"; -} - -.ph-spiral-light::before { - content: "\f192"; -} - -.ph-spotify-logo-light::before { - content: "\f193"; -} - -.ph-square-half-bottom-light::before { - content: "\f194"; -} - -.ph-square-half-light::before { - content: "\f195"; -} - -.ph-square-light::before { - content: "\f196"; -} - -.ph-square-logo-light::before { - content: "\f197"; -} - -.ph-squares-four-light::before { - content: "\f198"; -} - -.ph-stack-light::before { - content: "\f199"; -} - -.ph-stack-overflow-logo-light::before { - content: "\f19a"; -} - -.ph-stack-simple-light::before { - content: "\f19b"; -} - -.ph-stamp-light::before { - content: "\f19c"; -} - -.ph-star-four-light::before { - content: "\f19d"; -} - -.ph-star-half-light::before { - content: "\f19e"; -} - -.ph-star-light::before { - content: "\f19f"; -} - -.ph-sticker-light::before { - content: "\f1a0"; -} - -.ph-stop-circle-light::before { - content: "\f1a1"; -} - -.ph-stop-light::before { - content: "\f1a2"; -} - -.ph-storefront-light::before { - content: "\f1a3"; -} - -.ph-strategy-light::before { - content: "\f1a4"; -} - -.ph-stripe-logo-light::before { - content: "\f1a5"; -} - -.ph-student-light::before { - content: "\f1a6"; -} - -.ph-suitcase-light::before { - content: "\f1a7"; -} - -.ph-suitcase-simple-light::before { - content: "\f1a8"; -} - -.ph-sun-dim-light::before { - content: "\f1a9"; -} - -.ph-sun-horizon-light::before { - content: "\f1aa"; -} - -.ph-sun-light::before { - content: "\f1ab"; -} - -.ph-sunglasses-light::before { - content: "\f1ac"; -} - -.ph-swap-light::before { - content: "\f1ad"; -} - -.ph-swatches-light::before { - content: "\f1ae"; -} - -.ph-sword-light::before { - content: "\f1af"; -} - -.ph-syringe-light::before { - content: "\f1b0"; -} - -.ph-t-shirt-light::before { - content: "\f1b1"; -} - -.ph-table-light::before { - content: "\f1b2"; -} - -.ph-tabs-light::before { - content: "\f1b3"; -} - -.ph-tag-chevron-light::before { - content: "\f1b4"; -} - -.ph-tag-light::before { - content: "\f1b5"; -} - -.ph-tag-simple-light::before { - content: "\f1b6"; -} - -.ph-target-light::before { - content: "\f1b7"; -} - -.ph-taxi-light::before { - content: "\f1b8"; -} - -.ph-telegram-logo-light::before { - content: "\f1b9"; -} - -.ph-television-light::before { - content: "\f1ba"; -} - -.ph-television-simple-light::before { - content: "\f1bb"; -} - -.ph-tennis-ball-light::before { - content: "\f1bc"; -} - -.ph-terminal-light::before { - content: "\f1bd"; -} - -.ph-terminal-window-light::before { - content: "\f1be"; -} - -.ph-test-tube-light::before { - content: "\f1bf"; -} - -.ph-text-aa-light::before { - content: "\f1c0"; -} - -.ph-text-align-center-light::before { - content: "\f1c1"; -} - -.ph-text-align-justify-light::before { - content: "\f1c2"; -} - -.ph-text-align-left-light::before { - content: "\f1c3"; -} - -.ph-text-align-right-light::before { - content: "\f1c4"; -} - -.ph-text-bolder-light::before { - content: "\f1c5"; -} - -.ph-text-h-five-light::before { - content: "\f1c6"; -} - -.ph-text-h-four-light::before { - content: "\f1c7"; -} - -.ph-text-h-light::before { - content: "\f1c8"; -} - -.ph-text-h-one-light::before { - content: "\f1c9"; -} - -.ph-text-h-six-light::before { - content: "\f1ca"; -} - -.ph-text-h-three-light::before { - content: "\f1cb"; -} - -.ph-text-h-two-light::before { - content: "\f1cc"; -} - -.ph-text-indent-light::before { - content: "\f1cd"; -} - -.ph-text-italic-light::before { - content: "\f1ce"; -} - -.ph-text-outdent-light::before { - content: "\f1cf"; -} - -.ph-text-strikethrough-light::before { - content: "\f1d0"; -} - -.ph-text-t-light::before { - content: "\f1d1"; -} - -.ph-text-underline-light::before { - content: "\f1d2"; -} - -.ph-textbox-light::before { - content: "\f1d3"; -} - -.ph-thermometer-cold-light::before { - content: "\f1d4"; -} - -.ph-thermometer-hot-light::before { - content: "\f1d5"; -} - -.ph-thermometer-light::before { - content: "\f1d6"; -} - -.ph-thermometer-simple-light::before { - content: "\f1d7"; -} - -.ph-thumbs-down-light::before { - content: "\f1d8"; -} - -.ph-thumbs-up-light::before { - content: "\f1d9"; -} - -.ph-ticket-light::before { - content: "\f1da"; -} - -.ph-tiktok-logo-light::before { - content: "\f1db"; -} - -.ph-timer-light::before { - content: "\f1dc"; -} - -.ph-toggle-left-light::before { - content: "\f1dd"; -} - -.ph-toggle-right-light::before { - content: "\f1de"; -} - -.ph-toilet-light::before { - content: "\f1df"; -} - -.ph-toilet-paper-light::before { - content: "\f1e0"; -} - -.ph-tote-light::before { - content: "\f1e1"; -} - -.ph-tote-simple-light::before { - content: "\f1e2"; -} - -.ph-trademark-registered-light::before { - content: "\f1e3"; -} - -.ph-traffic-cone-light::before { - content: "\f1e4"; -} - -.ph-traffic-sign-light::before { - content: "\f1e5"; -} - -.ph-traffic-signal-light::before { - content: "\f1e6"; -} - -.ph-train-light::before { - content: "\f1e7"; -} - -.ph-train-regional-light::before { - content: "\f1e8"; -} - -.ph-train-simple-light::before { - content: "\f1e9"; -} - -.ph-translate-light::before { - content: "\f1ea"; -} - -.ph-trash-light::before { - content: "\f1eb"; -} - -.ph-trash-simple-light::before { - content: "\f1ec"; -} - -.ph-tray-light::before { - content: "\f1ed"; -} - -.ph-tree-evergreen-light::before { - content: "\f1ee"; -} - -.ph-tree-light::before { - content: "\f1ef"; -} - -.ph-tree-structure-light::before { - content: "\f1f0"; -} - -.ph-trend-down-light::before { - content: "\f1f1"; -} - -.ph-trend-up-light::before { - content: "\f1f2"; -} - -.ph-triangle-light::before { - content: "\f1f3"; -} - -.ph-trophy-light::before { - content: "\f1f4"; -} - -.ph-truck-light::before { - content: "\f1f5"; -} - -.ph-twitch-logo-light::before { - content: "\f1f6"; -} - -.ph-twitter-logo-light::before { - content: "\f1f7"; -} - -.ph-umbrella-light::before { - content: "\f1f8"; -} - -.ph-umbrella-simple-light::before { - content: "\f1f9"; -} - -.ph-upload-light::before { - content: "\f1fa"; -} - -.ph-upload-simple-light::before { - content: "\f1fb"; -} - -.ph-user-circle-gear-light::before { - content: "\f1fc"; -} - -.ph-user-circle-light::before { - content: "\f1fd"; -} - -.ph-user-circle-minus-light::before { - content: "\f1fe"; -} - -.ph-user-circle-plus-light::before { - content: "\f1ff"; -} - -.ph-user-focus-light::before { - content: "\f200"; -} - -.ph-user-gear-light::before { - content: "\f201"; -} - -.ph-user-light::before { - content: "\f202"; -} - -.ph-user-list-light::before { - content: "\f203"; -} - -.ph-user-minus-light::before { - content: "\f204"; -} - -.ph-user-plus-light::before { - content: "\f205"; -} - -.ph-user-rectangle-light::before { - content: "\f206"; -} - -.ph-user-square-light::before { - content: "\f207"; -} - -.ph-user-switch-light::before { - content: "\f208"; -} - -.ph-users-four-light::before { - content: "\f209"; -} - -.ph-users-light::before { - content: "\f20a"; -} - -.ph-users-three-light::before { - content: "\f20b"; -} - -.ph-vault-light::before { - content: "\f20c"; -} - -.ph-vibrate-light::before { - content: "\f20d"; -} - -.ph-video-camera-light::before { - content: "\f20e"; -} - -.ph-video-camera-slash-light::before { - content: "\f20f"; -} - -.ph-vignette-light::before { - content: "\f210"; -} - -.ph-voicemail-light::before { - content: "\f211"; -} - -.ph-volleyball-light::before { - content: "\f212"; -} - -.ph-wall-light::before { - content: "\f213"; -} - -.ph-wallet-light::before { - content: "\f214"; -} - -.ph-warning-circle-light::before { - content: "\f215"; -} - -.ph-warning-light::before { - content: "\f216"; -} - -.ph-warning-octagon-light::before { - content: "\f217"; -} - -.ph-watch-light::before { - content: "\f218"; -} - -.ph-wave-sawtooth-light::before { - content: "\f219"; -} - -.ph-wave-sine-light::before { - content: "\f21a"; -} - -.ph-wave-square-light::before { - content: "\f21b"; -} - -.ph-wave-triangle-light::before { - content: "\f21c"; -} - -.ph-waves-light::before { - content: "\f21d"; -} - -.ph-webcam-light::before { - content: "\f21e"; -} - -.ph-whatsapp-logo-light::before { - content: "\f21f"; -} - -.ph-wheelchair-light::before { - content: "\f220"; -} - -.ph-wifi-high-light::before { - content: "\f221"; -} - -.ph-wifi-low-light::before { - content: "\f222"; -} - -.ph-wifi-medium-light::before { - content: "\f223"; -} - -.ph-wifi-none-light::before { - content: "\f224"; -} - -.ph-wifi-slash-light::before { - content: "\f225"; -} - -.ph-wifi-x-light::before { - content: "\f226"; -} - -.ph-wind-light::before { - content: "\f227"; -} - -.ph-windows-logo-light::before { - content: "\f228"; -} - -.ph-wine-light::before { - content: "\f229"; -} - -.ph-wrench-light::before { - content: "\f22a"; -} - -.ph-x-circle-light::before { - content: "\f22b"; -} - -.ph-x-light::before { - content: "\f22c"; -} - -.ph-x-square-light::before { - content: "\f22d"; -} - -.ph-yin-yang-light::before { - content: "\f22e"; -} - -.ph-youtube-logo-light::before { - content: "\f22f"; -} - -.ph-activity::before { - content: "\f230"; -} - -.ph-address-book::before { - content: "\f231"; -} - -.ph-airplane::before { - content: "\f232"; -} - -.ph-airplane-in-flight::before { - content: "\f233"; -} - -.ph-airplane-landing::before { - content: "\f234"; -} - -.ph-airplane-takeoff::before { - content: "\f235"; -} - -.ph-airplane-tilt::before { - content: "\f236"; -} - -.ph-airplay::before { - content: "\f237"; -} - -.ph-alarm::before { - content: "\f238"; -} - -.ph-alien::before { - content: "\f239"; -} - -.ph-align-bottom::before { - content: "\f23a"; -} - -.ph-align-bottom-simple::before { - content: "\f23b"; -} - -.ph-align-center-horizontal::before { - content: "\f23c"; -} - -.ph-align-center-horizontal-simple::before { - content: "\f23d"; -} - -.ph-align-center-vertical::before { - content: "\f23e"; -} - -.ph-align-center-vertical-simple::before { - content: "\f23f"; -} - -.ph-align-left::before { - content: "\f240"; -} - -.ph-align-left-simple::before { - content: "\f241"; -} - -.ph-align-right::before { - content: "\f242"; -} - -.ph-align-right-simple::before { - content: "\f243"; -} - -.ph-align-top::before { - content: "\f244"; -} - -.ph-align-top-simple::before { - content: "\f245"; -} - -.ph-anchor::before { - content: "\f246"; -} - -.ph-anchor-simple::before { - content: "\f247"; -} - -.ph-android-logo::before { - content: "\f248"; -} - -.ph-angular-logo::before { - content: "\f249"; -} - -.ph-aperture::before { - content: "\f24a"; -} - -.ph-app-store-logo::before { - content: "\f24b"; -} - -.ph-app-window::before { - content: "\f24c"; -} - -.ph-apple-logo::before { - content: "\f24d"; -} - -.ph-apple-podcasts-logo::before { - content: "\f24e"; -} - -.ph-archive::before { - content: "\f24f"; -} - -.ph-archive-box::before { - content: "\f250"; -} - -.ph-archive-tray::before { - content: "\f251"; -} - -.ph-armchair::before { - content: "\f252"; -} - -.ph-arrow-arc-left::before { - content: "\f253"; -} - -.ph-arrow-arc-right::before { - content: "\f254"; -} - -.ph-arrow-bend-double-up-left::before { - content: "\f255"; -} - -.ph-arrow-bend-double-up-right::before { - content: "\f256"; -} - -.ph-arrow-bend-down-left::before { - content: "\f257"; -} - -.ph-arrow-bend-down-right::before { - content: "\f258"; -} - -.ph-arrow-bend-left-down::before { - content: "\f259"; -} - -.ph-arrow-bend-left-up::before { - content: "\f25a"; -} - -.ph-arrow-bend-right-down::before { - content: "\f25b"; -} - -.ph-arrow-bend-right-up::before { - content: "\f25c"; -} - -.ph-arrow-bend-up-left::before { - content: "\f25d"; -} - -.ph-arrow-bend-up-right::before { - content: "\f25e"; -} - -.ph-arrow-circle-down::before { - content: "\f25f"; -} - -.ph-arrow-circle-down-left::before { - content: "\f260"; -} - -.ph-arrow-circle-down-right::before { - content: "\f261"; -} - -.ph-arrow-circle-left::before { - content: "\f262"; -} - -.ph-arrow-circle-right::before { - content: "\f263"; -} - -.ph-arrow-circle-up::before { - content: "\f264"; -} - -.ph-arrow-circle-up-left::before { - content: "\f265"; -} - -.ph-arrow-circle-up-right::before { - content: "\f266"; -} - -.ph-arrow-clockwise::before { - content: "\f267"; -} - -.ph-arrow-counter-clockwise::before { - content: "\f268"; -} - -.ph-arrow-down::before { - content: "\f269"; -} - -.ph-arrow-down-left::before { - content: "\f26a"; -} - -.ph-arrow-down-right::before { - content: "\f26b"; -} - -.ph-arrow-elbow-down-left::before { - content: "\f26c"; -} - -.ph-arrow-elbow-down-right::before { - content: "\f26d"; -} - -.ph-arrow-elbow-left::before { - content: "\f26e"; -} - -.ph-arrow-elbow-left-down::before { - content: "\f26f"; -} - -.ph-arrow-elbow-left-up::before { - content: "\f270"; -} - -.ph-arrow-elbow-right::before { - content: "\f271"; -} - -.ph-arrow-elbow-right-down::before { - content: "\f272"; -} - -.ph-arrow-elbow-right-up::before { - content: "\f273"; -} - -.ph-arrow-elbow-up-left::before { - content: "\f274"; -} - -.ph-arrow-elbow-up-right::before { - content: "\f275"; -} - -.ph-arrow-fat-down::before { - content: "\f276"; -} - -.ph-arrow-fat-left::before { - content: "\f277"; -} - -.ph-arrow-fat-line-down::before { - content: "\f278"; -} - -.ph-arrow-fat-line-left::before { - content: "\f279"; -} - -.ph-arrow-fat-line-right::before { - content: "\f27a"; -} - -.ph-arrow-fat-line-up::before { - content: "\f27b"; -} - -.ph-arrow-fat-lines-down::before { - content: "\f27c"; -} - -.ph-arrow-fat-lines-left::before { - content: "\f27d"; -} - -.ph-arrow-fat-lines-right::before { - content: "\f27e"; -} - -.ph-arrow-fat-lines-up::before { - content: "\f27f"; -} - -.ph-arrow-fat-right::before { - content: "\f280"; -} - -.ph-arrow-fat-up::before { - content: "\f281"; -} - -.ph-arrow-left::before { - content: "\f282"; -} - -.ph-arrow-line-down::before { - content: "\f283"; -} - -.ph-arrow-line-down-left::before { - content: "\f284"; -} - -.ph-arrow-line-down-right::before { - content: "\f285"; -} - -.ph-arrow-line-left::before { - content: "\f286"; -} - -.ph-arrow-line-right::before { - content: "\f287"; -} - -.ph-arrow-line-up::before { - content: "\f288"; -} - -.ph-arrow-line-up-left::before { - content: "\f289"; -} - -.ph-arrow-line-up-right::before { - content: "\f28a"; -} - -.ph-arrow-right::before { - content: "\f28b"; -} - -.ph-arrow-square-down::before { - content: "\f28c"; -} - -.ph-arrow-square-down-left::before { - content: "\f28d"; -} - -.ph-arrow-square-down-right::before { - content: "\f28e"; -} - -.ph-arrow-square-in::before { - content: "\f28f"; -} - -.ph-arrow-square-left::before { - content: "\f290"; -} - -.ph-arrow-square-out::before { - content: "\f291"; -} - -.ph-arrow-square-right::before { - content: "\f292"; -} - -.ph-arrow-square-up::before { - content: "\f293"; -} - -.ph-arrow-square-up-left::before { - content: "\f294"; -} - -.ph-arrow-square-up-right::before { - content: "\f295"; -} - -.ph-arrow-u-down-left::before { - content: "\f296"; -} - -.ph-arrow-u-down-right::before { - content: "\f297"; -} - -.ph-arrow-u-left-down::before { - content: "\f298"; -} - -.ph-arrow-u-left-up::before { - content: "\f299"; -} - -.ph-arrow-u-right-down::before { - content: "\f29a"; -} - -.ph-arrow-u-right-up::before { - content: "\f29b"; -} - -.ph-arrow-u-up-left::before { - content: "\f29c"; -} - -.ph-arrow-u-up-right::before { - content: "\f29d"; -} - -.ph-arrow-up::before { - content: "\f29e"; -} - -.ph-arrow-up-left::before { - content: "\f29f"; -} - -.ph-arrow-up-right::before { - content: "\f2a0"; -} - -.ph-arrows-clockwise::before { - content: "\f2a1"; -} - -.ph-arrows-counter-clockwise::before { - content: "\f2a2"; -} - -.ph-arrows-down-up::before { - content: "\f2a3"; -} - -.ph-arrows-horizontal::before { - content: "\f2a4"; -} - -.ph-arrows-in::before { - content: "\f2a5"; -} - -.ph-arrows-in-cardinal::before { - content: "\f2a6"; -} - -.ph-arrows-in-line-horizontal::before { - content: "\f2a7"; -} - -.ph-arrows-in-line-vertical::before { - content: "\f2a8"; -} - -.ph-arrows-in-simple::before { - content: "\f2a9"; -} - -.ph-arrows-left-right::before { - content: "\f2aa"; -} - -.ph-arrows-out::before { - content: "\f2ab"; -} - -.ph-arrows-out-cardinal::before { - content: "\f2ac"; -} - -.ph-arrows-out-line-horizontal::before { - content: "\f2ad"; -} - -.ph-arrows-out-line-vertical::before { - content: "\f2ae"; -} - -.ph-arrows-out-simple::before { - content: "\f2af"; -} - -.ph-arrows-vertical::before { - content: "\f2b0"; -} - -.ph-article::before { - content: "\f2b1"; -} - -.ph-article-medium::before { - content: "\f2b2"; -} - -.ph-article-ny-times::before { - content: "\f2b3"; -} - -.ph-asterisk::before { - content: "\f2b4"; -} - -.ph-asterisk-simple::before { - content: "\f2b5"; -} - -.ph-at::before { - content: "\f2b6"; -} - -.ph-atom::before { - content: "\f2b7"; -} - -.ph-baby::before { - content: "\f2b8"; -} - -.ph-backpack::before { - content: "\f2b9"; -} - -.ph-backspace::before { - content: "\f2ba"; -} - -.ph-bag::before { - content: "\f2bb"; -} - -.ph-bag-simple::before { - content: "\f2bc"; -} - -.ph-balloon::before { - content: "\f2bd"; -} - -.ph-bandaids::before { - content: "\f2be"; -} - -.ph-bank::before { - content: "\f2bf"; -} - -.ph-barbell::before { - content: "\f2c0"; -} - -.ph-barcode::before { - content: "\f2c1"; -} - -.ph-barricade::before { - content: "\f2c2"; -} - -.ph-baseball::before { - content: "\f2c3"; -} - -.ph-basketball::before { - content: "\f2c4"; -} - -.ph-bathtub::before { - content: "\f2c5"; -} - -.ph-battery-charging::before { - content: "\f2c6"; -} - -.ph-battery-charging-vertical::before { - content: "\f2c7"; -} - -.ph-battery-empty::before { - content: "\f2c8"; -} - -.ph-battery-full::before { - content: "\f2c9"; -} - -.ph-battery-high::before { - content: "\f2ca"; -} - -.ph-battery-low::before { - content: "\f2cb"; -} - -.ph-battery-medium::before { - content: "\f2cc"; -} - -.ph-battery-plus::before { - content: "\f2cd"; -} - -.ph-battery-warning::before { - content: "\f2ce"; -} - -.ph-battery-warning-vertical::before { - content: "\f2cf"; -} - -.ph-bed::before { - content: "\f2d0"; -} - -.ph-beer-bottle::before { - content: "\f2d1"; -} - -.ph-behance-logo::before { - content: "\f2d2"; -} - -.ph-bell::before { - content: "\f2d3"; -} - -.ph-bell-ringing::before { - content: "\f2d4"; -} - -.ph-bell-simple::before { - content: "\f2d5"; -} - -.ph-bell-simple-ringing::before { - content: "\f2d6"; -} - -.ph-bell-simple-slash::before { - content: "\f2d7"; -} - -.ph-bell-simple-z::before { - content: "\f2d8"; -} - -.ph-bell-slash::before { - content: "\f2d9"; -} - -.ph-bell-z::before { - content: "\f2da"; -} - -.ph-bezier-curve::before { - content: "\f2db"; -} - -.ph-bicycle::before { - content: "\f2dc"; -} - -.ph-binoculars::before { - content: "\f2dd"; -} - -.ph-bird::before { - content: "\f2de"; -} - -.ph-bluetooth::before { - content: "\f2df"; -} - -.ph-bluetooth-connected::before { - content: "\f2e0"; -} - -.ph-bluetooth-slash::before { - content: "\f2e1"; -} - -.ph-bluetooth-x::before { - content: "\f2e2"; -} - -.ph-boat::before { - content: "\f2e3"; -} - -.ph-book::before { - content: "\f2e4"; -} - -.ph-book-bookmark::before { - content: "\f2e5"; -} - -.ph-book-open::before { - content: "\f2e6"; -} - -.ph-bookmark::before { - content: "\f2e7"; -} - -.ph-bookmark-simple::before { - content: "\f2e8"; -} - -.ph-bookmarks::before { - content: "\f2e9"; -} - -.ph-bookmarks-simple::before { - content: "\f2ea"; -} - -.ph-books::before { - content: "\f2eb"; -} - -.ph-bounding-box::before { - content: "\f2ec"; -} - -.ph-brackets-angle::before { - content: "\f2ed"; -} - -.ph-brackets-curly::before { - content: "\f2ee"; -} - -.ph-brackets-round::before { - content: "\f2ef"; -} - -.ph-brackets-square::before { - content: "\f2f0"; -} - -.ph-brain::before { - content: "\f2f1"; -} - -.ph-brandy::before { - content: "\f2f2"; -} - -.ph-briefcase::before { - content: "\f2f3"; -} - -.ph-briefcase-metal::before { - content: "\f2f4"; -} - -.ph-broadcast::before { - content: "\f2f5"; -} - -.ph-browser::before { - content: "\f2f6"; -} - -.ph-browsers::before { - content: "\f2f7"; -} - -.ph-bug::before { - content: "\f2f8"; -} - -.ph-bug-beetle::before { - content: "\f2f9"; -} - -.ph-bug-droid::before { - content: "\f2fa"; -} - -.ph-buildings::before { - content: "\f2fb"; -} - -.ph-bus::before { - content: "\f2fc"; -} - -.ph-butterfly::before { - content: "\f2fd"; -} - -.ph-cactus::before { - content: "\f2fe"; -} - -.ph-cake::before { - content: "\f2ff"; -} - -.ph-calculator::before { - content: "\f300"; -} - -.ph-calendar::before { - content: "\f301"; -} - -.ph-calendar-blank::before { - content: "\f302"; -} - -.ph-calendar-check::before { - content: "\f303"; -} - -.ph-calendar-plus::before { - content: "\f304"; -} - -.ph-calendar-x::before { - content: "\f305"; -} - -.ph-camera::before { - content: "\f306"; -} - -.ph-camera-rotate::before { - content: "\f307"; -} - -.ph-camera-slash::before { - content: "\f308"; -} - -.ph-campfire::before { - content: "\f309"; -} - -.ph-car::before { - content: "\f30a"; -} - -.ph-car-simple::before { - content: "\f30b"; -} - -.ph-cardholder::before { - content: "\f30c"; -} - -.ph-cards::before { - content: "\f30d"; -} - -.ph-caret-circle-double-down::before { - content: "\f30e"; -} - -.ph-caret-circle-double-left::before { - content: "\f30f"; -} - -.ph-caret-circle-double-right::before { - content: "\f310"; -} - -.ph-caret-circle-double-up::before { - content: "\f311"; -} - -.ph-caret-circle-down::before { - content: "\f312"; -} - -.ph-caret-circle-left::before { - content: "\f313"; -} - -.ph-caret-circle-right::before { - content: "\f314"; -} - -.ph-caret-circle-up::before { - content: "\f315"; -} - -.ph-caret-double-down::before { - content: "\f316"; -} - -.ph-caret-double-left::before { - content: "\f317"; -} - -.ph-caret-double-right::before { - content: "\f318"; -} - -.ph-caret-double-up::before { - content: "\f319"; -} - -.ph-caret-down::before { - content: "\f31a"; -} - -.ph-caret-left::before { - content: "\f31b"; -} - -.ph-caret-right::before { - content: "\f31c"; -} - -.ph-caret-up::before { - content: "\f31d"; -} - -.ph-cat::before { - content: "\f31e"; -} - -.ph-cell-signal-full::before { - content: "\f31f"; -} - -.ph-cell-signal-high::before { - content: "\f320"; -} - -.ph-cell-signal-low::before { - content: "\f321"; -} - -.ph-cell-signal-medium::before { - content: "\f322"; -} - -.ph-cell-signal-none::before { - content: "\f323"; -} - -.ph-cell-signal-slash::before { - content: "\f324"; -} - -.ph-cell-signal-x::before { - content: "\f325"; -} - -.ph-chalkboard::before { - content: "\f326"; -} - -.ph-chalkboard-simple::before { - content: "\f327"; -} - -.ph-chalkboard-teacher::before { - content: "\f328"; -} - -.ph-chart-bar::before { - content: "\f329"; -} - -.ph-chart-bar-horizontal::before { - content: "\f32a"; -} - -.ph-chart-line::before { - content: "\f32b"; -} - -.ph-chart-line-up::before { - content: "\f32c"; -} - -.ph-chart-pie::before { - content: "\f32d"; -} - -.ph-chart-pie-slice::before { - content: "\f32e"; -} - -.ph-chat::before { - content: "\f32f"; -} - -.ph-chat-centered::before { - content: "\f330"; -} - -.ph-chat-centered-dots::before { - content: "\f331"; -} - -.ph-chat-centered-text::before { - content: "\f332"; -} - -.ph-chat-circle::before { - content: "\f333"; -} - -.ph-chat-circle-dots::before { - content: "\f334"; -} - -.ph-chat-circle-text::before { - content: "\f335"; -} - -.ph-chat-dots::before { - content: "\f336"; -} - -.ph-chat-teardrop::before { - content: "\f337"; -} - -.ph-chat-teardrop-dots::before { - content: "\f338"; -} - -.ph-chat-teardrop-text::before { - content: "\f339"; -} - -.ph-chat-text::before { - content: "\f33a"; -} - -.ph-chats::before { - content: "\f33b"; -} - -.ph-chats-circle::before { - content: "\f33c"; -} - -.ph-chats-teardrop::before { - content: "\f33d"; -} - -.ph-check::before { - content: "\f33e"; -} - -.ph-check-circle::before { - content: "\f33f"; -} - -.ph-check-square::before { - content: "\f340"; -} - -.ph-check-square-offset::before { - content: "\f341"; -} - -.ph-checks::before { - content: "\f342"; -} - -.ph-circle::before { - content: "\f343"; -} - -.ph-circle-dashed::before { - content: "\f344"; -} - -.ph-circle-half::before { - content: "\f345"; -} - -.ph-circle-half-tilt::before { - content: "\f346"; -} - -.ph-circle-notch::before { - content: "\f347"; -} - -.ph-circle-wavy::before { - content: "\f348"; -} - -.ph-circle-wavy-check::before { - content: "\f349"; -} - -.ph-circle-wavy-question::before { - content: "\f34a"; -} - -.ph-circle-wavy-warning::before { - content: "\f34b"; -} - -.ph-circles-four::before { - content: "\f34c"; -} - -.ph-circles-three::before { - content: "\f34d"; -} - -.ph-circles-three-plus::before { - content: "\f34e"; -} - -.ph-clipboard::before { - content: "\f34f"; -} - -.ph-clipboard-text::before { - content: "\f350"; -} - -.ph-clock::before { - content: "\f351"; -} - -.ph-clock-afternoon::before { - content: "\f352"; -} - -.ph-clock-clockwise::before { - content: "\f353"; -} - -.ph-clock-counter-clockwise::before { - content: "\f354"; -} - -.ph-closed-captioning::before { - content: "\f355"; -} - -.ph-cloud::before { - content: "\f356"; -} - -.ph-cloud-arrow-down::before { - content: "\f357"; -} - -.ph-cloud-arrow-up::before { - content: "\f358"; -} - -.ph-cloud-check::before { - content: "\f359"; -} - -.ph-cloud-fog::before { - content: "\f35a"; -} - -.ph-cloud-lightning::before { - content: "\f35b"; -} - -.ph-cloud-moon::before { - content: "\f35c"; -} - -.ph-cloud-rain::before { - content: "\f35d"; -} - -.ph-cloud-slash::before { - content: "\f35e"; -} - -.ph-cloud-snow::before { - content: "\f35f"; -} - -.ph-cloud-sun::before { - content: "\f360"; -} - -.ph-club::before { - content: "\f361"; -} - -.ph-coat-hanger::before { - content: "\f362"; -} - -.ph-code::before { - content: "\f363"; -} - -.ph-code-simple::before { - content: "\f364"; -} - -.ph-codepen-logo::before { - content: "\f365"; -} - -.ph-codesandbox-logo::before { - content: "\f366"; -} - -.ph-coffee::before { - content: "\f367"; -} - -.ph-coin::before { - content: "\f368"; -} - -.ph-coin-vertical::before { - content: "\f369"; -} - -.ph-coins::before { - content: "\f36a"; -} - -.ph-columns::before { - content: "\f36b"; -} - -.ph-command::before { - content: "\f36c"; -} - -.ph-compass::before { - content: "\f36d"; -} - -.ph-computer-tower::before { - content: "\f36e"; -} - -.ph-confetti::before { - content: "\f36f"; -} - -.ph-cookie::before { - content: "\f370"; -} - -.ph-cooking-pot::before { - content: "\f371"; -} - -.ph-copy::before { - content: "\f372"; -} - -.ph-copy-simple::before { - content: "\f373"; -} - -.ph-copyleft::before { - content: "\f374"; -} - -.ph-copyright::before { - content: "\f375"; -} - -.ph-corners-in::before { - content: "\f376"; -} - -.ph-corners-out::before { - content: "\f377"; -} - -.ph-cpu::before { - content: "\f378"; -} - -.ph-credit-card::before { - content: "\f379"; -} - -.ph-crop::before { - content: "\f37a"; -} - -.ph-crosshair::before { - content: "\f37b"; -} - -.ph-crosshair-simple::before { - content: "\f37c"; -} - -.ph-crown::before { - content: "\f37d"; -} - -.ph-crown-simple::before { - content: "\f37e"; -} - -.ph-cube::before { - content: "\f37f"; -} - -.ph-currency-btc::before { - content: "\f380"; -} - -.ph-currency-circle-dollar::before { - content: "\f381"; -} - -.ph-currency-cny::before { - content: "\f382"; -} - -.ph-currency-dollar::before { - content: "\f383"; -} - -.ph-currency-dollar-simple::before { - content: "\f384"; -} - -.ph-currency-eth::before { - content: "\f385"; -} - -.ph-currency-eur::before { - content: "\f386"; -} - -.ph-currency-gbp::before { - content: "\f387"; -} - -.ph-currency-inr::before { - content: "\f388"; -} - -.ph-currency-jpy::before { - content: "\f389"; -} - -.ph-currency-krw::before { - content: "\f38a"; -} - -.ph-currency-kzt::before { - content: "\f38b"; -} - -.ph-currency-ngn::before { - content: "\f38c"; -} - -.ph-currency-rub::before { - content: "\f38d"; -} - -.ph-cursor::before { - content: "\f38e"; -} - -.ph-cursor-text::before { - content: "\f38f"; -} - -.ph-cylinder::before { - content: "\f390"; -} - -.ph-database::before { - content: "\f391"; -} - -.ph-desktop::before { - content: "\f392"; -} - -.ph-desktop-tower::before { - content: "\f393"; -} - -.ph-detective::before { - content: "\f394"; -} - -.ph-device-mobile::before { - content: "\f395"; -} - -.ph-device-mobile-camera::before { - content: "\f396"; -} - -.ph-device-mobile-speaker::before { - content: "\f397"; -} - -.ph-device-tablet::before { - content: "\f398"; -} - -.ph-device-tablet-camera::before { - content: "\f399"; -} - -.ph-device-tablet-speaker::before { - content: "\f39a"; -} - -.ph-diamond::before { - content: "\f39b"; -} - -.ph-diamonds-four::before { - content: "\f39c"; -} - -.ph-dice-five::before { - content: "\f39d"; -} - -.ph-dice-four::before { - content: "\f39e"; -} - -.ph-dice-one::before { - content: "\f39f"; -} - -.ph-dice-six::before { - content: "\f3a0"; -} - -.ph-dice-three::before { - content: "\f3a1"; -} - -.ph-dice-two::before { - content: "\f3a2"; -} - -.ph-disc::before { - content: "\f3a3"; -} - -.ph-discord-logo::before { - content: "\f3a4"; -} - -.ph-divide::before { - content: "\f3a5"; -} - -.ph-dog::before { - content: "\f3a6"; -} - -.ph-door::before { - content: "\f3a7"; -} - -.ph-dots-nine::before { - content: "\f3a8"; -} - -.ph-dots-six::before { - content: "\f3a9"; -} - -.ph-dots-six-vertical::before { - content: "\f3aa"; -} - -.ph-dots-three::before { - content: "\f3ab"; -} - -.ph-dots-three-circle::before { - content: "\f3ac"; -} - -.ph-dots-three-circle-vertical::before { - content: "\f3ad"; -} - -.ph-dots-three-outline::before { - content: "\f3ae"; -} - -.ph-dots-three-outline-vertical::before { - content: "\f3af"; -} - -.ph-dots-three-vertical::before { - content: "\f3b0"; -} - -.ph-download::before { - content: "\f3b1"; -} - -.ph-download-simple::before { - content: "\f3b2"; -} - -.ph-dribbble-logo::before { - content: "\f3b3"; -} - -.ph-drop::before { - content: "\f3b4"; -} - -.ph-drop-half::before { - content: "\f3b5"; -} - -.ph-drop-half-bottom::before { - content: "\f3b6"; -} - -.ph-ear::before { - content: "\f3b7"; -} - -.ph-ear-slash::before { - content: "\f3b8"; -} - -.ph-egg::before { - content: "\f3b9"; -} - -.ph-egg-crack::before { - content: "\f3ba"; -} - -.ph-eject::before { - content: "\f3bb"; -} - -.ph-eject-simple::before { - content: "\f3bc"; -} - -.ph-envelope::before { - content: "\f3bd"; -} - -.ph-envelope-open::before { - content: "\f3be"; -} - -.ph-envelope-simple::before { - content: "\f3bf"; -} - -.ph-envelope-simple-open::before { - content: "\f3c0"; -} - -.ph-equalizer::before { - content: "\f3c1"; -} - -.ph-equals::before { - content: "\f3c2"; -} - -.ph-eraser::before { - content: "\f3c3"; -} - -.ph-exam::before { - content: "\f3c4"; -} - -.ph-export::before { - content: "\f3c5"; -} - -.ph-eye::before { - content: "\f3c6"; -} - -.ph-eye-closed::before { - content: "\f3c7"; -} - -.ph-eye-slash::before { - content: "\f3c8"; -} - -.ph-eyedropper::before { - content: "\f3c9"; -} - -.ph-eyedropper-sample::before { - content: "\f3ca"; -} - -.ph-eyeglasses::before { - content: "\f3cb"; -} - -.ph-face-mask::before { - content: "\f3cc"; -} - -.ph-facebook-logo::before { - content: "\f3cd"; -} - -.ph-factory::before { - content: "\f3ce"; -} - -.ph-faders::before { - content: "\f3cf"; -} - -.ph-faders-horizontal::before { - content: "\f3d0"; -} - -.ph-fast-forward::before { - content: "\f3d1"; -} - -.ph-fast-forward-circle::before { - content: "\f3d2"; -} - -.ph-figma-logo::before { - content: "\f3d3"; -} - -.ph-file::before { - content: "\f3d4"; -} - -.ph-file-arrow-down::before { - content: "\f3d5"; -} - -.ph-file-arrow-up::before { - content: "\f3d6"; -} - -.ph-file-audio::before { - content: "\f3d7"; -} - -.ph-file-cloud::before { - content: "\f3d8"; -} - -.ph-file-code::before { - content: "\f3d9"; -} - -.ph-file-css::before { - content: "\f3da"; -} - -.ph-file-csv::before { - content: "\f3db"; -} - -.ph-file-doc::before { - content: "\f3dc"; -} - -.ph-file-dotted::before { - content: "\f3dd"; -} - -.ph-file-html::before { - content: "\f3de"; -} - -.ph-file-image::before { - content: "\f3df"; -} - -.ph-file-jpg::before { - content: "\f3e0"; -} - -.ph-file-js::before { - content: "\f3e1"; -} - -.ph-file-jsx::before { - content: "\f3e2"; -} - -.ph-file-lock::before { - content: "\f3e3"; -} - -.ph-file-minus::before { - content: "\f3e4"; -} - -.ph-file-pdf::before { - content: "\f3e5"; -} - -.ph-file-plus::before { - content: "\f3e6"; -} - -.ph-file-png::before { - content: "\f3e7"; -} - -.ph-file-ppt::before { - content: "\f3e8"; -} - -.ph-file-rs::before { - content: "\f3e9"; -} - -.ph-file-search::before { - content: "\f3ea"; -} - -.ph-file-text::before { - content: "\f3eb"; -} - -.ph-file-ts::before { - content: "\f3ec"; -} - -.ph-file-tsx::before { - content: "\f3ed"; -} - -.ph-file-video::before { - content: "\f3ee"; -} - -.ph-file-vue::before { - content: "\f3ef"; -} - -.ph-file-x::before { - content: "\f3f0"; -} - -.ph-file-xls::before { - content: "\f3f1"; -} - -.ph-file-zip::before { - content: "\f3f2"; -} - -.ph-files::before { - content: "\f3f3"; -} - -.ph-film-script::before { - content: "\f3f4"; -} - -.ph-film-slate::before { - content: "\f3f5"; -} - -.ph-film-strip::before { - content: "\f3f6"; -} - -.ph-fingerprint::before { - content: "\f3f7"; -} - -.ph-fingerprint-simple::before { - content: "\f3f8"; -} - -.ph-finn-the-human::before { - content: "\f3f9"; -} - -.ph-fire::before { - content: "\f3fa"; -} - -.ph-fire-simple::before { - content: "\f3fb"; -} - -.ph-first-aid::before { - content: "\f3fc"; -} - -.ph-first-aid-kit::before { - content: "\f3fd"; -} - -.ph-fish::before { - content: "\f3fe"; -} - -.ph-fish-simple::before { - content: "\f3ff"; -} - -.ph-flag::before { - content: "\f400"; -} - -.ph-flag-banner::before { - content: "\f401"; -} - -.ph-flag-checkered::before { - content: "\f402"; -} - -.ph-flame::before { - content: "\f403"; -} - -.ph-flashlight::before { - content: "\f404"; -} - -.ph-flask::before { - content: "\f405"; -} - -.ph-floppy-disk::before { - content: "\f406"; -} - -.ph-floppy-disk-back::before { - content: "\f407"; -} - -.ph-flow-arrow::before { - content: "\f408"; -} - -.ph-flower::before { - content: "\f409"; -} - -.ph-flower-lotus::before { - content: "\f40a"; -} - -.ph-flying-saucer::before { - content: "\f40b"; -} - -.ph-folder::before { - content: "\f40c"; -} - -.ph-folder-dotted::before { - content: "\f40d"; -} - -.ph-folder-lock::before { - content: "\f40e"; -} - -.ph-folder-minus::before { - content: "\f40f"; -} - -.ph-folder-notch::before { - content: "\f410"; -} - -.ph-folder-notch-minus::before { - content: "\f411"; -} - -.ph-folder-notch-open::before { - content: "\f412"; -} - -.ph-folder-notch-plus::before { - content: "\f413"; -} - -.ph-folder-open::before { - content: "\f414"; -} - -.ph-folder-plus::before { - content: "\f415"; -} - -.ph-folder-simple::before { - content: "\f416"; -} - -.ph-folder-simple-dotted::before { - content: "\f417"; -} - -.ph-folder-simple-lock::before { - content: "\f418"; -} - -.ph-folder-simple-minus::before { - content: "\f419"; -} - -.ph-folder-simple-plus::before { - content: "\f41a"; -} - -.ph-folder-simple-star::before { - content: "\f41b"; -} - -.ph-folder-simple-user::before { - content: "\f41c"; -} - -.ph-folder-star::before { - content: "\f41d"; -} - -.ph-folder-user::before { - content: "\f41e"; -} - -.ph-folders::before { - content: "\f41f"; -} - -.ph-football::before { - content: "\f420"; -} - -.ph-fork-knife::before { - content: "\f421"; -} - -.ph-frame-corners::before { - content: "\f422"; -} - -.ph-framer-logo::before { - content: "\f423"; -} - -.ph-function::before { - content: "\f424"; -} - -.ph-funnel::before { - content: "\f425"; -} - -.ph-funnel-simple::before { - content: "\f426"; -} - -.ph-game-controller::before { - content: "\f427"; -} - -.ph-gas-pump::before { - content: "\f428"; -} - -.ph-gauge::before { - content: "\f429"; -} - -.ph-gear::before { - content: "\f42a"; -} - -.ph-gear-six::before { - content: "\f42b"; -} - -.ph-gender-female::before { - content: "\f42c"; -} - -.ph-gender-intersex::before { - content: "\f42d"; -} - -.ph-gender-male::before { - content: "\f42e"; -} - -.ph-gender-neuter::before { - content: "\f42f"; -} - -.ph-gender-nonbinary::before { - content: "\f430"; -} - -.ph-gender-transgender::before { - content: "\f431"; -} - -.ph-ghost::before { - content: "\f432"; -} - -.ph-gif::before { - content: "\f433"; -} - -.ph-gift::before { - content: "\f434"; -} - -.ph-git-branch::before { - content: "\f435"; -} - -.ph-git-commit::before { - content: "\f436"; -} - -.ph-git-diff::before { - content: "\f437"; -} - -.ph-git-fork::before { - content: "\f438"; -} - -.ph-git-merge::before { - content: "\f439"; -} - -.ph-git-pull-request::before { - content: "\f43a"; -} - -.ph-github-logo::before { - content: "\f43b"; -} - -.ph-gitlab-logo::before { - content: "\f43c"; -} - -.ph-gitlab-logo-simple::before { - content: "\f43d"; -} - -.ph-globe::before { - content: "\f43e"; -} - -.ph-globe-hemisphere-east::before { - content: "\f43f"; -} - -.ph-globe-hemisphere-west::before { - content: "\f440"; -} - -.ph-globe-simple::before { - content: "\f441"; -} - -.ph-globe-stand::before { - content: "\f442"; -} - -.ph-google-chrome-logo::before { - content: "\f443"; -} - -.ph-google-logo::before { - content: "\f444"; -} - -.ph-google-photos-logo::before { - content: "\f445"; -} - -.ph-google-play-logo::before { - content: "\f446"; -} - -.ph-google-podcasts-logo::before { - content: "\f447"; -} - -.ph-gradient::before { - content: "\f448"; -} - -.ph-graduation-cap::before { - content: "\f449"; -} - -.ph-graph::before { - content: "\f44a"; -} - -.ph-grid-four::before { - content: "\f44b"; -} - -.ph-hamburger::before { - content: "\f44c"; -} - -.ph-hand::before { - content: "\f44d"; -} - -.ph-hand-eye::before { - content: "\f44e"; -} - -.ph-hand-fist::before { - content: "\f44f"; -} - -.ph-hand-grabbing::before { - content: "\f450"; -} - -.ph-hand-palm::before { - content: "\f451"; -} - -.ph-hand-pointing::before { - content: "\f452"; -} - -.ph-hand-soap::before { - content: "\f453"; -} - -.ph-hand-waving::before { - content: "\f454"; -} - -.ph-handbag::before { - content: "\f455"; -} - -.ph-handbag-simple::before { - content: "\f456"; -} - -.ph-hands-clapping::before { - content: "\f457"; -} - -.ph-handshake::before { - content: "\f458"; -} - -.ph-hard-drive::before { - content: "\f459"; -} - -.ph-hard-drives::before { - content: "\f45a"; -} - -.ph-hash::before { - content: "\f45b"; -} - -.ph-hash-straight::before { - content: "\f45c"; -} - -.ph-headlights::before { - content: "\f45d"; -} - -.ph-headphones::before { - content: "\f45e"; -} - -.ph-headset::before { - content: "\f45f"; -} - -.ph-heart::before { - content: "\f460"; -} - -.ph-heart-break::before { - content: "\f461"; -} - -.ph-heart-straight::before { - content: "\f462"; -} - -.ph-heart-straight-break::before { - content: "\f463"; -} - -.ph-heartbeat::before { - content: "\f464"; -} - -.ph-hexagon::before { - content: "\f465"; -} - -.ph-highlighter-circle::before { - content: "\f466"; -} - -.ph-horse::before { - content: "\f467"; -} - -.ph-hourglass::before { - content: "\f468"; -} - -.ph-hourglass-high::before { - content: "\f469"; -} - -.ph-hourglass-low::before { - content: "\f46a"; -} - -.ph-hourglass-medium::before { - content: "\f46b"; -} - -.ph-hourglass-simple::before { - content: "\f46c"; -} - -.ph-hourglass-simple-high::before { - content: "\f46d"; -} - -.ph-hourglass-simple-low::before { - content: "\f46e"; -} - -.ph-hourglass-simple-medium::before { - content: "\f46f"; -} - -.ph-house::before { - content: "\f470"; -} - -.ph-house-line::before { - content: "\f471"; -} - -.ph-house-simple::before { - content: "\f472"; -} - -.ph-identification-badge::before { - content: "\f473"; -} - -.ph-identification-card::before { - content: "\f474"; -} - -.ph-image::before { - content: "\f475"; -} - -.ph-image-square::before { - content: "\f476"; -} - -.ph-infinity::before { - content: "\f477"; -} - -.ph-info::before { - content: "\f478"; -} - -.ph-instagram-logo::before { - content: "\f479"; -} - -.ph-intersect::before { - content: "\f47a"; -} - -.ph-jeep::before { - content: "\f47b"; -} - -.ph-kanban::before { - content: "\f47c"; -} - -.ph-key::before { - content: "\f47d"; -} - -.ph-key-return::before { - content: "\f47e"; -} - -.ph-keyboard::before { - content: "\f47f"; -} - -.ph-keyhole::before { - content: "\f480"; -} - -.ph-knife::before { - content: "\f481"; -} - -.ph-ladder::before { - content: "\f482"; -} - -.ph-ladder-simple::before { - content: "\f483"; -} - -.ph-lamp::before { - content: "\f484"; -} - -.ph-laptop::before { - content: "\f485"; -} - -.ph-layout::before { - content: "\f486"; -} - -.ph-leaf::before { - content: "\f487"; -} - -.ph-lifebuoy::before { - content: "\f488"; -} - -.ph-lightbulb::before { - content: "\f489"; -} - -.ph-lightbulb-filament::before { - content: "\f48a"; -} - -.ph-lightning::before { - content: "\f48b"; -} - -.ph-lightning-slash::before { - content: "\f48c"; -} - -.ph-line-segment::before { - content: "\f48d"; -} - -.ph-line-segments::before { - content: "\f48e"; -} - -.ph-link::before { - content: "\f48f"; -} - -.ph-link-break::before { - content: "\f490"; -} - -.ph-link-simple::before { - content: "\f491"; -} - -.ph-link-simple-break::before { - content: "\f492"; -} - -.ph-link-simple-horizontal::before { - content: "\f493"; -} - -.ph-link-simple-horizontal-break::before { - content: "\f494"; -} - -.ph-linkedin-logo::before { - content: "\f495"; -} - -.ph-linux-logo::before { - content: "\f496"; -} - -.ph-list::before { - content: "\f497"; -} - -.ph-list-bullets::before { - content: "\f498"; -} - -.ph-list-checks::before { - content: "\f499"; -} - -.ph-list-dashes::before { - content: "\f49a"; -} - -.ph-list-numbers::before { - content: "\f49b"; -} - -.ph-list-plus::before { - content: "\f49c"; -} - -.ph-lock::before { - content: "\f49d"; -} - -.ph-lock-key::before { - content: "\f49e"; -} - -.ph-lock-key-open::before { - content: "\f49f"; -} - -.ph-lock-laminated::before { - content: "\f4a0"; -} - -.ph-lock-laminated-open::before { - content: "\f4a1"; -} - -.ph-lock-open::before { - content: "\f4a2"; -} - -.ph-lock-simple::before { - content: "\f4a3"; -} - -.ph-lock-simple-open::before { - content: "\f4a4"; -} - -.ph-magic-wand::before { - content: "\f4a5"; -} - -.ph-magnet::before { - content: "\f4a6"; -} - -.ph-magnet-straight::before { - content: "\f4a7"; -} - -.ph-magnifying-glass::before { - content: "\f4a8"; -} - -.ph-magnifying-glass-minus::before { - content: "\f4a9"; -} - -.ph-magnifying-glass-plus::before { - content: "\f4aa"; -} - -.ph-map-pin::before { - content: "\f4ab"; -} - -.ph-map-pin-line::before { - content: "\f4ac"; -} - -.ph-map-trifold::before { - content: "\f4ad"; -} - -.ph-marker-circle::before { - content: "\f4ae"; -} - -.ph-martini::before { - content: "\f4af"; -} - -.ph-mask-happy::before { - content: "\f4b0"; -} - -.ph-mask-sad::before { - content: "\f4b1"; -} - -.ph-math-operations::before { - content: "\f4b2"; -} - -.ph-medal::before { - content: "\f4b3"; -} - -.ph-medium-logo::before { - content: "\f4b4"; -} - -.ph-megaphone::before { - content: "\f4b5"; -} - -.ph-megaphone-simple::before { - content: "\f4b6"; -} - -.ph-messenger-logo::before { - content: "\f4b7"; -} - -.ph-microphone::before { - content: "\f4b8"; -} - -.ph-microphone-slash::before { - content: "\f4b9"; -} - -.ph-microphone-stage::before { - content: "\f4ba"; -} - -.ph-microsoft-excel-logo::before { - content: "\f4bb"; -} - -.ph-microsoft-powerpoint-logo::before { - content: "\f4bc"; -} - -.ph-microsoft-teams-logo::before { - content: "\f4bd"; -} - -.ph-microsoft-word-logo::before { - content: "\f4be"; -} - -.ph-minus::before { - content: "\f4bf"; -} - -.ph-minus-circle::before { - content: "\f4c0"; -} - -.ph-money::before { - content: "\f4c1"; -} - -.ph-monitor::before { - content: "\f4c2"; -} - -.ph-monitor-play::before { - content: "\f4c3"; -} - -.ph-moon::before { - content: "\f4c4"; -} - -.ph-moon-stars::before { - content: "\f4c5"; -} - -.ph-mountains::before { - content: "\f4c6"; -} - -.ph-mouse::before { - content: "\f4c7"; -} - -.ph-mouse-simple::before { - content: "\f4c8"; -} - -.ph-music-note::before { - content: "\f4c9"; -} - -.ph-music-note-simple::before { - content: "\f4ca"; -} - -.ph-music-notes::before { - content: "\f4cb"; -} - -.ph-music-notes-plus::before { - content: "\f4cc"; -} - -.ph-music-notes-simple::before { - content: "\f4cd"; -} - -.ph-navigation-arrow::before { - content: "\f4ce"; -} - -.ph-needle::before { - content: "\f4cf"; -} - -.ph-newspaper::before { - content: "\f4d0"; -} - -.ph-newspaper-clipping::before { - content: "\f4d1"; -} - -.ph-note::before { - content: "\f4d2"; -} - -.ph-note-blank::before { - content: "\f4d3"; -} - -.ph-note-pencil::before { - content: "\f4d4"; -} - -.ph-notebook::before { - content: "\f4d5"; -} - -.ph-notepad::before { - content: "\f4d6"; -} - -.ph-notification::before { - content: "\f4d7"; -} - -.ph-number-circle-eight::before { - content: "\f4d8"; -} - -.ph-number-circle-five::before { - content: "\f4d9"; -} - -.ph-number-circle-four::before { - content: "\f4da"; -} - -.ph-number-circle-nine::before { - content: "\f4db"; -} - -.ph-number-circle-one::before { - content: "\f4dc"; -} - -.ph-number-circle-seven::before { - content: "\f4dd"; -} - -.ph-number-circle-six::before { - content: "\f4de"; -} - -.ph-number-circle-three::before { - content: "\f4df"; -} - -.ph-number-circle-two::before { - content: "\f4e0"; -} - -.ph-number-circle-zero::before { - content: "\f4e1"; -} - -.ph-number-eight::before { - content: "\f4e2"; -} - -.ph-number-five::before { - content: "\f4e3"; -} - -.ph-number-four::before { - content: "\f4e4"; -} - -.ph-number-nine::before { - content: "\f4e5"; -} - -.ph-number-one::before { - content: "\f4e6"; -} - -.ph-number-seven::before { - content: "\f4e7"; -} - -.ph-number-six::before { - content: "\f4e8"; -} - -.ph-number-square-eight::before { - content: "\f4e9"; -} - -.ph-number-square-five::before { - content: "\f4ea"; -} - -.ph-number-square-four::before { - content: "\f4eb"; -} - -.ph-number-square-nine::before { - content: "\f4ec"; -} - -.ph-number-square-one::before { - content: "\f4ed"; -} - -.ph-number-square-seven::before { - content: "\f4ee"; -} - -.ph-number-square-six::before { - content: "\f4ef"; -} - -.ph-number-square-three::before { - content: "\f4f0"; -} - -.ph-number-square-two::before { - content: "\f4f1"; -} - -.ph-number-square-zero::before { - content: "\f4f2"; -} - -.ph-number-three::before { - content: "\f4f3"; -} - -.ph-number-two::before { - content: "\f4f4"; -} - -.ph-number-zero::before { - content: "\f4f5"; -} - -.ph-nut::before { - content: "\f4f6"; -} - -.ph-ny-times-logo::before { - content: "\f4f7"; -} - -.ph-octagon::before { - content: "\f4f8"; -} - -.ph-option::before { - content: "\f4f9"; -} - -.ph-package::before { - content: "\f4fa"; -} - -.ph-paint-brush::before { - content: "\f4fb"; -} - -.ph-paint-brush-broad::before { - content: "\f4fc"; -} - -.ph-paint-brush-household::before { - content: "\f4fd"; -} - -.ph-paint-bucket::before { - content: "\f4fe"; -} - -.ph-paint-roller::before { - content: "\f4ff"; -} - -.ph-palette::before { - content: "\f500"; -} - -.ph-paper-plane::before { - content: "\f501"; -} - -.ph-paper-plane-right::before { - content: "\f502"; -} - -.ph-paper-plane-tilt::before { - content: "\f503"; -} - -.ph-paperclip::before { - content: "\f504"; -} - -.ph-paperclip-horizontal::before { - content: "\f505"; -} - -.ph-parachute::before { - content: "\f506"; -} - -.ph-password::before { - content: "\f507"; -} - -.ph-path::before { - content: "\f508"; -} - -.ph-pause::before { - content: "\f509"; -} - -.ph-pause-circle::before { - content: "\f50a"; -} - -.ph-paw-print::before { - content: "\f50b"; -} - -.ph-peace::before { - content: "\f50c"; -} - -.ph-pen::before { - content: "\f50d"; -} - -.ph-pen-nib::before { - content: "\f50e"; -} - -.ph-pen-nib-straight::before { - content: "\f50f"; -} - -.ph-pencil::before { - content: "\f510"; -} - -.ph-pencil-circle::before { - content: "\f511"; -} - -.ph-pencil-line::before { - content: "\f512"; -} - -.ph-pencil-simple::before { - content: "\f513"; -} - -.ph-pencil-simple-line::before { - content: "\f514"; -} - -.ph-percent::before { - content: "\f515"; -} - -.ph-person::before { - content: "\f516"; -} - -.ph-person-simple::before { - content: "\f517"; -} - -.ph-person-simple-run::before { - content: "\f518"; -} - -.ph-person-simple-walk::before { - content: "\f519"; -} - -.ph-perspective::before { - content: "\f51a"; -} - -.ph-phone::before { - content: "\f51b"; -} - -.ph-phone-call::before { - content: "\f51c"; -} - -.ph-phone-disconnect::before { - content: "\f51d"; -} - -.ph-phone-incoming::before { - content: "\f51e"; -} - -.ph-phone-outgoing::before { - content: "\f51f"; -} - -.ph-phone-slash::before { - content: "\f520"; -} - -.ph-phone-x::before { - content: "\f521"; -} - -.ph-phosphor-logo::before { - content: "\f522"; -} - -.ph-piano-keys::before { - content: "\f523"; -} - -.ph-picture-in-picture::before { - content: "\f524"; -} - -.ph-pill::before { - content: "\f525"; -} - -.ph-pinterest-logo::before { - content: "\f526"; -} - -.ph-pinwheel::before { - content: "\f527"; -} - -.ph-pizza::before { - content: "\f528"; -} - -.ph-placeholder::before { - content: "\f529"; -} - -.ph-planet::before { - content: "\f52a"; -} - -.ph-play::before { - content: "\f52b"; -} - -.ph-play-circle::before { - content: "\f52c"; -} - -.ph-playlist::before { - content: "\f52d"; -} - -.ph-plug::before { - content: "\f52e"; -} - -.ph-plugs::before { - content: "\f52f"; -} - -.ph-plugs-connected::before { - content: "\f530"; -} - -.ph-plus::before { - content: "\f531"; -} - -.ph-plus-circle::before { - content: "\f532"; -} - -.ph-plus-minus::before { - content: "\f533"; -} - -.ph-poker-chip::before { - content: "\f534"; -} - -.ph-police-car::before { - content: "\f535"; -} - -.ph-polygon::before { - content: "\f536"; -} - -.ph-popcorn::before { - content: "\f537"; -} - -.ph-power::before { - content: "\f538"; -} - -.ph-prescription::before { - content: "\f539"; -} - -.ph-presentation::before { - content: "\f53a"; -} - -.ph-presentation-chart::before { - content: "\f53b"; -} - -.ph-printer::before { - content: "\f53c"; -} - -.ph-prohibit::before { - content: "\f53d"; -} - -.ph-prohibit-inset::before { - content: "\f53e"; -} - -.ph-projector-screen::before { - content: "\f53f"; -} - -.ph-projector-screen-chart::before { - content: "\f540"; -} - -.ph-push-pin::before { - content: "\f541"; -} - -.ph-push-pin-simple::before { - content: "\f542"; -} - -.ph-push-pin-simple-slash::before { - content: "\f543"; -} - -.ph-push-pin-slash::before { - content: "\f544"; -} - -.ph-puzzle-piece::before { - content: "\f545"; -} - -.ph-qr-code::before { - content: "\f546"; -} - -.ph-question::before { - content: "\f547"; -} - -.ph-queue::before { - content: "\f548"; -} - -.ph-quotes::before { - content: "\f549"; -} - -.ph-radical::before { - content: "\f54a"; -} - -.ph-radio::before { - content: "\f54b"; -} - -.ph-radio-button::before { - content: "\f54c"; -} - -.ph-rainbow::before { - content: "\f54d"; -} - -.ph-rainbow-cloud::before { - content: "\f54e"; -} - -.ph-receipt::before { - content: "\f54f"; -} - -.ph-record::before { - content: "\f550"; -} - -.ph-rectangle::before { - content: "\f551"; -} - -.ph-recycle::before { - content: "\f552"; -} - -.ph-reddit-logo::before { - content: "\f553"; -} - -.ph-repeat::before { - content: "\f554"; -} - -.ph-repeat-once::before { - content: "\f555"; -} - -.ph-rewind::before { - content: "\f556"; -} - -.ph-rewind-circle::before { - content: "\f557"; -} - -.ph-robot::before { - content: "\f558"; -} - -.ph-rocket::before { - content: "\f559"; -} - -.ph-rocket-launch::before { - content: "\f55a"; -} - -.ph-rows::before { - content: "\f55b"; -} - -.ph-rss::before { - content: "\f55c"; -} - -.ph-rss-simple::before { - content: "\f55d"; -} - -.ph-rug::before { - content: "\f55e"; -} - -.ph-ruler::before { - content: "\f55f"; -} - -.ph-scales::before { - content: "\f560"; -} - -.ph-scan::before { - content: "\f561"; -} - -.ph-scissors::before { - content: "\f562"; -} - -.ph-screencast::before { - content: "\f563"; -} - -.ph-scribble-loop::before { - content: "\f564"; -} - -.ph-scroll::before { - content: "\f565"; -} - -.ph-selection::before { - content: "\f566"; -} - -.ph-selection-all::before { - content: "\f567"; -} - -.ph-selection-background::before { - content: "\f568"; -} - -.ph-selection-foreground::before { - content: "\f569"; -} - -.ph-selection-inverse::before { - content: "\f56a"; -} - -.ph-selection-plus::before { - content: "\f56b"; -} - -.ph-selection-slash::before { - content: "\f56c"; -} - -.ph-share::before { - content: "\f56d"; -} - -.ph-share-network::before { - content: "\f56e"; -} - -.ph-shield::before { - content: "\f56f"; -} - -.ph-shield-check::before { - content: "\f570"; -} - -.ph-shield-checkered::before { - content: "\f571"; -} - -.ph-shield-chevron::before { - content: "\f572"; -} - -.ph-shield-plus::before { - content: "\f573"; -} - -.ph-shield-slash::before { - content: "\f574"; -} - -.ph-shield-star::before { - content: "\f575"; -} - -.ph-shield-warning::before { - content: "\f576"; -} - -.ph-shopping-bag::before { - content: "\f577"; -} - -.ph-shopping-bag-open::before { - content: "\f578"; -} - -.ph-shopping-cart::before { - content: "\f579"; -} - -.ph-shopping-cart-simple::before { - content: "\f57a"; -} - -.ph-shower::before { - content: "\f57b"; -} - -.ph-shuffle::before { - content: "\f57c"; -} - -.ph-shuffle-angular::before { - content: "\f57d"; -} - -.ph-shuffle-simple::before { - content: "\f57e"; -} - -.ph-sidebar::before { - content: "\f57f"; -} - -.ph-sidebar-simple::before { - content: "\f580"; -} - -.ph-sign-in::before { - content: "\f581"; -} - -.ph-sign-out::before { - content: "\f582"; -} - -.ph-signpost::before { - content: "\f583"; -} - -.ph-sim-card::before { - content: "\f584"; -} - -.ph-sketch-logo::before { - content: "\f585"; -} - -.ph-skip-back::before { - content: "\f586"; -} - -.ph-skip-back-circle::before { - content: "\f587"; -} - -.ph-skip-forward::before { - content: "\f588"; -} - -.ph-skip-forward-circle::before { - content: "\f589"; -} - -.ph-skull::before { - content: "\f58a"; -} - -.ph-slack-logo::before { - content: "\f58b"; -} - -.ph-sliders::before { - content: "\f58c"; -} - -.ph-sliders-horizontal::before { - content: "\f58d"; -} - -.ph-smiley::before { - content: "\f58e"; -} - -.ph-smiley-blank::before { - content: "\f58f"; -} - -.ph-smiley-meh::before { - content: "\f590"; -} - -.ph-smiley-nervous::before { - content: "\f591"; -} - -.ph-smiley-sad::before { - content: "\f592"; -} - -.ph-smiley-sticker::before { - content: "\f593"; -} - -.ph-smiley-wink::before { - content: "\f594"; -} - -.ph-smiley-x-eyes::before { - content: "\f595"; -} - -.ph-snapchat-logo::before { - content: "\f596"; -} - -.ph-snowflake::before { - content: "\f597"; -} - -.ph-soccer-ball::before { - content: "\f598"; -} - -.ph-sort-ascending::before { - content: "\f599"; -} - -.ph-sort-descending::before { - content: "\f59a"; -} - -.ph-spade::before { - content: "\f59b"; -} - -.ph-sparkle::before { - content: "\f59c"; -} - -.ph-speaker-high::before { - content: "\f59d"; -} - -.ph-speaker-low::before { - content: "\f59e"; -} - -.ph-speaker-none::before { - content: "\f59f"; -} - -.ph-speaker-simple-high::before { - content: "\f5a0"; -} - -.ph-speaker-simple-low::before { - content: "\f5a1"; -} - -.ph-speaker-simple-none::before { - content: "\f5a2"; -} - -.ph-speaker-simple-slash::before { - content: "\f5a3"; -} - -.ph-speaker-simple-x::before { - content: "\f5a4"; -} - -.ph-speaker-slash::before { - content: "\f5a5"; -} - -.ph-speaker-x::before { - content: "\f5a6"; -} - -.ph-spinner::before { - content: "\f5a7"; -} - -.ph-spinner-gap::before { - content: "\f5a8"; -} - -.ph-spiral::before { - content: "\f5a9"; -} - -.ph-spotify-logo::before { - content: "\f5aa"; -} - -.ph-square::before { - content: "\f5ab"; -} - -.ph-square-half::before { - content: "\f5ac"; -} - -.ph-square-half-bottom::before { - content: "\f5ad"; -} - -.ph-square-logo::before { - content: "\f5ae"; -} - -.ph-squares-four::before { - content: "\f5af"; -} - -.ph-stack::before { - content: "\f5b0"; -} - -.ph-stack-overflow-logo::before { - content: "\f5b1"; -} - -.ph-stack-simple::before { - content: "\f5b2"; -} - -.ph-stamp::before { - content: "\f5b3"; -} - -.ph-star::before { - content: "\f5b4"; -} - -.ph-star-four::before { - content: "\f5b5"; -} - -.ph-star-half::before { - content: "\f5b6"; -} - -.ph-sticker::before { - content: "\f5b7"; -} - -.ph-stop::before { - content: "\f5b8"; -} - -.ph-stop-circle::before { - content: "\f5b9"; -} - -.ph-storefront::before { - content: "\f5ba"; -} - -.ph-strategy::before { - content: "\f5bb"; -} - -.ph-stripe-logo::before { - content: "\f5bc"; -} - -.ph-student::before { - content: "\f5bd"; -} - -.ph-suitcase::before { - content: "\f5be"; -} - -.ph-suitcase-simple::before { - content: "\f5bf"; -} - -.ph-sun::before { - content: "\f5c0"; -} - -.ph-sun-dim::before { - content: "\f5c1"; -} - -.ph-sun-horizon::before { - content: "\f5c2"; -} - -.ph-sunglasses::before { - content: "\f5c3"; -} - -.ph-swap::before { - content: "\f5c4"; -} - -.ph-swatches::before { - content: "\f5c5"; -} - -.ph-sword::before { - content: "\f5c6"; -} - -.ph-syringe::before { - content: "\f5c7"; -} - -.ph-t-shirt::before { - content: "\f5c8"; -} - -.ph-table::before { - content: "\f5c9"; -} - -.ph-tabs::before { - content: "\f5ca"; -} - -.ph-tag::before { - content: "\f5cb"; -} - -.ph-tag-chevron::before { - content: "\f5cc"; -} - -.ph-tag-simple::before { - content: "\f5cd"; -} - -.ph-target::before { - content: "\f5ce"; -} - -.ph-taxi::before { - content: "\f5cf"; -} - -.ph-telegram-logo::before { - content: "\f5d0"; -} - -.ph-television::before { - content: "\f5d1"; -} - -.ph-television-simple::before { - content: "\f5d2"; -} - -.ph-tennis-ball::before { - content: "\f5d3"; -} - -.ph-terminal::before { - content: "\f5d4"; -} - -.ph-terminal-window::before { - content: "\f5d5"; -} - -.ph-test-tube::before { - content: "\f5d6"; -} - -.ph-text-aa::before { - content: "\f5d7"; -} - -.ph-text-align-center::before { - content: "\f5d8"; -} - -.ph-text-align-justify::before { - content: "\f5d9"; -} - -.ph-text-align-left::before { - content: "\f5da"; -} - -.ph-text-align-right::before { - content: "\f5db"; -} - -.ph-text-bolder::before { - content: "\f5dc"; -} - -.ph-text-h::before { - content: "\f5dd"; -} - -.ph-text-h-five::before { - content: "\f5de"; -} - -.ph-text-h-four::before { - content: "\f5df"; -} - -.ph-text-h-one::before { - content: "\f5e0"; -} - -.ph-text-h-six::before { - content: "\f5e1"; -} - -.ph-text-h-three::before { - content: "\f5e2"; -} - -.ph-text-h-two::before { - content: "\f5e3"; -} - -.ph-text-indent::before { - content: "\f5e4"; -} - -.ph-text-italic::before { - content: "\f5e5"; -} - -.ph-text-outdent::before { - content: "\f5e6"; -} - -.ph-text-strikethrough::before { - content: "\f5e7"; -} - -.ph-text-t::before { - content: "\f5e8"; -} - -.ph-text-underline::before { - content: "\f5e9"; -} - -.ph-textbox::before { - content: "\f5ea"; -} - -.ph-thermometer::before { - content: "\f5eb"; -} - -.ph-thermometer-cold::before { - content: "\f5ec"; -} - -.ph-thermometer-hot::before { - content: "\f5ed"; -} - -.ph-thermometer-simple::before { - content: "\f5ee"; -} - -.ph-thumbs-down::before { - content: "\f5ef"; -} - -.ph-thumbs-up::before { - content: "\f5f0"; -} - -.ph-ticket::before { - content: "\f5f1"; -} - -.ph-tiktok-logo::before { - content: "\f5f2"; -} - -.ph-timer::before { - content: "\f5f3"; -} - -.ph-toggle-left::before { - content: "\f5f4"; -} - -.ph-toggle-right::before { - content: "\f5f5"; -} - -.ph-toilet::before { - content: "\f5f6"; -} - -.ph-toilet-paper::before { - content: "\f5f7"; -} - -.ph-tote::before { - content: "\f5f8"; -} - -.ph-tote-simple::before { - content: "\f5f9"; -} - -.ph-trademark-registered::before { - content: "\f5fa"; -} - -.ph-traffic-cone::before { - content: "\f5fb"; -} - -.ph-traffic-sign::before { - content: "\f5fc"; -} - -.ph-traffic-signal::before { - content: "\f5fd"; -} - -.ph-train::before { - content: "\f5fe"; -} - -.ph-train-regional::before { - content: "\f5ff"; -} - -.ph-train-simple::before { - content: "\f600"; -} - -.ph-translate::before { - content: "\f601"; -} - -.ph-trash::before { - content: "\f602"; -} - -.ph-trash-simple::before { - content: "\f603"; -} - -.ph-tray::before { - content: "\f604"; -} - -.ph-tree::before { - content: "\f605"; -} - -.ph-tree-evergreen::before { - content: "\f606"; -} - -.ph-tree-structure::before { - content: "\f607"; -} - -.ph-trend-down::before { - content: "\f608"; -} - -.ph-trend-up::before { - content: "\f609"; -} - -.ph-triangle::before { - content: "\f60a"; -} - -.ph-trophy::before { - content: "\f60b"; -} - -.ph-truck::before { - content: "\f60c"; -} - -.ph-twitch-logo::before { - content: "\f60d"; -} - -.ph-twitter-logo::before { - content: "\f60e"; -} - -.ph-umbrella::before { - content: "\f60f"; -} - -.ph-umbrella-simple::before { - content: "\f610"; -} - -.ph-upload::before { - content: "\f611"; -} - -.ph-upload-simple::before { - content: "\f612"; -} - -.ph-user::before { - content: "\f613"; -} - -.ph-user-circle::before { - content: "\f614"; -} - -.ph-user-circle-gear::before { - content: "\f615"; -} - -.ph-user-circle-minus::before { - content: "\f616"; -} - -.ph-user-circle-plus::before { - content: "\f617"; -} - -.ph-user-focus::before { - content: "\f618"; -} - -.ph-user-gear::before { - content: "\f619"; -} - -.ph-user-list::before { - content: "\f61a"; -} - -.ph-user-minus::before { - content: "\f61b"; -} - -.ph-user-plus::before { - content: "\f61c"; -} - -.ph-user-rectangle::before { - content: "\f61d"; -} - -.ph-user-square::before { - content: "\f61e"; -} - -.ph-user-switch::before { - content: "\f61f"; -} - -.ph-users::before { - content: "\f620"; -} - -.ph-users-four::before { - content: "\f621"; -} - -.ph-users-three::before { - content: "\f622"; -} - -.ph-vault::before { - content: "\f623"; -} - -.ph-vibrate::before { - content: "\f624"; -} - -.ph-video-camera::before { - content: "\f625"; -} - -.ph-video-camera-slash::before { - content: "\f626"; -} - -.ph-vignette::before { - content: "\f627"; -} - -.ph-voicemail::before { - content: "\f628"; -} - -.ph-volleyball::before { - content: "\f629"; -} - -.ph-wall::before { - content: "\f62a"; -} - -.ph-wallet::before { - content: "\f62b"; -} - -.ph-warning::before { - content: "\f62c"; -} - -.ph-warning-circle::before { - content: "\f62d"; -} - -.ph-warning-octagon::before { - content: "\f62e"; -} - -.ph-watch::before { - content: "\f62f"; -} - -.ph-wave-sawtooth::before { - content: "\f630"; -} - -.ph-wave-sine::before { - content: "\f631"; -} - -.ph-wave-square::before { - content: "\f632"; -} - -.ph-wave-triangle::before { - content: "\f633"; -} - -.ph-waves::before { - content: "\f634"; -} - -.ph-webcam::before { - content: "\f635"; -} - -.ph-whatsapp-logo::before { - content: "\f636"; -} - -.ph-wheelchair::before { - content: "\f637"; -} - -.ph-wifi-high::before { - content: "\f638"; -} - -.ph-wifi-low::before { - content: "\f639"; -} - -.ph-wifi-medium::before { - content: "\f63a"; -} - -.ph-wifi-none::before { - content: "\f63b"; -} - -.ph-wifi-slash::before { - content: "\f63c"; -} - -.ph-wifi-x::before { - content: "\f63d"; -} - -.ph-wind::before { - content: "\f63e"; -} - -.ph-windows-logo::before { - content: "\f63f"; -} - -.ph-wine::before { - content: "\f640"; -} - -.ph-wrench::before { - content: "\f641"; -} - -.ph-x::before { - content: "\f642"; -} - -.ph-x-circle::before { - content: "\f643"; -} - -.ph-x-square::before { - content: "\f644"; -} - -.ph-yin-yang::before { - content: "\f645"; -} - -.ph-youtube-logo::before { - content: "\f646"; -} - -.ph-activity-bold::before { - content: "\f647"; -} - -.ph-address-book-bold::before { - content: "\f648"; -} - -.ph-airplane-bold::before { - content: "\f649"; -} - -.ph-airplane-in-flight-bold::before { - content: "\f64a"; -} - -.ph-airplane-landing-bold::before { - content: "\f64b"; -} - -.ph-airplane-takeoff-bold::before { - content: "\f64c"; -} - -.ph-airplane-tilt-bold::before { - content: "\f64d"; -} - -.ph-airplay-bold::before { - content: "\f64e"; -} - -.ph-alarm-bold::before { - content: "\f64f"; -} - -.ph-alien-bold::before { - content: "\f650"; -} - -.ph-align-bottom-bold::before { - content: "\f651"; -} - -.ph-align-bottom-simple-bold::before { - content: "\f652"; -} - -.ph-align-center-horizontal-bold::before { - content: "\f653"; -} - -.ph-align-center-horizontal-simple-bold::before { - content: "\f654"; -} - -.ph-align-center-vertical-bold::before { - content: "\f655"; -} - -.ph-align-center-vertical-simple-bold::before { - content: "\f656"; -} - -.ph-align-left-bold::before { - content: "\f657"; -} - -.ph-align-left-simple-bold::before { - content: "\f658"; -} - -.ph-align-right-bold::before { - content: "\f659"; -} - -.ph-align-right-simple-bold::before { - content: "\f65a"; -} - -.ph-align-top-bold::before { - content: "\f65b"; -} - -.ph-align-top-simple-bold::before { - content: "\f65c"; -} - -.ph-anchor-bold::before { - content: "\f65d"; -} - -.ph-anchor-simple-bold::before { - content: "\f65e"; -} - -.ph-android-logo-bold::before { - content: "\f65f"; -} - -.ph-angular-logo-bold::before { - content: "\f660"; -} - -.ph-aperture-bold::before { - content: "\f661"; -} - -.ph-app-store-logo-bold::before { - content: "\f662"; -} - -.ph-app-window-bold::before { - content: "\f663"; -} - -.ph-apple-logo-bold::before { - content: "\f664"; -} - -.ph-apple-podcasts-logo-bold::before { - content: "\f665"; -} - -.ph-archive-bold::before { - content: "\f666"; -} - -.ph-archive-box-bold::before { - content: "\f667"; -} - -.ph-archive-tray-bold::before { - content: "\f668"; -} - -.ph-armchair-bold::before { - content: "\f669"; -} - -.ph-arrow-arc-left-bold::before { - content: "\f66a"; -} - -.ph-arrow-arc-right-bold::before { - content: "\f66b"; -} - -.ph-arrow-bend-double-up-left-bold::before { - content: "\f66c"; -} - -.ph-arrow-bend-double-up-right-bold::before { - content: "\f66d"; -} - -.ph-arrow-bend-down-left-bold::before { - content: "\f66e"; -} - -.ph-arrow-bend-down-right-bold::before { - content: "\f66f"; -} - -.ph-arrow-bend-left-down-bold::before { - content: "\f670"; -} - -.ph-arrow-bend-left-up-bold::before { - content: "\f671"; -} - -.ph-arrow-bend-right-down-bold::before { - content: "\f672"; -} - -.ph-arrow-bend-right-up-bold::before { - content: "\f673"; -} - -.ph-arrow-bend-up-left-bold::before { - content: "\f674"; -} - -.ph-arrow-bend-up-right-bold::before { - content: "\f675"; -} - -.ph-arrow-circle-down-bold::before { - content: "\f676"; -} - -.ph-arrow-circle-down-left-bold::before { - content: "\f677"; -} - -.ph-arrow-circle-down-right-bold::before { - content: "\f678"; -} - -.ph-arrow-circle-left-bold::before { - content: "\f679"; -} - -.ph-arrow-circle-right-bold::before { - content: "\f67a"; -} - -.ph-arrow-circle-up-bold::before { - content: "\f67b"; -} - -.ph-arrow-circle-up-left-bold::before { - content: "\f67c"; -} - -.ph-arrow-circle-up-right-bold::before { - content: "\f67d"; -} - -.ph-arrow-clockwise-bold::before { - content: "\f67e"; -} - -.ph-arrow-counter-clockwise-bold::before { - content: "\f67f"; -} - -.ph-arrow-down-bold::before { - content: "\f680"; -} - -.ph-arrow-down-left-bold::before { - content: "\f681"; -} - -.ph-arrow-down-right-bold::before { - content: "\f682"; -} - -.ph-arrow-elbow-down-left-bold::before { - content: "\f683"; -} - -.ph-arrow-elbow-down-right-bold::before { - content: "\f684"; -} - -.ph-arrow-elbow-left-bold::before { - content: "\f685"; -} - -.ph-arrow-elbow-left-down-bold::before { - content: "\f686"; -} - -.ph-arrow-elbow-left-up-bold::before { - content: "\f687"; -} - -.ph-arrow-elbow-right-bold::before { - content: "\f688"; -} - -.ph-arrow-elbow-right-down-bold::before { - content: "\f689"; -} - -.ph-arrow-elbow-right-up-bold::before { - content: "\f68a"; -} - -.ph-arrow-elbow-up-left-bold::before { - content: "\f68b"; -} - -.ph-arrow-elbow-up-right-bold::before { - content: "\f68c"; -} - -.ph-arrow-fat-down-bold::before { - content: "\f68d"; -} - -.ph-arrow-fat-left-bold::before { - content: "\f68e"; -} - -.ph-arrow-fat-line-down-bold::before { - content: "\f68f"; -} - -.ph-arrow-fat-line-left-bold::before { - content: "\f690"; -} - -.ph-arrow-fat-line-right-bold::before { - content: "\f691"; -} - -.ph-arrow-fat-line-up-bold::before { - content: "\f692"; -} - -.ph-arrow-fat-lines-down-bold::before { - content: "\f693"; -} - -.ph-arrow-fat-lines-left-bold::before { - content: "\f694"; -} - -.ph-arrow-fat-lines-right-bold::before { - content: "\f695"; -} - -.ph-arrow-fat-lines-up-bold::before { - content: "\f696"; -} - -.ph-arrow-fat-right-bold::before { - content: "\f697"; -} - -.ph-arrow-fat-up-bold::before { - content: "\f698"; -} - -.ph-arrow-left-bold::before { - content: "\f699"; -} - -.ph-arrow-line-down-bold::before { - content: "\f69a"; -} - -.ph-arrow-line-down-left-bold::before { - content: "\f69b"; -} - -.ph-arrow-line-down-right-bold::before { - content: "\f69c"; -} - -.ph-arrow-line-left-bold::before { - content: "\f69d"; -} - -.ph-arrow-line-right-bold::before { - content: "\f69e"; -} - -.ph-arrow-line-up-bold::before { - content: "\f69f"; -} - -.ph-arrow-line-up-left-bold::before { - content: "\f6a0"; -} - -.ph-arrow-line-up-right-bold::before { - content: "\f6a1"; -} - -.ph-arrow-right-bold::before { - content: "\f6a2"; -} - -.ph-arrow-square-down-bold::before { - content: "\f6a3"; -} - -.ph-arrow-square-down-left-bold::before { - content: "\f6a4"; -} - -.ph-arrow-square-down-right-bold::before { - content: "\f6a5"; -} - -.ph-arrow-square-in-bold::before { - content: "\f6a6"; -} - -.ph-arrow-square-left-bold::before { - content: "\f6a7"; -} - -.ph-arrow-square-out-bold::before { - content: "\f6a8"; -} - -.ph-arrow-square-right-bold::before { - content: "\f6a9"; -} - -.ph-arrow-square-up-bold::before { - content: "\f6aa"; -} - -.ph-arrow-square-up-left-bold::before { - content: "\f6ab"; -} - -.ph-arrow-square-up-right-bold::before { - content: "\f6ac"; -} - -.ph-arrow-u-down-left-bold::before { - content: "\f6ad"; -} - -.ph-arrow-u-down-right-bold::before { - content: "\f6ae"; -} - -.ph-arrow-u-left-down-bold::before { - content: "\f6af"; -} - -.ph-arrow-u-left-up-bold::before { - content: "\f6b0"; -} - -.ph-arrow-u-right-down-bold::before { - content: "\f6b1"; -} - -.ph-arrow-u-right-up-bold::before { - content: "\f6b2"; -} - -.ph-arrow-u-up-left-bold::before { - content: "\f6b3"; -} - -.ph-arrow-u-up-right-bold::before { - content: "\f6b4"; -} - -.ph-arrow-up-bold::before { - content: "\f6b5"; -} - -.ph-arrow-up-left-bold::before { - content: "\f6b6"; -} - -.ph-arrow-up-right-bold::before { - content: "\f6b7"; -} - -.ph-arrows-clockwise-bold::before { - content: "\f6b8"; -} - -.ph-arrows-counter-clockwise-bold::before { - content: "\f6b9"; -} - -.ph-arrows-down-up-bold::before { - content: "\f6ba"; -} - -.ph-arrows-horizontal-bold::before { - content: "\f6bb"; -} - -.ph-arrows-in-bold::before { - content: "\f6bc"; -} - -.ph-arrows-in-cardinal-bold::before { - content: "\f6bd"; -} - -.ph-arrows-in-line-horizontal-bold::before { - content: "\f6be"; -} - -.ph-arrows-in-line-vertical-bold::before { - content: "\f6bf"; -} - -.ph-arrows-in-simple-bold::before { - content: "\f6c0"; -} - -.ph-arrows-left-right-bold::before { - content: "\f6c1"; -} - -.ph-arrows-out-bold::before { - content: "\f6c2"; -} - -.ph-arrows-out-cardinal-bold::before { - content: "\f6c3"; -} - -.ph-arrows-out-line-horizontal-bold::before { - content: "\f6c4"; -} - -.ph-arrows-out-line-vertical-bold::before { - content: "\f6c5"; -} - -.ph-arrows-out-simple-bold::before { - content: "\f6c6"; -} - -.ph-arrows-vertical-bold::before { - content: "\f6c7"; -} - -.ph-article-bold::before { - content: "\f6c8"; -} - -.ph-article-medium-bold::before { - content: "\f6c9"; -} - -.ph-article-ny-times-bold::before { - content: "\f6ca"; -} - -.ph-asterisk-bold::before { - content: "\f6cb"; -} - -.ph-asterisk-simple-bold::before { - content: "\f6cc"; -} - -.ph-at-bold::before { - content: "\f6cd"; -} - -.ph-atom-bold::before { - content: "\f6ce"; -} - -.ph-baby-bold::before { - content: "\f6cf"; -} - -.ph-backpack-bold::before { - content: "\f6d0"; -} - -.ph-backspace-bold::before { - content: "\f6d1"; -} - -.ph-bag-bold::before { - content: "\f6d2"; -} - -.ph-bag-simple-bold::before { - content: "\f6d3"; -} - -.ph-balloon-bold::before { - content: "\f6d4"; -} - -.ph-bandaids-bold::before { - content: "\f6d5"; -} - -.ph-bank-bold::before { - content: "\f6d6"; -} - -.ph-barbell-bold::before { - content: "\f6d7"; -} - -.ph-barcode-bold::before { - content: "\f6d8"; -} - -.ph-barricade-bold::before { - content: "\f6d9"; -} - -.ph-baseball-bold::before { - content: "\f6da"; -} - -.ph-basketball-bold::before { - content: "\f6db"; -} - -.ph-bathtub-bold::before { - content: "\f6dc"; -} - -.ph-battery-charging-bold::before { - content: "\f6dd"; -} - -.ph-battery-charging-vertical-bold::before { - content: "\f6de"; -} - -.ph-battery-empty-bold::before { - content: "\f6df"; -} - -.ph-battery-full-bold::before { - content: "\f6e0"; -} - -.ph-battery-high-bold::before { - content: "\f6e1"; -} - -.ph-battery-low-bold::before { - content: "\f6e2"; -} - -.ph-battery-medium-bold::before { - content: "\f6e3"; -} - -.ph-battery-plus-bold::before { - content: "\f6e4"; -} - -.ph-battery-warning-bold::before { - content: "\f6e5"; -} - -.ph-battery-warning-vertical-bold::before { - content: "\f6e6"; -} - -.ph-bed-bold::before { - content: "\f6e7"; -} - -.ph-beer-bottle-bold::before { - content: "\f6e8"; -} - -.ph-behance-logo-bold::before { - content: "\f6e9"; -} - -.ph-bell-bold::before { - content: "\f6ea"; -} - -.ph-bell-ringing-bold::before { - content: "\f6eb"; -} - -.ph-bell-simple-bold::before { - content: "\f6ec"; -} - -.ph-bell-simple-ringing-bold::before { - content: "\f6ed"; -} - -.ph-bell-simple-slash-bold::before { - content: "\f6ee"; -} - -.ph-bell-simple-z-bold::before { - content: "\f6ef"; -} - -.ph-bell-slash-bold::before { - content: "\f6f0"; -} - -.ph-bell-z-bold::before { - content: "\f6f1"; -} - -.ph-bezier-curve-bold::before { - content: "\f6f2"; -} - -.ph-bicycle-bold::before { - content: "\f6f3"; -} - -.ph-binoculars-bold::before { - content: "\f6f4"; -} - -.ph-bird-bold::before { - content: "\f6f5"; -} - -.ph-bluetooth-bold::before { - content: "\f6f6"; -} - -.ph-bluetooth-connected-bold::before { - content: "\f6f7"; -} - -.ph-bluetooth-slash-bold::before { - content: "\f6f8"; -} - -.ph-bluetooth-x-bold::before { - content: "\f6f9"; -} - -.ph-boat-bold::before { - content: "\f6fa"; -} - -.ph-book-bold::before { - content: "\f6fb"; -} - -.ph-book-bookmark-bold::before { - content: "\f6fc"; -} - -.ph-book-open-bold::before { - content: "\f6fd"; -} - -.ph-bookmark-bold::before { - content: "\f6fe"; -} - -.ph-bookmark-simple-bold::before { - content: "\f6ff"; -} - -.ph-bookmarks-bold::before { - content: "\f700"; -} - -.ph-bookmarks-simple-bold::before { - content: "\f701"; -} - -.ph-books-bold::before { - content: "\f702"; -} - -.ph-bounding-box-bold::before { - content: "\f703"; -} - -.ph-brackets-angle-bold::before { - content: "\f704"; -} - -.ph-brackets-curly-bold::before { - content: "\f705"; -} - -.ph-brackets-round-bold::before { - content: "\f706"; -} - -.ph-brackets-square-bold::before { - content: "\f707"; -} - -.ph-brain-bold::before { - content: "\f708"; -} - -.ph-brandy-bold::before { - content: "\f709"; -} - -.ph-briefcase-bold::before { - content: "\f70a"; -} - -.ph-briefcase-metal-bold::before { - content: "\f70b"; -} - -.ph-broadcast-bold::before { - content: "\f70c"; -} - -.ph-browser-bold::before { - content: "\f70d"; -} - -.ph-browsers-bold::before { - content: "\f70e"; -} - -.ph-bug-beetle-bold::before { - content: "\f70f"; -} - -.ph-bug-bold::before { - content: "\f710"; -} - -.ph-bug-droid-bold::before { - content: "\f711"; -} - -.ph-buildings-bold::before { - content: "\f712"; -} - -.ph-bus-bold::before { - content: "\f713"; -} - -.ph-butterfly-bold::before { - content: "\f714"; -} - -.ph-cactus-bold::before { - content: "\f715"; -} - -.ph-cake-bold::before { - content: "\f716"; -} - -.ph-calculator-bold::before { - content: "\f717"; -} - -.ph-calendar-blank-bold::before { - content: "\f718"; -} - -.ph-calendar-bold::before { - content: "\f719"; -} - -.ph-calendar-check-bold::before { - content: "\f71a"; -} - -.ph-calendar-plus-bold::before { - content: "\f71b"; -} - -.ph-calendar-x-bold::before { - content: "\f71c"; -} - -.ph-camera-bold::before { - content: "\f71d"; -} - -.ph-camera-rotate-bold::before { - content: "\f71e"; -} - -.ph-camera-slash-bold::before { - content: "\f71f"; -} - -.ph-campfire-bold::before { - content: "\f720"; -} - -.ph-car-bold::before { - content: "\f721"; -} - -.ph-car-simple-bold::before { - content: "\f722"; -} - -.ph-cardholder-bold::before { - content: "\f723"; -} - -.ph-cards-bold::before { - content: "\f724"; -} - -.ph-caret-circle-double-down-bold::before { - content: "\f725"; -} - -.ph-caret-circle-double-left-bold::before { - content: "\f726"; -} - -.ph-caret-circle-double-right-bold::before { - content: "\f727"; -} - -.ph-caret-circle-double-up-bold::before { - content: "\f728"; -} - -.ph-caret-circle-down-bold::before { - content: "\f729"; -} - -.ph-caret-circle-left-bold::before { - content: "\f72a"; -} - -.ph-caret-circle-right-bold::before { - content: "\f72b"; -} - -.ph-caret-circle-up-bold::before { - content: "\f72c"; -} - -.ph-caret-double-down-bold::before { - content: "\f72d"; -} - -.ph-caret-double-left-bold::before { - content: "\f72e"; -} - -.ph-caret-double-right-bold::before { - content: "\f72f"; -} - -.ph-caret-double-up-bold::before { - content: "\f730"; -} - -.ph-caret-down-bold::before { - content: "\f731"; -} - -.ph-caret-left-bold::before { - content: "\f732"; -} - -.ph-caret-right-bold::before { - content: "\f733"; -} - -.ph-caret-up-bold::before { - content: "\f734"; -} - -.ph-cat-bold::before { - content: "\f735"; -} - -.ph-cell-signal-full-bold::before { - content: "\f736"; -} - -.ph-cell-signal-high-bold::before { - content: "\f737"; -} - -.ph-cell-signal-low-bold::before { - content: "\f738"; -} - -.ph-cell-signal-medium-bold::before { - content: "\f739"; -} - -.ph-cell-signal-none-bold::before { - content: "\f73a"; -} - -.ph-cell-signal-slash-bold::before { - content: "\f73b"; -} - -.ph-cell-signal-x-bold::before { - content: "\f73c"; -} - -.ph-chalkboard-bold::before { - content: "\f73d"; -} - -.ph-chalkboard-simple-bold::before { - content: "\f73e"; -} - -.ph-chalkboard-teacher-bold::before { - content: "\f73f"; -} - -.ph-chart-bar-bold::before { - content: "\f740"; -} - -.ph-chart-bar-horizontal-bold::before { - content: "\f741"; -} - -.ph-chart-line-bold::before { - content: "\f742"; -} - -.ph-chart-line-up-bold::before { - content: "\f743"; -} - -.ph-chart-pie-bold::before { - content: "\f744"; -} - -.ph-chart-pie-slice-bold::before { - content: "\f745"; -} - -.ph-chat-bold::before { - content: "\f746"; -} - -.ph-chat-centered-bold::before { - content: "\f747"; -} - -.ph-chat-centered-dots-bold::before { - content: "\f748"; -} - -.ph-chat-centered-text-bold::before { - content: "\f749"; -} - -.ph-chat-circle-bold::before { - content: "\f74a"; -} - -.ph-chat-circle-dots-bold::before { - content: "\f74b"; -} - -.ph-chat-circle-text-bold::before { - content: "\f74c"; -} - -.ph-chat-dots-bold::before { - content: "\f74d"; -} - -.ph-chat-teardrop-bold::before { - content: "\f74e"; -} - -.ph-chat-teardrop-dots-bold::before { - content: "\f74f"; -} - -.ph-chat-teardrop-text-bold::before { - content: "\f750"; -} - -.ph-chat-text-bold::before { - content: "\f751"; -} - -.ph-chats-bold::before { - content: "\f752"; -} - -.ph-chats-circle-bold::before { - content: "\f753"; -} - -.ph-chats-teardrop-bold::before { - content: "\f754"; -} - -.ph-check-bold::before { - content: "\f755"; -} - -.ph-check-circle-bold::before { - content: "\f756"; -} - -.ph-check-square-bold::before { - content: "\f757"; -} - -.ph-check-square-offset-bold::before { - content: "\f758"; -} - -.ph-checks-bold::before { - content: "\f759"; -} - -.ph-circle-bold::before { - content: "\f75a"; -} - -.ph-circle-dashed-bold::before { - content: "\f75b"; -} - -.ph-circle-half-bold::before { - content: "\f75c"; -} - -.ph-circle-half-tilt-bold::before { - content: "\f75d"; -} - -.ph-circle-notch-bold::before { - content: "\f75e"; -} - -.ph-circle-wavy-bold::before { - content: "\f75f"; -} - -.ph-circle-wavy-check-bold::before { - content: "\f760"; -} - -.ph-circle-wavy-question-bold::before { - content: "\f761"; -} - -.ph-circle-wavy-warning-bold::before { - content: "\f762"; -} - -.ph-circles-four-bold::before { - content: "\f763"; -} - -.ph-circles-three-bold::before { - content: "\f764"; -} - -.ph-circles-three-plus-bold::before { - content: "\f765"; -} - -.ph-clipboard-bold::before { - content: "\f766"; -} - -.ph-clipboard-text-bold::before { - content: "\f767"; -} - -.ph-clock-afternoon-bold::before { - content: "\f768"; -} - -.ph-clock-bold::before { - content: "\f769"; -} - -.ph-clock-clockwise-bold::before { - content: "\f76a"; -} - -.ph-clock-counter-clockwise-bold::before { - content: "\f76b"; -} - -.ph-closed-captioning-bold::before { - content: "\f76c"; -} - -.ph-cloud-arrow-down-bold::before { - content: "\f76d"; -} - -.ph-cloud-arrow-up-bold::before { - content: "\f76e"; -} - -.ph-cloud-bold::before { - content: "\f76f"; -} - -.ph-cloud-check-bold::before { - content: "\f770"; -} - -.ph-cloud-fog-bold::before { - content: "\f771"; -} - -.ph-cloud-lightning-bold::before { - content: "\f772"; -} - -.ph-cloud-moon-bold::before { - content: "\f773"; -} - -.ph-cloud-rain-bold::before { - content: "\f774"; -} - -.ph-cloud-slash-bold::before { - content: "\f775"; -} - -.ph-cloud-snow-bold::before { - content: "\f776"; -} - -.ph-cloud-sun-bold::before { - content: "\f777"; -} - -.ph-club-bold::before { - content: "\f778"; -} - -.ph-coat-hanger-bold::before { - content: "\f779"; -} - -.ph-code-bold::before { - content: "\f77a"; -} - -.ph-code-simple-bold::before { - content: "\f77b"; -} - -.ph-codepen-logo-bold::before { - content: "\f77c"; -} - -.ph-codesandbox-logo-bold::before { - content: "\f77d"; -} - -.ph-coffee-bold::before { - content: "\f77e"; -} - -.ph-coin-bold::before { - content: "\f77f"; -} - -.ph-coin-vertical-bold::before { - content: "\f780"; -} - -.ph-coins-bold::before { - content: "\f781"; -} - -.ph-columns-bold::before { - content: "\f782"; -} - -.ph-command-bold::before { - content: "\f783"; -} - -.ph-compass-bold::before { - content: "\f784"; -} - -.ph-computer-tower-bold::before { - content: "\f785"; -} - -.ph-confetti-bold::before { - content: "\f786"; -} - -.ph-cookie-bold::before { - content: "\f787"; -} - -.ph-cooking-pot-bold::before { - content: "\f788"; -} - -.ph-copy-bold::before { - content: "\f789"; -} - -.ph-copy-simple-bold::before { - content: "\f78a"; -} - -.ph-copyleft-bold::before { - content: "\f78b"; -} - -.ph-copyright-bold::before { - content: "\f78c"; -} - -.ph-corners-in-bold::before { - content: "\f78d"; -} - -.ph-corners-out-bold::before { - content: "\f78e"; -} - -.ph-cpu-bold::before { - content: "\f78f"; -} - -.ph-credit-card-bold::before { - content: "\f790"; -} - -.ph-crop-bold::before { - content: "\f791"; -} - -.ph-crosshair-bold::before { - content: "\f792"; -} - -.ph-crosshair-simple-bold::before { - content: "\f793"; -} - -.ph-crown-bold::before { - content: "\f794"; -} - -.ph-crown-simple-bold::before { - content: "\f795"; -} - -.ph-cube-bold::before { - content: "\f796"; -} - -.ph-currency-btc-bold::before { - content: "\f797"; -} - -.ph-currency-circle-dollar-bold::before { - content: "\f798"; -} - -.ph-currency-cny-bold::before { - content: "\f799"; -} - -.ph-currency-dollar-bold::before { - content: "\f79a"; -} - -.ph-currency-dollar-simple-bold::before { - content: "\f79b"; -} - -.ph-currency-eth-bold::before { - content: "\f79c"; -} - -.ph-currency-eur-bold::before { - content: "\f79d"; -} - -.ph-currency-gbp-bold::before { - content: "\f79e"; -} - -.ph-currency-inr-bold::before { - content: "\f79f"; -} - -.ph-currency-jpy-bold::before { - content: "\f7a0"; -} - -.ph-currency-krw-bold::before { - content: "\f7a1"; -} - -.ph-currency-kzt-bold::before { - content: "\f7a2"; -} - -.ph-currency-ngn-bold::before { - content: "\f7a3"; -} - -.ph-currency-rub-bold::before { - content: "\f7a4"; -} - -.ph-cursor-bold::before { - content: "\f7a5"; -} - -.ph-cursor-text-bold::before { - content: "\f7a6"; -} - -.ph-cylinder-bold::before { - content: "\f7a7"; -} - -.ph-database-bold::before { - content: "\f7a8"; -} - -.ph-desktop-bold::before { - content: "\f7a9"; -} - -.ph-desktop-tower-bold::before { - content: "\f7aa"; -} - -.ph-detective-bold::before { - content: "\f7ab"; -} - -.ph-device-mobile-bold::before { - content: "\f7ac"; -} - -.ph-device-mobile-camera-bold::before { - content: "\f7ad"; -} - -.ph-device-mobile-speaker-bold::before { - content: "\f7ae"; -} - -.ph-device-tablet-bold::before { - content: "\f7af"; -} - -.ph-device-tablet-camera-bold::before { - content: "\f7b0"; -} - -.ph-device-tablet-speaker-bold::before { - content: "\f7b1"; -} - -.ph-diamond-bold::before { - content: "\f7b2"; -} - -.ph-diamonds-four-bold::before { - content: "\f7b3"; -} - -.ph-dice-five-bold::before { - content: "\f7b4"; -} - -.ph-dice-four-bold::before { - content: "\f7b5"; -} - -.ph-dice-one-bold::before { - content: "\f7b6"; -} - -.ph-dice-six-bold::before { - content: "\f7b7"; -} - -.ph-dice-three-bold::before { - content: "\f7b8"; -} - -.ph-dice-two-bold::before { - content: "\f7b9"; -} - -.ph-disc-bold::before { - content: "\f7ba"; -} - -.ph-discord-logo-bold::before { - content: "\f7bb"; -} - -.ph-divide-bold::before { - content: "\f7bc"; -} - -.ph-dog-bold::before { - content: "\f7bd"; -} - -.ph-door-bold::before { - content: "\f7be"; -} - -.ph-dots-nine-bold::before { - content: "\f7bf"; -} - -.ph-dots-six-bold::before { - content: "\f7c0"; -} - -.ph-dots-six-vertical-bold::before { - content: "\f7c1"; -} - -.ph-dots-three-bold::before { - content: "\f7c2"; -} - -.ph-dots-three-circle-bold::before { - content: "\f7c3"; -} - -.ph-dots-three-circle-vertical-bold::before { - content: "\f7c4"; -} - -.ph-dots-three-outline-bold::before { - content: "\f7c5"; -} - -.ph-dots-three-outline-vertical-bold::before { - content: "\f7c6"; -} - -.ph-dots-three-vertical-bold::before { - content: "\f7c7"; -} - -.ph-download-bold::before { - content: "\f7c8"; -} - -.ph-download-simple-bold::before { - content: "\f7c9"; -} - -.ph-dribbble-logo-bold::before { - content: "\f7ca"; -} - -.ph-drop-bold::before { - content: "\f7cb"; -} - -.ph-drop-half-bold::before { - content: "\f7cc"; -} - -.ph-drop-half-bottom-bold::before { - content: "\f7cd"; -} - -.ph-ear-bold::before { - content: "\f7ce"; -} - -.ph-ear-slash-bold::before { - content: "\f7cf"; -} - -.ph-egg-bold::before { - content: "\f7d0"; -} - -.ph-egg-crack-bold::before { - content: "\f7d1"; -} - -.ph-eject-bold::before { - content: "\f7d2"; -} - -.ph-eject-simple-bold::before { - content: "\f7d3"; -} - -.ph-envelope-bold::before { - content: "\f7d4"; -} - -.ph-envelope-open-bold::before { - content: "\f7d5"; -} - -.ph-envelope-simple-bold::before { - content: "\f7d6"; -} - -.ph-envelope-simple-open-bold::before { - content: "\f7d7"; -} - -.ph-equalizer-bold::before { - content: "\f7d8"; -} - -.ph-equals-bold::before { - content: "\f7d9"; -} - -.ph-eraser-bold::before { - content: "\f7da"; -} - -.ph-exam-bold::before { - content: "\f7db"; -} - -.ph-export-bold::before { - content: "\f7dc"; -} - -.ph-eye-bold::before { - content: "\f7dd"; -} - -.ph-eye-closed-bold::before { - content: "\f7de"; -} - -.ph-eye-slash-bold::before { - content: "\f7df"; -} - -.ph-eyedropper-bold::before { - content: "\f7e0"; -} - -.ph-eyedropper-sample-bold::before { - content: "\f7e1"; -} - -.ph-eyeglasses-bold::before { - content: "\f7e2"; -} - -.ph-face-mask-bold::before { - content: "\f7e3"; -} - -.ph-facebook-logo-bold::before { - content: "\f7e4"; -} - -.ph-factory-bold::before { - content: "\f7e5"; -} - -.ph-faders-bold::before { - content: "\f7e6"; -} - -.ph-faders-horizontal-bold::before { - content: "\f7e7"; -} - -.ph-fast-forward-bold::before { - content: "\f7e8"; -} - -.ph-fast-forward-circle-bold::before { - content: "\f7e9"; -} - -.ph-figma-logo-bold::before { - content: "\f7ea"; -} - -.ph-file-arrow-down-bold::before { - content: "\f7eb"; -} - -.ph-file-arrow-up-bold::before { - content: "\f7ec"; -} - -.ph-file-audio-bold::before { - content: "\f7ed"; -} - -.ph-file-bold::before { - content: "\f7ee"; -} - -.ph-file-cloud-bold::before { - content: "\f7ef"; -} - -.ph-file-code-bold::before { - content: "\f7f0"; -} - -.ph-file-css-bold::before { - content: "\f7f1"; -} - -.ph-file-csv-bold::before { - content: "\f7f2"; -} - -.ph-file-doc-bold::before { - content: "\f7f3"; -} - -.ph-file-dotted-bold::before { - content: "\f7f4"; -} - -.ph-file-html-bold::before { - content: "\f7f5"; -} - -.ph-file-image-bold::before { - content: "\f7f6"; -} - -.ph-file-jpg-bold::before { - content: "\f7f7"; -} - -.ph-file-js-bold::before { - content: "\f7f8"; -} - -.ph-file-jsx-bold::before { - content: "\f7f9"; -} - -.ph-file-lock-bold::before { - content: "\f7fa"; -} - -.ph-file-minus-bold::before { - content: "\f7fb"; -} - -.ph-file-pdf-bold::before { - content: "\f7fc"; -} - -.ph-file-plus-bold::before { - content: "\f7fd"; -} - -.ph-file-png-bold::before { - content: "\f7fe"; -} - -.ph-file-ppt-bold::before { - content: "\f7ff"; -} - -.ph-file-rs-bold::before { - content: "\f800"; -} - -.ph-file-search-bold::before { - content: "\f801"; -} - -.ph-file-text-bold::before { - content: "\f802"; -} - -.ph-file-ts-bold::before { - content: "\f803"; -} - -.ph-file-tsx-bold::before { - content: "\f804"; -} - -.ph-file-video-bold::before { - content: "\f805"; -} - -.ph-file-vue-bold::before { - content: "\f806"; -} - -.ph-file-x-bold::before { - content: "\f807"; -} - -.ph-file-xls-bold::before { - content: "\f808"; -} - -.ph-file-zip-bold::before { - content: "\f809"; -} - -.ph-files-bold::before { - content: "\f80a"; -} - -.ph-film-script-bold::before { - content: "\f80b"; -} - -.ph-film-slate-bold::before { - content: "\f80c"; -} - -.ph-film-strip-bold::before { - content: "\f80d"; -} - -.ph-fingerprint-bold::before { - content: "\f80e"; -} - -.ph-fingerprint-simple-bold::before { - content: "\f80f"; -} - -.ph-finn-the-human-bold::before { - content: "\f810"; -} - -.ph-fire-bold::before { - content: "\f811"; -} - -.ph-fire-simple-bold::before { - content: "\f812"; -} - -.ph-first-aid-bold::before { - content: "\f813"; -} - -.ph-first-aid-kit-bold::before { - content: "\f814"; -} - -.ph-fish-bold::before { - content: "\f815"; -} - -.ph-fish-simple-bold::before { - content: "\f816"; -} - -.ph-flag-banner-bold::before { - content: "\f817"; -} - -.ph-flag-bold::before { - content: "\f818"; -} - -.ph-flag-checkered-bold::before { - content: "\f819"; -} - -.ph-flame-bold::before { - content: "\f81a"; -} - -.ph-flashlight-bold::before { - content: "\f81b"; -} - -.ph-flask-bold::before { - content: "\f81c"; -} - -.ph-floppy-disk-back-bold::before { - content: "\f81d"; -} - -.ph-floppy-disk-bold::before { - content: "\f81e"; -} - -.ph-flow-arrow-bold::before { - content: "\f81f"; -} - -.ph-flower-bold::before { - content: "\f820"; -} - -.ph-flower-lotus-bold::before { - content: "\f821"; -} - -.ph-flying-saucer-bold::before { - content: "\f822"; -} - -.ph-folder-bold::before { - content: "\f823"; -} - -.ph-folder-dotted-bold::before { - content: "\f824"; -} - -.ph-folder-lock-bold::before { - content: "\f825"; -} - -.ph-folder-minus-bold::before { - content: "\f826"; -} - -.ph-folder-notch-bold::before { - content: "\f827"; -} - -.ph-folder-notch-minus-bold::before { - content: "\f828"; -} - -.ph-folder-notch-open-bold::before { - content: "\f829"; -} - -.ph-folder-notch-plus-bold::before { - content: "\f82a"; -} - -.ph-folder-open-bold::before { - content: "\f82b"; -} - -.ph-folder-plus-bold::before { - content: "\f82c"; -} - -.ph-folder-simple-bold::before { - content: "\f82d"; -} - -.ph-folder-simple-dotted-bold::before { - content: "\f82e"; -} - -.ph-folder-simple-lock-bold::before { - content: "\f82f"; -} - -.ph-folder-simple-minus-bold::before { - content: "\f830"; -} - -.ph-folder-simple-plus-bold::before { - content: "\f831"; -} - -.ph-folder-simple-star-bold::before { - content: "\f832"; -} - -.ph-folder-simple-user-bold::before { - content: "\f833"; -} - -.ph-folder-star-bold::before { - content: "\f834"; -} - -.ph-folder-user-bold::before { - content: "\f835"; -} - -.ph-folders-bold::before { - content: "\f836"; -} - -.ph-football-bold::before { - content: "\f837"; -} - -.ph-fork-knife-bold::before { - content: "\f838"; -} - -.ph-frame-corners-bold::before { - content: "\f839"; -} - -.ph-framer-logo-bold::before { - content: "\f83a"; -} - -.ph-function-bold::before { - content: "\f83b"; -} - -.ph-funnel-bold::before { - content: "\f83c"; -} - -.ph-funnel-simple-bold::before { - content: "\f83d"; -} - -.ph-game-controller-bold::before { - content: "\f83e"; -} - -.ph-gas-pump-bold::before { - content: "\f83f"; -} - -.ph-gauge-bold::before { - content: "\f840"; -} - -.ph-gear-bold::before { - content: "\f841"; -} - -.ph-gear-six-bold::before { - content: "\f842"; -} - -.ph-gender-female-bold::before { - content: "\f843"; -} - -.ph-gender-intersex-bold::before { - content: "\f844"; -} - -.ph-gender-male-bold::before { - content: "\f845"; -} - -.ph-gender-neuter-bold::before { - content: "\f846"; -} - -.ph-gender-nonbinary-bold::before { - content: "\f847"; -} - -.ph-gender-transgender-bold::before { - content: "\f848"; -} - -.ph-ghost-bold::before { - content: "\f849"; -} - -.ph-gif-bold::before { - content: "\f84a"; -} - -.ph-gift-bold::before { - content: "\f84b"; -} - -.ph-git-branch-bold::before { - content: "\f84c"; -} - -.ph-git-commit-bold::before { - content: "\f84d"; -} - -.ph-git-diff-bold::before { - content: "\f84e"; -} - -.ph-git-fork-bold::before { - content: "\f84f"; -} - -.ph-git-merge-bold::before { - content: "\f850"; -} - -.ph-git-pull-request-bold::before { - content: "\f851"; -} - -.ph-github-logo-bold::before { - content: "\f852"; -} - -.ph-gitlab-logo-bold::before { - content: "\f853"; -} - -.ph-gitlab-logo-simple-bold::before { - content: "\f854"; -} - -.ph-globe-bold::before { - content: "\f855"; -} - -.ph-globe-hemisphere-east-bold::before { - content: "\f856"; -} - -.ph-globe-hemisphere-west-bold::before { - content: "\f857"; -} - -.ph-globe-simple-bold::before { - content: "\f858"; -} - -.ph-globe-stand-bold::before { - content: "\f859"; -} - -.ph-google-chrome-logo-bold::before { - content: "\f85a"; -} - -.ph-google-logo-bold::before { - content: "\f85b"; -} - -.ph-google-photos-logo-bold::before { - content: "\f85c"; -} - -.ph-google-play-logo-bold::before { - content: "\f85d"; -} - -.ph-google-podcasts-logo-bold::before { - content: "\f85e"; -} - -.ph-gradient-bold::before { - content: "\f85f"; -} - -.ph-graduation-cap-bold::before { - content: "\f860"; -} - -.ph-graph-bold::before { - content: "\f861"; -} - -.ph-grid-four-bold::before { - content: "\f862"; -} - -.ph-hamburger-bold::before { - content: "\f863"; -} - -.ph-hand-bold::before { - content: "\f864"; -} - -.ph-hand-eye-bold::before { - content: "\f865"; -} - -.ph-hand-fist-bold::before { - content: "\f866"; -} - -.ph-hand-grabbing-bold::before { - content: "\f867"; -} - -.ph-hand-palm-bold::before { - content: "\f868"; -} - -.ph-hand-pointing-bold::before { - content: "\f869"; -} - -.ph-hand-soap-bold::before { - content: "\f86a"; -} - -.ph-hand-waving-bold::before { - content: "\f86b"; -} - -.ph-handbag-bold::before { - content: "\f86c"; -} - -.ph-handbag-simple-bold::before { - content: "\f86d"; -} - -.ph-hands-clapping-bold::before { - content: "\f86e"; -} - -.ph-handshake-bold::before { - content: "\f86f"; -} - -.ph-hard-drive-bold::before { - content: "\f870"; -} - -.ph-hard-drives-bold::before { - content: "\f871"; -} - -.ph-hash-bold::before { - content: "\f872"; -} - -.ph-hash-straight-bold::before { - content: "\f873"; -} - -.ph-headlights-bold::before { - content: "\f874"; -} - -.ph-headphones-bold::before { - content: "\f875"; -} - -.ph-headset-bold::before { - content: "\f876"; -} - -.ph-heart-bold::before { - content: "\f877"; -} - -.ph-heart-break-bold::before { - content: "\f878"; -} - -.ph-heart-straight-bold::before { - content: "\f879"; -} - -.ph-heart-straight-break-bold::before { - content: "\f87a"; -} - -.ph-heartbeat-bold::before { - content: "\f87b"; -} - -.ph-hexagon-bold::before { - content: "\f87c"; -} - -.ph-highlighter-circle-bold::before { - content: "\f87d"; -} - -.ph-horse-bold::before { - content: "\f87e"; -} - -.ph-hourglass-bold::before { - content: "\f87f"; -} - -.ph-hourglass-high-bold::before { - content: "\f880"; -} - -.ph-hourglass-low-bold::before { - content: "\f881"; -} - -.ph-hourglass-medium-bold::before { - content: "\f882"; -} - -.ph-hourglass-simple-bold::before { - content: "\f883"; -} - -.ph-hourglass-simple-high-bold::before { - content: "\f884"; -} - -.ph-hourglass-simple-low-bold::before { - content: "\f885"; -} - -.ph-hourglass-simple-medium-bold::before { - content: "\f886"; -} - -.ph-house-bold::before { - content: "\f887"; -} - -.ph-house-line-bold::before { - content: "\f888"; -} - -.ph-house-simple-bold::before { - content: "\f889"; -} - -.ph-identification-badge-bold::before { - content: "\f88a"; -} - -.ph-identification-card-bold::before { - content: "\f88b"; -} - -.ph-image-bold::before { - content: "\f88c"; -} - -.ph-image-square-bold::before { - content: "\f88d"; -} - -.ph-infinity-bold::before { - content: "\f88e"; -} - -.ph-info-bold::before { - content: "\f88f"; -} - -.ph-instagram-logo-bold::before { - content: "\f890"; -} - -.ph-intersect-bold::before { - content: "\f891"; -} - -.ph-jeep-bold::before { - content: "\f892"; -} - -.ph-kanban-bold::before { - content: "\f893"; -} - -.ph-key-bold::before { - content: "\f894"; -} - -.ph-key-return-bold::before { - content: "\f895"; -} - -.ph-keyboard-bold::before { - content: "\f896"; -} - -.ph-keyhole-bold::before { - content: "\f897"; -} - -.ph-knife-bold::before { - content: "\f898"; -} - -.ph-ladder-bold::before { - content: "\f899"; -} - -.ph-ladder-simple-bold::before { - content: "\f89a"; -} - -.ph-lamp-bold::before { - content: "\f89b"; -} - -.ph-laptop-bold::before { - content: "\f89c"; -} - -.ph-layout-bold::before { - content: "\f89d"; -} - -.ph-leaf-bold::before { - content: "\f89e"; -} - -.ph-lifebuoy-bold::before { - content: "\f89f"; -} - -.ph-lightbulb-bold::before { - content: "\f8a0"; -} - -.ph-lightbulb-filament-bold::before { - content: "\f8a1"; -} - -.ph-lightning-bold::before { - content: "\f8a2"; -} - -.ph-lightning-slash-bold::before { - content: "\f8a3"; -} - -.ph-line-segment-bold::before { - content: "\f8a4"; -} - -.ph-line-segments-bold::before { - content: "\f8a5"; -} - -.ph-link-bold::before { - content: "\f8a6"; -} - -.ph-link-break-bold::before { - content: "\f8a7"; -} - -.ph-link-simple-bold::before { - content: "\f8a8"; -} - -.ph-link-simple-break-bold::before { - content: "\f8a9"; -} - -.ph-link-simple-horizontal-bold::before { - content: "\f8aa"; -} - -.ph-link-simple-horizontal-break-bold::before { - content: "\f8ab"; -} - -.ph-linkedin-logo-bold::before { - content: "\f8ac"; -} - -.ph-linux-logo-bold::before { - content: "\f8ad"; -} - -.ph-list-bold::before { - content: "\f8ae"; -} - -.ph-list-bullets-bold::before { - content: "\f8af"; -} - -.ph-list-checks-bold::before { - content: "\f8b0"; -} - -.ph-list-dashes-bold::before { - content: "\f8b1"; -} - -.ph-list-numbers-bold::before { - content: "\f8b2"; -} - -.ph-list-plus-bold::before { - content: "\f8b3"; -} - -.ph-lock-bold::before { - content: "\f8b4"; -} - -.ph-lock-key-bold::before { - content: "\f8b5"; -} - -.ph-lock-key-open-bold::before { - content: "\f8b6"; -} - -.ph-lock-laminated-bold::before { - content: "\f8b7"; -} - -.ph-lock-laminated-open-bold::before { - content: "\f8b8"; -} - -.ph-lock-open-bold::before { - content: "\f8b9"; -} - -.ph-lock-simple-bold::before { - content: "\f8ba"; -} - -.ph-lock-simple-open-bold::before { - content: "\f8bb"; -} - -.ph-magic-wand-bold::before { - content: "\f8bc"; -} - -.ph-magnet-bold::before { - content: "\f8bd"; -} - -.ph-magnet-straight-bold::before { - content: "\f8be"; -} - -.ph-magnifying-glass-bold::before { - content: "\f8bf"; -} - -.ph-magnifying-glass-minus-bold::before { - content: "\f8c0"; -} - -.ph-magnifying-glass-plus-bold::before { - content: "\f8c1"; -} - -.ph-map-pin-bold::before { - content: "\f8c2"; -} - -.ph-map-pin-line-bold::before { - content: "\f8c3"; -} - -.ph-map-trifold-bold::before { - content: "\f8c4"; -} - -.ph-marker-circle-bold::before { - content: "\f8c5"; -} - -.ph-martini-bold::before { - content: "\f8c6"; -} - -.ph-mask-happy-bold::before { - content: "\f8c7"; -} - -.ph-mask-sad-bold::before { - content: "\f8c8"; -} - -.ph-math-operations-bold::before { - content: "\f8c9"; -} - -.ph-medal-bold::before { - content: "\f8ca"; -} - -.ph-medium-logo-bold::before { - content: "\f8cb"; -} - -.ph-megaphone-bold::before { - content: "\f8cc"; -} - -.ph-megaphone-simple-bold::before { - content: "\f8cd"; -} - -.ph-messenger-logo-bold::before { - content: "\f8ce"; -} - -.ph-microphone-bold::before { - content: "\f8cf"; -} - -.ph-microphone-slash-bold::before { - content: "\f8d0"; -} - -.ph-microphone-stage-bold::before { - content: "\f8d1"; -} - -.ph-microsoft-excel-logo-bold::before { - content: "\f8d2"; -} - -.ph-microsoft-powerpoint-logo-bold::before { - content: "\f8d3"; -} - -.ph-microsoft-teams-logo-bold::before { - content: "\f8d4"; -} - -.ph-microsoft-word-logo-bold::before { - content: "\f8d5"; -} - -.ph-minus-bold::before { - content: "\f8d6"; -} - -.ph-minus-circle-bold::before { - content: "\f8d7"; -} - -.ph-money-bold::before { - content: "\f8d8"; -} - -.ph-monitor-bold::before { - content: "\f8d9"; -} - -.ph-monitor-play-bold::before { - content: "\f8da"; -} - -.ph-moon-bold::before { - content: "\f8db"; -} - -.ph-moon-stars-bold::before { - content: "\f8dc"; -} - -.ph-mountains-bold::before { - content: "\f8dd"; -} - -.ph-mouse-bold::before { - content: "\f8de"; -} - -.ph-mouse-simple-bold::before { - content: "\f8df"; -} - -.ph-music-note-bold::before { - content: "\f8e0"; -} - -.ph-music-note-simple-bold::before { - content: "\f8e1"; -} - -.ph-music-notes-bold::before { - content: "\f8e2"; -} - -.ph-music-notes-plus-bold::before { - content: "\f8e3"; -} - -.ph-music-notes-simple-bold::before { - content: "\f8e4"; -} - -.ph-navigation-arrow-bold::before { - content: "\f8e5"; -} - -.ph-needle-bold::before { - content: "\f8e6"; -} - -.ph-newspaper-bold::before { - content: "\f8e7"; -} - -.ph-newspaper-clipping-bold::before { - content: "\f8e8"; -} - -.ph-note-blank-bold::before { - content: "\f8e9"; -} - -.ph-note-bold::before { - content: "\f8ea"; -} - -.ph-note-pencil-bold::before { - content: "\f8eb"; -} - -.ph-notebook-bold::before { - content: "\f8ec"; -} - -.ph-notepad-bold::before { - content: "\f8ed"; -} - -.ph-notification-bold::before { - content: "\f8ee"; -} - -.ph-number-circle-eight-bold::before { - content: "\f8ef"; -} - -.ph-number-circle-five-bold::before { - content: "\f8f0"; -} - -.ph-number-circle-four-bold::before { - content: "\f8f1"; -} - -.ph-number-circle-nine-bold::before { - content: "\f8f2"; -} - -.ph-number-circle-one-bold::before { - content: "\f8f3"; -} - -.ph-number-circle-seven-bold::before { - content: "\f8f4"; -} - -.ph-number-circle-six-bold::before { - content: "\f8f5"; -} - -.ph-number-circle-three-bold::before { - content: "\f8f6"; -} - -.ph-number-circle-two-bold::before { - content: "\f8f7"; -} - -.ph-number-circle-zero-bold::before { - content: "\f8f8"; -} - -.ph-number-eight-bold::before { - content: "\f8f9"; -} - -.ph-number-five-bold::before { - content: "\f8fa"; -} - -.ph-number-four-bold::before { - content: "\f8fb"; -} - -.ph-number-nine-bold::before { - content: "\f8fc"; -} - -.ph-number-one-bold::before { - content: "\f8fd"; -} - -.ph-number-seven-bold::before { - content: "\f8fe"; -} - -.ph-number-six-bold::before { - content: "\f8ff"; -} - -.ph-number-square-eight-bold::before { - content: "\f900"; -} - -.ph-number-square-five-bold::before { - content: "\f901"; -} - -.ph-number-square-four-bold::before { - content: "\f902"; -} - -.ph-number-square-nine-bold::before { - content: "\f903"; -} - -.ph-number-square-one-bold::before { - content: "\f904"; -} - -.ph-number-square-seven-bold::before { - content: "\f905"; -} - -.ph-number-square-six-bold::before { - content: "\f906"; -} - -.ph-number-square-three-bold::before { - content: "\f907"; -} - -.ph-number-square-two-bold::before { - content: "\f908"; -} - -.ph-number-square-zero-bold::before { - content: "\f909"; -} - -.ph-number-three-bold::before { - content: "\f90a"; -} - -.ph-number-two-bold::before { - content: "\f90b"; -} - -.ph-number-zero-bold::before { - content: "\f90c"; -} - -.ph-nut-bold::before { - content: "\f90d"; -} - -.ph-ny-times-logo-bold::before { - content: "\f90e"; -} - -.ph-octagon-bold::before { - content: "\f90f"; -} - -.ph-option-bold::before { - content: "\f910"; -} - -.ph-package-bold::before { - content: "\f911"; -} - -.ph-paint-brush-bold::before { - content: "\f912"; -} - -.ph-paint-brush-broad-bold::before { - content: "\f913"; -} - -.ph-paint-brush-household-bold::before { - content: "\f914"; -} - -.ph-paint-bucket-bold::before { - content: "\f915"; -} - -.ph-paint-roller-bold::before { - content: "\f916"; -} - -.ph-palette-bold::before { - content: "\f917"; -} - -.ph-paper-plane-bold::before { - content: "\f918"; -} - -.ph-paper-plane-right-bold::before { - content: "\f919"; -} - -.ph-paper-plane-tilt-bold::before { - content: "\f91a"; -} - -.ph-paperclip-bold::before { - content: "\f91b"; -} - -.ph-paperclip-horizontal-bold::before { - content: "\f91c"; -} - -.ph-parachute-bold::before { - content: "\f91d"; -} - -.ph-password-bold::before { - content: "\f91e"; -} - -.ph-path-bold::before { - content: "\f91f"; -} - -.ph-pause-bold::before { - content: "\f920"; -} - -.ph-pause-circle-bold::before { - content: "\f921"; -} - -.ph-paw-print-bold::before { - content: "\f922"; -} - -.ph-peace-bold::before { - content: "\f923"; -} - -.ph-pen-bold::before { - content: "\f924"; -} - -.ph-pen-nib-bold::before { - content: "\f925"; -} - -.ph-pen-nib-straight-bold::before { - content: "\f926"; -} - -.ph-pencil-bold::before { - content: "\f927"; -} - -.ph-pencil-circle-bold::before { - content: "\f928"; -} - -.ph-pencil-line-bold::before { - content: "\f929"; -} - -.ph-pencil-simple-bold::before { - content: "\f92a"; -} - -.ph-pencil-simple-line-bold::before { - content: "\f92b"; -} - -.ph-percent-bold::before { - content: "\f92c"; -} - -.ph-person-bold::before { - content: "\f92d"; -} - -.ph-person-simple-bold::before { - content: "\f92e"; -} - -.ph-person-simple-run-bold::before { - content: "\f92f"; -} - -.ph-person-simple-walk-bold::before { - content: "\f930"; -} - -.ph-perspective-bold::before { - content: "\f931"; -} - -.ph-phone-bold::before { - content: "\f932"; -} - -.ph-phone-call-bold::before { - content: "\f933"; -} - -.ph-phone-disconnect-bold::before { - content: "\f934"; -} - -.ph-phone-incoming-bold::before { - content: "\f935"; -} - -.ph-phone-outgoing-bold::before { - content: "\f936"; -} - -.ph-phone-slash-bold::before { - content: "\f937"; -} - -.ph-phone-x-bold::before { - content: "\f938"; -} - -.ph-phosphor-logo-bold::before { - content: "\f939"; -} - -.ph-piano-keys-bold::before { - content: "\f93a"; -} - -.ph-picture-in-picture-bold::before { - content: "\f93b"; -} - -.ph-pill-bold::before { - content: "\f93c"; -} - -.ph-pinterest-logo-bold::before { - content: "\f93d"; -} - -.ph-pinwheel-bold::before { - content: "\f93e"; -} - -.ph-pizza-bold::before { - content: "\f93f"; -} - -.ph-placeholder-bold::before { - content: "\f940"; -} - -.ph-planet-bold::before { - content: "\f941"; -} - -.ph-play-bold::before { - content: "\f942"; -} - -.ph-play-circle-bold::before { - content: "\f943"; -} - -.ph-playlist-bold::before { - content: "\f944"; -} - -.ph-plug-bold::before { - content: "\f945"; -} - -.ph-plugs-bold::before { - content: "\f946"; -} - -.ph-plugs-connected-bold::before { - content: "\f947"; -} - -.ph-plus-bold::before { - content: "\f948"; -} - -.ph-plus-circle-bold::before { - content: "\f949"; -} - -.ph-plus-minus-bold::before { - content: "\f94a"; -} - -.ph-poker-chip-bold::before { - content: "\f94b"; -} - -.ph-police-car-bold::before { - content: "\f94c"; -} - -.ph-polygon-bold::before { - content: "\f94d"; -} - -.ph-popcorn-bold::before { - content: "\f94e"; -} - -.ph-power-bold::before { - content: "\f94f"; -} - -.ph-prescription-bold::before { - content: "\f950"; -} - -.ph-presentation-bold::before { - content: "\f951"; -} - -.ph-presentation-chart-bold::before { - content: "\f952"; -} - -.ph-printer-bold::before { - content: "\f953"; -} - -.ph-prohibit-bold::before { - content: "\f954"; -} - -.ph-prohibit-inset-bold::before { - content: "\f955"; -} - -.ph-projector-screen-bold::before { - content: "\f956"; -} - -.ph-projector-screen-chart-bold::before { - content: "\f957"; -} - -.ph-push-pin-bold::before { - content: "\f958"; -} - -.ph-push-pin-simple-bold::before { - content: "\f959"; -} - -.ph-push-pin-simple-slash-bold::before { - content: "\f95a"; -} - -.ph-push-pin-slash-bold::before { - content: "\f95b"; -} - -.ph-puzzle-piece-bold::before { - content: "\f95c"; -} - -.ph-qr-code-bold::before { - content: "\f95d"; -} - -.ph-question-bold::before { - content: "\f95e"; -} - -.ph-queue-bold::before { - content: "\f95f"; -} - -.ph-quotes-bold::before { - content: "\f960"; -} - -.ph-radical-bold::before { - content: "\f961"; -} - -.ph-radio-bold::before { - content: "\f962"; -} - -.ph-radio-button-bold::before { - content: "\f963"; -} - -.ph-rainbow-bold::before { - content: "\f964"; -} - -.ph-rainbow-cloud-bold::before { - content: "\f965"; -} - -.ph-receipt-bold::before { - content: "\f966"; -} - -.ph-record-bold::before { - content: "\f967"; -} - -.ph-rectangle-bold::before { - content: "\f968"; -} - -.ph-recycle-bold::before { - content: "\f969"; -} - -.ph-reddit-logo-bold::before { - content: "\f96a"; -} - -.ph-repeat-bold::before { - content: "\f96b"; -} - -.ph-repeat-once-bold::before { - content: "\f96c"; -} - -.ph-rewind-bold::before { - content: "\f96d"; -} - -.ph-rewind-circle-bold::before { - content: "\f96e"; -} - -.ph-robot-bold::before { - content: "\f96f"; -} - -.ph-rocket-bold::before { - content: "\f970"; -} - -.ph-rocket-launch-bold::before { - content: "\f971"; -} - -.ph-rows-bold::before { - content: "\f972"; -} - -.ph-rss-bold::before { - content: "\f973"; -} - -.ph-rss-simple-bold::before { - content: "\f974"; -} - -.ph-rug-bold::before { - content: "\f975"; -} - -.ph-ruler-bold::before { - content: "\f976"; -} - -.ph-scales-bold::before { - content: "\f977"; -} - -.ph-scan-bold::before { - content: "\f978"; -} - -.ph-scissors-bold::before { - content: "\f979"; -} - -.ph-screencast-bold::before { - content: "\f97a"; -} - -.ph-scribble-loop-bold::before { - content: "\f97b"; -} - -.ph-scroll-bold::before { - content: "\f97c"; -} - -.ph-selection-all-bold::before { - content: "\f97d"; -} - -.ph-selection-background-bold::before { - content: "\f97e"; -} - -.ph-selection-bold::before { - content: "\f97f"; -} - -.ph-selection-foreground-bold::before { - content: "\f980"; -} - -.ph-selection-inverse-bold::before { - content: "\f981"; -} - -.ph-selection-plus-bold::before { - content: "\f982"; -} - -.ph-selection-slash-bold::before { - content: "\f983"; -} - -.ph-share-bold::before { - content: "\f984"; -} - -.ph-share-network-bold::before { - content: "\f985"; -} - -.ph-shield-bold::before { - content: "\f986"; -} - -.ph-shield-check-bold::before { - content: "\f987"; -} - -.ph-shield-checkered-bold::before { - content: "\f988"; -} - -.ph-shield-chevron-bold::before { - content: "\f989"; -} - -.ph-shield-plus-bold::before { - content: "\f98a"; -} - -.ph-shield-slash-bold::before { - content: "\f98b"; -} - -.ph-shield-star-bold::before { - content: "\f98c"; -} - -.ph-shield-warning-bold::before { - content: "\f98d"; -} - -.ph-shopping-bag-bold::before { - content: "\f98e"; -} - -.ph-shopping-bag-open-bold::before { - content: "\f98f"; -} - -.ph-shopping-cart-bold::before { - content: "\f990"; -} - -.ph-shopping-cart-simple-bold::before { - content: "\f991"; -} - -.ph-shower-bold::before { - content: "\f992"; -} - -.ph-shuffle-angular-bold::before { - content: "\f993"; -} - -.ph-shuffle-bold::before { - content: "\f994"; -} - -.ph-shuffle-simple-bold::before { - content: "\f995"; -} - -.ph-sidebar-bold::before { - content: "\f996"; -} - -.ph-sidebar-simple-bold::before { - content: "\f997"; -} - -.ph-sign-in-bold::before { - content: "\f998"; -} - -.ph-sign-out-bold::before { - content: "\f999"; -} - -.ph-signpost-bold::before { - content: "\f99a"; -} - -.ph-sim-card-bold::before { - content: "\f99b"; -} - -.ph-sketch-logo-bold::before { - content: "\f99c"; -} - -.ph-skip-back-bold::before { - content: "\f99d"; -} - -.ph-skip-back-circle-bold::before { - content: "\f99e"; -} - -.ph-skip-forward-bold::before { - content: "\f99f"; -} - -.ph-skip-forward-circle-bold::before { - content: "\f9a0"; -} - -.ph-skull-bold::before { - content: "\f9a1"; -} - -.ph-slack-logo-bold::before { - content: "\f9a2"; -} - -.ph-sliders-bold::before { - content: "\f9a3"; -} - -.ph-sliders-horizontal-bold::before { - content: "\f9a4"; -} - -.ph-smiley-blank-bold::before { - content: "\f9a5"; -} - -.ph-smiley-bold::before { - content: "\f9a6"; -} - -.ph-smiley-meh-bold::before { - content: "\f9a7"; -} - -.ph-smiley-nervous-bold::before { - content: "\f9a8"; -} - -.ph-smiley-sad-bold::before { - content: "\f9a9"; -} - -.ph-smiley-sticker-bold::before { - content: "\f9aa"; -} - -.ph-smiley-wink-bold::before { - content: "\f9ab"; -} - -.ph-smiley-x-eyes-bold::before { - content: "\f9ac"; -} - -.ph-snapchat-logo-bold::before { - content: "\f9ad"; -} - -.ph-snowflake-bold::before { - content: "\f9ae"; -} - -.ph-soccer-ball-bold::before { - content: "\f9af"; -} - -.ph-sort-ascending-bold::before { - content: "\f9b0"; -} - -.ph-sort-descending-bold::before { - content: "\f9b1"; -} - -.ph-spade-bold::before { - content: "\f9b2"; -} - -.ph-sparkle-bold::before { - content: "\f9b3"; -} - -.ph-speaker-high-bold::before { - content: "\f9b4"; -} - -.ph-speaker-low-bold::before { - content: "\f9b5"; -} - -.ph-speaker-none-bold::before { - content: "\f9b6"; -} - -.ph-speaker-simple-high-bold::before { - content: "\f9b7"; -} - -.ph-speaker-simple-low-bold::before { - content: "\f9b8"; -} - -.ph-speaker-simple-none-bold::before { - content: "\f9b9"; -} - -.ph-speaker-simple-slash-bold::before { - content: "\f9ba"; -} - -.ph-speaker-simple-x-bold::before { - content: "\f9bb"; -} - -.ph-speaker-slash-bold::before { - content: "\f9bc"; -} - -.ph-speaker-x-bold::before { - content: "\f9bd"; -} - -.ph-spinner-bold::before { - content: "\f9be"; -} - -.ph-spinner-gap-bold::before { - content: "\f9bf"; -} - -.ph-spiral-bold::before { - content: "\f9c0"; -} - -.ph-spotify-logo-bold::before { - content: "\f9c1"; -} - -.ph-square-bold::before { - content: "\f9c2"; -} - -.ph-square-half-bold::before { - content: "\f9c3"; -} - -.ph-square-half-bottom-bold::before { - content: "\f9c4"; -} - -.ph-square-logo-bold::before { - content: "\f9c5"; -} - -.ph-squares-four-bold::before { - content: "\f9c6"; -} - -.ph-stack-bold::before { - content: "\f9c7"; -} - -.ph-stack-overflow-logo-bold::before { - content: "\f9c8"; -} - -.ph-stack-simple-bold::before { - content: "\f9c9"; -} - -.ph-stamp-bold::before { - content: "\f9ca"; -} - -.ph-star-bold::before { - content: "\f9cb"; -} - -.ph-star-four-bold::before { - content: "\f9cc"; -} - -.ph-star-half-bold::before { - content: "\f9cd"; -} - -.ph-sticker-bold::before { - content: "\f9ce"; -} - -.ph-stop-bold::before { - content: "\f9cf"; -} - -.ph-stop-circle-bold::before { - content: "\f9d0"; -} - -.ph-storefront-bold::before { - content: "\f9d1"; -} - -.ph-strategy-bold::before { - content: "\f9d2"; -} - -.ph-stripe-logo-bold::before { - content: "\f9d3"; -} - -.ph-student-bold::before { - content: "\f9d4"; -} - -.ph-suitcase-bold::before { - content: "\f9d5"; -} - -.ph-suitcase-simple-bold::before { - content: "\f9d6"; -} - -.ph-sun-bold::before { - content: "\f9d7"; -} - -.ph-sun-dim-bold::before { - content: "\f9d8"; -} - -.ph-sun-horizon-bold::before { - content: "\f9d9"; -} - -.ph-sunglasses-bold::before { - content: "\f9da"; -} - -.ph-swap-bold::before { - content: "\f9db"; -} - -.ph-swatches-bold::before { - content: "\f9dc"; -} - -.ph-sword-bold::before { - content: "\f9dd"; -} - -.ph-syringe-bold::before { - content: "\f9de"; -} - -.ph-t-shirt-bold::before { - content: "\f9df"; -} - -.ph-table-bold::before { - content: "\f9e0"; -} - -.ph-tabs-bold::before { - content: "\f9e1"; -} - -.ph-tag-bold::before { - content: "\f9e2"; -} - -.ph-tag-chevron-bold::before { - content: "\f9e3"; -} - -.ph-tag-simple-bold::before { - content: "\f9e4"; -} - -.ph-target-bold::before { - content: "\f9e5"; -} - -.ph-taxi-bold::before { - content: "\f9e6"; -} - -.ph-telegram-logo-bold::before { - content: "\f9e7"; -} - -.ph-television-bold::before { - content: "\f9e8"; -} - -.ph-television-simple-bold::before { - content: "\f9e9"; -} - -.ph-tennis-ball-bold::before { - content: "\f9ea"; -} - -.ph-terminal-bold::before { - content: "\f9eb"; -} - -.ph-terminal-window-bold::before { - content: "\f9ec"; -} - -.ph-test-tube-bold::before { - content: "\f9ed"; -} - -.ph-text-aa-bold::before { - content: "\f9ee"; -} - -.ph-text-align-center-bold::before { - content: "\f9ef"; -} - -.ph-text-align-justify-bold::before { - content: "\f9f0"; -} - -.ph-text-align-left-bold::before { - content: "\f9f1"; -} - -.ph-text-align-right-bold::before { - content: "\f9f2"; -} - -.ph-text-bolder-bold::before { - content: "\f9f3"; -} - -.ph-text-h-bold::before { - content: "\f9f4"; -} - -.ph-text-h-five-bold::before { - content: "\f9f5"; -} - -.ph-text-h-four-bold::before { - content: "\f9f6"; -} - -.ph-text-h-one-bold::before { - content: "\f9f7"; -} - -.ph-text-h-six-bold::before { - content: "\f9f8"; -} - -.ph-text-h-three-bold::before { - content: "\f9f9"; -} - -.ph-text-h-two-bold::before { - content: "\f9fa"; -} - -.ph-text-indent-bold::before { - content: "\f9fb"; -} - -.ph-text-italic-bold::before { - content: "\f9fc"; -} - -.ph-text-outdent-bold::before { - content: "\f9fd"; -} - -.ph-text-strikethrough-bold::before { - content: "\f9fe"; -} - -.ph-text-t-bold::before { - content: "\f9ff"; -} - -.ph-text-underline-bold::before { - content: "\fa00"; -} - -.ph-textbox-bold::before { - content: "\fa01"; -} - -.ph-thermometer-bold::before { - content: "\fa02"; -} - -.ph-thermometer-cold-bold::before { - content: "\fa03"; -} - -.ph-thermometer-hot-bold::before { - content: "\fa04"; -} - -.ph-thermometer-simple-bold::before { - content: "\fa05"; -} - -.ph-thumbs-down-bold::before { - content: "\fa06"; -} - -.ph-thumbs-up-bold::before { - content: "\fa07"; -} - -.ph-ticket-bold::before { - content: "\fa08"; -} - -.ph-tiktok-logo-bold::before { - content: "\fa09"; -} - -.ph-timer-bold::before { - content: "\fa0a"; -} - -.ph-toggle-left-bold::before { - content: "\fa0b"; -} - -.ph-toggle-right-bold::before { - content: "\fa0c"; -} - -.ph-toilet-bold::before { - content: "\fa0d"; -} - -.ph-toilet-paper-bold::before { - content: "\fa0e"; -} - -.ph-tote-bold::before { - content: "\fa0f"; -} - -.ph-tote-simple-bold::before { - content: "\fa10"; -} - -.ph-trademark-registered-bold::before { - content: "\fa11"; -} - -.ph-traffic-cone-bold::before { - content: "\fa12"; -} - -.ph-traffic-sign-bold::before { - content: "\fa13"; -} - -.ph-traffic-signal-bold::before { - content: "\fa14"; -} - -.ph-train-bold::before { - content: "\fa15"; -} - -.ph-train-regional-bold::before { - content: "\fa16"; -} - -.ph-train-simple-bold::before { - content: "\fa17"; -} - -.ph-translate-bold::before { - content: "\fa18"; -} - -.ph-trash-bold::before { - content: "\fa19"; -} - -.ph-trash-simple-bold::before { - content: "\fa1a"; -} - -.ph-tray-bold::before { - content: "\fa1b"; -} - -.ph-tree-bold::before { - content: "\fa1c"; -} - -.ph-tree-evergreen-bold::before { - content: "\fa1d"; -} - -.ph-tree-structure-bold::before { - content: "\fa1e"; -} - -.ph-trend-down-bold::before { - content: "\fa1f"; -} - -.ph-trend-up-bold::before { - content: "\fa20"; -} - -.ph-triangle-bold::before { - content: "\fa21"; -} - -.ph-trophy-bold::before { - content: "\fa22"; -} - -.ph-truck-bold::before { - content: "\fa23"; -} - -.ph-twitch-logo-bold::before { - content: "\fa24"; -} - -.ph-twitter-logo-bold::before { - content: "\fa25"; -} - -.ph-umbrella-bold::before { - content: "\fa26"; -} - -.ph-umbrella-simple-bold::before { - content: "\fa27"; -} - -.ph-upload-bold::before { - content: "\fa28"; -} - -.ph-upload-simple-bold::before { - content: "\fa29"; -} - -.ph-user-bold::before { - content: "\fa2a"; -} - -.ph-user-circle-bold::before { - content: "\fa2b"; -} - -.ph-user-circle-gear-bold::before { - content: "\fa2c"; -} - -.ph-user-circle-minus-bold::before { - content: "\fa2d"; -} - -.ph-user-circle-plus-bold::before { - content: "\fa2e"; -} - -.ph-user-focus-bold::before { - content: "\fa2f"; -} - -.ph-user-gear-bold::before { - content: "\fa30"; -} - -.ph-user-list-bold::before { - content: "\fa31"; -} - -.ph-user-minus-bold::before { - content: "\fa32"; -} - -.ph-user-plus-bold::before { - content: "\fa33"; -} - -.ph-user-rectangle-bold::before { - content: "\fa34"; -} - -.ph-user-square-bold::before { - content: "\fa35"; -} - -.ph-user-switch-bold::before { - content: "\fa36"; -} - -.ph-users-bold::before { - content: "\fa37"; -} - -.ph-users-four-bold::before { - content: "\fa38"; -} - -.ph-users-three-bold::before { - content: "\fa39"; -} - -.ph-vault-bold::before { - content: "\fa3a"; -} - -.ph-vibrate-bold::before { - content: "\fa3b"; -} - -.ph-video-camera-bold::before { - content: "\fa3c"; -} - -.ph-video-camera-slash-bold::before { - content: "\fa3d"; -} - -.ph-vignette-bold::before { - content: "\fa3e"; -} - -.ph-voicemail-bold::before { - content: "\fa3f"; -} - -.ph-volleyball-bold::before { - content: "\fa40"; -} - -.ph-wall-bold::before { - content: "\fa41"; -} - -.ph-wallet-bold::before { - content: "\fa42"; -} - -.ph-warning-bold::before { - content: "\fa43"; -} - -.ph-warning-circle-bold::before { - content: "\fa44"; -} - -.ph-warning-octagon-bold::before { - content: "\fa45"; -} - -.ph-watch-bold::before { - content: "\fa46"; -} - -.ph-wave-sawtooth-bold::before { - content: "\fa47"; -} - -.ph-wave-sine-bold::before { - content: "\fa48"; -} - -.ph-wave-square-bold::before { - content: "\fa49"; -} - -.ph-wave-triangle-bold::before { - content: "\fa4a"; -} - -.ph-waves-bold::before { - content: "\fa4b"; -} - -.ph-webcam-bold::before { - content: "\fa4c"; -} - -.ph-whatsapp-logo-bold::before { - content: "\fa4d"; -} - -.ph-wheelchair-bold::before { - content: "\fa4e"; -} - -.ph-wifi-high-bold::before { - content: "\fa4f"; -} - -.ph-wifi-low-bold::before { - content: "\fa50"; -} - -.ph-wifi-medium-bold::before { - content: "\fa51"; -} - -.ph-wifi-none-bold::before { - content: "\fa52"; -} - -.ph-wifi-slash-bold::before { - content: "\fa53"; -} - -.ph-wifi-x-bold::before { - content: "\fa54"; -} - -.ph-wind-bold::before { - content: "\fa55"; -} - -.ph-windows-logo-bold::before { - content: "\fa56"; -} - -.ph-wine-bold::before { - content: "\fa57"; -} - -.ph-wrench-bold::before { - content: "\fa58"; -} - -.ph-x-bold::before { - content: "\fa59"; -} - -.ph-x-circle-bold::before { - content: "\fa5a"; -} - -.ph-x-square-bold::before { - content: "\fa5b"; -} - -.ph-yin-yang-bold::before { - content: "\fa5c"; -} - -.ph-youtube-logo-bold::before { - content: "\fa5d"; -} - -.ph-activity-fill::before { - content: "\fa5e"; -} - -.ph-address-book-fill::before { - content: "\fa5f"; -} - -.ph-airplane-fill::before { - content: "\fa60"; -} - -.ph-airplane-in-flight-fill::before { - content: "\fa61"; -} - -.ph-airplane-landing-fill::before { - content: "\fa62"; -} - -.ph-airplane-takeoff-fill::before { - content: "\fa63"; -} - -.ph-airplane-tilt-fill::before { - content: "\fa64"; -} - -.ph-airplay-fill::before { - content: "\fa65"; -} - -.ph-alarm-fill::before { - content: "\fa66"; -} - -.ph-alien-fill::before { - content: "\fa67"; -} - -.ph-align-bottom-fill::before { - content: "\fa68"; -} - -.ph-align-bottom-simple-fill::before { - content: "\fa69"; -} - -.ph-align-center-horizontal-fill::before { - content: "\fa6a"; -} - -.ph-align-center-horizontal-simple-fill::before { - content: "\fa6b"; -} - -.ph-align-center-vertical-fill::before { - content: "\fa6c"; -} - -.ph-align-center-vertical-simple-fill::before { - content: "\fa6d"; -} - -.ph-align-left-fill::before { - content: "\fa6e"; -} - -.ph-align-left-simple-fill::before { - content: "\fa6f"; -} - -.ph-align-right-fill::before { - content: "\fa70"; -} - -.ph-align-right-simple-fill::before { - content: "\fa71"; -} - -.ph-align-top-fill::before { - content: "\fa72"; -} - -.ph-align-top-simple-fill::before { - content: "\fa73"; -} - -.ph-anchor-fill::before { - content: "\fa74"; -} - -.ph-anchor-simple-fill::before { - content: "\fa75"; -} - -.ph-android-logo-fill::before { - content: "\fa76"; -} - -.ph-angular-logo-fill::before { - content: "\fa77"; -} - -.ph-aperture-fill::before { - content: "\fa78"; -} - -.ph-app-store-logo-fill::before { - content: "\fa79"; -} - -.ph-app-window-fill::before { - content: "\fa7a"; -} - -.ph-apple-logo-fill::before { - content: "\fa7b"; -} - -.ph-apple-podcasts-logo-fill::before { - content: "\fa7c"; -} - -.ph-archive-box-fill::before { - content: "\fa7d"; -} - -.ph-archive-fill::before { - content: "\fa7e"; -} - -.ph-archive-tray-fill::before { - content: "\fa7f"; -} - -.ph-armchair-fill::before { - content: "\fa80"; -} - -.ph-arrow-arc-left-fill::before { - content: "\fa81"; -} - -.ph-arrow-arc-right-fill::before { - content: "\fa82"; -} - -.ph-arrow-bend-double-up-left-fill::before { - content: "\fa83"; -} - -.ph-arrow-bend-double-up-right-fill::before { - content: "\fa84"; -} - -.ph-arrow-bend-down-left-fill::before { - content: "\fa85"; -} - -.ph-arrow-bend-down-right-fill::before { - content: "\fa86"; -} - -.ph-arrow-bend-left-down-fill::before { - content: "\fa87"; -} - -.ph-arrow-bend-left-up-fill::before { - content: "\fa88"; -} - -.ph-arrow-bend-right-down-fill::before { - content: "\fa89"; -} - -.ph-arrow-bend-right-up-fill::before { - content: "\fa8a"; -} - -.ph-arrow-bend-up-left-fill::before { - content: "\fa8b"; -} - -.ph-arrow-bend-up-right-fill::before { - content: "\fa8c"; -} - -.ph-arrow-circle-down-fill::before { - content: "\fa8d"; -} - -.ph-arrow-circle-down-left-fill::before { - content: "\fa8e"; -} - -.ph-arrow-circle-down-right-fill::before { - content: "\fa8f"; -} - -.ph-arrow-circle-left-fill::before { - content: "\fa90"; -} - -.ph-arrow-circle-right-fill::before { - content: "\fa91"; -} - -.ph-arrow-circle-up-fill::before { - content: "\fa92"; -} - -.ph-arrow-circle-up-left-fill::before { - content: "\fa93"; -} - -.ph-arrow-circle-up-right-fill::before { - content: "\fa94"; -} - -.ph-arrow-clockwise-fill::before { - content: "\fa95"; -} - -.ph-arrow-counter-clockwise-fill::before { - content: "\fa96"; -} - -.ph-arrow-down-fill::before { - content: "\fa97"; -} - -.ph-arrow-down-left-fill::before { - content: "\fa98"; -} - -.ph-arrow-down-right-fill::before { - content: "\fa99"; -} - -.ph-arrow-elbow-down-left-fill::before { - content: "\fa9a"; -} - -.ph-arrow-elbow-down-right-fill::before { - content: "\fa9b"; -} - -.ph-arrow-elbow-left-down-fill::before { - content: "\fa9c"; -} - -.ph-arrow-elbow-left-fill::before { - content: "\fa9d"; -} - -.ph-arrow-elbow-left-up-fill::before { - content: "\fa9e"; -} - -.ph-arrow-elbow-right-down-fill::before { - content: "\fa9f"; -} - -.ph-arrow-elbow-right-fill::before { - content: "\faa0"; -} - -.ph-arrow-elbow-right-up-fill::before { - content: "\faa1"; -} - -.ph-arrow-elbow-up-left-fill::before { - content: "\faa2"; -} - -.ph-arrow-elbow-up-right-fill::before { - content: "\faa3"; -} - -.ph-arrow-fat-down-fill::before { - content: "\faa4"; -} - -.ph-arrow-fat-left-fill::before { - content: "\faa5"; -} - -.ph-arrow-fat-line-down-fill::before { - content: "\faa6"; -} - -.ph-arrow-fat-line-left-fill::before { - content: "\faa7"; -} - -.ph-arrow-fat-line-right-fill::before { - content: "\faa8"; -} - -.ph-arrow-fat-line-up-fill::before { - content: "\faa9"; -} - -.ph-arrow-fat-lines-down-fill::before { - content: "\faaa"; -} - -.ph-arrow-fat-lines-left-fill::before { - content: "\faab"; -} - -.ph-arrow-fat-lines-right-fill::before { - content: "\faac"; -} - -.ph-arrow-fat-lines-up-fill::before { - content: "\faad"; -} - -.ph-arrow-fat-right-fill::before { - content: "\faae"; -} - -.ph-arrow-fat-up-fill::before { - content: "\faaf"; -} - -.ph-arrow-left-fill::before { - content: "\fab0"; -} - -.ph-arrow-line-down-fill::before { - content: "\fab1"; -} - -.ph-arrow-line-down-left-fill::before { - content: "\fab2"; -} - -.ph-arrow-line-down-right-fill::before { - content: "\fab3"; -} - -.ph-arrow-line-left-fill::before { - content: "\fab4"; -} - -.ph-arrow-line-right-fill::before { - content: "\fab5"; -} - -.ph-arrow-line-up-fill::before { - content: "\fab6"; -} - -.ph-arrow-line-up-left-fill::before { - content: "\fab7"; -} - -.ph-arrow-line-up-right-fill::before { - content: "\fab8"; -} - -.ph-arrow-right-fill::before { - content: "\fab9"; -} - -.ph-arrow-square-down-fill::before { - content: "\faba"; -} - -.ph-arrow-square-down-left-fill::before { - content: "\fabb"; -} - -.ph-arrow-square-down-right-fill::before { - content: "\fabc"; -} - -.ph-arrow-square-in-fill::before { - content: "\fabd"; -} - -.ph-arrow-square-left-fill::before { - content: "\fabe"; -} - -.ph-arrow-square-out-fill::before { - content: "\fabf"; -} - -.ph-arrow-square-right-fill::before { - content: "\fac0"; -} - -.ph-arrow-square-up-fill::before { - content: "\fac1"; -} - -.ph-arrow-square-up-left-fill::before { - content: "\fac2"; -} - -.ph-arrow-square-up-right-fill::before { - content: "\fac3"; -} - -.ph-arrow-u-down-left-fill::before { - content: "\fac4"; -} - -.ph-arrow-u-down-right-fill::before { - content: "\fac5"; -} - -.ph-arrow-u-left-down-fill::before { - content: "\fac6"; -} - -.ph-arrow-u-left-up-fill::before { - content: "\fac7"; -} - -.ph-arrow-u-right-down-fill::before { - content: "\fac8"; -} - -.ph-arrow-u-right-up-fill::before { - content: "\fac9"; -} - -.ph-arrow-u-up-left-fill::before { - content: "\faca"; -} - -.ph-arrow-u-up-right-fill::before { - content: "\facb"; -} - -.ph-arrow-up-fill::before { - content: "\facc"; -} - -.ph-arrow-up-left-fill::before { - content: "\facd"; -} - -.ph-arrow-up-right-fill::before { - content: "\face"; -} - -.ph-arrows-clockwise-fill::before { - content: "\facf"; -} - -.ph-arrows-counter-clockwise-fill::before { - content: "\fad0"; -} - -.ph-arrows-down-up-fill::before { - content: "\fad1"; -} - -.ph-arrows-horizontal-fill::before { - content: "\fad2"; -} - -.ph-arrows-in-cardinal-fill::before { - content: "\fad3"; -} - -.ph-arrows-in-fill::before { - content: "\fad4"; -} - -.ph-arrows-in-line-horizontal-fill::before { - content: "\fad5"; -} - -.ph-arrows-in-line-vertical-fill::before { - content: "\fad6"; -} - -.ph-arrows-in-simple-fill::before { - content: "\fad7"; -} - -.ph-arrows-left-right-fill::before { - content: "\fad8"; -} - -.ph-arrows-out-cardinal-fill::before { - content: "\fad9"; -} - -.ph-arrows-out-fill::before { - content: "\fada"; -} - -.ph-arrows-out-line-horizontal-fill::before { - content: "\fadb"; -} - -.ph-arrows-out-line-vertical-fill::before { - content: "\fadc"; -} - -.ph-arrows-out-simple-fill::before { - content: "\fadd"; -} - -.ph-arrows-vertical-fill::before { - content: "\fade"; -} - -.ph-article-fill::before { - content: "\fadf"; -} - -.ph-article-medium-fill::before { - content: "\fae0"; -} - -.ph-article-ny-times-fill::before { - content: "\fae1"; -} - -.ph-asterisk-fill::before { - content: "\fae2"; -} - -.ph-asterisk-simple-fill::before { - content: "\fae3"; -} - -.ph-at-fill::before { - content: "\fae4"; -} - -.ph-atom-fill::before { - content: "\fae5"; -} - -.ph-baby-fill::before { - content: "\fae6"; -} - -.ph-backpack-fill::before { - content: "\fae7"; -} - -.ph-backspace-fill::before { - content: "\fae8"; -} - -.ph-bag-fill::before { - content: "\fae9"; -} - -.ph-bag-simple-fill::before { - content: "\faea"; -} - -.ph-balloon-fill::before { - content: "\faeb"; -} - -.ph-bandaids-fill::before { - content: "\faec"; -} - -.ph-bank-fill::before { - content: "\faed"; -} - -.ph-barbell-fill::before { - content: "\faee"; -} - -.ph-barcode-fill::before { - content: "\faef"; -} - -.ph-barricade-fill::before { - content: "\faf0"; -} - -.ph-baseball-fill::before { - content: "\faf1"; -} - -.ph-basketball-fill::before { - content: "\faf2"; -} - -.ph-bathtub-fill::before { - content: "\faf3"; -} - -.ph-battery-charging-fill::before { - content: "\faf4"; -} - -.ph-battery-charging-vertical-fill::before { - content: "\faf5"; -} - -.ph-battery-empty-fill::before { - content: "\faf6"; -} - -.ph-battery-full-fill::before { - content: "\faf7"; -} - -.ph-battery-high-fill::before { - content: "\faf8"; -} - -.ph-battery-low-fill::before { - content: "\faf9"; -} - -.ph-battery-medium-fill::before { - content: "\fafa"; -} - -.ph-battery-plus-fill::before { - content: "\fafb"; -} - -.ph-battery-warning-fill::before { - content: "\fafc"; -} - -.ph-battery-warning-vertical-fill::before { - content: "\fafd"; -} - -.ph-bed-fill::before { - content: "\fafe"; -} - -.ph-beer-bottle-fill::before { - content: "\faff"; -} - -.ph-behance-logo-fill::before { - content: "\fb00"; -} - -.ph-bell-fill::before { - content: "\fb01"; -} - -.ph-bell-ringing-fill::before { - content: "\fb02"; -} - -.ph-bell-simple-fill::before { - content: "\fb03"; -} - -.ph-bell-simple-ringing-fill::before { - content: "\fb04"; -} - -.ph-bell-simple-slash-fill::before { - content: "\fb05"; -} - -.ph-bell-simple-z-fill::before { - content: "\fb06"; -} - -.ph-bell-slash-fill::before { - content: "\fb07"; -} - -.ph-bell-z-fill::before { - content: "\fb08"; -} - -.ph-bezier-curve-fill::before { - content: "\fb09"; -} - -.ph-bicycle-fill::before { - content: "\fb0a"; -} - -.ph-binoculars-fill::before { - content: "\fb0b"; -} - -.ph-bird-fill::before { - content: "\fb0c"; -} - -.ph-bluetooth-connected-fill::before { - content: "\fb0d"; -} - -.ph-bluetooth-fill::before { - content: "\fb0e"; -} - -.ph-bluetooth-slash-fill::before { - content: "\fb0f"; -} - -.ph-bluetooth-x-fill::before { - content: "\fb10"; -} - -.ph-boat-fill::before { - content: "\fb11"; -} - -.ph-book-bookmark-fill::before { - content: "\fb12"; -} - -.ph-book-fill::before { - content: "\fb13"; -} - -.ph-book-open-fill::before { - content: "\fb14"; -} - -.ph-bookmark-fill::before { - content: "\fb15"; -} - -.ph-bookmark-simple-fill::before { - content: "\fb16"; -} - -.ph-bookmarks-fill::before { - content: "\fb17"; -} - -.ph-bookmarks-simple-fill::before { - content: "\fb18"; -} - -.ph-books-fill::before { - content: "\fb19"; -} - -.ph-bounding-box-fill::before { - content: "\fb1a"; -} - -.ph-brackets-angle-fill::before { - content: "\fb1b"; -} - -.ph-brackets-curly-fill::before { - content: "\fb1c"; -} - -.ph-brackets-round-fill::before { - content: "\fb1d"; -} - -.ph-brackets-square-fill::before { - content: "\fb1e"; -} - -.ph-brain-fill::before { - content: "\fb1f"; -} - -.ph-brandy-fill::before { - content: "\fb20"; -} - -.ph-briefcase-fill::before { - content: "\fb21"; -} - -.ph-briefcase-metal-fill::before { - content: "\fb22"; -} - -.ph-broadcast-fill::before { - content: "\fb23"; -} - -.ph-browser-fill::before { - content: "\fb24"; -} - -.ph-browsers-fill::before { - content: "\fb25"; -} - -.ph-bug-beetle-fill::before { - content: "\fb26"; -} - -.ph-bug-droid-fill::before { - content: "\fb27"; -} - -.ph-bug-fill::before { - content: "\fb28"; -} - -.ph-buildings-fill::before { - content: "\fb29"; -} - -.ph-bus-fill::before { - content: "\fb2a"; -} - -.ph-butterfly-fill::before { - content: "\fb2b"; -} - -.ph-cactus-fill::before { - content: "\fb2c"; -} - -.ph-cake-fill::before { - content: "\fb2d"; -} - -.ph-calculator-fill::before { - content: "\fb2e"; -} - -.ph-calendar-blank-fill::before { - content: "\fb2f"; -} - -.ph-calendar-check-fill::before { - content: "\fb30"; -} - -.ph-calendar-fill::before { - content: "\fb31"; -} - -.ph-calendar-plus-fill::before { - content: "\fb32"; -} - -.ph-calendar-x-fill::before { - content: "\fb33"; -} - -.ph-camera-fill::before { - content: "\fb34"; -} - -.ph-camera-rotate-fill::before { - content: "\fb35"; -} - -.ph-camera-slash-fill::before { - content: "\fb36"; -} - -.ph-campfire-fill::before { - content: "\fb37"; -} - -.ph-car-fill::before { - content: "\fb38"; -} - -.ph-car-simple-fill::before { - content: "\fb39"; -} - -.ph-cardholder-fill::before { - content: "\fb3a"; -} - -.ph-cards-fill::before { - content: "\fb3b"; -} - -.ph-caret-circle-double-down-fill::before { - content: "\fb3c"; -} - -.ph-caret-circle-double-left-fill::before { - content: "\fb3d"; -} - -.ph-caret-circle-double-right-fill::before { - content: "\fb3e"; -} - -.ph-caret-circle-double-up-fill::before { - content: "\fb3f"; -} - -.ph-caret-circle-down-fill::before { - content: "\fb40"; -} - -.ph-caret-circle-left-fill::before { - content: "\fb41"; -} - -.ph-caret-circle-right-fill::before { - content: "\fb42"; -} - -.ph-caret-circle-up-fill::before { - content: "\fb43"; -} - -.ph-caret-double-down-fill::before { - content: "\fb44"; -} - -.ph-caret-double-left-fill::before { - content: "\fb45"; -} - -.ph-caret-double-right-fill::before { - content: "\fb46"; -} - -.ph-caret-double-up-fill::before { - content: "\fb47"; -} - -.ph-caret-down-fill::before { - content: "\fb48"; -} - -.ph-caret-left-fill::before { - content: "\fb49"; -} - -.ph-caret-right-fill::before { - content: "\fb4a"; -} - -.ph-caret-up-fill::before { - content: "\fb4b"; -} - -.ph-cat-fill::before { - content: "\fb4c"; -} - -.ph-cell-signal-full-fill::before { - content: "\fb4d"; -} - -.ph-cell-signal-high-fill::before { - content: "\fb4e"; -} - -.ph-cell-signal-low-fill::before { - content: "\fb4f"; -} - -.ph-cell-signal-medium-fill::before { - content: "\fb50"; -} - -.ph-cell-signal-none-fill::before { - content: "\fb51"; -} - -.ph-cell-signal-slash-fill::before { - content: "\fb52"; -} - -.ph-cell-signal-x-fill::before { - content: "\fb53"; -} - -.ph-chalkboard-fill::before { - content: "\fb54"; -} - -.ph-chalkboard-simple-fill::before { - content: "\fb55"; -} - -.ph-chalkboard-teacher-fill::before { - content: "\fb56"; -} - -.ph-chart-bar-fill::before { - content: "\fb57"; -} - -.ph-chart-bar-horizontal-fill::before { - content: "\fb58"; -} - -.ph-chart-line-fill::before { - content: "\fb59"; -} - -.ph-chart-line-up-fill::before { - content: "\fb5a"; -} - -.ph-chart-pie-fill::before { - content: "\fb5b"; -} - -.ph-chart-pie-slice-fill::before { - content: "\fb5c"; -} - -.ph-chat-centered-dots-fill::before { - content: "\fb5d"; -} - -.ph-chat-centered-fill::before { - content: "\fb5e"; -} - -.ph-chat-centered-text-fill::before { - content: "\fb5f"; -} - -.ph-chat-circle-dots-fill::before { - content: "\fb60"; -} - -.ph-chat-circle-fill::before { - content: "\fb61"; -} - -.ph-chat-circle-text-fill::before { - content: "\fb62"; -} - -.ph-chat-dots-fill::before { - content: "\fb63"; -} - -.ph-chat-fill::before { - content: "\fb64"; -} - -.ph-chat-teardrop-dots-fill::before { - content: "\fb65"; -} - -.ph-chat-teardrop-fill::before { - content: "\fb66"; -} - -.ph-chat-teardrop-text-fill::before { - content: "\fb67"; -} - -.ph-chat-text-fill::before { - content: "\fb68"; -} - -.ph-chats-circle-fill::before { - content: "\fb69"; -} - -.ph-chats-fill::before { - content: "\fb6a"; -} - -.ph-chats-teardrop-fill::before { - content: "\fb6b"; -} - -.ph-check-circle-fill::before { - content: "\fb6c"; -} - -.ph-check-fill::before { - content: "\fb6d"; -} - -.ph-check-square-fill::before { - content: "\fb6e"; -} - -.ph-check-square-offset-fill::before { - content: "\fb6f"; -} - -.ph-checks-fill::before { - content: "\fb70"; -} - -.ph-circle-dashed-fill::before { - content: "\fb71"; -} - -.ph-circle-fill::before { - content: "\fb72"; -} - -.ph-circle-half-fill::before { - content: "\fb73"; -} - -.ph-circle-half-tilt-fill::before { - content: "\fb74"; -} - -.ph-circle-notch-fill::before { - content: "\fb75"; -} - -.ph-circle-wavy-check-fill::before { - content: "\fb76"; -} - -.ph-circle-wavy-fill::before { - content: "\fb77"; -} - -.ph-circle-wavy-question-fill::before { - content: "\fb78"; -} - -.ph-circle-wavy-warning-fill::before { - content: "\fb79"; -} - -.ph-circles-four-fill::before { - content: "\fb7a"; -} - -.ph-circles-three-fill::before { - content: "\fb7b"; -} - -.ph-circles-three-plus-fill::before { - content: "\fb7c"; -} - -.ph-clipboard-fill::before { - content: "\fb7d"; -} - -.ph-clipboard-text-fill::before { - content: "\fb7e"; -} - -.ph-clock-afternoon-fill::before { - content: "\fb7f"; -} - -.ph-clock-clockwise-fill::before { - content: "\fb80"; -} - -.ph-clock-counter-clockwise-fill::before { - content: "\fb81"; -} - -.ph-clock-fill::before { - content: "\fb82"; -} - -.ph-closed-captioning-fill::before { - content: "\fb83"; -} - -.ph-cloud-arrow-down-fill::before { - content: "\fb84"; -} - -.ph-cloud-arrow-up-fill::before { - content: "\fb85"; -} - -.ph-cloud-check-fill::before { - content: "\fb86"; -} - -.ph-cloud-fill::before { - content: "\fb87"; -} - -.ph-cloud-fog-fill::before { - content: "\fb88"; -} - -.ph-cloud-lightning-fill::before { - content: "\fb89"; -} - -.ph-cloud-moon-fill::before { - content: "\fb8a"; -} - -.ph-cloud-rain-fill::before { - content: "\fb8b"; -} - -.ph-cloud-slash-fill::before { - content: "\fb8c"; -} - -.ph-cloud-snow-fill::before { - content: "\fb8d"; -} - -.ph-cloud-sun-fill::before { - content: "\fb8e"; -} - -.ph-club-fill::before { - content: "\fb8f"; -} - -.ph-coat-hanger-fill::before { - content: "\fb90"; -} - -.ph-code-fill::before { - content: "\fb91"; -} - -.ph-code-simple-fill::before { - content: "\fb92"; -} - -.ph-codepen-logo-fill::before { - content: "\fb93"; -} - -.ph-codesandbox-logo-fill::before { - content: "\fb94"; -} - -.ph-coffee-fill::before { - content: "\fb95"; -} - -.ph-coin-fill::before { - content: "\fb96"; -} - -.ph-coin-vertical-fill::before { - content: "\fb97"; -} - -.ph-coins-fill::before { - content: "\fb98"; -} - -.ph-columns-fill::before { - content: "\fb99"; -} - -.ph-command-fill::before { - content: "\fb9a"; -} - -.ph-compass-fill::before { - content: "\fb9b"; -} - -.ph-computer-tower-fill::before { - content: "\fb9c"; -} - -.ph-confetti-fill::before { - content: "\fb9d"; -} - -.ph-cookie-fill::before { - content: "\fb9e"; -} - -.ph-cooking-pot-fill::before { - content: "\fb9f"; -} - -.ph-copy-fill::before { - content: "\fba0"; -} - -.ph-copy-simple-fill::before { - content: "\fba1"; -} - -.ph-copyleft-fill::before { - content: "\fba2"; -} - -.ph-copyright-fill::before { - content: "\fba3"; -} - -.ph-corners-in-fill::before { - content: "\fba4"; -} - -.ph-corners-out-fill::before { - content: "\fba5"; -} - -.ph-cpu-fill::before { - content: "\fba6"; -} - -.ph-credit-card-fill::before { - content: "\fba7"; -} - -.ph-crop-fill::before { - content: "\fba8"; -} - -.ph-crosshair-fill::before { - content: "\fba9"; -} - -.ph-crosshair-simple-fill::before { - content: "\fbaa"; -} - -.ph-crown-fill::before { - content: "\fbab"; -} - -.ph-crown-simple-fill::before { - content: "\fbac"; -} - -.ph-cube-fill::before { - content: "\fbad"; -} - -.ph-currency-btc-fill::before { - content: "\fbae"; -} - -.ph-currency-circle-dollar-fill::before { - content: "\fbaf"; -} - -.ph-currency-cny-fill::before { - content: "\fbb0"; -} - -.ph-currency-dollar-fill::before { - content: "\fbb1"; -} - -.ph-currency-dollar-simple-fill::before { - content: "\fbb2"; -} - -.ph-currency-eth-fill::before { - content: "\fbb3"; -} - -.ph-currency-eur-fill::before { - content: "\fbb4"; -} - -.ph-currency-gbp-fill::before { - content: "\fbb5"; -} - -.ph-currency-inr-fill::before { - content: "\fbb6"; -} - -.ph-currency-jpy-fill::before { - content: "\fbb7"; -} - -.ph-currency-krw-fill::before { - content: "\fbb8"; -} - -.ph-currency-kzt-fill::before { - content: "\fbb9"; -} - -.ph-currency-ngn-fill::before { - content: "\fbba"; -} - -.ph-currency-rub-fill::before { - content: "\fbbb"; -} - -.ph-cursor-fill::before { - content: "\fbbc"; -} - -.ph-cursor-text-fill::before { - content: "\fbbd"; -} - -.ph-cylinder-fill::before { - content: "\fbbe"; -} - -.ph-database-fill::before { - content: "\fbbf"; -} - -.ph-desktop-fill::before { - content: "\fbc0"; -} - -.ph-desktop-tower-fill::before { - content: "\fbc1"; -} - -.ph-detective-fill::before { - content: "\fbc2"; -} - -.ph-device-mobile-camera-fill::before { - content: "\fbc3"; -} - -.ph-device-mobile-fill::before { - content: "\fbc4"; -} - -.ph-device-mobile-speaker-fill::before { - content: "\fbc5"; -} - -.ph-device-tablet-camera-fill::before { - content: "\fbc6"; -} - -.ph-device-tablet-fill::before { - content: "\fbc7"; -} - -.ph-device-tablet-speaker-fill::before { - content: "\fbc8"; -} - -.ph-diamond-fill::before { - content: "\fbc9"; -} - -.ph-diamonds-four-fill::before { - content: "\fbca"; -} - -.ph-dice-five-fill::before { - content: "\fbcb"; -} - -.ph-dice-four-fill::before { - content: "\fbcc"; -} - -.ph-dice-one-fill::before { - content: "\fbcd"; -} - -.ph-dice-six-fill::before { - content: "\fbce"; -} - -.ph-dice-three-fill::before { - content: "\fbcf"; -} - -.ph-dice-two-fill::before { - content: "\fbd0"; -} - -.ph-disc-fill::before { - content: "\fbd1"; -} - -.ph-discord-logo-fill::before { - content: "\fbd2"; -} - -.ph-divide-fill::before { - content: "\fbd3"; -} - -.ph-dog-fill::before { - content: "\fbd4"; -} - -.ph-door-fill::before { - content: "\fbd5"; -} - -.ph-dots-nine-fill::before { - content: "\fbd6"; -} - -.ph-dots-six-fill::before { - content: "\fbd7"; -} - -.ph-dots-six-vertical-fill::before { - content: "\fbd8"; -} - -.ph-dots-three-circle-fill::before { - content: "\fbd9"; -} - -.ph-dots-three-circle-vertical-fill::before { - content: "\fbda"; -} - -.ph-dots-three-fill::before { - content: "\fbdb"; -} - -.ph-dots-three-outline-fill::before { - content: "\fbdc"; -} - -.ph-dots-three-outline-vertical-fill::before { - content: "\fbdd"; -} - -.ph-dots-three-vertical-fill::before { - content: "\fbde"; -} - -.ph-download-fill::before { - content: "\fbdf"; -} - -.ph-download-simple-fill::before { - content: "\fbe0"; -} - -.ph-dribbble-logo-fill::before { - content: "\fbe1"; -} - -.ph-drop-fill::before { - content: "\fbe2"; -} - -.ph-drop-half-bottom-fill::before { - content: "\fbe3"; -} - -.ph-drop-half-fill::before { - content: "\fbe4"; -} - -.ph-ear-fill::before { - content: "\fbe5"; -} - -.ph-ear-slash-fill::before { - content: "\fbe6"; -} - -.ph-egg-crack-fill::before { - content: "\fbe7"; -} - -.ph-egg-fill::before { - content: "\fbe8"; -} - -.ph-eject-fill::before { - content: "\fbe9"; -} - -.ph-eject-simple-fill::before { - content: "\fbea"; -} - -.ph-envelope-fill::before { - content: "\fbeb"; -} - -.ph-envelope-open-fill::before { - content: "\fbec"; -} - -.ph-envelope-simple-fill::before { - content: "\fbed"; -} - -.ph-envelope-simple-open-fill::before { - content: "\fbee"; -} - -.ph-equalizer-fill::before { - content: "\fbef"; -} - -.ph-equals-fill::before { - content: "\fbf0"; -} - -.ph-eraser-fill::before { - content: "\fbf1"; -} - -.ph-exam-fill::before { - content: "\fbf2"; -} - -.ph-export-fill::before { - content: "\fbf3"; -} - -.ph-eye-closed-fill::before { - content: "\fbf4"; -} - -.ph-eye-fill::before { - content: "\fbf5"; -} - -.ph-eye-slash-fill::before { - content: "\fbf6"; -} - -.ph-eyedropper-fill::before { - content: "\fbf7"; -} - -.ph-eyedropper-sample-fill::before { - content: "\fbf8"; -} - -.ph-eyeglasses-fill::before { - content: "\fbf9"; -} - -.ph-face-mask-fill::before { - content: "\fbfa"; -} - -.ph-facebook-logo-fill::before { - content: "\fbfb"; -} - -.ph-factory-fill::before { - content: "\fbfc"; -} - -.ph-faders-fill::before { - content: "\fbfd"; -} - -.ph-faders-horizontal-fill::before { - content: "\fbfe"; -} - -.ph-fast-forward-circle-fill::before { - content: "\fbff"; -} - -.ph-fast-forward-fill::before { - content: "\fc00"; -} - -.ph-figma-logo-fill::before { - content: "\fc01"; -} - -.ph-file-arrow-down-fill::before { - content: "\fc02"; -} - -.ph-file-arrow-up-fill::before { - content: "\fc03"; -} - -.ph-file-audio-fill::before { - content: "\fc04"; -} - -.ph-file-cloud-fill::before { - content: "\fc05"; -} - -.ph-file-code-fill::before { - content: "\fc06"; -} - -.ph-file-css-fill::before { - content: "\fc07"; -} - -.ph-file-csv-fill::before { - content: "\fc08"; -} - -.ph-file-doc-fill::before { - content: "\fc09"; -} - -.ph-file-dotted-fill::before { - content: "\fc0a"; -} - -.ph-file-fill::before { - content: "\fc0b"; -} - -.ph-file-html-fill::before { - content: "\fc0c"; -} - -.ph-file-image-fill::before { - content: "\fc0d"; -} - -.ph-file-jpg-fill::before { - content: "\fc0e"; -} - -.ph-file-js-fill::before { - content: "\fc0f"; -} - -.ph-file-jsx-fill::before { - content: "\fc10"; -} - -.ph-file-lock-fill::before { - content: "\fc11"; -} - -.ph-file-minus-fill::before { - content: "\fc12"; -} - -.ph-file-pdf-fill::before { - content: "\fc13"; -} - -.ph-file-plus-fill::before { - content: "\fc14"; -} - -.ph-file-png-fill::before { - content: "\fc15"; -} - -.ph-file-ppt-fill::before { - content: "\fc16"; -} - -.ph-file-rs-fill::before { - content: "\fc17"; -} - -.ph-file-search-fill::before { - content: "\fc18"; -} - -.ph-file-text-fill::before { - content: "\fc19"; -} - -.ph-file-ts-fill::before { - content: "\fc1a"; -} - -.ph-file-tsx-fill::before { - content: "\fc1b"; -} - -.ph-file-video-fill::before { - content: "\fc1c"; -} - -.ph-file-vue-fill::before { - content: "\fc1d"; -} - -.ph-file-x-fill::before { - content: "\fc1e"; -} - -.ph-file-xls-fill::before { - content: "\fc1f"; -} - -.ph-file-zip-fill::before { - content: "\fc20"; -} - -.ph-files-fill::before { - content: "\fc21"; -} - -.ph-film-script-fill::before { - content: "\fc22"; -} - -.ph-film-slate-fill::before { - content: "\fc23"; -} - -.ph-film-strip-fill::before { - content: "\fc24"; -} - -.ph-fingerprint-fill::before { - content: "\fc25"; -} - -.ph-fingerprint-simple-fill::before { - content: "\fc26"; -} - -.ph-finn-the-human-fill::before { - content: "\fc27"; -} - -.ph-fire-fill::before { - content: "\fc28"; -} - -.ph-fire-simple-fill::before { - content: "\fc29"; -} - -.ph-first-aid-fill::before { - content: "\fc2a"; -} - -.ph-first-aid-kit-fill::before { - content: "\fc2b"; -} - -.ph-fish-fill::before { - content: "\fc2c"; -} - -.ph-fish-simple-fill::before { - content: "\fc2d"; -} - -.ph-flag-banner-fill::before { - content: "\fc2e"; -} - -.ph-flag-checkered-fill::before { - content: "\fc2f"; -} - -.ph-flag-fill::before { - content: "\fc30"; -} - -.ph-flame-fill::before { - content: "\fc31"; -} - -.ph-flashlight-fill::before { - content: "\fc32"; -} - -.ph-flask-fill::before { - content: "\fc33"; -} - -.ph-floppy-disk-back-fill::before { - content: "\fc34"; -} - -.ph-floppy-disk-fill::before { - content: "\fc35"; -} - -.ph-flow-arrow-fill::before { - content: "\fc36"; -} - -.ph-flower-fill::before { - content: "\fc37"; -} - -.ph-flower-lotus-fill::before { - content: "\fc38"; -} - -.ph-flying-saucer-fill::before { - content: "\fc39"; -} - -.ph-folder-dotted-fill::before { - content: "\fc3a"; -} - -.ph-folder-fill::before { - content: "\fc3b"; -} - -.ph-folder-lock-fill::before { - content: "\fc3c"; -} - -.ph-folder-minus-fill::before { - content: "\fc3d"; -} - -.ph-folder-notch-fill::before { - content: "\fc3e"; -} - -.ph-folder-notch-minus-fill::before { - content: "\fc3f"; -} - -.ph-folder-notch-open-fill::before { - content: "\fc40"; -} - -.ph-folder-notch-plus-fill::before { - content: "\fc41"; -} - -.ph-folder-open-fill::before { - content: "\fc42"; -} - -.ph-folder-plus-fill::before { - content: "\fc43"; -} - -.ph-folder-simple-dotted-fill::before { - content: "\fc44"; -} - -.ph-folder-simple-fill::before { - content: "\fc45"; -} - -.ph-folder-simple-lock-fill::before { - content: "\fc46"; -} - -.ph-folder-simple-minus-fill::before { - content: "\fc47"; -} - -.ph-folder-simple-plus-fill::before { - content: "\fc48"; -} - -.ph-folder-simple-star-fill::before { - content: "\fc49"; -} - -.ph-folder-simple-user-fill::before { - content: "\fc4a"; -} - -.ph-folder-star-fill::before { - content: "\fc4b"; -} - -.ph-folder-user-fill::before { - content: "\fc4c"; -} - -.ph-folders-fill::before { - content: "\fc4d"; -} - -.ph-football-fill::before { - content: "\fc4e"; -} - -.ph-fork-knife-fill::before { - content: "\fc4f"; -} - -.ph-frame-corners-fill::before { - content: "\fc50"; -} - -.ph-framer-logo-fill::before { - content: "\fc51"; -} - -.ph-function-fill::before { - content: "\fc52"; -} - -.ph-funnel-fill::before { - content: "\fc53"; -} - -.ph-funnel-simple-fill::before { - content: "\fc54"; -} - -.ph-game-controller-fill::before { - content: "\fc55"; -} - -.ph-gas-pump-fill::before { - content: "\fc56"; -} - -.ph-gauge-fill::before { - content: "\fc57"; -} - -.ph-gear-fill::before { - content: "\fc58"; -} - -.ph-gear-six-fill::before { - content: "\fc59"; -} - -.ph-gender-female-fill::before { - content: "\fc5a"; -} - -.ph-gender-intersex-fill::before { - content: "\fc5b"; -} - -.ph-gender-male-fill::before { - content: "\fc5c"; -} - -.ph-gender-neuter-fill::before { - content: "\fc5d"; -} - -.ph-gender-nonbinary-fill::before { - content: "\fc5e"; -} - -.ph-gender-transgender-fill::before { - content: "\fc5f"; -} - -.ph-ghost-fill::before { - content: "\fc60"; -} - -.ph-gif-fill::before { - content: "\fc61"; -} - -.ph-gift-fill::before { - content: "\fc62"; -} - -.ph-git-branch-fill::before { - content: "\fc63"; -} - -.ph-git-commit-fill::before { - content: "\fc64"; -} - -.ph-git-diff-fill::before { - content: "\fc65"; -} - -.ph-git-fork-fill::before { - content: "\fc66"; -} - -.ph-git-merge-fill::before { - content: "\fc67"; -} - -.ph-git-pull-request-fill::before { - content: "\fc68"; -} - -.ph-github-logo-fill::before { - content: "\fc69"; -} - -.ph-gitlab-logo-fill::before { - content: "\fc6a"; -} - -.ph-gitlab-logo-simple-fill::before { - content: "\fc6b"; -} - -.ph-globe-fill::before { - content: "\fc6c"; -} - -.ph-globe-hemisphere-east-fill::before { - content: "\fc6d"; -} - -.ph-globe-hemisphere-west-fill::before { - content: "\fc6e"; -} - -.ph-globe-simple-fill::before { - content: "\fc6f"; -} - -.ph-globe-stand-fill::before { - content: "\fc70"; -} - -.ph-google-chrome-logo-fill::before { - content: "\fc71"; -} - -.ph-google-logo-fill::before { - content: "\fc72"; -} - -.ph-google-photos-logo-fill::before { - content: "\fc73"; -} - -.ph-google-play-logo-fill::before { - content: "\fc74"; -} - -.ph-google-podcasts-logo-fill::before { - content: "\fc75"; -} - -.ph-gradient-fill::before { - content: "\fc76"; -} - -.ph-graduation-cap-fill::before { - content: "\fc77"; -} - -.ph-graph-fill::before { - content: "\fc78"; -} - -.ph-grid-four-fill::before { - content: "\fc79"; -} - -.ph-hamburger-fill::before { - content: "\fc7a"; -} - -.ph-hand-eye-fill::before { - content: "\fc7b"; -} - -.ph-hand-fill::before { - content: "\fc7c"; -} - -.ph-hand-fist-fill::before { - content: "\fc7d"; -} - -.ph-hand-grabbing-fill::before { - content: "\fc7e"; -} - -.ph-hand-palm-fill::before { - content: "\fc7f"; -} - -.ph-hand-pointing-fill::before { - content: "\fc80"; -} - -.ph-hand-soap-fill::before { - content: "\fc81"; -} - -.ph-hand-waving-fill::before { - content: "\fc82"; -} - -.ph-handbag-fill::before { - content: "\fc83"; -} - -.ph-handbag-simple-fill::before { - content: "\fc84"; -} - -.ph-hands-clapping-fill::before { - content: "\fc85"; -} - -.ph-handshake-fill::before { - content: "\fc86"; -} - -.ph-hard-drive-fill::before { - content: "\fc87"; -} - -.ph-hard-drives-fill::before { - content: "\fc88"; -} - -.ph-hash-fill::before { - content: "\fc89"; -} - -.ph-hash-straight-fill::before { - content: "\fc8a"; -} - -.ph-headlights-fill::before { - content: "\fc8b"; -} - -.ph-headphones-fill::before { - content: "\fc8c"; -} - -.ph-headset-fill::before { - content: "\fc8d"; -} - -.ph-heart-break-fill::before { - content: "\fc8e"; -} - -.ph-heart-fill::before { - content: "\fc8f"; -} - -.ph-heart-straight-break-fill::before { - content: "\fc90"; -} - -.ph-heart-straight-fill::before { - content: "\fc91"; -} - -.ph-heartbeat-fill::before { - content: "\fc92"; -} - -.ph-hexagon-fill::before { - content: "\fc93"; -} - -.ph-highlighter-circle-fill::before { - content: "\fc94"; -} - -.ph-horse-fill::before { - content: "\fc95"; -} - -.ph-hourglass-fill::before { - content: "\fc96"; -} - -.ph-hourglass-high-fill::before { - content: "\fc97"; -} - -.ph-hourglass-low-fill::before { - content: "\fc98"; -} - -.ph-hourglass-medium-fill::before { - content: "\fc99"; -} - -.ph-hourglass-simple-fill::before { - content: "\fc9a"; -} - -.ph-hourglass-simple-high-fill::before { - content: "\fc9b"; -} - -.ph-hourglass-simple-low-fill::before { - content: "\fc9c"; -} - -.ph-hourglass-simple-medium-fill::before { - content: "\fc9d"; -} - -.ph-house-fill::before { - content: "\fc9e"; -} - -.ph-house-line-fill::before { - content: "\fc9f"; -} - -.ph-house-simple-fill::before { - content: "\fca0"; -} - -.ph-identification-badge-fill::before { - content: "\fca1"; -} - -.ph-identification-card-fill::before { - content: "\fca2"; -} - -.ph-image-fill::before { - content: "\fca3"; -} - -.ph-image-square-fill::before { - content: "\fca4"; -} - -.ph-infinity-fill::before { - content: "\fca5"; -} - -.ph-info-fill::before { - content: "\fca6"; -} - -.ph-instagram-logo-fill::before { - content: "\fca7"; -} - -.ph-intersect-fill::before { - content: "\fca8"; -} - -.ph-jeep-fill::before { - content: "\fca9"; -} - -.ph-kanban-fill::before { - content: "\fcaa"; -} - -.ph-key-fill::before { - content: "\fcab"; -} - -.ph-key-return-fill::before { - content: "\fcac"; -} - -.ph-keyboard-fill::before { - content: "\fcad"; -} - -.ph-keyhole-fill::before { - content: "\fcae"; -} - -.ph-knife-fill::before { - content: "\fcaf"; -} - -.ph-ladder-fill::before { - content: "\fcb0"; -} - -.ph-ladder-simple-fill::before { - content: "\fcb1"; -} - -.ph-lamp-fill::before { - content: "\fcb2"; -} - -.ph-laptop-fill::before { - content: "\fcb3"; -} - -.ph-layout-fill::before { - content: "\fcb4"; -} - -.ph-leaf-fill::before { - content: "\fcb5"; -} - -.ph-lifebuoy-fill::before { - content: "\fcb6"; -} - -.ph-lightbulb-filament-fill::before { - content: "\fcb7"; -} - -.ph-lightbulb-fill::before { - content: "\fcb8"; -} - -.ph-lightning-fill::before { - content: "\fcb9"; -} - -.ph-lightning-slash-fill::before { - content: "\fcba"; -} - -.ph-line-segment-fill::before { - content: "\fcbb"; -} - -.ph-line-segments-fill::before { - content: "\fcbc"; -} - -.ph-link-break-fill::before { - content: "\fcbd"; -} - -.ph-link-fill::before { - content: "\fcbe"; -} - -.ph-link-simple-break-fill::before { - content: "\fcbf"; -} - -.ph-link-simple-fill::before { - content: "\fcc0"; -} - -.ph-link-simple-horizontal-break-fill::before { - content: "\fcc1"; -} - -.ph-link-simple-horizontal-fill::before { - content: "\fcc2"; -} - -.ph-linkedin-logo-fill::before { - content: "\fcc3"; -} - -.ph-linux-logo-fill::before { - content: "\fcc4"; -} - -.ph-list-bullets-fill::before { - content: "\fcc5"; -} - -.ph-list-checks-fill::before { - content: "\fcc6"; -} - -.ph-list-dashes-fill::before { - content: "\fcc7"; -} - -.ph-list-fill::before { - content: "\fcc8"; -} - -.ph-list-numbers-fill::before { - content: "\fcc9"; -} - -.ph-list-plus-fill::before { - content: "\fcca"; -} - -.ph-lock-fill::before { - content: "\fccb"; -} - -.ph-lock-key-fill::before { - content: "\fccc"; -} - -.ph-lock-key-open-fill::before { - content: "\fccd"; -} - -.ph-lock-laminated-fill::before { - content: "\fcce"; -} - -.ph-lock-laminated-open-fill::before { - content: "\fccf"; -} - -.ph-lock-open-fill::before { - content: "\fcd0"; -} - -.ph-lock-simple-fill::before { - content: "\fcd1"; -} - -.ph-lock-simple-open-fill::before { - content: "\fcd2"; -} - -.ph-magic-wand-fill::before { - content: "\fcd3"; -} - -.ph-magnet-fill::before { - content: "\fcd4"; -} - -.ph-magnet-straight-fill::before { - content: "\fcd5"; -} - -.ph-magnifying-glass-fill::before { - content: "\fcd6"; -} - -.ph-magnifying-glass-minus-fill::before { - content: "\fcd7"; -} - -.ph-magnifying-glass-plus-fill::before { - content: "\fcd8"; -} - -.ph-map-pin-fill::before { - content: "\fcd9"; -} - -.ph-map-pin-line-fill::before { - content: "\fcda"; -} - -.ph-map-trifold-fill::before { - content: "\fcdb"; -} - -.ph-marker-circle-fill::before { - content: "\fcdc"; -} - -.ph-martini-fill::before { - content: "\fcdd"; -} - -.ph-mask-happy-fill::before { - content: "\fcde"; -} - -.ph-mask-sad-fill::before { - content: "\fcdf"; -} - -.ph-math-operations-fill::before { - content: "\fce0"; -} - -.ph-medal-fill::before { - content: "\fce1"; -} - -.ph-medium-logo-fill::before { - content: "\fce2"; -} - -.ph-megaphone-fill::before { - content: "\fce3"; -} - -.ph-megaphone-simple-fill::before { - content: "\fce4"; -} - -.ph-messenger-logo-fill::before { - content: "\fce5"; -} - -.ph-microphone-fill::before { - content: "\fce6"; -} - -.ph-microphone-slash-fill::before { - content: "\fce7"; -} - -.ph-microphone-stage-fill::before { - content: "\fce8"; -} - -.ph-microsoft-excel-logo-fill::before { - content: "\fce9"; -} - -.ph-microsoft-powerpoint-logo-fill::before { - content: "\fcea"; -} - -.ph-microsoft-teams-logo-fill::before { - content: "\fceb"; -} - -.ph-microsoft-word-logo-fill::before { - content: "\fcec"; -} - -.ph-minus-circle-fill::before { - content: "\fced"; -} - -.ph-minus-fill::before { - content: "\fcee"; -} - -.ph-money-fill::before { - content: "\fcef"; -} - -.ph-monitor-fill::before { - content: "\fcf0"; -} - -.ph-monitor-play-fill::before { - content: "\fcf1"; -} - -.ph-moon-fill::before { - content: "\fcf2"; -} - -.ph-moon-stars-fill::before { - content: "\fcf3"; -} - -.ph-mountains-fill::before { - content: "\fcf4"; -} - -.ph-mouse-fill::before { - content: "\fcf5"; -} - -.ph-mouse-simple-fill::before { - content: "\fcf6"; -} - -.ph-music-note-fill::before { - content: "\fcf7"; -} - -.ph-music-note-simple-fill::before { - content: "\fcf8"; -} - -.ph-music-notes-fill::before { - content: "\fcf9"; -} - -.ph-music-notes-plus-fill::before { - content: "\fcfa"; -} - -.ph-music-notes-simple-fill::before { - content: "\fcfb"; -} - -.ph-navigation-arrow-fill::before { - content: "\fcfc"; -} - -.ph-needle-fill::before { - content: "\fcfd"; -} - -.ph-newspaper-clipping-fill::before { - content: "\fcfe"; -} - -.ph-newspaper-fill::before { - content: "\fcff"; -} - -.ph-note-blank-fill::before { - content: "\fd00"; -} - -.ph-note-fill::before { - content: "\fd01"; -} - -.ph-note-pencil-fill::before { - content: "\fd02"; -} - -.ph-notebook-fill::before { - content: "\fd03"; -} - -.ph-notepad-fill::before { - content: "\fd04"; -} - -.ph-notification-fill::before { - content: "\fd05"; -} - -.ph-number-circle-eight-fill::before { - content: "\fd06"; -} - -.ph-number-circle-five-fill::before { - content: "\fd07"; -} - -.ph-number-circle-four-fill::before { - content: "\fd08"; -} - -.ph-number-circle-nine-fill::before { - content: "\fd09"; -} - -.ph-number-circle-one-fill::before { - content: "\fd0a"; -} - -.ph-number-circle-seven-fill::before { - content: "\fd0b"; -} - -.ph-number-circle-six-fill::before { - content: "\fd0c"; -} - -.ph-number-circle-three-fill::before { - content: "\fd0d"; -} - -.ph-number-circle-two-fill::before { - content: "\fd0e"; -} - -.ph-number-circle-zero-fill::before { - content: "\fd0f"; -} - -.ph-number-eight-fill::before { - content: "\fd10"; -} - -.ph-number-five-fill::before { - content: "\fd11"; -} - -.ph-number-four-fill::before { - content: "\fd12"; -} - -.ph-number-nine-fill::before { - content: "\fd13"; -} - -.ph-number-one-fill::before { - content: "\fd14"; -} - -.ph-number-seven-fill::before { - content: "\fd15"; -} - -.ph-number-six-fill::before { - content: "\fd16"; -} - -.ph-number-square-eight-fill::before { - content: "\fd17"; -} - -.ph-number-square-five-fill::before { - content: "\fd18"; -} - -.ph-number-square-four-fill::before { - content: "\fd19"; -} - -.ph-number-square-nine-fill::before { - content: "\fd1a"; -} - -.ph-number-square-one-fill::before { - content: "\fd1b"; -} - -.ph-number-square-seven-fill::before { - content: "\fd1c"; -} - -.ph-number-square-six-fill::before { - content: "\fd1d"; -} - -.ph-number-square-three-fill::before { - content: "\fd1e"; -} - -.ph-number-square-two-fill::before { - content: "\fd1f"; -} - -.ph-number-square-zero-fill::before { - content: "\fd20"; -} - -.ph-number-three-fill::before { - content: "\fd21"; -} - -.ph-number-two-fill::before { - content: "\fd22"; -} - -.ph-number-zero-fill::before { - content: "\fd23"; -} - -.ph-nut-fill::before { - content: "\fd24"; -} - -.ph-ny-times-logo-fill::before { - content: "\fd25"; -} - -.ph-octagon-fill::before { - content: "\fd26"; -} - -.ph-option-fill::before { - content: "\fd27"; -} - -.ph-package-fill::before { - content: "\fd28"; -} - -.ph-paint-brush-broad-fill::before { - content: "\fd29"; -} - -.ph-paint-brush-fill::before { - content: "\fd2a"; -} - -.ph-paint-brush-household-fill::before { - content: "\fd2b"; -} - -.ph-paint-bucket-fill::before { - content: "\fd2c"; -} - -.ph-paint-roller-fill::before { - content: "\fd2d"; -} - -.ph-palette-fill::before { - content: "\fd2e"; -} - -.ph-paper-plane-fill::before { - content: "\fd2f"; -} - -.ph-paper-plane-right-fill::before { - content: "\fd30"; -} - -.ph-paper-plane-tilt-fill::before { - content: "\fd31"; -} - -.ph-paperclip-fill::before { - content: "\fd32"; -} - -.ph-paperclip-horizontal-fill::before { - content: "\fd33"; -} - -.ph-parachute-fill::before { - content: "\fd34"; -} - -.ph-password-fill::before { - content: "\fd35"; -} - -.ph-path-fill::before { - content: "\fd36"; -} - -.ph-pause-circle-fill::before { - content: "\fd37"; -} - -.ph-pause-fill::before { - content: "\fd38"; -} - -.ph-paw-print-fill::before { - content: "\fd39"; -} - -.ph-peace-fill::before { - content: "\fd3a"; -} - -.ph-pen-fill::before { - content: "\fd3b"; -} - -.ph-pen-nib-fill::before { - content: "\fd3c"; -} - -.ph-pen-nib-straight-fill::before { - content: "\fd3d"; -} - -.ph-pencil-circle-fill::before { - content: "\fd3e"; -} - -.ph-pencil-fill::before { - content: "\fd3f"; -} - -.ph-pencil-line-fill::before { - content: "\fd40"; -} - -.ph-pencil-simple-fill::before { - content: "\fd41"; -} - -.ph-pencil-simple-line-fill::before { - content: "\fd42"; -} - -.ph-percent-fill::before { - content: "\fd43"; -} - -.ph-person-fill::before { - content: "\fd44"; -} - -.ph-person-simple-fill::before { - content: "\fd45"; -} - -.ph-person-simple-run-fill::before { - content: "\fd46"; -} - -.ph-person-simple-walk-fill::before { - content: "\fd47"; -} - -.ph-perspective-fill::before { - content: "\fd48"; -} - -.ph-phone-call-fill::before { - content: "\fd49"; -} - -.ph-phone-disconnect-fill::before { - content: "\fd4a"; -} - -.ph-phone-fill::before { - content: "\fd4b"; -} - -.ph-phone-incoming-fill::before { - content: "\fd4c"; -} - -.ph-phone-outgoing-fill::before { - content: "\fd4d"; -} - -.ph-phone-slash-fill::before { - content: "\fd4e"; -} - -.ph-phone-x-fill::before { - content: "\fd4f"; -} - -.ph-phosphor-logo-fill::before { - content: "\fd50"; -} - -.ph-piano-keys-fill::before { - content: "\fd51"; -} - -.ph-picture-in-picture-fill::before { - content: "\fd52"; -} - -.ph-pill-fill::before { - content: "\fd53"; -} - -.ph-pinterest-logo-fill::before { - content: "\fd54"; -} - -.ph-pinwheel-fill::before { - content: "\fd55"; -} - -.ph-pizza-fill::before { - content: "\fd56"; -} - -.ph-placeholder-fill::before { - content: "\fd57"; -} - -.ph-planet-fill::before { - content: "\fd58"; -} - -.ph-play-circle-fill::before { - content: "\fd59"; -} - -.ph-play-fill::before { - content: "\fd5a"; -} - -.ph-playlist-fill::before { - content: "\fd5b"; -} - -.ph-plug-fill::before { - content: "\fd5c"; -} - -.ph-plugs-connected-fill::before { - content: "\fd5d"; -} - -.ph-plugs-fill::before { - content: "\fd5e"; -} - -.ph-plus-circle-fill::before { - content: "\fd5f"; -} - -.ph-plus-fill::before { - content: "\fd60"; -} - -.ph-plus-minus-fill::before { - content: "\fd61"; -} - -.ph-poker-chip-fill::before { - content: "\fd62"; -} - -.ph-police-car-fill::before { - content: "\fd63"; -} - -.ph-polygon-fill::before { - content: "\fd64"; -} - -.ph-popcorn-fill::before { - content: "\fd65"; -} - -.ph-power-fill::before { - content: "\fd66"; -} - -.ph-prescription-fill::before { - content: "\fd67"; -} - -.ph-presentation-chart-fill::before { - content: "\fd68"; -} - -.ph-presentation-fill::before { - content: "\fd69"; -} - -.ph-printer-fill::before { - content: "\fd6a"; -} - -.ph-prohibit-fill::before { - content: "\fd6b"; -} - -.ph-prohibit-inset-fill::before { - content: "\fd6c"; -} - -.ph-projector-screen-chart-fill::before { - content: "\fd6d"; -} - -.ph-projector-screen-fill::before { - content: "\fd6e"; -} - -.ph-push-pin-fill::before { - content: "\fd6f"; -} - -.ph-push-pin-simple-fill::before { - content: "\fd70"; -} - -.ph-push-pin-simple-slash-fill::before { - content: "\fd71"; -} - -.ph-push-pin-slash-fill::before { - content: "\fd72"; -} - -.ph-puzzle-piece-fill::before { - content: "\fd73"; -} - -.ph-qr-code-fill::before { - content: "\fd74"; -} - -.ph-question-fill::before { - content: "\fd75"; -} - -.ph-queue-fill::before { - content: "\fd76"; -} - -.ph-quotes-fill::before { - content: "\fd77"; -} - -.ph-radical-fill::before { - content: "\fd78"; -} - -.ph-radio-button-fill::before { - content: "\fd79"; -} - -.ph-radio-fill::before { - content: "\fd7a"; -} - -.ph-rainbow-cloud-fill::before { - content: "\fd7b"; -} - -.ph-rainbow-fill::before { - content: "\fd7c"; -} - -.ph-receipt-fill::before { - content: "\fd7d"; -} - -.ph-record-fill::before { - content: "\fd7e"; -} - -.ph-rectangle-fill::before { - content: "\fd7f"; -} - -.ph-recycle-fill::before { - content: "\fd80"; -} - -.ph-reddit-logo-fill::before { - content: "\fd81"; -} - -.ph-repeat-fill::before { - content: "\fd82"; -} - -.ph-repeat-once-fill::before { - content: "\fd83"; -} - -.ph-rewind-circle-fill::before { - content: "\fd84"; -} - -.ph-rewind-fill::before { - content: "\fd85"; -} - -.ph-robot-fill::before { - content: "\fd86"; -} - -.ph-rocket-fill::before { - content: "\fd87"; -} - -.ph-rocket-launch-fill::before { - content: "\fd88"; -} - -.ph-rows-fill::before { - content: "\fd89"; -} - -.ph-rss-fill::before { - content: "\fd8a"; -} - -.ph-rss-simple-fill::before { - content: "\fd8b"; -} - -.ph-rug-fill::before { - content: "\fd8c"; -} - -.ph-ruler-fill::before { - content: "\fd8d"; -} - -.ph-scales-fill::before { - content: "\fd8e"; -} - -.ph-scan-fill::before { - content: "\fd8f"; -} - -.ph-scissors-fill::before { - content: "\fd90"; -} - -.ph-screencast-fill::before { - content: "\fd91"; -} - -.ph-scribble-loop-fill::before { - content: "\fd92"; -} - -.ph-scroll-fill::before { - content: "\fd93"; -} - -.ph-selection-all-fill::before { - content: "\fd94"; -} - -.ph-selection-background-fill::before { - content: "\fd95"; -} - -.ph-selection-fill::before { - content: "\fd96"; -} - -.ph-selection-foreground-fill::before { - content: "\fd97"; -} - -.ph-selection-inverse-fill::before { - content: "\fd98"; -} - -.ph-selection-plus-fill::before { - content: "\fd99"; -} - -.ph-selection-slash-fill::before { - content: "\fd9a"; -} - -.ph-share-fill::before { - content: "\fd9b"; -} - -.ph-share-network-fill::before { - content: "\fd9c"; -} - -.ph-shield-check-fill::before { - content: "\fd9d"; -} - -.ph-shield-checkered-fill::before { - content: "\fd9e"; -} - -.ph-shield-chevron-fill::before { - content: "\fd9f"; -} - -.ph-shield-fill::before { - content: "\fda0"; -} - -.ph-shield-plus-fill::before { - content: "\fda1"; -} - -.ph-shield-slash-fill::before { - content: "\fda2"; -} - -.ph-shield-star-fill::before { - content: "\fda3"; -} - -.ph-shield-warning-fill::before { - content: "\fda4"; -} - -.ph-shopping-bag-fill::before { - content: "\fda5"; -} - -.ph-shopping-bag-open-fill::before { - content: "\fda6"; -} - -.ph-shopping-cart-fill::before { - content: "\fda7"; -} - -.ph-shopping-cart-simple-fill::before { - content: "\fda8"; -} - -.ph-shower-fill::before { - content: "\fda9"; -} - -.ph-shuffle-angular-fill::before { - content: "\fdaa"; -} - -.ph-shuffle-fill::before { - content: "\fdab"; -} - -.ph-shuffle-simple-fill::before { - content: "\fdac"; -} - -.ph-sidebar-fill::before { - content: "\fdad"; -} - -.ph-sidebar-simple-fill::before { - content: "\fdae"; -} - -.ph-sign-in-fill::before { - content: "\fdaf"; -} - -.ph-sign-out-fill::before { - content: "\fdb0"; -} - -.ph-signpost-fill::before { - content: "\fdb1"; -} - -.ph-sim-card-fill::before { - content: "\fdb2"; -} - -.ph-sketch-logo-fill::before { - content: "\fdb3"; -} - -.ph-skip-back-circle-fill::before { - content: "\fdb4"; -} - -.ph-skip-back-fill::before { - content: "\fdb5"; -} - -.ph-skip-forward-circle-fill::before { - content: "\fdb6"; -} - -.ph-skip-forward-fill::before { - content: "\fdb7"; -} - -.ph-skull-fill::before { - content: "\fdb8"; -} - -.ph-slack-logo-fill::before { - content: "\fdb9"; -} - -.ph-sliders-fill::before { - content: "\fdba"; -} - -.ph-sliders-horizontal-fill::before { - content: "\fdbb"; -} - -.ph-smiley-blank-fill::before { - content: "\fdbc"; -} - -.ph-smiley-fill::before { - content: "\fdbd"; -} - -.ph-smiley-meh-fill::before { - content: "\fdbe"; -} - -.ph-smiley-nervous-fill::before { - content: "\fdbf"; -} - -.ph-smiley-sad-fill::before { - content: "\fdc0"; -} - -.ph-smiley-sticker-fill::before { - content: "\fdc1"; -} - -.ph-smiley-wink-fill::before { - content: "\fdc2"; -} - -.ph-smiley-x-eyes-fill::before { - content: "\fdc3"; -} - -.ph-snapchat-logo-fill::before { - content: "\fdc4"; -} - -.ph-snowflake-fill::before { - content: "\fdc5"; -} - -.ph-soccer-ball-fill::before { - content: "\fdc6"; -} - -.ph-sort-ascending-fill::before { - content: "\fdc7"; -} - -.ph-sort-descending-fill::before { - content: "\fdc8"; -} - -.ph-spade-fill::before { - content: "\fdc9"; -} - -.ph-sparkle-fill::before { - content: "\fdca"; -} - -.ph-speaker-high-fill::before { - content: "\fdcb"; -} - -.ph-speaker-low-fill::before { - content: "\fdcc"; -} - -.ph-speaker-none-fill::before { - content: "\fdcd"; -} - -.ph-speaker-simple-high-fill::before { - content: "\fdce"; -} - -.ph-speaker-simple-low-fill::before { - content: "\fdcf"; -} - -.ph-speaker-simple-none-fill::before { - content: "\fdd0"; -} - -.ph-speaker-simple-slash-fill::before { - content: "\fdd1"; -} - -.ph-speaker-simple-x-fill::before { - content: "\fdd2"; -} - -.ph-speaker-slash-fill::before { - content: "\fdd3"; -} - -.ph-speaker-x-fill::before { - content: "\fdd4"; -} - -.ph-spinner-fill::before { - content: "\fdd5"; -} - -.ph-spinner-gap-fill::before { - content: "\fdd6"; -} - -.ph-spiral-fill::before { - content: "\fdd7"; -} - -.ph-spotify-logo-fill::before { - content: "\fdd8"; -} - -.ph-square-fill::before { - content: "\fdd9"; -} - -.ph-square-half-bottom-fill::before { - content: "\fdda"; -} - -.ph-square-half-fill::before { - content: "\fddb"; -} - -.ph-square-logo-fill::before { - content: "\fddc"; -} - -.ph-squares-four-fill::before { - content: "\fddd"; -} - -.ph-stack-fill::before { - content: "\fdde"; -} - -.ph-stack-overflow-logo-fill::before { - content: "\fddf"; -} - -.ph-stack-simple-fill::before { - content: "\fde0"; -} - -.ph-stamp-fill::before { - content: "\fde1"; -} - -.ph-star-fill::before { - content: "\fde2"; -} - -.ph-star-four-fill::before { - content: "\fde3"; -} - -.ph-star-half-fill::before { - content: "\fde4"; -} - -.ph-sticker-fill::before { - content: "\fde5"; -} - -.ph-stop-circle-fill::before { - content: "\fde6"; -} - -.ph-stop-fill::before { - content: "\fde7"; -} - -.ph-storefront-fill::before { - content: "\fde8"; -} - -.ph-strategy-fill::before { - content: "\fde9"; -} - -.ph-stripe-logo-fill::before { - content: "\fdea"; -} - -.ph-student-fill::before { - content: "\fdeb"; -} - -.ph-suitcase-fill::before { - content: "\fdec"; -} - -.ph-suitcase-simple-fill::before { - content: "\fded"; -} - -.ph-sun-dim-fill::before { - content: "\fdee"; -} - -.ph-sun-fill::before { - content: "\fdef"; -} - -.ph-sun-horizon-fill::before { - content: "\fdf0"; -} - -.ph-sunglasses-fill::before { - content: "\fdf1"; -} - -.ph-swap-fill::before { - content: "\fdf2"; -} - -.ph-swatches-fill::before { - content: "\fdf3"; -} - -.ph-sword-fill::before { - content: "\fdf4"; -} - -.ph-syringe-fill::before { - content: "\fdf5"; -} - -.ph-t-shirt-fill::before { - content: "\fdf6"; -} - -.ph-table-fill::before { - content: "\fdf7"; -} - -.ph-tabs-fill::before { - content: "\fdf8"; -} - -.ph-tag-chevron-fill::before { - content: "\fdf9"; -} - -.ph-tag-fill::before { - content: "\fdfa"; -} - -.ph-tag-simple-fill::before { - content: "\fdfb"; -} - -.ph-target-fill::before { - content: "\fdfc"; -} - -.ph-taxi-fill::before { - content: "\fdfd"; -} - -.ph-telegram-logo-fill::before { - content: "\fdfe"; -} - -.ph-television-fill::before { - content: "\fdff"; -} - -.ph-television-simple-fill::before { - content: "\fe00"; -} - -.ph-tennis-ball-fill::before { - content: "\fe01"; -} - -.ph-terminal-fill::before { - content: "\fe02"; -} - -.ph-terminal-window-fill::before { - content: "\fe03"; -} - -.ph-test-tube-fill::before { - content: "\fe04"; -} - -.ph-text-aa-fill::before { - content: "\fe05"; -} - -.ph-text-align-center-fill::before { - content: "\fe06"; -} - -.ph-text-align-justify-fill::before { - content: "\fe07"; -} - -.ph-text-align-left-fill::before { - content: "\fe08"; -} - -.ph-text-align-right-fill::before { - content: "\fe09"; -} - -.ph-text-bolder-fill::before { - content: "\fe0a"; -} - -.ph-text-h-fill::before { - content: "\fe0b"; -} - -.ph-text-h-five-fill::before { - content: "\fe0c"; -} - -.ph-text-h-four-fill::before { - content: "\fe0d"; -} - -.ph-text-h-one-fill::before { - content: "\fe0e"; -} - -.ph-text-h-six-fill::before { - content: "\fe0f"; -} - -.ph-text-h-three-fill::before { - content: "\fe10"; -} - -.ph-text-h-two-fill::before { - content: "\fe11"; -} - -.ph-text-indent-fill::before { - content: "\fe12"; -} - -.ph-text-italic-fill::before { - content: "\fe13"; -} - -.ph-text-outdent-fill::before { - content: "\fe14"; -} - -.ph-text-strikethrough-fill::before { - content: "\fe15"; -} - -.ph-text-t-fill::before { - content: "\fe16"; -} - -.ph-text-underline-fill::before { - content: "\fe17"; -} - -.ph-textbox-fill::before { - content: "\fe18"; -} - -.ph-thermometer-cold-fill::before { - content: "\fe19"; -} - -.ph-thermometer-fill::before { - content: "\fe1a"; -} - -.ph-thermometer-hot-fill::before { - content: "\fe1b"; -} - -.ph-thermometer-simple-fill::before { - content: "\fe1c"; -} - -.ph-thumbs-down-fill::before { - content: "\fe1d"; -} - -.ph-thumbs-up-fill::before { - content: "\fe1e"; -} - -.ph-ticket-fill::before { - content: "\fe1f"; -} - -.ph-tiktok-logo-fill::before { - content: "\fe20"; -} - -.ph-timer-fill::before { - content: "\fe21"; -} - -.ph-toggle-left-fill::before { - content: "\fe22"; -} - -.ph-toggle-right-fill::before { - content: "\fe23"; -} - -.ph-toilet-fill::before { - content: "\fe24"; -} - -.ph-toilet-paper-fill::before { - content: "\fe25"; -} - -.ph-tote-fill::before { - content: "\fe26"; -} - -.ph-tote-simple-fill::before { - content: "\fe27"; -} - -.ph-trademark-registered-fill::before { - content: "\fe28"; -} - -.ph-traffic-cone-fill::before { - content: "\fe29"; -} - -.ph-traffic-sign-fill::before { - content: "\fe2a"; -} - -.ph-traffic-signal-fill::before { - content: "\fe2b"; -} - -.ph-train-fill::before { - content: "\fe2c"; -} - -.ph-train-regional-fill::before { - content: "\fe2d"; -} - -.ph-train-simple-fill::before { - content: "\fe2e"; -} - -.ph-translate-fill::before { - content: "\fe2f"; -} - -.ph-trash-fill::before { - content: "\fe30"; -} - -.ph-trash-simple-fill::before { - content: "\fe31"; -} - -.ph-tray-fill::before { - content: "\fe32"; -} - -.ph-tree-evergreen-fill::before { - content: "\fe33"; -} - -.ph-tree-fill::before { - content: "\fe34"; -} - -.ph-tree-structure-fill::before { - content: "\fe35"; -} - -.ph-trend-down-fill::before { - content: "\fe36"; -} - -.ph-trend-up-fill::before { - content: "\fe37"; -} - -.ph-triangle-fill::before { - content: "\fe38"; -} - -.ph-trophy-fill::before { - content: "\fe39"; -} - -.ph-truck-fill::before { - content: "\fe3a"; -} - -.ph-twitch-logo-fill::before { - content: "\fe3b"; -} - -.ph-twitter-logo-fill::before { - content: "\fe3c"; -} - -.ph-umbrella-fill::before { - content: "\fe3d"; -} - -.ph-umbrella-simple-fill::before { - content: "\fe3e"; -} - -.ph-upload-fill::before { - content: "\fe3f"; -} - -.ph-upload-simple-fill::before { - content: "\fe40"; -} - -.ph-user-circle-fill::before { - content: "\fe41"; -} - -.ph-user-circle-gear-fill::before { - content: "\fe42"; -} - -.ph-user-circle-minus-fill::before { - content: "\fe43"; -} - -.ph-user-circle-plus-fill::before { - content: "\fe44"; -} - -.ph-user-fill::before { - content: "\fe45"; -} - -.ph-user-focus-fill::before { - content: "\fe46"; -} - -.ph-user-gear-fill::before { - content: "\fe47"; -} - -.ph-user-list-fill::before { - content: "\fe48"; -} - -.ph-user-minus-fill::before { - content: "\fe49"; -} - -.ph-user-plus-fill::before { - content: "\fe4a"; -} - -.ph-user-rectangle-fill::before { - content: "\fe4b"; -} - -.ph-user-square-fill::before { - content: "\fe4c"; -} - -.ph-user-switch-fill::before { - content: "\fe4d"; -} - -.ph-users-fill::before { - content: "\fe4e"; -} - -.ph-users-four-fill::before { - content: "\fe4f"; -} - -.ph-users-three-fill::before { - content: "\fe50"; -} - -.ph-vault-fill::before { - content: "\fe51"; -} - -.ph-vibrate-fill::before { - content: "\fe52"; -} - -.ph-video-camera-fill::before { - content: "\fe53"; -} - -.ph-video-camera-slash-fill::before { - content: "\fe54"; -} - -.ph-vignette-fill::before { - content: "\fe55"; -} - -.ph-voicemail-fill::before { - content: "\fe56"; -} - -.ph-volleyball-fill::before { - content: "\fe57"; -} - -.ph-wall-fill::before { - content: "\fe58"; -} - -.ph-wallet-fill::before { - content: "\fe59"; -} - -.ph-warning-circle-fill::before { - content: "\fe5a"; -} - -.ph-warning-fill::before { - content: "\fe5b"; -} - -.ph-warning-octagon-fill::before { - content: "\fe5c"; -} - -.ph-watch-fill::before { - content: "\fe5d"; -} - -.ph-wave-sawtooth-fill::before { - content: "\fe5e"; -} - -.ph-wave-sine-fill::before { - content: "\fe5f"; -} - -.ph-wave-square-fill::before { - content: "\fe60"; -} - -.ph-wave-triangle-fill::before { - content: "\fe61"; -} - -.ph-waves-fill::before { - content: "\fe62"; -} - -.ph-webcam-fill::before { - content: "\fe63"; -} - -.ph-whatsapp-logo-fill::before { - content: "\fe64"; -} - -.ph-wheelchair-fill::before { - content: "\fe65"; -} - -.ph-wifi-high-fill::before { - content: "\fe66"; -} - -.ph-wifi-low-fill::before { - content: "\fe67"; -} - -.ph-wifi-medium-fill::before { - content: "\fe68"; -} - -.ph-wifi-none-fill::before { - content: "\fe69"; -} - -.ph-wifi-slash-fill::before { - content: "\fe6a"; -} - -.ph-wifi-x-fill::before { - content: "\fe6b"; -} - -.ph-wind-fill::before { - content: "\fe6c"; -} - -.ph-windows-logo-fill::before { - content: "\fe6d"; -} - -.ph-wine-fill::before { - content: "\fe6e"; -} - -.ph-wrench-fill::before { - content: "\fe6f"; -} - -.ph-x-circle-fill::before { - content: "\fe70"; -} - -.ph-x-fill::before { - content: "\fe71"; -} - -.ph-x-square-fill::before { - content: "\fe72"; -} - -.ph-yin-yang-fill::before { - content: "\fe73"; -} - -.ph-youtube-logo-fill::before { - content: "\fe74"; -} diff --git a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot b/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot deleted file mode 100644 index 2af0b72..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.eot +++ /dev/null Binary files differ diff --git a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg b/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg deleted file mode 100644 index 8a51454..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.svg +++ /dev/null @@ -1,15725 +0,0 @@ - - - -{ - "author": "Phosphor Icons", - "description": "A friendly icon family for everyone", - "version": "1.4", - "copyright": "Phosphor Icons", - "license": "MIT", - "url": "https://phosphoricons.com" -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf b/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf deleted file mode 100644 index 2145d9b..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.ttf +++ /dev/null Binary files differ diff --git a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff b/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff deleted file mode 100644 index 2f11770..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff +++ /dev/null Binary files differ diff --git a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 b/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 deleted file mode 100644 index 596a6fd..0000000 --- a/webclient/public/assets/fonts/phosphor-icons/src/fonts/Phosphor.woff2 +++ /dev/null Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1125x2436-landscape.png b/webclient/public/images/apple-splash/splash-1125x2436-landscape.png new file mode 100644 index 0000000..636b8ac --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1125x2436-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1125x2436-portrait.png b/webclient/public/images/apple-splash/splash-1125x2436-portrait.png new file mode 100644 index 0000000..838fff9 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1125x2436-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1170x2532-landscape.png b/webclient/public/images/apple-splash/splash-1170x2532-landscape.png new file mode 100644 index 0000000..fb9b115 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1170x2532-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1170x2532-portrait.png b/webclient/public/images/apple-splash/splash-1170x2532-portrait.png new file mode 100644 index 0000000..39effbe --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1170x2532-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1179x2556-landscape.png b/webclient/public/images/apple-splash/splash-1179x2556-landscape.png new file mode 100644 index 0000000..b5254ab --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1179x2556-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1179x2556-portrait.png b/webclient/public/images/apple-splash/splash-1179x2556-portrait.png new file mode 100644 index 0000000..18a8f36 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1179x2556-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1242x2208-landscape.png b/webclient/public/images/apple-splash/splash-1242x2208-landscape.png new file mode 100644 index 0000000..845a78a --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1242x2208-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1242x2208-portrait.png b/webclient/public/images/apple-splash/splash-1242x2208-portrait.png new file mode 100644 index 0000000..30d8181 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1242x2208-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1242x2688-landscape.png b/webclient/public/images/apple-splash/splash-1242x2688-landscape.png new file mode 100644 index 0000000..324d997 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1242x2688-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1242x2688-portrait.png b/webclient/public/images/apple-splash/splash-1242x2688-portrait.png new file mode 100644 index 0000000..8ee9019 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1242x2688-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1284x2778-landscape.png b/webclient/public/images/apple-splash/splash-1284x2778-landscape.png new file mode 100644 index 0000000..3cc9bfe --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1284x2778-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1284x2778-portrait.png b/webclient/public/images/apple-splash/splash-1284x2778-portrait.png new file mode 100644 index 0000000..6199f6d --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1284x2778-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1290x2796-landscape.png b/webclient/public/images/apple-splash/splash-1290x2796-landscape.png new file mode 100644 index 0000000..60d29e3 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1290x2796-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1290x2796-portrait.png b/webclient/public/images/apple-splash/splash-1290x2796-portrait.png new file mode 100644 index 0000000..3ffbb9d --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1290x2796-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1320x2868-landscape.png b/webclient/public/images/apple-splash/splash-1320x2868-landscape.png new file mode 100644 index 0000000..7e8a57b --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1320x2868-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1320x2868-portrait.png b/webclient/public/images/apple-splash/splash-1320x2868-portrait.png new file mode 100644 index 0000000..a32474c --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1320x2868-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1488x2266-landscape.png b/webclient/public/images/apple-splash/splash-1488x2266-landscape.png new file mode 100644 index 0000000..5078f9d --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1488x2266-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1488x2266-portrait.png b/webclient/public/images/apple-splash/splash-1488x2266-portrait.png new file mode 100644 index 0000000..65cac2e --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1488x2266-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1500x2668-landscape.png b/webclient/public/images/apple-splash/splash-1500x2668-landscape.png new file mode 100644 index 0000000..e6a39ec --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1500x2668-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1500x2668-portrait.png b/webclient/public/images/apple-splash/splash-1500x2668-portrait.png new file mode 100644 index 0000000..d0a9b79 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1500x2668-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1536x2048-landscape.png b/webclient/public/images/apple-splash/splash-1536x2048-landscape.png new file mode 100644 index 0000000..a5b4caa --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1536x2048-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1536x2048-portrait.png b/webclient/public/images/apple-splash/splash-1536x2048-portrait.png new file mode 100644 index 0000000..f6cc0dc --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1536x2048-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1620x2160-landscape.png b/webclient/public/images/apple-splash/splash-1620x2160-landscape.png new file mode 100644 index 0000000..c1dae41 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1620x2160-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1620x2160-portrait.png b/webclient/public/images/apple-splash/splash-1620x2160-portrait.png new file mode 100644 index 0000000..1aba92a --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1620x2160-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1640x2160-landscape.png b/webclient/public/images/apple-splash/splash-1640x2160-landscape.png new file mode 100644 index 0000000..95105ef --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1640x2160-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1640x2160-portrait.png b/webclient/public/images/apple-splash/splash-1640x2160-portrait.png new file mode 100644 index 0000000..2b180c8 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1640x2160-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1668x2224-landscape.png b/webclient/public/images/apple-splash/splash-1668x2224-landscape.png new file mode 100644 index 0000000..c246335 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1668x2224-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1668x2224-portrait.png b/webclient/public/images/apple-splash/splash-1668x2224-portrait.png new file mode 100644 index 0000000..531c02b --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1668x2224-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1668x2388-landscape.png b/webclient/public/images/apple-splash/splash-1668x2388-landscape.png new file mode 100644 index 0000000..0eea906 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1668x2388-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-1668x2388-portrait.png b/webclient/public/images/apple-splash/splash-1668x2388-portrait.png new file mode 100644 index 0000000..a8c6a80 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-1668x2388-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2048x2732-landscape.png b/webclient/public/images/apple-splash/splash-2048x2732-landscape.png new file mode 100644 index 0000000..a2825b0 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2048x2732-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2048x2732-portrait.png b/webclient/public/images/apple-splash/splash-2048x2732-portrait.png new file mode 100644 index 0000000..d1da8a7 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2048x2732-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2064x2752-landscape.png b/webclient/public/images/apple-splash/splash-2064x2752-landscape.png new file mode 100644 index 0000000..3c4d26b --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2064x2752-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2064x2752-portrait.png b/webclient/public/images/apple-splash/splash-2064x2752-portrait.png new file mode 100644 index 0000000..63ca3e8 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2064x2752-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2560x3600-landscape.png b/webclient/public/images/apple-splash/splash-2560x3600-landscape.png new file mode 100644 index 0000000..e185dcf --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2560x3600-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-2560x3600-portrait.png b/webclient/public/images/apple-splash/splash-2560x3600-portrait.png new file mode 100644 index 0000000..d5e47dd --- /dev/null +++ b/webclient/public/images/apple-splash/splash-2560x3600-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-320x480-landscape.png b/webclient/public/images/apple-splash/splash-320x480-landscape.png new file mode 100644 index 0000000..568f2fb --- /dev/null +++ b/webclient/public/images/apple-splash/splash-320x480-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-320x480-portrait.png b/webclient/public/images/apple-splash/splash-320x480-portrait.png new file mode 100644 index 0000000..caaaf43 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-320x480-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-640x1136-landscape.png b/webclient/public/images/apple-splash/splash-640x1136-landscape.png new file mode 100644 index 0000000..697f31c --- /dev/null +++ b/webclient/public/images/apple-splash/splash-640x1136-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-640x1136-portrait.png b/webclient/public/images/apple-splash/splash-640x1136-portrait.png new file mode 100644 index 0000000..53e052b --- /dev/null +++ b/webclient/public/images/apple-splash/splash-640x1136-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-750x1334-landscape.png b/webclient/public/images/apple-splash/splash-750x1334-landscape.png new file mode 100644 index 0000000..01b3e2a --- /dev/null +++ b/webclient/public/images/apple-splash/splash-750x1334-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-750x1334-portrait.png b/webclient/public/images/apple-splash/splash-750x1334-portrait.png new file mode 100644 index 0000000..ba05101 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-750x1334-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-750x1624-landscape.png b/webclient/public/images/apple-splash/splash-750x1624-landscape.png new file mode 100644 index 0000000..0d5f179 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-750x1624-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-750x1624-portrait.png b/webclient/public/images/apple-splash/splash-750x1624-portrait.png new file mode 100644 index 0000000..30ae302 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-750x1624-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-828x1620-landscape.png b/webclient/public/images/apple-splash/splash-828x1620-landscape.png new file mode 100644 index 0000000..d83ef5f --- /dev/null +++ b/webclient/public/images/apple-splash/splash-828x1620-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-828x1620-portrait.png b/webclient/public/images/apple-splash/splash-828x1620-portrait.png new file mode 100644 index 0000000..3a757bc --- /dev/null +++ b/webclient/public/images/apple-splash/splash-828x1620-portrait.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-828x1792-landscape.png b/webclient/public/images/apple-splash/splash-828x1792-landscape.png new file mode 100644 index 0000000..e5b13a5 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-828x1792-landscape.png Binary files differ diff --git a/webclient/public/images/apple-splash/splash-828x1792-portrait.png b/webclient/public/images/apple-splash/splash-828x1792-portrait.png new file mode 100644 index 0000000..85081f0 --- /dev/null +++ b/webclient/public/images/apple-splash/splash-828x1792-portrait.png Binary files differ diff --git a/webclient/public/images/icon-180.png b/webclient/public/images/icon-180.png new file mode 100644 index 0000000..4d77545 --- /dev/null +++ b/webclient/public/images/icon-180.png Binary files differ diff --git a/webclient/public/images/icon-maskable-192.png b/webclient/public/images/icon-maskable-192.png index 6b512db..4677643 100644 --- a/webclient/public/images/icon-maskable-192.png +++ b/webclient/public/images/icon-maskable-192.png Binary files differ diff --git a/webclient/public/images/icon-maskable-512.png b/webclient/public/images/icon-maskable-512.png index 5706349..84866b1 100644 --- a/webclient/public/images/icon-maskable-512.png +++ b/webclient/public/images/icon-maskable-512.png Binary files differ diff --git a/webclient/public/manifest.webmanifest b/webclient/public/manifest.webmanifest index 7b28205..b2bbd44 100644 --- a/webclient/public/manifest.webmanifest +++ b/webclient/public/manifest.webmanifest @@ -5,6 +5,7 @@ "start_url": "/", "scope": "/", "display": "standalone", + "display_override": ["standalone"], "theme_color": "#16161E", "background_color": "#16161E", "description": "Navi — personal AI assistant", diff --git a/webclient/src/App.vue b/webclient/src/App.vue index 164f304..6320732 100644 --- a/webclient/src/App.vue +++ b/webclient/src/App.vue @@ -109,8 +109,13 @@ const documentTitle = computed(() => { if (route.value === 'settings') return 'Navi — Settings' if (!chatStore.currentId) return 'Navi' - const session = sessionsStore.sessions.find(s => s.session_id === chatStore.currentId) - return session?.name || chatStore.currentId.slice(0, 8) + const id = chatStore.currentId + // nameById persists beyond the loaded list page (the list holds only ~30) + return ( + sessionsStore.nameById[id] || + sessionsStore.sessions.find(s => s.session_id === id)?.name || + id.slice(0, 8) + ) }) watch(documentTitle, (title) => { @@ -203,7 +208,7 @@ background: rgba(0, 0, 0, 0.6); z-index: 99; - @media (max-width: 1280px) { + @media (max-width: 1279.98px) { display: block; } } diff --git a/webclient/src/api/index.js b/webclient/src/api/index.js index 5182090..2ec6d22 100644 --- a/webclient/src/api/index.js +++ b/webclient/src/api/index.js @@ -53,13 +53,15 @@ } // ─── Sessions ────────────────────────────────────────────────────────────── -export function getSessions({ limit = 30, offset = 0, profileId = null, search = null } = {}) { +export function getSessions({ limit = 30, offset = 0, profileId = null, search = null, special = null } = {}) { const params = new URLSearchParams({ limit: String(limit), offset: String(offset), }) if (profileId) params.set('profile_id', profileId) if (search) params.set('search', search) + // null — no filtering (server regular-only default); true — service sessions only + if (special != null) params.set('special', String(special)) return request('GET', `/sessions?${params.toString()}`) } @@ -67,6 +69,16 @@ return request('GET', `/sessions/${id}`) } +export function getSessionMeta(id) { + return request('GET', `/sessions/${id}/meta`) +} + +export function getSessionHistory(id, beforeSeq = null, limit = 200) { + const params = new URLSearchParams({ limit: String(limit) }) + if (beforeSeq != null) params.set('before_seq', String(beforeSeq)) + return request('GET', `/sessions/${id}/messages/history?${params.toString()}`) +} + export function createSession(profileId) { return request('POST', '/sessions', { profile_id: profileId }) } @@ -79,6 +91,11 @@ return request('PATCH', `/sessions/${id}/pin`, { pinned }) } +// Empty name → the server regenerates the title from session content +export function renameSession(id, name) { + return request('PATCH', `/sessions/${id}/name`, { name }) +} + export function stopSession(id) { return request('POST', `/sessions/${id}/stop`) } @@ -91,6 +108,11 @@ return request('GET', `/sessions/${id}/content`) } +// ─── Background tasks ────────────────────────────────────────────────────── +export function getSessionTasks(sessionId) { + return request('GET', `/sessions/${sessionId}/tasks`) +} + export function getArchivedMessages(id, beforeSeq, limit = 50) { const params = new URLSearchParams({ limit: String(limit) }) if (beforeSeq != null) params.set('before_seq', String(beforeSeq)) @@ -156,6 +178,52 @@ return request('DELETE', `/api-tokens/${id}`) } +// ─── Synapse delivery targets ────────────────────────────────────────────── +// Per-user secrets of Synapse s2s targets that deliver events to this navi. +// The secret is sent here once (shown once in the UI, never returned by the API). +export function getSynapseTargets() { + return request('GET', '/synapse-targets') +} + +export function createSynapseTarget(tokenRef, secret) { + return request('POST', '/synapse-targets', { token_ref: tokenRef, secret }) +} + +export function revokeSynapseTarget(id) { + return request('DELETE', `/synapse-targets/${id}`) +} + +// ─── Synapse reactions ───────────────────────────────────────────────────── +// Per-user settings of the agent-reaction layer: whether Synapse events get +// a background agent run, where notifications go, and the reaction +// instructions (user- and Navi-editable, full edit history). +export function getSynapseReactions() { + return request('GET', '/synapse-settings') +} + +export function updateSynapseReactions(payload) { + return request('PUT', '/synapse-settings', payload) +} + +export function getSynapseReactionVersions(limit = 20) { + return request('GET', `/synapse-settings/versions?limit=${limit}`) +} + +// ─── MCP user keys (BYOK) ────────────────────────────────────────────────── +// Per-user credentials for MCP servers that declare a user_key slot. +// The key is sent when saving; it is never returned by the API. +export function getMcpKeys() { + return request('GET', '/mcp-keys') +} + +export function saveMcpKey(serverName, key) { + return request('PUT', `/mcp-keys/${serverName}`, { key }) +} + +export function resetMcpKey(serverName) { + return request('DELETE', `/mcp-keys/${serverName}`) +} + // ─── Web push (PWA) ─────────────────────────────────────────────────────── export function getVapidKey() { diff --git a/webclient/src/components/artifacts/ArtifactsPanel.vue b/webclient/src/components/artifacts/ArtifactsPanel.vue index 26f343b..9bda6c8 100644 --- a/webclient/src/components/artifacts/ArtifactsPanel.vue +++ b/webclient/src/components/artifacts/ArtifactsPanel.vue @@ -14,10 +14,11 @@ />
    -
    + +